diff --git a/src/Exp_Scribe.cpp b/src/Exp_Scribe.cpp
--- a/src/Exp_Scribe.cpp
+++ b/src/Exp_Scribe.cpp
@@ -1,906 +1,906 @@
 
 #include "Scribe.h"
 
 #include "lgi/common/List.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/Store3.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 
 #include "ScribeFolderSelect.h"
 #include "resdefs.h"
 #include "FolderTask.h"
 
 #define OnError(...) \
 { \
 	Errors.Add(in->Type(), Errors.Find(in->Type()) + 1); \
 	LgiTrace(__VA_ARGS__); \
 	break; \
 }
 #define OnSkip() \
 { \
 	Skipped.Add(in->Type(), Skipped.Find(in->Type()) + 1); \
 	break; \
 }
 #define OnCreate() \
 { \
 	Created.Add(in->Type(), Created.Find(in->Type()) + 1); \
 }
 
 struct ExportParams
 {
 	bool AllFolders = false;
 	bool ExceptTrashSpam = false;
 	LString DestFolders; // Mail3 path for dest folders;
 	LString DestPath; // Sub folder path for export
 	LString::Array SrcPaths;
 };
 
 struct Mail3Folders
 {
 	ScribeWnd *App = NULL;
 	LAutoPtr<LDataStoreI> Store;
 	LAutoPtr<ScribeFolder> Root;
 
 	Mail3Folders(ScribeWnd *app) : App(app)
 	{
 	}
 
 	Mail3Folders(Mail3Folders &src)
 	{
 		App = src.App;
 
 		if (src)
 		{
 			Store = src.Store;
 			Root = src.Root;
 		}
 		else LAssert(!"Src not loaded.");
 	}
 
 	operator bool()
 	{
 		return Store != NULL && Root != NULL;
 	}
 
 	void LoadFolders(const char *FilePath)
 	{
 		if (!Store)
 			Store.Reset(App->CreateDataStore(FilePath, true));
 
 		if (Store && !Root)
 		{
 			if (Root.Reset(new ScribeFolder))
 			{
 				Root->App = App;
 				Root->SetObject(Store->GetRoot(), false, _FL);
 			}
 		}
 	}
 
 	void Unload()
 	{
 		Root.Reset();
 		Store.Reset();
 	}
 
 	bool CheckDirty(ScribeFolder *f)
 	{
 		if (f->GetDirty())
 			return true;
 		for (auto c = f->GetChildFolder(); c; c = c->GetNextFolder())
 			if (CheckDirty(c))
 				return true;
 		return false;
 	}
 
 	bool IsDirty()
 	{
 		if (!Root)
 			return false;
 		return CheckDirty(Root);
 	}
 };
 
 struct ScribeExportTask : public FolderTask
 {
 	int FolderLoadErrors = 0;
 
 	LHashTbl<IntKey<int>,int> Created, Errors, Skipped;
 
 	LMailStore *SrcStore = NULL; // Source data store
 	Mail3Folders Dst;
 	ScribeFolder *Spam = NULL;
 	ScribeFolder *Trash = NULL;
 	ExportParams Params;
 
 	// Working state, used to iterate over the exporting process while
 	// being able to yield to the OS at regular intervals.
 	enum ExportState
 	{
 		ExpNone,
 		ExpGetNext,
 		ExpLoadFolders,
 		ExpItems,
 		ExpFinished,
 		ExpCleanup
 	}	State = ExpNone;
 
 	LString::Array InputPaths;
 	ScribeFolder *SrcFolder = NULL;
 	LArray<LDataI*> SrcItems;
 	ScribeFolder *DstFolder = NULL;
 	LDataFolderI *DstObj = NULL;
 	LDataStoreI *DstStore = NULL;
 	LHashTbl<ConstStrKey<char>,LDataI*> DstObjMap;
 
 	ScribeExportTask(struct ScribeExportDlg *dlg);
 
 	LString ContactKey(Contact *c);	
 	bool TimeSlice();
 	bool CopyAttachments(LDataI *outMail, LDataPropI *outSeg, LDataPropI *inSeg, LString &err);
 
 	LString MakePath(LString path)
 	{
 		LString sep = "/";
 		auto p = Params.DestPath.SplitDelimit(sep);
 		p += path.Strip(sep).SplitDelimit(sep).Slice(1);
 		return sep + sep.Join(p);
 	}
 
 	void CollectPaths(ScribeFolder *f, LString::Array &paths)
 	{
 		paths.Add(f->GetPath());
 		for (auto c = f->GetChildFolder(); c; c = c->GetNextFolder())
 			CollectPaths(c, paths);
 	}
 
 	ScribeFolder *GetFolder(LString Path, Store3ItemTypes CreateItemType = MAGIC_NONE)
 	{
 		if (!Dst.Root)
 		{
 			LAssert(!"No root loaded.");
 			return NULL;
 		}
 
 		Dst.Root->LoadFolders();
 
 		bool Create = false;
 		auto parts = Path.SplitDelimit("/");
 		ScribeFolder *f = Dst.Root;
 		for (auto p: parts)
 		{
 			auto c = f->GetSubFolder(p);
 			if (!c)
 			{
 				if (CreateItemType != MAGIC_NONE)
 				{
-					c = f->CreateSubDirectory(p, CreateItemType);
+					c = f->CreateSubFolder(p, CreateItemType);
 					if (!c)
 					{
 						Errors.Add(MAGIC_FOLDER, Errors.Find(MAGIC_FOLDER)+1);
 						return NULL;
 					}
 
 					Create = true;
 				}
 				else return NULL;
 			}
 
 			f = c;
 		}
 
 		if (Create)
 			Created.Add(MAGIC_FOLDER, Created.Find(MAGIC_FOLDER)+1);
 		else
 			Skipped.Add(MAGIC_FOLDER, Skipped.Find(MAGIC_FOLDER)+1);
 
 		return f;
 	}
 
 	void OnComplete()
 	{
 		Store3ItemTypes types[] = { MAGIC_FOLDER, MAGIC_MAIL, MAGIC_CONTACT, MAGIC_CALENDAR, MAGIC_GROUP, MAGIC_FILTER };
 		LStringPipe html;
 
 		html.Print("<style> td{background:ThreeDFace; padding:3px;}</style>\n"
 					"<body style='background:ThreeDFace;'><div>Mail export complete.</div>\n"
 					"<br>\n"
 					"<table style='border-spacing: 1px; background:#aaa;'>\n"
 					"<tr><th>Type <th>Created <th>Errors <th>Skipped </tr>\n");
 		for (int i=0; i<CountOf(types); i++)
 		{
 			auto type    = types[i];
 			auto name    = LString(Store3ItemTypeName(type)).Replace("MAGIC_");
 			StrLwr(name.Get() + 1);
 			auto created = Created.Find(type);
 			auto errors  = Errors.Find(type);
 			auto skipped = Skipped.Find(type);
 			auto errStyle = errors ? " style='color:red'" : "";
 
 			html.Print("<tr><td>%s <td>%i <td%s>%i <td>%i </tr>\n",
 				name.Get(), created, errStyle, errors, skipped);
 		}
 
 		html.Print("</table>\n"
 					"<br>\n"
 					"<b>Created:</b> new item created in destination store.<br>\n"
 					"<b>Error:</b> there was an error replicating item.<br>\n"
 					"<b>Skipped:</b> the item already existed in the destination store.<br>\n"
 					);
 
 		LHtmlMsg(NULL, App, html.NewLStr(), "Export", MB_OK);
 	}
 
 	LString GetOrCreateMessageId(LDataI &obj)
 	{
 		auto msgId = obj.GetStr(FIELD_MESSAGE_ID);
 		if (msgId)
 			return msgId;
 
 		// Check the headers:
 		auto hdrs = obj.GetStr(FIELD_INTERNET_HEADER);
 		if (hdrs)
 		{
 			LAutoString Header(InetGetHeaderField(hdrs, "Message-ID"));
 			if (Header)
 			{
 				auto ids = ParseIdList(Header);
 				auto id = ids[0];
 				obj.SetStr(FIELD_MESSAGE_ID, id);
 				obj.Save();
 				return id;
 			}
 		}
 
 		// Msg has no ID and no header... create one.
 		auto from = obj.GetObj(FIELD_FROM);
 		if (!from)
 		{
 			LgiTrace("%s:%i - No from for email: %p\n", _FL, &obj);
 			return LString();
 		}
 
 		auto fromEmail = from->GetStr(FIELD_EMAIL);
 		LVariant Email;
 		const char *At = fromEmail ? strchr(fromEmail, '@') : NULL;
 		if (!At)
 		{
 			if (App->GetOptions()->GetValue(OPT_Email, Email) && Email.Str())
 				At = strchr(Email.Str(), '@');
 			else
 				At = "@domain.com";
 		}
 		if (!At)
 		{
 			LgiTrace("%s:%i - No at in email: %p\n", _FL, &obj);
 			return LString();
 		}
 
 		char m[96], a[32], b[32];
 		Base36(a, LCurrentTime());
 		Base36(b, LRand(RAND_MAX));
 		sprintf_s(m, sizeof(m), "<%s.%i%s%s>", a, LRand(RAND_MAX), b, At);
 		obj.SetStr(FIELD_MESSAGE_ID, m);
 		obj.Save();
 		return m;
 	}
 
 	LString ObjToId(LDataI &obj)
 	{
 		switch (obj.Type())
 		{
 			case MAGIC_MAIL:
 			{
 				return obj.GetStr(FIELD_MESSAGE_ID);
 			}
 			case MAGIC_CONTACT:
 			{
 				auto fn = obj.GetStr(FIELD_FIRST_NAME);
 				auto ln = obj.GetStr(FIELD_LAST_NAME);
 				auto em = obj.GetStr(FIELD_EMAIL);
 				LString s;
 				s.Printf("%s,%s,%s", fn, ln, em);
 				return s;
 			}
 			case MAGIC_CALENDAR:
 			{
 				auto sub = obj.GetStr(FIELD_CAL_SUBJECT);
 				auto start = obj.GetDate(FIELD_CAL_START_UTC);
 				LString s;
 				s.Printf("%s," LPrintfInt64, sub, start?start->Ts():0);
 				return s;
 				break;
 			}
 			case MAGIC_GROUP:
 			{
 				return obj.GetStr(FIELD_GROUP_NAME);
 			}
 			case MAGIC_FILTER:
 			{
 				return obj.GetStr(FIELD_FILTER_NAME);
 			}
 			default:
 			{
 				LAssert(!"Impl me.");
 				break;
 			}
 		}
 
 		return LString();
 	}
 
 	bool CheckModified(LDataI *in, LDataI *out)
 	{
 		if (!out)
 			// No existing object
 			return true;
 
 		auto inMod = in->GetDate(FIELD_DATE_MODIFIED);
 		auto outMod = in->GetDate(FIELD_DATE_MODIFIED);
 		if (!inMod ||
 			!outMod ||
 			!inMod->IsValid() ||
 			!outMod->IsValid())
 			return true; // Can't tell... no dates stored.
 	
 		bool mod = *inMod > *outMod;
 
 		return mod;
 	}
 
 	void MakeDstObjMap()
 	{
 		DstObjMap.Empty();
 
 		if (!DstFolder || !DstObj)
 			return;
 
 		auto &c = DstObj->Children();
 		for (auto t = c.First(); t; t = c.Next())
 		{
 			auto Id = ObjToId(*t);
 			if (Id)
 				DstObjMap.Add(Id, t);
 		}
 	}
 };
 
 struct ScribeExportDlg : public LDialog, public LDataEventsI
 {
 	ScribeWnd *App = NULL;
 	LMailStore *SrcStore = NULL;
 	LList *Lst = NULL;
 	ExportParams Params;
 	Mail3Folders Dst;
 
 	ScribeExportDlg(ScribeWnd *app, LMailStore *srcStore) :
 		SrcStore(srcStore),
 		Dst(app)
 	{
 		SetParent(App = app);
 
 		if (!SrcStore)
 			SrcStore = App->GetDefaultMailStore();
 
 		if (LoadFromResource(IDD_SCRIBE_EXPORT))
 		{
 			MoveToCenter();
 			// EnableCtrls(false);
 			GetViewById(IDC_SRC_FOLDERS, Lst);
 
 			LVariant s;
 			if (Lst && App->GetOptions()->GetValue(OPT_ScribeExpSrcPaths, s) && s.Str())
 			{
 				Params.SrcPaths = LString(s.Str()).SplitDelimit(":");
 				for (auto p: Params.SrcPaths)
 					Lst->Insert(new LListItem(p));
 
 				Lst->ResizeColumnsToContent();
 			}
 
 			if (App->GetOptions()->GetValue(OPT_ScribeExpDstPath, s) &&
 				ValidStr(s.Str()))
 				SetCtrlName(IDC_FOLDER, s.Str());
 			else
 				SetCtrlName(IDC_FOLDER, "/");
 
 			LVariant n;
 			if (App->GetOptions()->GetValue(OPT_ScribeExpAll, n))
 				SetCtrlValue(IDC_ALL, n.CastInt32());
 
 			if (App->GetOptions()->GetValue(OPT_ScribeExpExclude, n))
 				SetCtrlValue(IDC_NO_SPAM_TRASH, n.CastInt32());
 			else
 				SetCtrlValue(IDC_NO_SPAM_TRASH, true);
 
 			if (App->GetOptions()->GetValue(OPT_ScribeExpFolders, s) && s.Str())
 				SetCtrlName(IDC_DEST, s.Str());
 
 			OnAll();
 		}
 	}
 
 	void OnNew(LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new)
 	{
 	}
 
 	bool OnDelete(LDataFolderI *parent, LArray<LDataI*> &items)
 	{
 		return true;
 	}
 	
 	bool OnMove(LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items)
 	{
 		return true;
 	}
 
 	bool OnChange(LArray<LDataI*> &items, int FieldHint)
 	{
 		return true;
 	}
 
 	void OnAll()
 	{
 		SetCtrlEnabled(IDC_SRC_FOLDERS, !GetCtrlValue(IDC_ALL));
 		SetCtrlEnabled(IDC_ADD_SRC_FOLDER, !GetCtrlValue(IDC_ALL));
 		SetCtrlEnabled(IDC_DEL_SRC_FOLDER, !GetCtrlValue(IDC_ALL));
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_ALL:
 			{
 				OnAll();
 				break;
 			}
 			case IDC_SET_DEST:
 			{
 				auto s = new LFileSelect(this);
 				s->Type("Scribe Folders", "*.mail3");
 				s->Type("All Files", LGI_ALL_FILES);
 				s->Open([this](auto dlg, auto status)
 				{
 					if (status)
 						SetCtrlName(IDC_DEST, dlg->Name());
 					delete dlg;
 				});
 				break;
 			}
 			case IDC_ADD_SRC_FOLDER:
 			{
 				if (!Lst)
 					break;
 
 				auto s = new FolderDlg(this, App);
 				s->DoModal([this, s](auto dlg, auto status)
 				{
 					if (status && ValidStr(s->Get()))
 					{
 						bool Has = false;
 
 						for (auto n: *Lst)
 						{
 							if (Stricmp(n->GetText(), s->Get()) == 0)
 							{
 								Has = true;
 								break;
 							}
 						}
 
 						if (!Has)
 						{
 							Lst->Insert(new LListItem(s->Get()));
 							Lst->ResizeColumnsToContent();
 						}
 					}
 
 					delete dlg;
 				});
 				break;
 			}
 			case IDC_DEL_SRC_FOLDER:
 			{
 				if (Lst)
 				{
 					List<LListItem> i;
 					if (Lst->GetSelection(i))
 					{
 						i.DeleteObjects();
 					}
 				}
 				break;
 			}
 			case IDC_SET_FOLDER:
 			{
 				if (!Dst)
 					Dst.LoadFolders(GetCtrlName(IDC_DEST));
 
 				if (Dst.Root)
 				{
 					auto s = new FolderDlg(this, App, MAGIC_NONE, Dst.Root);
 					s->DoModal([this, s](auto dlg, auto ctrlId)
 					{
 						if (ctrlId)
 							SetCtrlName(IDC_FOLDER, s->Get());
 						delete dlg;
 					});
 				}
 				else LgiMsg(this, "Couldn't load mail3 store.", AppName);
 				break;
 			}
 			case IDOK:
 			{
 				Params.AllFolders = GetCtrlValue(IDC_ALL) != 0;
 				Params.ExceptTrashSpam = GetCtrlValue(IDC_NO_SPAM_TRASH) != 0;
 				Params.DestPath = GetCtrlName(IDC_FOLDER);
 				Params.DestFolders = GetCtrlName(IDC_DEST);
 
 				if (Lst)
 				{
 					Params.SrcPaths.Empty();
 					Params.SrcPaths.SetFixedLength(false);
 					for (auto i: *Lst)
 						Params.SrcPaths.Add(i->GetText());
 				}
 
 				if (!Dst)
 					Dst.LoadFolders(Params.DestFolders);
 
 				// fall through
 			}
 			case IDCANCEL:
 			{
 				LVariant v;
 				if (Lst)
 				{
 					LStringPipe p;
 					int n=0;
 					for (auto i : *Lst)
 					{
 						p.Print("%s%s", n ? (char*)":" : (char*) "", i->GetText(0));
 					}
 					char *s = p.NewStr();
 					if (s)
 					{
 						App->GetOptions()->SetValue(OPT_ScribeExpSrcPaths, v = s);
 						DeleteArray(s);
 					}
 				}
 
 				App->GetOptions()->SetValue(OPT_ScribeExpDstPath, v = GetCtrlName(IDC_FOLDER));
 				App->GetOptions()->SetValue(OPT_ScribeExpAll,     v = (int)GetCtrlValue(IDC_ALL));
 				App->GetOptions()->SetValue(OPT_ScribeExpExclude, v = (int)GetCtrlValue(IDC_NO_SPAM_TRASH));
 				App->GetOptions()->SetValue(OPT_ScribeExpFolders, v = GetCtrlName(IDC_DEST));
 
 				EndModal(c->GetId() == IDOK);
 			}
 		}
 
 		return 0;
 	}
 };
 
 ScribeExportTask::ScribeExportTask(ScribeExportDlg *dlg) :
 	FolderTask(dlg->Dst.Root, LAutoPtr<LStreamI>(NULL), NULL, NULL),
 	Dst(dlg->Dst),
 	SrcStore(dlg->SrcStore)
 {
 	SetDescription("Initializing...");
 	SetType("Folders");
 
 	LAssert(SrcStore);
 
 	Params = dlg->Params;
 	if (Params.ExceptTrashSpam)
 	{
 		Spam = App->GetFolder("/Spam");
 		Trash = App->GetFolder(FOLDER_TRASH);
 	}
 
 	// Work out the folders we need to operate on:
 	if (Params.AllFolders)
 		CollectPaths(SrcStore->Root, InputPaths);
 	else
 		InputPaths = Params.SrcPaths;
 	SetRange(InputPaths.Length());
 
 	// Kick off the processing...
 	State = ExpGetNext;
 	SetPulse(PULSE_MS);
 	SetAlwaysOnTop(true);
 }
 
 LString ScribeExportTask::ContactKey(Contact *c)
 {
 	LString p;
 	const char *f = 0, *l = 0;
 	auto e = c->GetAddrAt(0);
 	c->Get(OPT_First, f);
 	c->Get(OPT_Last, l);
 	p.Printf("%s,%s,%s", e.Get(), f, l);
 	return p;
 }
 
 #define ExportFolderStatus(b) \
 	{ if (onStatus) onStatus(b); \
 	return; }
 
 bool ScribeExportTask::TimeSlice()
 {
 	if (IsCancelled())
 		return false;
 
 	switch (State)
 	{
 		case ExpGetNext:
 		{
 			if (InputPaths.Length() == 0)
 			{
 				State = ExpFinished;
 				break;
 			}
 
 			// Load up the next SrcFolder...
 			auto src = InputPaths[0];
 			InputPaths.DeleteAt(0, true);
 
 			auto dst = MakePath(src);
 			SrcFolder = App->GetFolder(src, SrcStore);
 			if (!SrcFolder)
 			{
 				FolderLoadErrors++;
 				return true;
 			}
 
 			DstStore = NULL;
 			DstFolder = GetFolder(dst, SrcFolder->GetItemType());
 			if (!DstFolder)
 			{
 				return true;
 			}
 
 			State = ExpLoadFolders;
 			SrcFolder->LoadThings(this, [this](auto status)
 			{
 				if (status == Store3Success)
 				{
 					// Load a list of things to process...
 					SrcItems.Empty();
 					auto SrcObj = dynamic_cast<LDataFolderI*>(SrcFolder->GetObject());
 					if (SrcObj)
 					{
 						auto &c = SrcObj->Children();
 						for (auto t = c.First(); t; t = c.Next())
 							SrcItems.Add(t);
 					}
 
 					DstFolder->LoadThings(this, [this](auto status)
 					{
 						if (status == Store3Success)
 						{
 							State = ExpItems;
 							SetDescription(SrcFolder->GetPath());
 
 							if (DstFolder->GetObject())
 								DstObj = dynamic_cast<LDataFolderI*>(DstFolder->GetObject());
 							else
 								LAssert(!"No object?");
 
 							if (DstObj)
 								DstStore = DstObj->GetStore();
 							else
 								LAssert(!"No object?");
 
 							MakeDstObjMap();
 						}
 						else
 							State = ExpGetNext;
 					});
 				}
 				else
 				{
 					State = ExpGetNext;
 				}					
 			});
 			break;
 		}
 		case ExpLoadFolders:
 		{
 			// No-op, but we should probably time out...
 			break;
 		}
 		case ExpItems:
 		{
 			if (!SrcFolder || !DstFolder || !DstStore)
 			{
 				State = ExpGetNext;
 				break;
 			}
 
 			auto Trans = DstStore->StartTransaction();
 
 			auto StartTs = LCurrentTime();
 			int Processed = 0;
 			while (	SrcItems.Length() > 0 &&
 					LCurrentTime() - StartTs < WORK_SLICE_MS)
 			{
 				auto in = SrcItems[0];
 				SrcItems.DeleteAt(0);
 
 				switch (in->Type())
 				{
 					case MAGIC_MAIL:
 					{
 						auto Id = GetOrCreateMessageId(*in);
 						if (!Id)
 							OnError("%s:%i - Email %p has no MsgId\n", _FL, in)
 
 						if (DstObjMap.Find(Id))
 							OnSkip()
 
 						// Create new mail...
 						auto outMail = DstStore->Create(MAGIC_MAIL);
 						outMail->CopyProps(*in);
 
 						// Now create all the attachments
 						auto inSeg = dynamic_cast<LDataI*>(in->GetObj(FIELD_MIME_SEG));
 						LDataI *outSeg = NULL;
 						if (inSeg)
 						{
 							outSeg = DstStore->Create(MAGIC_ATTACHMENT);
 							if (!outSeg)
 								OnError("%s:%i - Failed to create attachment\n", _FL)
 							else
 							{
 								outSeg->CopyProps(*inSeg);
 
 								auto outMime = outSeg->GetStr(FIELD_MIME_TYPE);
 								if (!outMime)
 								{
 									auto hdrs = outSeg->GetStr(FIELD_INTERNET_HEADER);
 									if (!hdrs)
 									{
 										// This is going to cause an assert later
 										outSeg->SetStr(FIELD_MIME_TYPE, sAppOctetStream);
 										// LgiTrace("%s:%i - Setting default mime on %p\n", _FL, outSeg);
 									}
 								}
 
 								if (outMail->SetObj(FIELD_MIME_SEG, outSeg) < Store3Delayed)
 									OnError("%s:%i - Failed to attach seg to mail.\n", _FL)
 								else
 								{
 									LString err;
 									if (!CopyAttachments(outMail, outSeg, inSeg, err))
 										OnError("%s:%i - CopyAttachments failed\n", _FL)
 									else
 										OnCreate()
 								}
 							}
 						}
 						else
 							OnCreate()
 
 						outMail->Save(DstFolder->GetObject());
 						break;
 					}
 					default:
 					{
 						// Is the object already in the dst map?
 						auto Id = ObjToId(*in);
 						auto existing = DstObjMap.Find(Id);
 						if (!CheckModified(in, existing))
 							OnSkip();
 
 						auto outObj = DstStore->Create(in->Type());
 						if (!outObj)
 						{
 							OnError("%s:%i - %s failed to create %s\n", _FL,
 								DstStore->GetStr(FIELD_STORE_TYPE),
 								Store3ItemTypeName((Store3ItemTypes)in->Type()))
 						}
 
 						if (!outObj->CopyProps(*in))
 							OnError("%s:%i - CopyProps failed.\n", _FL)
 
 						if (outObj->Save(DstFolder->GetObject()) < Store3Delayed)
 							OnError("%s:%i - Save failed\n", _FL)
 
 						OnCreate();
 						break;
 					}
 				}
 
 				Processed++;
 			}
 
 			if (SrcItems.Length() == 0)
 			{
 				SrcFolder = NULL;
 				DstFolder = NULL;
 				DstStore = NULL;
 				State = ExpGetNext;
 				(*this)++; // move progress...
 			}
 
 			// LgiTrace("Processed: %i\n", Processed);
 			break;
 		}
 		case ExpFinished:
 		{
 			OnComplete();
 			State = ExpCleanup;
 			return true;
 		}
 		case ExpCleanup:
 		{
 			if (Dst.IsDirty())
 				return true;
 
 			// We're done...
 			return false;
 		}
 		default:
 		{
 			LAssert(!"Not impl.");
 			return false;
 		}
 	}
 
 	return true;
 }
 
 // This should copy all the child objects of 'inSeg' to new child objects of 'outSeg'
 bool ScribeExportTask::CopyAttachments(LDataI *outMail, LDataPropI *outSeg, LDataPropI *inSeg, LString &err)
 {
 	#define ERR(str) \
 		{ err = str; return false; }
 	if (!outMail || !outSeg || !inSeg)
 		ERR("param error");
 
 	auto children = inSeg->GetList(FIELD_MIME_SEG);
 	if (!children)
 		return true; // Nothing to copy...
 
 	for (auto i = children->First(); i; i = children->Next())
 	{
 		auto inMime = i->GetStr(FIELD_MIME_TYPE);
 		if (!inMime)
 			continue;
 
 		auto o = outMail->GetStore()->Create(MAGIC_ATTACHMENT);
 		if (!o)
 			ERR("couldn't create attachment");
 
 		if (!o->CopyProps(*i))
 			ERR("copy attachment properties failed");
 
 		auto outData = dynamic_cast<LDataI*>(outSeg);
 		if (!outData)
 			ERR("outSeg isn't a LDataI object");
 
 		if (!o->Save(outData))
 			ERR("failed to save attachment to output mail");
 
 		if (!CopyAttachments(outMail, o, i, err))
 			return false; // but leave the error message untouched.
 	}
 
 	return true;
 }
 
 void ExportScribe(ScribeWnd *App, LMailStore *Store)
 {
 	auto Dlg = new ScribeExportDlg(App, Store);
 	Dlg->DoModal([Dlg, App](auto dlg, auto ctrlId)
 	{
 		if (ctrlId && Dlg->Dst)
 		{
 			new ScribeExportTask(Dlg);
 		}
 		delete dlg;
 	});
 }
diff --git a/src/FolderTask.h b/src/FolderTask.h
--- a/src/FolderTask.h
+++ b/src/FolderTask.h
@@ -1,156 +1,492 @@
 #pragma once
 
 #include "resdefs.h"
 
 class FolderTask : public LProgressDlg
 {
 protected:
 	ScribeWnd *App = NULL;
 	ScribeFolder *Folder = NULL;
+	bool Loading = true;
 	
 	LString MimeType;
 	
 	LAutoPtr<LStreamI> Stream;
 
 	ThingType::IoProgress Status;
 	ThingType::IoProgressCallback onComplete;
 
 public:
 	// Minimum amount of time to do work.
 	constexpr static int WORK_SLICE_MS		= 130;
 	// This should be larger then WORK_SLICE_MS to allow message loop to process
 	constexpr static int PULSE_MS			= 200;
 
 	FolderTask(	ScribeFolder *folder,
 				LAutoPtr<LStreamI> stream,
 				LString mimeType,
 				ThingType::IoProgressCallback cb) :
 		LProgressDlg(folder->App),
 		Folder(folder),
 		Stream(stream),
 		MimeType(mimeType),
 		onComplete(cb),
 		Status(Store3Success)
 	{
 		App = Folder->App;
+		Status.prog = this;
 		Ts = LCurrentTime();
 		SetParent(Folder->GetTree());		
-		SetPulse(PULSE_MS);
 		SetAlwaysOnTop(true);
 
 		App->OnFolderTask(this, true);
+
+		Folder->WhenLoaded(_FL, [this]()
+		{
+			Loading = false;
+			SetPulse(PULSE_MS);
+		});
+
+		if (!Folder->IsLoaded())
+			Folder->LoadThings();
 	}
 	
 	virtual ~FolderTask()
 	{
 		App->OnFolderTask(this, false);
 		
 		if (onComplete)
 			onComplete(&Status, Stream);
+
+		Status.prog = NULL;
 	}
 
 	bool OnRequestClose(bool OsClose)
 	{
 		return true;
 	}
 
 	void OnPulse()
 	{
 		LProgressDlg::OnPulse();
 
+		if (Loading)
+			return;
+
 		// We aren't checking IsCancelled() here to allow the
 		// TimeSlice implementation a chance to clean up anything relevant
 		// before returning false to this caller.
 		auto StartTs = LCurrentTime();
 		while ((LCurrentTime() - StartTs) < WORK_SLICE_MS)
 		{
 			if (!TimeSlice())
 			{
 				Quit();
 				break;
 			}
 		}
 	}
 	
 	/// This should use around WORK_SLICE_MS of time and then
 	/// \returns true if more work to do or false if finished.
 	/// Do check for IsCancelled() while doing work and return
 	/// false.
 	virtual bool TimeSlice() = 0;
 };
 
+class MboxParser : public LStringPipe
+{
+	LStreamI *Src = NULL;
+	int Hdrs = 0;
+	bool NewMsg = true;
+	LArray<char> Buf;
+	int64 Pos = 0;
+	bool Eof = false;
+	
+	bool IsMessageHdr(LString c)
+	{
+		// check that it's a from line
+		auto parts = c.SplitDelimit(" \r");
+		if (parts.Length() >= 7 &&
+			parts.Length() <= 9 &&
+			parts[0].Equals("From"))
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	struct Blk
+	{
+		uint8_t *ptr;
+		ssize_t size;
+	};
+
+	struct Blocks : public LArray<Blk>
+	{
+		ssize_t Bytes = 0;
+
+		Blocks(LMemQueue *q)
+		{
+			q->Iterate([this](auto ptr, auto size)
+			{
+				auto &b = New();
+				
+				b.ptr = ptr;
+				b.size = size;
+				Bytes += size;
+
+				return true;
+			});
+		}
+
+		LString GetLine(size_t idx, size_t offset)
+		{
+			char buf[256];
+			int ch = 0;
+
+			for (size_t i = idx; i < Length(); i++)
+			{
+				auto &b = (*this)[i];
+				auto p = b.ptr + offset;
+				auto end = b.ptr + b.size;
+				while (p < end)
+				{
+					if (*p == '\n' || ch == sizeof(buf)-1)
+						return LString(buf, ch);
+
+					buf[ch++] = *p++;
+				}
+			}
+
+			return LString();
+		}
+
+		bool ValidateSeparator(LString ln)
+		{
+			auto p = ln.SplitDelimit();
+
+			if (p.Length() < 7)
+				return false;
+
+			if (!p[0].Equals("From"))
+				return false;
+
+			if (p[1].Find("@") < 0)
+				return false;
+
+			bool hasYear = false;
+			bool hasTime = false;
+			for (int i=2; i<p.Length(); i++)
+			{
+				auto &s = p[i];
+				if (s.Length() == 4)
+				{
+					auto val = s.Int();
+					if (val >= 1800 && val < 2200)
+						hasYear = true;
+				}
+				else if (s.Find(":") > 0)
+				{
+					int colons = 0, nonDigits = 0;
+					for (auto p = s.Get(); *p; p++)
+						if (*p == ':')
+							colons++;
+						else if (!IsDigit(*p))
+							nonDigits++;
+					if (colons == 2 && nonDigits == 0)
+						hasTime = true;
+				}
+			}
+
+			return hasYear && hasTime;
+		}
+
+		ssize_t FindBoundary(ssize_t start)
+		{
+			const char *key = "\nFrom ";
+			const char *k = key + 1;
+			size_t idx = 0;
+			ssize_t offset = 0;
+
+			if (Bytes == 0)
+				return -1;
+
+			if (start < 0 || start >= Bytes)
+			{
+				LAssert(!"Start out of range.");
+				return -1;
+			}
+
+			// Seek to the right starting block...
+			while (idx < Length())
+			{
+				auto &b = (*this)[idx];
+				if (start < b.size)
+					break;
+				start -= b.size;
+				offset += b.size;
+				idx++;
+			}
+			
+			// Start searching for the key...
+			while (idx < Length())
+			{
+				auto &b = (*this)[idx];
+				
+				auto end = b.ptr + b.size;
+				for (auto p = b.ptr + start; p < end; p++)
+				{
+					if (*k == *p)
+					{
+						if (*++k == 0)
+						{
+							// Found the "From " part, but lets check the rest of the line.
+							// Should be in the format:
+							//		From sender date more-info
+							auto blkAddr = (p - b.ptr) - 4;
+							LString ln = GetLine(idx, blkAddr);
+							if (ln && ValidateSeparator(ln))
+								return offset + blkAddr;
+						}
+					}
+					else k = key;
+				}
+
+				offset += b.size;
+				idx++;
+			}
+
+			return -1;
+		}
+
+		LRange FindMsg(MboxParser &parser)
+		{
+			auto start = FindBoundary(0);
+			if (start > 0)
+				LgiTrace("%s:%i - Usually the start should be 0, but it's " LPrintfSSizeT "?\n",
+					_FL, start);
+
+			if (start >= 0)
+			{
+				auto end = FindBoundary(start + 5);
+				if (end > start)
+				{
+					return LRange(start, end - start);
+				}
+				else if (parser.Eof)
+				{
+					return LRange(start, Bytes);
+				}
+			}
+
+			return LRange(-1, 0);
+		}
+	};
+
+public:
+	MboxParser(LStreamI *s) : LStringPipe(128 << 10)
+	{
+		Src = s;
+		// _debug = true;
+		Buf.Length(128 << 10);
+	}
+
+	bool ReadSource()
+	{
+		auto rd = Src->Read(Buf.AddressOf(), Buf.Length());
+		if (rd <= 0)
+		{
+			// Src stream is empty or in an error state..
+			Eof = true;
+			return false;
+		}
+
+		auto wr = Write(Buf.AddressOf(), Buf.Length());
+		if (wr <= 0)
+		{
+			LgiTrace("%s:%i - Failed to write to local buffer.\n", _FL);
+			return false;
+		}
+
+		return true;
+	}
+
+	LAutoPtr<LStreamI> ReadMessage()
+	{
+		LAutoPtr<LStreamI> m;
+
+		while (true)
+		{
+			Blocks blks(this);
+			auto r = blks.FindMsg(*this);
+			if (r.Start >= 0)
+			{
+				LMemStream *ms = NULL;
+
+				/*
+				LgiTrace("ReadMsg " LPrintfInt64 " %s\n", Pos, r.GetStr());
+				auto InitPos = Pos;
+				*/
+
+				Pos += r.Len;
+				m.Reset(ms = new LMemStream(this, r.Start, r.Len));
+
+				/* Debugging...
+				auto key = "The package name is vmware_addons.";
+				auto base = ms->GetBasePtr();
+				auto result = Strnistr(base, key, m->GetSize());
+				if (result)
+					LgiTrace("Found the Key @ " LPrintfInt64 "\n", InitPos + (result - base));
+				*/
+				break;
+			}
+			else if (!ReadSource())
+			{
+				r = blks.FindMsg(*this);
+				if (r.Start >= 0)
+					m.Reset(new LMemStream(this, r.Start, r.Len));
+				break;
+			}
+		}
+
+		return m;
+	}
+};
+
+class ImportFolderTask : public FolderTask
+{
+	LDataStoreI::StoreTrans trans;
+	LAutoPtr<MboxParser> Parser;
+	
+public:
+	ImportFolderTask(ScribeFolder *fld, LAutoPtr<LStreamI> in, LString mimeType, ThingType::IoProgressCallback cb) :
+		FolderTask(fld, in, mimeType, cb)
+	{
+		SetDescription(LLoadString(IDS_MBOX_READING));
+		SetType("K");
+		SetScale(1.0/1024.0);
+		SetRange(Stream->GetSize());
+
+		trans = fld->GetObject()->GetStore()->StartTransaction();
+	}
+	
+	bool TimeSlice()
+	{
+		auto Start = LCurrentTime();
+		bool Eof = false;
+
+		if (!Parser)
+			Parser.Reset(new MboxParser(Stream));
+		
+		while ( Parser
+				&&
+				LCurrentTime() - Start < WORK_SLICE_MS
+		        &&
+		        !IsCancelled())
+		{
+			auto Msg = Parser->ReadMessage();
+			if (Msg)
+			{
+				Mail *m = dynamic_cast<Mail*>(App->CreateItem(MAGIC_MAIL, Folder, false));
+				if (m)
+				{
+					m->OnAfterReceive(Msg);
+					m->SetFlags(MAIL_RECEIVED|MAIL_READ);
+					m->Save();
+					m->Update();
+				}
+				else
+				{
+					Eof = true;
+					break;
+				}
+			}
+			else
+			{
+				Eof = true;
+				break;
+			}
+
+			Value(Stream->GetPos());
+		}
+		
+		return !Eof && !IsCancelled();
+	}
+};
+
 class ExportFolderTask : public FolderTask
 {
 	int Idx = 0;
 
 public:
 	ExportFolderTask(	ScribeFolder *folder,
 						LAutoPtr<LStreamI> out,
 						LString mimeType,
 						ThingType::IoProgressCallback cb) :
 		FolderTask(folder, out, mimeType, cb)
 	{
 		bool Mbox = _stricmp(MimeType, sMimeMbox) == 0;
 
 		// Clear the files contents
 		Stream->SetSize(0);
 
 		// Setup progress UI
 		SetDescription(Mbox ? LLoadString(IDS_MBOX_WRITING) : (char*)"Writing...");
 		SetRange(Folder->Items.Length());
 		
 		switch (Folder->GetItemType())
 		{
 			case MAGIC_MAIL:
 				SetType(LLoadString(IDS_EMAIL));
 				break;
 			case MAGIC_CALENDAR:
 				SetType(LLoadString(IDS_CALENDAR));
 				break;
 			case MAGIC_CONTACT:
 				SetType(LLoadString(IDS_CONTACT));
 				break;
 			case MAGIC_GROUP:
 				SetType("Groups");
 				break;
 			default:
 				SetType("Objects");
 				break;
 		}
 
-		SetPulse(PULSE_MS);
 		SetAlwaysOnTop(true);
 	}
 	
 	bool TimeSlice()
 	{
 		auto Start = LCurrentTime();
 		while (	LCurrentTime() - Start < WORK_SLICE_MS
 				&&
 		        !IsCancelled())
 		{
 			if (Idx >= (ssize_t)Folder->Items.Length())
 				return false;
 
 			// Process all the container's items
 			Thing *t = Folder->Items[Idx++];
 			if (!t)
 				return false;
 
 			LAutoPtr<LStreamI> wrapper(new LProxyStream(Stream));
 			if (!t->Export(wrapper, MimeType))
 			{
 				Status.status = Store3Error;
 				Status.errMsg = "Error exporting items.";
 				return false;
 			}
 			
 			Value(Idx);
 		}
 		
-		return true;
+		return !IsCancelled();
 	}
 };
 
 
 
diff --git a/src/ImpExp_Mbox.cpp b/src/ImpExp_Mbox.cpp
--- a/src/ImpExp_Mbox.cpp
+++ b/src/ImpExp_Mbox.cpp
@@ -1,349 +1,361 @@
 #include <stdio.h>
 #include <time.h>
 #include <stdlib.h>
 #include <sys/timeb.h>
 
 #include "Scribe.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/TextFile.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 
 #include "FolderTask.h"
 #include "resdefs.h"
 
 ///////////////////////////////////////////////////////////////////////////
 ImportExportDlg::ImportExportDlg
 (
 	ScribeWnd *parent,
 	bool IsExport,
 	const char *Title,
 	const char *Msg,
 	LString::Array *srcFiles,
 	const char *dstFolder,
 	int FolderType
 )
 {
 	Type = FolderType;
 	SetParent(App = parent);
 	Export = IsExport;
 
 	if (LoadFromResource(Export ? IDD_FILES_EXPORT : IDD_FILES_IMPORT))
 	{
 		Name(Title);
 
 		GetViewById(IDC_SRC, Src);
 		GetViewById(IDC_DST, Dst);
 
 		if (Src)
 		{
 			Src->ShowColumnHeader(false);
 			if (srcFiles)
 			{
 				for (auto f: *srcFiles)
 					InsertFile(f);
 			}
 		}
 		else LAssert(0);
 
 		if (Dst)
 		{
 			if (dstFolder)
 				Dst->Name(dstFolder);
 		}
 		else LAssert(0);
 
 		SetCtrlName(IDC_MSG, Msg);
 	}
 
 	MoveToCenter();
 }
 
 void ImportExportDlg::InsertFile(const char *f)
 {
 	if (!Src)
 		return;
 
 	bool Has = false;
 	for (auto n : *Src)
 	{
 		auto path = n->GetText(0);
 		if (Stricmp(path, f) == 0)
 		{
 			Has = true;
 			break;
 		}
 	}
 
 	if (Has)
 		return;
 	
 	LListItem *n = new LListItem(f);
 	if (!n)
 		return;
 	Src->Insert(n);
 }
 
 int ImportExportDlg::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (!Src || !Dst)
 		return 0;
 
 	switch (Ctrl->GetId())
 	{
 		case IDC_ADD:
 		{
 			if (Export)
 			{
 				// Pick scribe folders to export:
 				auto Dlg = new FolderDlg(this, App, Type);
 				Dlg->DoModal([this, Dlg](auto dlg, auto ctrlId)
 					{
 						if (ctrlId)
 						{
 							auto f = Dlg->Get();
 							if (f)
 								InsertFile(f);
 						}
 						delete dlg;
 					});
 			}
 			else
 			{
 				// Pick external MBOX files to import:
 				auto s = new LFileSelect(this);
 
 				s->MultiSelect(true);
 				s->Type("All Files", LGI_ALL_FILES);
 				s->Type("MBOX Files", "*.mbx;*.mbox");
 				s->Type("Outlook Express Folders", "*.mbx;*.dbx");
 				s->Type("Mozilla Address Book", "*.mab");
 				s->Type("Eudora Address Book", "NNdbase.txt");
 				s->Open([this](auto dlg, auto status)
 				{
 					if (status)
 					{
 						for (int i=0; i<dlg->Length(); i++)
 							InsertFile((*dlg)[i]);
 					}
 					delete dlg;
 				});
 			}
 			break;
 		}
 		case IDC_SRC:
 		{
 			if (n.Type == LNotifyDeleteKey)
 			{
 				List<LListItem> Sel;
 				if (Src->GetSelection(Sel))
 					Sel.DeleteObjects();
 			}
 			break;
 		}
 		case IDC_DEL:
 		{
 			List<LListItem> Sel;
 			if (Src->GetSelection(Sel))
 				Sel.DeleteObjects();
 			break;
 		}
 		case IDC_SET_DEST:
 		{
 			if (Export)
 			{
 				// Pick external folder for writing to:
 				auto s = new LFileSelect(this);
 
 				s->MultiSelect(!Export);
 				s->OpenFolder(	[this](auto s, auto status)
 								{
 									if (status)
 										SetCtrlName(IDC_DST, s->Name());
 									delete s;
 								});
 			}
 			else
 			{
 				// Pick scribe folder for writing to:
 				auto Dlg = new FolderDlg(this, App, Type);
 				Dlg->DoModal([this, Dlg](auto dlg, auto ctrlId)
 				{
 					if (ctrlId)
 					{
 						auto f = Dlg->Get();
 						if (f && Dst)
 							Dst->Name(f);
 					}
 					delete dlg;
 				});
 			}
 			break;
 		}
 		case IDOK:
 		{
 			for (auto n : *Src)
 				SrcFiles.Add(n->GetText());
 			DestFolder = Dst->Name();
 			IncSubFolders = GetCtrlValue(IDC_SUB_FOLDERS) > 0;
 
 			EndModal(1);
 			break;
 		}
 		case IDCANCEL:
 		{
 			EndModal(0);
 			break;
 		}
 	}
 	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////
-void Import_UnixMBox(ScribeWnd *Parent)
-{
-	auto Cur = Parent->GetCurrentFolder();
-	LString DstPath;
-	if (Cur)
-		DstPath = Cur->GetPath();
-	
-	auto Dlg = new ImportExportDlg(	Parent,
-									false,
-									LLoadString(IDS_MBOX_IMPORT),
-									LLoadString(IDS_MBOX_SELECT_FOLDER),
-									NULL, // Src
-									DstPath);
-	Dlg->DoModal([Dlg, Parent](auto dlg, auto ok)
-	{
-		if (ok && Dlg->DestFolder)
-		{
-			auto Folder = Parent->GetFolder(Dlg->DestFolder);
-			if (Folder)
-			{
-				for (auto File: Dlg->SrcFiles)
-				{
-					LAutoPtr<LTextFile> F(new LTextFile);
-					if (F->Open(File, O_READ))
-						Folder->Import(Folder->AutoCast(F), sMimeMbox);
-				}
-			}
-		}
-		delete dlg;
-	});
-}
-
 struct MboxExportTask : public LView::ViewEventTarget
 {
 	ScribeWnd *App = NULL;
 	LString DestFolder;
 	LString::Array SrcFiles;
 	bool IncSubFolders = false;
+	bool Export = false;
 
 	// Chain together enough ExportFolderTask instances to
 	// get the SrcFiles written....
-	MboxExportTask(ScribeWnd *Parent) :
-		LView::ViewEventTarget(Parent, M_EXPORT_NEXT)
+	MboxExportTask(ScribeWnd *Parent, bool exportMode) :
+		LView::ViewEventTarget(Parent, M_EXPORT_NEXT),
+		Export(exportMode)
 	{
 		// Kick it off....
 		App = Parent;
 	}
 
 	void Next()
 	{
 		PostEvent(M_EXPORT_NEXT);
 	}
 
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		if (Msg->Msg() == M_EXPORT_NEXT)
 		{
 			if (SrcFiles.Length() == 0)
 				return OnFinished();
 
 			// Pop next folder path
 			auto inPath = SrcFiles[0];
 			SrcFiles.DeleteAt(0, true);
-			auto folder = App->GetFolder(inPath);
-			if (folder)
-			{	
-				LFile::Path outPath = DestFolder;
-				outPath += LGetLeaf( folder->GetDropFileName() );
-				auto p = outPath.GetFull();
-				LAutoPtr<LStreamI> outFile;
-				outFile.Reset(new LFile(p, O_WRITE));
+
+			if (Export)
+			{
+				auto folder = App->GetFolder(inPath);
+				if (folder)
+				{	
+					LFile::Path outPath = DestFolder;
+					outPath += LGetLeaf( folder->GetDropFileName() );
+					auto p = outPath.GetFull();
+					LAutoPtr<LStreamI> outFile;
+					outFile.Reset(new LFile(p, O_WRITE));
 
-				new ExportFolderTask(folder,
-									outFile,
-									sMimeMbox, 
-									[this](auto prog, auto stream)
-									{
-										Next();
-									});
-				return 1;
+					new ExportFolderTask(folder,
+										outFile,
+										sMimeMbox, 
+										[this](auto prog, auto stream)
+										{
+											if (prog->IsCancelled())
+												SrcFiles.Empty();
+											Next();
+										});
+					return 1;
+				}
+			}
+			else
+			{
+				auto parentFolder = App->GetFolder(DestFolder);
+				if (parentFolder)
+				{
+					LString leaf = LGetLeaf(inPath);
+					if (leaf.Find(".") >= 0)
+						leaf = leaf.RSplit(".", 1)[0];
+
+					auto folder = parentFolder->GetSubFolder(leaf);
+					if (!folder)
+						folder = parentFolder->CreateSubFolder(leaf, MAGIC_MAIL);
+
+					if (folder)
+					{
+						LAutoPtr<LFile> inFile(new LFile(inPath, O_READ));
+						if (inFile && *inFile)
+						{
+							new ImportFolderTask(folder,
+												inFile,
+												sMimeMbox,
+												[this](auto prog, auto stream)
+												{
+													if (prog->IsCancelled())
+														SrcFiles.Empty();
+													Next();
+												});
+							return 1;
+						}
+					}
+				}
 			}
 
 			Next();
 		}
 
 		return 0;
 	}
 
 	int OnFinished()
 	{
 		delete this;
 		return 0;
 	}
 };
 
+void Import_UnixMBox(ScribeWnd *Parent)
+{
+	auto Cur = Parent->GetCurrentFolder();
+	LString DstPath;
+	if (Cur)
+		DstPath = Cur->GetPath();
+	
+	auto Dlg = new ImportExportDlg(	Parent,
+									false,
+									LLoadString(IDS_MBOX_IMPORT),
+									LLoadString(IDS_MBOX_SELECT_FOLDER),
+									NULL, // Src
+									DstPath);
+	Dlg->DoModal([Dlg, Parent](auto dlg, auto ok)
+	{
+		if (ok &&
+			Dlg->SrcFiles.Length() > 0 &&
+			Dlg->DestFolder)
+		{
+			auto task = new MboxExportTask(Parent, false);
+			task->DestFolder = Dlg->DestFolder;
+			task->SrcFiles = Dlg->SrcFiles;
+			task->Next();
+		}
+		delete dlg;
+	});
+}
+
 void Export_UnixMBox(ScribeWnd *Parent)
 {
 	ScribeFolder *Cur = Parent->GetCurrentFolder();
 	LString::Array SrcPath;
 	if (Cur)
 		SrcPath.Add(Cur->GetPath());
 	
 	auto Dlg = new ImportExportDlg(	Parent,
 									true,
 									LLoadString(IDS_MBOX_EXPORT),
 									LLoadString(IDS_MBOX_EXPORT_FOLDER),
 									&SrcPath);
 	Dlg->DoModal([Dlg, Parent](auto dlg, auto ok)
 	{
 		if (ok &&
 			Dlg->SrcFiles.Length() > 0 &&
 			Dlg->DestFolder)
 		{
-			auto task = new MboxExportTask(Parent);
+			auto task = new MboxExportTask(Parent, true);
 			task->DestFolder = Dlg->DestFolder;
 			task->SrcFiles = Dlg->SrcFiles;
 			task->IncSubFolders = Dlg->IncSubFolders;
 			task->Next();
 		}
 		delete dlg;
 	});
 }
-
-
-/*
-
-	ScribeFolder *Folder = Parent->GetFolder(Dlg->DestFolder);
-	if (Folder)
-	{
-		for (auto File: Dlg->SrcFiles)
-		{
-			if (!LFileExists(File) ||
-				LgiMsg(	Parent,
-						LLoadString(IDS_ERROR_FILE_EXISTS),
-						AppName,
-						MB_YESNO,
-						File.Get()) == IDYES)
-			{
-				LAutoPtr<LFile> F(new LFile);
-				if (F->Open(File, O_WRITE))
-					Folder->Export(Folder->AutoCast(F), sMimeMbox);
-			}
-		}
-	}
-
-*/
\ No newline at end of file
diff --git a/src/ImpExp_Outlook.cpp b/src/ImpExp_Outlook.cpp
--- a/src/ImpExp_Outlook.cpp
+++ b/src/ImpExp_Outlook.cpp
@@ -1,3943 +1,3943 @@
 #undef UNICODE
 #include "Scribe.h"
 #include "lgi/common/Com.h"
 #include "mapix.h"
 #include "mapiutil.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/RtfHtml.h"
 #include "Calendar.h"
 #include "resdefs.h"
 #include "lgi/common/LgiRes.h"
 
 #if _MSC_VER >= 1400
 typedef ULONG_PTR	UI_TYPE;
 #else
 typedef ULONG		UI_TYPE;
 #endif
 
 typedef HRESULT (STDAPICALLTYPE *pWrapCompressedRTFStream)(LPSTREAM lpCompressedRTFStream,
         ULONG ulFlags, LPSTREAM FAR * lpUncompressedRTFStream);
 
 #define PR_SMTP_ADDRESS				(PROP_TAG(PT_STRING8,	0x39fe))
 #define PR_SENDER_SMTP_ADDRESS		(PROP_TAG(PT_STRING8,	0x0065))
 #define PR_SENDER_SMTP_ADDRESS2		(PROP_TAG(PT_STRING8,	0x0c1f))
 #ifndef PR_INTERNET_MESSAGE_ID
 #define PR_INTERNET_MESSAGE_ID		0x1035001E
 #endif
 #ifndef PR_BODY_HTML
 #define PR_BODY_HTML				0x1013001E
 #endif
 #ifndef PR_ATTACH_CONTENT_ID
 #define PR_ATTACH_CONTENT_ID		0x3712001E
 #endif
 
 char *RClientsEmail = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\Mail";
 
 // Helper classes/functions
 void RemoveChars(char *Str, int Start, int Len)
 {
 	memmove(Str, Str + Len, strlen(Str + Len) + 1);
 }
 
 void InsertChars(char *Ins, char *Str, int At)
 {
 	auto Len = strlen(Ins);
 	memmove(Str + Len, Str, strlen(Str) + 1);
 	memcpy(Str, Ins, Len);
 }
 
 class MapiEntry
 {
 public:
 	uchar *Bin;
 	int Len;
 
 	MapiEntry(SPropValue *v)
 	{
 		Len = 0;
 		Bin = 0;
 		if (v)
 		{
 			Len = v->Value.bin.cb;
 			Bin = new uchar[Len];
 			if (Bin)
 			{
 				memcpy(Bin, v->Value.bin.lpb, Len);
 			}
 		}
 	}
 
 	~MapiEntry()
 	{
 		DeleteArray(Bin);
 	}
 };
 
 SPropValue *MapiGetField(SRow *Row, int Field)
 {
 	SPropValue *v = 0;
 	if (Row)
 	{
 		for (unsigned i=0; i<Row->cValues; i++)
 		{
 			if (PROP_ID(Row->lpProps[i].ulPropTag) == PROP_ID(Field))
 			{
 				return Row->lpProps + i;
 			}
 		}
 	}
 	return v;
 }
 
 SPropValue *MapiGetProp(IMAPIProp *Props, int Field)
 {
 	SPropTagArray InTag;
 	InTag.cValues = 1;
 	InTag.aulPropTag[0] = Field;
 
 	SPropValue *OutTag = 0;
 	ULONG Tags = 0;
 	if (Props)
 	{
 		if (Props->GetProps(&InTag, 0, &Tags, &OutTag) == S_OK)
 		{
 			if (Tags == 1)
 			{
 				return OutTag;
 			}
 		}
 	}
 
 	return 0;
 }
 
 int MapiCastInt(SPropValue *Val)
 {
 	if (Val && PROP_TYPE(Val->ulPropTag) == PT_LONG)
 	{
 		return Val->Value.l;
 	}
 	if (Val && PROP_TYPE(Val->ulPropTag) == PT_SHORT)
 	{
 		return Val->Value.i;
 	}
 
 	return 0;
 }
 
 char *MapiCastString(SPropValue *Val)
 {
 	if (Val && PROP_TYPE(Val->ulPropTag) == PT_STRING8)
 	{
 		return Val->Value.lpszA;
 	}
 
 	return 0;
 }
 
 bool MapiCastBinary(SPropValue *Val, void *&Ptr, int &Size)
 {
 	if (Val && PROP_TYPE(Val->ulPropTag) == PT_BINARY)
 	{
 		Ptr = Val->Value.bin.lpb;
 		Size = Val->Value.bin.cb;
 		return true;
 	}
 
 	return false;
 }
 
 char *MapiGetPropStr(IMAPIProp *Props, int Field)
 {
 	SPropValue *Val = MapiGetProp(Props, Field);
 	if (Val)
 	{
 		return MapiCastString(Val);
 	}
 	return 0;	
 }
 
 int MapiGetPropInt(IMAPIProp *Props, int Field)
 {
 	SPropValue *Val = MapiGetProp(Props, Field);
 	if (Val)
 	{
 		return MapiCastInt(Val);
 	}
 	return 0;	
 }
 
 bool MapiSetPropStr(IMAPIProp *Props, int Field, const char *Str, bool Unicode = false)
 {
 	if (Props && Str)
 	{
 		LAssert(PROP_TYPE(Field) == PT_STRING8);
 
 		SPropValue p;
 		LString n;
 		p.ulPropTag = Field;
 		if (Unicode)
 		{
 			p.Value.lpszA = n = LToNativeCp(Str);
 		}
 		else
 		{
 			p.Value.lpszA = (LPSTR)Str;
 		}
 		bool Status = Props->SetProps(1, &p, 0) == S_OK;
 		return Status;
 	}
 
 	return false;
 }
 
 bool MapiSetPropLong(IMAPIProp *Props, int Field, ULONG lng)
 {
 	if (Props)
 	{
 		SPropValue p;
 		p.ulPropTag = Field;
 		p.Value.l = lng;
 		return Props->SetProps(1, &p, 0) == S_OK;
 	}
 
 	return false;
 }
 
 bool MapiSetPropBool(IMAPIProp *Props, int Field, bool b)
 {
 	if (Props)
 	{
 		SPropValue p;
 		p.ulPropTag = Field;
 		p.Value.b = b;
 		return Props->SetProps(1, &p, 0) == S_OK;
 	}
 
 	return false;
 }
 
 bool MapiSetPropDate(IMAPIProp *Props, int Field, const LDateTime &d, bool AdjustTz = true)
 {
 	if (d.Year())
 	{
 		// Set sent date
 		SPropValue Prop;
 		Prop.ulPropTag = Field;
 
 		LDateTime a = d;
 		if (AdjustTz)
 			a.ToUtc();
 
 		SYSTEMTIME st;
 		st.wDay = a.Day();
 		st.wMonth = a.Month();
 		st.wYear = a.Year();
 		st.wMinute = a.Minutes();
 		st.wHour = a.Hours();
 		st.wSecond = a.Seconds();
 		st.wMilliseconds = 0;
 		if (SystemTimeToFileTime(&st, &Prop.Value.ft))
 		{
 			return Props->SetProps(1, &Prop, 0) == S_OK;
 		}
 	}
 
 	return false;
 }
 
 class LMapiList
 {
 	LPMAPITABLE List;
 	ULONG Rows;
 	SRowSet *BaseRow;
 	uint32_t i, StartIndex;
 	bool ReleaseList;
 
 public:
 	LMapiList(LPMAPITABLE &list, bool release = true)
 	{
 		List = list;
 		list = NULL;
 		Rows = 0;
 		BaseRow = 0;
 		i = 0;
 		StartIndex = 0;
 		ReleaseList = release;
 
 		if (List)
 		{
 			HRESULT r = List->GetRowCount(0, &Rows);
 			if (Rows &&
 				List->SeekRow(BOOKMARK_BEGINNING, 0, NULL) == S_OK)
 			{
 				if (List->QueryRows(Rows, 0, &BaseRow) == S_OK)
 				{
 					// Ok
 				}
 			}
 		}
 	}
 
 	~LMapiList()
 	{
 		if (List && ReleaseList)
 		{
 			List->Release();
 		}
 	}
 
 	int Index() { return i; }
 	int Length() { return Rows; }
 	bool More() { return (BaseRow && i >= StartIndex && i < BaseRow->cRows + StartIndex); }
 	void Next()
 	{
 		i++;
 
 		if (BaseRow->cRows < Rows &&
 			i-StartIndex >= BaseRow->cRows)
 		{
 			// run into the end of the list section
 			int s = StartIndex + BaseRow->cRows;
 			if (List->QueryRows(Rows-StartIndex, 0, &BaseRow) == S_OK)
 			{
 				StartIndex = s;
 			}
 		}
 	}
 
 	SRowSet *Current()
 	{
 		if (More()) // in range
 		{
 			return BaseRow + i - StartIndex;
 		}
 
 		return 0;
 	}
 
 	SPropValue *GetField(int Field)
 	{
 		if (More()) // in range
 		{
 			return MapiGetField(BaseRow->aRow + i - StartIndex, Field);
 		}
 
 		return 0;
 	}
 };
 
 // DEBUG STUFF
 #ifdef _DEBUG
 class LRow : public LListItem
 {
 	SRow *Row;
 	char **Data;
 	int Cols;
 
 public:
 	LRow(SRow *row)
 	{
 		Cols = 0;
 		Row = row;
 		if (Row)
 		{
 			Cols = Row->cValues;
 			Data = new char*[Cols];
 			if (Data)
 			{
 				memset(Data, 0, sizeof(*Data)*Cols);
 			}
 		}
 	}
 
 	const char *GetText(int i)
 	{
 		SPropValue *Value = (Row)?Row->lpProps+i:0;
 		if (Value)
 		{
 			char Str[256] = "";
 
 			DeleteArray(Data[i]);
 			switch (PROP_TYPE(Value->ulPropTag))
 			{
 				case PT_I2:
 				{
 					sprintf_s(Str, sizeof(Str), "%i", Value->Value.i);
 					break;
 				}
 				case PT_I4:
 				{
 					sprintf_s(Str, sizeof(Str), "%i", Value->Value.l);
 					break;
 				}
 				case PT_R8:
 				{
 					sprintf_s(Str, sizeof(Str), "%f", Value->Value.dbl);
 					break;
 				}
 				case PT_BOOLEAN:
 				{
 					sprintf_s(Str, sizeof(Str), "%s", (Value->Value.b)?"true":"false");
 					break;
 				}
 				case PT_STRING8:
 				{
 					sprintf_s(Str, sizeof(Str), "%s", Value->Value.lpszA);
 					break;
 				}
 				case PT_ERROR:
 				{
 					sprintf_s(Str, sizeof(Str), "e(%08.8X)", Value->Value.err);
 					break;
 				}
 				case PT_BINARY:
 				{
 					sprintf_s(Str, sizeof(Str), "Bin(%i)", Value->Value.bin.cb);
 					break;
 				}
 				default:
 				{
 					sprintf_s(Str, sizeof(Str), "#TYPE(%04.4X)", PROP_TYPE(Value->ulPropTag));
 					break;
 				}
 			}
 
 			if (strlen(Str)>0)
 			{
 				Data[i] = NewStr(Str);
 			}
 
 			return (Data[i])?Data[i]:"";
 		}
 		return "";
 	}
 };
 
 class LShowTable : public LDialog
 {
 	SRowSet *Table;
 	LList *List;
 
 public:
 	LShowTable(LView *parent, SRowSet *table)
 	{
 		SetParent(parent);
 		SetPos(LRect(0, 0, 660, 490));
 		MoveToCenter();
 		Name("Show Table");
 		Table = table;
 
 		Children.Insert(new LButton(101, 550, 420, 60, 20, "Close"));
 		Children.Insert(List = new LList(100, 10, 10, 600, 400));
 		if (List && Table)
 		{
 			if (Table->cRows > 0)
 			{
 				SRow *First = Table->aRow;
 				for (unsigned i=0; i<First->cValues; i++)
 				{
 					char Str[256];
 					sprintf_s(Str, sizeof(Str), "%08.8X", First->lpProps[i].ulPropTag);
 					List->AddColumn(Str, 80);
 				}
 
 				for (unsigned i=0; i<Table->cRows; i++)
 				{
 					List->Insert(new LRow(Table->aRow+i));
 				}
 			}
 		}
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (Ctrl->GetId() == 101)
 		{
 			EndModal(0);
 		}
 		return 0;
 	}
 
 };
 
 void ViewTable(LPMAPITABLE Table, LView *Wnd)
 {
 	LMapiList Lst(Table);
 	if (Lst.Current())
 	{
 		auto Tbl = new LShowTable(Wnd, Lst.Current());
 		Tbl->DoModal(NULL);
 	}
 }
 #endif // _DEBUG
 
 class EntryRef
 {
 public:
 	char *DisplayName;
 	int Size;
 	LPENTRYID Entry;
 
 	EntryRef()
 	{
 		DisplayName = 0;
 		Size = 0;
 		Entry = 0;
 	}
 
 	bool OpenRoot(LComPtr<IMAPISession> &Session, UI_TYPE UiHnd, LComPtr<IMsgStore> &MsgStore, LComPtr<IMAPIFolder> &RootFolder)
 	{
 		if (!Session)
 		{
 			LgiTrace("%s:%i - No Session.\n", _FL);
 			return false;
 		}
 
 		if (Session->OpenMsgStore(	UiHnd,
 									Size,	// entry bytes
 									Entry,	// ptr to entry
 									NULL,	// default interface: IMsgStore
 									MAPI_BEST_ACCESS,
 									MsgStore.Set()) != S_OK ||
 			!MsgStore)
 		{
 			LgiTrace("%s:%i - OpenMsgStore failed.\n", _FL);
 			return false;
 		}
 
 		SPropValue *SubTree = MapiGetProp(MsgStore, PR_IPM_SUBTREE_ENTRYID);
 		if (!SubTree)
 		{
 			LgiTrace("%s:%i - Failed to get PR_IPM_SUBTREE_ENTRYID.\n", _FL);
 			return false;
 		}
 
 		ULONG ObjType;
 		if (MsgStore->OpenEntry(SubTree->Value.bin.cb,
 								(LPENTRYID)SubTree->Value.bin.lpb,
 								NULL,
 								MAPI_MODIFY,
 								&ObjType,
 								(IUnknown**) RootFolder.Set()) != S_OK ||
 			!RootFolder)
 		{
 			LgiTrace("%s:%i - OpenEntry failed.\n", _FL);
 			MsgStore.Release();
 			return false;
 		}
 
 		return true;
 	}
 };
 
 class MessageStores : public List<EntryRef>
 {
 	LPMAPITABLE MsgStores;
 
 public:
 	bool Status;
 
 	MessageStores(LPMAPISESSION Session)
 	{
 		Status = false;
 		MsgStores = 0;
 
 		if (Session->GetMsgStoresTable(0, &MsgStores) == S_OK &&
 			MsgStores)
 		{
 			for (LMapiList Lst(MsgStores, false); Lst.More(); Lst.Next())
 			{
 				SPropValue *DisplayName = Lst.GetField(PR_DISPLAY_NAME); 
 				SPropValue *Entry = Lst.GetField(PR_ENTRYID);
 				if (DisplayName && Entry)
 				{
 					LAutoPtr<EntryRef> Ref(new EntryRef);
 					if (Ref)
 					{
 						Ref->DisplayName = MapiCastString(DisplayName);
 
 						void *p = 0;
 						int s = 0;
 						if (Ref->DisplayName && MapiCastBinary(Entry, p, s))
 						{
 							Ref->Size = s;
 							Ref->Entry = (ENTRYID*) p;
 							Insert(Ref.Release());
 						}
 					}
 				}
 			}
 
 			Status = true;
 		}
 	}
 
 	~MessageStores()
 	{
 		if (MsgStores)
 			MsgStores->Release();
 		DeleteObjects();
 	}
 };
 
 class ChooseMessageStoreDlg : public LDialog
 {
 	ScribeWnd *App;
 	LCombo *CStore;
 	LEdit *Folder;
 	bool InitOk;
 	bool Directory;
 	MessageStores *Stores;
 
 public:
 	int Size;
 	LPENTRYID Entry;
 	EntryRef *Ref;
 	LString FolderName;
 
 	ChooseMessageStoreDlg(ScribeWnd *Wnd, LPMAPISESSION Session, bool Dir = true)
 	{
 		App = Wnd;
 		Size = 0;
 		Entry = 0;
 		InitOk = false;
 		Directory = Dir;
 		Ref = 0;
 		Stores = 0;
 		CStore = 0;
 		Folder = 0;
 
 		if (LoadFromResource(IDD_OUTLOOK_IMPORT))
 		{
 			Stores = new MessageStores(Session);
 			if (Stores && Stores->Status)
 			{
 				if (GetViewById(IDC_MSG_STORE, CStore))
 				{
 					InitOk = true;
 					for (auto e: *Stores)
 						CStore->Insert(e->DisplayName);
 				}
 			}
 
 			if (GetViewById(IDC_FOLDER, Folder))
 			{
 				Folder->Name("/");
 				Folder->Enabled(false);
 			}
 		}
 
 		MoveToCenter();
 	}
 
 	~ChooseMessageStoreDlg()
 	{
 		DeleteObj(Stores);
 	}
 
 	bool InitCheck()
 	{
 		return InitOk;
 	}
 
 	void OnCreate()
 	{
 		LViewI *v = FindControl(IDC_TABLE);
 		if (v)
 		{
 			LRect c = GetClient();
 			c.Inset(10, 10);
 			v->SetPos(c);
 		}
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case IDC_SET_FOLDER:
 			{
 				if (!Folder)
 					break;
 
 				auto Dlg = new FolderDlg(this, App);
 				Dlg->DoModal([this, Dlg](auto dlg, auto ctrlId)
 				{
 					if (ctrlId)
 						this->Folder->LView::Name(Dlg->Get());
 					delete dlg;
 				});
 				break;
 			}
 			case IDOK:
 			{
 				if (CStore)
 				{
 					Ref = Stores->ItemAt((int)CStore->Value());
 					if (Ref)
 					{
 						Size = Ref->Size;
 						Entry = Ref->Entry;
 					}
 				}
 
 				if (Directory && Folder)
 					FolderName = Folder->Name();
 
 				EndModal(1);
 				break;
 			}
 			case IDCANCEL:
 			{
 				EndModal(0);
 				break;
 			}
 		}
 		return 0;
 	}
 };
 
 // Import / Export parameters
 class ImportParams
 {
 public:
 	ScribeWnd *App;
 	Progress *Prog;
 	Progress *ItemProg;
 	bool AllFolders;
 	LString::Array Import;
 
 	ImportParams()
 	{
 		AllFolders = false;
 		App = NULL;
 		Prog = NULL;
 		ItemProg = NULL;
 	}
 	
 	~ImportParams()
 	{
 	}
 };
 
 class ExportParams
 {
 public:
 	ScribeWnd *App;
 	Progress *Prog;
 	Progress *ItemProg;
 	bool AllFolders;
 
 	List<ScribeFolder> Include;
 	List<ScribeFolder> Export;
 	List<ScribeFolder> Exclude;
 
 	ExportParams()
 	{
 		AllFolders = false;
 		App = 0;
 		Prog = 0;
 		ItemProg = 0;
 	}
 };
 
 int StrCmp(char *a, char *b, NativeInt d)
 {
 	return _stricmp(a, b);
 }
 
 // Importer class
 class OutlookIO
 {
 	friend class MailMapiSource;
 	friend class ImportDlg;
 	friend class ExportDlg;
 
 	ScribeWnd					*App;
 	ScribeAccount				*Account;
 	LAutoString                 DefClient;
 
 	HINSTANCE					hMapi;
 	LComPtr<IMAPISession>		Session;
 	LComPtr<IMsgStore>			MsgStore;
 	UI_TYPE						Ui;
 	LComPtr<IAddrBook>			AddrBook;
 
 	MAPIINITIALIZE				*MAPIInitialize;
 	MAPILOGONEX					*MAPILogonEx;
 	MAPIUNINITIALIZE			*MAPIUninitialize;
 	MAPIALLOCATEBUFFER			*MAPIAllocateBuffer;
 	MAPIFREEBUFFER				*MAPIFreeBuffer;
 	pWrapCompressedRTFStream	WrapCompressedRTFStream;
 
 	bool ImportEmail(ScribeFolder *Folder, Mail *&To, IMessage *From, bool Post);
 
 public:
 	OutlookIO(ScribeWnd *Wnd, int Flags, ScribeAccount *Account = 0);
 	~OutlookIO();
 
 	bool LoadSession(LViewI *Parent, char *ResetClient);
 	LComPtr<IMAPISession> &GetSession() { return Session; }
 	UI_TYPE GetUiHnd() { return Ui; }
 
 	// Import functions
 	bool Import(	ImportParams *P,
 					IMAPIFolder *In,
 					ScribeFolder *Out,
 					LString::Array &Path);
 	void ImportPersonalAddressBook(std::function<void(bool)> callback);
 
 	// Export functions
 	bool Export(	ExportParams *P,
 					ScribeFolder *In,
 					IMAPIFolder *Out,
 					int Depth = 0);
 	bool ExportCalendar(Calendar *c, IMessage *m);
 	int CountFolders(ScribeFolder *f);
 
 	// Workers
 	bool ImportItem(ScribeFolder *Out, IMAPIFolder *In, SPropValue *EntryId);
 	int FolderType(IMAPIFolder *In);
 };
 
 // UI classes
 class AddFolderDlg : public LDialog
 {
 	OutlookIO *Io;
 	LTree *Tree;
 
 	void Load(IMAPIFolder *f, LTreeItem *i)
 	{
 		if (f && i)
 		{
 			LPMAPITABLE Folders = 0;
 			if (f->GetHierarchyTable(0, &Folders) == S_OK)
 			{
 				for (LMapiList Lst(Folders); Lst.More(); Lst.Next())
 				{
 					SPropValue *v = Lst.GetField(PR_ENTRYID);
 					LString Name = LFromNativeCp(MapiCastString(Lst.GetField(PR_DISPLAY_NAME)));
 					if (v && Name)
 					{
 						LTreeItem *ChildItem = new LTreeItem;
 						if (ChildItem)
 						{
 							ChildItem->SetText(Name);
 							i->Insert(ChildItem);
 							i->Expanded(true);
 
 							IMAPIFolder *ChildFolder = 0;
 							ULONG Type;
 							if (f->OpenEntry(v->Value.bin.cb, (LPENTRYID)v->Value.bin.lpb, NULL, MAPI_BEST_ACCESS, &Type, (IUnknown**)&ChildFolder) == S_OK &&
 								ChildFolder)
 							{
 								Load(ChildFolder, ChildItem);
 								ChildFolder->Release();
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 public:
 	LAutoString Path;
 
 	AddFolderDlg(LView *parent, OutlookIO *io, EntryRef *Store)
 	{
 		Io = io;
 		SetParent(parent);
 		if (LoadFromResource(IDD_OUTLOOK_ADD_FLD))
 		{
 			MoveToCenter();
 			GetViewById(IDC_FOLDERS, Tree);
 
 			auto Session = Io->GetSession();
 			if (Tree && Session && Store)
 			{
 				LTreeItem *RootItem = new LTreeItem;
 				if (RootItem)
 				{
 					RootItem->SetText(Store->DisplayName);
 					Tree->Insert(RootItem);
 					RootItem->Expanded(true);
 
 					LComPtr<IMsgStore> MsgStore;
 					LComPtr<IMAPIFolder> RootFolder;
 
 					if (Store->OpenRoot(Session, Io->GetUiHnd(), MsgStore, RootFolder))
 						Load(RootFolder, RootItem);
 				}
 			}
 		}
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDOK:
 			{
 				LArray<LTreeItem*> p;
 				for (LTreeItem *s = Tree ? Tree->Selection() : 0; s; s = s->GetParent())
 				{
 					p.AddAt(0, s);
 				}
 				LStringPipe n;
 				for (unsigned i=1; i<p.Length(); i++)
 				{
 					n.Print("/%s", p[i]->GetText());
 				}
 				Path.Reset(n.NewStr());
 				LAssert(Path != NULL);
 
 				// Fall thru
 			}
 			case IDCANCEL:
 			{
 				EndModal(c->GetId() == IDOK);
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 class IoDlg : public LDialog
 {
 protected:
 	ScribeWnd *App;
 	List<char> Clients;
 	OutlookIO *Io;
 	char *DefClient;
 	LAutoPtr<MessageStores> Stores;
 	LList *SrcFolders;
 
 	LComPtr<IMAPIFolder> *MapiFolder;
 	ScribeFolder **OurFolder;
 
 public:
 	IoDlg(	ScribeWnd *app,
 			OutlookIO *io,
 			LComPtr<IMAPIFolder> *mapifolder,
 			ScribeFolder *&scribefolder)
 	{
 		App = app;
 		Io = io;
 		DefClient = 0;
 		SrcFolders = 0;
 		MapiFolder = mapifolder;
 		OurFolder = &scribefolder;
 	}
 
 	~IoDlg()
 	{
 		Clients.DeleteArrays();
 		DeleteArray(DefClient);
 	}
 
 	virtual void AddFolder() {}
 	virtual void OnLogin(bool e) {}
 
 	void InitSrcClients()
 	{
 		LRegKey Email(false, RClientsEmail);
 		LCombo *SrcClient;
 		if (Email.GetKeyNames(Clients) && GetViewById(IDC_CLIENT, SrcClient))
 		{
 			Clients.Sort(StrCmp);
 
 			DefClient = NewStr(Email.GetStr());
 			int i = 0;
 			for (auto c: Clients)
 			{
 				SrcClient->Insert(c);
 				if (DefClient && _stricmp(DefClient, c) == 0)
 				{
 					SrcClient->Value(i);
 				}
 				i++;
 			}
 		}
 	}
 
 	void AddPath(char *p)
 	{
 		if (SrcFolders && p)
 		{
 			bool Has = false;
 			for (auto i : *SrcFolders)
 			{
 				const char *s = i->GetText(0);
 				if (s && _stricmp(s, p) == 0)
 				{
 					Has = true;
 					break;
 				}
 			}
 			if (!Has)
 			{
 				LListItem *i = new LListItem;
 				if (i)
 				{
 					i->SetText(p);
 					SrcFolders->Insert(i);
 					SrcFolders->ResizeColumnsToContent();
 				}
 			}
 		}
 	}
 
 	int OnNotify(LViewI *v, LNotification n)
 	{
 		bool Ok = false;
 
 		switch (v->GetId())
 		{
 			case IDC_LOGIN:
 			{
 				const char *NewClient = GetCtrlName(IDC_CLIENT);
 				if (!NewClient)
 				{
 					LgiMsg(this, "Unknown Client Name.", AppName);
 					break;
 				}
 
 				if (!Io->LoadSession(this, DefClient))
 				{
 					LgiMsg(this, "Outlook LoadSession failed.\n", AppName);
 					break;
 				}
 
 				OnLogin(true);
 
 				Stores.Reset(new MessageStores(Io->GetSession()));
 
 				LCombo *StoreCbo;
 				if (!Stores || !GetViewById(IDC_MSG_STORE, StoreCbo))
 				{
 					LgiMsg(this, "No store combo?\n", AppName);
 					break;
 				}
 
 				for (auto e: *Stores)
 					StoreCbo->Insert(e->DisplayName);
 
 				StoreCbo->Value(0);
 				break;
 			}
 			case IDC_ADD_SRC_FOLDER:
 			{
 				AddFolder();
 				break;
 			}
 			case IDC_DEL_SRC_FOLDER:
 			{
 				if (!SrcFolders)
 				{
 					LgiTrace("%s:%i - SrcFolders is NULL.\n", _FL);
 					break;
 				}
 
 				List<LListItem> s;
 				if (!SrcFolders->GetSelection(s))
 				{
 					LgiTrace("%s:%i - GetSelection failed.\n", _FL);
 					break;
 				}
 
 				s.DeleteObjects();
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 class ImportDlg : public IoDlg
 {
 	ImportParams *Params;
 
 public:
 	ImportDlg(	ScribeWnd *app,
 				ImportParams *params,
 				OutlookIO *io,
 				LComPtr<IMAPIFolder> *mapifolder,
 				ScribeFolder *&scribefolder) :
 		IoDlg(app, io, mapifolder, scribefolder)
 	{
 		SetParent(App = app);
 		Params = params;
 
 		if (LoadFromResource(IDD_OUTLOOK_IMPORT))
 		{
 			MoveToCenter();
 			OnLogin(false);
 			GetViewById(IDC_SRC_FOLDERS, SrcFolders);
 
 			LVariant s;
 			if (App->GetOptions()->GetValue(OPT_OutlookImportSrc, s) && s.Str())
 			{
 				auto t = s.LStr().SplitDelimit(",");
 				for (unsigned i=0; i<t.Length(); i++)
 				{
 					AddPath(t[i]);
 				}
 			}
 			if (App->GetOptions()->GetValue(OPT_OutlookImportDst, s) && s.Str())
 				SetCtrlName(IDC_FOLDER, s.Str());
 			else
 			{
 				auto Cur = App->GetCurrentFolder();
 				if (Cur)
 				{
 					auto Path = Cur->GetPath();
 					if (Path)
 						SetCtrlName(IDC_FOLDER, Path);
 				}
 			}
 			if (App->GetOptions()->GetValue(OPT_OutlookImportAll, s))
 			{
 				SetCtrlValue(IDC_ALL, s.CastInt32());
 			}
 
 			InitSrcClients();
 		}
 	}
 
 	void OnLogin(bool e)
 	{
 		SetCtrlEnabled(IDC_CLIENT, !e);
 		SetCtrlEnabled(IDC_LOGIN, !e);
 
 		SetCtrlEnabled(IDC_MSG_STORE, e);
 		SetCtrlEnabled(IDC_ALL, e);
 		SetCtrlEnabled(IDC_SRC_FOLDERS, e);
 		SetCtrlEnabled(IDC_ADD_SRC_FOLDER, e);
 		SetCtrlEnabled(IDC_DEL_SRC_FOLDER, e);
 		SetCtrlEnabled(IDC_SET_FOLDER, e);
 		SetCtrlEnabled(IDOK, e);
 
 		SetCtrlEnabled(IDC_FOLDER, false);
 	}
 
 	void AddFolder()
 	{
 		if (Stores)
 		{
 			EntryRef *e = (*Stores)[(int)GetCtrlValue(IDC_MSG_STORE)];
 			if (!e)
 			{
 				auto Dlg = new AddFolderDlg(this, Io, e);
 				Dlg->DoModal([this, Dlg](auto dlg, auto ctrlId)
 				{
 					if (ctrlId)
 						AddPath(Dlg->Path);
 					delete dlg;
 				});
 			}
 		}
 	}
 
 	int OnNotify(LViewI *v, LNotification n)
 	{
 		bool Ok = false;
 
 		switch (v->GetId())
 		{
 			case IDC_SET_FOLDER:
 			{
 				auto Dlg = new FolderDlg(this, App);
 				Dlg->DoModal([this, Dlg](auto dlg, auto ctrlId)
 				{
 					if (ctrlId)
 						SetCtrlName(IDC_FOLDER, Dlg->Get());
 					delete dlg;
 				});
 				break;
 			}
 			case IDOK:
 			{
 				Ok = true;
 				// fall thru
 			}
 			case IDCANCEL:
 			{
 				LVariant k;
 				const char *s;
 				if (SrcFolders)
 				{
 					Params->Import.Empty();
 					Params->Import.SetFixedLength(false);
 					for (auto i : *SrcFolders)
 						Params->Import.New() = i->GetText(0);
 					Params->Import.SetFixedLength(true);
 
 					auto s = LString(",").Join(Params->Import);
 					if (s)
 						App->GetOptions()->SetValue(OPT_OutlookImportSrc, k = s);
 					else
 						App->GetOptions()->DeleteValue(OPT_OutlookImportSrc);
 				}
 				s = GetCtrlName(IDC_FOLDER);
 				if (s)
 				{
 					App->GetOptions()->SetValue(OPT_OutlookImportDst, k = s);
 
 					if (Ok)
 						*OurFolder = App->GetFolder(s);
 				}
 				else
 				{
 					App->GetOptions()->DeleteValue(OPT_OutlookImportDst);
 				}
 
 				Params->AllFolders = GetCtrlValue(IDC_ALL) != 0;
 				App->GetOptions()->SetValue(OPT_OutlookImportAll, k = (int)Params->AllFolders);
 
 				if (Ok && Io->GetSession() && Stores)
 				{
 					EntryRef *e = (*Stores)[(int)GetCtrlValue(IDC_MSG_STORE)];
 					if (e)
 					{
 						e->OpenRoot(Io->GetSession(), Io->GetUiHnd(), Io->MsgStore, *MapiFolder);
 					}
 				}
 
 				EndModal(v->GetId());
 				break;
 			}
 		}
 
 		return IoDlg::OnNotify(v, n);
 	}
 };
 
 class ExportDlg : public IoDlg
 {
 	ExportParams *Params;
 
 public:
 	ExportDlg(	ScribeWnd *app,
 				ExportParams *params,
 				OutlookIO *io,
 				LComPtr<IMAPIFolder> *MapiFolder,
 				ScribeFolder *&ScribeFolder) :
 		IoDlg(app, io, MapiFolder, ScribeFolder)
 	{
 		SetParent(app);
 		Params = params;
 
 		if (LoadFromResource(IDD_OUTLOOK_EXPORT))
 		{
 			MoveToCenter();
 			OnLogin(false);
 			GetViewById(IDC_SRC_FOLDERS, SrcFolders);
 
 			SetCtrlValue(IDC_NO_SPAM_TRASH, true);
 
 			LVariant v;
 			if (App->GetOptions()->GetValue(OPT_OutlookExportSrc, v) && v.Str())
 			{
 				auto t = v.LStr().SplitDelimit(",");
 				for (unsigned i=0; i<t.Length(); i++)
 				{
 					AddPath(t[i]);
 				}
 			}
 			if (App->GetOptions()->GetValue(OPT_OutlookExportDst, v))
 			{
 				SetCtrlName(IDC_FOLDER, v.Str());
 			}
 			if (App->GetOptions()->GetValue(OPT_OutlookExportAll, v))
 			{
 				SetCtrlValue(IDC_ALL, v.CastInt32());
 			}
 			if (App->GetOptions()->GetValue(OPT_OutlookExportExclude, v))
 			{
 				SetCtrlValue(IDC_NO_SPAM_TRASH, v.CastInt32());
 			}
 
 			InitSrcClients();
 		}
 	}
 
 	void OnLogin(bool e)
 	{
 		SetCtrlEnabled(IDC_CLIENT, !e);
 		SetCtrlEnabled(IDC_LOGIN, !e);
 
 		SetCtrlEnabled(IDC_MSG_STORE, e);
 		SetCtrlEnabled(IDC_ALL, e);
 		SetCtrlEnabled(IDC_NO_SPAM_TRASH, e);
 		SetCtrlEnabled(IDC_SRC_FOLDERS, e);
 		SetCtrlEnabled(IDC_ADD_SRC_FOLDER, e);
 		SetCtrlEnabled(IDC_DEL_SRC_FOLDER, e);
 		SetCtrlEnabled(IDC_SET_FOLDER, e);
 		SetCtrlEnabled(IDOK, e);
 
 		SetCtrlEnabled(IDC_FOLDER, false);
 	}
 
 	void AddFolder()
 	{
 		auto Fs = new FolderDlg(this, App);
 		Fs->DoModal([this, Fs](auto dlg, auto ctrlId)
 		{
 			if (ctrlId && Fs->Get())
 				AddPath(Fs->Get());
 			delete dlg;
 		});
 	}
 
 	LComPtr<IMAPIFolder> GetSubFolderByName(IMAPIFolder *f, char *name)
 	{
 		LComPtr<IMAPIFolder> ChildFolder;
 
 		if (f && name)
 		{
 			LPMAPITABLE Folders = 0;
 			if (f->GetHierarchyTable(0, &Folders) == S_OK)
 			{
 				for (LMapiList Lst(Folders); Lst.More(); Lst.Next())
 				{
 					SPropValue *v = Lst.GetField(PR_ENTRYID);
 					char *Name = MapiCastString(Lst.GetField(PR_DISPLAY_NAME));
 					if (v && Name)
 					{
 						if (_stricmp(Name, name) == 0)
 						{
 							ULONG Type;
 							f->OpenEntry(v->Value.bin.cb, (LPENTRYID)v->Value.bin.lpb, NULL, MAPI_BEST_ACCESS, &Type, (IUnknown**)ChildFolder.Set());
 						}
 					}					
 				}
 			}
 		}
 
 		return ChildFolder;
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_SET_FOLDER:
 			{
 				if (Stores)
 				{
 					EntryRef *e = (*Stores)[(int)GetCtrlValue(IDC_MSG_STORE)];
 					if (e)
 					{
 						auto Dlg = new AddFolderDlg(this, Io, e);
 						Dlg->DoModal([this, Dlg](auto dlg, auto id)
 						{
 							if (id)
 								SetCtrlName(IDC_FOLDER, Dlg->Path);
 							delete dlg;
 						});
 					}
 				}
 				break;
 			}
 			case IDOK:
 			{
 				Params->Include.Empty();
 				Params->AllFolders = GetCtrlValue(IDC_ALL) != 0;
 				for (auto i : *SrcFolders)
 				{
 					ScribeFolder *f = App->GetFolder(i->GetText(0));
 					if (f)
 					{
 						if (!Params->Export.HasItem(f))
 						{
 							Params->Export.Insert(f);
 						}
 
 						if (!Params->Include.HasItem(f))
 						{
 							Params->Include.Insert(f);
 
 							ScribeFolder *p = f;
 							while (p = p->GetFolder())
 							{
 								if (!Params->Include.HasItem(p))
 								{
 									Params->Include.Insert(p);
 								}
 							}
 						}
 					}
 				}
 
 				if (GetCtrlValue(IDC_NO_SPAM_TRASH))
 				{
 					Params->Exclude.Insert(App->GetFolder("/Spam"));
 					Params->Exclude.Insert(App->GetFolder(FOLDER_TRASH));
 				}
 
 				// Get the scribe folder to start at...
 				*OurFolder = App->GetFolder("/");
 
 				// Get the mapi folder to start at..
 				if (Io->GetSession() && Stores)
 				{
 					EntryRef *e = (*Stores)[(int)GetCtrlValue(IDC_MSG_STORE)];
 					if (e)
 					{
 						// Open the store...
 						e->OpenRoot(Io->GetSession(), Io->GetUiHnd(), Io->MsgStore, *MapiFolder);
 
 						// Drill down to the select sub-folder...
 						auto t = LString(GetCtrlName(IDC_FOLDER)).SplitDelimit("/");
 						if (t.Length() > 0)
 						{
 							LComPtr<IMAPIFolder> f = *MapiFolder;
 							for (unsigned i=0; i<t.Length(); i++)
 							{
 								f = GetSubFolderByName(f, t[i]);
 								if (!f)
 									break;
 							}
 							*MapiFolder = f;
 						}
 					}
 				}
 
 				// Fall thru
 			}
 			case IDCANCEL:
 			{
 				LVariant v;
 				LStringPipe p;
 				for (auto i : *SrcFolders)
 				{
 					if (p.GetSize()) p.Push(",");
 					p.Push(i->GetText(0));
 				}
 				char *Fld = p.NewStr();
 				if (Fld)
 				{
 					App->GetOptions()->SetValue(OPT_OutlookExportSrc, v = Fld);
 					DeleteArray(Fld);
 				}
 				else
 				{
 					App->GetOptions()->DeleteValue(OPT_OutlookExportSrc);
 				}
 				App->GetOptions()->SetValue(OPT_OutlookExportDst, v = GetCtrlName(IDC_FOLDER));
 				App->GetOptions()->SetValue(OPT_OutlookExportAll, v = GetCtrlValue(IDC_ALL));
 				App->GetOptions()->SetValue(OPT_OutlookExportExclude, v = GetCtrlValue(IDC_NO_SPAM_TRASH));
 
 				EndModal(c->GetId() == IDOK);
 				break;
 			}
 		}
 
 		return IoDlg::OnNotify(c, n);
 	}
 };
 
 void Import_Outlook(ScribeWnd *Wnd, int Flags)
 {
 	OutlookIO Imp(Wnd, Flags);
 }
 
 void Export_Outlook(ScribeWnd *Wnd)
 {
 	OutlookIO Exp(Wnd, EXP_OUTLOOK_EMAIL);
 }
 
 OutlookIO::OutlookIO(ScribeWnd *Wnd, int Flags, ScribeAccount *account)
 {
 	App = Wnd;
 	hMapi = NULL;
 	Ui = (UI_TYPE) ((Wnd) ? Wnd->Handle() : 0);
 	MAPIInitialize = NULL;
 	MAPILogonEx = NULL;
 	MAPIUninitialize = NULL;
 	MAPIAllocateBuffer = NULL;
 	MAPIFreeBuffer = NULL;
 	WrapCompressedRTFStream = NULL;
 	Account = account;
 
 	ImportParams IParams;
 	IParams.App = App;
 
 	ExportParams EParams;
 	EParams.App = App;
 
 	LComPtr<IMAPIFolder> MapiFolder;
 	ScribeFolder *OurFolder = NULL;
 
 	#if 0 // FIXME
 	if (Flags == IMP_OUTLOOK)
 	{
 		ImportDlg Dlg(Wnd, &IParams, this, &MapiFolder, OurFolder);
 		if (Dlg.DoModal() == IDOK)
 		{
 		}
 		else return;
 	}
 	else if (Flags == EXP_OUTLOOK_EMAIL)
 	{
 		ExportDlg Dlg(Wnd, &EParams, this, &MapiFolder, OurFolder);
 		if (Dlg.DoModal() == IDOK)
 		{
 		}
 		else return;
 	}
 
 	if (Session &&
 		MapiFolder &&
 		OurFolder)
 	{
 		if (Flags == EXP_OUTLOOK_EMAIL)
 		{
 			LProgressDlg *Prog = new LProgressDlg(Wnd);
 			if (Prog)
 			{
 				Prog->SetDescription("Initializing...");
 				if (EParams.Export.Length())
 				{
 					Prog->SetRange(EParams.Export.Length());
 				}
 				else
 				{
 					LMailStore *Ms = App->GetDefaultMailStore();
 					Prog->SetRange(Ms ? CountFolders(Ms->Root) : 0);
 				}
 				EParams.Prog = Prog->ItemAt(0);
 				EParams.ItemProg = Prog->Push();
 				if (EParams.ItemProg)
 				{
 					EParams.ItemProg->SetDescription("Items...");
 				}
 			}
 
 			for (auto *f = OurFolder->GetChildFolder(); f; f = f->GetNextFolder())
 			{
 				Export(&EParams, f, MapiFolder);
 			}
 			DeleteObj(Prog);
 		}
 		else
 		{
 			if (Flags == IMP_OUTLOOK_PAB)
 			{
 				ImportPersonalAddressBook();
 			}
 			else
 			{
 				LProgressDlg *Prog = new LProgressDlg(Wnd);
 				if (Prog)
 				{
 					Prog->SetDescription("Initializing...");
 					if (IParams.Import.Length())
 					{
 						Prog->SetRange(IParams.Import.Length());
 					}
 					else
 					{
 						LMailStore *Ms = App->GetDefaultMailStore();
 						Prog->SetRange(Ms ? CountFolders(Ms->Root) : 0);
 					}
 					IParams.Prog = Prog->ItemAt(0);
 					IParams.ItemProg = Prog->Push();
 					if (IParams.ItemProg)
 					{
 						IParams.ItemProg->SetDescription("Items...");
 					}
 				}
 
 				LString::Array Path;
 				Import(&IParams, MapiFolder, OurFolder, Path);
 				DeleteObj(Prog);
 			}
 		}
 	}
 	#endif
 
 	if (MsgStore)
 		MsgStore.Release();
 }
 
 OutlookIO::~OutlookIO()
 {
 	if (AddrBook)
 		AddrBook.Release();
 
 	if (Session)
 	{
 		Session->Logoff(0, 0, 0);
 		Session.Release();
 	}
 
 	if (MsgStore)
 		MsgStore.Release();
 
 	if (MAPIUninitialize)
 	{
 		MAPIUninitialize();
 	}
 
 	if (hMapi)
 	{
 		FreeLibrary(hMapi);
 		hMapi = NULL;
 	}
 }
 
 bool OutlookIO::LoadSession(LViewI *Parent, char *ResetClient)
 {
 	bool Status = false;
     char Cur[MAX_PATH_LEN];
     GetCurrentDirectory(sizeof(Cur), Cur);
 
 	DefClient.Reset(NewStr(ResetClient));
 
 	HRESULT Error = S_OK;
 	hMapi = LoadLibraryA("mapi32.dll");
 	if (hMapi)
 	{
 		MAPIInitialize			= (MAPIINITIALIZE*)				GetProcAddress(hMapi, "MAPIInitialize");
 		MAPILogonEx				= (MAPILOGONEX*)				GetProcAddress(hMapi, "MAPILogonEx");
 		MAPIAllocateBuffer		= (MAPIALLOCATEBUFFER*)			GetProcAddress(hMapi, "MAPIAllocateBuffer");
 		MAPIFreeBuffer			= (MAPIFREEBUFFER*)				GetProcAddress(hMapi, "MAPIFreeBuffer");
 		WrapCompressedRTFStream = (pWrapCompressedRTFStream)	GetProcAddress(hMapi, "WrapCompressedRTFStream");
 
 		if (MAPIInitialize &&
 			MAPILogonEx &&
 			MAPIAllocateBuffer &&
 			MAPIFreeBuffer &&
 			MAPIInitialize(NULL) == S_OK)
 		{
 			MAPIUninitialize = (MAPIUNINITIALIZE*)	GetProcAddress(hMapi, "MAPIUninitialize");
 			
 			if (!Account)
 			{
 				if (MAPILogonEx(Parent ? (UI_TYPE)Parent->Handle() : Ui,
 								NULL,
 								NULL,
 								MAPI_LOGON_UI | MAPI_EXTENDED,
 								Session.Set()) == S_OK &&
 					Session)
 				{
                     SetCurrentDirectory(Cur);
 					Status = true;
 				}
 				else
 				{
 					LgiMsg(App, LLoadString(IDS_MAPI_LOGIN_FAILED), AppName);
 				}
 			}
 		}
 		else
 		{
 			LgiMsg(App, LLoadString(IDS_ERROR_MAPI_INIT_FAILED), AppName);
 		}
 	}
 	else
 	{
 		LgiMsg(App, LLoadString(IDS_ERROR_MAPI_NOT_INSTALLED), AppName);
 	}
 
 	if (!Status && hMapi)
 	{
 		MAPIUninitialize();
 		MAPIUninitialize = NULL;
 		MAPIInitialize = NULL;
 		MAPILogonEx = NULL;
 		MAPIAllocateBuffer = NULL;
 		MAPIFreeBuffer = NULL;
 		WrapCompressedRTFStream = NULL;
 
 		FreeLibrary(hMapi);
 		hMapi = NULL;
 	}
 
 	return Status;
 }
 
 Mail *MatchEmail(ScribeFolder *f, Mail *m1)
 {
 	f->LoadThings();
 
 	for (auto t: f->Items)
 	{
 		Mail *m2 = t->IsMail();
 		if (m2)
 		{
 			const char *id1, *id2;
 			if ((id1 = m1->GetMessageId()) &&
 				(id2 = m2->GetMessageId()) &&
 				strcmp(id1, id2) == 0)
 			{
 				return m2;
 			}
 		}
 	}
 
 	for (auto t: f->Items)
 	{
 		Mail *m2 = t->IsMail();
 		if (m2)
 		{
 			if (m1->GetSubject() &&
 				m2->GetSubject() &&
 				strcmp(m1->GetSubject(), m2->GetSubject()) == 0 &&
 				*m1->GetDateSent() == *m2->GetDateSent())
 			{
 				return m2;
 			}
 		}
 	}
 
 	return 0;
 }
 
 int MapNetCpToWin(int Cp)
 {
 	switch (Cp)
 	{
 		case 708:
 			return 1256;
 		case 720:
 			return 1256;
 		case 28596:
 			return 1256;
 		case 10004:
 			return 1256;
 		case 1256:
 			return 1256;
 		case 775:
 			return 1257;
 		case 28594:
 			return 1257;
 		case 1257:
 			return 1257;
 		case 852:
 			return 1250;
 		case 28592:
 			return 1250;
 		case 10029:
 			return 1250;
 		case 1250:
 			return 1250;
 		case 51936:
 			return 936;
 		case 936:
 			return 936;
 		case 52936:
 			return 936;
 		case 10008:
 			return 936;
 		case 950:
 			return 950;
 		case 20000:
 			return 950;
 		case 20002:
 			return 950;
 		case 10002:
 			return 950;
 		case 866:
 			return 1251;
 		case 28595:
 			return 1251;
 		case 20866:
 			return 1251;
 		case 21866:
 			return 1251;
 		case 10007:
 			return 1251;
 		case 1251:
 			return 1251;
 		case 29001:
 			return 1252;
 		case 20106:
 			return 1252;
 		case 737:
 			return 1253;
 		case 28597:
 			return 1253;
 		case 10006:
 			return 1253;
 		case 1253:
 			return 1253;
 		case 869:
 			return 1253;
 		case 862:
 			return 1255;
 		case 38598:
 			return 1255;
 		case 28598:
 			return 1255;
 		case 10005:
 			return 1255;
 		case 1255:
 			return 1255;
 		case 20420:
 			return 1256;
 		case 20880:
 			return 1251;
 		case 21025:
 			return 1251;
 		case 20277:
 			return 1252;
 		case 1142:
 			return 1252;
 		case 20278:
 			return 1252;
 		case 1143:
 			return 1252;
 		case 1147:
 			return 1252;
 		case 20273:
 			return 1252;
 		case 1141:
 			return 1252;
 		case 875:
 			return 1253;
 		case 20423:
 			return 1253;
 		case 20424:
 			return 1255;
 		case 20871:
 			return 1252;
 		case 1149:
 			return 1252;
 		case 1148:
 			return 1252;
 		case 20280:
 			return 1252;
 		case 1144:
 			return 1252;
 		case 50930:
 			return 932;
 		case 50939:
 			return 932;
 		case 50931:
 			return 932;
 		case 20290:
 			return 932;
 		case 50933:
 			return 949;
 		case 20833:
 			return 949;
 		case 870:
 			return 1250;
 		case 50935:
 			return 936;
 		case 20284:
 			return 1252;
 		case 1145:
 			return 1252;
 		case 20838:
 			return 874;
 		case 50937:
 			return 950;
 		case 1026:
 			return 1254;
 		case 20905:
 			return 1254;
 		case 20285:
 			return 1252;
 		case 1146:
 			return 1252;
 		case 37:
 			return 1252;
 		case 1140:
 			return 1252;
 		case 861:
 			return 1252;
 		case 10079:
 			return 1252;
 		case 57006:
 			return 57006;
 		case 57003:
 			return 57003;
 		case 57002:
 			return 57002;
 		case 57010:
 			return 57010;
 		case 57008:
 			return 57008;
 		case 57009:
 			return 57009;
 		case 57007:
 			return 57007;
 		case 57011:
 			return 57011;
 		case 57004:
 			return 57004;
 		case 57005:
 			return 57005;
 		case 51932:
 			return 932;
 		case 50220:
 			return 932;
 		case 50222:
 			return 932;
 		case 50221:
 			return 932;
 		case 10001:
 			return 932;
 		case 932:
 			return 932;
 		case 949:
 			return 949;
 		case 51949:
 			return 949;
 		case 50225:
 			return 949;
 		case 1361:
 			return 1361;
 		case 10003:
 			return 949;
 		case 28593:
 			return 1254;
 		case 28605:
 			return 1252;
 		case 20108:
 			return 1252;
 		case 437:
 			return 1252;
 		case 20107:
 			return 1252;
 		case 874:
 			return 874;
 		case 857:
 			return 1254;
 		case 28599:
 			return 1254;
 		case 10081:
 			return 1254;
 		case 1254:
 			return 1254;
 		case 1200:
 			return 1200;
 		case 1201:
 			return 1200;
 		case 65000:
 			return 1200;
 		case 65001:
 			return 1200;
 		case 20127:
 			return 1252;
 		case 1258:
 			return 1258;
 		case 850:
 			return 1252;
 		case 20105:
 			return 1252;
 		case 28591:
 			return 1252;
 		case 10000:
 			return 1252;
 		case 1252:
 			return 1252;
 	}
 
 	return 0;
 }
 
 LAutoString MapiToUtf(const char *Charset, const char *Text)
 {
 	LAutoString s;
 
 	char16 *w = (char16*) LNewConvertCp(LGI_WideCharset, Text, Charset ? Charset : LAnsiToLgiCp());
 	if (w)
 	{
 		s.Reset(WideToUtf8(w));
 		DeleteArray(w);
 	}
 
 	return s;
 }
 
 bool OutlookIO::ImportEmail(ScribeFolder *Folder, Mail *&To, IMessage *From, bool Post)
 {
 	if (!To)
 	    return false;
 	
 	if (!From)
 	{
 	    To->DecRef();
 	    return false;
 	}
 	
 	char *MsgId = MapiGetPropStr(From, PR_INTERNET_MESSAGE_ID);
 	if (MsgId)
 	{
 		To->SetMessageId(MsgId);
 	}
 
 	// Get the codepage...
 	int CodePage = MapNetCpToWin(MapiGetPropInt(From, 0x3FDE0003));
 	const char *Charset = LAnsiToLgiCp(CodePage);
 
 	// Get Internet Header fairly early in the peice to allow us to
 	// extract the codepage for the body of the message.
 	char *Header = MapiGetPropStr(From, PR_TRANSPORT_MESSAGE_HEADERS);
 	if (Header)
 	{
 		To->SetInternetHeader(Header);
 	}
 
 	// Get subject
 	char *Subject = MapiGetPropStr(From, PR_SUBJECT);
 	if (Subject)
 	{
 	    LAutoString a = MapiToUtf(Charset, Subject);
 		To->SetSubject(a);
 	}
 
 	// Get sent date
 	SPropValue *Sent = MapiGetProp(From, PR_CLIENT_SUBMIT_TIME);
 	if (Sent)
 	{
 		SYSTEMTIME st;
 		FileTimeToSystemTime(&Sent->Value.ft, &st);
 		LDateTime dt;
 		dt.Day(st.wDay);
 		dt.Month(st.wMonth);
 		dt.Year(st.wYear);
 		dt.Minutes(st.wMinute);
 		dt.Hours(st.wHour);
 		dt.Seconds(st.wSecond);
 		To->SetDateSent(&dt);
 	}
 
 	// Do replication side of things...
 	Mail *Match = MatchEmail(Folder, To);
 	if (Match)
 	{
 	    To->DecRef();
 		return true;
 	}
 
 	// Get from
 	char *SenderEmail = MapiGetPropStr(From, PR_SENDER_EMAIL_ADDRESS);
 	char *SenderName = MapiGetPropStr(From, PR_SENT_REPRESENTING_NAME);
 	if (!SenderName)
 		SenderName = MapiGetPropStr(From, PR_SENDER_NAME);
 	
 	
 	To->GetFrom()->SetStr(FIELD_NAME, SenderName);
 
 	if (SenderEmail && strchr(SenderEmail, '@'))
 	{
 		To->GetFrom()->SetStr(FIELD_EMAIL, SenderEmail);
 	}
 	else
 	{
 		// Ok we have to look up their email address ourselves.
 		SPropValue *EmailEntryId = MapiGetProp(From, PR_SENDER_ENTRYID);
 		if (EmailEntryId)
 		{
 			if (!AddrBook)
 				Session->OpenAddressBook(Ui, NULL, 0, AddrBook.Set());
 
 			if (AddrBook)
 			{
 				ULONG Type = 0;
 				IMailUser *User = 0;
 				if (AddrBook->OpenEntry(EmailEntryId->Value.bin.cb,
 										(LPENTRYID) EmailEntryId->Value.bin.lpb,
 										0,
 										MAPI_BEST_ACCESS,
 										&Type,
 										(IUnknown**)&User) == S_OK &&
 					User)
 				{
 					char *E1 = MapiGetPropStr(User, PR_EMAIL_ADDRESS);
 					char *E2 = MapiGetPropStr(User, PR_SMTP_ADDRESS);
 					if (E1 && strchr(E1, '@'))
 					{
 						To->GetFrom()->SetStr(FIELD_EMAIL, E1);
 					}
 					else if (E2 && strchr(E2, '@'))
 					{
 						To->GetFrom()->SetStr(FIELD_EMAIL, E2);
 					}
 				}
 			}
 		}
 	}
 
 	// for all recipients
 	LPMAPITABLE Recipients = 0;
 	if (From->GetRecipientTable(0, &Recipients) == S_OK &&
 		Recipients)
 	{
 		for (LMapiList Lst(Recipients); Lst.More(); Lst.Next())
 		{
 			SPropValue *Name = Lst.GetField(PR_DISPLAY_NAME);
 			SPropValue *Type = Lst.GetField(PR_RECIPIENT_TYPE);
 			SPropValue *Email1 = Lst.GetField(PR_EMAIL_ADDRESS);
 			SPropValue *Email2 = Lst.GetField(PR_SMTP_ADDRESS);
 			if (Name || Email1 || Email2)
 			{
 				LDataPropI *r = To->GetTo()->Create(To->GetObject()->GetStore());
 				if (r)
 				{
 					if (Name)
 					{
 						r->SetStr(FIELD_NAME, MapiCastString(Name));
 					}
 
 					char *E1 = (Email1) ? MapiCastString(Email1) : 0;
 					char *E2 = (Email2) ? MapiCastString(Email2) : 0;
 					if (E1 && strchr(E1, '@'))
 					{
 						r->SetStr(FIELD_EMAIL, E1);
 					}
 					else if (E2 && strchr(E2, '@'))
 					{
 						r->SetStr(FIELD_EMAIL, E2);
 					}
 
 					if (Type)
 					{
 						LONG Flags = Type->Value.ul;
 						if (Flags & MAPI_TO)
 						{
 							r->SetInt(FIELD_CC, 0);
 						}
 						else if (Flags & MAPI_CC)
 						{
 							r->SetInt(FIELD_CC, 1);
 						}
 						else if (Flags & MAPI_BCC)
 						{
 							r->SetInt(FIELD_CC, 2);
 						}
 					}
 
 					To->GetTo()->Insert(r);
 				}
 			}
 		}
 	}
 
 	// Get Body/Text
 	char *Body = MapiGetPropStr(From, PR_BODY);
 	if (Body)
 	{
 	    LAutoString a = MapiToUtf(Charset, Body);
 		To->SetBody(a);
 		To->SetBodyCharset("utf-8");
 	}
 
 	char *Html = MapiGetPropStr(From, PR_BODY_HTML);
 	if (Html)
 	{
 		To->SetHtml(Html);
 	}
 	else
 	{
 		// Rtf/HTML
 		IStream *Comp = 0;
 		if (WrapCompressedRTFStream &&
 			From->OpenProperty(	PR_RTF_COMPRESSED,
 								&IID_IStream,
 								0,
 								0,
 								(IUnknown**) &Comp) == S_OK)
 		{
 			IStream *Uncomp = 0;
 			if (WrapCompressedRTFStream(Comp, 0, &Uncomp) == S_OK)
 			{
 				LStringPipe p;
 				char Buf[1024];
 				ULONG r;
 				while (Uncomp->Read(Buf, sizeof(Buf), &r) == S_OK)
 				{
 					if (r)
 					{
 						p.Push(Buf, r);
 					}
 					else break;
 				}
 				char *Rtf = p.NewStr();
 				if (Rtf)
 				{
 					{
 						int i=0;
 						char p[256];
 						for (; true; i++)
 						{
 							#ifdef WINDOWS
 							sprintf_s(p, sizeof(p), "c:\\temp\\rtf-%i.txt", i);
 							#else
 							sprintf_s(p, sizeof(p), "/tmp/rtf-%i.txt", i);
 							#endif
 							if (!LFileExists(p)) break;
 						}
 
 						LFile f;
 						if (f.Open(p, O_WRITE))
 						{
 							f.Write(Rtf, strlen(Rtf));
 						}
 					}
 
 					LAutoString HtmlStr(MsRtfToHtml(Rtf));
 					To->SetHtml(HtmlStr);
 					DeleteArray(Rtf);
 				}
 
 				Uncomp->Release();
 			}
 			Comp->Release();
 		}
 	}
 
 	// Get Attachments
 	LPMAPITABLE Attachments = 0;
 	if (From->GetAttachmentTable(0, &Attachments) == S_OK &&
 		Attachments)
 	{
 		for (LMapiList Lst(Attachments); Lst.More(); Lst.Next())
 		{
 			SPropValue *Num = Lst.GetField(PR_ATTACH_NUM);
 			if (!Num)
 			    continue;
 
 			IAttach *Attach = 0;
 			if (From->OpenAttach(Num->Value.ul, NULL, MAPI_BEST_ACCESS, &Attach) != S_OK || !Attach)
 			    continue;
 
 			SPropValue *Method = MapiGetProp(Attach, PR_ATTACH_METHOD);
 			if (Method)
 			{
 			    char *AttachName = MapiGetPropStr(Attach, PR_ATTACH_LONG_FILENAME);
 			    char *ContentId = MapiGetPropStr(Attach, PR_ATTACH_CONTENT_ID);
 			    switch (Method->Value.ul)
 			    {
 				    case ATTACH_BY_VALUE:
 				    {
 					    Attachment *File = 0;
 					    IStream *Stream = 0;
 					    if (Attach->OpenProperty(PR_ATTACH_DATA_BIN, &IID_IStream, 0, 0, (IUnknown**)&Stream) == S_OK &&
 						    Stream)
 					    {
 						    STATSTG Stat;
 						    if (Stream->Stat(&Stat, STATFLAG_DEFAULT) == S_OK)
 						    {
 							    int Size = Stat.cbSize.LowPart;
 							    char *Data = new char[Size];
 							    if (Data)
 							    {
 								    int Block = 128 << 10;
 								    char *p = Data; 
 								    for (int i=0; i<Size; i+=Block)
 								    {
 									    auto Len = min(Size - (p - Data), Block);
 									    if (Stream->Read(p, (ULONG)Len, NULL) != S_OK)
 									    {
 										    break;
 									    }
 
 									    p += Len;
 								    }
 
 								    if (p == Data + Size)
 								    {
 									    File = new Attachment(Folder->App);
 									    if (File)
 									    {
 										    File->Set(Data, Size);
 									    }
 								    }
 
 								    DeleteArray(Data);
 							    }
 						    }
 
 						    Stream->Release();
 					    }
 
 					    if (File)
 					    {
 					        char *MimeType = MapiGetPropStr(Attach, PR_ATTACH_MIME_TAG);
 					        File->SetMimeType(MimeType ? MimeType : "application/octet-stream");
 						    
 						    if (AttachName)
 						    {
 							    File->SetName(AttachName);
 						    }
 						    else
 						    {
 							    char Str[256];
 							    sprintf_s(Str, sizeof(Str), "file%i", Num->Value.ul);
 							    File->SetName(Str);
 						    }
 
 						    if (ContentId)
 						    {
 							    File->SetContentId(ContentId);
 						    }
 
 						    To->AttachFile(File);
 
 						    // remove attachment from memory
 						    if (File->GetObject())
 						    {
 							    /* FIXME
 							    File->Store->Object = 0;
 							    File->Store = 0;
 							    DeleteObj(File);
 							    */
 						    }
 					    }
 					    break;
 				    }
 				    case ATTACH_BY_REFERENCE:
 				    case ATTACH_BY_REF_RESOLVE:
 				    case ATTACH_BY_REF_ONLY:
 				    {
 					    char *FileName = MapiGetPropStr(Attach, PR_ATTACH_LONG_PATHNAME);
 					    if (FileName)
 					    {
 						    To->AttachFile(App, FileName);
 					    }																		
 					    break;
 				    }
 				    case ATTACH_EMBEDDED_MSG:
 				    {
 					    break;
 				    }
 			    }
 			}
 
 		    Attach->Release();
 		}
 	} 
 	
 	// Set Sent/Received/Read/Unread Flags
 	SPropValue *Flags = MapiGetProp(From, PR_MESSAGE_FLAGS);
 	if (Flags)
 	{
 		ulong f = 0;
 		if (Flags->Value.ul & (MSGFLAG_SUBMIT | MSGFLAG_UNSENT) && 
 			!Post)
 		{
 			f |= MAIL_CREATED;
 		}
 		else
 		{
 			f |= MAIL_RECEIVED;
 		}
 
 		if (Flags->Value.ul & MSGFLAG_HASATTACH)
 		{
 			f |= MAIL_ATTACHMENTS;
 		}
 		if (Flags->Value.ul & MSGFLAG_READ)
 		{
 			f |= MAIL_READ;
 		}
 
 		To->SetFlags(f);
 	}
 
 	To->Update();
 	To->Save(Folder);
 	To = NULL;
 
 	return true;
 }
 
 bool PropToDate(SPropValue *p, LDateTime &dt)
 {
 	if (p && PROP_TYPE(p->ulPropTag) == PT_SYSTIME)
 	{
 		uint64 i = (((uint64)p->Value.ft.dwHighDateTime) << 32) | p->Value.ft.dwLowDateTime;
 		return dt.Set(i);
 	}
 	return false;
 }
 
 Contact *MatchContact(ScribeFolder *f, Contact *c1)
 {
 	f->LoadThings();
 
 	for (auto t: f->Items)
 	{
 		Contact *c2 = t->IsContact();
 		if (c2)
 		{
 			#define CmpOpt(name) \
 			{ \
 				const char *s1, *s2; \
 				if (!c1->Get(name, s1) || \
 					!c2->Get(name, s2) || \
 					_stricmp(s1, s2) != 0) \
 				{ \
 					continue; \
 				} \
 			}
 
 			CmpOpt(OPT_First);
 			CmpOpt(OPT_Last);
 			CmpOpt(OPT_Email);
 
 			return c2;
 		}
 	}
 
 	return 0;
 }
 
 Calendar *MatchCalendar(ScribeFolder *f, Calendar *c1)
 {
 	f->LoadThings();
 
 	for (auto t: f->Items)
 	{
 		Calendar *c2 = t->IsCalendar();
 		if (c2)
 		{
 			LDateTime d1, d2;
 			if (c1->GetField(FIELD_CAL_START_UTC, d1) &&
 				c2->GetField(FIELD_CAL_START_UTC, d2) &&
 				d1 != d2)
 			{
 				continue;
 			}
 			if (c1->GetField(FIELD_CAL_END_UTC, d1) &&
 				c2->GetField(FIELD_CAL_END_UTC, d2) &&
 				d1 != d2)
 			{
 				continue;
 			}
 			const char *s1, *s2;
 			if (c1->GetField(FIELD_CAL_SUBJECT, s1) &&
 				c2->GetField(FIELD_CAL_SUBJECT, s2) &&
 				_stricmp(s1, s2) != 0)
 			{
 				continue;
 			}
 			int t1, t2;
 			if (c1->GetField(FIELD_CAL_TYPE, t1) &&
 				c2->GetField(FIELD_CAL_TYPE, t2) &&
 				t1 != t2)
 			{
 				continue;
 			}
 
 			return c2;
 		}
 	}
 
 	return 0;
 }
 
 bool OutlookIO::ImportItem(ScribeFolder *Out, IMAPIFolder *In, SPropValue *EntryId)
 {
 	bool Status = false;
 	if (Out && In && EntryId)
 	{
         LDataStoreI::StoreTrans StoreTransaction = Out->GetObject()->GetStore()->StartTransaction();
 		
 		ULONG Type = 0;
 		IUnknown *Item = 0;
 		HRESULT e;
 		if ((e = In->OpenEntry(	EntryId->Value.bin.cb,
 								(LPENTRYID)EntryId->Value.bin.lpb,
 								NULL,
 								MAPI_BEST_ACCESS,
 								&Type,
 								&Item)) == S_OK &&
 			Item)
 		{
 			switch (Type)
 			{
 				case MAPI_MESSAGE:
 				{
 					IMessage *Msg = 0;
 					if (Item->QueryInterface(IID_IMessage, (void**)&Msg) == S_OK && Msg)
 					{
 						SPropValue *Class = MapiGetProp(Msg, PR_ORIG_MESSAGE_CLASS);
 						if (!Class)
 						{
 							Class = MapiGetProp(Msg, PR_MESSAGE_CLASS);
 						}
 
 						if (Class)
 						{
 							char *sClass = MapiCastString(Class);
 							bool Note = _strnicmp(sClass, "IPM.Note", 8) == 0;
 							bool Post = _strnicmp(sClass, "IPM.Post", 8) == 0;
 							bool Document = _strnicmp(sClass, "IPM.Document", 12) == 0;
 
 							if (Note || Document || Post)
 							{
 								// Email
 								Mail *Email = new Mail(Out->App);
 								if (Email)
 								{
 									Email->App = App;
 									Status = ImportEmail(Out, Email, Msg, Post);
 								}
 								LAssert(Email == NULL);
 							}
 							else if (_stricmp(sClass, "IPM.Contact") == 0)
 							{
 								// Contact
 								Contact *c = new Contact(Out->App);
 								if (c)
 								{
 									c->App = App;
 
 									#define ConvertStr(opt, tag) \
 										{ auto s = LFromNativeCp(MapiGetPropStr(Msg, tag)); \
 										c->Set(opt, s); }
 
 									ConvertStr(OPT_First, PR_GIVEN_NAME);
 									ConvertStr(OPT_Last, PR_SURNAME);
 									
 									char *Email = 0;
 									#define CheckTagForEmail(tag) \
 										if (!Email) { char *e = MapiGetPropStr(Msg, tag); \
 										if (e && strchr(e, '@')) Email = e; }
 									
 									CheckTagForEmail(0x81b0001e);
 									CheckTagForEmail(0x805d001e);
 									CheckTagForEmail(0x8060001e);
 									CheckTagForEmail(0x81ae001e);
 
 									c->Set(OPT_Email, Email);
 
 									Contact *Match = MatchContact(Out, c);
 									if (Match)
 									{
 										DeleteObj(c);
 										c = Match;
 									}
 
 									ConvertStr(OPT_HomeStreet, PR_STREET_ADDRESS);
 									ConvertStr(OPT_HomeSuburb, PR_LOCALITY); // city
 									ConvertStr(OPT_HomePostcode, PR_POSTAL_CODE);
 									ConvertStr(OPT_HomeState, PR_STATE_OR_PROVINCE);
 									ConvertStr(OPT_HomeCountry, PR_COUNTRY);
 									ConvertStr(OPT_WorkPhone, PR_BUSINESS_TELEPHONE_NUMBER);
 									ConvertStr(OPT_HomePhone, PR_HOME_TELEPHONE_NUMBER);
 									ConvertStr(OPT_HomeMobile, PR_CELLULAR_TELEPHONE_NUMBER);
 									ConvertStr(OPT_HomeFax, PR_PRIMARY_FAX_NUMBER);
 									char *WebPage = MapiGetPropStr(Msg, PR_PERSONAL_HOME_PAGE);
 									if (!WebPage) WebPage = MapiGetPropStr(Msg, PR_BUSINESS_HOME_PAGE);
 									c->Set(OPT_HomeWebPage, WebPage);
 									ConvertStr(OPT_Nick, PR_NICKNAME);
 									ConvertStr(OPT_Spouse, PR_SPOUSE_NAME);
 									ConvertStr(OPT_Note, PR_BODY);
 
 									c->Save(Out);
 
 									Status = true;
 								}
 							}
 							else if (_stricmp(sClass, "IPM.Appointment") == 0)
 							{
 								Calendar *c = new Calendar(Out->App);
 								if (c)
 								{
 									c->App = App;
 
 									bool Historical = false;
 									LDateTime dt, Now;
 									Now.SetNow();
 									SPropValue *p = MapiGetProp(Msg, PR_START_DATE);
 									if (PropToDate(p, dt))
 									{
 										Historical = dt < Now;
 										c->SetField(FIELD_CAL_START_UTC, dt);
 									}
 									p = MapiGetProp(Msg, PR_END_DATE);
 									if (PropToDate(p, dt))
 									{
 										c->SetField(FIELD_CAL_END_UTC, dt);
 									}
 									char *s = MapiGetPropStr(Msg, PR_SUBJECT);
 									if (s) c->SetField(FIELD_CAL_SUBJECT, s);
 
 									Calendar *Match = MatchCalendar(Out, c);
 									if (Match)
 									{
 									    c->DecRef();
 										c = Match;
 									}
 
 									s = MapiGetPropStr(Msg, 0x810C001E);
 									if (s) c->SetField(FIELD_CAL_LOCATION, s);
 									s = MapiGetPropStr(Msg, PR_BODY);
 									if (s) c->SetField(FIELD_CAL_NOTES, s);
 
 									// Only import alarms for future objects, otherwise a replicate from
 									// Outlook -> Scribe sets off all the old alarms. Which is annoying.
 									if (!Historical)
 									{
 										p = MapiGetProp(Msg, 0x81EE000B);
 										if (p && p->Value.b)
 										{
 											/* FIXME
 											c->SetField(FIELD_CAL_REMINDER_ACTION, true);
 											int i = MapiCastInt(MapiGetProp(Msg, 0x81E90003));
 											c->SetField(FIELD_CAL_REMINDER_TIME, -i);
 											*/
 										}
 									}
 
 									// Erm, you'd usually have to map the names here, but I used the Outlook list
 									// to write my calendar, so it doesn't need converting... ;)
 									int ShowAs = MapiCastInt(MapiGetProp(Msg, 0x81930003));
 									c->SetField(FIELD_CAL_SHOW_TIME_AS, ShowAs);
 
 									c->Save(Out);
 
 									Status = true;
 								}
 							}
 						}
 
 						Msg->Release();
 					}
 					else
 					{
 						LgiTrace("%s:%i - QueryInterface for IMessage failed.\n", __FILE__, __LINE__);
 					}
 					break;
 				}
 			}
 
 			Item->Release();
 		}
 		else
 		{
 			LgiTrace("%s:%i - OpenEntry failed.\n", __FILE__, __LINE__);
 		}
 	}
 
 	return Status;
 }
 
 int OutlookIO::FolderType(IMAPIFolder *In)
 {
 	int Status = MAGIC_MAIL;
 	LPMAPITABLE Items = 0;
 	if (In &&
 		In->GetContentsTable(0, &Items) == S_OK)
 	{
 		// Loop through all the items
 		bool Done = false;
 		for (LMapiList Lst(Items); Lst.More() && !Done; Lst.Next())
 		{
 			SPropValue *EntryId = Lst.GetField(PR_ENTRYID);
 			if (EntryId)
 			{
 				ULONG Type = 0;
 				IUnknown *Item = 0;
 				if (In->OpenEntry(	EntryId->Value.bin.cb,
 									(LPENTRYID)EntryId->Value.bin.lpb,
 									NULL,
 									MAPI_BEST_ACCESS,
 									&Type,
 									&Item) == S_OK &&
 					Item)
 				{
 					IMessage *Msg = 0;
 					if (Item->QueryInterface(IID_IMessage, (void**)&Msg) == S_OK && Msg)
 					{
 						char *Vs;
 						SPropValue *v = MapiGetProp(Msg, PR_MESSAGE_CLASS);
 						if (v && (Vs = MapiCastString(v)))
 						{
 							if (_stricmp(Vs, "IPM.Note") == 0)
 							{
 								Status = MAGIC_MAIL;
 								Done = true;
 							}
 							else if (_stricmp(Vs, "IPM.Contact") == 0)
 							{
 								Status = MAGIC_CONTACT;
 								Done = true;
 							}
 							else if (_stricmp(Vs, "IPM.Appointment") == 0)
 							{
 								Status = MAGIC_CALENDAR;
 								Done = true;
 							}
 						}
 
 						Msg->Release();
 					}
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 LString ConvertToString(LString::Array &Path)
 {
 	LString d("/");
 	LString ret = d + d.Join(Path);
 	return ret;
 }
 
 bool OutlookIO::Import(	ImportParams *P,
 						IMAPIFolder *In,
 						ScribeFolder *Out,
 						LString::Array &Path)
 {
 	bool Status = false;
 	if (App && Out && In)
 	{
 		const char *FolderName = Out->GetText(0);
 		if (FolderName && P->Prog)
 		{
 			char FolderStr[256];
 			sprintf_s(FolderStr, sizeof(FolderStr), "Folder: '%s'", FolderName);
 			P->Prog->SetDescription(FolderStr);
 		}
 
 		bool ImportThisFolder = P->AllFolders;
 		
 		if (!ImportThisFolder)
 		{
 			auto CurPath = ConvertToString(Path);
 			for (auto s: P->Import)
 			{
 				if (_stricmp(CurPath, s) == 0)
 				{
 					ImportThisFolder = true;
 					break;
 				}
 			}
 		}
 
 		if (ImportThisFolder)
 		{
 			// look through all the items for mail and contacts
 			LPMAPITABLE Items = 0;
 			if (In->GetContentsTable(0, &Items) == S_OK)
 			{
 				// ViewTable(Items, Wnd);
 				Status = true;
 
 				LMapiList Lst(Items);
 				if (Lst.Length() > 0)
 				{
 					int GoodConvert = 0;
 
 					if (P->ItemProg)
 					{
 						P->ItemProg->SetDescription("Processing items...");
 						P->ItemProg->SetRange(Lst.Length());
 					}
 
 					// Loop through all the items
 					for (; Lst.More() && !P->ItemProg->IsCancelled(); Lst.Next())
 					{
 						SPropValue *v = Lst.GetField(PR_ENTRYID);
 						if (v)
 						{
 							if (ImportItem(Out, In, v))
 							{
 								GoodConvert++;
 							}
 							else
 							{
 								#ifdef _DEBUG
 								// try it again
 								ImportItem(Out, In, v);
 								#endif
 							}
 						}
 
 						if (P->ItemProg)
 						{
 							P->ItemProg->Value(Lst.Index());
 						}
 					}
 
 					if (P->ItemProg)
 					{
 						P->ItemProg->SetDescription("");
 						P->ItemProg->Value(0);
 						P->ItemProg->SetRange(0);
 					}
 				}
 			}
 		}
 
 		// look through all the children folders for more stuff to import
 		LPMAPITABLE Folders = 0;
 		if (In->GetHierarchyTable(0, &Folders) == S_OK)
 		{
 			// Loop through all the folders
 			for (LMapiList Lst(Folders); Lst.More() && !P->Prog->IsCancelled(); Lst.Next())
 			{
 				SPropValue *v = Lst.GetField(PR_ENTRYID);
 				SPropValue *Name = Lst.GetField(PR_DISPLAY_NAME);
 				if (v && Name)
 				{
 					IMAPIFolder *ChildIn;
 					ULONG Type;
 					if (In->OpenEntry(v->Value.bin.cb, (LPENTRYID)v->Value.bin.lpb, NULL, MAPI_BEST_ACCESS, &Type, (IUnknown**)&ChildIn) == S_OK &&
 						ChildIn)
 					{
 						// Check that this folder exists
 						auto OutlookName = LFromNativeCp(MapiCastString(Name));
 						char Str[256];
 						auto OutPath = Out->GetPath();
 						strcpy_s(Str, sizeof(Str), OutPath);
 						if (Str[strlen(Str)-1] != '/') strcat(Str, "/");
 						strcat(Str, OutlookName);
 						ScribeFolder *ChildOut = App->GetFolder(Str);
 						if (!ChildOut)
 						{
-							ChildOut = Out->CreateSubDirectory(OutlookName, FolderType(ChildIn));
+							ChildOut = Out->CreateSubFolder(OutlookName, FolderType(ChildIn));
 						}
 
 						if (ChildOut)
 						{
 							Path.New() = MapiCastString(Name);
 
 							Status &= Import(P, ChildIn, ChildOut, Path);
 							ChildOut->Save();
 
 							Path.PopLast();
 						}
 
 						ChildIn->Release();
 					}
 				}
 			}
 		}
 	}
 	return Status;
 }
 
 void OutlookIO::ImportPersonalAddressBook(std::function<void(bool)> callback)
 {
 	auto Dlg = new FolderDlg(App, App, MAGIC_CONTACT);
 	Dlg->DoModal([this, Dlg, callback](auto dlg, auto ctrlId)
 	{
 		if (!ctrlId)
 		{
 			delete dlg;
 			if (callback)
 				callback(false);
 			return;
 		}
 
 		bool Status = false;
 		HRESULT Error = S_OK;
 		IAddrBook *AddrBook = 0;
 		auto DestFolder = App->GetFolder(Dlg->Get());
 		if (DestFolder &&
 			(Error = Session->OpenAddressBook(Ui, NULL, 0, &AddrBook)) == S_OK &&
 			AddrBook)
 		{
 			ULONG EntryIDSize = 0;
 			ENTRYID *PersonalAddrBook = 0;
 			if (AddrBook->GetPAB(&EntryIDSize, &PersonalAddrBook) == S_OK &&
 				PersonalAddrBook)
 			{
 				ULONG Type = 0;
 				IDistList *DistList = 0;
 				if (AddrBook->OpenEntry(EntryIDSize,
 										PersonalAddrBook,
 										NULL,
 										0,
 										&Type,
 										(IUnknown**)&DistList) == S_OK &&
 					DistList)
 				{
 					int NewContacts = 0;
 					LPMAPITABLE DistContents = 0;
 					if (DistList->GetContentsTable(0, &DistContents) == S_OK &&
 						DistContents)
 					{
 						for (LMapiList Lst(DistContents); Lst.More(); Lst.Next())
 						{
 							SPropValue *v = Lst.GetField(PR_ENTRYID);
 							if (v)
 							{
 								ULONG type = 0;
 								IMailUser *User = 0;
 								if (DistList->OpenEntry(	v->Value.bin.cb,
 															(LPENTRYID) v->Value.bin.lpb,
 															0,
 															0,
 															&type,
 															(IUnknown**)&User) == S_OK &&
 									User)
 								{
 									SPropValue *Array = 0;
 									ULONG Values = 0;
 
 									if (User->GetProps(	NULL, // Props
 														0,
 														&Values,
 														&Array) == S_OK &&
 										Array)
 									{
 										Contact *Person = (Contact*)App->CreateItem(MAGIC_CONTACT, DestFolder, false);
 										if (Person)
 										{
 											for (unsigned n=0; n<Values; n++)
 											{
 												switch (Array[n].ulPropTag)
 												{
 													case PR_DISPLAY_NAME:
 													{
 														auto Name = LFromNativeCp(Array[n].Value.lpszA);
 														if (Name)
 														{
 															int Spaces = 0;
 															for (int k=0; Name.Get()[k]; k++)
 															{
 																if (Name.Get()[k] == ' ') Spaces++;
 															}
 
 															if (Spaces == 1)
 															{
 																char *Space = strchr(Name, ' ');
 																*Space = 0;
 																Person->Set(OPT_First, Name);
 																Person->Set(OPT_Last, Space+1);
 
 																const char *Last = 0;
 																Person->Get(OPT_Last, Last);
 																int n=0;
 															}
 															else
 															{
 																Person->Set(OPT_First, Name);
 															}
 														}
 														break;
 													}
 													case PR_EMAIL_ADDRESS:
 													case PR_SMTP_ADDRESS:
 													{
 														char *Addr = Array[n].Value.lpszA;
 														if (strchr(Addr, '@'))
 														{
 															Person->Set(OPT_Email, Array[n].Value.lpszA);
 														}
 														break;
 													}
 													default:
 													{
 														if (PROP_ID(Array[n].ulPropTag) >= 0x8000 &&
 															PROP_ID(Array[n].ulPropTag) <= 0x8100 &&
 															PROP_TYPE(Array[n].ulPropTag) == PT_STRING8)
 														{
 															char *Addr = Array[n].Value.lpszA;
 															if (strchr(Addr, '@'))
 															{
 																Person->Set(OPT_Email, Array[n].Value.lpszA);
 															}
 														}
 														break;
 													}
 												}
 											}
 
 											Person->Save();
 											NewContacts++;
 										}
 									}
 								}
 							}
 						}
 					}
 
 					char Msg[256];
 					sprintf_s(Msg, sizeof(Msg), "%i contacts imported from Outlook.", NewContacts);
 					LgiMsg(App, Msg, AppName, MB_OK);
 
 					Status = true;
 				}
 				else
 				{
 					LgiMsg(App, "Couldn't open the personal address book.", "Error", MB_OK);
 				}
 			}
 			else
 			{
 				LgiMsg(App, "No personal address book.", "Error", MB_OK);
 			}
 		}
 		else
 		{
 			LgiMsg(App, "Couldn't open the address book.", "Error", MB_OK);
 		}
 
 		delete dlg;
 		if (callback)
 			callback(Status);
 	});
 }
 
 void Import_OutlookContacts(ScribeWnd *Parent)
 {
 	#ifdef WIN32
 	Import_Outlook(Parent, IMP_OUTLOOK_PAB);
 	#else
 	ScribeFolder *Contacts = Parent->GetFolder(FOLDER_CONTACTS);
 	if (!Contacts)
 		return;
 
 	auto Select = new LFileSelect;
 
 	Select->Parent(Parent);
 	Select->Type("Outlook Contacts", "*.csv");
 
 	Select.Open([](auto s, auto ok)
 	{
 		if (ok)
 		{
 			ImpRecordSet Rs;
 			if (ReadCsv(s->Name(), Rs) > 0)
 			{
 				for (ImpRecord *r = Rs.First(); r; r = Rs.Next())
 				{
 					Contact *c = new Contact;
 					if (c)
 					{
 						CopyField(c, OPT_First, r, "First Name");
 						CopyField(c, OPT_Last, r, "Last Name");
 						CopyField(c, OPT_Email, r, "E-mail Address");
 						CopyField(c, OPT_Street, r, "Home Street");
 						CopyField(c, OPT_Suburb, r, "Home City");
 						CopyField(c, OPT_State, r, "Home State");
 						CopyField(c, OPT_Postcode, r, "Home Postal Code");
 						CopyField(c, OPT_Country, r, "Home Country");
 						CopyField(c, OPT_Work, r, "Business Phone");
 						CopyField(c, OPT_Home, r, "Home Phone");
 						CopyField(c, OPT_Mobile, r, "Mobile Phone");
 						CopyField(c, OPT_Fax, r, "Business Fax");
 						CopyField(c, OPT_WebPage, r, "Web Page");
 
 						c->Save(Contacts);
 					}
 				}
 			}
 		}
 
 		delete s;
 	});
 	#endif
 }
 
 ////////////////////////////////////////////////////////////////////////////
 bool SetPropToEntryId(SPropValue &Prop, int Id, char *Email, char *Name)
 {
 	/*
 	struct SenderEntry
 	{
 		char Flags[4];		// 0
 		char Muid[16];		// MAPI_ONE_OFF_UID
 		uint16 wVersion;	// 0
 		uint16 wFlags;		// MAPI_ONE_OFF_NO_RICH_INFO (1)
 		char *DisplayName;
 		char *AddrType;
 		char *EmailAddr;
 	};
 	*/
 
 	uchar MapiOneOffUid[] = MAPI_ONE_OFF_UID;
 	char AddrType[] = "SMTP";
 	
 	if (Email && Name)
 	{
 		LMemQueue p;
 		int32 i32 = 0;
 		int16 i16 = 0;
 		p.Write(&i32, sizeof(i32));
 		p.Write(MapiOneOffUid, sizeof(MapiOneOffUid));
 		p.Write(&i16, sizeof(i16));
 		i16 = MAPI_ONE_OFF_NO_RICH_INFO;
 		p.Write(&i16, sizeof(i16));
 		#define WriteStr(s) \
 			p.Write(s ? s : "", (s ? strlen(s) : 0) + 1);
 		if (Name)
 		{
 			WriteStr(Name);
 		}
 		else if (Email)
 		{
 			WriteStr(Email);
 		}
 		WriteStr(AddrType);
 		WriteStr(Email);
 		Prop.ulPropTag = Id;
 		Prop.Value.bin.cb = (ULONG) p.GetSize();
 		Prop.Value.bin.lpb = (uchar*)p.New();
 
 		return Prop.Value.bin.lpb != 0;
 	}
 
 	return false;
 };
 
 int OutlookIO::CountFolders(ScribeFolder *f)
 {
 	int Count = 1;
 	for (ScribeFolder *c = f->GetChildFolder(); c; c = c->GetNextFolder())
 	{
 		Count += CountFolders(c);
 	}
 	return Count;
 }
 
 bool OutlookIO::ExportCalendar(Calendar *c, IMessage *m)
 {
 	bool Status = false;
 
 	if (c && m)
 	{
 		LDateTime dt;
 		const char *s;
 		int i;
 
 		if (c->GetCalType() == CalEvent)
 		{
 			MapiSetPropStr(m, PR_MESSAGE_CLASS, "IPM.Appointment", false);
 		}
 		else if (c->GetCalType() == CalTodo)
 		{
 			MapiSetPropStr(m, PR_MESSAGE_CLASS, "IPM.Task", false);
 		}
 
 		char Tz[64];
 		int TzOff = dt.SystemTimeZone();
 		sprintf_s(Tz, sizeof(Tz), "(+%.2f)", (double)TzOff / 60);
 		MapiSetPropStr(m, 0x8091001E, Tz);
 
 		if (c->GetField(FIELD_CAL_START_UTC, dt))
 		{
 			MapiSetPropDate(m, PR_START_DATE, dt);
 			MapiSetPropDate(m, 0x80800040, dt);
 		}
 
 		if (c->GetField(FIELD_CAL_END_UTC, dt))
 		{
 			MapiSetPropDate(m, PR_END_DATE, dt);
 			MapiSetPropDate(m, 0x80810040, dt);
 		}
 
 		if (c->GetField(FIELD_CAL_SUBJECT, s))
 			MapiSetPropStr(m, PR_SUBJECT, s);
 
 		if (c->GetField(FIELD_CAL_LOCATION, s))
 			MapiSetPropStr(m, 0x810C001E, s);
 
 		if (c->GetField(FIELD_CAL_NOTES, s))
 			MapiSetPropStr(m, PR_BODY, s);
 
 		/* FIXME
 		if (c->GetField(FIELD_CAL_REMINDER_ACTION, i) && i)
 		{
 			MapiSetPropBool(m, 0x81EE000B, true);
 			if (c->GetField(FIELD_CAL_REMINDER_TIME, i))
 				MapiSetPropLong(m, 0x81E90003, -i);				
 		}
 		*/
 
 		if (c->GetField(FIELD_CAL_SHOW_TIME_AS, i))
 			MapiSetPropLong(m, 0x81930003, i);
 
 		MapiSetPropLong(m, PR_MESSAGE_FLAGS, 1);
 
 		/*
 		MapiSetPropLong(m, 0x80030003, 369);
 		MapiSetPropLong(m, 0x807D0003, 2);
 		MapiSetPropBool(m, 0x8001000B, true);
 		MapiSetPropBool(m, 0x8002000B, false);
 		*/
 	}
 
 	return Status;
 }
 
 bool OutlookIO::Export(	ExportParams *P,
 						ScribeFolder *In,
 						IMAPIFolder *Out,
 						int Depth)
 {
 	bool Status = false;
 	HRESULT Err;
 
 	// 'In' is created/found as a sub-folder of 'Out'
 	if (App &&
 		Out &&
 		In &&
 		!P->Exclude.HasItem(In) &&
 		(P->AllFolders || P->Include.HasItem(In)) &&
 		(!P->Prog || !P->Prog->IsCancelled()))
 	{
 		// Create/find the output folder
 		LPMAPITABLE Folders = 0;
 		if ((Err = Out->GetHierarchyTable(0, &Folders)) == S_OK)
 		{
 			// ViewTable(Folders, App);
 			IMAPIFolder *Match = 0;
 			auto InName = In->GetName(true);
 
 			// Loop through all the folders
 			{
 				for (LMapiList Lst(Folders); Lst.More() && !P->Prog->IsCancelled(); Lst.Next())
 				{
 					SPropValue *Name = Lst.GetField(PR_DISPLAY_NAME);
 					auto n = LFromNativeCp(MapiCastString(Name));
 					if (n && InName && _stricmp(n, InName) == 0)
 					{
 						SPropValue *v = Lst.GetField(PR_ENTRYID);
 						if (v)
 						{
 							ULONG Type;
 							if (Out->OpenEntry(	v->Value.bin.cb,
 												(LPENTRYID)v->Value.bin.lpb,
 												NULL,
 												MAPI_BEST_ACCESS,
 												&Type,
 												(IUnknown**)&Match) == S_OK)
 							{
 								break;
 							}
 						}
 					}
 				}
 			}
 
 			if (!Match)
 			{
 				Out->CreateFolder(FOLDER_GENERIC, InName, 0, 0, OPEN_IF_EXISTS, &Match);
 			}
 
 			if (Match)
 			{
 				auto FolderPath = In->GetPath();
 
 				if (P->AllFolders || P->Export.HasItem(In))
 				{
 					if (P->Prog)
 					{
 						char s[256];
 						sprintf_s(s, sizeof(s), "Loading %s...", FolderPath ? FolderPath.Get() : InName.Get());
 						P->Prog->SetDescription(s);
 					}
 
 					// Export all the contained items, by first scanning existing entries so
 					// that we can skip existing copies of the items in Scribe					
 					LPMAPITABLE Items = 0;
 					LHashTbl<StrKey<char>,bool> MsgIds;
 					if ((Err = Match->GetContentsTable(0, &Items)) == S_OK)
 					{
 						for (LMapiList Lst(Items); Lst.More(); Lst.Next())
 						{
 							SPropValue *v = Lst.GetField(PR_ENTRYID);
 							if (v)
 							{
 								ULONG Type = 0;
 								IUnknown *Item = 0;
 								if ((Err = Match->OpenEntry(v->Value.bin.cb,
 															(LPENTRYID)v->Value.bin.lpb,
 															NULL,
 															MAPI_BEST_ACCESS,
 															&Type,
 															&Item)) == S_OK &&
 									Item)
 								{
 									if (Type == MAPI_MESSAGE)
 									{
 										IMessage *Msg = 0;
 										if (Item->QueryInterface(IID_IMessage, (void**)&Msg) == S_OK && Msg)
 										{
 											char *MsgId = MapiGetPropStr(Msg, PR_INTERNET_MESSAGE_ID);
 											if (MsgId)
 											{
 												MsgIds.Add(MsgId, true);
 											}
 
 											Msg->Release();
 										}
 									}
 
 									Item->Release();
 								}
 								else
 								{
 									LgiTrace("%s:%i - Match->OpenEntry failed, Err=%x\n", __FILE__, __LINE__, Err);
 								}
 							}
 						}
 					}
 
 					// Copy items from Scribe to the MAPI store
 					bool WasLoaded = In->IsLoaded();
 					In->LoadThings();
 
 					if (P->Prog)
 					{
 						char s[256];
 						sprintf_s(s, sizeof(s), "Exporting %s...", FolderPath ? FolderPath.Get() : InName.Get());
 						P->Prog->SetDescription(s);
 					}
 					if (P->ItemProg)
 					{
 						P->ItemProg->Value(0);
 						P->ItemProg->SetRange(In->Items.Length());
 						P->ItemProg->SetType("email");
 						P->ItemProg->Cancel(false);
 					}
 					for (auto t: In->Items)
 					{
 						if (P->ItemProg && P->ItemProg->IsCancelled())
 							break;
 
 						Mail *m = t->IsMail();
 						if (m)
 						{
 							char MsgId[256];
 							sprintf_s(MsgId, sizeof(MsgId), "<%s>", m->GetMessageId(true));
 							if (!MsgIds.Find(MsgId))
 							{
 								IMessage *Msg;
 								if ((Err = Match->CreateMessage(0, 0, &Msg)) == S_OK)
 								{
 									SPropValue v;
 									Msg->SetProps(1, &v, 0);
 
 									MapiSetPropLong(Msg, PR_MESSAGE_FLAGS, m->GetFlags() & MAIL_READ ? MSGFLAG_READ : 0);
 									MapiSetPropLong(Msg, PR_OBJECT_TYPE, MAPI_MESSAGE);
 									MapiSetPropStr(Msg, PR_MESSAGE_CLASS, "IPM.Note", false);
 									MapiSetPropStr(Msg, PR_INTERNET_MESSAGE_ID, MsgId, false);
 
 									if (m->GetSubject())
 									{
 										MapiSetPropStr(Msg, PR_SUBJECT, m->GetSubject(), true);
 									}
 
 									// Write the sender...
 									if (m->GetFrom())
 									{
 										SPropValue Prop;
 										if (SetPropToEntryId(Prop, PR_SENDER_ENTRYID, (char*)m->GetFromStr(FIELD_EMAIL), (char*)m->GetFromStr(FIELD_NAME)))
 										{
 											Msg->SetProps(1, &Prop, 0);
 											DeleteArray(Prop.Value.bin.lpb);
 										}
 
 										if (m->GetFromStr(FIELD_EMAIL))
 										{
 											MapiSetPropStr(Msg, PR_SENDER_ADDRTYPE, "SMTP", false);
 											MapiSetPropStr(Msg, PR_SENDER_EMAIL_ADDRESS, m->GetFromStr(FIELD_EMAIL), false);
 
 											MapiSetPropStr(Msg, PR_SENT_REPRESENTING_ADDRTYPE, "SMTP", false);
 											MapiSetPropStr(Msg, PR_SENT_REPRESENTING_EMAIL_ADDRESS, m->GetFromStr(FIELD_EMAIL), false);
 										}
 
 										auto Name = m->GetFromStr(FIELD_EMAIL) ? m->GetFromStr(FIELD_EMAIL) : m->GetFromStr(FIELD_EMAIL);
 										if (Name)
 										{
 											MapiSetPropStr(Msg, PR_SENDER_NAME, Name, true);
 											MapiSetPropStr(Msg, PR_SENT_REPRESENTING_NAME, Name, true);
 										}
 									}
 
 									// Write out the recipients table
 									if (m->GetTo()->Length())
 									{
 										ADRLIST *Adr = 0;
 										if (MAPIAllocateBuffer(CbNewADRLIST((ULONG)m->GetTo()->Length()), (void**) &Adr) == S_OK)
 										{
 											Adr->cEntries = (ULONG)m->GetTo()->Length();
 
 											int n = 0;
 											for (LDataPropI *a = m->GetTo()->First(); a; a = m->GetTo()->Next(), n++)
 											{
 												Adr->aEntries[n].cValues = 3 + (a->GetStr(FIELD_EMAIL) ? 1 : 0) + (a->GetStr(FIELD_NAME) ? 1 : 0);
 												Adr->aEntries[n].ulReserved1 = 0;
 												if (MAPIAllocateBuffer(	sizeof(SPropValue) * Adr->aEntries[n].cValues,
 																		(void**) &Adr->aEntries[n].rgPropVals) == S_OK)
 												{
 													SPropValue *p = Adr->aEntries[n].rgPropVals;
 													int i = 0;
 
 													if (SetPropToEntryId(p[0], PR_ENTRYID, (char*)a->GetStr(FIELD_EMAIL), (char*)a->GetStr(FIELD_NAME)))
 													{
 														i++;
 													}
 													else
 													{
 														Adr->aEntries[n].cValues--;
 													}
 													
 													switch (a->GetInt(FIELD_CC))
 													{
 														default:
 														case MAIL_ADDR_TO:
 															p[i].Value.l = MAPI_TO;
 															break;
 														case MAIL_ADDR_CC:
 															p[i].Value.l = MAPI_CC;
 															break;
 														case MAIL_ADDR_BCC:
 															p[i].Value.l = MAPI_BCC;
 															break;
 													}
 													p[i].ulPropTag = PR_RECIPIENT_TYPE;
 													p[i++].dwAlignPad = 0;
 
 													p[i].ulPropTag = PR_ADDRTYPE;
 													p[i].dwAlignPad = 0;
 													p[i++].Value.lpszA = "SMTP";
 
 													p[i].ulPropTag = PR_DISPLAY_NAME;
 													p[i].Value.lpszA = (char*) (a->GetStr(FIELD_NAME) ? a->GetStr(FIELD_NAME) : a->GetStr(FIELD_EMAIL));
 													p[i++].dwAlignPad = 0;
 													
 													if (a->GetStr(FIELD_EMAIL))
 													{
 														p[i].ulPropTag = PR_EMAIL_ADDRESS;
 														p[i].Value.lpszA = (char*) a->GetStr(FIELD_EMAIL);
 														p[i++].dwAlignPad = 0;
 													}
 												}
 											}
 
 											HRESULT e;
 											if ((e = Msg->ModifyRecipients(MODRECIP_ADD, Adr)) != S_OK)
 											{
 												// _asm int 3
 											}
 
 											for (unsigned i=0; i<Adr->cEntries; i++)
 											{
 												MAPIFreeBuffer(Adr->aEntries[i].rgPropVals);
 											}
 
 											MAPIFreeBuffer(Adr);
 										}
 									}
 									
 									if (m->GetBody())
 									{
 										LAutoString cs = m->GetCharSet();
 										if (cs)
 										{
 											char *u8 = (char*) LNewConvertCp("utf-8", m->GetBody(), cs);
 											MapiSetPropStr(Msg, PR_BODY, u8, true);
 											DeleteArray(u8);
 										}
 										else
 										{
 											MapiSetPropStr(Msg, PR_BODY, m->GetBody(), false);
 										}
 									}
 
 									if (m->GetHtml())
 									{
 										MapiSetPropStr(Msg, PR_BODY_HTML, m->GetHtml(), true);
 									}
 
 									if (m->GetInternetHeader())
 									{
 										MapiSetPropStr(Msg, PR_TRANSPORT_MESSAGE_HEADERS, m->GetInternetHeader(), false);
 									}
 
 									MapiSetPropDate(Msg, PR_CLIENT_SUBMIT_TIME, *m->GetDateSent());
 									MapiSetPropDate(Msg, PR_MESSAGE_DELIVERY_TIME, *m->GetDateReceived());
 
 									// Write out any attachments
 									List<Attachment> Att;
 									if (m->GetAttachments(&Att))
 									{
 										for (auto a: Att)
 										{
 											char *Ptr;
 											ssize_t Size;
 											if (a->Get(&Ptr, &Size))
 											{
 												ULONG AttachmentNum = 0;
 												LPATTACH Attach = 0;
 												if ((Err = Msg->CreateAttach(0, 0, &AttachmentNum, &Attach)) == S_OK)
 												{
 													MapiSetPropLong(Attach, PR_ATTACH_METHOD, ATTACH_BY_VALUE);
 													if (a->GetName())
 													{
 														MapiSetPropStr(Attach, PR_ATTACH_LONG_FILENAME, a->GetName(), false);
 
 														auto d = a->GetName();
 														const char *Dir = 0;
 														while (*d)
 														{
 															if (*d == '/' || *d == '\\')
 															{
 																Dir = d;
 															}
 															d++;
 														}
 														if (Dir)
 														{
 															Dir++;
 														}
 														else
 														{
 															Dir = a->GetName();
 														}
 														MapiSetPropStr(Attach, PR_DISPLAY_NAME, Dir, false);
 													}
 													if (a->GetMimeType())
 													{
 														MapiSetPropStr(Attach, PR_ATTACH_MIME_TAG, a->GetMimeType(), false);
 													}
 													if (a->GetContentId())
 													{
 														MapiSetPropStr(Attach, PR_ATTACH_CONTENT_ID, a->GetContentId(), false);
 													}
 													
 													SPropValue Bin;
 													Bin.dwAlignPad = 0;
 													Bin.ulPropTag = PR_ATTACH_DATA_BIN;
 													Bin.Value.bin.cb = (ULONG) Size;
 													Bin.Value.bin.lpb = (uchar*)Ptr;
 													Attach->SetProps(1, &Bin, 0);
 
 													Attach->SaveChanges(0);
 													Attach->Release();
 												}
 												else
 												{
 													LgiTrace("%s:%i - Msg->CreateAttach failed, Err=%x\n", __FILE__, __LINE__, Err);
 												}
 											}
 										}
 									}
 
 									Msg->SaveChanges(0);
 									Msg->Release();
 								}
 								else
 								{
 									LgiTrace("%s:%i - Match->CreateMessage failed, Err=%x\n", __FILE__, __LINE__, Err);
 								}
 							}
 						}
 
 						Calendar *Cal = t->IsCalendar();
 						if (Cal)
 						{
 							if (Cal->GetCalType() == CalEvent)
 							{
 								IMessage *Msg;
 								if ((Err = Match->CreateMessage(0, 0, &Msg)) == S_OK)
 								{
 									ExportCalendar(Cal, Msg);
 									Msg->SaveChanges(0);
 									Msg->Release();
 								}
 							}
 							else
 							{
 								// Find todo folder...
 							}
 						}
 
 						if (P->ItemProg)
 							P->ItemProg->Value(P->ItemProg->Value()+1);
 					}
 
 					if (P->Prog)
 						P->Prog->Value(P->Prog->Value()+1);
 
 					if (!WasLoaded)
 					{
 						In->UnloadThings();
 					}
 				}
 
 				// Export child folders...
 				for (ScribeFolder *c = In->GetChildFolder(); c; c = c->GetNextFolder())
 				{
 					Export(P, c, Match, Depth + 1);
 				}
 
 				Match->Release();
 			}
 		}
 		else
 		{
 			LgiTrace("%s:%i - Out->GetHierarchyTable failed, Err=%x\n", _FL, Err);
 		}
 	}
 
 	return Status;
 }
 //////////////////////////////////////////////////////////////////////////////
 class MailMapiSource : public MailSource
 {
 protected:
 	OutlookIO *Mapi;
 	ScribeWnd *Parent;
 	ScribeAccount *Account;
 	UI_TYPE Ui;
 
 	IMsgStore *MsgStore;
 	IMAPIFolder *pFolder;
 	List<MapiEntry> Entries;
 
 	bool ListEntries();
 	bool OnMsgStore(HRESULT Result);
 
 public:
 	MailMapiSource(ScribeWnd *parent, ScribeAccount *account);
 	~MailMapiSource();
 
 	// Connection
 	bool Open(LSocketI *S, const char *RemoteHost, int Port, const char *User, const char *Password, LDom *SettingStore, int Flags = 0);
 	bool Close();
 
 	// Commands available while connected
 	ssize_t GetMessages() override;
 	bool Receive(LArray<MailTransaction*> &Trans, MailCallbacks *Callbacks);
 	bool Delete(int Message);
 	int Sizeof(int Message);
 	bool GetUid(int Message, char *Id, int IdLen);
 	bool GetUidList(LString::Array &Id);
 	LString GetHeaders(int Message);
 };
 
 MailMapiSource::MailMapiSource(ScribeWnd *parent, ScribeAccount *account)
 {
 	MsgStore = 0;
 	pFolder = 0;
 
 	Parent = parent;
 	Account = account;
 	Ui = (UI_TYPE) ((Parent) ? Parent->Handle() : 0);
 	Mapi = new OutlookIO(Parent, 0, Account);
 }
 
 MailMapiSource::~MailMapiSource()
 {
 	if (pFolder)
 	{
 		pFolder->Release();
 	}
 	if (MsgStore)
 	{
 		MsgStore->Release();
 	}
 
 	DeleteObj(Mapi);
 }
 
 bool MailMapiSource::OnMsgStore(HRESULT Result)
 {
 	if (FAILED(Result))
 		return false;
 
 	if (!MsgStore)
 		return false;
 
 	SPropValue *SubTree = MapiGetProp(MsgStore, PR_IPM_SUBTREE_ENTRYID);
 	if (!SubTree)
 		return false;
 
 	ULONG ObjType;
 	IMAPIFolder *Root = 0;
 	if (MsgStore->OpenEntry(SubTree->Value.bin.cb, (LPENTRYID)SubTree->Value.bin.lpb, NULL, MAPI_BEST_ACCESS, &ObjType, (IUnknown**) &Root) != S_OK ||
 		!Root)
 		return false;
 
 	LPMAPITABLE Folders = 0;
 	if (Root->GetHierarchyTable(0, &Folders) != S_OK)
 		return false;
 
 	// Loop through all the folders
 	bool Status = false;
 	for (LMapiList Lst(Folders); Lst.More(); Lst.Next())
 	{
 		SPropValue *v = Lst.GetField(PR_ENTRYID);
 		SPropValue *Name = Lst.GetField(PR_DISPLAY_NAME);
 		if (v && Name)
 		{
 			char *FolderName = MapiCastString(Name);
 			if (FolderName &&
 				_stricmp(FolderName, "Inbox") == 0)
 			{
 				ULONG Type;
 				Status |= Root->OpenEntry(v->Value.bin.cb,
 										(LPENTRYID)v->Value.bin.lpb,
 										NULL,
 										MAPI_BEST_ACCESS,
 										&Type,
 										(IUnknown**)&pFolder) == S_OK &&
 										pFolder;
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool MailMapiSource::Open(LSocketI *S, const char *RemoteHost, int Port, const char *User, const char *Password, LDom *SettingStore, int Flags)
 {
 	bool Status = true;
 
 	if (Account &&
 		Mapi)
 	{
 		LVariant Server = Account->Receive.Server();
 		if (Server.Str())
 		{
 			char PassStr[128] = "";
 			LPassword p;
 			Account->Receive.GetPassword(&p);
 			p.Get(PassStr);
 
 			Mapi->MAPILogonEx(	Ui,
 								Server.Str(),
 								ValidStr(PassStr) ? PassStr : 0,
 								MAPI_EXTENDED,
 								Mapi->Session.Set());
 		}
 		
 		if (!Status)
 		{
 			Mapi->MAPILogonEx(	Ui,
 								NULL,
 								NULL,
 								MAPI_LOGON_UI | MAPI_EXTENDED,
 								Mapi->Session.Set());
 
 			if (Account &&
 				Mapi->Session)
 			{
 				// when we're called with a blank account we should be nice and
 				// record what the user entered for their profile
 
 				LPMAPITABLE Tbl = 0;
 				if (Mapi->Session->GetStatusTable(0, &Tbl) == SUCCESS_SUCCESS)
 				{
 					// ViewTable(Tbl, Window);
 					for (LMapiList Lst(Tbl); Lst.More(); Lst.Next())
 					{
 						SPropValue *Type = Lst.GetField(PR_RESOURCE_TYPE);
 						SPropValue *Name = Lst.GetField(PR_DISPLAY_NAME); 
 						if (MapiCastInt(Type) == MAPI_SUBSYSTEM)
 						{
 							// this should be the profile name
 							Account->Receive.Server(MapiCastString(Name));
 							break;
 						}
 					}
 				}
 			}
 		}
 
 		if (Mapi->Session)
 		{
 			LVariant UserName = Account->Receive.UserName();
 			if (!ValidStr(UserName.Str()))
 			{
 				auto Dlg = new ChooseMessageStoreDlg(Parent, Mapi->Session, false);
 				if (!Dlg->InitCheck())
 				{
 					delete Dlg;
 				}
 				else
 				{
 					Dlg->DoModal([this, Dlg](auto dlg, auto id)
 					{
 						if (id && Dlg->Ref)
 						{
 							Account->Receive.UserName(Dlg->Ref->DisplayName);
 
 							auto Error = Mapi->Session->OpenMsgStore(Ui,
 																Dlg->Ref->Size, // entry bytes
 																Dlg->Ref->Entry, // ptr to entry
 																NULL, // default interface: IMsgStore
 																MAPI_BEST_ACCESS,
 																&MsgStore);
 							OnMsgStore(Error);
 						}
 						delete dlg;
 					});
 				}
 			}
 			else
 			{
 				MessageStores Entries(Mapi->Session);
 				if (Entries.Status)
 				{
 					for (auto e: Entries)
 					{
 						if (e->DisplayName &&
 							_stricmp(e->DisplayName, UserName.Str()) == 0)
 						{
 							auto Error = Mapi->Session->OpenMsgStore(Ui,
 																e->Size, // entry bytes
 																e->Entry, // ptr to entry
 																NULL, // default interface: IMsgStore
 																MAPI_BEST_ACCESS,
 																&MsgStore);
 							if (OnMsgStore(Error))
 								break;
 						}
 					}
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool MailMapiSource::Close()
 {
 	if (Mapi &&
 		Mapi->Session)
 	{
 		return true;
 	}
 	return false;
 }
 
 bool MailMapiSource::ListEntries()
 {
 	if (pFolder && Entries.Length() < 1)
 	{
 		LPMAPITABLE Items = 0;
 		if (pFolder->GetContentsTable(0, &Items) == S_OK)
 		{
 			for (LMapiList Lst(Items); Lst.More(); Lst.Next())
 			{
 				SPropValue *v = Lst.GetField(PR_ENTRYID);
 				if (v)
 				{
 					Entries.Insert(new MapiEntry(v));
 				}
 			}
 		}
 	}
 
 	return Entries.Length() > 0;
 }
 
 ssize_t MailMapiSource::GetMessages()
 {
 	ssize_t Status = 0;
 	if (ListEntries())
 	{
 		Status = Entries.Length();
 	}
 	return Status;
 }
 
 bool MailMapiSource::Receive(LArray<MailTransaction*> &Trans, MailCallbacks *Callbacks)
 {
 	bool Status = false;
 
 	for (unsigned n=0; n<Trans.Length(); n++)
 	{
 		MapiEntry *e = Entries.ItemAt(Trans[n]->Index);
 		if (e && Trans[n]->Stream)
 		{
 			ULONG Type = 0;
 			IUnknown *Item = 0;
 			if (pFolder->OpenEntry(	e->Len,
 									(LPENTRYID)e->Bin,
 									NULL,
 									MAPI_BEST_ACCESS,
 									&Type,
 									&Item) == S_OK &&
 				Item)
 			{
 				switch (Type)
 				{
 					case MAPI_MESSAGE:
 					{
 						IMessage *IMsg = 0;
 						if (Item->QueryInterface(IID_IMessage, (void**)&IMsg) == S_OK)
 						{
 							SPropValue *Class = MapiGetProp(IMsg, PR_ORIG_MESSAGE_CLASS);
 							if (!Class)
 							{
 								Class = MapiGetProp(IMsg, PR_MESSAGE_CLASS);
 							}
 
 							if (Class)
 							{
 								char *sClass = MapiCastString(Class);
 								bool Note = _stricmp(sClass, "IPM.Note") == 0;
 								bool Post = _stricmp(sClass, "IPM.Post") == 0;
 								bool Document = _strnicmp(sClass, "IPM.Document", 12) == 0;
 
 								if (Note || Post || Document)
 								{
 									// FIXME
 									// Status |= Trans[n]->Status = Mapi->ImportEmail(dynamic_cast<Mail*>(Msg), IMsg, Post);
 								}
 							}
 
 							IMsg->Release();
 						}
 						break;
 					}
 				}
 
 				Item->Release();
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool MailMapiSource::Delete(int Message)
 {
 	return false;
 }
 
 int MailMapiSource::Sizeof(int Message)
 {
 	return 0;
 }
 
 bool MailMapiSource::GetUid(int Message, char *Id, int IdLen)
 {
 	return false;
 }
 
 bool MailMapiSource::GetUidList(LString::Array &Id)
 {
 	return false;
 }
 
 LString MailMapiSource::GetHeaders(int Message)
 {
 	return NULL;
 }
 
 MailSource *NewOutlookMailSource(ScribeWnd *Parent, ScribeAccount *Account)
 {
 	return new MailMapiSource(Parent, Account);
 }
 
diff --git a/src/Imp_Eml.cpp b/src/Imp_Eml.cpp
--- a/src/Imp_Eml.cpp
+++ b/src/Imp_Eml.cpp
@@ -1,213 +1,213 @@
 #include "Scribe.h"
 #include "lgi/common/Db.h"
 #include "lgi/common/XmlTree.h"
 #include "lgi/common/FileSelect.h"
 #include "resdefs.h"
 
 //////////////////////////////////////////////////////////////////////////
 class LImportEml : public LDialog
 {
 	ScribeWnd *App;
 
 public:
 	LString In;
 	ScribeFolder *Out;
 	int TotalEmail;
 
 	LImportEml(ScribeWnd *app)
 	{
 		Out = 0;
 		SetParent(App = app);
 		if (LoadFromResource(IDD_EML_IMPORT))
 		{
 			MoveToCenter();
 		}
 
 		if ((Out = App->GetCurrentFolder()))
 			SetCtrlName(IDC_OUT_FOLDER, Out->GetPath());
 	}
 	
 	int Scan(LTreeNode *Parent, char *Folder)
 	{
 		LDirectory d;
 
 		int Email = 0;
 		int ChildEmail = 0;
 		LTreeItem *i = new LTreeItem;
 
 		for (int b=d.First(Folder); b; b=d.Next())
 		{
 			if (d.IsDir())
 			{
 				char c[MAX_PATH_LEN];
 				d.Path(c, sizeof(c));
 				ChildEmail += Scan(i, c);
 			}
 			else
 			{
 				char *ext = strrchr(d.GetName(), '.');
 				if (ext && !_stricmp(ext, ".eml"))
 				{
 					Email++;
 				}
 			}
 		}
 
 		if (Email || ChildEmail)
 		{
 			char *Leaf = strrchr(Folder, DIR_CHAR);
 			char Msg[MAX_PATH_LEN];
 			sprintf_s(Msg, sizeof(Msg), "%s (%i)", Leaf + 1, Email);
 			i->SetText(Msg);
 			Parent->Insert(i);
 			Parent->Expanded(true);
 		}
 		else
 		{
 			DeleteObj(i);
 		}
 
 		return Email + ChildEmail;
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_SET_IN:
 			{
 				auto s = new LFileSelect(this);
 				s->Type("Email Files", "*.eml");
 				s->Type("All Files", LGI_ALL_FILES);
 				s->Open([this](auto dlg, auto status)
 				{
 					if (status)
 					{
 						char p[MAX_PATH_LEN];
 						strcpy_s(p, sizeof(p), dlg->Name());
 						LTrimDir(p);
 						SetCtrlName(IDC_IN_FOLDER, p);
 					
 						if (LDirExists(p))
 						{
 							LTree *t;
 							if (GetViewById(IDC_TREE, t))
 							{
 								TotalEmail = Scan(t, p);
 							}
 						}
 					}
 					delete dlg;
 				});
 				break;
 			}
 			case IDC_SET_OUT:
 			{
 				auto Dlg = new FolderDlg(this, App, MAGIC_MAIL);
 				Dlg->DoModal([this, Dlg](auto dlg, auto id)
 				{
 					if (id)
 					{
 						Out = App->GetFolder(Dlg->Get());
 						if (Out)
 							SetCtrlName(IDC_OUT_FOLDER, Out->GetPath());
 					}
 					delete dlg;
 				});
 				break;
 			}
 			case IDOK:
 			{
 				In = GetCtrlName(IDC_IN_FOLDER);
 				// fall through
 			}
 			case IDCANCEL:
 			{
 				EndModal(c->GetId() == IDOK);
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 void ImportEmlFolders(ScribeWnd *App, LProgressPane *Prog, ScribeFolder *Out, char *In, int *Errors)
 {
 	LDirectory d;
 	
 	{
 		LDataStoreI::StoreTrans Trans = Out->GetObject()->GetStore()->StartTransaction();
 		for (int b=d.First(In); b && !Prog->IsCancelled(); b=d.Next())
 		{
 			if (!d.IsDir())
 			{
 				char *ext = strrchr(d.GetName(), '.');
 				if (ext && !_stricmp(ext, ".eml"))
 				{
 					Thing *t = App->CreateItem(MAGIC_MAIL, NULL, false);
 					if (t)
 					{
 						char c[MAX_PATH_LEN];
 						d.Path(c, sizeof(c));
 
 						LAutoPtr<LFile> Eml(new LFile);
 						if (Eml->Open(c, O_READ))
 						{
 							if (t->Import(t->AutoCast(Eml), sMimeMessage))
 							{
 								t->Save(Out);
 							}
 							else (*Errors)++;
 						}
 						else (*Errors)++;
 					}
 					else (*Errors)++;
 					
 					Prog->Value(Prog->Value() + 1);
 				}
 			}
 		}
 	}
 
 	for (int b=d.First(In); b && !Prog->IsCancelled(); b=d.Next())
 	{
 		if (d.IsDir())
 		{
 			char c[MAX_PATH_LEN];
 			d.Path(c, sizeof(c));
 			
 			ScribeFolder *Child = Out->GetSubFolder(d.GetName());
 			if (!Child)
 			{
-				Child = Out->CreateSubDirectory(d.GetName(), MAGIC_MAIL);
+				Child = Out->CreateSubFolder(d.GetName(), MAGIC_MAIL);
 			}
 			if (Child)
 			{			
 				ImportEmlFolders(App, Prog, Child, c, Errors);
 			}
 		}
 	}
 }
 
 void ImportEml(ScribeWnd *App)
 {
 	auto Dlg = new LImportEml(App);
 	Dlg->DoModal([Dlg, App](auto dlg, auto id)
 	{
 		if (id)
 		{
 			int Errors = 0;
 			LProgressDlg Prog(App);
 			Prog.SetRange(Dlg->TotalEmail);
 			Prog.SetDescription("Email");
 			ImportEmlFolders(App, Prog.ItemAt(0), Dlg->Out, Dlg->In, &Errors);
 			if (Errors)
 			{
 				Prog.Visible(false);
 				LgiMsg(App, "%i email failed to import.", AppName, MB_OK, Errors);
 			}
 		}
 		delete dlg;
 	});
 }
diff --git a/src/Imp_Mozilla.cpp b/src/Imp_Mozilla.cpp
--- a/src/Imp_Mozilla.cpp
+++ b/src/Imp_Mozilla.cpp
@@ -1,607 +1,607 @@
 // #include <stdlib.h>
 
 #include "Scribe.h"
 #include "lgi/common/Map.h"
 #include "resdefs.h"
 #include "lgi/common/TextFile.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 #include "v3.6.14/sqlite3.h"
 
 void ToRecord(LMap<int, int> &r, char *Str)
 {
 	char *n;
 	for (char *s=strchr(Str, '('); s && *s; s=n)
 	{
 		n = strchr(s, ')');
 		if (n)
 		{
 			s++;
 			*n++ = 0;
 
 			if (*s++ == '^')
 			{
 				int a = htoi(s);
 				s = strchr(s, '^');
 				if (s)
 				{
 					int b = htoi(++s);
 					r[a] = b;
 				}
 			}
 
 			n = strchr(n, '(');
 		}
 	}
 }
 
 void ToMap(LMap<int, char*> &m, char *Str)
 {
 	char *n;
 	for (char *s=strchr(Str, '('); s && *s; s=n)
 	{
 		n = strchr(s, ')');
 		if (n)
 		{
 			s++;
 			*n++ = 0;
 			char *e = strchr(s, '=');
 			if (e)
 			{
 				*e++ = 0;
 				int Var = htoi(s);
 				if (Var > 0)
 				{
 					m[Var] = e;
 				}
 			}
 
 			n = strchr(n, '(');
 		}
 	}
 }
 
 char *Decode(char *s)
 {
 	// static const char *Cp = "iso-8859-1";
 
 	if (s && strchr(s, '$'))
 	{
 		char Hex[3] = {0, 0, 0};
 		LStringPipe p(4 << 10);
 
 		char *b = s;
 		while (*s)
 		{
 			if (*s == '$')
 			{
 				if (b < s)
 				{
 					p.Push(b, (int) (s - b));
 				}
 
 				s++;
 				if (s[0] && s[1])
 				{
 					Hex[0] = *s++;
 					Hex[1] = *s++;
 
 					char c = htoi(Hex);
 					p.Push(&c, 1);
 
 					/*
 					if (*s == '$')
 					{
 						s++;
 						if (s[0] && s[1])
 						{
 							Hex[0] = *s++;
 							Hex[1] = *s++;
 							char16 c = c1 | (htoi(Hex) << 8);
 							char *Utf8 = WideToUtf8(&c, sizeof(c));
 							if (Utf8)
 							{
 								p.Push(Utf8);
 								DeleteArray(Utf8);
 							}
 						}
 					}
 					*/
 
 					b = s;
 				}
 				else break;
 			}
 			else s++;
 		}
 		if (b < s)
 		{
 			p.Push(b, (int) (s - b));
 		}
 
 		return p.NewStr();
 	}
 
 	return NewStr(s);
 }
 
 struct Sqlite
 {
 	bool Open;
 	sqlite3 *Db;
 
 	Sqlite(const char *File)
 	{	
 		Open = Check(sqlite3_open(File, &Db));
 	}
 	
 	~Sqlite()
 	{
 		if (Open)
 			sqlite3_close(Db);
 	}
 	
 	bool Check(int Code, const char *Sql = NULL)
 	{
 		if (Code == SQLITE_OK ||
 			Code == SQLITE_DONE)
 			return true;
 
 		const char *Err = sqlite3_errmsg(Db);
 		LgiTrace("%s:%i - Sqlite error %i: %s\n%s",
 			_FL,
 			Code, Err,
 			Sql?Sql:(char*)"",
 			Sql?"\n":"");
 		LAssert(!"Db Error");
 
 		return false;
 	}
 };
 
 bool ImportMozillaAddresss(ScribeWnd *App, ScribeFolder *Folder, char *File)
 {
 	if (!App || !Folder || !File)
 	{
 		LgiTrace("%s:%i - Param error.\n", _FL);
 		return false;
 	}
 
 	auto Ext = LGetExtension(File);
 	if (!Ext)
 	{
 		LgiTrace("%s:%i - No extension '%s'.\n", _FL, File);
 		return false;
 	}
 
 	bool Status = false;
 	if (!stricmp(Ext, "mab"))
 	{
 		char *Text = LReadTextFile(File);
 		if (Text)
 		{
 			int Angle = 0;
 			int Square = 0;
 			List<char> Blocks;
 			List<char> Records;
 			char *StartAngle = 0;
 			char *StartSquare = 0;
 
 			// Parse MAB...
 			for (char *s=Text; s && *s; s++)
 			{
 				if (*s == '<')
 				{
 					if (_strnicmp(s+1, "!--", 3) == 0)
 					{
 						char *e = strstr(s, "-->");
 						if (e) s = e + 3;
 						else break;
 					}
 					else
 					{
 						Angle++;
 
 						if (Angle == 1)
 							StartAngle = s + 1;
 					}
 				}
 				else if (*s == '>')
 				{
 					if (Angle > 0)
 					{
 						if (StartAngle && Angle == 1)
 							Blocks.Insert(NewStr(StartAngle, s - StartAngle));
 
 						Angle--;
 					}
 				}
 				else if (Angle == 0)
 				{
 					if (*s == '[')
 					{
 						if (++Square == 1)
 							StartSquare = s + 1;
 					}
 					else if (*s == ']')
 					{
 						if (StartSquare && Square == 1)
 							Records.Insert(NewStr(StartSquare, s - StartSquare));
 
 						Square--;
 					}
 				}
 			}
 
 			// Parse blocks..
 			bool Fields = true;
 			LMap<int, char*> Field;
 			LMap<int, char*> Data;
 
 			for (auto b: Blocks)
 			{
 				if (Fields)
 				{
 					ToMap(Field, b);
 					Fields = false;
 				}
 				else
 				{
 					ToMap(Data, b);
 				}
 			}
 
 			for (auto r: Records)
 			{
 				LMap<int, int> Record;
 				ToRecord(Record, r);
 
 				int Flds = 0;
 				Contact *c = new Contact(App);
 				if (c)
 				{
 					c->App = App;
 
 					#define MapField(From, To) \
 					{ \
 						char *d = Data[Record[Field.Reverse((char*)From)]]; \
 						if (d) \
 						{ \
 							char *s = Decode(d); \
 							if (s) \
 							{ \
 								c->Set(To, s); \
 								Flds++; \
 								DeleteArray(s); \
 							} \
 						} \
 					}
 
 					MapField("FirstName", OPT_First);
 					MapField("LastName", OPT_Last);
 					MapField("NickName", OPT_Nick);
 					MapField("PrimaryEmail", OPT_Email);
 					MapField("WorkPhone", OPT_WorkPhone);
 					MapField("HomePhone", OPT_HomePhone);
 					MapField("FaxNumber", OPT_HomeFax);
 					MapField("CellularNumber", OPT_HomeMobile);
 					MapField("HomeAddress", OPT_HomeStreet);
 					MapField("HomeAddress2", OPT_HomeSuburb);
 					MapField("HomeState", OPT_HomeState);
 					MapField("HomeZipCode", OPT_HomePostcode);
 					MapField("HomeCountry", OPT_HomeCountry);
 					MapField("WorkAddress", OPT_WorkStreet);
 					MapField("WorkAddress2", OPT_WorkSuburb);
 					MapField("WorkState", OPT_WorkState);
 					MapField("WorkZipCode", OPT_WorkPostcode);
 					MapField("WorkCountry", OPT_WorkCountry);
 					MapField("Company", OPT_Company);
 					MapField("WebPage1", OPT_WorkWebPage);
 					MapField("WebPage2", OPT_HomeWebPage);
 					MapField("CustomFields", OPT_CustomFields);
 					MapField("Notes", OPT_Note);
 					// HomeCity
 					// WorkCity
 					// JobTitle
 					// Department
 					// BirthYear
 					// BirthMonth
 					// BirthDay
 					// LastModifiedDate
 					// RecordKey
 					// AddrCharSet
 					// LastRecordKey
 					// ListName
 					// ListNickName
 					// ListDescription
 					// ListTotalAddresses
 					// LowercaseListName
 					// SecondEmail
 					// PreferMailFormat
 					// PagerNumber
 					
 					#undef MapField
 
 					if (Flds > 0)
 					{
 						Folder->WriteThing(c, NULL);
 						Status = true;
 					}
 					else
 					{
 						DeleteObj(c);
 					}
 				}
 			}
 		}
 		else
 		{
 			LgiMsg(	App,
 					"Couldn't read from '%s'\n"
 					"Is Mozilla still open?",
 					AppName,
 					MB_OK,
 					File);
 		}
 	}
 	else if (!stricmp(Ext, "sqlite"))
 	{
 		Sqlite s(File);
 		if (!s.Open)
 		{
 			LgiTrace("%s:%i - Failed to open '%s'\n", _FL, File);
 			return false;
 		}
 		
 		LString Sql = "select * from properties";
 		sqlite3_stmt *Stmt = NULL;
 		if (!s.Check(sqlite3_prepare_v2(s.Db, Sql, -1, &Stmt, 0), Sql))
 			return false;
 		
 		LHashTbl<ConstStrKey<char,false>, Contact*> Map;
 		int r;
 		while ((r = sqlite3_step(Stmt)) == SQLITE_ROW)
 		{
 			const char *card = (const char *)sqlite3_column_text(Stmt, 0);
 			auto name = sqlite3_column_text(Stmt, 1);
 			auto value = sqlite3_column_text(Stmt, 2);
 			
 			Contact *c = Map.Find(card);
 			if (!c)
 			{
 				if ((c = new Contact(App)))
 					Map.Add(card, c);
 			}
 			if (!c || !name || !value)
 				continue;
 			
 			printf("%s, %s, %s\n", card, name, value);
 			
 			#define MapField(src, dst) \
 				if (!stricmp((const char*)name, src)) c->Set(dst, (char*)value)
 			MapField("FirstName", OPT_First);
 			MapField("LastName", OPT_Last);
 			MapField("NickName", OPT_Nick);
 			MapField("PrimaryEmail", OPT_Email);
 			MapField("WorkPhone", OPT_WorkPhone);
 			MapField("HomePhone", OPT_HomePhone);
 			MapField("FaxNumber", OPT_HomeFax);
 			MapField("CellularNumber", OPT_HomeMobile);
 			MapField("HomeAddress", OPT_HomeStreet);
 			MapField("HomeAddress2", OPT_HomeSuburb);
 			MapField("HomeState", OPT_HomeState);
 			MapField("HomeZipCode", OPT_HomePostcode);
 			MapField("HomeCountry", OPT_HomeCountry);
 			MapField("WorkAddress", OPT_WorkStreet);
 			MapField("WorkAddress2", OPT_WorkSuburb);
 			MapField("WorkState", OPT_WorkState);
 			MapField("WorkZipCode", OPT_WorkPostcode);
 			MapField("WorkCountry", OPT_WorkCountry);
 			MapField("Company", OPT_Company);
 			MapField("WebPage1", OPT_WorkWebPage);
 			MapField("WebPage2", OPT_HomeWebPage);
 			MapField("CustomFields", OPT_CustomFields);
 			MapField("Notes", OPT_Note);
 			#undef MapField
 		}
 		
 		s.Check(sqlite3_finalize(Stmt), 0);
 		
 		Status = Map.Length() > 0;
 		for (auto p: Map)
 			Folder->WriteThing(p.value, NULL);
 	}
 	else
 	{
 		LgiTrace("%s:%i - Unsupported address book format '%s'\n", _FL, File);
 	}
 
 	return Status;
 }
 
 void Import_MozillaAddressBook(ScribeWnd *App)
 {
 	LArray<char*> FindFiles;
 	LArray<const char*> Ext;
 
 	LFile::Path Str(
 		#ifdef LINUX
 		LSP_HOME
 		#else
 		LSP_USER_APP_DATA
 		#endif
 		);
 	#ifdef LINUX
 	Str += ".thunderbird";
 	#endif
 	Ext.Add("abook.mab");
 	Ext.Add("abook.sqlite");
 	LgiTrace("Searching '%s' for thunderbird address book files.\n", Str.GetFull().Get());
 	LRecursiveFileSearch(Str, &Ext, &FindFiles);
 
 	// Get default path..
 	char DefaultFolder[256] = "/Contacts";
 	ScribeFolder *f = App->GetCurrentFolder();
 	if (!f || f->GetItemType() != MAGIC_CONTACT)
 	{
 		f = App->GetFolder(FOLDER_CONTACTS);
 	}
 	if (f && f->GetItemType() == MAGIC_CONTACT)
 	{
 		auto p = f->GetPath();
 		if (p)
 			strcpy_s(DefaultFolder, sizeof(DefaultFolder), p);
 	}
 
 	LString::Array Files;
 	for (auto f: FindFiles)
 		Files.Add(f);
 	FindFiles.DeleteArrays();
 
 	// Ask user...
 	auto Dlg = new ImportExportDlg(	App,
 									false,
 									AppName,
 									"Select input files and destination directory",
 									&Files,
 									DefaultFolder,
 									MAGIC_CONTACT);
 	Dlg->DoModal([App, Dlg](auto dlg, auto id)
 	{
 		if (id && Dlg->SrcFiles[0])
 			ImportMozillaAddresss(App, App->GetFolder(Dlg->DestFolder), Dlg->SrcFiles[0]);
 		delete dlg;
 	});
 }
 
 #ifndef WIN32
 int GetPrivateProfileStringA(const char *lpAppName,
 							const char *lpKeyName,
 							const char *lpDefault,
 							char *lpReturnedString,
 							int nSize,
 							const char *lpFileName)
 {
 	// FIXME
 	LAssert(0);
 	return 0;
 }
 #endif
 
 void Import_MozillaMail(ScribeWnd *App)
 {
 	char Path[MAX_PATH_LEN];
 	if (!LGetSystemPath(LSP_USER_APP_DATA, Path, sizeof(Path)))
 		return;
 
 	LMakePath(Path, sizeof(Path), Path, "Thunderbird\\profiles.ini");
 	if (!LFileExists(Path))
 	{
 		LgiMsg(App, LLoadString(IDS_ERROR_FILE_DOESNT_EXIST), AppName, MB_OK, Path);
 		return;
 	}
 
 	char s[128];
 	if (GetPrivateProfileStringA("Profile0", "Path", "", s, sizeof(s), Path) <= 0)
 		return;
 
 	if (LIsRelativePath(s))
 	{
 		LTrimDir(Path);
 		LMakePath(Path, sizeof(Path), Path, s);
 	}
 	else
 	{
 		strcpy_s(Path, sizeof(Path), s);
 	}
 	LMakePath(Path, sizeof(Path), Path, "Mail");
 	if (!LDirExists(Path))
 	{
 		LgiMsg(App, LLoadString(IDS_ERROR_FOLDER_DOESNT_EXIST), AppName, MB_OK, Path);
 		return;
 	}
 		
 	LArray<char*> FindFiles;
 	if (!LRecursiveFileSearch(Path, 0, &FindFiles))
 		return;
 
 	// Clear out index files...
 	for (unsigned i=0; i<FindFiles.Length(); i++)
 	{
 		auto f = FindFiles[i];
 		int64 Size = LFileSize(f);
 		char *Ext = strrchr(f, '.');
 		if
 		(
 			Size == 0
 			||
 			(
 				Ext
 				&&
 				(
 					_stricmp(Ext, ".msf") == 0
 					||
 					_stricmp(Ext, ".dat") == 0
 				)
 			)
 		)
 		{
 			FindFiles.DeleteAt(i);
 			DeleteArray(f);
 			i--;
 		}
 	}
 
 	LString::Array Files;
 	for (auto f: FindFiles)
 		Files.New() = f;
 	FindFiles.DeleteArrays();
 
 	// Do UI
 	ScribeFolder *Cur = App->GetCurrentFolder();
 	LString CurPath;
 	if (Cur)
 		CurPath = Cur->GetPath();
 	auto Dlg = new ImportExportDlg(App,
 						false,
 						"Mozilla/Thunderbird",
 						LLoadString(IDS_IMPORT),
 						&Files,
 						CurPath,
 						MAGIC_MAIL);
 	Dlg->DoModal([App, Dlg](auto dlg, auto id)
 	{
 		if (id && Dlg->DestFolder)
 		{
 			ScribeFolder *Dest = App->GetFolder(Dlg->DestFolder);
 			if (Dest)
 			{
 				for (auto Src: Dlg->SrcFiles)
 				{
 					char *Name = strrchr(Src, DIR_CHAR);
 					if (!Name) Name = Src;
 					else Name++;
 
-					ScribeFolder *Child = Dest->CreateSubDirectory(Name, MAGIC_MAIL);
+					ScribeFolder *Child = Dest->CreateSubFolder(Name, MAGIC_MAIL);
 					if (Child)
 					{
 						LAutoPtr<LTextFile> f(new LTextFile);
 						if (f->Open(Src, O_READ))
 						{
 							Child->Import(Child->AutoCast(f), sMimeMbox);
 						}
 					}
 				}
 
 				Dest->Expanded(true);
 			}
 			else LgiMsg(App,
 						LLoadString(IDS_ERROR_FOLDER_DOESNT_EXIST),
 						AppName,
 						MB_OK,
 						Dlg->DestFolder.Get());
 		}
 
 		delete dlg;
 	});
 }
diff --git a/src/Imp_OutlookExpress.cpp b/src/Imp_OutlookExpress.cpp
--- a/src/Imp_OutlookExpress.cpp
+++ b/src/Imp_OutlookExpress.cpp
@@ -1,719 +1,719 @@
 /*
 **	FILE:			Imp_OutlookExpress.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			4/2/2000
 **	DESCRIPTION:	Scribe importer
 **
 **	Copyright (C) 2000, Matthew Allen
 **		fret@memecode.com
 */
 
 #include "Scribe.h"
 #include "resdefs.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 
 bool ImportMBX(ScribeWnd *Parent, ScribeFolder *ParentFolder, char *FileName)
 {
 	LFile F;
 	if (FileName &&
 		ParentFolder &&
 		Parent &&
 		F.Open(FileName, O_READ))
 	{
 		char Magic[4] = {'J', 'M', 'F', '6'};
 		char Buf[4];
 		if (F.Read(Buf, 4) == 4 &&
 			memcmp(Magic, Buf, 4) == 0)
 		{
 			int32 Msgs;
 
 			F.Seek(4, SEEK_CUR);
 			F >> Msgs;
 
 			// Create folder for these messages
 			char n[256];
 			strcpy_s(n, sizeof(n), FileName);
 			char *Ls = 0; // last slash
 			for (Ls = n+strlen(n)-1; Ls > n; Ls--)
 			{
 				if (*Ls == DIR_CHAR)
 				{
 					Ls++;
 					break;
 				}
 			}
 
 			char *Dot = strchr(Ls, '.');
 			if (Dot)
 			{
 				*Dot = 0;
 			}
 
-			ScribeFolder *Folder = ParentFolder->CreateSubDirectory(Ls, MAGIC_MAIL);
+			ScribeFolder *Folder = ParentFolder->CreateSubFolder(Ls, MAGIC_MAIL);
 			if (Folder)
 			{
 				// Skip unknown feilds
 				F.Seek(4 + 4 + 1 + 63, SEEK_CUR);
 
 				// Read the messages
 				for (int i=0; i<Msgs; i++)
 				{
 					int MsgStartPos = (int)F.GetPos();
 					
 					int MsgId = 0;
 					F >> MsgId;
 					int MsgNum = 0;
 					F >> MsgNum;
 					int MsgTotalSize = 0;
 					F >> MsgTotalSize;
 					int MsgTextSize;
 					F >> MsgTextSize;
 
 					// Create item
 					Mail *m = dynamic_cast<Mail*>(Parent->CreateItem(MAGIC_MAIL, Folder, false));
 					if (m)
 					{
 						LMemStream Text(&F, 0, MsgTextSize);
 
 						// Decode email into fields
 						m->OnAfterReceive(&Text);
 
 						m->SetFlags(MAIL_RECEIVED |
 									MAIL_READ |
 									((m->HasAttachments()) ? MAIL_ATTACHMENTS : 0) );
 					}
 
 					// Seek to the next message
 					F.Seek(MsgStartPos+MsgTotalSize, SEEK_SET);
 				}
 			}
 			else
 			{
 				return false;
 			}
 
 			return true;
 		}
 	}
 
 	return false;
 }
 
 #ifdef WIN32
 #pragma pack(push, 1)
 #endif
 class DbxMessagePtr
 {
 public:
 	uint MessagePos;
 	uint TablePos;
 	char Reserved[4];
 };
 
 // #define DbxTableSize 0x27c
 class DbxTable
 {
 public:
 	// Header
 	/*
 	uint FilePos;
 	char Reserved1[13];
 	uint Msgs;
 	char Reserved2[3];
 	*/
 
 	uint FilePos;
 	char Reserved1[4];
 	uint ListPtr;
 	uint NextPtr;
 	char Reserved2[8];
 };
 
 class DbxMsgTable
 {
 public:
 	uint FilePos;
 	uint MessageLength;
     char Reserved[17];
     uint FirstBlockPos;
 };
 
 class DbxMsgBlock
 {
 public:
 	/*
 	uint FilePos;
 	uint Flags;
     uint BlockSize;
     uint NextBlockPos;
 	*/
 
 	uint FilePos;
 	uint Increase;
     uint Include;
     uint Next;
 	uint UseNet;
 };
 
 #ifdef WIN32
 #pragma pack(pop)
 #endif
 
 class ImportDBX
 {
 private:
 	ScribeWnd *Parent = NULL;
 	ScribeFolder *ParentFolder = NULL;
 	LFile F;
 	uint64 FileSize = 0;
 	List<ssize_t> Used;
 	
 	class MsgInfo
 	{
 	public:
 		int Pos;
 		bool IsNews;
 
 		MsgInfo(int p, bool n)
 		{
 			Pos = p;
 			IsNews = n;
 		}
 	};
 	List<MsgInfo> MsgList;
 
 	bool IsUsed(ssize_t i)
 	{
 		for (auto n: Used)
 		{
 			if (*n == i) return true;
 		}
 		return false;
 	}
 
 	void SetUsed(ssize_t i)
 	{
 		if (!IsUsed(i))
 		{
 			Used.Insert(new ssize_t(i));
 		}
 	}
 
 	bool ReadMessage(ssize_t Pos, bool IsNews, ScribeFolder *Folder)
 	{
 		bool Status = false;
 		if (!IsUsed(Pos) &&
 			F.Seek(Pos, SEEK_SET))
 		{
 			LTempStream Text(ScribeTempPath());
 
 			SetUsed(Pos);
 
 			while (Pos > 0)
 			{
 				DbxMsgBlock Msg;
 				ZeroObj(Msg);
 				F.Read(&Msg, sizeof(Msg)-4);
 				if (Pos != Msg.FilePos)
 				{
 					break;
 				}
 
 				Pos += sizeof(Msg)-4;
 				// int Next = Pos + Msg.Next;
 				auto End = Pos + Msg.Include;
 
 				char Buf[1024];
 				while (Pos < End)
 				{
 					ssize_t R = F.Read(Buf, MIN(End-Pos, sizeof(Buf)));
 					Text.Write(Buf, R);
 					Pos += R;
 				}
 
 				F.Seek(Msg.Next, SEEK_SET);
 				Pos = Msg.Next;
 			}
 
 			Mail *m = new Mail(Parent);
 			if (m)
 			{
 				m->App = Parent;
 
 				m->OnAfterReceive(&Text);
 				m->SetFlags(MAIL_RECEIVED |
 							MAIL_READ |
 							// ((MsgTable.Reserved[3] == 3) ? MAIL_READ : 0) |
 							(m->GetAttachments(0) ? MAIL_ATTACHMENTS : 0));
 				m->SetDirty();
 				m->Save(Folder);
 				Status = true;
 			}
 		}
 
 		return Status;
 	}
 
 	bool ReadMsgHeader(int Pos)
 	{
 		bool Status = false;
 		if (!IsUsed(Pos) &&
 			F.Seek(Pos, SEEK_SET))
 		{
 			SetUsed(Pos);
 
 			DbxMsgBlock Msg;
 			F.Read(&Msg, sizeof(Msg));
 			if (Msg.FilePos == Pos)
 			{
 				Pos += sizeof(Msg);
 
 				int32 Self, MsgPos = 0, NewsPost = false, Count = 0;
 				do
 				{
 					F.Read(&Self, sizeof(Self));
 					if ((Self & 0xff) == 0x84)
 					{
 						if (!MsgPos)
 						{
 							MsgPos = Self >> 8;
 						}
 					}
 
 					if ((Self & 0xff) == 0x83)
 					{
 						NewsPost = true;
 					}
 					Count++;
 				}
 				while ((Self & 0x7f) > 0);
 
 				if (MsgPos)
 				{
 					MsgList.Insert(new MsgInfo(MsgPos, NewsPost != 0));
 					Status |= true;
 				}
 				else
 				{
 					F.Read(&Self, sizeof(Self));
 					F.Read(&MsgPos, sizeof(MsgPos));
 					MsgList.Insert(new MsgInfo(MsgPos, NewsPost != 0));
 					Status |= true;
 				}
 			}
 		}
 
 		return Status;
 	}
 
 	bool ReadTable(ssize_t Pos)
 	{
 		bool Status = false;
 
 		if (Pos > 0 &&
 			(uint64)Pos < FileSize &&
 			!IsUsed(Pos))
 		{
 			DbxTable Tbl;
 
 			F.Seek(Pos, SEEK_SET);
 			SetUsed(Pos);
 			F.Read(&Tbl, sizeof(Tbl));
 			if (Tbl.FilePos == Pos)
 			{
 				Pos += sizeof(Tbl);
 				Status |= ReadTable(Tbl.NextPtr);
 				Status |= ReadTable(Tbl.ListPtr);
 				F.Seek(Pos, SEEK_SET);
 
 				while (true)
 				{
 					bool Actioned = false;
 
 					DbxMessagePtr Node;
 					F.Seek(Pos, SEEK_SET);
 					Pos += F.Read(&Node, sizeof(Node));
 					if (Node.MessagePos > 0 &&
 						Node.MessagePos < FileSize &&
 						Node.MessagePos != Node.TablePos)
 					{
 						Actioned |= ReadMsgHeader(Node.MessagePos);
 					}
 
 					if (Node.TablePos > 0 &&
 						Node.TablePos < FileSize &&
 						Node.TablePos != Node.MessagePos)
 					{
 						Actioned |= ReadTable(Node.TablePos);
 					}
 
 					if (Actioned)
 					{
 						Status = true;
 					}
 					else break;
 				}
 			}
 		}
 
 		return Status;
 	}
 
 	void Clean()
 	{
 		Used.DeleteObjects();
 		MsgList.DeleteObjects();
 	}
 
 public:
 	ImportDBX(ScribeWnd *parent)
 	{
 		Parent = parent;
 		ParentFolder = 0;
 	}
 
 	~ImportDBX()
 	{
 		Clean();
 	}
 
 	bool Import(ScribeFolder *parentFolder, char *FileName)
 	{
 		Clean();
 		ParentFolder = parentFolder;
 		if (sizeof(DbxTable) != 24)
 		{
 			// packing is screwed
 			LgiMsg(Parent, "Compiled object 'DbxTable' is the wrong size", AppName, MB_OK);
 			return false;
 		}
 
 		LProgressDlg Dlg(Parent);
 		Dlg.SetDescription("Reading tables...");
 		Dlg.SetRange(1);
 		LProgressPane *Import = Dlg.Push();
 		if (Import)
 			Import->SetDescription("Importing messages...");
 
 		if (Parent &&
 			ParentFolder &&
 			FileName &&
 			F.Open(FileName, O_READ))
 		{
 			FileSize = F.GetSize();
 
 			// Create folder for these messages
 			char n[256];
 			strcpy_s(n, sizeof(n), FileName);
 			char *Ls = strrchr(n, DIR_CHAR); // last slash
 			if (Ls)
 			{
 				Ls++;
 				char *Dot = strchr(Ls, '.');
 				if (Dot)
 				{
 					*Dot = 0;
 				}
 				
 				// Make sure the path is unique, no overwriting previous folders
 				LStringPipe NewPath(256);
 				auto ParentPath = ParentFolder->GetPath();
 				NewPath.Print("/%s/%s", ParentPath.Get(), Ls);
 				auto BaseNewPath = NewPath.NewLStr();
 				LString NewPathStr = BaseNewPath.Get();
 
 				while (Parent->GetFolder(NewPathStr))
 				{
 					char *Num = NewPathStr.Get() + BaseNewPath.Length() - 1;
 					for (; Num>NewPathStr && IsDigit(*Num); Num--)
 						;
 					if (!IsDigit(*Num))
 						Num++;
 
 					int i = atoi(Num);
 					NewPath.Print("%s%i", BaseNewPath.Get(), i+1);
 					NewPathStr = NewPath.NewLStr();
 				}
 
 				// Create output folder
-				ScribeFolder *Folder = ParentFolder->CreateSubDirectory(Ls, MAGIC_MAIL);
+				ScribeFolder *Folder = ParentFolder->CreateSubFolder(Ls, MAGIC_MAIL);
 				if (Folder)
 				{
 					// Read header
 					F.Seek(0x30, SEEK_SET);
 					uint TableLoc;
 					F >> TableLoc;
 					if (!TableLoc) TableLoc = 0x1e254;
 					ReadTable(TableLoc);
 
 					// Import msg list
 					Dlg.Value(1);
 					if (Import)
 					{
 						Import->SetRange(MsgList.Length());
 						Import->SetType("Mail");
 					}
 					for (auto i: MsgList)
 					{
 						ReadMessage(i->Pos, i->IsNews, Folder);
 						if (Import)
 							Import->Value(Import->Value()+1);
 					}
 
 					/* 
 					List<int> Msgs;
 					while (Tbl)
 					{
 						int Pos = F.GetPosition();
 						F.Read(Tbl, DbxTableSize);
 						if (Tbl->FilePos == Pos)
 						{
 							for (int i=0; i<Tbl->Msgs; i++)
 							{
 								Msgs.Insert(new int(Tbl->Msg[i].MessagePos));
 							}
 						}			
 						if (Tbl->Msgs < 76 ||
 							Tbl->FilePos != Pos)
 						{
 							DeleteArray(Tbl);
 						}
 					}
 					*/
 
 					// Read in messages
 					/*
 					for (int *MsgPos = Msgs.First(); MsgPos; MsgPos = Msgs.Next())
 					{
 						bool Read = true;
 
 						DbxMsgTable MsgTable;
 						F.Seek(*MsgPos, SEEK_SET);
 						F.Read(&MsgTable, sizeof(MsgTable));
 						if (MsgTable.FilePos == *MsgPos)
 						{
 							// Read in blocks
 							GBytePipe Msg;
 							DbxMsgBlock MsgBlock;
 
 							MsgBlock.NextBlockPos = MsgTable.FirstBlockPos;
 							while (MsgBlock.NextBlockPos)
 							{
 								int SeekTo = MsgBlock.NextBlockPos & 0xFFFFFF;
 								F.Seek(SeekTo, SEEK_SET);
 								F.Read(&MsgBlock, sizeof(MsgBlock));
 
 								if (MsgBlock.FilePos == SeekTo)
 								{
 									uchar *Data = new uchar[MsgBlock.BlockSize];
 									if (Data)
 									{
 										F.Read(Data, MsgBlock.BlockSize);
 										Msg.Push(Data, MsgBlock.BlockSize);
 										DeleteArray(Data);
 									}
 								}
 							}
 
 							// Msg contains email...
 							int Size = Msg.Sizeof();
 							if (Size > 0)
 							{
 								Mail *m = dynamic_cast<Mail*>(Parent->CreateItem(MAGIC_MAIL, Folder, false));
 								if (m)
 								{
 									m->Text = new char[Size+1];
 									if (m->Text)
 									{
 										// Read data into item
 										Msg.Pop((uchar*) m->Text, Size);
 										m->Text[Size] = 0;
 
 										// Decode email into fields
 										m->OnAfterReceive();
 
 										m->SetFlags(MAIL_RECEIVED |
 													((MsgTable.Reserved[3] == 3) ? MAIL_READ : 0) |
 													((m->Store->GetChild() != 0) ? MAIL_ATTACHMENTS : 0));
 										
 										m->StoreDirty = true;
 									}
 								}
 							}
 						}
 					}
 					*/
 
 					return true;
 				}
 			}
 		}
 
 		return false;
 	}
 
 };
 
 struct ImportOe : public LProgressDlg
 {
 	ScribeWnd *App;
 	bool v5;
 	int Imported = 0, TotalFiles = 0;
 	LString Dir;
 	LArray<char*> Files;
 	LArray<const char*> Ext;
 	LString::Array FileArr;
 	ScribeFolder *Folder = NULL;
 
 	ImportOe(ScribeWnd *app, bool ver5) :
 		App(app),
 		v5(ver5),
 		LProgressDlg(app)
 	{
 		// Get the base directory
 		Dir = LGetSystemPath(LSP_LOCAL_APP_DATA);
 		if (!Dir)
 			// Just in case
 			Dir = LGetSystemPath(LSP_OS);
 	
 		// Search for the folder files
 		Ext.Add(v5 ? "*.dbx" : "*.mbx");
 
 		DoFileSearch();
 		if (Files.Length() == 0)
 		{
 			if (LgiMsg(	App,
 						"%i outlook express data files found in:\n"
 						"%s\n"
 						"Do you want to select a different directory to search?",
 						AppName,
 						MB_YESNO,
 						(int)Files.Length(),
 						Dir.Get()) == IDYES)
 			{
 				auto Select = new LFileSelect(App);
 				Select->OpenFolder([this](auto s, auto ok)
 				{
 					if (ok)
 					{
 						Dir = s->Name();
 						DoFileSearch();
 						ProcessFiles();
 					}
 					delete s;
 				});
 			}
 		}
 		else ProcessFiles();
 	}
 
 	void DoFileSearch()
 	{
 		LRecursiveFileSearch(Dir, &Ext, &Files);
 	}
 
 	void ProcessFiles()
 	{
 		if (Files.Length() == 0)
 			return;
 
 		// Strip files
 		for (unsigned i=0; i<Files.Length(); i++)
 		{
 			auto f = Files[i];
 			if (stristr(f, "Folders.") ||
 				stristr(f, "Pop3uidl.") ||
 				stristr(f, "Deleted Items."))
 			{
 				Files.DeleteAt(i);
 				DeleteArray(f);
 				i--;
 			}
 		}
 
 		FileArr.Length(0);
 		for (auto s: Files)
 			FileArr.New() = s;
 		Files.DeleteArrays();
 
 		// Ask the user where to put them..
 		auto Current = App->GetCurrentFolder();
 		LString CurrentPath;
 		if (Current)
 			CurrentPath = Current->GetPath();
 
 		auto Dlg = new ImportExportDlg(	App,
 										false,
 										AppName,
 										LLoadString(IDS_OE_IMPORT),
 										&FileArr,
 										CurrentPath,
 										MAGIC_MAIL);
 		Dlg->DoModal([this, Dlg](auto dlg, auto id)
 		{
 			LAutoPtr<LDialog> mem(dlg);
 
 			if (!id)
 				return;
 
 			ScribeFolder *Folder = App->GetFolder(Dlg->DestFolder);
 			if (!Folder)
 			{
 				LgiMsg(App, "Error locating that folder.", AppName, MB_OK);
 				return;
 			}
 
 			SetDescription("Importing folders...");
 			SetRange(FileArr.Length());
 
 			FileArr = Dlg->SrcFiles;
 			TotalFiles = (int)FileArr.Length();
 			
 			SetPulse(100); // Start processing... each timeout allows the message loop to run a bit
 		});
 	};
 
 	void OnFinished()
 	{
 		LgiMsg(	App,
 				"%i of %i %s files imported successfully.",
 				AppName,
 				MB_OK,
 				Imported,
 				TotalFiles,
 				(v5) ? (char*)"DBX" : (char*)"MBX");
 
 		delete this;
 	}
 
 	void OnPulse()
 	{
 		if (FileArr.Length())
 		{
 			auto FileName = FileArr.Last();
 			FileArr.PopLast();
 
 			if (v5)
 			{
 				ImportDBX Filter(App);
 				if (Filter.Import(Folder, FileName))
 					Imported++;
 			}
 			else
 			{
 				if (ImportMBX(App, Folder, FileName))
 					Imported++;
 			}
 
 			(*this)++; // inc progress bar...
 		}
 		else OnFinished();
 	}
 };
 
 void Import_OutlookExpress(ScribeWnd *Parent, bool v5)
 {
 	new ImportOe(Parent, v5);
 }
diff --git a/src/Scribe.h b/src/Scribe.h
--- a/src/Scribe.h
+++ b/src/Scribe.h
@@ -1,2584 +1,2589 @@
 /*hdr
 **      FILE:           Scribe.h
 **      AUTHOR:         Matthew Allen
 **      DATE:           22/10/97
 **      DESCRIPTION:    Scribe email application
 **
 **      Copyright (C) 1998-2003 Matthew Allen
 **              fret@memecode.com
 */
 
 // Includes
 #include <stdio.h>
 #include <functional>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DragAndDrop.h"
 #include "lgi/common/DateTime.h"
 #include "lgi/common/Password.h"
 #include "lgi/common/vCard-vCal.h"
 #include "lgi/common/WordStore.h"
 #include "lgi/common/SharedMemory.h"
 #include "lgi/common/XmlTreeUi.h"
 #include "lgi/common/Mime.h"
 #include "lgi/common/OptionsFile.h"
 #include "lgi/common/TextLog.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/ToolBar.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Printer.h"
 
 // Gui controls
 #include "lgi/common/Panel.h"
 #include "lgi/common/DocView.h"
 #include "lgi/common/List.h"
 #include "lgi/common/Tree.h"
 #include "lgi/common/ListItemCheckBox.h"
 
 // Storage
 #include "lgi/common/Store3.h"
 
 // App Includes
 #include "ScribeInc.h"
 #include "ScribeUtils.h"
 #include "ScribeDefs.h"
 #include "DomType.h"
 
 class ListAddr;
 
 // The field definition type
 struct ItemFieldDef
 {
 	const char *DisplayText;
 	ScribeDomType Dom;
 	LVariantType Type;
 	int FieldId; // Was 'Id'
 	int CtrlId;
 	const char *Option;
 	bool UtcConvert;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Classes
 class MailTree;
 class LMailStore;
 class ScribeWnd;
 class Thing;
 class Mail;
 class Contact;
 class ThingUi;
 class MailUi;
 class ScribeFolder;
 class ContactUi;
 class FolderPropertiesDlg;
 class ScribeAccount;
 class Filter;
 class Attachment;
 class Calendar;
 class CalendarSource;
 
 class AttachmentList;
 struct ItemFieldDef;
 class FolderDlg;
 class Filter;
 class ContactGroup;
 class ScribeBehaviour;
 class AccountletThread;
 class ThingList;
 class LSpellCheck;
 
 ////////////////////////////////////////////////////////////////////////
 // Scripting support
 #include "lgi/common/Scripting.h"
 
 /// Script callback types. See 'api.html' in the Scripts folder for more details.
 enum LScriptCallbackType
 {
 	LCallbackNull,
 	LToolsMenu,
 	LThingContextMenu,
 	LThingUiToolbar,
 	LApplicationToolbar,
 	LMailOnBeforeSend, // "OnBeforeMailSend"
 	LMailOnAfterReceive,
 	LBeforeInstallBar,
 	LInstallComponent,
 	LFolderContextMenu,
 	LOnTimer,
 	LRenderMail,
 	LOnLoad
 };
 
 struct LScript;
 struct LScriptCallback
 {
 	LScriptCallbackType Type = LCallbackNull;
 	LScript *Script = NULL;
 	LFunctionInfo *Func = NULL;
 	int Param = 0;
 	double fParam = 0.0;
 	LVariant Data;
 	uint64 PrevTs = 0;
 	bool OnSecond = false;
 };
 
 struct LScript
 {
 	LAutoPtr<LCompiledCode> Code;
 	LArray<LScriptCallback> Callbacks;
 };
 
 typedef void (*ConsoleClosingCallback)(class LScriptConsole *Console, void *user_data);
 
 class LScriptConsole : public LWindow
 {
 	ScribeWnd *App;
 	LTextLog *Txt;
 	ConsoleClosingCallback Callback;
 	void *CallbackData;
 
 	bool OnViewKey(LView *v, LKey &k);
 
 public:
 	LScriptConsole(ScribeWnd *app, ConsoleClosingCallback callback, void *callback_data);
 	~LScriptConsole();
 
 	void Write(const char *s, int64 Len);
 	bool OnRequestClose(bool OsShuttingDown);
 };
 
 /// This class is a wrapper around a user interface element used for
 /// Scripting. The script engine needs to be able to store information 
 /// pertaining to the menu item's callbacks along with the sub menu.
 class LScriptUi : public LDom
 {
 public:
 	LScriptUi *Parent;
 	LSubMenu *Sub;
 	LToolBar *Toolbar;
 	LArray<LScriptCallback> Callbacks;
 	LArray<LScriptUi*> Subs;
 
 	LScriptUi()
 	{
 		Parent = 0;
 		Sub = 0;
 		Toolbar = 0;
 	}
 
 	LScriptUi(LSubMenu *s)
 	{
 		Parent = 0;
 		Toolbar = 0;
 		Sub = s;
 	}
 
 	LScriptUi(LToolBar *t)
 	{
 		Parent = 0;
 		Toolbar = t;
 		Sub = 0;
 	}
 
 	~LScriptUi()
 	{
 		Subs.DeleteObjects();
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Arr = NULL) override
 	{
 		if (Sub)
 			return Sub->GetVariant(Name, Value, Arr);
 
 		LDomProperty Method = LStringToDomProp(Name);
 		if (Method == ObjLength)
 		{
 			if (Toolbar)
 				Value = (int64)Toolbar->Length();
 		}
 		else return false;
 
 		return true;
 	}
 
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override
 	{
 		if (Sub)
 			return Sub->CallMethod(MethodName, ReturnValue, Args);
 
 		return false;
 	}
 
 	bool SetupCallbacks(ScribeWnd *App, ThingUi *Parent, Thing *t, LScriptCallbackType Type);
 	bool ExecuteCallbacks(ScribeWnd *App, ThingUi *Parent, Thing *t, int Cmd);
 };
 
 class LScribeScript : public LScriptContext
 {
 	LScriptEngine *Eng;
 	struct LScribeScriptPriv *d;
 
 public:
 	ScribeWnd *App;
 
 	static LScribeScript *Inst;
 
 	LScribeScript(ScribeWnd *app);
 	~LScribeScript();
 
 	void ShowScriptingWindow(bool show);
 	LAutoString GetDataFolder() override;
 	LStream *GetLog() override;
 	LHostFunc *GetCommands() override;	
 	LString GetIncludeFile(const char *FileName) override;
 
 	// System
 	void SetEngine(LScriptEngine *eng);
 	bool MsgBox(LScriptArguments &Args);
 
 	// Paths
 	bool GetSystemPath(LScriptArguments &Args);
 	bool GetScribeTempPath(LScriptArguments &Args);
 	bool JoinPath(LScriptArguments &Args);
 
 	// Folders
 	bool GetFolder(LScriptArguments &Args);
 	bool GetSourceFolders(LScriptArguments &Args);
 	bool CreateSubFolder(LScriptArguments &Args);
 	bool LoadFolder(LScriptArguments &Args);
 	bool FolderSelect(LScriptArguments &Args);
 	bool BrowseFolder(LScriptArguments &Args);
 
 	// Things
 	bool CreateThing(LScriptArguments &Args);
 	bool MoveThing(LScriptArguments &Args);
 	bool SaveThing(LScriptArguments &Args);
 	bool DeleteThing(LScriptArguments &Args);
 	bool ShowThingWindow(LScriptArguments &Args);
 	bool FilterDoActions(LScriptArguments &Args);
 	bool LookupContact(LScriptArguments &Args);
 
 	// Callbacks
 	bool AddToolsMenuItem(LScriptArguments &Args);
 	bool AddCallback(LScriptArguments &Args);
 
 	// UI
 	bool MenuAddItem(LScriptArguments &Args);
 	bool MenuAddSubmenu(LScriptArguments &Args);
 	bool ToolbarAddItem(LScriptArguments &Args);
 };
 
 ////////////////////////////////////////////////////////////////////////
 class ScribePassword
 {
 	class ScribePasswordPrivate *d;
 
 public:
 	ScribePassword(LOptionsFile *p, const char *opt, int check, int pwd, int confirm);
 	~ScribePassword();
 
 	bool IsOk();
 	bool Load(LView *dlg);
 	bool Save();
 	void OnNotify(LViewI *c, LNotification &n);
 };
 
 
 class ImportExportDlg : public LDialog
 {
     ScribeWnd *App = NULL;
 	int Type = 0;
 	bool Export = false;
 	LList *Src = NULL;
 	LEdit *Dst = NULL;
 
 	void InsertFile(const char *f);
 
 public:
 	LString DestFolder;
 	LString::Array SrcFiles;
 	bool IncSubFolders = false;
 
 	ImportExportDlg
 	(
 		ScribeWnd *parent,
 		bool IsExport,
 		const char *Title,
 		const char *Msg,
 		LString::Array *SrcFiles = NULL,
 		const char *DefFolder = NULL,
 		int FolderType = MAGIC_MAIL
 	);
 
 	int OnNotify(LViewI *Ctrl, LNotification n);
 };
 
 #define IoProgressImplArgs		LAutoPtr<LStreamI> stream, const char *mimeType, IoProgressCallback cb
 #define IoProgressFnArgs		IoProgressImplArgs = NULL
 #define IoProgressError(err)	\
 	{ \
 		IoProgress p(Store3Error, err); \
 		if (cb) cb(&p, stream); \
 		return p; \
 	}
 #define IoProgressSuccess()	\
 	{ \
 		IoProgress p(Store3Success); \
 		if (cb) cb(&p, stream); \
 		return p; \
 	}
 #define IoProgressNotImpl()	\
 	{ \
 		IoProgress p(Store3NotImpl); \
 		if (cb) cb(&p, stream); \
 		return p; \
 	}
 
 class ScribeClass ThingType :
 	public LDom,
 	public LDataUserI
 {
 	bool Dirty     = false;
 	bool WillDirty = true;
 	bool Loaded    = false;
 
 protected:
 	bool OnError(const char *File, int Line)
 	{
 		_lgi_assert(false, "Object Missing", File, Line);
 		return false;
 	}
 
 	// Callbacks
 	struct ThingEventInfo
 	{
 		const char *File = NULL;
 		int Line = 0;
 		std::function<void()> Callback;
 	};
 	LArray<ThingEventInfo*> OnLoadCallbacks;
 
 public:
 	#ifdef _DEBUG
 	bool _debug = false;
 	#endif
 
 	struct IoProgress;
 	typedef std::function<void(IoProgress*,LStreamI*)> IoProgressCallback;
 	struct IoProgress
 	{
 		// This is the main result to look at:
 		//		Store3NotImpl - typically means the mime type is wrong.
-		//		Store3Error - an error occured.
+		//		Store3Error - an error occurred.
 		//		Store3Delayed - means the operation will take a long time.
 		//			However progress is report via 'prog' if not NULL.
 		//			And the 'onComplete' handler will be called at the end.
 		//		Store3Success - the operation successfully completed.
 		Store3Status status = Store3NotImpl;
 		
 		// Optional progress for the operation. Really only relevant for
 		// status == Store3Delayed.
 		Progress *prog = NULL;
 		
 		// Optional error message for the operation. Relevant if
 		// status == Store3Error.
 		LString errMsg;
 		
 		IoProgress(Store3Status s, const char *err = NULL)
 		{
 			status = s;
 			if (err)
 				errMsg = err;
 		}
 		
 		operator bool()
 		{
 			return status > Store3Error;
 		}
+
+		bool IsCancelled()
+		{
+			return prog ? prog->IsCancelled() : false;
+		}
 	};
 	
 	template<typename T>
 	LAutoPtr<LStreamI> AutoCast(LAutoPtr<T> ap)
 	{
 		return LAutoPtr<LStreamI>(ap.Release());
 	}
 
 	static LArray<ThingType*> DirtyThings;
 	ScribeWnd *App = NULL;
 
 	ThingType();
 	virtual ~ThingType();
 
 	virtual Store3ItemTypes Type() { return MAGIC_NONE; }
 	bool GetDirty() { return Dirty; }
 	virtual bool SetDirty(bool b = true);
 	void SetWillDirty(bool c) { WillDirty = c; }
 
 	virtual bool Save(ScribeFolder *Into) { return false; }
 	virtual void OnProperties(int Tab = -1) {}
 	virtual ScribeFolder *GetFolder() = 0;
 	virtual Store3Status SetFolder(ScribeFolder *f, int Param = -1) = 0;
 	virtual bool IsPlaceHolder() { return false; }
 
 	// Events
 	void WhenLoaded(const char *file, int line, std::function<void()> Callback, int index = -1);
 	bool IsLoaded(int Set = -1);
 
 	// Printing
 	virtual void OnPrintHeaders(struct ScribePrintContext &Context) { LAssert(!"Impl me."); }
 	virtual void OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages) { LAssert(!"Impl me."); }
 	virtual int OnPrintHtml(ScribePrintContext &Context, LPrintPageRanges &Pages, LSurface *RenderedHtml) { LAssert(!"Impl me."); return 0; }
 };
 
 class MailContainerIter;
 class ScribeClass MailContainer
 {
 	friend class MailContainerIter;
 
 	List<MailContainerIter> Iters;
 
 public:
 	virtual ~MailContainer();
 
 	virtual size_t Length() { return 0; }
 	virtual ssize_t IndexOf(Mail *m) { return -1; }
 	virtual Mail *operator [](size_t i) { return NULL; }
 };
 
 class ScribeClass MailContainerIter
 {
 	friend class MailContainer;
 
 protected:
 	MailContainer *Container;
 
 public:
 	MailContainerIter();
 	~MailContainerIter();
 
 	void SetContainer(MailContainer *c);
 };
 
 class ScribeClass ThingStorage // External storage information
 {
 public:
 	int Data;
 
 	ThingStorage() { Data = 0; }
 	virtual ~ThingStorage() {}
 };
 
 class ThingUi;
 
 class ScribeClass Thing :
 	public ThingType,
 	public LListItem,
 	public LDragDropSource,
 	public LRefCount
 {
 	friend class ScribeWnd;
 	friend class ScribeFolder;
 
 	ScribeFolder *_ParentFolder = NULL;
 
 protected:
 	LArray<int> FieldArray;
 	LAutoString DropFileName;
 
 	// This structure allows the app to move objects between
 	// mail stores. After a delayed write to the new mail store
 	// the old item needs to be removed. This keeps track of
 	// where that old item is. Don't assume that the Obj pointer
 	// is valid... check in the folder's items first.
 	struct ThingReference
 	{
 		LString Path;
 		Thing *Obj;
 
 		ThingReference()
 		{
 			Obj = NULL;
 		}
 	}	DeleteOnAdd;
 
 public:
 	ThingStorage *Data = NULL;
 
 	Thing(ScribeWnd *app, LDataI *object = 0);
 	~Thing();
 
 	// Dom
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// D'n'd
 	bool GetData(LArray<LDragData> &Data) override;
 	bool GetFormats(LDragFormats &Formats) override;
 	bool OnBeginDrag(LMouse &m) override;
 
 	// Import / Export
 	virtual bool GetFormats(bool Export, LString::Array &MimeTypes) { return false; }
 
 	// Anything implementing 2 functions should mostly be using one of these 
 	// to "return" an IoProgress and process any callback:
 	//		IoProgressError(msg)
 	//		IoProgressNotImpl()
 	//		IoProgressSuccess()
 	virtual IoProgress Import(IoProgressFnArgs) = 0;
 	virtual IoProgress Export(IoProgressFnArgs) = 0;
 	
 	/// This exports all the selected items
 	void ExportAll(LViewI *Parent, const char *ExportMimeType, std::function<void(bool)> Callback);
 
 	// UI
 	bool OnKey(LKey &k) override;
 
 	// Thing
 	ScribeFolder *GetFolder() override { return _ParentFolder; }
 	void SetParentFolder(ScribeFolder *f);
 	Store3Status SetFolder(ScribeFolder *f, int Param = -1) override;
 	LDataI *DefaultObject(LDataI *arg = 0);
 
 	virtual ThingUi *DoUI(MailContainer *c = 0) { return NULL; }
 	virtual ThingUi *GetUI() { return 0; }
 	virtual bool SetUI(ThingUi *ui = 0) { return false; }
 
 	virtual uint32_t GetFlags() { return 0; }
 	virtual void OnCreate() override;
 	virtual bool OnDelete();
 	virtual int *GetDefaultFields() { return 0; }
 	virtual const char *GetFieldText(int Field) { return 0; }
 	virtual void DoContextMenu(LMouse &m, LView *Parent = 0) {}
 	virtual Thing &operator =(Thing &c) { LAssert(0); return *this; }
 	virtual char *GetDropFileName() = 0;
 	virtual bool GetDropFiles(LString::Array &Files) { return false; }
 	virtual void OnSerialize(bool Write) {}
 	virtual void Reparse();
 
 	// Interfaces
 	virtual Mail *IsMail() { return 0; }
 	virtual Contact *IsContact() { return 0; }
 	virtual ContactGroup *IsGroup() { return 0; }
 	virtual Filter *IsFilter() { return 0; }
 	virtual Attachment *IsAttachment() { return 0; }
 	virtual Calendar *IsCalendar() { return 0; }
 
 	void SetFieldArray(LArray<int> &i) { FieldArray = i; }
 	void OnMove();
 
 	bool SetField(int Field, int n);
 	bool SetField(int Field, double n);
 	bool SetField(int Field, char *n);
 	bool SetField(int Field, LDateTime &n);
 	bool SetDateField(int Field, LVariant &v);
 
 	bool GetField(int Field, int &n);
 	bool GetField(int Field, double &n);
 	bool GetField(int Field, const char *&n);
 	bool GetField(int Field, LDateTime &n);
 	bool GetDateField(int Field, LVariant &v);
 
 	bool DeleteField(int Field);
 };
 
 class ThingUi : public LWindow
 {
 	friend class MailUiGpg;
 
 	bool _Dirty;
 	char *_Name;
 
 protected:
 	Thing *_Item;
 	bool _Running;
 	void SetItem(Thing *i) { _Item = i; }
 
 public:
 	ScribeWnd *App;
 	static LArray<ThingUi*> All;
 
 	ThingUi(Thing *item, const char *name);
 	~ThingUi();
 
 	virtual bool SetDirty(bool d, bool ui = true);
 	bool IsDirty() { return _Dirty; }
 	bool OnRequestClose(bool OsShuttingDown);
 	bool OnViewKey(LView *v, LKey &k);
 
 	virtual void OnDirty(bool Dirty) {}
 	virtual void OnLoad() = 0;
 	virtual void OnSave() = 0;
 	virtual void OnChange() {}
 	virtual AttachmentList *GetAttachments() { return 0; }
 	virtual bool AddRecipient(AddressDescriptor *Addr) { return false; }
 };
 
 class ThingFilter
 {
 public:
 	virtual bool TestThing(Thing *Thing) = 0;
 };
 
 class ScribeClass Attachment : public Thing
 {
 	friend class Mail;
 
 protected:
 	Mail *Msg;
 	Mail *Owner;
 	bool IsResizing;
 	LString Buf;
 
 	// D'n'd
 	LAutoString DropSourceFile;
 	bool GetFormats(LDragFormats &Formats) override;
 	bool GetData(LArray<LDragData> &Data) override;
 
 	void _New(LDataI *object);
 
 public:
 	enum Encoding
 	{
 		OCTET_STREAM,
 		PLAIN_TEXT,
 		BASE64,
 		QUOTED_PRINTABLE,
 	};	
 	
 	Attachment(ScribeWnd *App, Attachment *import = 0);
 	Attachment(ScribeWnd *App, LDataI *object, const char *import = 0);
 	~Attachment();
 
 	bool ImportFile(const char *FileName);
 	bool ImportStream(const char *FileName, const char *MimeType, LAutoStreamI Stream);
 
 	Thing &operator =(Thing &c) override;
 
 	LDATA_INT64_PROP(Size, FIELD_SIZE);
 	LDATA_STR_PROP(Name, FIELD_NAME);
 	LDATA_STR_PROP(MimeType, FIELD_MIME_TYPE);
 	LDATA_STR_PROP(ContentId, FIELD_CONTENT_ID);
 	LDATA_STR_PROP(Charset, FIELD_CHARSET);
 	LDATA_STR_PROP(InternetHeaders, FIELD_INTERNET_HEADER);
 
 	// LDom support
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *Ret, LArray<LVariant*> &Args) override;
 
 	void OnOpen(LView *Parent, char *Dest = 0);
 	void OnDeleteAttachment(LView *Parent, bool Ask);
 	void OnSaveAs(LView *Parent);
 	void OnMouseClick(LMouse &m) override;
 	bool OnKey(LKey &k) override;
 
 	Store3ItemTypes Type() override { return MAGIC_ATTACHMENT; }
 	bool Get(char **ptr, ssize_t *size);
 	bool Set(char *ptr, ssize_t size);
 	bool Set(LAutoStreamI Stream);
 	Attachment *IsAttachment() override { return this; }
 	LAutoString MakeFileName();
 	bool GetIsResizing();
 	void SetIsResizing(bool b);
 	bool IsMailMessage();
 	bool IsVCalendar();
 	bool IsVCard();
 
 	// The owner is the mail that this is attached to
 	Mail *GetOwner() { return Owner; }
 	void SetOwner(Mail *msg);
 
 	// The msg is the mail that this message/rfc822 attachment is rendered into
 	Mail *GetMsg();
 	void SetMsg(Mail *m);
 
 	LStreamI *GotoObject(const char *file, int line);
 	IoProgress Import(IoProgressFnArgs) override { return Store3Error; }
 	IoProgress Export(IoProgressFnArgs) override { return Store3Error; }
 
 	bool SaveTo(char *FileName, bool Quite = false, LView *Parent = 0);
 
 	const char *GetText(int i) override;
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 };
 
 class ScribeClass Contact :
 	public Thing
 {
 	friend class ContactUi;
 
 protected:
 	class ContactPriv *d = NULL;
 	ContactUi *Ui = NULL;
 
 public:
 	static List<Contact> Everyone;
 	static Contact *LookupEmail(const char *Email);
 	static LHashTbl<ConstStrKey<char,false>, int> PropMap;
 	static int DefaultContactFields[];
 
 	Contact(ScribeWnd *app, LDataI *object = 0);
 	~Contact();
 
 	LDATA_STR_PROP(First, FIELD_FIRST_NAME);
 	LDATA_STR_PROP(Last, FIELD_LAST_NAME);
 	LDATA_STR_PROP(Email, FIELD_EMAIL);
 
 	bool Get(const char *Opt, const char *&Value);
 	bool Set(const char *Opt, const char *Value);
 	bool Get(const char *Opt, int &Value);
 	bool Set(const char *Opt, int Value);
 
 	// operators
 	Thing &operator =(Thing &c) override;
 	Contact *IsContact() override { return this; }
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = 0) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = 0) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Events
 	void OnMouseClick(LMouse &m) override;
 
 	// Printing
 	void OnPrintHeaders(struct ScribePrintContext &Context) override;
 	void OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages) override;
 
 	// Misc
 	Store3ItemTypes Type() override { return MAGIC_CONTACT; }
 	ThingUi *DoUI(MailContainer *c = 0) override;
 	int Compare(LListItem *Arg, ssize_t Field) override;
 	bool IsAssociatedWith(char *PluginName);
 	char *GetLocalTime(const char *TimeZone = 0);
 	
 	// Email address
 	int GetAddrCount();
 	LString::Array GetEmails();
 	LString GetAddrAt(int i);
 	bool HasEmail(LString email);
 
 	// Serialization
 	bool Save(ScribeFolder *Into = 0) override;
 
 	// ListItem
 	const char *GetText(int i) override;
 	int *GetDefaultFields() override;
 	const char *GetFieldText(int Field) override;
 	int GetImage(int Flags = 0) override { return ICON_CONTACT; }
 
 	// Import/Export
 	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
 	IoProgress Import(IoProgressFnArgs) override;
 	IoProgress Export(IoProgressFnArgs) override;
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 };
 
 #define ContactGroupObj					"ContactGroup"
 #define ContactGroupName				"Name"
 #define ContactGroupList				"List"
 #define ContactGroupDateModified		"DateModified"
 extern ItemFieldDef GroupFieldDefs[];
 
 class ContactGroup : public Thing
 {
 	friend class GroupUi;
 	class GroupUi *Ui;
 	class ContactGroupPrivate *d;
 	LString DateCache;
 
 public:
 	LDateTime UsedTs;
 
 	LDATA_STR_PROP(Name, FIELD_GROUP_NAME);	
 
 	ContactGroup(ScribeWnd *app, LDataI *object = 0);
 	~ContactGroup();
 
 	// operators
 	Thing &operator =(Thing &c) override;
 	ContactGroup *IsGroup() override { return this; }
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Events
 	void OnMouseClick(LMouse &m) override;
 	void OnSerialize(bool Write) override;
 
 	// Misc
 	Store3ItemTypes Type() override { return MAGIC_GROUP; }
 	ThingUi *DoUI(MailContainer *c = 0) override;
 	int Compare(LListItem *Arg, ssize_t Field) override;
 	bool GetAddresses(List<char> &a);
 	LString::Array GetAddresses();
 
 	// Serialization
 	bool Save(ScribeFolder *Into = 0) override;
 
 	// ListItem
 	const char *GetText(int i) override;
 	int *GetDefaultFields() override;
 	const char *GetFieldText(int Field) override;
 	int GetImage(int Flags = 0) override { return ICON_CONTACT_GROUP; }
 
 	// Import / Export
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
 	IoProgress Import(IoProgressFnArgs) override;
 	IoProgress Export(IoProgressFnArgs) override;
 };
 
 struct LGroupMapArray : public LArray<ContactGroup*>
 {
 	LString toString()
 	{
 		LString::Array a;
 		for (auto i: *this)
 			a.Add(i->GetName());
 		return LString(",").Join(a);
 	}
 };
 
 class LGroupMap : public LHashTbl<ConstStrKey<char,false>,LGroupMapArray*>
 {
 	ScribeWnd *App;
 
 	void Index(ContactGroup *grp);
 
 public:
 	LGroupMap(ScribeWnd *app);
 	~LGroupMap();
 };
 
 
 /////////////////////////////////////////////////////////////
 // Mail threading
 //
 //    See: http://www.jwz.org/doc/threading.html
 struct ThingSortParams
 {
 	int SortAscend;
 	int SortField;
 };
 
 class MContainer
 {
 	int			Lines;
 	int			Depth;
 	bool		Open;
 	bool		Next;
 
 	void Dump(LStream &s, int Depth = 0);
 
 public:
     typedef LHashTbl<StrKey<char>, MContainer*> ContainerHash;
 
 	// Container data
 	Mail		*Message;
 	MContainer	*Parent;
 	LArray<MContainer*> Children;
 	List<MContainer> Refs;
 	int			Index;
 
 	// Cache data
 	LString::Array RefCache;
 	
 	// Debug
 	#ifdef _DEBUG
 	LAutoString MsgId;
 	#endif
 
 	// Methods
 	MContainer(const char *Id, Mail *m = 0);
 	~MContainer();
 
 	void SetMail(Mail *m);
 	Mail *GetTop();
 
 	bool HasChild(MContainer *m);
 	void AddChild(MContainer *m);
 	void RemoveChild(MContainer *m);
 	int CountMessages();
 	
 	void Pour(int &index, int depth, int tree, bool next, ThingSortParams *folder);
 	void OnPaint(LSurface *pDC, LRect &r, LItemColumn *c, LColour Fore, LColour Back, LFont *Font, const char *Txt);
 
 	static void Prune(int &ParentIndex, LArray<MContainer*> &L);
 	static void Thread(List<Mail> &In, LArray<MContainer*> &Out);
 };
 
 extern int ListItemCompare(LListItem *a, LListItem *b, NativeInt Data);
 extern int ContainerIndexer(Thing *a, Thing *b, NativeInt Data);
 extern int GetFolderVersion(const char *Path);
 extern bool CreateMailHeaders(ScribeWnd *App, LStream &Out, LDataI *Mail, MailProtocol *Protocol);
 extern void Base36(char *Out, uint64 In);
 
 ////////////////////////////////////////////////////////////
 // Thing sorting
 
 // The old way
 extern int ContainerCompare(MContainer **a, MContainer **b);
 extern int ThingCompare(Thing *a, Thing *b, NativeInt Data);
 
 // The new way
 extern int ContainerSorter(MContainer *&a, MContainer *&b, ThingSortParams *Params);
 extern int ThingSorter(Thing *a, Thing *b, ThingSortParams *Data);
 
 /////////////////////////////////////////////////////////////
 class MailViewOwner : public LCapabilityTarget
 {
 public:
     virtual LDocView *GetDoc(const char *MimeType) = 0;
     virtual bool SetDoc(LDocView *v, const char *MimeType) = 0;
 };
 
 /////////////////////////////////////////////////////////////
 // The core mail object
 struct MailPrintContext;
 
 class ScribeClass Mail :
 	public Thing,
 	public MailContainer,
 	public LDefaultDocumentEnv
 {
 	friend class MailUi;
 	friend class MailPropDlg;
 	friend class ScribeFolder;
 	friend class Attachment;
 	friend class ScribeWnd;
 
 private:
 	class MailPrivate *d;
 	static LHashTbl<ConstStrKey<char>,Mail*> MessageIdMap;
 
 	// List item preview
 	int PreviewCacheX;
 	List<LDisplayString> PreviewCache;
 	
 	int64_t TotalSizeCache;
 	int64_t FlagsCache;
 	MailUi *Ui;
 	int Cursor; // Stores the cursor position in reply/forward format until the UI needs it
 	Attachment *ParentFile;
 	List<Attachment> Attachments;
 	Mail *PreviousMail; // the mail we are replying to / forwarding
 
 	void _New();
 	void _Delete();
 	bool _GetListItems(List<LListItem> &l, bool All); // All=false is just the selected items
 	void SetListRead(bool Read);
 	void SetFlagsCache(int64_t NewFlags, bool IgnoreReceipt, bool UpdateScreen);
 
 	// LDocumentEnv impl
 	List<Filter> Actions;
 	bool OnNavigate(LDocView *Parent, const char *Uri) override;
 	bool AppendItems(LSubMenu *Menu, const char *Param, int Base = 1000) override;
 	bool OnMenu(LDocView *View, int Id, void *Context) override;
 	LoadType GetContent(LoadJob *&j) override;
 
 public:
 	static bool PreviewLines;
 	static bool AdjustDateTz;
 	static int DefaultMailFields[];
 	static bool RunMailPipes;
 	static List<Mail> NewMailLst;
 	constexpr static float MarkColourMix = 0.9f;
 
 	uint8_t SendAttempts;
 	
 	enum NewEmailState
 	{
 		NewEmailNone,
 		NewEmailLoading,
 		NewEmailFilter,
 		NewEmailBayes,
 		NewEmailGrowl,
 		NewEmailTray
 	};
 	
 	NewEmailState NewEmail;
 
 	Mail(ScribeWnd *app, LDataI *object = 0);
 	~Mail();
 
 	bool SetObject(LDataI *o, bool InDataDestuctor, const char *File, int Line) override;
 
 	LDATA_STR_PROP(Label, FIELD_LABEL);
 	LDATA_STR_PROP(FwdMsgId, FIELD_FWD_MSG_ID);
 	LDATA_STR_PROP(BounceMsgId, FIELD_BOUNCE_MSG_ID);
 	LDATA_STR_PROP(Subject, FIELD_SUBJECT);
 	LDATA_STR_PROP(Body, FIELD_TEXT);
 	LDATA_STR_PROP(BodyCharset, FIELD_CHARSET);
 	LDATA_STR_PROP(Html, FIELD_ALTERNATE_HTML);
 	LDATA_STR_PROP(HtmlCharset, FIELD_HTML_CHARSET);
 	LDATA_STR_PROP(InternetHeader, FIELD_INTERNET_HEADER);
 	LDATA_INT_TYPE_PROP(EmailPriority, Priority, FIELD_PRIORITY, MAIL_PRIORITY_NORMAL);
 	LDATA_INT32_PROP(AccountId, FIELD_ACCOUNT_ID);
 	LDATA_INT64_PROP(MarkColour, FIELD_COLOUR);
 	LDATA_STR_PROP(References, FIELD_REFERENCES);
 	LDATA_DATE_PROP(DateReceived, FIELD_DATE_RECEIVED);
 	LDATA_DATE_PROP(DateSent, FIELD_DATE_SENT);
 	LDATA_INT_TYPE_PROP(Store3State, Loaded, FIELD_LOADED, Store3Loaded);
 	LVariant GetServerUid();
 	bool SetServerUid(LVariant &v);
 
 	const char *GetFromStr(int id)
 	{
 		LDataPropI *From = GetObject() ? GetObject()->GetObj(FIELD_FROM) : 0;
 		return From ? From->GetStr(id) : NULL;
 	}
 
 	LDataPropI *GetFrom()
 	{
 		return GetObject() ? GetObject()->GetObj(FIELD_FROM) : 0;
 	}
 
 	LDataPropI *GetReply()
 	{
 		return GetObject() ? GetObject()->GetObj(FIELD_REPLY) : 0;
 	}
 
 	LDataIt GetTo()
 	{
 		return GetObject() ? GetObject()->GetList(FIELD_TO) : 0;
 	}
 
 	bool GetAttachmentObjs(LArray<LDataI*> &Objs);
 	LDataI *GetFileAttachPoint();
 
 	// Operators
 	Mail *IsMail() override { return this; }
 	Thing &operator =(Thing &c) override;
 	OsView Handle();
 	ThingUi *GetUI() override;
 	bool SetUI(ThingUi *ui) override;
 
 	// References and ID's
 	MContainer *Container;
 	const char *GetMessageId(bool Create = false);
 	bool SetMessageId(const char *val);
 	LAutoString GetThreadIndex(int TruncateChars = 0);
 	
 	static Mail *GetMailFromId(const char *Id);
 	bool MailMessageIdMap(bool Add = true);
 	bool GetReferences(LString::Array &Ids);
 	void GetThread(List<Mail> &Thread);
 	LString GetMailRef();
 	bool ResizeImage(Attachment *a);
 
 	// MailContainer
 	size_t Length() override;
 	ssize_t IndexOf(Mail *m) override;
 	Mail *operator [](size_t i) override;
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Events
 	void OnCreate() override;
 	bool OnBeforeSend(struct ScribeEnvelope *Out);
 	void OnAfterSend();
 	bool OnBeforeReceive();
 	bool OnAfterReceive(LStreamI *Msg);
 	void OnMouseClick(LMouse &m) override;
 	void OnProperties(int Tab = -1) override;
 	void OnInspect();
 	void OnReply(Mail *m, bool All, bool MarkOriginal);
 	bool OnForward(Mail *m, bool MarkOriginal, int WithAttachments = -1);
 	bool OnBounce(Mail *m, bool MarkOriginal, int WithAttachments = -1);
 	void OnReceipt(Mail *m);
 	int OnNotify(LViewI *Ctrl, LNotification n) override;
 
 	// Printing
 	void OnPrintHeaders(ScribePrintContext &Context) override;
 	void OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages) override;
 	int OnPrintHtml(ScribePrintContext &Context, LPrintPageRanges &Pages, LSurface *RenderedHtml) override;
 
 	// Misc	
 	uint32_t GetFlags() override;
 	void SetFlags(ulong i, bool IgnoreReceipt = false, bool Update = true);
 	void DeleteAsSpam(LView *View);
 	const char *GetFieldText(int Field) override;
 	LAutoString GetCharSet();
 	char *GetNewText(int Max = 64 << 10, const char *AsCp = "utf-8");
 	int *GetDefaultFields() override;
 	Store3ItemTypes Type() override { return MAGIC_MAIL; }
 	void DoContextMenu(LMouse &m, LView *Parent = 0) override;
 	int Compare(LListItem *Arg, ssize_t Field) override;
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 	LAutoString GetSig(bool HtmlVersion, ScribeAccount *Account = 0);
 	bool LoadFromFile(char *File);
 	void PrepSend();
 	void NewRecipient(char *Email, char *Name = 0);
 	void ClearCachedItems();
 	bool Send(bool Now);
 	void CreateMailHeaders();
 	bool AddCalendarEvent(LViewI *Parent, bool AddPopupReminder, LString *Msg);
 	LArray<Attachment*> GetCalendarAttachments();
 	void Reparse() override;
 
 	// UI
 	LDocView *CreateView(MailViewOwner *Owner, LString MimeType, bool Sunken, size_t MaxBytes, bool NoEdit = false);
 	ThingUi *DoUI(MailContainer *c = 0) override;
 
 	// Alt HTML
 	bool HasAlternateHtml(Attachment **Attach = 0);
 	char *GetAlternateHtml(List<Attachment> *Refs = 0); // dynamically allocated ptr
 	bool WriteAlternateHtml(char *File = NULL, int FileLen = 0); // defaults to TEMP dir
 
 	// Account stuff
 	void ProcessTextForResponse(Mail *From, LOptionsFile *Options, ScribeAccount *Account);
 	void WrapAndQuote(LStringPipe &Pipe, const char *QuoteStr, int WrapAt = -1);
 	ScribeAccount *GetAccountSentTo();
 
 	// Access
 	int64 TotalSizeof();
 	bool Save(ScribeFolder *Into = 0) override;
 	
 	// Attachments
 	Attachment *AttachFile(LView *Parent, const char *FileName);
 	bool AttachFile(Attachment *File);
 	bool DeleteAttachment(Attachment *File);
 	LArray<Attachment*> GetAttachments();
 	bool GetAttachments(List<Attachment> *Attachments);
 	bool HasAttachments() { return Attachments.Length() > 0; }
 	bool UnloadAttachments();
 
 	// Import / Export
 	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
 	IoProgress Import(IoProgressFnArgs) override;
 	IoProgress Export(IoProgressFnArgs) override;
 
 	// ListItem
 	void Update() override;
 	const char *GetText(int i) override;
 	int GetImage(int SelFlags = 0) override;
 	void OnMeasure(LPoint *Info) override;
 	void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c) override;
 	void OnPaint(LItem::ItemPaintCtx &Ctx) override;
 };
 
 inline const char *toString(Mail::NewEmailState s)
 {
 	#define _(s) case Mail::s: return #s;
 	switch (s)
 	{
 		_(NewEmailNone)
 		_(NewEmailLoading)
 		_(NewEmailFilter)
 		_(NewEmailBayes)
 		_(NewEmailGrowl)
 		_(NewEmailTray)
 	}
 	#undef _
 	LAssert(0);
 	return "#invalidNewEmailState";
 }
 
 // this is where the items reside
 // and it forms a leaf on the mail box tree
 // to the user it looks like a folder
 class ScribeClass ScribeFolder :
 	public ThingType,
 	public LTreeItem,
 	public LDragDropSource,
 	public MailContainer
 {
 	friend class MailTree;
 	friend class FolderPropertiesDlg;
 	friend class ThingList;
 	friend class ScribeWnd;
 	friend class MoveToState;
 	friend struct MboxExportTask;
 
 protected:
 	class ScribeFolderPriv *d;
 	ThingList *View();
 	LString DropFileName;
 
 	LString GetDropFileName();
 
 	// UI cache
 	LAutoString NameCache;
 	int ChildUnRead = 0;
 	LTreeItem *LoadOnDemand = NULL;
 	LAutoPtr<LListItem> Loading;
 
 	LArray<int> FieldArray;
 	void SerializeFieldWidths(bool Write = false);
 	void EmptyFieldList();
 	void SetLoadFolder(Thing *t) { if (t) t->SetParentFolder(this); }
 	bool HasFieldId(int Id);
 	void ContinueLoading(int OldUnread, std::function<void(Store3Status)> Callback);
 
 	// Tree item stuff
 	void _PourText(LPoint &Size) override;
 	void _PaintText(LItem::ItemPaintCtx &Ctx) override;
 	int _UnreadChildren();
 
 	void UpdateOsUnread();
 
 	// Debugging state
 	enum FolderState
 	{
 		FldState_Idle,
 		FldState_Loading,
 		FldState_Populating,
 	}	CurState = FldState_Idle;
 
 public:
 	List<Thing> Items;
 
 	ScribeFolder();
 	~ScribeFolder();
 
 	// Object
 	LArray<int> &GetFieldArray() { return FieldArray; }
 	LDataFolderI *GetFldObj() { return dynamic_cast<LDataFolderI*>(GetObject()); }
 	bool SetObject(LDataI *o, bool InDataDestuctor, const char *File, int Line) override;
 
 	// ThingType
 	Store3ItemTypes Type() override { return GetObject() ? (Store3ItemTypes)GetObject()->Type() : MAGIC_NONE; }
 	ScribeFolder *GetFolder() override { return dynamic_cast<ScribeFolder*>(LTreeItem::GetParent()); }
 	ScribeFolder *GetChildFolder() { return dynamic_cast<ScribeFolder*>(LTreeItem::GetChild()); }
 	ScribeFolder *GetNextFolder() { return dynamic_cast<ScribeFolder*>(LTreeItem::GetNext()); }
 	Store3Status SetFolder(ScribeFolder *f, int Param = -1) override;
 	ScribeFolder *IsFolder() { return this; }
 	Store3Status CopyTo(ScribeFolder *NewParent, int NewIndex = -1);
 
 	// MailContainer
 	size_t Length() override;
 	ssize_t IndexOf(Mail *m) override;
 	Mail *operator [](size_t i) override;
 
 	/// Update the unread count
 	void OnUpdateUnRead
 	(
 		/// Increments the count, or zero if a child folder is changing.
 		int Offset,
 		/// Re-scan the folder
 		bool ScanItems
 	);							
 
 	// Methods
 	LDATA_INT32_PROP(UnRead, FIELD_UNREAD);
 	LDATA_INT_TYPE_PROP(Store3ItemTypes, ItemType, FIELD_FOLDER_TYPE, MAGIC_MAIL);
 	LDATA_INT32_PROP(Open, FIELD_FOLDER_OPEN);
 	LDATA_INT32_PROP(SortIndex, FIELD_FOLDER_INDEX);
 	LDATA_INT64_PROP(Items, FIELD_FOLDER_ITEMS); // Cached item count
 	LDATA_INT_TYPE_PROP(ScribePerm, ReadAccess, FIELD_FOLDER_PERM_READ, PermRequireNone);
 	LDATA_INT_TYPE_PROP(ScribePerm, WriteAccess, FIELD_FOLDER_PERM_WRITE, PermRequireNone);
 	LDATA_ENUM_PROP(SystemFolderType, FIELD_SYSTEM_FOLDER, Store3SystemFolder);
 
 	void SetSort(int Col, bool Ascend, bool CanDirty = true);
 	int GetSortAscend() { return GetObject()->GetInt(FIELD_SORT) > 0; }
 	int GetSortCol() { return abs((int)GetObject()->GetInt(FIELD_SORT)) - 1; }
 	int GetSortField();
 	void ReSort();
 	bool Save(ScribeFolder *Into = 0) override;
 	bool ReindexField(int OldIndex, int NewIndex);
 	void CollectSubFolderMail(ScribeFolder *To = 0);
 	bool InsertThing(Thing *Item);
 	void MoveTo(LArray<Thing*> &Items, bool CopyOnly, std::function<void(bool, LArray<Store3Status>&)> Callback = NULL);
 	bool Delete(LArray<Thing*> &Items, bool ToTrash);
 	void SetDefaultFields(bool Force = false);
 	bool Thread();
 	ScribePerm GetFolderPerms(ScribeAccessType Access); 
 	void SetFolderPerms(LView *Parent, ScribeAccessType Access, ScribePerm Perm, std::function<void(bool)> Callback); 
 	bool GetThreaded();
 	void SetThreaded(bool t);
 	// void Update();
 	void GetMessageById(const char *Id, std::function<void(Mail*)> Callback);
 	void SetLoadOnDemand();
 	void SortSubfolders();
 	void DoContextMenu(LMouse &m);
 	void OnItemType();
 	bool IsInTrash();
 	bool SortItems();
 	
 	/// 
 	/// These methods can be used in a synchronous or asynchronous manner:
 	///		sync:	Call with 'Callback=NULL' and use the return value.
 	///				If the function needs to show a dialog (like to get permissions from
 	///				the user) then it'll return Store3Delayed immediately.
 	///		async:	Call with a valid callback, and the method will possibly wait 
 	///				for the user and then either return Store3Error or Store3Success.
 	Store3Status LoadThings(LViewI *Parent = NULL,	std::function<void(Store3Status)> Callback = NULL);
 	Store3Status WriteThing(Thing *t,				std::function<void(Store3Status)> Callback = NULL);
 	Store3Status DeleteThing(Thing *t,				std::function<void(Store3Status)> Callback = NULL);
 	Store3Status DeleteAllThings(					std::function<void(Store3Status)> Callback = NULL);
 	bool LoadFolders();
 	bool UnloadThings();
 	bool IsWriteable() { return true; }
 	bool IsPublicFolders() { return false; }
 
 	void OnProperties(int Tab = -1) override;
-	ScribeFolder *CreateSubDirectory(const char *Name, int Type);
+	ScribeFolder *GetSubFolder(const char *Path);
+	ScribeFolder *CreateSubFolder(const char *Name, int Type);
 	void OnRename(char *NewName);
 	void OnDelete();
 	LString GetPath();
-	ScribeFolder *GetSubFolder(const char *Path);
 	void Populate(ThingList *List);
 	bool CanHaveSubFolders(Store3ItemTypes Type = MAGIC_MAIL) { return GetItemType() != MAGIC_ANY; }
 	void OnRethread();
 
 	// Name
 	void SetName(const char *Name, bool Encode);
 	LString GetName(bool Decode);
 
 	// Tree Item
 	const char *GetText(int i=0) override;
 	int GetImage(int Flags = 0) override;
 	void OnExpand(bool b) override;
 	bool OnKey(LKey &k) override;
 	void Update() override;
 
 	// Drag'n'drop
 	bool GetFormats(LDragFormats &Formats) override;
 	bool OnBeginDrag(LMouse &m) override;
 	void OnEndData() override;
 	bool GetData(LArray<LDragData> &Data) override;
 	void OnReceiveFiles(LArray<const char*> &Files);
 
 	// Import/Export
 	bool GetFormats(bool Export, LString::Array &MimeTypes);
 	IoProgress Import(IoProgressFnArgs);
 	IoProgress Export(IoProgressFnArgs);
 	void ExportAsync(LAutoPtr<LStreamI> f, const char *MimeType, std::function<void(LProgressDlg*)> Callback = NULL);
 	const char *GetStorageMimeType();
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant *> &Args) override;
 };
 
 //////////////////////////////////////////////////////////////
 class Filter;
 
 class FilterCondition
 {
 protected:
 	bool TestData(Filter *F, LVariant &v, LStream *Log);
 
 public:
 	// Data
 	LAutoString Source; // Data Source (used to be "int Field")
 	LAutoString Value; // Constant
 	char Op;
 	uint8_t Not;
 
 	// Methods
 	FilterCondition();
 	bool Set(class LXmlTag *t);
 
 	// Test condition against email
 	bool Test(Filter *F, Mail *m, LStream *Log);
 	FilterCondition &operator =(FilterCondition &c);
 
 	// Object
 	ThingUi *DoUI(MailContainer *c = 0);
 };
 
 class FilterAction : public LListItem, public LDataPropI
 {
 	LCombo *TypeCbo;
 	LEdit *ArgEdit;
 	LButton *Btn;
 
 public:
 	// Data
 	FilterActionTypes Type;
 	LString Arg1;
 
 	// Methods
 	FilterAction(LDataStoreI *Store);
 	~FilterAction();
 
 	bool Set(LXmlTag *t);
 	bool Get(LXmlTag *t);
 	bool Do(Filter *F, ScribeWnd *App, Mail *&m, LStream *log);
 	void Browse(ScribeWnd *App, LView *Parent);
 	void DescribeHtml(Filter *Flt, LStream &s);
 
 	LDataPropI &operator =(LDataPropI &p);
 
 	// List item
 	const char *GetText(int Col = 0);
 	void OnMeasure(LPoint *Info);
 	bool Select();
 	void Select(bool b);
 	void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c);
 	int OnNotify(LViewI *c, LNotification n);
 
 	// Object
 	ThingUi *DoUI(MailContainer *c = 0);
 	// bool Serialize(ObjProperties &f, bool Write);
 };
 
 class ScribeClass Filter : public Thing
 {
 	friend class FilterUi;
 	
 protected:
 	class FilterUi *Ui;
 	class FilterPrivate *d;
 	static int MaxIndex;
 
 	// Ui
 	LListItemCheckBox *ChkIncoming;
 	LListItemCheckBox *ChkOutgoing;
 	LListItemCheckBox *ChkInternal;
 	bool IgnoreCheckEvents;
 
 	// Current
 	Mail **Current;
 
 	// XML I/O
 	LAutoPtr<LXmlTag> ConditionsCache;
 	LAutoPtr<LXmlTag> Parse(bool Actions);
 
 	// Methods
 	bool EvaluateTree(LXmlTag *n, Mail *m, bool &Stop, LStream *Log);
 	bool EvaluateXml(Mail *m, bool &Stop, LStream *Log);
 
 public:
 	Filter(ScribeWnd *app, LDataI *object = 0);
 	~Filter();
 
 	LDATA_STR_PROP(Name, FIELD_FILTER_NAME);
 	LDATA_STR_PROP(ConditionsXml, FIELD_FILTER_CONDITIONS_XML);
 	LDATA_STR_PROP(ActionsXml, FIELD_FILTER_ACTIONS_XML);
 	LDATA_STR_PROP(Script, FIELD_FILTER_SCRIPT);
 	LDATA_INT32_PROP(Index, FIELD_FILTER_INDEX);
 	LDATA_INT32_PROP(StopFiltering, FIELD_STOP_FILTERING);
 	LDATA_INT32_PROP(Incoming, FIELD_FILTER_INCOMING);
 	LDATA_INT32_PROP(Outgoing, FIELD_FILTER_OUTGOING);
 	LDATA_INT32_PROP(Internal, FIELD_FILTER_INTERNAL);
 
 	int Compare(LListItem *Arg, ssize_t Field) override;
 	Thing &operator =(Thing &c) override;
 	Filter *IsFilter() override { return this; }
 	static void Reindex(ScribeFolder *Folder);
 	int *GetDefaultFields() override;
 	const char *GetFieldText(int Field) override;
 
 	// Methods
 	void Empty();
 	LAutoString DescribeHtml();
 
 	// Import / Export
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
 	IoProgress Import(IoProgressFnArgs) override;
 	IoProgress Export(IoProgressFnArgs) override;
 
 	// Dom
 	bool Evaluate(char *s, LVariant &v);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Filter
 	bool Test(Mail *m, bool &Stop, LStream *Log = 0);
 	bool DoActions(Mail *&m, bool &Stop, LStream *Log = 0);
 	Mail *GetCurrent() { return Current?*Current:0; }
 	
 	/// This filters all the mail in 'Email'. Anything that is handled by a filter
 	/// is removed from the list, leaving just the unfiltered mail.
 	static int ApplyFilters
 	(
 	    /// [In] The window of the filtering caller
 	    LView *Parent,
 	    /// [In] List of all the filter to test and/or apply
 	    List<Filter> &Filters,
 	    /// [In/Out] The email to filter. After the call anything that has been
 	    /// acted on by a filter will be removed from the list.
 	    List<Mail> &Email
 	);
 
 	// Object
 	Store3ItemTypes Type() override { return MAGIC_FILTER; }
 	ThingUi *DoUI(MailContainer *c = 0) override;
 	bool Serialize(LFile &f, bool Write);
 	bool Save(ScribeFolder *Into = 0) override;
 	void OnMouseClick(LMouse &m) override;
 	void AddAction(FilterAction *a);
 	
 	// List item
 	const char *GetText(int i) override;
 	int GetImage(int Flags) override;
 	void OnPaint(ItemPaintCtx &Ctx) override;
 	void OnColumnNotify(int Col, int64 Data) override;
 
 	// Index
 	Filter *GetFilterAt(int Index);
 };
 
 //////////////////////////////////////////////////////////////////////
 class Accountlet;
 
 enum AccountThreadState
 {
 	ThreadIdle,
 	ThreadSetup,
 	ThreadConnecting,
 	ThreadTransfer,
 	ThreadWaiting,
 	ThreadDeleting,
 	ThreadDone,
 	ThreadCancel,
 	ThreadError
 };
 
 enum ReceiveAction
 {
 	MailNoop,
 	MailDelete,
 	MailDownloadAndDelete,
 	MailDownload,
 	MailUpload,
 	MailHeaders,
 
 };
 
 enum ReceiveStatus
 {
 	MailReceivedNone,
 	MailReceivedWaiting,	// This has been given to the main thread
 	MailReceivedOk,			// and one of "Ok" or "Error" has to be
 	MailReceivedError,		// set to continue.
 	MailReceivedMax,
 };
 
 ScribeFunc const char *AccountThreadStateName(AccountThreadState i);
 ScribeFunc const char *ReceiveActionName(ReceiveAction i);
 ScribeFunc const char *ReceiveStatusName(ReceiveStatus i);
 
 class LScribeMime : public LMime
 {
 public:
 	LScribeMime() : LMime(ScribeTempPath())
 	{
 	}
 };
 
 class LMimeStream : public LTempStream, public LScribeMime
 {
 public:
 	LMimeStream();
 	bool Parse();
 };
 
 class MailTransferEvent
 {
 public:
 	// Message
 	LAutoPtr<LStreamI> Rfc822Msg;
 	ReceiveAction Action = MailNoop;
 	ReceiveStatus Status = MailReceivedNone;
 	int Index = 0;
 	bool Explicit = false;
 	LString Uid;
 	int64 Size = 0;
 	int64 StartWait = 0;
 	
 	// Header Listing
 	class AccountMessage *Msg = NULL;
 	LList *GetList();
 
 	// Sending
 	ScribeEnvelope *Send = NULL;
 	LString OutgoingHeaders;
 
 	// Other
 	class Accountlet *Account = NULL;
 
 	MailTransferEvent()
 	{
 	}
 
 	~MailTransferEvent()
 	{
 		#ifndef LGI_STATIC
 		// LStackTrace("%p::~MailTransferEvent\n", this);
 		#endif
 	}
 };
 
 #define RoProp(Type, Name)					\
 	protected:								\
 		Type Name;							\
 	public:									\
 		Type Get##Name() { return Name; }
 
 class AccountThread : public LThread, public LCancel
 {
 protected:
 	Accountlet *Acc;
 	void OnAfterMain();
 
 public:
 	// Object
 	AccountThread(Accountlet *acc);
 	~AccountThread();
 
 	// Api
 	Accountlet *GetAccountlet() { return Acc; }
 	
 	// 1st phase
 	virtual void Disconnect();
 
 	// 2nd phase
 	virtual bool Kill();
 };
 
 #define AccStrOption(func, opt) \
 	LVariant func(const char *Set = 0) { LVariant v; StrOption(opt, v, Set); return v; }
 
 #define AccIntOption(name, opt) \
 	int name(int Set = -1) { LVariant v; IntOption(opt, v, Set); return v.CastInt32(); }
 
 class ScribeClass Accountlet : public LStream
 {
 	friend class ScribeAccount;
 	friend class AccountletThread;
 	friend class AccountThread;
 
 public:
 	struct AccountletPriv
 	{
 		LArray<LogEntry*> Log;
 	};
 
 	class AccountletLock
 	{
 		LMutex *l;
 
 	public:
 		bool Locked;
 		AccountletPriv *d;
 
 		AccountletLock(AccountletPriv *data, LMutex *lck, const char *file, int line)
 		{
 			d = data;
 			l = lck;
 			Locked = lck->Lock(file, line);
 		}
 
 		~AccountletLock()
 		{
 			if (Locked)
 				l->Unlock();
 		}
 	};
 
 	typedef LAutoPtr<AccountletLock> I;
 
 private:
 	AccountletPriv d;
 	LMutex PrivLock;
 
 protected:
 	// Data
 	ScribeAccount *Account;
 	LAutoPtr<AccountThread> Thread;
 	bool ConnectionStatus;
 	MailProtocol *Client;
 	uint64 LastOnline;
 	LString TempPsw;
 	bool Quiet;
 	LView *Parent;
 
 	// Pointers
 	ScribeFolder *Root;
 	LDataStoreI *DataStore;
 	LMailStore *MailStore; // this memory is owned by ScribeWnd
 
 	// Options
 	const char *OptPassword;
 
 	// Members
 	LSocketI *CreateSocket(bool Sending, LCapabilityClient *Caps, bool RawLFCheck);
 	bool WaitForTransfers(List<MailTransferEvent> &Files);
 
 	void StrOption(const char *Opt, LVariant &v, const char *Set);
 	void IntOption(const char *Opt, LVariant &v, int Set);
 
 	// LStringPipe Line;
 	ssize_t Write(const void *buf, ssize_t size, int flags);
 
 public:
 	MailProtocolProgress Group;
 	MailProtocolProgress Item;
 
 	Accountlet(ScribeAccount *a);
 	~Accountlet();
 
 	Accountlet &operator =(const Accountlet &a)
 	{
 		LAssert(0);
 		return *this;
 	}
 
 	I Lock(const char *File, int Line)
 	{
 		I a(new AccountletLock(&d, &PrivLock, File, Line));
 		if (!a->Locked)
 			a.Reset();
 		return a;
 	}
 
 	// Methods
 	bool			Connect(LView *Parent, bool Quiet);
 	bool			Lock();
 	void			Unlock();
 	virtual bool	IsConfigured() 	{ return false; }
 	bool			GetStatus()		{ return ConnectionStatus; }
 	uint64			GetLastOnline()	{ return LastOnline; }
 	ScribeAccount*	GetAccount() 	{ return Account; }
 	bool			IsCancelled();
 	void			IsCancelled(bool b);
 	ScribeWnd*		GetApp();
 	const char*		GetStateName();
 	ScribeFolder* GetRootFolder() { return Root; }
 	RoProp(AccountThreadState, State);
 
 	bool IsOnline()
 	{
 		if (DataStore)
 			return DataStore->GetInt(FIELD_IS_ONLINE) != 0;
 		
 		return Thread != 0;
 	}
 
 	void OnEndSession()
 	{
 		if (DataStore)
 			DataStore->SetInt(FIELD_IS_ONLINE, false);
 	}
 
 	// Commands
 	void Disconnect();
 	void Kill();
 
 	// Data
 	char *OptionName(const char *Opt, char *Dest, int DestLen);
 	void Delete();
 	LThread *GetThread() { return Thread; }
 	LMailStore *GetMailStore() { return MailStore; }
 	LDataStoreI *GetDataStore() { return DataStore; }
 
 	// General options
 	virtual int UseSSL(int Set = -1) = 0;
 
 	AccStrOption(Name, OPT_AccountName);
 	AccIntOption(Disabled, OPT_AccountDisabled);
 	AccIntOption(Id, OPT_AccountUID);
 	AccIntOption(Expanded, OPT_AccountExpanded);
 	bool GetPassword(LPassword *p);
 	void SetPassword(LPassword *p);
 	bool IsCheckDialup();
 	
 	// Events
 	void OnThreadDone();
 	void OnOnlineChange(bool Online);
 	virtual void OnBeforeDelete();
 
 	// LDom impl
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 
 	// Virtuals
 	virtual void Main(AccountletThread *Thread) = 0;
 	virtual LVariant Server(const char *Set = 0) = 0;
 	virtual LVariant UserName(const char *Set = 0) = 0;
 	virtual void Enabled(bool b) = 0;
 	virtual void OnPulse(char *s, int s_len) {}
 	virtual bool IsReceive() { return false; }
 	virtual bool InitMenus() { return false; }
 	virtual void CreateMaps() = 0;
 	virtual ScribeAccountletStatusIcon GetStatusIcon() { return STATUS_ERROR; }
 };
 
 #undef RoProp
 
 class AccountletThread;
 
 class AccountIdentity : public Accountlet
 {
 public:
 	AccountIdentity(ScribeAccount *a);
 
 	AccStrOption(Name, OPT_AccIdentName);
 	AccStrOption(Email, OPT_AccIdentEmail);
 	AccStrOption(ReplyTo, OPT_AccIdentReply);
 	AccStrOption(TextSig, OPT_AccIdentTextSig);
 	AccStrOption(HtmlSig, OPT_AccIdentHtmlSig);
 
 	AccIntOption(Sort, OPT_AccountSort);
 
 	int UseSSL(int Set = -1) { return 0; }
 	void Main(AccountletThread *Thread) {}
 	LVariant Server(const char *Set = 0) { return LVariant(); }
 	LVariant UserName(const char *Set = 0) { return LVariant(); }
 	void Enabled(bool b) {}
 	void CreateMaps();
 	bool IsValid();
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 };
 
 struct ScribeEnvelope
 {
 	LString MsgId;
 	LString SourceFolder;
 	LString From;
 	LArray<LString> To;
 
 	LString References;
 	LString FwdMsgId;
 	LString BounceMsgId;
 
 	LString Rfc822;
 };	
 
 class SendAccountlet : public Accountlet
 {
 	friend class ScribeAccount;
 	friend class ScribeWnd;
 
 	LMenuItem *SendItem;
 
 public:
 	LArray<ScribeEnvelope*> Outbox;
 
 	SendAccountlet(ScribeAccount *a);
 	~SendAccountlet();
 
 	// Methods
 	void Main(AccountletThread *Thread);
 	void Enabled(bool b);
 	bool InitMenus();
 	void CreateMaps();
 	ScribeAccountletStatusIcon GetStatusIcon();
 
 	// Sending options
 	AccStrOption(Server, OPT_SmtpServer);
 	AccIntOption(Port, OPT_SmtpPort);
 	AccStrOption(Domain, OPT_SmtpDomain);
 	AccStrOption(UserName, OPT_SmtpName);
 	AccIntOption(RequireAuthentication, OPT_SmtpAuth);
 	AccIntOption(AuthType, OPT_SmtpAuthType);
 	AccStrOption(PrefCharset1, OPT_SendCharset1);
 	AccStrOption(PrefCharset2, OPT_SendCharset2);
 	AccStrOption(HotFolder, OPT_SendHotFolder);
 	AccIntOption(OnlySendThroughThisAccount, OPT_OnlySendThroughThis);
 	
 	/// Get/Set the SSL mode
 	/// \sa #SSL_NONE, #SSL_STARTTLS or #SSL_DIRECT
 	AccIntOption(UseSSL, OPT_SmtpSSL);
 
 	bool IsConfigured()
 	{
 		LVariant hot = HotFolder();
 		if (hot.Str())
 		{
 			bool Exists = LDirExists(hot.Str());
 			printf("%s:%i - '%s' exists = %i\n", _FL, hot.Str(), Exists);
 			return Exists;
 		}
 
 		return ValidStr(Server().Str());
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 };
 
 typedef LHashTbl<ConstStrKey<char>, LXmlTag*> MsgListHash;
 class MsgList : protected MsgListHash
 {
 	LOptionsFile *Opts;
 	LString Tag;
 	bool Loaded;
 
 	bool Load();
 	LXmlTag *LockId(const char *id, const char *file, int line);
 	void Unlock();
 
 public:
 	typedef MsgListHash Parent;
 	bool Dirty;
 
 	MsgList(LOptionsFile *Opts, char *Tag);
 	~MsgList();
 
 	// Access methods
 	bool Add(const char *id);
 	bool Delete(const char *id);
 	int Length();
 	bool Find(const char *id);
 	void Empty();
 	LString::Array CopyKeys();
 
 	// Dates
 	bool SetDate(char *id, LDateTime *dt);
 	bool GetDate(char *id, LDateTime *dt);
 };
 
 class ReceiveAccountlet : public Accountlet
 {
 	friend class ScribeAccount;
 	friend class ScribeWnd;
 	friend class ImapThread;
 	friend class ScpThread;
 
 	LArray<ReceiveAction> Actions;
 	LList *Items;
 	int	SecondsTillOnline;
 	LMenuItem *ReceiveItem;
 	LMenuItem *PreviewItem;
 	List<char> *IdTemp;
 	LAutoPtr<ProtocolSettingStore> SettingStore;
 	
 	LAutoPtr<MsgList> Msgs;
 	LAutoPtr<MsgList> Spam;
 
 public:
 	ReceiveAccountlet(ScribeAccount *a);
 	~ReceiveAccountlet();
 
 	// Props
 	LList *GetItems() { return Items; }
 	bool SetItems(LList *l);
 	bool SetActions(LArray<ReceiveAction> *a = NULL);
 
 	bool IsReceive() { return true; }
 	bool IsPersistant();
 
 	// Methods
 	void Main(AccountletThread *Thread);
 	void OnPulse(char *s, int s_len);
 	bool OnIdle();
 	void Enabled(bool b);
 	bool InitMenus();
 	int GetCheckTimeout();
 	void CreateMaps();
 	ScribeAccountletStatusIcon GetStatusIcon();
 
 	// Message list
 	bool HasMsg(const char *Id);
 	void AddMsg(const char *Id);
 	void RemoveMsg(const char *Id);
 	void RemoveAllMsgs();
 	int GetMsgs();
 
 	// Spam list
 	void DeleteAsSpam(const char *Id);
 	bool RemoveFromSpamIds(const char *Id);
 	bool IsSpamId(const char *Id, bool Delete = false);
 
 	// Receive options
 	AccStrOption(Protocol, OPT_Pop3Protocol);
 	ScribeProtocol ProtocolType() { return ProtocolStrToEnum(Protocol().Str()); }
 	AccStrOption(Server, OPT_Pop3Server);
 	AccIntOption(Port, OPT_Pop3Port);
 	AccStrOption(UserName, OPT_Pop3Name);
 	AccStrOption(DestinationFolder, OPT_Pop3Folder);
 	AccIntOption(AutoReceive, OPT_Pop3AutoReceive);
 	AccStrOption(CheckTimeout, OPT_Pop3CheckEvery);
 	
 	AccIntOption(LeaveOnServer, OPT_Pop3LeaveOnServer);
 	AccIntOption(DeleteAfter, OPT_DeleteAfter);
 	AccIntOption(DeleteDays, OPT_DeleteDays);
 	AccIntOption(DeleteLarger, OPT_DeleteIfLarger);
 	AccIntOption(DeleteSize, OPT_DeleteIfLargerSize);
 	AccIntOption(DownloadLimit, OPT_MaxEmailSize);
 	
 	AccStrOption(Assume8BitCharset, OPT_Receive8BitCs);
 	AccStrOption(AssumeAsciiCharset, OPT_ReceiveAsciiCs);
 	AccIntOption(AuthType, OPT_ReceiveAuthType);
 	AccStrOption(HotFolder, OPT_ReceiveHotFolder);
 	AccIntOption(SecureAuth, OPT_ReceiveSecAuth);
 	
 	/// Get/Set the SSL mode
 	/// \sa #SSL_NONE, #SSL_STARTTLS or #SSL_DIRECT
 	AccIntOption(UseSSL, OPT_Pop3SSL);
 
 	bool IsConfigured()
 	{
 		LVariant hot = HotFolder();
 		if (hot.Str() && LDirExists(hot.Str()))
 		{
 			return true;
 		}
 		
 		LVariant v = Server();
 		bool s = ValidStr(v.Str());
 		v = Protocol();
 		if (!v.Str() ||
 			_stricmp(v.Str(), PROTOCOL_POP_OVER_HTTP) != 0)
 		{
 			v = UserName();
 			s &= ValidStr(v.Str());
 		}
 		return s;
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 };
 
 class ScribeAccount :
 	public LDom,
 	public LXmlTreeUi,
 	public LCapabilityClient
 {
 	friend class ScribeWnd;
 	friend class ScribePopViewer;
 	friend class AccountStatusPanel;
 	friend class Accountlet;
 	friend class SendAccountlet;
 	friend class ReceiveAccountlet;
 
 protected:
 	class ScribeAccountPrivate *d;
 	ScribeWnd *Parent;
 	
 	ScribeFolder *&GetRoot();
 	void SetIndex(int i);
 
 public:
 	// Data
 	AccountIdentity Identity;
 	SendAccountlet Send;
 	ReceiveAccountlet Receive;
 	LArray<LListItem*> Views;
 
 	// Object
 	ScribeAccount(ScribeWnd *parent, int index);
 	~ScribeAccount();
 
 	// Lifespan
 	bool IsValid();
 	bool Create();
 	bool Delete();
 
 	// Properties
 	ScribeWnd *GetApp() { return Parent; }
 	int GetIndex();
 	bool IsOnline();
 	void SetCheck(bool c);
 	LMenuItem *GetMenuItem();
 	void SetMenuItem(LMenuItem *i);
 	void OnEndSession()
 	{
 		Send.OnEndSession();
 		Receive.OnEndSession();
 	}
 
 	// Commands
 	void Stop();
 	bool Disconnect();
 	void Kill();
 	void SetDefaults();
 
 	// User interface
 	void InitUI(LView *Parent, int Tab, std::function<void(bool)> callback);
 	bool InitMenus();
 	void SerializeUi(LView *Wnd, bool Load);
 	int OnNotify(LViewI *Ctrl, LNotification &n);
 
 	// Worker
 	void OnPulse(char *s = NULL, int s_len = 0);
 	void ReIndex(int i);
 	void CreateMaps();
 
 	// LDom interface
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 };
 
 //////////////////////////////////////////////////////////////////////
 class ScribeClass ScribeDom : public LDom
 {
 	ScribeWnd *App;
 
 public:
 	Mail *Email;
 	Contact *Con;
 	ContactGroup *Grp;
 	Calendar *Cal;
 	Filter *Fil;
 
 	ScribeDom(ScribeWnd *a);
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = 0);
 };
 
 //////////////////////////////////////////////////////////////////////
 #include "BayesianFilter.h"
 #include "Components.h"
 
 class LMailStore
 {
 public:
 	bool Default, Expanded;
 	LString Name;
 	LString Path;
 	LDataStoreI *Store;
 	ScribeFolder *Root;
 
 	LMailStore()
 	{
 		Expanded = true;
 		Default = false;
 		Store = NULL;
 		Root = NULL;
 	}
 
 	bool IsOk()
 	{
 		return	Store != NULL &&
 				Root != NULL;
 	}
 
 	int Priority()
 	{
 		int Ver = Store ? (int)Store->GetInt(FIELD_VERSION) : 0;
 		return Ver;
 	}
 
 	void Empty()
 	{
 		DeleteObj(Store);
 		Name.Empty();
 		Path.Empty();
 		Root = NULL;
 	}
 
 	LMailStore &operator =(LMailStore &a)
 	{
 		LAssert(0);
 		return *this;
 	}
 };
 
 struct OptionsInfo
 {
 	LString File;
 	char *Leaf;
 	int Score;
 	uint64 Mod;
 	bool Usual;
 	
 	OptionsInfo();
 	
 	OptionsInfo &operator =(char *p);
 	LAutoPtr<LOptionsFile> Load();
 };
 
 class ScribeClass ScribeWnd :
 	public LWindow,
 	public LDom,
 	public LDataEventsI,
 	public BayesianFilter,
 	public CapabilityInstaller,
 	public LCapabilityTarget
 {
 	friend class ScribeAccount;
 	friend class Accountlet;
 	friend class SendAccountlet;
 	friend class ReceiveAccountlet;
 	friend class AccountStatusPanel;
 	friend class ScribeFolder;
 	friend class OptionsDlg;
 	friend class LoadWordStoreThread;
 	friend struct ScribeReplicator;
 	friend struct LoadMailStoreState;
 	friend struct UnitTestState;
 
 public:
 	enum LayoutMode
 	{
 		OptionsLayout = 0,
 		
 		///--------------------
 		///         |         |
 		/// Folders |  List   |
 		///         |         |
 		///         |---------|
 		///         | Preview |
 		///--------------------
 		FoldersListAndPreview = 1,
 
 		///-----------------
 		///         |      |
 		/// Folders | List |
 		///         |      |
 		///-----------------
 		///     Preview    |
 		///-----------------
 		PreviewOnBottom,
 
 		///-----------------
 		///         |      |
 		/// Folders | List |
 		///         |      |
 		///-----------------
 		FoldersAndList,
 
 		///---------------------------
 		///         |      |         |
 		/// Folders | List | Preview |
 		///         |      |         |
 		///---------------------------
 		ThreeColumn,
 	};
 
 	enum AppState
 	{
 	    ScribeConstructing, // In Construct1 + Construct2
 	    ScribeConstructed,	// Finished Construct2 and ready for Construct3
 	    ScribeInitializing,	// In Construct3
 	    ScribeRunning,
 	    ScribeExiting,
 	    ScribeLoadingFolders,
 	    ScribeUnloadingFolders,
 	};
 	
 	AppState GetScribeState()
 	{
 	    return ScribeState;
 	}
 
 protected:
 	class ScribeWndPrivate *d = NULL;
 
 	LTrayIcon		TrayIcon;
 	
 	// Ipc
 	LSharedMemory	*ScribeIpc = NULL;
 	class ScribeIpcInstance *ThisInst = NULL;
 	bool ShutdownIpc();
 
 	// Accounts
 	List<ScribeAccount> Accounts;
 
 	// New Mail stuff
 	class LNewMailDlg *NewMailDlg = NULL;
 
 	static AppState ScribeState;
 	DoEvery			Ticker;
 	int64			LastDrop = 0;
 
 	// Static 
 	LSubMenu		*File = NULL;
 	LSubMenu		*ContactsMenu = NULL;
 	LSubMenu		*Edit = NULL;
 	LSubMenu		*Help = NULL;
 	LToolBar		*Commands = NULL;
 
 	// Dynamic
 	LSubMenu		*IdentityMenu = NULL;
 	LMenuItem		*DefaultIdentityItem = NULL;
 	LSubMenu		*MailMenu = NULL;
 	LSubMenu		*SendMenu = NULL, *ReceiveMenu = NULL, *PreviewMenu = NULL;
 	LMenuItem		*SendItem = NULL, *ReceiveItem = NULL, *PreviewItem = NULL;
 	LSubMenu		*NewTemplateMenu = NULL;
 	LMenuItem		*WorkOffline = NULL;
 
 	// Commands
 	LCommand		CmdSend;
 	LCommand		CmdReceive;
 	LCommand		CmdPreview;
 
 	// Storage
 	LArray<LMailStore> Folders;
 	LArray<LEventTargetI*> FolderTasks;
 	
 	List<ScribeFolder> PostValidateFree;
 
 	// Main view
 	LAutoPtr<LImageList> ImageList;
 	LAutoPtr<LImageList> ToolbarImgs;
 	class LBox		*Splitter = NULL;
 	ThingList		*MailList = NULL;
 	class DynamicHtml *TitlePage = NULL;
 	class LSearchView *SearchView = NULL;
 	MailTree		*Tree = NULL;
 	class LPreviewPanel	*PreviewPanel = NULL;
 	class AccountStatusPanel *StatusPanel = NULL;
 
 	// Security
 	ScribePerm		CurrentAuthLevel = PermRequireNone;
 
 	// Methods
 	void			SetupUi();
 	void			SetupAccounts();
 	int				AdjustAllObjectSizes(LDataI *Item);
 	bool			CleanFolders(ScribeFolder *f);
 	void			LoadFolders(std::function<void(bool)> Callback);
 	void			LoadMailStores(std::function<void(bool)> Callback);
 	bool			ProcessFolder(LDataStoreI *&Store, int StoreIdx, char *StoreName);
 	bool			UnLoadFolders();
 	void			AddFolderToMru(char *FileName);
 	void			AddContactsToMenu(LSubMenu *Menu);
 	bool			FindWordDb(char *Out, int OutSize, char *Name);
 	void			OnFolderChanged(LDataFolderI *folder);
 	bool			ValidateFolder(LMailStore *s, int Id);
     void            GrowlOnMail(Mail *m);
 	void			GrowlInfo(LString title, LString text);
 	bool			OnTransfer();
 	ScribeDomType	StrToDom(const char *Var) { return ::StrToDom(Var); }
 	const char*		DomToStr(ScribeDomType p) { return ::DomToStr(p); }
 	void			LoadImageResources();
 	void			DoOnTimer(LScriptCallback *c);
 
 public:
 	ScribeWnd();
 	void Construct1();
 	void Construct2();
 	void Construct3();
 	void SetLanguage();
 
 	~ScribeWnd();
 
 	const char *GetClass() override { return "ScribeWnd"; }
 	void DoDebug(char *s);
 	void Validate(LMailStore *s);
 
 	// Unit testing.
 	static bool IsUnitTest;
 	#ifdef _DEBUG
 	void UnitTests(std::function<void(bool)> Callback);
 	#endif
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// ---------------------------------------------------------------------
 	// Methods
 	LAutoString		GetDataFolder();
 	LDataStoreI		*CreateDataStore(const char *Full, bool CreateIfMissing);
 	Thing			*CreateThingOfType(Store3ItemTypes Type, LDataI *obj = 0);
 	Thing			*CreateItem(int Type, ScribeFolder *Folder = 0, bool Ui = true);
 	Mail			*CreateMail(Contact *c = 0, const char *Email = 0, const char *Name = 0);
 	Mail			*LookupMailRef(const char *MsgRef, bool TraceAllUids = false);
 	bool			CreateFolders(LAutoString &FileName);
 	bool			CompactFolders(LMailStore &Store, bool Interactive = true);
 	void			Send(int Which = -1, bool Quiet = false);
 	void			Receive(int Which);
 	void			Preview(int Which);
 	void			OnBeforeConnect(ScribeAccount *Account, bool Receive);
 	void			OnAfterConnect(ScribeAccount *Account, bool Receive);
     bool			NeedsCapability(const char *Name, const char *Param = NULL) override;
 	void			OnInstall(CapsHash *Caps, bool Status) override;
     void			OnCloseInstaller() override;
     bool			HasFolderTasks() { return FolderTasks.Length() > 0; }
     int				GetEventHandle();
 
 	void			Update(int What = 0);
 	void			UpdateUnRead(ScribeFolder *Folder, int Delta);
 	void			ThingPrint(std::function<void(bool)> Callback, ThingType *m, LPrinter *Info = NULL, LView *Parent = NULL, int MaxPage = -1);
 	bool			OpenAMail(ScribeFolder *Folder);
 	void			BuildDynMenus();
 	LDocView		*CreateTextControl(int Id, const char *MimeType, bool Editor, Mail *m = 0);
 	void			SetLastDrop() { LastDrop = LCurrentTime(); }
 	void			SetListPane(LView *v);
 	void			SetLayout(LayoutMode Mode = OptionsLayout);
 	bool			IsMyEmail(const char *Email);
 	bool			SetItemPreview(LView *v);
 	LOptionsFile::PortableType GetPortableType();
 	ScribeRemoteContent RemoteContent_GetSenderStatus(const char *Addr);
 	void			RemoteContent_ClearCache();
 	void			RemoteContent_AddSender(const char *Addr, bool WhiteList);
 
 	void			SetDefaultHandler();
 	void			OnSetDefaultHandler(bool Error, bool OldAssert);
 	void			SetCurrentIdentity(int i=-1);
 	int				GetCurrentIdentity();
 
 	bool			MailReplyTo(Mail *m, bool All = false);
 	bool			MailForward(Mail *m);
 	bool			MailBounce(Mail *m);
 	void			MailMerge(LArray<ListAddr*> &Recip, const char *FileName, Mail *Source);
 
 	void			OnNewMail(List<Mail> *NewMailObjs, bool Add = true);
 	void			OnNewMailSound();
 	void			OnCommandLine();
 	void			OnTrayClick(LMouse &m) override;
 	void			OnTrayMenu(LSubMenu &m) override;
 	void			OnTrayMenuResult(int MenuId) override;
 	void			OnFolderSelect(ScribeFolder *f);
 
 	void			AddThingSrc(ScribeFolder *src);
 	void			RemoveThingSrc(ScribeFolder *src);
 	LArray<ScribeFolder*> GetThingSources(Store3ItemTypes Type);
 
 	bool			GetContacts(List<Contact> &Contacts, ScribeFolder *f = 0, bool Deep = true);
 	List<Contact>	*GetEveryone();
 	void			HashContacts(LHashTbl<StrKey<char,false>,Contact*> &Contacts, ScribeFolder *Folder = 0, bool Deep = true);
 	
     // CapabilityInstaller impl
     LAutoString     GetHttpProxy() override;
     InstallProgress *StartAction(MissingCapsBar *Bar, LCapabilityTarget::CapsHash *Components, const char *Action) override;
     
 	class HttpImageThread *GetImageLoader();
 	int				GetMaxPages();
 	ScribeWnd::LayoutMode GetEffectiveLayoutMode();
 	ThingList		*GetMailList() { return MailList; }
 	
 	// Gets the matching mail store for a given identity
 	LMailStore		*GetMailStoreForIdentity
 	(
 		/// If this is NULL, assume the current identity
 		const char *IdEmail = NULL
 	);
 	
 	ScribeFolder	*GetFolder(int Id, LMailStore *s = NULL, bool Quiet = false);
 	ScribeFolder	*GetFolder(int Id, LDataI *s);
 	ScribeFolder	*GetFolder(const char *Name, LMailStore *s = NULL);
 	
 	ScribeFolder	*GetCurrentFolder();
 	int				GetFolderType(ScribeFolder *f);
 	LImageList		*GetIconImgList() { return ImageList; }
 	LAutoPtr<LImageList> &GetToolbarImgList() { return ToolbarImgs; }
 	LString			GetResourceFile(SribeResourceType Type);
 	DoEvery			*GetTicker() { return &Ticker; }
 	ScribeAccount	*GetSendAccount();
 	ScribeAccount	*GetCurrentAccount();
 	ThingFilter		*GetThingFilter();
 	List<ScribeAccount> *GetAccounts() { return &Accounts; }
 	ScribeAccount	*GetAccountById(int Id);
 	ScribeAccount	*GetAccountByEmail(const char *Email);
 	LPrinter		*GetPrinter();
 	int				GetActiveThreads();
 	int				GetToolbarHeight();
 	void			GetFilters(List<Filter> &Filters, bool JustIn, bool JustOut, bool JustInternal);
 	bool			OnFolderTask(LEventTargetI *Ptr, bool Add);
 	LArray<LMailStore> &GetStorageFolders() { return Folders; }
 	LMailStore		*GetDefaultMailStore();
 	LMailStore		*GetMailStoreForPath(const char *Path);
 	bool			OnMailStore(LMailStore **MailStore, bool Add);
 	ThingList		*GetItemList() { return MailList; }
 	LColour			GetColour(int i);
 	LMutex			*GetLock();
 	LFont			*GetPreviewFont();
 	LFont			*GetBoldFont() { return LSysBold; }
 	LToolBar		*LoadToolbar(LViewI *Parent, const char *File, LAutoPtr<LImageList> &Img);
 	class LVmCallback *GetDebuggerCallback();
 	class GpgConnector *GetGpgConnector();
 	void			GetUserInput(LView *Parent, LString Msg, bool Password, std::function<void(LString)> Callback);
 
 	int				GetCalendarSources(LArray<CalendarSource*> &Sources);
 
 	Store3Status	GetAccessLevel(LViewI *Parent, ScribePerm Required, const char *ResourceName, std::function<void(bool)> Callback);
 	void			GetAccountSettingsAccess(LViewI *Parent, ScribeAccessType AccessType, std::function<void(bool)> Callback);
 	const char*		EditCtrlMimeType();
 	LAutoString		GetReplyXml(const char *MimeType);
 	LAutoString		GetForwardXml(const char *MimeType);
 	bool			GetHelpFilesPath(char *Path, int PathSize);
 	bool			LaunchHelp(const char *File);
 	LAutoString		ProcessSig(Mail *m, char *Xml, const char *MimeType);
 	LString			ProcessReplyForwardTemplate(Mail *m, Mail *r, char *Xml, int &Cursor, const char *MimeType);
 	bool			LogFilterActivity();
 	ScribeFolder *FindContainer(LDataFolderI *f);
 	bool			SaveDirtyObjects(int TimeLimitMs = 100);
 	class LSpellCheck *CreateSpellObject();
 	class LSpellCheck *GetSpellThread(bool OverrideOpt = false);
 	bool			SetSpellThreadParams(LSpellCheck *Thread);
 	void			OnSpellerSettingChange();
 	bool			OnMailTransferEvent(MailTransferEvent *e);
 	LViewI			*GetView() { return this; }
 	char			*GetUiTags();
 
 	struct MailStoreUpgradeParams
 	{
 		LAutoString OldFolders;
 		LAutoString NewFolders;
 		bool Quiet;
 		LStream *Log;
 		
 		MailStoreUpgradeParams()
 		{
 		    Quiet = false;
 		    Log = 0;
 		}
 	};
 
 	// Scripting support
 	bool GetScriptCallbacks(LScriptCallbackType Type, LArray<LScriptCallback*> &Callbacks);
 	LScriptCallback GetCallback(const char *CallbackMethodName);
 	bool RegisterCallback(LScriptCallbackType Type, LScriptArguments &Args);
 	LStream *ShowScriptingConsole();
 	bool ExecuteScriptCallback(LScriptCallback &c, LScriptArguments &Args, bool ReturnArgs = false);
 	LScriptEngine *GetScriptEngine();
 
 	// Options
 	LOptionsFile	*GetOptions(bool Create = false) override;
 	bool			ScanForOptionsFiles(LArray<OptionsInfo> &Inf, LSystemPath PathType);
 	bool			LoadOptions();
 	bool			SaveOptions();
 	bool			IsSending() { return false; }
 	bool			ShowToolbarText();
 	bool			IsValid();
 
 	// Data events from storage back ends
 	bool GetSystemPath(int Folder, LVariant &Path) override;
 	void OnNew(LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new) override;
 	bool OnDelete(LDataFolderI *parent, LArray<LDataI*> &items) override;
 	bool OnMove(LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &Items) override;
 	void SetContext(const char *file, int line) override;
 	bool OnChange(LArray<LDataI*> &items, int FieldHint) override;
 	void Post(LDataStoreI *store, void *Param) override { PostEvent(M_STORAGE_EVENT, store->Id, (LMessage::Param)Param); }
 	void OnPropChange(LDataStoreI *store, int Prop, LVariantType Type) override;
 	bool Match(LDataStoreI *store, LDataPropI *Addr, int Type, LArray<LDom*> &Matches) override;
 	ContactGroup *FindGroup(char *Name);
 
 	bool AddStore3EventHandler(LDataEventsI *callback);
 	bool RemoveStore3EventHandler(LDataEventsI *callback);
 
 	// ---------------------------------------------------------------------
 	// Events
 	void			OnDelete();
 	int				OnNotify(LViewI *Ctrl, LNotification n) override;
 	void			OnPaint(LSurface *pDC) override;
     LMessage::Result OnEvent(LMessage *Msg) override;
 	int				OnCommand(int Cmd, int Event, OsView Handle) override;
 	void			OnPulse() override;
     void            OnPulseSecond();
 	bool			OnRequestClose(bool OsShuttingDown) override;
 	void			OnSelect(List<Thing> *l = 0, bool ChangeEvent = false);
 	void			OnReceiveFiles(LArray<const char*> &Files) override;
 	void			OnUrl(const char *Url) override;
 	void			OnZoom(LWindowZoom Action) override;
 	void			OnCreate() override;
 	void			OnMinute();
 	void			OnHour();
 	bool			OnIdle();
     void            OnBayesAnalyse(const char *Msg, const char *WhiteListEmail) override;
     
     /// \returns true if spam
     bool            OnBayesResult(const char *MailRef, double Rating) override;
     /// \returns true if spam
     bool            OnBayesResult(Mail *m, double Rating);
 
 	void			OnScriptCompileError(const char *Source, Filter *f);
 };
 
 ////////////////////////////////////////////////////////////////////////////////////
 #ifdef SCRIBE_APP
 #include "ScribePrivate.h"
 #endif
diff --git a/src/ScribeApp.cpp b/src/ScribeApp.cpp
--- a/src/ScribeApp.cpp
+++ b/src/ScribeApp.cpp
@@ -1,13258 +1,13266 @@
 /*
 **	FILE:			ScribeApp.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			22/10/1998
 **	DESCRIPTION:	Scribe email application
 **
 **	Copyright (C) 1998, Matthew Allen
 **		fret@memecode.com
 */
 
 // Debug defines
 // #define PRINT_OUT_STORAGE_TREE
 // #define TEST_OBJECT_SIZE
 
 #define USE_SPELLCHECKER			1
 #define USE_INTERNAL_BROWSER		1		// for help
 #define RUN_STARTUP_SCRIPTS			1
 #define PROFILE_ON_PULSE			0
 #define TRAY_CONTACT_BASE			1000
 #define TRAY_MAIL_BASE				10000
 
 // Includes
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 #include <memory>
 
 #include "Scribe.h"
 
 #include "lgi/common/StoreConvert1To2.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/OpenSSLSocket.h"
 #include "lgi/common/SoftwareUpdate.h"
 #include "lgi/common/Html.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/RichTextEdit.h"
 #include "lgi/common/Browser.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/Store3.h"
 #include "lgi/common/Growl.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/SpellCheck.h"
 #include "lgi/common/SubProcess.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/Map.h"
 #include "lgi/common/Charset.h"
 #include "lgi/common/RefCount.h"
 
 #include "ScribePrivate.h"
 #include "PreviewPanel.h"
 #include "ScribeStatusPanel.h"
 #include "ScribeFolderDlg.h"
 #include "ScribePageSetup.h"
 #include "Calendar.h"
 #include "CalendarView.h"
 #include "ScribeSpellCheck.h"
 #include "Store3Common.h"
 #include "PrintContext.h"
 #include "resource.h"
 #include "ManageMailStores.h"
 #include "ReplicateDlg.h"
 #include "ScribeAccountPreview.h"
 #include "Encryption/GnuPG.h"
 #include "Store3Webdav/WebdavStore.h"
 #include "resdefs.h"
 #include "../unittests/UnitTest.h"
 #include "../src/common/Coding/ScriptingPriv.h"
 
 #define DEBUG_STORE_EVENTS			0
 #if DEBUG_STORE_EVENTS
 #define LOG_STORE(...)				LgiTrace(__VA_ARGS__)
 #else
 #define LOG_STORE(...)
 #endif
 
 #define IDM_LOAD_MSG				2000
 #define RAISED_LOOK					0
 #define SUNKEN_LOOK					false
 #ifdef MAC
 #define SUNKEN_CTRL					false
 #else
 #define SUNKEN_CTRL					true
 #endif
 
 #if LGI_CARBON
 
 #define TRAY_ICON_NONE				-1
 #define TRAY_ICON_NORMAL			-1
 #define TRAY_ICON_MAIL				0
 #define TRAY_ICON_ERROR				1
 
 #elif defined(WIN32)
 
 #define TRAY_ICON_NORMAL			0
 #define TRAY_ICON_ERROR				1
 #define TRAY_ICON_MAIL				2
 #define TRAY_ICON_NONE				3
 
 #else
 
 #define TRAY_ICON_NONE				-1
 #define TRAY_ICON_NORMAL			0
 #define TRAY_ICON_ERROR				1
 #define TRAY_ICON_MAIL				2
 
 #endif
 
 char ScribeThingList[] = "com.memecode.ThingList";
 
 ScribeClipboardFmt *ScribeClipboardFmt::Alloc(bool ForFolders, size_t Size)
 {
 	ScribeClipboardFmt *obj = (ScribeClipboardFmt*) calloc(sizeof(ScribeClipboardFmt)+((Size-1)*sizeof(Thing*)), 1);
 	if (obj)
 	{
 		memcpy(obj->Magic, ForFolders ? ScribeFolderMagic : ScribeThingMagic, sizeof(obj->Magic));
 		obj->ProcessId = LAppInst->GetProcessId();
 		obj->Len = (uint32_t)Size;
 	}
 	return obj;
 }
 
 ScribeClipboardFmt *ScribeClipboardFmt::Alloc(List<Thing> &Lst)
 {
 	ScribeClipboardFmt *Fmt = Alloc(false, Lst.Length());
 	for (unsigned i=0; i<Lst.Length() && Fmt; i++)
 		Fmt->ThingAt(i, Lst[i]);
 	return Fmt;
 }
 
 ScribeClipboardFmt *ScribeClipboardFmt::Alloc(LArray<Thing*> &Arr)
 {
 	ScribeClipboardFmt *Fmt = Alloc(false, Arr.Length());
 	for (unsigned i=0; i<Arr.Length() && Fmt; i++)
 		Fmt->ThingAt(i, Arr[i]);
 	return Fmt;
 }
 
 bool ScribeClipboardFmt::Is(const char *Type, void *Ptr, size_t Bytes)
 {
 	// Do we have the minimum bytes for the structure?
 	if (Bytes >= sizeof(ScribeClipboardFmt) &&
 		Ptr != NULL)
 	{
 		ScribeClipboardFmt *This = (ScribeClipboardFmt*)Ptr;
 
 		// Check the magic is the right value
 		if (memcmp(This->Magic, Type, 4) != 0)
 			return false;
 
 		// Check it's from this process
 		if (This->ProcessId != LAppInst->GetProcessId())
 			return false;
 		
 		return true;
 	}
 
 	return false;
 }
 
 Thing *ScribeClipboardFmt::ThingAt(size_t Idx, Thing *Set)
 {
 	if (memcmp(Magic, ScribeThingMagic, 4))
 		return NULL;
 	if (Idx >= Len)
 		return NULL;
 	if (Set)
 		Things[Idx] = Set;
 	return Things[Idx];
 }
 
 ScribeFolder *ScribeClipboardFmt::FolderAt(size_t Idx, ScribeFolder *Set)
 {
 	if (memcmp(Magic, ScribeFolderMagic, 4))
 		return NULL;
 	if (Idx >= Len)
 		return NULL;
 	if (Set)
 		Folders[Idx] = Set;
 	return Folders[Idx];
 }
 
 size_t ScribeClipboardFmt::Sizeof()
 {
 	return sizeof(*this) + ((Len - 1) * sizeof(Thing*));
 }
 
 bool OptionSizeInKiB = false;
 bool ShowRelativeDates = false;
 const char *MailAddressDelimiters = "\t\r\n;,";
 
 char16 SpellDelim[] =
 {
 	' ', '\t', '\r', '\n', ',', ',', '.', ':', ';',
 	'{', '}', '[', ']', '!', '@', '#', '$', '%', '^', '&', '*',
 	'(', ')', '_', '-', '+', '=', '|', '\\', '/', '?', '\"',
 	0
 };
 
 const char *DefaultRfXml = 
 	"---------- %s ----------\n"
 	"%s: <mail.to[0].name> (<mail.to[0].email>)\n"
 	"%s: <mail.from.name> (<mail.from.email>)\n"
 	"%s: <mail.subject>\n"
 	"%s: <mail.datesent>\n"
 	"\n"
 	"<mail.bodyastext quote=scribe.quote>\n"
 	"<cursor>\n"
 	"<mail.sig>\n";
 
 uchar DateTimeFormats[] = 
 {
 	GDTF_DEFAULT,
 	
 	GDTF_DAY_MONTH_YEAR | GDTF_12HOUR,
 	GDTF_MONTH_DAY_YEAR | GDTF_12HOUR,
 	GDTF_YEAR_MONTH_DAY | GDTF_12HOUR,
 
 	GDTF_DAY_MONTH_YEAR | GDTF_24HOUR,
 	GDTF_MONTH_DAY_YEAR | GDTF_24HOUR,
 	GDTF_YEAR_MONTH_DAY | GDTF_24HOUR
 };
 
 SystemFolderInfo SystemFolders[] =
 {
 	{FOLDER_INBOX,		OPT_Inbox,		NULL},
 	{FOLDER_OUTBOX,		OPT_Outbox,		NULL},
 	{FOLDER_SENT,		OPT_Sent,		NULL},
 	{FOLDER_CONTACTS,	OPT_Contacts,	NULL},
 	{FOLDER_TRASH,		OPT_Trash,		NULL},
 	{FOLDER_CALENDAR,	OPT_Calendar,	OPT_HasCalendar},
 	{FOLDER_TEMPLATES,	OPT_Templates,	OPT_HasTemplates},
 	{FOLDER_FILTERS,	OPT_Filters,	OPT_HasFilters},
 	{FOLDER_GROUPS,		OPT_Groups,		OPT_HasGroups},
 	{FOLDER_SPAM,		OPT_SpamFolder,	OPT_HasSpam},
 	{-1, 0, 0}
 };
 
 ScribeBehaviour *ScribeBehaviour::New(ScribeWnd *app)
 {
 	return 0;
 }
 
 void ScribeOptionsDefaults(LOptionsFile *f)
 {
 	if (!f)
 		return;
 
 	f->CreateTag("Accounts");
 	f->CreateTag("CalendarUI");
 	f->CreateTag("CalendarUI.Sources");
 	f->CreateTag("MailUI");
 	f->CreateTag("ScribeUI");
 	f->CreateTag("Plugins");
 	f->CreateTag("Print");
 
 	#define DefaultIntOption(opt, def) { LVariant v; if (!f->GetValue(opt, v)) \
 											f->SetValue(opt, v = (int)def); }
 	#define DefaultStrOption(opt, def) { LVariant v; if (!f->GetValue(opt, v)) \
 											f->SetValue(opt, v = def); }
 	DefaultIntOption(OPT_DefaultAlternative, 1);
 	DefaultIntOption(OPT_BoldUnread, 1);
 	DefaultIntOption(OPT_PreviewLines, 1);
 	DefaultIntOption(OPT_AutoDeleteExe, 1);
 	DefaultIntOption(OPT_DefaultReplyAllSetting, MAIL_ADDR_BCC);
 	DefaultIntOption(OPT_BlinkNewMail, 1);
 	DefaultIntOption(OPT_MarkReadAfterSeconds, 5);
 	DefaultStrOption(OPT_BayesThreshold, "0.9");
 	DefaultIntOption(OPT_SoftwareUpdate, 1);
 	DefaultIntOption(OPT_ResizeImgAttachments, false);
 	DefaultIntOption(OPT_ResizeJpegQual, 80);
 	DefaultIntOption(OPT_ResizeMaxPx, 1024);
 	DefaultIntOption(OPT_ResizeMaxKb, 200);
 	DefaultIntOption(OPT_RegisterWindowsClient, 1);
 	DefaultIntOption(OPT_HasTemplates, 0);
 	DefaultIntOption(OPT_HasCalendar, 1);
 	DefaultIntOption(OPT_HasGroups, 1);
 	DefaultIntOption(OPT_HasFilters, 1);
 	DefaultIntOption(OPT_HasSpam, 0);
 }
 
 const char *Store3ItemTypeName(Store3ItemTypes t)
 {
 	switch (t)
 	{
 		case MAGIC_NONE:		return "MAGIC_NONE";
 		case MAGIC_BASE:		return "MAGIC_BASE";
 		case MAGIC_MAIL:		return "MAGIC_MAIL";
 		case MAGIC_CONTACT:		return "MAGIC_CONTACT";
 		// case MAGIC_FOLDER:		return "MAGIC_FOLDER";
 		case MAGIC_MAILBOX:		return "MAGIC_MAILBOX";
 		case MAGIC_ATTACHMENT:	return "MAGIC_ATTACHMENT";
 		case MAGIC_ANY:			return "MAGIC_ANY";
 		case MAGIC_FILTER:		return "MAGIC_FILTER";
 		case MAGIC_FOLDER:		return "MAGIC_FOLDER";
 		case MAGIC_CONDITION:	return "MAGIC_CONDITION";
 		case MAGIC_ACTION:		return "MAGIC_ACTION";
 		case MAGIC_CALENDAR:	return "MAGIC_CALENDAR";
 		case MAGIC_ATTENDEE:	return "MAGIC_ATTENDEE";
 		case MAGIC_GROUP:		return "MAGIC_GROUP";
 		default:
 			LAssert(0);
 			break;
 	}
 	
 	return "(error)";
 }
 
 void SetRecipients(ScribeWnd *App, char *Start, LDataIt l, EmailAddressType CC)
 {
 	while (Start && *Start)
 	{
 		LString Str;
 		char *End = strchr(Start, ',');
 		if (End)
 		{
 			Str.Set(Start, End-Start);
 			Start = End + 1;
 		}
 		else
 		{
 			Str = Start;
 			Start = 0;
 		}
 
 		if (Str)
 		{
 			ListAddr *a = new ListAddr(App);
 			if (a)
 			{
 				a->CC = CC;
 				
 				if (_strnicmp(Str, "mailto:", 7) == 0)
 					a->sAddr = Str(7,-1);
 				else
 					a->sAddr = Str;
 				
 				l->Insert(a);
 			}
 		}
 	}
 }
 
 static char SoftwareUpdateUri[] = "http://www.memecode.com/update.php";
 
 enum SoftwareStatus
 {
 	SwError,
 	SwCancel,
 	SwOutOfDate,
 	SwUpToDate
 };
 
 static LString ExtractVer(const char *s)
 {
 	char Buf[256], *Out = Buf;
 	for (const char *In = s; *In && Out < Buf + sizeof(Buf) - 1; In++)
 	{
 		if (*In == ' ')
 			break;
 		if (IsDigit(*In) || *In == '.')
 			*Out++ = *In;
 	}
 	*Out++ = 0;
 	return LString(Buf);
 }
 
 void IsSoftwareUpToDate(ScribeWnd *Parent, bool WithUI, bool IncBetas, std::function<void(SoftwareStatus, LSoftwareUpdate::UpdateInfo*)> callback)
 {
 	// LSoftwareUpdate::UpdateInfo Info
 	// Software update?
 	auto Proxy  = Parent->GetHttpProxy();
 	auto Update = new LSoftwareUpdate(AppName, SoftwareUpdateUri, Proxy);
 
 	Update->CheckForUpdate(
 		[WithUI, Parent, callback, Update](auto Info, auto errorMsg)
 		{
 			if (Info)
 			{
 				auto LocalVer = LString(ScribeVer).SplitDelimit(".");
 				LString BuildVer = ExtractVer(Info->Build);
 				auto OnlineVer = BuildVer.SplitDelimit(".");
 				if (OnlineVer.Length() != LocalVer.Length())
 				{
 					LgiTrace("%s:%i - Invalid online version number \"%s\"\n", _FL, Info->Version.Get());
 					if(callback)
 						callback(SwError, Info);
 					return;
 				}
 
 				unsigned i;
 				for(i = 0; i < OnlineVer.Length(); i++)
 				{
 					auto l = Atoi(LocalVer[i].Get());
 					auto o = Atoi(OnlineVer[i].Get());
 					if(l < o)
 					{
 						if(callback)
 							callback(SwOutOfDate, Info);
 						return;
 					}
 					if(l > o)
 					{
 						if(callback)
 							callback(SwUpToDate, Info);
 						return;
 					}
 				}
 
 				LDateTime Compile;
 				auto Date = LString(__DATE__).SplitDelimit(" ");
 				Compile.Month(LDateTime::MonthFromName(Date[0]));
 				Compile.Day(atoi(Date[1]));
 				Compile.Year(atoi(Date[2]));
 				Compile.SetTime(__TIME__);
 
 				bool DateGreaterThenCompile = Info->Date > Compile;
 				if (callback)
 					callback(DateGreaterThenCompile ? SwOutOfDate : SwUpToDate, Info);
 				return;
 			}
 			else if (WithUI)
 			{
 				if (callback)
 					callback(SwCancel, NULL);
 				LgiMsg(Parent, LLoadString(IDS_ERROR_SOFTWARE_UPDATE), AppName, MB_OK, errorMsg);
 			}
 
 			if (callback)
 				callback(SwError, NULL);
 		},
 		WithUI ? Parent : NULL,
 		IncBetas);
 }
 
 bool UpgradeSoftware(const LSoftwareUpdate::UpdateInfo *Info, ScribeWnd *Parent, bool WithUI)
 {
 	bool DownloadUpdate = true;
 
 	if (WithUI)
 	{
 		char Ds[64];
 		Info->Date.Get(Ds, sizeof(Ds));
 
 		DownloadUpdate = LgiMsg(Parent,
 								LLoadString(IDS_SOFTWARE_UPDATE_DOWNLOAD),
 								AppName,
 								MB_YESNO,
 								Info->Build.Get(),
 								Info->Uri.Get(),
 								Ds)
 							==
 								IDYES;
 	}
 
 	if (!DownloadUpdate)
 		return false;
 
 	LAutoString Proxy = Parent->GetHttpProxy();
 	LSoftwareUpdate Update(AppName, SoftwareUpdateUri, Proxy, ScribeTempPath());
 	// FIXME:
 	return false; // Update.ApplyUpdate(Info, false, Parent);
 }
 
 void SoftwareUpdate(ScribeWnd *Parent, bool WithUI, bool IncBetas, std::function<void(bool goingToUpdate)> callback)
 {
 	// Software update?
 	IsSoftwareUpToDate(Parent, WithUI, IncBetas, [WithUI, Parent, callback](auto s, auto Info)
 	{
 		if (s == SwUpToDate)
 		{
 			if (WithUI)
 				LgiMsg(Parent, LLoadString(IDS_SOFTWARE_CURRENT), AppName, MB_OK);
 			if (callback)
 				callback(false); // we're up to date
 		}
 		else if (s == SwOutOfDate)
 		{
 			auto status = UpgradeSoftware(Info, Parent, WithUI);
 			if (callback)
 				callback(status); // update is going to happen
 		}
 	});
 }
 
 const char *AppName = "Scribe";
 char HelpFile[] = "index.html";
 
 const char OptionsFileName[] = "ScribeOptions";
 
 const char AuthorEmailAddr[] = "fret@memecode.com";
 const char AuthorHomepage[] = "http://www.memecode.com";
 const char ApplicationHomepage[] = "http://www.memecode.com/scribe.php";
 const char CommercialHomepage[] = "http://www.memecode.com/inscribe.php";
 const char FaqHomepage[] = "http://www.memecode.com/scribe/faq.php";
 
 const char *DefaultFolderNames[16];
 Store3ItemTypes DefaultFolderTypes[] = {
 	MAGIC_MAIL,		// Inbox
 	MAGIC_MAIL,		// Outbox
 	MAGIC_MAIL,		// Sent
 	MAGIC_ANY,		// Trash
 	MAGIC_CONTACT,	// Contacts
 	MAGIC_MAIL,		// Templates
 	MAGIC_FILTER,	// Filters
 	MAGIC_CALENDAR,	// Calendar Events
 	MAGIC_GROUP,	// Groups
 	MAGIC_MAIL,		// Spam
 	MAGIC_NONE,
 	MAGIC_NONE,
 	MAGIC_NONE,
 	MAGIC_NONE
 };
 
 extern void Log(char *File, char *Str, ...);
 
 //////////////////////////////////////////////////////////////////////////////
 void LogMsg(char *str, ...)
 {
 	#ifdef _DEBUG
 	char f[256];
 	LMakePath(f, sizeof(f), LGetExePath(), "log.txt");
 
 	if (str)
 	{
 		char buffer[256];
 		va_list arg;
 		va_start(arg ,str);
 		vsprintf_s(buffer, sizeof(buffer), str, arg);
 		va_end(arg);
 
 		LFile File;
 		while (!File.Open(f, O_WRITE))
 		{
 			LSleep(5);
 		}
 
 		File.Seek(File.GetSize(), SEEK_SET);
 		File.Write(buffer, strlen(buffer));
 	}
 	else
 	{
 		FileDev->Delete(f, false);
 	}
 	#endif
 }
 
 LString GetFullAppName(bool Platform)
 {
 	LString Ret = AppName;
 	if (Platform)
 	{
 		LString s;
 		const char *Build = 
 			#ifndef _DEBUG
 			"Release";
 			#else
 			"Debug";
 			#endif
 		
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		const char *OsName = LGetOsName();
 		if (Os == LGI_OS_WIN9X)
 		{
 			switch (Ver[1])
 			{
 				case 0:
 					OsName = "Win95";
 					break;
 				case 10:
 					OsName = "Win98";
 					break;
 				case 90:
 					OsName = "WinME";
 					break;
 			}
 		}
 		else if (Os == LGI_OS_WIN32 ||
 				 Os == LGI_OS_WIN64)
 		{
 			if (Ver[0] < 5)
 			{
 				OsName = "WinNT";
 			}
 			else if (Ver[0] == 5)
 			{
 				if (Ver[1] == 0)
 					OsName = "Win2k";
 				else
 					OsName = "WinXP";
 			}
 			else if (Ver[0] == 6)
 			{
 				if (Ver[1] == 0)
 					OsName = "Vista";
 				else if (Ver[1] == 1)
 					OsName = "Win7";
 				else if (Ver[1] == 2)
 					OsName = "Win8";
 				else if (Ver[1] == 3)
 					OsName = "Win8.1";
 			}
 			else if (Ver[0] == 10)
 			{
 				OsName = "Win10";
 			}
 			else if (Ver[0] == 11)
 			{
 				// What's the chances eh?
 				OsName = "Win11";
 			}
 		}
 
 		s.Printf(" v%s (%s v", ScribeVer, OsName);
 		Ret += s;
 		
 		for (unsigned i=0; i<Ver.Length(); i++)
 		{
 			s.Printf("%s%i", i?".":"", Ver[i]);
 			Ret += s;
 		}
 		
 		s.Printf(", %s", Build);
 		Ret += s;
 	
 		#ifdef LINUX
 		const char *Wm = NULL;
 		switch (LGetWindowManager())
 		{
 			case WM_Gnome:
 				Wm = "Gnome";
 				break;
 			case WM_Kde:
 				Wm = "Kde";
 				break;
 		}
 		if (Wm)
 		{
 			s.Printf(", %s", Wm);
 			Ret += s;
 		}
 		#endif
 		
 		LLanguage *CurLang = LGetLanguageId();
 		if (CurLang)
 		{
 			s.Printf(", %s", CurLang->Id);
 			Ret += s;
 		}
 		
 		s.Printf(")");
 		Ret += s;
 	}
 	
 	return Ret;
 }
 
 bool MatchWord(char *Str, char *Word)
 {
 	bool Status = false;
 	
 	if (Str && Word)
 	{
 		#define IsWord(c)	( IsDigit(c) || IsAlpha(c) )
 		for (char *s=stristr(Str, Word); s; s=stristr(s+1, Word))
 		{
 			char *e = s + strlen(Word);
 			if (	(s<=Str || !IsWord(s[-1]) )	&&
 					(e[0] == 0 || !IsWord(e[0]))	)
 			{
 				return true;
 			}
 		}
 	}
 
 	return Status;
 }
 
 
 
 //////////////////////////////////////////////////////////////////////////////
 ScribePanel::ScribePanel(ScribeWnd *app, const char *name, int size, bool open) :
 	LPanel(name, size, open)
 {
 	App = app;
 }
 
 bool ScribePanel::Pour(LRegion &r)
 {
 	if (App)
 	{
 		SetClosedSize(App->GetToolbarHeight());
 	}
 
 	return LPanel::Pour(r);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 class NoContactType : public Contact
 {
 	LString NoFace80Path;
 	LString NoFace160Path;
 
 public:
 	NoContactType(ScribeWnd *wnd) : Contact(wnd)
 	{
 	}
 
 	Thing &operator =(Thing &c) override
 	{
 		return *this;
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array) override
 	{
 		ScribeDomType Fld = StrToDom(Name);
 		int Px = Array ? atoi(Array) : 80;
 		LString &Str = Px == 160 ? NoFace160Path : NoFace80Path;
 
 		if (!Str)
 		{
 			LString f;
 			f.Printf("NoFace%i.png", Px);
 			Str = LFindFile(f);
 			LAssert(Str != NULL); // This should always resolve.
 		}
 
 		if (!Str)
 			return false;
 
 		if (Fld == SdImageHtml)
 		{
 			LString html;
 			html.Printf("<img src='file://%s'>\n", Str.Get());
 			Value = html;
 			return true;
 		}
 		else if (Fld == SdImage)
 		{
 			Value = Str;
 			return true;
 		}
 
 		return false;
 	}
 };
 
 class ScribeWndPrivate :
 	public LBrowser::LBrowserEvents,
 	public LVmCallback,
 	public LHtmlStaticInst
 {
 	LOptionsFile::PortableType InstallMode = LOptionsFile::UnknownMode;
 
 public:
 	ScribeWnd		*App;
 	
 	uint64          LastTs = 0;
 	int				ClipboardFormat = 0;
 	LFont			*PreviewFont = NULL;
 	int				PrintMaxPages = -1;
 	int				NewMailTimeout = -1;
 	bool			SendAfterReceive = false;
 	bool			IngoreOnClose = false;
 	LAutoString		UiTags;
 	LAutoPtr<LGrowl> Growl;
 	LArray<Contact*> TrayMenuContacts;
 	bool            ExitAfterSend = false;
 	LToolButton		*ShowConsoleBtn = NULL;
 	LString			MulPassword;
 	LString			CalendarSummary;
 	LBox			*SubSplit = NULL, *SearchSplit = NULL;
 	LArray<ScribeFolder*> ThingSources;
 	int				LastLayout = 0;
 	LMenuItem		*DisableUserFilters = NULL;
 	LAutoPtr<LOptionsFile> Options;
 	HttpImageThread	*ImageLoader = NULL;
 	int				LastMinute = -1, LastHour = -1;
 	LArray<LDataEventsI*> Store3EventCallbacks;
 	LAutoPtr<LPrinter> PrintOptions;
 	LHashTbl<IntKey<SribeResourceType,ResNone>, LString> ResFiles;
 
 	// These are for the LDataEventsI callbacks to store source context
 	// Mainly for debugging where various events came from.
 	const char		*CtxFile = NULL;
 	int				CtxLine = 0;
 
 	// Contact no face images
 	LAutoRefPtr<NoContactType> NoContact;
 	
 	// Remote content white/blacklists
 	bool RemoteContent_Init = false;
 	LString::Array RemoteWhiteLst, RemoteBlackLst;
 
 	// Spell checking
 	int AppWndHnd;
 	LAutoPtr<LSpellCheck> SpellerThread;
 
 	// Missing caps
 	LCapabilityTarget::CapsHash MissingCaps;
 	MissingCapsBar *Bar = NULL;
 	LString ErrSource; // Script file that has an error.
 	Filter *ErrFilter = NULL; // Filter that has scripting error.
 
 	// Load state
 	bool			FoldersLoaded = false;	
 
 	// Bayesian filter
 	LStringPipe BayesLog;
 
 	// Thread item processing
 	LArray<MailTransferEvent*> Transfers;
 
 	// Scripting...
 	LAutoPtr<LScriptEngine> Engine;
 	LArray<LScript*> Scripts;
 	LArray<LScript*> CurrentScripts;
 	LScript *CurrentScript() { return CurrentScripts.Length() ? CurrentScripts.Last() : NULL; }
 	int NextToolMenuId = IDM_TOOL_SCRIPT_BASE;
 	LAutoPtr<LScriptUi> ScriptToolbar;
 	LArray<LScriptCallback*> OnSecondTimerCallbacks;
 
 	// Encryption
 	LAutoPtr<GpgConnector> GpgInst; 
 
 	// Unit tests
 	LAutoPtr<LUnitTestServer> UnitTestServer;
 
 	class ScribeTextControlFactory : public LViewFactory
 	{
 		ScribeWnd *Wnd;
 
 		LView *NewView(const char *Class, LRect *Pos, const char *Text)
 		{
 			if (!_stricmp(Class, "ScribeTextView"))
 				return Wnd->CreateTextControl(-1, 0, true);
 			return NULL;
 		}
 
 	public:
 		ScribeTextControlFactory(ScribeWnd *wnd)
 		{
 			Wnd = wnd;
 		}
 	} TextControlFactory;
 
 	ScribeWndPrivate(ScribeWnd *app) :
 		App(app),
 		TextControlFactory(app)
 	{
 		NoContact = new NoContactType(app);
 		NoContact->DecRef(); // 2->1
 		AppWndHnd = LEventSinkMap::Dispatch.AddSink(App);
 
 		#ifdef WIN32
 		ClipboardFormat = RegisterClipboardFormat(
 			#ifdef UNICODE
 			L"Scribe.Item"
 			#else
 			"Scribe.Item"
 			#endif
 			);
 		#endif
 
 		LScribeScript::Inst = new LScribeScript(App);
 		if (Engine.Reset(new LScriptEngine(App, LScribeScript::Inst, this)))
 			Engine->SetConsole(LScribeScript::Inst->GetLog());
 	}
 
 	~ScribeWndPrivate()
 	{
 		// Why do we need this? ~LView will take care of it?
 		// LEventSinkMap::Dispatch.RemoveSink(App);
 		Options.Reset();
 		Scripts.DeleteObjects();
 		DeleteObj(ImageLoader);
 		Engine.Reset();
 		DeleteObj(LScribeScript::Inst);
 	}
 
 	LGrowl *GetGrowl()
 	{
 		if (!Growl &&
 			Growl.Reset(new LGrowl))
 		{
 			LAutoPtr<LGrowl::LRegister> r(new LGrowl::LRegister);
 			r->App = "Scribe";
 			r->IconUrl = "http://memecode.com/images/scribe/growl-app.png";
 			
 			LGrowl::LNotifyType &NewMail = r->Types.New();
 			NewMail.Name = "new-mail";
 			NewMail.IconUrl = "http://memecode.com/images/scribe/growl-new-mail.png";
 			NewMail.Enabled = true;
 
 			LGrowl::LNotifyType &Cal = r->Types.New();
 			Cal.Name = "calendar";
 			Cal.IconUrl = "http://memecode.com/images/scribe/growl-calendar.png";
 			Cal.Enabled = true;
 
 			LGrowl::LNotifyType &Debug = r->Types.New();
 			Debug.Name = "debug";
 			Debug.IconUrl = "http://memecode.com/images/scribe/growl-bug.png";
 			Debug.Enabled = false;
 
 			LGrowl::LNotifyType &Info = r->Types.New();
 			Info.IconUrl = "http://memecode.com/images/scribe/growl-note.png";
 			Info.Name = "info";
 			Info.Enabled = true;
 
 			Growl->Register(r);
 		}
 		
 		return Growl;
 	}
 
 	LVmDebugger *AttachVm(LVirtualMachine *Vm, LCompiledCode *Code, const char *Assembly)
 	{
 		LVariant v;
 		if (Options)
 			Options->GetValue(OPT_ScriptDebugger, v);
 		if (v.CastInt32())
 			return new LVmDebuggerWnd(App, this, Vm, Code, NULL);
 		
 		return NULL;
 	}
 
 	bool CallCallback(LVirtualMachine &Vm, LString CallbackName, LScriptArguments &Args)
 	{
 		for (auto s: Scripts)
 		{
 			if (!s->Code)
 				continue;
 
 			auto Method = s->Code->GetMethod(CallbackName);
 			if (!Method)
 				continue;
 
 			auto Status = Vm.ExecuteFunction(s->Code, Method, Args);
 			return Status > ScriptError;
 		}
 
 		Vm.SetDebuggerEnabled(true); // Lets show the UI when we throw the callback not found error.
 		Args.Throw(_FL, "There is no function '%s' for callback.", CallbackName.Get());
 		return false;
 	}
 
 	bool CompileScript(LAutoPtr<LCompiledCode> &Output, const char *FileName, const char *Source)
 	{
 		LCompiler c;
 		return c.Compile(Output, Engine->GetSystemContext(), LScribeScript::Inst, FileName, Source, NULL);
 	}
 
 	bool OnSearch(LBrowser *br, const char *txt)
 	{
 		char Path[256];
 		if (!App->GetHelpFilesPath(Path, sizeof(Path)))
 			return false;
 
 		auto Terms = LString(txt).SplitDelimit(", ");
 
 		LStringPipe p;
 		p.Print("<html>\n<body><h1>Search Results</h1>\n<ul>\n");
 		LDirectory Dir;
 		for (int b = Dir.First(Path, "*.html"); b; b = Dir.Next())
 		{
 			if (!Dir.IsDir())
 			{
 				char Path[256];
 				Dir.Path(Path, sizeof(Path));
 				LFile f;
 				if (f.Open(Path, O_READ))
 				{
 					LXmlTree t(GXT_NO_DOM);
 					LXmlTag r;
 					if (t.Read(&r, &f))
 					{
 						char *PrevName = 0;
 						char PrevUri[256] = "";
 						for (auto c: r.Children)
 						{
 							if (c->IsTag("a"))
 							{
 								char *Name = c->GetAttr("name");
 								if (Name)
 								{
 									PrevName = Name;
 								}
 							}
 							else if (c->GetContent())
 							{
 								bool Hit = false;
 								for (unsigned i=0; !Hit && i<Terms.Length(); i++)
 								{
 									Hit = stristr(c->GetContent(), Terms[i]) != 0;
 								}
 								if (Hit)
 								{
 									LStringPipe Uri(256);
 									char *Leaf = strrchr(Path, DIR_CHAR);
 									Leaf = Leaf ? Leaf + 1 : Path;
 									
 									Uri.Print("file://%s", Path);
 									if (PrevName)
 										Uri.Print("#%s", PrevName);
 									
 									LAutoString UriStr(Uri.NewStr());
 									
 									if (_stricmp(UriStr, PrevUri))
 									{
 										p.Print("<li> <a href='%s'>%s",
 												UriStr.Get(),
 												Leaf);
 										if (PrevName)
 											p.Print("#%s", PrevName);
 										p.Print("</a>\n");
 										
 										strcpy_s(PrevUri, sizeof(PrevUri), UriStr);
 									}
 								}
 							}
 						}
 					}
 				}
 			}
 		}
 
 		p.Print("</ul>\n</body>\n</html>\n");
 		LAutoString Html(p.NewStr());
 		br->SetHtml(Html);
 		return true;
 	}
 
 	void AskUserForInstallMode(std::function<void(LOptionsFile::PortableType)> callback)
 	{
 		auto Dlg = new LAlert(App,
 							AppName,
 							LLoadString(IDS_PORTABLE_Q),
 							LLoadString(IDS_HELP),
 							LLoadString(IDS_DESKTOP),
 							LLoadString(IDS_PORTABLE));
 		
 		Dlg->SetButtonCallback(1, [this](auto idx)
 		{
 			App->LaunchHelp("install.html");
 		});
 
 		Dlg->DoModal([callback](auto dlg, auto Btn)
 		{
 			if (Btn == 1)
 			{
 				// Help
 				LAssert(!"Help btn should use callback.");
 			}
 			else if (Btn == 2)
 			{
 				// Desktop
 				if (callback)
 					callback(LOptionsFile::DesktopMode);
 			}
 			else if (Btn == 3)
 			{
 				// Portable
 				if (callback)
 					callback(LOptionsFile::PortableMode);
 			}
 			else
 			{
 				delete dlg;
 				LAppInst->Exit(1);
 			}
 
 			delete dlg;
 		});
 	}
 
 	LOptionsFile::PortableType GetInstallMode()
 	{
 		if (InstallMode == LOptionsFile::UnknownMode)
 		{
 			if (LAppInst->GetOption("portable"))
 			{
 				InstallMode = LOptionsFile::PortableMode;
 				LgiTrace("Selecting portable mode based on -portable switch.\n");
 			}
 			else if (LAppInst->GetOption("desktop"))
 			{
 				InstallMode = LOptionsFile::DesktopMode;
 				LgiTrace("Selecting portable mode based on -desktop switch.\n");
 			}
 		}
 
 		if (InstallMode == LOptionsFile::UnknownMode)
 		{
 			bool PortableIsPossible = true;
 			
 			char Inst[MAX_PATH_LEN] = "";
 			LGetSystemPath(LSP_APP_INSTALL, Inst, sizeof(Inst));
 			
 			// Do write check
 			char Wr[MAX_PATH_LEN];
 			LMakePath(Wr, sizeof(Wr), Inst, "_write_test.txt");
 			LFile f;
 			if (f.Open(Wr, O_WRITE))
 			{
 				// Clean up
 				f.Close();
 				FileDev->Delete(Wr, false);
 			}
 			else
 			{
 				// No write perms
 				PortableIsPossible = false;
 			}
 			
 			if (PortableIsPossible && LAppInst->IsElevated())
 			{
 				// Check if the install is in some read only location:
 				// e.g. c:\Program Files
 				char Pm[MAX_PATH_LEN];
 				if (LGetSystemPath(LSP_USER_APPS, Pm, sizeof(Pm)))
 				{
 					size_t n = strlen(Pm);
 					PortableIsPossible = _strnicmp(Pm, Inst, n) != 0;
 					// LgiMsg(App, "%i\n%s\n%s", AppName, MB_OK, PortableIsPossible, Pm, Inst);
 				}
 				else LgiTrace("%s:%i - Failed to get paths.", _FL);
 			}
 
 			if (PortableIsPossible)
 			{
 				// Basically "ask the user" here...
 				return LOptionsFile::UnknownMode;
 			}
 			else
 			{
 				InstallMode = LOptionsFile::DesktopMode;
 				LgiTrace("Selecting Desktop based on lack of write permissions to install folder.\n");
 			}
 		}
 
 		return InstallMode;
 	}
 
 	void SetInstallMode(LOptionsFile::PortableType t)
 	{
 		InstallMode = t;
 	}
 
 	void DeleteCallbacks(LArray<LScriptCallback> &Callbacks)
 	{
 		for (unsigned i=0; i<Callbacks.Length(); i++)
 		{
 			if (Callbacks[i].Type == LToolsMenu &&
 				Callbacks[i].Param)
 			{
 				auto it = App->GetMenu()->FindItem(Callbacks[i].Param);
 				if (it)
 				{
 					it->Remove();
 					DeleteObj(it);
 				}
 			}
 		}
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 void UpgradeRfOption(ScribeWnd *App, const char *New, const char *Old, const char *Default)
 {
 	LVariant v;
 
 	/*
 	App->GetOptions()->GetValue(New, v);
 	if (v.Str())
 	{
 		ScribePath *Path = new ScribePath(App, Old);
 		if (Path)
 		{
 			char *Xml = LReadTextFile(*Path);
 			if (Xml)
 			{
 				App->GetOptions()->SetValue(New, v = Xml);
 				DeleteArray(Xml);
 			}
 			App->GetOptions()->DeleteValue(Old);
 			DeleteObj(Path);
 		}
 	}
 	*/
 
 	if (Default && !App->GetOptions()->GetValue(New, v))
 	{
 		App->GetOptions()->SetValue(New, v = Default);
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////
 ScribeWnd::AppState ScribeWnd::ScribeState = ScribeConstructing;
 
 
 /*
  * This constructor is a little convoluted, but the basic idea is this:
  * 
  * - Do some basic init.
  * - Attempt to load the options (could make portable/desktop mode clear)
  * - If the portable/desktop mode is unclear ask the user.
  * - Call AppConstruct1.
  * - If the UI language is not known, ask the user.
  * - Call AppConstruct2.
  * 
  * Each time a dialog is needed the rest of the code needs to be in a callable function.
  * 
  * It's important to note that the ScribeWnd::OnCreate method needs to be called after
  * the system Handle() is created, and after any dialogs in the ScribeWnd::ScribeWnd
  * constructor have finished.
  */
 ScribeWnd::ScribeWnd() :
 	BayesianFilter(this),
 	CapabilityInstaller("Scribe",
 						ScribeVer,
 						"http://memecode.com/components/lookup.php",
 						ScribeTempPath()),
 	TrayIcon(this)
 {
 	if (_Lock)
 		_Lock->SetName("ScribeWnd");
 
 	// init some variables
 	LApp::ObjInstance()->AppWnd = this;
 	LCharsetSystem::Inst()->DetectCharset = ::DetectCharset;
 	d = new ScribeWndPrivate(this);
 	ScribeIpc = new LSharedMemory("Scribe", SCRIBE_INSTANCE_MAX * sizeof(ScribeIpcInstance));
 	if (ScribeIpc && ScribeIpc->GetPtr())
 	{
 		ScribeIpcInstance *InstLst = (ScribeIpcInstance*) ScribeIpc->GetPtr();
 		for (int i=0; i<SCRIBE_INSTANCE_MAX; i++)
 		{
 			if (InstLst[i].Valid())
 			{
 				if (!LIsProcess(InstLst[i].Pid))
 				{
 					LgiTrace("Crashed instance %i\n", InstLst[i].Pid);
 					InstLst[i].Clear();
 				}
 			}
 			else if (!ThisInst)
 			{
 				ThisInst = InstLst + i;
 				memset(ThisInst, 0, sizeof(ScribeIpcInstance));
 				ThisInst->Magic = SCRIBE_INSTANCE_MAGIC;
 				ThisInst->Pid = LProcessId();
 				
 				// LgiTrace("Install Scribe pid=%i to pos=%i\n", LProcessId(), i);
 			}
 		}
 	}
 	else DeleteObj(ScribeIpc);
 
 	#ifndef WIN32
 	printf("%s\n", GetFullAppName(true).Get());
 	#endif
 
 	auto Type = d->GetInstallMode();
 
 	if (Type == LOptionsFile::UnknownMode)
 	{
 		 // This may make the mode more clear...
 		if (LoadOptions())
 			Type = d->GetInstallMode();
 	}
 
 	if (Type == LOptionsFile::UnknownMode)
 	{
 		d->AskUserForInstallMode([this](auto selectedMode)
 		{
 			d->SetInstallMode(selectedMode);
 
 			if (!d->Options)
 				d->Options.Reset(new LOptionsFile(selectedMode, OptionsFileName));
 
 			Construct1();
 		});
 	}
 	else Construct1();
 }
 
 void ScribeWnd::Construct1()
 {
 	if (!d->Options && !LoadOptions())
 	{
 		ScribeState = ScribeExiting;
 		return;
 	}
 	ScribeOptionsDefaults(d->Options);
 
 	LVariant GlyphSub;
 	if (GetOptions()->GetValue(OPT_GlyphSub, GlyphSub))
 	{
 		bool UseGlyphSub = GlyphSub.CastInt32() != 0;
 		LSysFont->SubGlyphs(UseGlyphSub);
 		LSysBold->SubGlyphs(UseGlyphSub);
 		LFontSystem::Inst()->SetDefaultGlyphSub(UseGlyphSub);
 	}
 	else
 	{
 		GetOptions()->SetValue(OPT_GlyphSub, GlyphSub = LFontSystem::Inst()->GetDefaultGlyphSub());
 	}
 
 	{
 		// Limit the size of the 'Scribe.txt' log file
 		if (auto p = LgiTraceGetFilePath())
 		{
 			int64 Sz = LFileSize(p);
 			#define MiB * 1024 * 1024
 			if (Sz > (3 MiB))
 				FileDev->Delete(p);
 		}
 	}
 
 	// Process pre-UI options
 	LVariant SizeAdj;
 	int SzAdj = SizeAdj.CastInt32();
 	if (GetOptions()->GetValue(OPT_UiFontSize, SizeAdj) &&
 		(SzAdj = SizeAdj.CastInt32()) >= 0 &&
 		SzAdj < 5)
 	{
 		SzAdj -= 2;
 		if (SzAdj)
 		{
 			int Pt = LSysFont->PointSize();
 		
 			LSysFont->PointSize(Pt + SzAdj);
 			LSysFont->Create();
 
 			LSysBold->PointSize(Pt + SzAdj);
 			LSysBold->Create();
 		
 			LFont *m = LMenu::GetFont();
 			if (m)
 			{
 				m->PointSize(m->PointSize() + SzAdj);
 				m->Create();
 			}
 		}
 	}
 	else
 	{
 		GetOptions()->SetValue(OPT_UiFontSize, SizeAdj = 2);
 	}
 
 	// Resources and languages
 	SetLanguage();
 
 	// If no language set...
 	LVariant LangId;
 	if (!GetOptions()->GetValue(OPT_UiLanguage, LangId))
 	{
 		// Ask the user...
 		auto Dlg = new LanguageDlg(this);
 		if (!Dlg->Ok)
 		{
 			delete Dlg;
 			LgiMsg(this, "Failed to create language selection dialog.", "Scribe Error");
 			ScribeState = ScribeExiting;
 			LCloseApp();
 		}
 		else
 		{
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 				{
 					// Set the language in the options file
 					LVariant v;
 					GetOptions()->SetValue(OPT_UiLanguage, v = Dlg->Lang.Get());
 		
 					// Reload the resource file... to get the new lang.
 					LResources *Cur = LgiGetResObj(false);
 					DeleteObj(Cur);
 
 					SetLanguage();
 					Construct2();
 				}
 				else // User canceled
 				{
 					ScribeState = ScribeExiting;
 					LCloseApp();
 				}
 				delete dlg;
 			});
 		}
 	}
 	else Construct2();
 }
 
 void ScribeWnd::Construct2()
 {
 	#if 1
 	auto CurRes = LgiGetResObj(false);
 	LVariant Theme;
 	if (CurRes && GetOptions()->GetValue(OPT_Theme, Theme))
 	{
 		auto Paths = ScribeThemePaths();
 		auto NoTheme = LLoadString(IDS_DEFAULT);
 		if (Theme.Str() &&
 			Stricmp(NoTheme, Theme.Str()))
 		{
 			for (auto p: Paths)
 			{
 				LFile::Path Inst(p);
 				Inst += Theme.Str();
 				if (Inst.Exists())
 				{
 					CurRes->SetThemeFolder(Inst);
 					d->Static->OnSystemColourChange();
 					break;
 				}
 			}
 		}
 	}
 	#endif
 
 	LoadCalendarStringTable();
 
 	ZeroObj(DefaultFolderNames);
 	DefaultFolderNames[FOLDER_INBOX]     = LLoadString(IDS_FOLDER_INBOX, "Inbox");
 	DefaultFolderNames[FOLDER_OUTBOX]    = LLoadString(IDS_FOLDER_OUTBOX, "Outbox");
 	DefaultFolderNames[FOLDER_SENT]      = LLoadString(IDS_FOLDER_SENT, "Sent");
 	DefaultFolderNames[FOLDER_TRASH]     = LLoadString(IDS_FOLDER_TRASH, "Trash");
 	DefaultFolderNames[FOLDER_CONTACTS]  = LLoadString(IDS_FOLDER_CONTACTS, "Contacts");
 	DefaultFolderNames[FOLDER_TEMPLATES] = LLoadString(IDS_FOLDER_TEMPLATES, "Templates");
 	DefaultFolderNames[FOLDER_FILTERS]   = LLoadString(IDS_FOLDER_FILTERS, "Filters");
 	DefaultFolderNames[FOLDER_CALENDAR]  = LLoadString(IDS_FOLDER_CALENDAR, "Calendar");
 	DefaultFolderNames[FOLDER_GROUPS]    = LLoadString(IDS_FOLDER_GROUPS, "Groups");
 	DefaultFolderNames[FOLDER_SPAM]      = LLoadString(IDS_SPAM, "Spam");
 
 	LStringPipe RfXml;
 	RfXml.Print(DefaultRfXml,
 				LLoadString(IDS_ORIGINAL_MESSAGE),
 				LLoadString(FIELD_TO),
 				LLoadString(FIELD_FROM),
 				LLoadString(FIELD_SUBJECT),
 				LLoadString(IDS_DATE));
 	{
 		LAutoString Xml(RfXml.NewStr());
 		UpgradeRfOption(this, OPT_TextReplyFormat, "ReplyXml", Xml);
 		UpgradeRfOption(this, OPT_TextForwardFormat, "ForwardXml", Xml);
 	}
 
 	LFontType t;
 	if (t.GetSystemFont("small"))
 	{
 		d->PreviewFont = t.Create();
 		if (d->PreviewFont)
 		{
 			#if defined WIN32
 			d->PreviewFont->PointSize(8);
 			#endif
 		}
 	}
 
 	MoveOnScreen();
 
 	// Load global graphics
 	LoadImageResources();
 
 	// Load time threads
 	// Window name
 	Name(AppName);
 	SetSnapToEdge(true);
 	ClearTempPath();
 
 	#if WINNATIVE
 	SetStyle(GetStyle() & ~WS_VISIBLE);
 	SetExStyle(GetExStyle() & ~WS_EX_ACCEPTFILES);
 	CreateClassW32(AppName, LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_APP)));
 	#endif
 
 	#if defined LINUX
 	SetIcon("About64px.png");
 	LFinishXWindowsStartup(this);
 	#endif
 
 	ScribeState = ScribeConstructed;
 	OnCreate();
 }
 
 void ScribeWnd::Construct3()
 {
 	if (ScribeState == ScribeConstructing)
 	{
 		// Constructor is still running, probably showing some UI.
 		// Don't complete setup at this point.
 		return;
 	}
 
 	// Load the styles
 	LResources::StyleElement(this);
 
 	// Main menu
 	Menu = new LMenu(AppName);
 	if (Menu)
 	{
 		Menu->Attach(this);
 		if (Menu->Load(this, "ID_MENU", GetUiTags()))
 		{
 			LAssert(ImageList != NULL);
 			Menu->SetImageList(ImageList, false);
 
 			auto IdentityItem = Menu->FindItem(IDM_NO_IDENTITIES);
 			if (IdentityItem)
 			{
 				IdentityMenu = IdentityItem->GetParent();
 			}
 
 			CmdSend.MenuItem = Menu->FindItem(IDM_SEND_MAIL);
 			auto NewMailMenu = Menu->FindItem(IDM_NEW_EMAIL);
 			if (NewMailMenu)
 			{
 				MailMenu = NewMailMenu->GetParent();
 			}
 
 			LVariant v;
 			WorkOffline = Menu->FindItem(IDM_WORK_OFFLINE);
 			if (WorkOffline && GetOptions()->GetValue(OPT_WorkOffline, v))
 			{
 				WorkOffline->Checked(v.CastInt32() != 0);
 			}
 
 			if ((d->DisableUserFilters = Menu->FindItem(IDM_FILTERS_DISABLE)))
 			{
 				if (GetOptions()->GetValue(OPT_DisableUserFilters, v))
 				{
 					d->DisableUserFilters->Checked(v.CastInt32() != 0);
 				}
 			}
 
 			#if RUN_STARTUP_SCRIPTS
 			// Run scripts in './Scripts' folder
 			char s[MAX_PATH_LEN];
 			LMakePath(s, sizeof(s), ScribeResourcePath(),
 				"scripts");
 			if (!LDirExists(s))
 				LMakePath(s, sizeof(s), LGetSystemPath(LSP_APP_INSTALL),
 					#if defined(LINUX) || defined(WINDOWS)
 					"..\\"
 					#endif
 					"scripts");
 			if (!LDirExists(s))
 				LgiTrace("%s:%i - Error: the scripts folder '%s' doesn't exist.\n", _FL, s);
 			else
 			{
 				bool ErrorDsp = false;
 				LDirectory Dir;
 				for (int b = Dir.First(s); b; b = Dir.Next())
 				{
 					if (Dir.IsDir())
 						continue;
 
 					char *Ext = LGetExtension(Dir.GetName());
 					if (!Ext || _stricmp(Ext, "script") != 0)
 						continue;
 
 					Dir.Path(s, sizeof(s));
 
 					LStringPipe Log;
 					char *Source = LReadTextFile(s);
 					if (Source)
 					{
 						LScript *Cur = new LScript;
 						if (Cur)
 						{
 							char Msg[256];
 							d->CurrentScripts.Add(Cur);
 							LScribeScript::Inst->GetLog()->Write(Msg,
 								sprintf_s(Msg, sizeof(Msg), "Compiling '%s'...\n", Dir.GetName()));
 
 							LCompiler c;
 							if (c.Compile(	Cur->Code,
 											d->Engine->GetSystemContext(),
 											LScribeScript::Inst,
 											s,
 											Source,
 											NULL))
 							{
 								LFunctionInfo *Main = Cur->Code->GetMethod("Main");
 								if (Main)
 								{
 									LVirtualMachine Vm(d);
 									
 									LScriptArguments Args(&Vm);
 									Args.New() = new LVariant((LDom*)this);
 									d->Scripts.Add(Cur);
 									if (Vm.ExecuteFunction(	Cur->Code,
 															Main,
 															Args,
 															LScribeScript::Inst->GetLog()) &&
 										Args.GetReturn()->CastInt32())
 									{
 										d->CurrentScripts.Delete(Cur, true);
 										Cur = NULL;
 									}
 									else
 									{
 										LgiTrace("Error: Script's main failed (%s)\n", Cur->Code->GetFileName());
 										if (Cur->Callbacks.Length())
 											d->DeleteCallbacks(Cur->Callbacks);
 										d->Scripts.Delete(Cur);
 									}
 
 									Args.DeleteObjects();
 								}
 							}
 							else if (!ErrorDsp)
 							{
 								ErrorDsp = true;
 								OnScriptCompileError(Source, NULL);
 							}
 
 							if (Cur)
 							{
 								d->CurrentScripts.Delete(Cur, true);
 								DeleteObj(Cur);
 							}
 						}
 
 						DeleteArray(Source);
 					}
 				}
 
 			}
 			#endif
 
 			#define EnableItem(id, en) { auto i = Menu->FindItem(id); if (i) i->Enabled(en); }
 			#define SetMenuIcon(id, ico) { auto i = Menu->FindItem(id); if (i) i->Icon(ico); }
 			
 			EnableItem(IDM_IMPORT_OUTLOOK_ITEMS, true);
 			
 			// SetMenuIcon(IDM_OPEN_FOLDERS, ICON_OPEN_FOLDER);
 			SetMenuIcon(IDM_OPTIONS, ICON_OPTIONS);
 			SetMenuIcon(IDM_SECURITY, ICON_LOCK);
 
 			SetMenuIcon(IDM_CUT, ICON_CUT);
 			SetMenuIcon(IDM_COPY, ICON_COPY);
 			SetMenuIcon(IDM_PASTE, ICON_PASTE);
 
 			SetMenuIcon(IDM_LAYOUT1, ICON_LAYOUT1);
 			SetMenuIcon(IDM_LAYOUT2, ICON_LAYOUT2);
 			SetMenuIcon(IDM_LAYOUT3, ICON_LAYOUT3);
 			SetMenuIcon(IDM_LAYOUT4, ICON_LAYOUT4);
 			SetMenuIcon(IDM_NEW_EMAIL, ICON_UNSENT_MAIL);
 			SetMenuIcon(IDM_SET_READ, ICON_READ_MAIL);
 			SetMenuIcon(IDM_SET_UNREAD, ICON_UNREAD_MAIL);
 			SetMenuIcon(IDM_NEW_CONTACT, ICON_CONTACT);
 			SetMenuIcon(IDM_NEW_GROUP, ICON_CONTACT_GROUP);
 			SetMenuIcon(IDM_REPLY, ICON_FLAGS_REPLY);
 			SetMenuIcon(IDM_REPLY_ALL, ICON_FLAGS_REPLY);
 			SetMenuIcon(IDM_FORWARD, ICON_FLAGS_FORWARD);
 			SetMenuIcon(IDM_BOUNCE, ICON_FLAGS_BOUNCE);
 			SetMenuIcon(IDM_NEW_FILTER, ICON_FILTER);
 			SetMenuIcon(IDM_FILTER_CURRENT_FOLDER, ICON_FOLDER_FILTERS);
 			SetMenuIcon(IDM_MEMECODE, ICON_LINK);
 			SetMenuIcon(IDM_HOMEPAGE, ICON_LINK);
 			SetMenuIcon(IDM_SCRIBE_FAQ, ICON_LINK);
 			SetMenuIcon(IDM_INSCRIBE_LINK, ICON_LINK);
 			SetMenuIcon(IDM_VERSION_HISTORY, ICON_LINK);
 			SetMenuIcon(IDM_DEBUG_INFO, ICON_LINK);
 			SetMenuIcon(IDM_TUTORIALS, ICON_LINK);
 			SetMenuIcon(IDM_FEEDBACK, ICON_UNREAD_MAIL);
 			SetMenuIcon(IDM_HELP, ICON_HELP);
 
 			LMenuItem *mi;
 			if
 			(
 				GetOptions()->GetValue(OPT_EditControl, v) &&
 				(mi = Menu->FindItem(IDM_HTML_EDITOR))
 			)
 				mi->Checked(v.CastInt32() != 0);
 
 			Menu->SetPrefAndAboutItems(IDM_OPTIONS, IDM_ABOUT);
 		}
 	}
 
 	// Initialize user interface
 	SetupUi();
 
 	// Get some of the base submenu pointers. These are needed
 	// for SetupAccounts to work correctly, e.g. populate the
 	// send/receive/preview submenus. Folders need to be loaded
 	// before this for the templates folder
 	BuildDynMenus();
 
 	// Load accounts
 	SetupAccounts();
 
 	// Recursively load folder tree
 	LoadFolders([this](auto status)
 	{
 		// Redo it for the templates... now that load folders has completed.
 		BuildDynMenus();
 
 		if (ScribeState == ScribeExiting)
 			return;
 
 		// Process command line
 		OnCommandLine();
 
 		// Update the templates sub-menu now that the folders are loaded
 		BuildDynMenus();
 
 		// Check registry settings
 		SetDefaultHandler();
 
 		// Run on load scripts...
 		LArray<LScriptCallback*> OnLoadCallbacks;
 		if (GetScriptCallbacks(LOnLoad, OnLoadCallbacks))
 		{
 			for (auto r: OnLoadCallbacks)
 			{
 				LVirtualMachine Vm;
 				LScriptArguments Args(&Vm);
 				Args.New() = new LVariant(this);
 				ExecuteScriptCallback(*r, Args);
 				Args.DeleteObjects();
 			}
 		}
 	
 		ScribeState = ScribeRunning;
 	});
 }
 
 void ScribeWnd::SetLanguage()
 {
 	LVariant LangId;
 	if (GetOptions()->GetValue(OPT_UiLanguage, LangId))
 	{
 		// Set the language to load...
 		LAppInst->SetConfig("Language", LangId.Str());
 	}
 	LResources::SetLoadStyles(true);
 
 	// Load the resources (with the current lang)
 	if (!LgiGetResObj(true, "Scribe"))
 	{
 		LgiMsg(NULL, "The resource file 'Scribe.lr8' is missing.", AppName);
 		ScribeState = ScribeExiting;
 		LCloseApp();
 	}
 }
 
 ScribeWnd::~ScribeWnd()
 {
 	LAppInst->AppWnd = 0;
 	SearchView = NULL;
 	ScribeState = ScribeExiting;
 	LScribeScript::Inst->ShowScriptingWindow(false);
 
 	// Other cleanup...
 	ClearTempPath();
 	ShutdownIpc();
 	SetPulse();
 
 	// Save anything thats still dirty in the folders...
 	// just in case we crash during the shutdown phase.
 	ScribeFolder *Cur = GetCurrentFolder();
 	if (Cur)
 		Cur->SerializeFieldWidths();
 	SaveDirtyObjects(5000);
 
 	// Tell the UI not to reference anything in the folders
 	if (PreviewPanel)
 	{
 		PreviewPanel->OnThing(0, false);
 	}
 	Mail::NewMailLst.Empty();
 
 	// ~AccountStatusItem references the account list... must be before we
 	// delete the accounts.
 	DeleteObj(StatusPanel);
 
 	// ~Accountlet needs to reference the root container... so
 	// it has to go before unloading of folders.
 	Accounts.DeleteObjects();
 
 	UnLoadFolders();
 
 	DeleteObj(PreviewPanel);
 	SaveOptions();
 	DeleteObj(Commands);
 	DeleteObj(d->PreviewFont);
 	DeleteObj(d->SubSplit);
 	DeleteObj(Splitter);
 	MailList = NULL;
 
 	CmdSend.ToolButton = NULL;
 	CmdReceive.ToolButton = NULL;
 	CmdPreview.ToolButton = NULL;
 	CmdSend.MenuItem = NULL;
 	CmdReceive.MenuItem = NULL;
 	CmdPreview.MenuItem = NULL;
 
 	// This could be using the OpenSSL library for HTTPS connections. So
 	// close it before calling EndSSL.
 	DeleteObj(d->ImageLoader);
 	
 	// This has to be after we close all the accounts... otherwise
 	// they might still be using SSL functions, e.g. an IMAP/SSL connect.
 	EndSSL();
 
 	DeleteObj(d);
 }
 
 LString ScribeWnd::GetResourceFile(SribeResourceType Type)
 {
 	auto File = d->ResFiles.Find(Type);
 	if (!File)
 		LgiTrace("%s:%i - No file for resource type %i\n", _FL, Type);
 	return File;
 }
 
 void ScribeWnd::LoadImageResources()
 {
 	auto Res = LgiGetResObj();
 	LString::Array Folders;
 	if (Res)
 	{
 		auto p = Res->GetThemeFolder();
 		if (p)
 			Folders.Add(p);
 	}
 	Folders.Add(ScribeResourcePath());
 
 	for (auto p: Folders)
 	{
 		LDirectory Dir;
 
 		LgiTrace("%s:%i - Loading resource folder '%s'\n", _FL, p.Get());
 		for (auto b = Dir.First(p); b; b = Dir.Next())
 		{
 			if (Dir.IsDir())
 				continue;
 
 			auto Name = Dir.GetName();
 			if (MatchStr("Toolbar-*.png", Name))
 			{
 				if (!d->ResFiles.Find(ResToolbarFile))
 					d->ResFiles.Add(ResToolbarFile, Dir.FullPath());
 			}
 			else if (MatchStr("xgate-icons-*.png", Name))
 				d->ResFiles.Add(ResToolbarFile, Dir.FullPath());
 			else if (MatchStr("Icons-*.png", Name))
 				d->ResFiles.Add(ResIconsFile, Dir.FullPath());
 		}
 	}
 
 	ToolbarImgs.Reset(LLoadImageList(GetResourceFile(ResToolbarFile)));
 	ImageList.Reset(LLoadImageList(GetResourceFile(ResIconsFile)));
 	if (!ImageList)
 		LgiTrace("%s:%i - Failed to load toolbar image ('xgate-icons-32.png' or 'Toolbar-24.png')\n", _FL);
 }
 
 int ScribeWnd::GetEventHandle()
 {
 	return d->AppWndHnd;
 }
 
 void ScribeWnd::OnCloseInstaller()
 {
 	d->Bar = NULL;
 	if (InThread())
 	{
 		PourAll();
 	}
 	else LAssert(0);
 }
 
 void ScribeWnd::OnInstall(CapsHash *Caps, bool Status)
 {
 }
 
 bool ScribeWnd::NeedsCapability(const char *Name, const char *Param)
 {
 	#if DEBUG_CAPABILITIES
 	LgiTrace("ScribeWnd::NeedsCapability(%s, %s)\n", Name, Param);
 	#endif
 	
 	if (!InThread())
 	{
 		#if DEBUG_CAPABILITIES
 		LgiTrace("%s:%i - Posting M_NEEDS_CAP\n", _FL);
 		#endif
 		PostEvent(M_NEEDS_CAP, (LMessage::Param)NewStr(Name), (LMessage::Param)NewStr(Param));
 	}
 	else
 	{
 		if (!Name)
 			return false;
 			
 		if (d->MissingCaps.Find(Name))
 		{
 			#if DEBUG_CAPABILITIES
 			LgiTrace("%s:%i - Already in MissingCaps\n", _FL);
 			#endif
 			return true;
 		}
 
 		d->MissingCaps.Add(Name, true);
 
 		LStringPipe MsgBuf(256);
 		int i = 0;
 		// const char *k;
 		// for (bool b=d->MissingCaps.First(&k); b; b=d->MissingCaps.Next(&k), i++)
 		for (auto k : d->MissingCaps)
 		{
 			MsgBuf.Print("%s%s", i?", ":"", k.key);
 		}
 		
 		LVariant Actions;
 		if (stristr(Name, "OpenSSL"))
 		{
 			MsgBuf.Print(LLoadString(IDS_ERROR_SERVER_CONNECT));
 			if (Param)
 				MsgBuf.Print("\n%s", Param);
 			Actions.Add(new LVariant(LLoadString(IDS_INSTALL)));
 		}
 		else if (stristr(Name, "Registry"))
 		{
 			MsgBuf.Print(LLoadString(IDS_ERROR_REG_WRITE));
 			Actions.Add(new LVariant(LLoadString(IDS_DONT_SHOW_AGAIN)));
 		}
 		else if (stristr(Name, "SpellingDictionary"))
 		{
 			MsgBuf.Print(LLoadString(IDS_ERROR_NEED_INSTALL), Param);
 			Actions.Add(new LVariant(LLoadString(IDS_DOWNLOAD)));
 		}
 		Actions.Add(new LVariant(LLoadString(IDS_OK)));
 		
 		#if DEBUG_CAPABILITIES
 		LgiTrace("%s:%i - Actions.Length()=%i, Bar=%p\n", _FL, Actions.Length(), d->Bar);
 		#endif
 		if (Actions.Length())
 		{
 			LAutoString Msg(MsgBuf.NewStr());
 
 			// Check the script hook here...
 			bool ShowInstallBar = true;
 			LArray<LScriptCallback*> Callbacks;
 			if (GetScriptCallbacks(LBeforeInstallBar, Callbacks))
 			{
 				for (unsigned i=0; i<Callbacks.Length(); i++)
 				{
 					LScriptCallback &c = *Callbacks[i];
 					if (!c.Func)
 						continue;
 
 					LVirtualMachine Vm;
 					LScriptArguments Args(&Vm);
 					LVariant This((LDom*)this);
 					LVariant TheMsg(Msg.Get());					
 					
 					Args.Add(&This);
 					Args.Add(&TheMsg);
 					Args.Add(&Actions);
 					
 					if (ExecuteScriptCallback(c, Args, true))
 					{
 						if (!Args.GetReturn()->CastInt32())
 							ShowInstallBar = false;
 						else
 							Msg.Reset(TheMsg.ReleaseStr());
 					}
 				}
 			}
 			
 			// Now create the capability install bar...
 			if (!d->Bar && ShowInstallBar && Actions.Type == GV_LIST)
 			{
 				// FYI Capabilities are handled in ScribeWnd::StartAction.
 				LArray<const char *> Act;
 				for (auto v : *Actions.Value.Lst)
 					Act.Add(v->Str());
 				
 				d->Bar = new MissingCapsBar(this, &d->MissingCaps, Msg, this, Act);
 				AddView(d->Bar, 2);
 				AttachChildren();
 				OnPosChange();
 			}
 		}
 	}
 
 	return true;
 }
 
 LAutoString ScribeWnd::GetDataFolder()
 {
 	LVariant v;
 	GetOptions()->GetValue(OPT_IsPortableInstall, v);
 	
 	char p[MAX_PATH_LEN];
 	if (LGetSystemPath(v.CastInt32() ? LSP_APP_INSTALL : LSP_APP_ROOT, p, sizeof(p)))
 	{
 		if (!LDirExists(p))
 			FileDev->CreateFolder(p);
 
 		return LAutoString(NewStr(p));
 	}
 	else LgiTrace("%s:%i - LgiGetSystemPath failed (portable=%i).\n", _FL, v.CastInt32());
 	
 	return LAutoString();
 }
 
 LScriptEngine *ScribeWnd::GetScriptEngine()
 {
 	return d->Engine;
 }
 
 LScriptCallback ScribeWnd::GetCallback(const char *CallbackMethodName)
 {
 	LScriptCallback Cb;
 	
 	auto Cur = d->CurrentScript();
 	if (Cur && Cur->Code)
 	{
 		Cb.Script = Cur;
 		Cb.Func = Cur->Code->GetMethod(CallbackMethodName);
 	}
 
 	if (!Cb.Func)
 	{
 		for (auto s: d->Scripts)
 		{
 			Cb.Script = s;
 			if ((Cb.Func = s->Code->GetMethod(CallbackMethodName)))
 				break;
 		}
 	}
 
 	return Cb;
 }
 
 bool ScribeWnd::RegisterCallback(LScriptCallbackType Type, LScriptArguments &Args)
 {
 	if (!d->CurrentScript())
 	{
 		LgiTrace("%s:%i - No current script.\n", _FL);
 		return false;
 	}
 
 	char *Fn = Args[1]->Str();
 	LScriptCallback Cb = GetCallback(Fn);
 	if (!Cb.Func)
 	{
 		LgiTrace("%s:%i - No callback '%s'.\n", _FL, Fn);
 		return false;
 	}
 
 	switch (Type)
 	{
 		case LToolsMenu:
 		{
 			char *Menu = Args[0]->Str();
 			auto Cur = d->CurrentScript();
 			if (!Menu || !Fn || !Cur)
 			{
 				LgiTrace("%s:%i - menu=%s, fn=%s.\n", _FL, Menu, Fn);
 				return false;
 			}
 
 			LScriptCallback &c = Cur->Callbacks.New();
 			c = Cb;
 			c.Type = Type;
 			c.Param = d->NextToolMenuId;
 
 			LMenuItem *Tools = GetMenu()->FindItem(IDM_TOOLS_MENU);
 			auto ToolSub = Tools ? Tools->Sub() : 0;
 			if (ToolSub)
 			{
 				if (d->NextToolMenuId == IDM_TOOL_SCRIPT_BASE)
 				{
 					ToolSub->AppendSeparator();
 				}
 
 				ToolSub->AppendItem(Menu, c.Param, true);			
 				d->NextToolMenuId++;
 			}
 			break;
 		}
 		case LThingContextMenu:
 		case LFolderContextMenu:
 		case LThingUiToolbar:
 		case LMailOnBeforeSend:
 		case LMailOnAfterReceive:
 		case LApplicationToolbar:
 		case LBeforeInstallBar:
 		case LInstallComponent:
 		case LOnTimer:
 		case LRenderMail:
 		case LOnLoad:
 		{
 			auto Cur = d->CurrentScript();
 			LAssert(d->Scripts.HasItem(Cur));
 
 			LScriptCallback &c = Cur->Callbacks.New();
 			c = Cb;
 			c.Type = Type;
 			if (Args.Length() > 2)
 				c.Data = *Args[2];
 			break;
 		}
 		default:
 		{
 			LAssert(!"Not a known callback type");
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool ScribeWnd::GetScriptCallbacks(LScriptCallbackType Type, LArray<LScriptCallback*> &Callbacks)
 {
 	for (auto s: d->Scripts)
 	{
 		for (auto &c: s->Callbacks)
 		{
 			if (c.Type == Type)
 				Callbacks.Add(&c);
 		}
 	}
 
 	return Callbacks.Length() > 0;
 }
 
 bool ScribeWnd::ExecuteScriptCallback(LScriptCallback &c, LScriptArguments &Args, bool ReturnArgs)
 {
 	if (!c.Func || !c.Script)
 		return false;
 
 	// Setup
 	LVirtualMachine Vm(d);
 	d->CurrentScripts.Add(c.Script);
 	
 	// Call the method
 	bool Status = Vm.ExecuteFunction(	c.Script->Code,
 										c.Func,
 										Args,
 										LScribeScript::Inst->GetLog(),
 										ReturnArgs ? &Args : NULL) != ScriptError;
 
 	// Cleanup
 	d->CurrentScripts.PopLast();
 	return Status;
 }
 
 LStream *ScribeWnd::ShowScriptingConsole()
 {
 	auto Item = Menu->FindItem(IDM_SCRIPTING_CONSOLE);
 	if (Item)
 	{
 		Item->Checked(!Item->Checked());
 		LScribeScript::Inst->ShowScriptingWindow(Item->Checked());
 		
 		LVariant v;
 		GetOptions()->SetValue(OPT_ShowScriptConsole, v = Item->Checked());
 	}
 	
 	return LScribeScript::Inst->GetLog();
 }
 
 LOptionsFile::PortableType ScribeWnd::GetPortableType()
 {
 	return d->GetInstallMode();
 }
 
 void ScribeWnd::RemoteContent_AddSender(const char *Addr, bool WhiteList)
 {
 	if (!Addr)
 		return;
 
 	auto Opt = WhiteList ? OPT_RemoteContentWhiteList : OPT_RemoteContentBlackList;
 	LVariant v;
 	GetOptions()->GetValue(Opt, v); // Not an error if not there...
 
 	auto existing = LString(v.Str()).SplitDelimit(" ,\r\n");
 	for (auto p: existing)
 	{
 		if (MatchStr(p, Addr))
 		{
 			LgiTrace("%s:%i - '%s' is already in '%s'\n", _FL, Addr, Opt);
 			return; // Already in list...
 		}
 	}
 
 	existing.SetFixedLength(false);
 	existing.Add(Addr);
 	auto updated = LString("\n").Join(existing);
 	GetOptions()->SetValue(Opt, v = updated.Get());
 	LgiTrace("%s:%i - Added '%s' to '%s'\n", _FL, Addr, Opt);
 	d->RemoteContent_Init = false;
 }
 
 ScribeRemoteContent ScribeWnd::RemoteContent_GetSenderStatus(const char *Addr)
 {
 	if (!d->RemoteContent_Init)
 	{
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_RemoteContentWhiteList, v))
 			d->RemoteWhiteLst = LString(v.Str()).SplitDelimit(" ,\r\n");
 		if (GetOptions()->GetValue(OPT_RemoteContentBlackList, v))
 			d->RemoteBlackLst = LString(v.Str()).SplitDelimit(" ,\r\n");
 		d->RemoteContent_Init = true;
 	}
 
 	for (auto p: d->RemoteWhiteLst)
 		if (MatchStr(p, Addr))
 			return RemoteAlwaysLoad;
 
 	for (auto p: d->RemoteBlackLst)
 		if (MatchStr(p, Addr))
 			return RemoteNeverLoad;
 
 	return RemoteDefault;
 }
 
 void ScribeWnd::RemoteContent_ClearCache()
 {
 	d->RemoteWhiteLst.Empty();
 	d->RemoteBlackLst.Empty();
 	d->RemoteContent_Init = false;
 }
 
 void ScribeWnd::OnSpellerSettingChange()
 {
 	// Kill the current thread
 	d->SpellerThread.Reset();
 	
 	// Setup the new thread
 	LSpellCheck *t = GetSpellThread();
 	if (t)
 	{
 		// Trigger an install if needed
 		t->Check(d->AppWndHnd, "thisisamispeltword", 0, 18);
 	}
 }
 
 bool ScribeWnd::SetSpellThreadParams(LSpellCheck *Thread)
 {
 	if (!Thread)
 		return false;
 	
 	LVariant Lang, Dict;
 	GetOptions()->GetValue(OPT_SpellCheckLanguage, Lang);
 	GetOptions()->GetValue(OPT_SpellCheckDictionary, Dict);
 
 	LAutoPtr<LSpellCheck::Params> Params(new LSpellCheck::Params);
 	if (!Params)
 		return false;
 
 	Params->IsPortable = GetPortableType();
 	Params->OptionsPath = GetOptions()->GetFile();
 	Params->Lang = Lang.Str();
 	Params->Dict = Dict.Str();
 	Params->CapTarget = this;
 	
 	Thread->SetParams(Params);
 	return true;
 }
 
 LSpellCheck *ScribeWnd::CreateSpellObject()
 {
 	LVariant PrefAspell;
 	GetOptions()->GetValue(OPT_PreferAspell, PrefAspell);
 
 	LAutoPtr<LSpellCheck> Obj;
 
 	if (PrefAspell.CastInt32())
 		Obj = CreateAspellObject();
 
 	#if defined(MAC)
 
 		if (!Obj)
 			Obj = CreateAppleSpellCheck();
 
 	#elif defined(WINDOWS)
 
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		if
 		(
 			!Obj &&
 			(Os == LGI_OS_WIN32 || Os == LGI_OS_WIN64)
 			&&
 			(
 				Ver.Length() > 1 &&
 				(
 					Ver[0] > 6
 					||
 					(Ver[0] == 6 && Ver[1] > 1)
 				)
 			)
 		)
 			Obj = CreateWindowsSpellCheck();
 				
 	#endif
 
 	if (!Obj)
 		Obj = CreateAspellObject();
 
 	SetSpellThreadParams(Obj);
 	return Obj.Release();
 }
 
 LSpellCheck *ScribeWnd::GetSpellThread(bool OverrideOpt)
 {
 	LVariant Use;
 	if (OverrideOpt)
 		Use = true;
 	else
 		GetOptions()->GetValue(OPT_SpellCheck, Use);
 
 	#if USE_SPELLCHECKER
 	if ((Use.CastInt32() != 0) ^ (d->SpellerThread.Get() != 0))
 		d->SpellerThread.Reset(Use.CastInt32() ? CreateSpellObject() : NULL);
 	#endif
 
 	return d->SpellerThread;
 }
 
 LAutoString ScribeWnd::GetHttpProxy()
 {
 	LAutoString Proxy;
 	
 	LVariant v;
 	if (GetOptions()->GetValue(OPT_HttpProxy, v) && ValidStr(v.Str()))
 	{
 		Proxy.Reset(v.ReleaseStr());
 	}
 	else
 	{
 		LProxyUri p;
 		if (p.sHost)
 			Proxy.Reset(NewStr(p.ToString()));
 	}
 	
 	return Proxy;
 }
 
 InstallProgress *ScribeWnd::StartAction(MissingCapsBar *Bar, LCapabilityTarget::CapsHash *Components, const char *ActionParam)
 {
 	if (!ActionParam)
 	{
 		LgiTrace("%s:%i - No action supplied.\n", _FL);
 		return NULL;
 	}
 
 	LArray<LScriptCallback*> Callbacks;
 	LVariant Action(ActionParam);
 	if (GetScriptCallbacks(LInstallComponent, Callbacks))
 	{
 		bool StartInstall = true;
 
 		for (unsigned i=0; i<Callbacks.Length(); i++)
 		{
 			LScriptCallback &c = *Callbacks[i];
 			if (!c.Func)
 				continue;
 
 			LVirtualMachine Vm;
 			LScriptArguments Args(&Vm);
 			LVariant This((LDom*)this);
 			
 			Args.Add(&This);
 			Args.Add(&Action);
 			
 			if (ExecuteScriptCallback(c, Args))
 			{
 				if (!Args.GetReturn()->CastInt32())
 					StartInstall = false;
 			}
 		}
 		
 		if (!Action.Str())
 		{
 			LgiTrace("%s:%i - GInstallComponent removed action name.\n", _FL);
 			return NULL;
 		}
 
 		if (!StartInstall)
 		{
 			LgiTrace("%s:%i - GInstallComponent script canceled install of '%s'.\n", _FL, ActionParam);
 			return NULL;
 		}
 	}
 
 	if (!_stricmp(Action.Str(), LLoadString(IDS_OK)))
 	{
 		// Do nothing
 		d->MissingCaps.Empty();
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_DONT_SHOW_AGAIN)))
 	{
 		// Turn off registering as a client.
 		LVariant No(false);
 		GetOptions()->SetValue(OPT_RegisterWindowsClient, No);
 		GetOptions()->SetValue(OPT_CheckDefaultEmail, No);
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_INSTALL)))
 	{
 		#ifdef WINDOWS
 		bool IsSsl = false;
 		for (auto c: *Components)
 		{
 			if (!_stricmp(c.key, "openssl"))
 			{
 				IsSsl = true;
 				break;
 			}
 		}
 		if (IsSsl)
 		{
 			LString s;
 			s.Printf(LLoadString(IDS_WINDOWS_SSL_INSTALL), LGetOsName());
 			
 			auto q = new LAlert(this, AppName, s, "Open Website", LLoadString(IDS_CANCEL));
 			q->DoModal([this, q](auto dlg, auto id)
 			{
 				switch (id)
 				{
 					case 1:
 						LExecute("https://slproweb.com/products/Win32OpenSSL.html");
 						break;
 					default:
 						break;
 				}
 				delete dlg;
 			});
 			return NULL;
 		}
 		#endif
 
 		return CapabilityInstaller::StartAction(Bar, Components, Action.Str());
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_SHOW_CONSOLE)))
 	{
 		ShowScriptingConsole();
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_OPEN_SOURCE)))
 	{
 		if (d->ErrSource)
 			LExecute(d->ErrSource);
 		else if (d->ErrFilter)
 			d->ErrFilter->DoUI();
 		
 		d->ErrSource.Empty();
 		d->ErrFilter = NULL;
 	}
 	else if (	!Stricmp(Action.Str(), LLoadString(IDS_SHOW_REMOTE_CONTENT)) ||
 				!Stricmp(Action.Str(), LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT)))
 	{
 		auto c = Components->begin();
 		LWindow *w = Bar->GetWindow();
 		if ((*c).key &&
 			!Stricmp((*c).key, "RemoteContent") &&
 			w)
 		{
 			LVariant Ret, Always(!Stricmp(Action.Str(), LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT)));
 			LArray<LVariant*> Args;
 			Args[0] = &Always;
 			w->CallMethod(DomToStr(SdShowRemoteContent), &Ret, Args);
 		}
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_DOWNLOAD)))
 	{
 		auto t = GetSpellThread();
 		if (t)
 			t->InstallDictionary();
 		else
 			LgiTrace("%s:%i - No spell thread.\n", _FL);
 	}
 	else LAssert(!"Unknown action.");
 	
 	return NULL;
 }
 
 HttpImageThread *ScribeWnd::GetImageLoader()
 {
 	if (!d->ImageLoader)
 	{
 		LAutoString Proxy = GetHttpProxy();
 		d->ImageLoader = new HttpImageThread(this, Proxy, 0);
 	}
 
 	return d->ImageLoader;
 }
 
 char *ScribeWnd::GetUiTags()
 {
 	if (!d->UiTags)
 	{
 		char UiTags[256] =
 			"inscribe"
 			#if defined WIN32
 			" win32"
 			#elif defined LINUX
 			" linux"
 			#elif defined MAC
 			" mac"
 			#endif
 			;
 	
 		LVariant Tags;
 		if (!GetOptions())
 		{
 			LAssert(!"Where is the options?");
 		}
 		else if (GetOptions()->GetValue("tags", Tags))
 		{
 			size_t Len = strlen(UiTags);
 			sprintf_s(UiTags+Len, sizeof(UiTags)-Len, " %s", Tags.Str());
 		}
 
 		d->UiTags.Reset(NewStr(UiTags));
 	}
 
 	return d->UiTags;
 }
 
 void ScribeWnd::OnCreate()
 {
 	// LgiTrace("ScribeWnd::OnCreate. ScribeState=%i\n", ScribeState);
 	if (IsAttached() && ScribeState == ScribeConstructed)
 	{
 		ScribeState = ScribeInitializing;
 		Construct3();
 	}
 }
 
 ScribeAccount *ScribeWnd::GetAccountByEmail(const char *Email)
 {
 	if (!Email)
 		return NULL;
 
 	for (auto a : *GetAccounts())
 	{
 		LVariant e = a->Identity.Email();
 		if (e.Str() &&
 			!_stricmp(e.Str(), Email))
 		{
 			return a;
 		}
 	}
 	
 	return 0;
 }
 
 ScribeAccount *ScribeWnd::GetAccountById(int Id)
 {
 	for (auto a : *GetAccounts())
 	{
 		if (a->Receive.Id() == Id)
 		{
 			return a;
 		}
 	}
 	
 	return 0;
 }
 
 const char *ScribeWnd::EditCtrlMimeType()
 {
 	LVariant Html;
 	GetOptions()->GetValue(OPT_EditControl, Html);
 	return Html.CastInt32() ? sTextHtml : sTextPlain;
 }
 
 LAutoString ScribeWnd::GetReplyXml(const char *MimeType)
 {
 	bool IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 
 	LVariant s;
 	GetOptions()->GetValue(IsHtml ? OPT_HtmlReplyFormat : OPT_TextReplyFormat, s);
 	return LAutoString(s.ReleaseStr());
 }
 
 LAutoString ScribeWnd::GetForwardXml(const char *MimeType)
 {
 	bool IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 
 	LVariant s;
 	GetOptions()->GetValue(IsHtml ? OPT_HtmlForwardFormat : OPT_TextForwardFormat, s);
 	return LAutoString(s.ReleaseStr());
 }
 
 LVmCallback *ScribeWnd::GetDebuggerCallback()
 {
 	return d;
 }
 
 GpgConnector *ScribeWnd::GetGpgConnector()
 {
 	if (!d->GpgInst)
 	{
 		if (!GpgConnector::IsInstalled())
 			return NULL;
 		
 		d->GpgInst.Reset(new GpgConnector());
 	}
 	
 	return d->GpgInst;
 }
 
 LFont *ScribeWnd::GetPreviewFont()
 {
 	return d->PreviewFont;
 }
 
 bool ScribeWnd::IsValid()
 {
 	#if 0
 	try
 	{
 		for (ScribeAccount *a = Accounts.First(); a; a = Accounts.Next())
 		{
 		}
 	}
 	catch(...)
 	{
 		return false;
 	}
 	#endif
 
 	return true;
 }
 
 bool ScribeWnd::ShutdownIpc()
 {
 	// Remove our instance from the shared memory
 	if (ScribeIpc && ScribeIpc->GetPtr())
 	{
 		ScribeIpcInstance *InstLst = (ScribeIpcInstance*) ScribeIpc->GetPtr();
 
 		if (ThisInst)
 			memset(ThisInst, 0, sizeof(*ThisInst));
 
 		int c = 0;
 		for (int i=0; i<SCRIBE_INSTANCE_MAX; i++)
 		{
 			if (InstLst[i].Valid())
 				c++;
 		}
 
 		if (!c)
 			ScribeIpc->Destroy();
 	}	
 	
 	ThisInst = 0;
 	DeleteObj(ScribeIpc);
 
 	return true;
 }
 
 bool ScribeWnd::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdQuote: // Type: String
 		{
 			return GetOptions()->GetValue(OPT_QuoteReplyStr, Value);
 		}
 		case SdName: // Type: String
 		{
 			Value = AppName;
 			break;
 		}
 		case SdHome: // Type: String
 		{
 			Value = LGetExePath().Get();
 			break;
 		}
 		case SdNow: // Type: String
 		{
 			LDateTime Now;
 			Now.SetNow();
 			char s[64];
 			Now.Get(s, sizeof(s));
 			Value = s;
 			break;
 		}
 		case SdFolder:	// Type: ScribeFolder[]
 						// Pass system folder index or string as array parameter.
 		{
 			ScribeFolder *f = 0;
 			if (!Array)
 				return false;
 
 			if (IsDigit(*Array))
 			{
 				f = GetFolder(atoi(Array));
 			}
 			else
 			{
 				f = GetFolder(Array);
 			}
 
 			if (!f)
 				return false;
 
 			Value = (LDom*)f;
 			break;
 		}
 		case SdAppName: // Type: String
 		{
 			Value = AppName;
 			break;
 		}
 		case SdCalendarToday: // Type: String
 		{
 			Calendar::SummaryOfToday(this, [this](auto s)
 			{
 				d->CalendarSummary = s;
 			});
 
 			return d->CalendarSummary;
 		}
 		case SdInboxSummary:
 		{
 			LStringPipe p;
 			
 			// Iterate through the mail stores
 			for (auto m: Folders)
 			{
 				if (!m.Store)
 					continue;
 				auto Inbox = m.Store->GetObj(FIELD_INBOX);
 				if (!Inbox)
 					continue;
 
 				auto Unread = Inbox->GetInt(FIELD_UNREAD);
 				auto Name = Inbox->GetStr(FIELD_FOLDER_NAME);
 				LString Path;
 				Path.Printf("/%s/%s", m.Name.Get(), Name);
 					
 				if (Unread)
 					p.Print("%s: <a href='folder://%s'>%i unread</a><br>", m.Name.Get(), Path.Get(), Unread);
 				else
 					p.Print("%s: 0 unread<br>", m.Name.Get());
 			}
 			
 			// And also the IMAP full folders
 			for (auto a: Accounts)
 			{
 				ScribeProtocol Protocol = a->Receive.ProtocolType();
 				if (Protocol == ProtocolImapFull)
 				{
 					LDataStoreI *Store = a->Receive.GetDataStore();
 					if (Store)
 					{
 						auto Inbox = Store->GetObj(FIELD_INBOX);
 						if (Inbox)
 						{
 							auto Unread = Inbox->GetInt(FIELD_UNREAD);
 							auto Name = Inbox->GetStr(FIELD_FOLDER_NAME);
 							auto m = a->Receive.Name();
 							if (m.Str())
 							{
 								LString Path;
 								Path.Printf("/%s/%s", m.Str(), Name);
 								
 								if (Unread)
 									p.Print("%s: <a href='folder://%s'>%i unread</a><br>", m.Str(), Path.Get(), Unread);
 								else
 									p.Print("%s: 0 unread<br>", m.Str());
 							}
 						}
 					}
 				}
 			}
 			
 			Value = p.NewLStr().Get();
 			break;
 		}
 		case SdExecute: // Type: String
 		{
 			if (!Array)
 				return false;
 
 			const char *s = Array;
 			char *Exe = LTokStr(s);
 			if (!Exe)
 				return false;
 
 			while (*s && *s == ' ') s++;
 			
 			LStringPipe Out;
 			LSubProcess p(Exe, (char*)s);
 			if (p.Start())
 			{
 				p.Communicate(&Out);
 				LAutoString o(Out.NewStr());
 				LAutoString t(TrimStr(o));
 				Value = t;
 			}
 			
 			DeleteArray(Exe);
 			break;
 		}
 		case SdBuildType: // Type: String
 		{
 			#ifdef _DEBUG
 			Value = "<font color=#ff0000>Debug</font>";
 			#else
 			Value = "Release";
 			#endif
 			break;
 		}
 		case SdPlatform: // Type: String
 		{
 			LArray<int> Ver;
 			LGetOs(&Ver);
 			
 			LString::Array Va;
 			for (auto i: Ver)
 				Va.New().Printf("%i", i);
 			
 			#if defined __GTK_H__
 				auto Api = "GTK3";
 			#elif LGI_SDL
 				auto Api = "SDL";
 			#elif LGI_COCOA
 				auto Api = "Cocoa";
 			#elif LGI_CARBON
 				auto Api = "Carbon";
 			#elif defined WIN32
 				auto Api = "WinApi";
 			#else
 				#error "Impl me."
 				auto Api = "#err";
 			#endif
 			
 			LString s;
 			s.Printf("%s, v%s, %s", LGetOsName(), LString(".").Join(Va).Get(), Api);
 			Value = s.Get();
 			break;
 		}
 		case SdVersion: // Type: String
 		{
 			char Ver[32];
 			sprintf_s(Ver, sizeof(Ver), "v%s", ScribeVer);
 			Value = Ver;
 			break;
 		}
 		case SdBuild: // Type: String
 		{
 			char s[128];
 			sprintf_s(s, sizeof(s), "%s, %s, %ibit", __DATE__, __TIME__, (int)(sizeof(NativeInt)*8));
 			Value = s;
 			break;
 		}
 		case SdLanguage: // Type: String
 		{
 			LLanguage *l = LGetLanguageId();
 			if (!l)
 				return false;
 
 			char s[256];
 			sprintf_s(s, sizeof(s), "%s \"%s\"", l->Name, l->Id);
 			Value = s;
 			break;
 		}
 		case SdString: // Type: String
 		{
 			if (!Array)
 			{
 				LAssert(!"Missing string ID");
 				return false;
 			}
 
 			int Id = atoi(Array);
 			Value = LLoadString(Id);
 			break;
 		}
 		case SdCurrentFolder: // Type: ScribeFolder
 		{
 			Value = (LDom*) GetCurrentFolder();
 			break;
 		}
 		case SdView: // Type: LView
 		{
 			Value = (LView*)this;
 			break;
 		}
 		case SdNoContact: // Type: Contact
 		{
 			Value = (NoContactType*)d->NoContact;
 			break;
 		}
 		case SdAccounts:
 		{
 			if (Array)
 			{
 				if (IsDigit(*Array))
 				{
 					auto i = atoi(Array);
 					if (i >= 0 && i < (ssize_t)Accounts.Length())
 					{
 						Value = (LDom*)Accounts[i];
 					}
 					else return false;
 				}
 				else
 				{
 					for (auto a : Accounts)
 					{
 						LVariant nm = a->Send.Name();
 						if (nm.Str() && !_stricmp(nm.Str(), Array))
 						{
 							Value = (LDom*)a;
 							break;
 						}
 					}
 				}
 			}
 			else
 			{
 				Value = (int32)Accounts.Length();
 			}
 			break;
 		}
 		case SdOptions:
 		{
 			Value = GetOptions();
 			break;
 		}
 		case SdMailStorePaths:
 		{
 			if (!Value.SetList())
 				return false;
 			for (auto Ms : Folders)
 				Value.Add(new LVariant(Ms.Path));
 			break;
 		}
 		case SdRootFolders:
 		{
 			if (!Value.SetList() || !Tree)
 				return false;
 
 			for (auto *i = Tree->GetChild(); i; i = i->GetNext())
 			{
 				ScribeFolder *c = dynamic_cast<ScribeFolder*>(i);
 				if (c)
 				{
 					auto p = c->GetPath();
 					Value.Add(new LVariant(p));
 				}
 			}
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool ScribeWnd::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType m = StrToDom(MethodName);
 	switch (m)
 	{
 		case SdGrowlOnMail: // Type: (Mail Obj)
 		{
 			if (Args.Length() != 1)
 			{
 				LgiTrace("%s:%i - Wrong arg count: %i.\n", _FL, (int)Args.Length());
 				return false;
 			}
 			
 			Mail *m = dynamic_cast<Mail*>(Args[0]->CastDom());
 			if (!m)
 			{
 				LgiTrace("%s:%i - Invalid object.\n", _FL);
 				return false;
 			}
 			
 			GrowlOnMail(m);
 			break;
 		}
 		case SdGrowlInfo:
 		{
 			auto Title = Args.Length() > 0 ? Args[0] : NULL;
 			auto Text = Args.Length() > 1 ? Args[1] : NULL;
 			GrowlInfo(Title ? Title->Str() : NULL, Text ? Text->Str() : NULL);
 			break;
 		}
 		case SdGetClipboardText: // Type: ()
 		{
 			LClipBoard c(this);
 			*ReturnValue = c.Text();
 			break;
 		}
 		case SdSetClipboardText: // Type: (String Text)
 		{
 			if (Args.Length() != 1)
 			{
 				LgiTrace("%s:%i - Wrong arg count: %i.\n", _FL, (int)Args.Length());
 				return false;
 			}
 
 			char *Str = Args[0]->CastString();
 			LClipBoard c(this);
 
 			if (ValidStr(Str))
 				*ReturnValue = c.Text(Str);
 			else
 				*ReturnValue = c.Empty();
 			break;
 		}
 		case SdLookupContactGroup: // Type: (String GroupName)
 		{
 			if (Args.Length() != 1)
 			{
 				LgiTrace("%s:%i - Wrong arg count: %i.\n", _FL, (int)Args.Length());
 				return false;
 			}
 			
 			ContactGroup *Grp = LookupContactGroup(this, Args[0]->Str());
 			*ReturnValue = dynamic_cast<LDom*>(Grp);
 			break;
 		}
 		case SdAskUserString: // Type: (LView ParentView, String Callback, String PromptMessage[, Bool ObsurePassword[, String DefaultValue]])
 		{
 			LVirtualMachine::Context Ctx;
 			// Ctx = Args.GetVm()->SaveContext()
 
 			if (!Ctx || Args.Length() < 3)
 			{
 				*ReturnValue = true;
 				return true;
 			}
 
 			LView *View       = Args[0]->CastView();
 			auto CallbackName = Args[1]->Str();
 			auto Prompt       = Args[2]->CastString();
 			bool IsPassword   = Args.Length() > 3 ? Args[3]->CastInt32() != 0 : false;
 			auto Default      = Args.Length() > 4 ? Args[4]->Str() : NULL;
 
 			auto i = new LInput(View ? View : this, Default, Prompt, AppName, IsPassword);
 			i->DoModal([Ctx, i, CallbackName=LString(CallbackName)](auto dlg, auto id)
 			{
 				if (id)
 				{
 					LScriptArguments Args(NULL);
 					Args.Add(new LVariant(i->GetStr()));
 					Ctx.Call(CallbackName, Args);
 					Args.DeleteObjects();
 				}
 				delete dlg;
 			});
 
 			*ReturnValue = true;
 			break;
 		}
 		case SdCreateAccount: // Type: ()
 		{
 			ScribeAccount *a = new ScribeAccount(this, (int)Accounts.Length());
 			if (a)
 			{
 				if (ReturnValue)
 					*ReturnValue = (LDom*)a;
 				Accounts.Insert(a);
 				a->Create();
 			}
 			else return false;
 			break;
 		}
 		case SdDeleteAccount: // Type: (ScribeAccount AccountToDelete)
 		{
 			if (Args.Length() != 1)
 				return false;
 			
 			ScribeAccount *a = dynamic_cast<ScribeAccount*>(Args[0]->CastDom());
 			if (!a)
 			{
 				if (ReturnValue)
 					*ReturnValue = false;
 			}
 			else
 			{
 				int Idx = (int)Accounts.IndexOf(a);
 				if (Idx < 0 || a->IsOnline())
 				{
 					if (ReturnValue)
 						*ReturnValue = false;
 				}
 				else
 				{
 					Accounts.Delete(a);
 					a->Delete();
 					delete a; // delete actual account object
 
 					// Reindex remaining items so their are no gaps
 					int i=0;
 					auto it = Accounts.begin();
 					for (a = *it; a; a = *++it, i++)
 					{
 						a->ReIndex(i);
 					}
 				}
 			}
 			break;
 		}
 		case SdShowRemoteContent:
 		{
 			if (PreviewPanel)
 				return PreviewPanel->CallMethod(MethodName, ReturnValue, Args);
 			else
 				return false;
 			break;
 		}
 		case SdSearchHtml: // Type(Html, SearchExp, ResultExp)
 		{
 			if (Args.Length() != 3)
 			{
 				LgiTrace("%s:%i - SearchHtml requires 3 arguments.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto Html = Args[0]->Str();
 			auto SearchExp = Args[1]->Str();
 			auto ResultExp = Args[2]->Str();
 			if (!Html || !SearchExp || !ResultExp)
 			{
 				LgiTrace("%s:%i - SearchHtml got non-string argument.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			SearchHtml(ReturnValue, Html, SearchExp, ResultExp);
 			return true;
 		}
 		case SdGetUri: // Type(UriToDownload, CallbackName)
 		{
 			if (Args.Length() < 2)
 			{
 				LgiTrace("%s:%i - GetUri requires at least 2 arguments.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto Uri = Args[0]->Str();
 			auto Callback = Args[1]->Str();
 			LVariant *UserData = Args.Length() > 2 ? Args[2] : NULL;
 			new ScriptDownloadContentThread(this, Uri, Callback, UserData);
 			*ReturnValue = true;
 			return true;
 		}
 		default:
 		{
 			LAssert(!"Unsupported method.");
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 LOptionsFile *ScribeWnd::GetOptions(bool Create)
 {
 	if (!d->Options && Create)
 	{
 		LAssert(!"Not here... do it in LoadOptions.");
 		return NULL;
 	}
 
 	return d->Options;
 }
 
 int OptionsFileCmp(OptionsInfo *a, OptionsInfo *b)
 {
 	int64 Diff = b->Mod - a->Mod;
 	return Diff < 0 ? -1 : (Diff > 0 ? 1 : 0);
 }
 
 OptionsInfo::OptionsInfo()
 {
 	Score = 0;
 	Mod = 0;
 	Leaf = NULL;
 	Usual = false;
 }
 	
 OptionsInfo &OptionsInfo::operator =(char *p)
 {
 	File = p;
 	Leaf = LGetLeaf(File);
 		
 	if (Leaf)
 	{
 		char n[64];
 		sprintf_s(n, sizeof(n), "%s.xml", OptionsFileName);
 		Usual = !_stricmp(n, Leaf);
 	}
 		
 	return *this;
 }
 	
 LAutoPtr<LOptionsFile> OptionsInfo::Load()
 {
 	// Read the file...
 	size_t Count = 0;
 	LXmlTag *Stores = NULL;
 	LXmlTag *Acc = NULL;
 	LAutoPtr<LOptionsFile> Of(new LOptionsFile(File));
 	if (!Of)
 		return Of;
 	if (!Of->SerializeFile(false))
 		goto OnError;
 		
 	// Sanity check the options...
 	Acc = Of->LockTag(OPT_Accounts, _FL);
 	if (!Acc)
 		goto OnError;
 	Of->Unlock();
 		
 	Stores = Of->LockTag(OPT_MailStores, _FL);
 	if (!Stores)
 		goto OnError;
 
 	Count = Stores->Children.Length();
 	Of->Unlock();
 	if (Count == 0)
 		goto OnError;
 		
 	return Of;
 
 OnError:
 	Of.Reset();
 	return Of;
 }
 
 #define DEBUG_OPTS_SCAN		0
 bool ScribeWnd::ScanForOptionsFiles(LArray<OptionsInfo> &Files, LSystemPath PathType)
 {
 	LString Root = LGetSystemPath(PathType);
 	LDirectory Dir;
 	char p[MAX_PATH_LEN];
 
 	if (IsUnitTest)
 		Root += ".unittest";
 
 	#if DEBUG_OPTS_SCAN
 	LgiTrace("%s:%i - Root='%s'\n", _FL, Root.Get());
 	#endif
 
 	for (int b = Dir.First(Root); b; b = Dir.Next())
 	{
 		if
 		(
 			!Dir.IsDir()
 			&&
 			Dir.Path(p, sizeof(p))
 		)
 		{
 			LResolveShortcut(p, p, sizeof(p));
 			char *Ext = LGetExtension(Dir.GetName());
 			if (stristr(Dir.GetName(), OptionsFileName) != NULL &&
 				Ext &&				
 				(!_stricmp(Ext, "xml") || !_stricmp(Ext, "bak")))
 			{
 				OptionsInfo &i = Files.New();
 				i = p;
 				i.Mod = Dir.GetLastWriteTime();
 
 				#if DEBUG_OPTS_SCAN
 				LgiTrace("%s:%i - File='%s'\n", _FL, p);
 				#endif
 			}
 		}
 	}
 	
 	Files.Sort(OptionsFileCmp);
 	
 	// Scan through the results and pick out the normal file
 	for (unsigned i=0; i<Files.Length() && !d->Options; i++)
 	{
 		if (Files[i].Usual)
 		{
 			d->Options = Files[i].Load();
 
 			#if DEBUG_OPTS_SCAN
 			LgiTrace("%s:%i - Attempt '%s' = %p\n", _FL, Files[i].File.Get(), d->Options);
 			#endif
 		}
 	}
 
 	if (!d->Options)
 	{
 		// Scan through the alternative files and look for something 
 		// we can use.
 		#if DEBUG_OPTS_SCAN
 		LgiTrace("%s:%i - Scanning backups\n", _FL);
 		#endif
 		for (unsigned i=0; i<Files.Length() && !d->Options; i++)
 		{
 			if (!Files[i].Usual)
 			{
 				d->Options = Files[i].Load();
 				if (d->Options)
 				{
 					// Lets rename this baby back to the real filename
 					LString Xml = OptionsFileName;
 					Xml += ".xml";
 					LFile::Path Normal(Root, Xml);
 					if (LFileExists(Normal))
 						FileDev->Delete(Normal);
 					
 					d->Options->SetFile(Normal);
 					d->Options->SerializeFile(true); // sets to clean after changing filename.
 				}
 			}
 		}
 	}
 
 	if (d->Options)
 	{
 		// Load OK: Clear out any old options files...
 		#if DEBUG_OPTS_SCAN
 		LgiTrace("%s:%i - Files.len=" LPrintfSizeT "\n", _FL, Files.Length());
 		#endif
 		while (Files.Length() > 6)
 		{
 			auto Idx = Files.Length() - 1;
 			auto &f = Files[Idx];
 			#if DEBUG_OPTS_SCAN
 			LgiTrace("%s:%i - Delete '%s'\n", _FL, f.File.Get());
 			#endif
 			FileDev->Delete(f.File);
 			Files.DeleteAt(Idx);
 		}
 	}
 
 	return d->Options != NULL;
 }
 
 bool ScribeWnd::IsUnitTest = false;
 
 bool ScribeWnd::LoadOptions()
 {
 	bool Load = false;
 	
 	// Check if we are running unit tests...
 	if ((IsUnitTest = LAppInst->GetOption("unittest")))
 	{
 		d->UnitTestServer.Reset(new LUnitTestServer(this));
 	}
 
 	// Look in the XGate folder
 	#if WINNATIVE && !defined(_DEBUG)
 	LRegKey xgate(false, "HKEY_CURRENT_USER\\Software\\XGate");
 	if (xgate.IsOk())
 	{
 		char *Spool = xgate.GetStr("SpoolDir");
 		if (LDirExists(Spool))
 		{
 			char File[MAX_PATH_LEN];
 			LMakePath(File, sizeof(File), Spool, "spool");
 			LMakePath(File, sizeof(File), File, OptionsFileName);
 			strcat_s(File, sizeof(File), ".xml");
 			if (LFileExists(File))
 			{
 				d->SetInstallMode(LOptionsFile::DesktopMode);
 				LgiTrace("Selecting xgate mode based on options file path.\n");
 				d->Options.Reset(new LOptionsFile(File));
 			}
 		}
 	}
 	#endif
 
 	// Now look in the application install folder
 	LArray<OptionsInfo> Files;
 	if (!d->Options &&
 		ScanForOptionsFiles(Files, LSP_APP_INSTALL))
 	{
 		// File is in the install folder...
 		d->SetInstallMode(LOptionsFile::PortableMode);
 		LgiTrace("Selecting portable mode based on options file path.\n");
 	}
 	
 	// Look in the app root
 	if
 	(
 		!d->Options &&
 		ScanForOptionsFiles(Files, LSP_APP_ROOT)
 	)
 	{
 		// Desktop mode
 		d->SetInstallMode(LOptionsFile::DesktopMode);
 		LgiTrace("Selecting desktop mode based on options file path.\n");
 	}
 	
 	// Do multi-instance stuff
 	if (d->Options && d->Options->GetFile())
 	{
 		// Search for other instances of Scribe
 		if (ScribeIpc)
 		{
 			int i;
 			ScribeIpcInstance *InstLst = (ScribeIpcInstance*) ScribeIpc->GetPtr();
 			ScribeIpcInstance *Mul = 0;
 
 			for (i=0; i<SCRIBE_INSTANCE_MAX; i++)
 			{
 				if (InstLst[i].IsMul())
 				{
 					Mul = InstLst + i;
 					d->MulPassword = Mul->Password;
 					break;
 				}
 			}
 
 			for (i=0; i<SCRIBE_INSTANCE_MAX; i++, InstLst++)
 			{
 				// LgiTrace("[%i] %i, magic=%x, pid=%i\n", i, InstLst->IsScribe(), InstLst->Magic, InstLst->Pid);
 				if (InstLst->IsScribe() && InstLst != ThisInst)
 				{
 					// LgiTrace("%s, %s\n", InstLst->OptionsPath, d->Options->GetFile());
 					if (Mul || _stricmp(InstLst->OptionsPath, d->Options->GetFile()) == 0)
 					{
 						int Pid = InstLst->Pid;
 						OsAppArguments *Args = LAppInst->GetAppArgs();
 						
 						if (!LIsProcess(Pid))
 						{
 							continue;
 						}
 						
 						char *Utf8 = 0;
 						#if WINNATIVE
 						Utf8 = WideToUtf8(Args->lpCmdLine);
 						#else
 						LStringPipe p;
 						for (int i=1; i<Args->Args; i++)
 						{
 							if (i > 1) p.Push(" ");
 							char *Sp = strchr(Args->Arg[i], ' ');
 							if (Sp) p.Push("\"");
 							p.Push(Args->Arg[i]);
 							if (Sp) p.Push("\"");
 						}
 						Utf8 = p.NewStr();
 						#endif
 						if (Utf8)
 						{
 							size_t Len = strlen(Utf8);
 							if (Len > 255)
 							{
 								InstLst->Flags |= SCRIBE_IPC_LONG_ARGS;
 								InstLst->Flags &= ~SCRIBE_IPC_CONTINUE_ARGS;
 								for (char *u = Utf8; Len > 0; u += 255)
 								{
 									ssize_t Part = MIN(sizeof(InstLst->Args)-1, Len);
 									
 									memcpy(InstLst->Args, u, Part);
 									Len -= Part;
 
 									int64 Start = LCurrentTime();
 									while (LCurrentTime() - Start < 60000)
 									{
 										if (TestFlag(InstLst->Flags, SCRIBE_IPC_CONTINUE_ARGS) &&
 											InstLst->Args[0] == 0)
 										{
 											Start = 0;
 											break;
 										}
 										LSleep(10);
 									}
 									if (Start)
 									{
 										LgiTrace("%s:%i - SendLA timed out.\n", _FL);
 										break;
 									}
 								}
 
 								InstLst->Flags &= ~(SCRIBE_IPC_CONTINUE_ARGS | SCRIBE_IPC_LONG_ARGS);
 							}
 							else
 							{
 								strcpy_s(InstLst->Args, sizeof(InstLst->Args), Utf8);
 							}
 							DeleteArray(Utf8);
 							
 							ShutdownIpc();
 							
 							LgiTrace("Passed args to the other running instance of Scribe (pid=%i)\n", Pid);
 							LCloseApp();
 							return false;
 						}
 						else LgiTrace("%s:%i - No arguments to pass.\n", _FL);
 					}
 				}
 			}
 			
 			if (Mul && LFileExists(Mul->OptionsPath))
 			{
 				// No instance of Scribe is running, but MUL may be keeping
 				// the previously run instance around. So we should run that
 				// by using the options file and password from MUL's instance
 				// record.
 				d->Options.Reset(new LOptionsFile(Mul->OptionsPath));
 			}
 		}
 		
 		// Insert ourselves into the instance list
 		if (ThisInst)
 		{
 			strcpy_s(ThisInst->OptionsPath, sizeof(ThisInst->OptionsPath), d->Options->GetFile());
 		}
 	}
 
 	// Open file and load..
 	if (!Load && d->Options)
 	{
 		LOptionsFile *Opts = GetOptions();
 		Load = Opts->SerializeFile(false);
 		if (Load)
 		{
 			LVariant v = d->GetInstallMode() == LOptionsFile::PortableMode;
 			GetOptions()->SetValue(OPT_IsPortableInstall, v);
 		}
 		else
 		{
             auto err = GetOptions()->GetError();
 			LgiMsg(	this,
 					LLoadString(IDS_ERROR_LR8_FAILURE),
 					AppName,
 					MB_OK,
 					err);
 		}
 	}
 
 	if (!d->Options)
 	{
 		// d->Options = new LOptionsFile(d->GetInstallMode(), OptionsFileName);
 		return false;
 	}
 
 	if (d->Options)
 	{
 		LVariant v;
 
 		if (!d->Options->GetValue(OPT_IsPortableInstall, v) &&
 			d->GetInstallMode() != LOptionsFile::UnknownMode)
 		{
 			v = d->GetInstallMode() == LOptionsFile::PortableMode;
 			d->Options->SetValue(OPT_IsPortableInstall, v);
 		}
 
 		ScribeOptionsDefaults(d->Options);
 
 		if (Load)
 		{
 			if (GetOptions()->GetValue(OPT_PrintSettings, v))
 			{
 				auto *p = GetPrinter();
 				if (p)
 				{
 					LString s = v.Str();
 					p->Serialize(s, false);
 				}
 			}
 		}
 
 		if (d->Options->GetValue(OPT_PreviewLines, v))
 		{
 			Mail::PreviewLines = v.CastInt32() != 0;
 		}
 
 		// upgrade smtp password
 		const char *Pw = "SmtpPsw";
 		if (!GetOptions()->GetValue(OPT_EncryptedSmtpPassword, v))
 		{
 			// no encrypted password, look for unencrypted password
 			if (GetOptions()->GetValue(Pw, v))
 			{
 				LPassword p;
 				p.Set(v.Str());
 				p.Serialize(GetOptions(), OPT_EncryptedSmtpPassword, true);
 			}
 		}
 
 		// if old un-encrypted password exists...
 		// delete the key, we are now storing an encrypted 
 		// password
 		if (GetOptions()->GetValue(Pw, v))
 			GetOptions()->DeleteValue(Pw);
 		
 		if (GetOptions()->GetValue(OPT_AdjustDateTz, v))
 			Mail::AdjustDateTz = !v.CastInt32();
 
 		if (!GetOptions()->GetValue(OPT_ConfirmDelete, v))
 			GetOptions()->SetValue(OPT_ConfirmDelete, v = true);
 
 		if (!GetOptions()->GetValue(OPT_DelDirection, v))
 			GetOptions()->SetValue(OPT_DelDirection, v = DeleteActionPrev);
 
 		if (GetOptions()->GetValue(OPT_SizeInKiB, v))
 			OptionSizeInKiB = v.CastInt32() != 0;	
 		if (GetOptions()->GetValue(OPT_RelativeDates, v))
 			ShowRelativeDates = v.CastInt32() != 0;	
 
 		// date format
 		if (GetOptions()->GetValue(OPT_DateFormat, v))
 		{
 			int Idx = v.CastInt32();
 			if (Idx >= 0 && Idx < CountOf(DateTimeFormats))
 				LDateTime::SetDefaultFormat(DateTimeFormats[Idx]);
 		}
 		
 		// SSL debug logging
 		if (GetOptions()->GetValue(OPT_DebugSSL, v))
 			SslSocket::DebugLogging = v.CastInt32() != 0;
 
 		// Growl
 		if (GetOptions()->GetValue(OPT_GrowlEnabled, v) &&
 			v.CastInt32())
 		{
 			LVariant Ver, Bld;
 			GetVariant(DomToStr(SdVersion), Ver);
 			GetVariant("Build", Bld);
 			LString n;
 			n.Printf("%s\n%s", Ver.Str(), Bld.Str());
 			GrowlInfo("Scribe has started up...", n);
 		}
 	}
 
 	#if LGI_EXCEPTIONS
 	try
 	{
 	#endif
 		// Default the font settings to the system font
 		// if they don't already exist
 		const char *OptFont[] = { OPT_EditorFont, OPT_PrintFont, OPT_HtmlFont, 0 };
 		int Index = 0;
 		for (const char **Opt=OptFont; *Opt; Opt++, Index++)
 		{
 			LVariant v;
 			if (!GetOptions()->GetValue(*Opt, v))
 			{
 				LFontType Type;
 				if (Type.GetSystemFont("System"))
 				{
 					if (Index == 2)
 					{
 						int Pt = Type.GetPointSize();
 						Type.SetPointSize(Pt+3);
 					}
 					Type.Serialize(GetOptions(), *Opt, true);
 				}
 			}
 		}
 	#if LGI_EXCEPTIONS
 	}
 	catch (...)
 	{
 		LgiMsg(	this,
 				LLoadString(IDS_ERROR_FONT_SETTINGS),
 				AppName,
 				MB_OK);
 	}
 	#endif
 
 	return true;
 }
 
 bool ScribeWnd::SaveOptions()
 {
 	LStringPipe Log(256);
 	bool Status = false;
 	bool WriteFailed = false;
 	bool WndStateSet = false;
 	
 	RestartSave:
 	if (d->Options && !d->Options->GetFile())
 	{
 		bool PortableOk = true;
 		char Path[MAX_PATH_LEN];
 		char Leaf[32];
 
 		sprintf_s(Leaf, sizeof(Leaf), "%s.xml", OptionsFileName);
 		Log.Print("No current path for '%s', creating...\n", Leaf);
 
 		LVariant v;
 		GetOptions()->GetValue(OPT_IsPortableInstall, v);
 		if (v.CastInt32())
 		{
 			if (!LGetSystemPath(LSP_APP_INSTALL, Path, sizeof(Path)))
 			{
 				PortableOk = false;
 				Log.Print("Error: LgiGetSystemPath(LSP_APP_INSTALL) failed.\n");
 			}
 			else
 			{
 				LMakePath(Path, sizeof(Path), Path, Leaf);
 				
 				// Do write test to confirm we are good to go
 				LFile f;
 				if (f.Open(Path, O_WRITE))
 				{
 					f.Close();
 					FileDev->Delete(Path, false);
 					d->Options->SetFile(Path);
 				}
 				else
 				{
 					PortableOk = false;
 					Log.Print("Warning: '%s' is not writable.\n", Path);
 				}
 			}
 		}
 		
 		if (!v.CastInt32() || !PortableOk)
 		{
 			// Desktop mode then.
 			if (v.CastInt32())
 			{
 				const char *Msg = "Switching to desktop mode because the install folder is not writable.";
 				Log.Print("%s\n", Msg);
 				LgiMsg(this, Msg, AppName, MB_OK);
 				GetOptions()->SetValue(OPT_IsPortableInstall, v = false);
 			}
 
 			if (!LGetSystemPath(LSP_APP_ROOT, Path, sizeof(Path)))
 			{
 				Log.Print("Error: LgiGetSystemPath(LSP_APP_ROOT) failed.\n");
 			}
 			else
 			{
 				LMakePath(Path, sizeof(Path), Path, LAppInst->LBase::Name());
 				if (!LDirExists(Path))
 				{
 					if (!FileDev->CreateFolder(Path))
 					{
 						Log.Print("Error: CreateFolder('%s') failed.\n", Path);
 					}
 				}
 
 				LMakePath(Path, sizeof(Path), Path, Leaf);
 				
 				// Do write test to confirm we are good to go
 				LFile f;
 				if (f.Open(Path, O_WRITE))
 				{
 					f.Close();
 					FileDev->Delete(Path, false);
 					d->Options->SetFile(Path);
 				}
 				else
 				{
 					Log.Print("Error: '%s' is not writable.\n", Path);
 				}
 			}
 		}
 	}
 
 	if (d->Options && d->Options->GetFile() && d->Options->IsValid())
 	{
 		// Backup options file
 		char Backup[MAX_PATH_LEN];
 		strcpy_s(Backup, sizeof(Backup), d->Options->GetFile());
 		char *Ext = LGetExtension(Backup);
 		if (Ext)
 		{
 			*--Ext = 0;
 
 			LString s;
 			for (int i=1; i<100; i++)
 			{
 				s.Printf("%s_%i.bak", Backup, i);
 				if (!LFileExists(s))
 					break;
 			}
 
 			if (!LFileExists(s))
 				FileDev->Move(d->Options->GetFile(), s);
 		}
 
 		// Update some settings...
 		#if LGI_VIEW_HANDLE
 		if (Handle())
 		#endif
 			WndStateSet = SerializeState(GetOptions(), OPT_ScribeWndPos, false);
 
 		LVariant v;
 		if (Splitter)
 			GetOptions()->SetValue(OPT_SplitterPos, v = (int)Splitter->Value());
 		if (d->SubSplit)
 		{
 			auto First = d->SubSplit->GetViewAt(0);
 			if (First == (LViewI*)SearchView)
 			{
 				auto Lst = (SearchView) ? d->SubSplit->GetViewAt(1) : NULL;
 				if (Lst)
 					GetOptions()->SetValue(OPT_SubSplitPos, v = (int)Lst->GetPos().Y());
 			}
 			else
 				GetOptions()->SetValue(OPT_SubSplitPos, v = (int)d->SubSplit->Value());
 		}
 
 		// Write them...
 		if (GetOptions()->SerializeFile(true))
 		{
 			Status = true;
 		}
 		else
 		{
 			// We probably don't have write permissions to the install folder...
 			Log.Print("Error: Options.Serialize failed.\n");
 			
 			if (!WriteFailed)
 			{
 				// This blocks any possibility of an infinite loop
 				WriteFailed = true;
 				d->Options->SetFile(NULL);
 				
 				// Set desktop mode explicitly
 				LVariant v;
 				GetOptions()->GetValue(OPT_IsPortableInstall, v = false);
 				
 				Log.Print("Restarting save after setting desktop mode...\n");
 				goto RestartSave;
 			}
 		}
 	}
 	
 	if (!Status)
 	{
 		LString a = Log.NewLStr();
 		LgiMsg(this, "Saving options failed:\n%s", AppName, MB_OK, a.Get());
 	}
 	
 	if (!WndStateSet)
 	{
 		LRect r(10, 10, 790, 590);
 		SetPos(r);
 		MoveToCenter();
 	}
 	
 	return Status;
 }
 
 //
 // Command Line Options:
 //
 //	-m, -t				: To recipient(s)
 //	-f					: The filename of the attachment
 //	-b					: Attach as a binary
 //	-c					: CC'd recipient(s)
 //	-s					: Subject for the email
 //	-n					: Send now... else UI is shown
 //	-p					: Print the file
 //  -upgrade_folders	: trigger a folder upgrade
 //  -o                  : Load the following options file
 //  -u                  : Load the following URL/file
 //
 void ScribeWnd::OnCommandLine()
 {
 	// check command line args
 	LString Str, File;
 	bool CreateMail = false;
 	CreateMail = LAppInst->GetOption("m", Str);
 	if (!CreateMail) CreateMail = LAppInst->GetOption("t", Str);
 	bool HasFile = LAppInst->GetOption("f", File);
 	if (!CreateMail) CreateMail = HasFile;
 
 	LString OpenArg;
 	if (LAppInst->GetOption("u", OpenArg))
 	{
 		LUri u(OpenArg);
 		if (u.sProtocol)
 		{
 			OnUrl(OpenArg);
 		}
 		else if (LFileExists(OpenArg))
 		{
 			LArray<const char*> Files;
 			Files.Add(OpenArg);
 			OnReceiveFiles(Files);
 		}
 	}
 
 	Mail *NewEmail = 0;
 	if (CreateMail && Str)
 	{
 		// strip off quotes if needed
 		char *In = Str, *Out = Str;
 		for (; In && *In; In++)
 		{
 			if (!strchr("\'\"", *In))
 			{
 				*Out++ = *In;
 			}
 		}
 		*Out++ = 0;
 
 		// create object
 		NewEmail = dynamic_cast<Mail*>(CreateItem(MAGIC_MAIL, NULL, false));
 		if (NewEmail)
 		{
 			Mailto mt(this, Str);
 			mt.Apply(NewEmail);
 
 			// cc's?
 			if (LAppInst->GetOption("c", Str))
 			{
 				SetRecipients(this, Str, NewEmail->GetObject()->GetList(FIELD_TO), MAIL_ADDR_CC);
 			}
 
 			// attach a file?
 			if (File)
 			{
 				if (LAppInst->GetOption("b"))
 				{
 					// attach as a binary file
 					NewEmail->AttachFile(this, &File[0]);
 				}
 				else
 				{
 					// insert as the body
 					LAutoString b(LReadTextFile(&File[0]));
 					if (b)
 					{
 						NewEmail->SetBody(b);
 					}
 				}
 			}
 
 			// subject?
 			if (LAppInst->GetOption("s", Str))
 			{
 				NewEmail->SetSubject(Str);
 			}
 
 			// Send now or later?
 			if (LAppInst->GetOption("n"))
 			{
 				// Check for exit after send option
 				d->ExitAfterSend = LAppInst->GetOption("exit");
 				
 				// now
 				NewEmail->SetFlags(MAIL_CREATED | MAIL_READY_TO_SEND | NewEmail->GetFlags());
 				NewEmail->Save();
 				OnCommand(IDM_SEND_MAIL, 0,
 					#ifndef __GTK_H__
 					Handle()
 					#else
 					NULL
 					#endif
 					);
 			}
 			else
 			{
 				// later
 				NewEmail->DoUI();
 			}
 		}
 	} 
 
 	// Pop3 on startup option
 	LVariant n;
 	if (GetOptions()->GetValue(OPT_Pop3OnStart, n) && n.CastInt32())
 	{
 		OnCommand(IDM_RECEIVE_MAIL, 0, NULL);
 	}
 }
 
 void ScribeWnd::SetCurrentIdentity(int i)
 {
 	LVariant v = i;
 	GetOptions()->SetValue(OPT_CurrentIdentity, v);
 	
 	if (DefaultIdentityItem) DefaultIdentityItem->Checked(i < 0);
 	for (auto a: Accounts)
 	{
 		a->SetCheck(i == a->GetIndex());
 	}
 }
 
 ScribeAccount *ScribeWnd::GetCurrentAccount()
 {
 	auto Idx = GetCurrentIdentity();
 	ScribeAccount *a = (Idx >= 0 && Idx < (ssize_t)Accounts.Length()) ? Accounts.ItemAt(Idx) : NULL;
 	bool ValidId = a != NULL && a->IsValid();
 	if (!ValidId)
 	{
 		LAssert(!"No current identity?");
 		
 		// Find a valid account to be the identity...
 		for (auto a : Accounts)
 		{
 			if (!a->Send.Disabled() &&
 				a->Identity.IsValid())
 			{
 				break;
 			}
 		}
 	}
 	return a;
 }
 
 int ScribeWnd::GetCurrentIdentity()
 {
 	LVariant i;
 	if (GetOptions()->GetValue(OPT_CurrentIdentity, i))
 		return i.CastInt32();
 	else if (ScribeState != ScribeInitializing)
 		LgiTrace("%s:%i - No OPT_CurrentIdentity set.\n", _FL);
 
 	return -1;
 }
 
 void ScribeWnd::SetupAccounts()
 {
 	int i, CurrentIdentity = GetCurrentIdentity();
 
 	if (StatusPanel)
 	{
 		StatusPanel->Empty();
 	}
 
 	#if !defined(COCOA) // FIXME
 	LAssert(ReceiveMenu && PreviewMenu);
 	#endif
 
 	if (SendMenu) SendMenu->Empty();
 	if (ReceiveMenu) ReceiveMenu->Empty();
 	if (PreviewMenu) PreviewMenu->Empty();
 	if (IdentityMenu)
 	{
 		IdentityMenu->Empty();
 	}
 
 	static bool Startup = true;
 
 	bool ResetDefault = false;
 	LArray<ScribeAccount*> Enabled;
 	for (i=0; true; i++)
 	{
 		// char *s = 0;
 
 		ScribeAccount *a = Startup ? new ScribeAccount(this, i) : Accounts[i];
 		if (a)
 		{
 			if (i == 0)
 			{
 				a->Create();
 			}
 			
 			a->Register(this);
 
 			LVariant ReceiveName = a->Receive.Name();
 			LVariant ReceiveServer = a->Receive.Server();
 			LVariant SendServer = a->Send.Server();
 
 			if (i == 0 ||
 				ValidStr(ReceiveName.Str()) ||
 				ValidStr(ReceiveServer.Str()) ||
 				ValidStr(SendServer.Str()) )
 			{
 				a->Send.SendItem = SendItem;
 				a->Receive.ReceiveItem = ReceiveItem;
 				a->Receive.PreviewItem = PreviewItem;
 
 				if (!Accounts.HasItem(a))
 				{
 					Accounts.Insert(a);
 				}
 				
 				if (i) a->Create();				
 				a->InitMenus();
 
 				// Identity Menu Item
 				LVariant IdEmail = a->Identity.Email();
 				LVariant IdName = a->Identity.Name();
 				if (IdentityMenu &&
 					ValidStr(IdEmail.Str()))
 				{
 					char s[256];
 					if (IdName.Str())
 						sprintf_s(s, sizeof(s), "%s <%s>", IdName.Str(), IdEmail.Str());
 					else
 						sprintf_s(s, sizeof(s), "<%s>", IdEmail.Str());
 
 					a->SetMenuItem(IdentityMenu->AppendItem(s, IDM_IDENTITY_BASE+i+1, !a->Send.Disabled()));
 					if (a->Send.Disabled())
 					{
 						a->SetCheck(false);
 						if (i == CurrentIdentity)
 							ResetDefault = true;
 					}
 					else
 					{
 						a->SetCheck(i == CurrentIdentity);
 						Enabled[i] = a;
 					}
 				}
 			}
 			else
 			{
 				Accounts.Delete(a);
 				DeleteObj(a);
 			}
 		}
 
 		if (!a)
 			break;
 	}
 
 	if ((ResetDefault || CurrentIdentity < 0) && Enabled.Length())
 	{
 		for (unsigned i=0; i<Enabled.Length(); i++)
 		{
 			if (Enabled[i])
 			{
 				Enabled[i]->SetCheck(true);
 				
 				LVariant v;
 				GetOptions()->SetValue(OPT_CurrentIdentity, v = (int)i);
 				break;					
 			}
 		}
 	}
 
 	Startup = false;
 
 	if (ReceiveMenu &&
 		i == 0)
 	{
 		ReceiveMenu->AppendItem(LLoadString(IDS_NO_ITEMS), 0, false);
 	}
 
 	if (StatusPanel)
 	{
 		StatusPanel->OnAccountListChange();
 	}
 
 	SetPulse(100);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 class LShutdown : public LDialog
 {
 	LTextLabel *Msg;
 	LButton *KillBtn;
 	LButton *CancelBtn;
 	bool Disconnected;
 	
 public:
 	ScribeAccount *Wait;
 	List<ScribeAccount> *Accounts;
 
 	LShutdown(List<ScribeAccount> *accounts)
 	{
 		Wait = 0;
 		Disconnected = false;
 		Accounts = accounts;
 		LRect r(	0,
 					0,
 					320 + LAppInst->GetMetric(LGI_MET_DECOR_X),
 					70 + LAppInst->GetMetric(LGI_MET_DECOR_Y));
 		SetPos(r);
 		MoveToCenter();
 
 		char Str[256];
 		sprintf_s(Str, sizeof(Str), "%s exiting...", AppName);
 		LView::Name(Str);
 
 		AddView(Msg = new LTextLabel(-1, 10, 10, 300, -1, "None"));
 		AddView(KillBtn = new LButton(IDC_KILL, 70, 35, 60, 20, "Kill"));
 		AddView(CancelBtn = new LButton(IDCANCEL, 140, 35, 60, 20, "Cancel"));
 
 		if (KillBtn)
 		{
 			KillBtn->Enabled(false);
 		}
 	}
 
 	void OnCreate()
 	{
 		SetPulse(100);
 	}
 
 	void OnPulse()
 	{
 		if (Accounts)
 		{
 			if (!Wait)
 			{
 				Wait = (*Accounts)[0];
 				if (Wait)
 				{
 					Disconnected = false;
 					
 					char s[256];
 					LVariant v = Wait->Receive.Name();
 					sprintf_s(s, sizeof(s), "Waiting for '%s'", v.Str() ? v.Str() : (char*)"Untitled...");
 					Msg->Name(s);
 
 					Accounts->Delete(Wait);					
 					Wait->Stop();
 
 					KillBtn->Enabled(true);
 				}
 				else
 				{
 					SetPulse();
 					EndModal(true);
 				}
 			}
 
 			if (Wait && !Wait->IsOnline())
 			{
 				Wait = 0;
 				Msg->Name("None");
 				KillBtn->Enabled(false);
 			}
 		}
 		else
 		{
 			SetPulse();
 			EndModal(false);
 		}
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case IDC_KILL:
 			{
 				if (Wait)
 				{
 					if (!Disconnected)
 					{
 						Disconnected = true;
 						Wait->Disconnect();
 					}
 					else
 					{
 						Wait->Kill();
 					}
 				}
 				break;
 			}
 			case IDCANCEL:
 			{
 				EndModal(false);
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 bool ScribeWnd::OnRequestClose(bool OsShuttingDown)
 {
 	if (FolderTasks.Length() > 0)
 	{
 		LgiTrace("%s:%i - %i folder tasks still busy...\n", _FL, FolderTasks.Length());
 		return false;
 	}
 
 	LString OnClose = LAppInst->GetConfig("Scribe.OnClose");
 	if (!d->IngoreOnClose &&
 		!OsShuttingDown &&
 		!Stricmp(OnClose.Get(), "minimize"))
 	{
 		SetZoom(LZoomMin);
 		return false;
 	}
 
 	Visible(false);
 
 	if (ScribeState != ScribeRunning)
 	{
 		// Inside a folder load/unload or initialization
 		// Tell the loader to quit out...
 		ScribeState = ScribeExiting;
 
 		// Leave now, we can exit when we're ready
 		return false;
 	}
 	else if (IsSending() ||
 			 GetActiveThreads() > 0)
 	{
 		// whack up a shutdown window
 		List<ScribeAccount> Online;
 
 		for (auto i: Accounts)
 		{
 			i->OnEndSession();
 			if (i->IsOnline())
 			{
 				Online.Insert(i);
 			}
 		}
 
 		auto Dlg = new LShutdown(&Online);
 		Dlg->DoModal([this, Dlg](auto dlg, auto id)
 		{
 			if (id)
 			{
 				ScribeState = ScribeExiting;
 				LCloseApp();
 			}
 			else
 			{
 				ScribeState = ScribeRunning;
 				Visible(true);
 			}
 		});
 		return false; // At the very minimum the app has to wait for the user to respond.
 	}
 	else
 	{
 		// End all sessions if any...
 		for (auto i: Accounts)
 		{
 			i->OnEndSession();
 		}
 	}
 
 	// close all the other top level windows
 	while (ThingUi::All.Length() > 0)
 	{
 		ThingUi *Ui = ThingUi::All.First();
 		if (!Ui->OnRequestClose(OsShuttingDown))
 		{
 			ScribeState = ScribeRunning;
 			Visible(true);
 			return false;
 		}
 
 		size_t Start = ThingUi::All.Length();
 		Ui->Quit();
 		if (ThingUi::All.Length() >= Start)
 		{
 			LAssert(0);
 			break;
 		}
 	}
 
 	SerializeState(GetOptions(), OPT_ScribeWndPos, false);
 	LCloseApp();
 
 	return LWindow::OnRequestClose(OsShuttingDown);
 }
 
 void ScribeWnd::DoOnTimer(LScriptCallback *c)
 {
 	if (!c)
 		return;
 
 	auto Now = LCurrentTime();
 	if (c->PrevTs)
 	{
 		auto Since = Now - c->PrevTs; 
 		double Sec = (double)Since / 1000.0;
 		if (Sec >= c->fParam)
 		{
 			// Call the function
 			c->PrevTs = Now;
 
 			LVirtualMachine Vm;
 			LScriptArguments Args(&Vm);
 			LVariant This((LDom*)this);
 			Args.Add(&This);
 			ExecuteScriptCallback(*c, Args);
 		}
 	}
 	else
 	{
 		c->PrevTs = Now;
 	}
 }
 
 void ScribeWnd::OnMinute()
 {
 	if (Folders.Length() == 0)
 		return;
 
 	// Check for calendar event alarms...
 	Calendar::CheckReminders();
 
 	// Check for any outgoing email that should be re-attempted...
 	ScribeFolder *Outbox = GetFolder(FOLDER_OUTBOX);
 	if (Outbox)
 	{
 		bool Resend = false;
 
 		for (auto t : Outbox->Items)
 		{
 			Mail *m = t->IsMail();
 			if (m &&
 				!TestFlag(m->GetFlags(), MAIL_SENT) &&
 				TestFlag(m->GetFlags(), MAIL_READY_TO_SEND) &&
 				m->SendAttempts > 0)
 			{
 				Resend = true;
 				break;
 			}			
 		}
 
 		if (Resend)
 			Send();
 	}
 
 	LArray<LScriptCallback*> Cb;
 	if (GetScriptCallbacks(LOnTimer, Cb))
 	{
 		for (auto c: Cb)
 		{
 			if (!c->Func)
 				continue;
 
 			if (c->fParam == 0.0)
 			{
 				// Work out the period from 'Data'
 				char *s = c->Data.Str();
 				while (*s && IsWhiteSpace(*s)) s++;
 				char *u = s;
 				while (*u && !IsAlpha(*u)) u++;
 				double v = atof(s);
 
 				switch (*u)
 				{
 					case 's': case 'S': // seconds
 						c->fParam = v;
 						break;
 					case 'm': case 'M': // mins
 						c->fParam = v * LDateTime::MinuteLength;
 						break;
 					case 'h': case 'H': // hours
 						c->fParam = v * LDateTime::HourLength;
 						break;
 					case 'd': case 'D': // days
 						c->fParam = v * LDateTime::DayLength;
 						break;
 					default:
 					{
 						LgiTrace("%s:%i - Couldn't understand period '%s'\n", _FL, c->Data.Str());
 						c->Data.Empty();
 						break;
 					}
 				}
 
 				if ((c->OnSecond = c->fParam < 60.0))
 				{
 					d->OnSecondTimerCallbacks.Add(c);
 				}
 			}
 
 			if (!c->OnSecond)
 				DoOnTimer(c);
 		}
 	}
 }
 
 void ScribeWnd::OnHour()
 {
 	// Force time zone update in case of daylight savings change.
 	LDateTime::SystemTimeZone(true);
 
 	// Check if we need should be doing a software update check
 	static bool InSoftwareCheck = false;
 	if (!InSoftwareCheck)
 	{
 		char s[64];
 
 		InSoftwareCheck = true;
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_SoftwareUpdate, v) &&
 			v.CastInt32())
 		{
 			LDateTime Now, Last;
 
 			Now.SetFormat(GDTF_YEAR_MONTH_DAY);
 			Last.SetFormat(Now.GetFormat());
 
 			Now.SetNow();
 					
 			if (!GetOptions()->GetValue(OPT_SoftwareUpdateLast, v) ||
 				!Last.Set(v.Str()))
 			{
 				// Record now as the last check point
 				Now.Get(s, sizeof(s));
 				GetOptions()->SetValue(OPT_SoftwareUpdateLast, v = s);
 			}
 			else if (GetOptions()->GetValue(OPT_SoftwareUpdateTime, v))
 			{
 				// Valid last check date/time.
 				switch (v.CastInt32())
 				{
 					case 0: // Week
 						Last.AddDays(7);
 						break;
 					case 1: // Month
 						Last.AddMonths(1);
 						break;
 					case 2: // Year
 						Last.AddMonths(12);
 						break;
 					default:
 						LgiTrace("%s:%i - The option '%s' is not valid\n", _FL, OPT_SoftwareUpdateTime);
 						return;
 				}
 
 				if (Last < Now)
 				{
 					// Save the last date for next time...
 					Now.Get(s, sizeof(s));
 					GetOptions()->SetValue(OPT_SoftwareUpdateLast, v = s);
 
 					// Check for update now...
 					GetOptions()->GetValue(OPT_SoftwareUpdateIncBeta, v);
 					IsSoftwareUpToDate(	this,
 										false,
 										v.CastInt32() != 0,
 										[this](auto s, auto Info)
 										{
 											if (s == SwOutOfDate)
 												if (UpgradeSoftware(Info, this, true))
 													LCloseApp();
 										});
 				}
 			}
 		}
 		InSoftwareCheck = false;
 	}
 }
 
 bool ScribeWnd::SaveDirtyObjects(int TimeLimitMs)
 {
 	bool Status = false;
 	if (Thing::DirtyThings.Length() > 0)
 	{
 		static bool SavingObjects = false;
 
 		if (!SavingObjects)
 		{
 			SavingObjects = true;
 
 			LArray<int> WriteTimes;
 			// ssize_t StartDirty = Thing::DirtyThings.Length();
 			uint64 Start = LCurrentTime();
 			for (unsigned i=0;
 				i<ThingType::DirtyThings.Length() && LCurrentTime() - Start < TimeLimitMs;
 				i++)
 			{
 				ThingType *t = ThingType::DirtyThings[i];
 				if (t)
 				{
 					static int FailedWrites = 0;
 
 					uint64 WriteStart = LCurrentTime();
 					if (t->Save(NULL))
 					{
 						WriteTimes.Add((int) (LCurrentTime() - WriteStart));
 						
 						LAssert(!ThingType::DirtyThings.HasItem(t));
 						Status = true;
 					}
 					else
 					{
 						LgiTrace("Failed to save thing type 0x%x\n", t->Type());
 
 						FailedWrites++;
 						if (FailedWrites > 2)
 						{
 							while (ThingType::DirtyThings.Length())
 								ThingType::DirtyThings[0]->SetDirty(false);
 							FailedWrites = 0;
 						}
 					}
 				}
 			}
 
 			SavingObjects = false;
 			
 			/*
 			if (Status)
 			{
 				LStringPipe p;
 				p.Print("WriteTimes: ");
 				for (unsigned i=0; i<WriteTimes.Length(); i++)
 					p.Print("%i, ", WriteTimes[i]);
 				LAutoString a(p.NewStr());
 				#ifdef WINDOWS
 				OutputDebugStringA(a);
 				#else
 				printf("%s", a.Get());
 				#endif
 			}
 			*/
 		}
 	}
 
 	return Status;
 }
 
 void ScribeWnd::OnPulse()
 {
 	if (ScribeState == ScribeRunning)
 	{
 		OnIdle();
 		
 		uint64 Now = LCurrentTime();
 		if (Now - d->LastTs >= 1000)
 		{
 			d->LastTs = Now;
 			OnPulseSecond();
 		}
 	}
 }
 
 void ScribeWnd::OnPulseSecond()
 {
 	#if PROFILE_ON_PULSE
 	LProfile Prof("NewMailLst handling");
 	Prof.HideResultsIfBelow(50);
 	#endif
 	
 	if (Mail::NewMailLst.Length() > 0)
 	{
 		LVariant Blink;
 		if (GetOptions()->GetValue(OPT_BlinkNewMail, Blink) && Blink.CastInt32())
 		{
 			TrayIcon.Value((TrayIcon.Value() == TRAY_ICON_MAIL) ? TRAY_ICON_NONE : TRAY_ICON_MAIL);
 		}
 	}
 	else
 	{
 		bool Err = false;
 		for (auto a: Accounts)
 		{
 			if (!a->Receive.GetStatus() ||
 				!a->Send.GetStatus())
 			{
 				Err = true;
 			}
 		}
 		
 		TrayIcon.Value(Err ? TRAY_ICON_ERROR : TRAY_ICON_NORMAL);
 	}
 	
 	#if PROFILE_ON_PULSE
 	Prof.Add("StatusPanel handling");
 	#endif
 
 	if (StatusPanel)
 	{
 		StatusPanel->OnPulse();
 	}
 
 	#if PROFILE_ON_PULSE
 	Prof.Add("OnXXXX handling");
 	#endif
 	
 	LDateTime Now;
 	Now.SetNow();
 	if (d->LastMinute != Now.Minutes()) // Check every minute...
 	{
 		d->LastMinute = Now.Minutes();
 		OnMinute();
 	}
 	if (d->LastHour != Now.Hours()) // Check every hour...
 	{
 		d->LastHour = Now.Hours();
 		OnHour();
 	}
 	{
 		// These timers need to be checked every second...
 		for (auto c: d->OnSecondTimerCallbacks)
 			DoOnTimer(c);
 	}
 
 	#if PROFILE_ON_PULSE
 	Prof.Add("Instance handling");
 	#endif
 
 	if (ThisInst && ValidStr(ThisInst->Args))
 	{
 		LStringPipe p;
 		p.Push(ThisInst->Args);
 		if (ThisInst->Flags & SCRIBE_IPC_LONG_ARGS)
 		{
 			ThisInst->Flags |= SCRIBE_IPC_CONTINUE_ARGS;
 
 			int64 Start = LCurrentTime();
 			while (	TestFlag(ThisInst->Flags, SCRIBE_IPC_LONG_ARGS) &&
 					LCurrentTime() - Start < 60000)
 			{
 				ZeroObj(ThisInst->Args);
 				while (	TestFlag(ThisInst->Flags, SCRIBE_IPC_LONG_ARGS) &&
 						!ThisInst->Args[0] &&
 						LCurrentTime() - Start < 60000)
 				{
 					LSleep(10);
 				}
 				p.Push(ThisInst->Args);
 			}
 		}
 		ZeroObj(ThisInst->Args);
 
 		LAutoString Arg(p.NewStr());
 		if (Arg)
 		{
 			OsAppArguments AppArgs(0, 0);
 			
 			LgiTrace("Received cmd line: %s\n", Arg.Get());
 			AppArgs.Set(Arg);
 
 			LAppInst->SetAppArgs(AppArgs);
 
 			if (LAppInst->GetOption("m") &&
 				LAppInst->GetOption("f"))
 				;
 			else
 				LAppInst->OnCommandLine();
 			
 			OnCommandLine();
 
 			if (GetZoom() == LZoomMin)
 				SetZoom(LZoomNormal);
 			Visible(true);
 		}
 	}
 
 	#if PROFILE_ON_PULSE
 	Prof.Add("PreviewPanel handling");
 	#endif
 
 	if (PreviewPanel)
 	{
 		PreviewPanel->OnPulse();
 	}
 }
 
 void ScribeWnd::AddFolderToMru(char *FileName)
 {
 	if (FileName)
 	{
 		// read MRU
 		List<char> Files;
 		int i;
 		for (i=0; i<10; i++)
 		{
 			char Key[32];
 			LVariant f;
 			sprintf_s(Key, sizeof(Key), "FolderMru.%i", i);
 			if (GetOptions()->GetValue(Key, f))
 			{
 				Files.Insert(NewStr(f.Str()));
 				GetOptions()->DeleteValue(Key);
 			}
 		}
 
 		// remove FileName if present
 		for (auto f: Files)
 		{
 			if (_stricmp(f, FileName) == 0)
 			{
 				Files.Delete(f);
 				DeleteArray(f);
 				break;
 			}
 		}
 
 		// insert FileName at the start of the list
 		Files.Insert(NewStr(FileName));
 
 		// write MRU
 		for (i=0; i<10; i++)
 		{
 			char *n = Files.ItemAt(i);
 			if (n)
 			{
 				char Key[32];
 				sprintf_s(Key, sizeof(Key), "FolderMru.%i", i);
 				LVariant f;
 				GetOptions()->SetValue(Key, f = n);
 			}
 			else break;
 		}
 
 		// Clean up
 		Files.DeleteArrays();
 	}
 }
 
 bool ScribeWnd::CleanFolders(ScribeFolder *f)
 {
 	if (!f)
 		return false;
 
 	if (f->Select())
 	{
 		f->SerializeFieldWidths();
 	}
 
 	for (ScribeFolder *c = f->GetChildFolder(); c; c = c->GetNextFolder())
 	{
 		CleanFolders(c);
 	}
 
 	return true;
 }
 
 void ScribeWnd::OnFolderChanged(LDataFolderI *folder)
 {
 }
 
 bool ScribeWnd::OnFolderTask(LEventTargetI *Ptr, bool Add)
 {
 	if (Add)
 	{
 		if (FolderTasks.HasItem(Ptr))
 		{
 			LAssert(!"Can't add task twice.");
 			return false;
 		}
 		FolderTasks.Add(Ptr);
 		return true;
 	}
 	else
 	{
 		if (!FolderTasks.HasItem(Ptr))
 		{
 			LAssert(!"Item not part of task list.");
 			return false;
 		}
 		FolderTasks.Delete(Ptr);
 		return true;
 	}
 }
 
 LMailStore *ScribeWnd::GetDefaultMailStore()
 {
 	LMailStore *Def = 0;
 
 	for (unsigned i=0; i<Folders.Length(); i++)
 	{
 		if (Folders[i].IsOk())
 		{
 			if (Folders[i].Default || !Def)
 			{
 				Def = &Folders[i];
 			}
 			else if (Def)
 			{
 				if (Folders[i].Priority() > Def->Priority())
 				{
 					Def = &Folders[i];
 				}
 			}
 		}
 	}
 
 	return Def;
 }
 
 bool HasMailStore(LXmlTag *MailStores, char *Name)
 {
 	for (auto t : MailStores->Children)
 	{
 		char *StoreName = t->GetAttr(OPT_MailStoreName);
 		if (StoreName && Name && !_stricmp(StoreName, Name))
 			return true;
 	}
 	return false;
 }
 
 LDataStoreI *ScribeWnd::CreateDataStore(const char *_Full, bool CreateIfMissing)
 {
 	LString Full(_Full);
 	auto Ext = LGetExtension(Full);
 	if (Ext)
 	{
 		if (!_stricmp(Ext, "mail2"))
 		{
 			LgiMsg(this, LLoadString(IDS_MAIL2_DEPRECATED), AppName, MB_OK, Full.Get());
 		}
 		else if (!_stricmp(Ext, "mail3"))
 		{
 			return OpenMail3(Full, this, CreateIfMissing);
 		}
 		else if (!_stricmp(Ext, "sqlite"))
 		{
 			LTrimDir(Full);
 			return OpenMail3(Full, this, CreateIfMissing);
 		}
 		else
 		{
 			LgiTrace("%s:%i - Not a valid mail store extension: %s\n", _FL, Full.Get());
 			LAssert(!"Not a valid mail store extension.");
 		}
 	}
 	else LgiTrace("%s:%i - No extension for CreateDataStore: %s\n", _FL, Full.Get());
 
 	return NULL;
 }
 
 class MailStoreUpgrade :
 	public LProgressDlg,
 	public LDataPropI
 {
 public:
 	ScribeWnd *App = NULL;
 	LDataStoreI *Ds = NULL;
 	int Status = -1;
 	LString Error;
 
 	MailStoreUpgrade(ScribeWnd *app, LDataStoreI *ds) :
 		LProgressDlg(app, -1)
 	{
 		SetParent(App = app);
 		Ds = ds;
 		SetCanCancel(false);
 		SetDescription("Upgrading mail store...");
 		SetPulse(1000);
 
 		Ds->Upgrade(this, this, [this](auto status)
 		{
 			Status = status;
 		});
 	}
 
 	~MailStoreUpgrade()
 	{
 	}
 
 	void OnPulse() override
 	{
 		if (Status >= 0)
 		{
 			EndModal(0);
 			return;
 		}
 
 		return LProgressDlg::OnPulse();
 	}
 
 	LDataPropI &operator =(LDataPropI &p)
 	{
 		LAssert(0);
 		return *this;
 	}
 
 	Store3Status SetStr(int id, const char *str) override
 	{
 		switch (id)
 		{
 			case Store3UiError:
 				Error = str;
 				break;
 			default:
 				LAssert(!"Impl me.");
 				return Store3Error;
 				break;
 		}
 		
 		return Store3Success;
 	}
 };
 
 bool ScribeWnd::ProcessFolder(LDataStoreI *&Store, int StoreIdx, char *StoreName)
 {
 	if (Store->GetInt(FIELD_VERSION) == 0)
 	{
 		// version error
 		LgiMsg(this, LLoadString(IDS_ERROR_FOLDERS_VERSION), AppName, MB_OK, 0, Store->GetInt(FIELD_VERSION));
 		return false;
 	}
 
 	if (Store->GetInt(FIELD_READONLY))
 	{
 		LgiMsg(this, LLoadString(IDS_ERROR_READONLY_FOLDERS), AppName);
 	}
 
 	// get root item
 	LDataFolderI *Root = Store->GetRoot();
 	if (!Root)
 		return false;
 
 	ScribeFolder *&Mailbox = Folders[StoreIdx].Root;
 	Mailbox = new ScribeFolder;
 	if (Mailbox)
 	{
 		Mailbox->App = this;
 		Mailbox->SetObject(Root, false, _FL);
 
 		Root->SetStr(FIELD_FOLDER_NAME, StoreName);
 		Root->SetInt(FIELD_FOLDER_TYPE, MAGIC_NONE);
 	}
 
 	#ifdef TEST_OBJECT_SIZE
 	// debug/repair code
 	if (Root->StoreSize != Root->Sizeof())
 	{
 		SizeErrors[0]++;
 		Root->StoreSize = Root->Sizeof();
 		if (Root->Object)
 		{
 			Root->Object->StoreDirty = true;
 		}
 	}
 	#endif
 
 	// Insert the root object and then...
 	Tree->Insert(Mailbox);
 
 	// Recursively load the rest of the tree
 	{
 		// LProfile p("Loadfolders");
 		Mailbox->LoadFolders();
 	}
 				
 	// This forces a re-pour to re-order the folders according to their
 	// sort settings.
 	Tree->UpdateAllItems();
 
 	if (ScribeState != ScribeExiting)
 	{
 		// Show the tree
 		Mailbox->Expanded(Folders[StoreIdx].Expanded);
 
 		// Checks the folders for a number of required objects
 		// and creates them if required
 		auto StoreType = Store->GetInt(FIELD_STORE_TYPE);
 		if (StoreType == Store3Sqlite)
 			Validate(&Folders[StoreIdx]);
 		else if (StoreType < 0)
 			LAssert(!"Make sure you impl the FIELD_STORE_TYPE field in the store.");
 
 					
 		// FIXME
 		// AddFolderToMru(Full);
 	}
 
 	return true;
 }
 
 struct LoadMailStoreState : public LView::ViewEventTarget
 {
 	typedef std::function<void(bool)> BoolCb;
 	typedef std::function<void(int)>  IntCb;
 
 	ScribeWnd *App;
 	BoolCb Callback; // Final cb for entire LoadMailStoreState execution
 	LOptionsFile *Options = NULL;
 	LXmlTag *MailStores = NULL;
 	LArray<LXmlTag*> Que;
 	int StoreIdx = 0;
 	bool OptionsDirty = false;
 	bool Status = false;
 	std::function<bool(bool)> ReturnWithEvent;
 	std::function<bool(bool)> ReturnOnDialog;
 	std::function<void(const char *folderPath,const char *details,IntCb callback)> AskStoreUpgrade;
 
 	LoadMailStoreState(ScribeWnd *app, std::function<void(bool)> callback) :
 		ViewEventTarget(app, M_LOAD_NEXT_MAIL_STORE),
 		App(app),
 		Callback(callback)
 	{
 		Options = App->GetOptions();
 
 		ReturnWithEvent = [this](bool s)
 		{
 			PostEvent(M_LOAD_NEXT_MAIL_STORE);
 			return s;
 		};
 
 		ReturnOnDialog = [this](bool s)
 		{
 			return s;
 		};
 
 		AskStoreUpgrade = [this](auto FolderPath, auto Details, auto cb)
 		{
 			auto result = LgiMsg(App,
 								LLoadString(IDS_MAILSTORE_UPGRADE_Q),
 								AppName,
 								MB_YESNO,
 								FolderPath,
 								ValidStr(Details) ? Details : "n/a");
 			cb(result);
 		};
 
 		MailStores = Options->LockTag(OPT_MailStores, _FL);
 
 		// Load up some work in the queue and start the iteration...
 		if (MailStores)
 			Que = MailStores->Children;
 	}
 
 	void Start()
 	{
 		PostEvent(M_LOAD_NEXT_MAIL_STORE);
 	}
 
 	bool OnStatus(bool b)
 	{
 		if (MailStores)
 			Options->Unlock();
 
 		if (OptionsDirty)
 			App->SaveOptions();
 
 		if (Callback)
 			Callback(b);
 		
 		delete this;
 		
 		return b;
 	}
 
 	LMessage::Result OnEvent(LMessage *Msg) override
 	{
 		if (Msg->Msg() == M_LOAD_NEXT_MAIL_STORE)
 		{
 			if (!MailStores)
 				OnStatus(false);
 			else
 				Iterate();
 		}
 
 		return 0;
 	}
 
 	// This will process one item off the Que,
 	// Or if no work is available call PostIterate to 
 	// finish the process.
 	//
 	// In most cases this function should complete with
 	// ReturnWithEvent to trigger the next iteration...
 	bool Iterate()
 	{
 		// No more work, so do the completion step:
 		if (Que.Length() == 0)
 			return PostIterate();
 
 		// There are 2 exits modes for this function:
 		//
 		// 1) Normal exit where we should post a M_LOAD_NEXT_MAIL_STORE to ourselves to
 		// start the next iteration by calling ReturnWithEvent.
 		//
 		// 2) A dialog was launched and we should NOT post a M_LOAD_NEXT_MAIL_STORE event
 		// by calling ReturnOnDialog. The dialog's callback will do that later.
 
 		// Get the next Xml tag off the queue:
 		auto MailStore = Que[0];
 		Que.DeleteAt(0, true);
 
 		if (!MailStore->IsTag(OPT_MailStore))
 			return ReturnWithEvent(false);
 
 		// Read the folders..
 		auto Path       = MailStore->GetAttr(OPT_MailStoreLocation);
 		auto ContactUrl = MailStore->GetAttr(OPT_MailStoreContactUrl);
 		auto CalUrl     = MailStore->GetAttr(OPT_MailStoreCalendarUrl);
 		if (!Path && !ContactUrl && !CalUrl)
 		{
 			LgiTrace("%s:%i - No mail store path (%i).\n", _FL, StoreIdx);
 			return ReturnWithEvent(false);
 		}
 
 		// If disabled, skip:
 		if (MailStore->GetAsInt(OPT_MailStoreDisable) > 0)
 			return ReturnWithEvent(false);
 
 		// Check and validate the folder name:
 		auto StoreName = MailStore->GetAttr(OPT_MailStoreName);
 		if (!StoreName)
 		{
 			char Tmp[256];
 			for (int i=1; true; i++)
 			{
 				sprintf_s(Tmp, sizeof(Tmp), "Folders%i", i);
 				if (!HasMailStore(MailStores, Tmp))
 					break;
 			}
 
 			MailStore->SetAttr(OPT_MailStoreName, Tmp);
 			StoreName = MailStore->GetAttr(OPT_MailStoreName);
 			OptionsDirty = true;
 		}
 
 		// Build a LMailStore entry in App->Folders:
 		auto &Folder = App->Folders[StoreIdx];
 		Folder.Name = StoreName;
 
 		if (Path)
 		{
 			// Mail3 folders on disk...
 			LFile::Path p;
 			if (LIsRelativePath(Path))
 			{
 				p = Options->GetFile();
 				p--;
 				p += Path;
 			}
 			else p = Path;
 			auto Full = p.GetFull();
 
 			LVariant CreateFoldersIfMissing;
 			Options->GetValue(OPT_CreateFoldersIfMissing, CreateFoldersIfMissing);
 
 			// Sniff type...
 			auto Ext = LGetExtension(Full);
 			if (!Ext)
 				return ReturnWithEvent(false);
 
 			if (!Folder.Store)
 				Folder.Store = App->CreateDataStore(Full, CreateFoldersIfMissing.CastInt32() != 0);
 			if (!Folder.Store)
 			{
 				LgiTrace("%s:%i - Failed to create data store for '%s'\n", _FL, Full.Get());
 				return ReturnWithEvent(false);
 			}
 
 			Folder.Path = Full;
 		}
 		else if (ContactUrl || CalUrl)
 		{
 			// Remove Webdav folders...
 			Folder.Store = new WebdavStore(App, App, StoreName);
 		}
 		else
 		{
 			return ReturnWithEvent(false);
 		}
 
 		LDataStoreI *&Store = Folder.Store;
 		auto ex = MailStore->GetAsInt(OPT_MailStoreExpanded);
 		if (ex >= 0)
 			Folder.Expanded = ex != 0;
 		
 		// Check if the mail store requires upgrading...
 		auto MsState = (Store3Status)Store->GetInt(FIELD_STATUS);
 		if (MsState == Store3UpgradeRequired)
 		{
 			LgiTrace("%s:%i - this=%p\n", _FL, this);
 			auto Details = Store->GetStr(FIELD_STATUS);
 			AskStoreUpgrade(Folder.Path.Get(),
 							ValidStr(Details) ? Details : "n/a",
 							[this, Store, MailStore](auto result)
 							{
 								if (result == IDYES)
 								{
 									auto Prog = new MailStoreUpgrade(App, Store);
 									Prog->DoModal([this, MailStore](auto dlg, auto code)
 									{
 										// Upgrade complete, finish the iteration..
 										Iterate2(MailStore);
 
 										delete dlg;
 									});
 									return;
 								}
 
 								// Upgrade not allowed, so do next iteration...			
 								ReturnWithEvent(false);
 							});
 
 			return ReturnOnDialog(true);
 		}
 		else if (MsState == Store3Error)
 		{
 			auto ErrMsg = Store->GetStr(FIELD_ERROR);
 			auto a = new LAlert(App,
 								AppName, ErrMsg ? ErrMsg : LLoadString(IDS_ERROR_FOLDERS_STATUS),
 								LLoadString(IDS_EDIT_MAIL_STORES),
 								LLoadString(IDS_OK));			
 			a->DoModal([this](auto dlg, auto code)
 			{
 				delete dlg;
 
 				if (code == 1)
 				{
 					App->PostEvent(M_COMMAND, IDM_MANAGE_MAIL_STORES);
 					
 					// This fails the whole LoadMailStores process, because the user
 					// is going to edit the mail store list via the dialog;
 					OnStatus(false);
 				}
 				else
 				{
 					// We can't load this mail store, so do the next iteration...
 					ReturnWithEvent(true);
 				}
 			});
 
 			return ReturnOnDialog(false);
 		}
 
 		// No upgrade or error, just keep going.
 		return Iterate2(MailStore);
 	}
 
 	// This also should complete by calling ReturnWithEvent/ReturnOnDialog.
 	bool Iterate2(LXmlTag *MailStore)
 	{
 		auto &Folder = App->Folders[StoreIdx];
 		auto StoreName = MailStore->GetAttr(OPT_MailStoreName);
 
 		// check password
 		LString FolderPsw;
 		if ((FolderPsw = Folder.Store->GetStr(FIELD_STORE_PASSWORD)))
 		{
 			bool Verified = false;
 
 			if (ValidStr(App->d->MulPassword))
 			{
 				Verified = App->d->MulPassword.Equals(FolderPsw, false);
 				App->d->MulPassword.Empty();
 			}
 
 			if (!Verified)
 			{
 				auto Dlg = new LInput(App, "", LLoadString(IDS_ASK_FOLDER_PASS), AppName, true);
 				Dlg->DoModal([this, Dlg, FolderPsw, StoreName](auto dlg, auto id)
 				{
 					auto psw = Dlg->GetStr();
 					delete dlg;
 
 					if (id == IDOK)
 					{
 						auto &Folder = App->Folders[StoreIdx];
 						if (psw == FolderPsw)
 						{
 							Status |= App->ProcessFolder(Folder.Store, StoreIdx, StoreName);
 						}
 						else
 						{
 							// Clear the folder and don't increment the StoreIdx...
 							Folder.Empty();
 							App->Folders.PopLast();
 							ReturnWithEvent(false);
 							return;
 						}
 					}
 
 					Iterate3();
 				});
 
 				return ReturnOnDialog(true);
 			}
 		}
 		else
 		{
 			Status |= App->ProcessFolder(Folder.Store, StoreIdx, StoreName);
 		}
 
 		return Iterate3();
 	}
 
 	bool Iterate3()
 	{
 		StoreIdx++;
 		return ReturnWithEvent(true);
 	}
 
 	bool PostIterate()
 	{
 		if (Status)
 		{
 			// Force load some folders...
 			ScribeFolder *Folder = App->GetFolder(FOLDER_CALENDAR);
 			if (Folder)
 				Folder->LoadThings();
 			Folder = App->GetFolder(FOLDER_FILTERS);
 			if (Folder)
 				Folder->LoadThings();
 			for (auto ms: App->Folders)
 			{
 				if (!ms.Root)
 					continue;
 				for (auto c = ms.Root->GetChildFolder(); c; c = c->GetNextFolder())
 				{
 					if (c->GetItemType() == MAGIC_CONTACT ||
 						c->GetItemType() == MAGIC_FILTER)
 						c->LoadThings();
 				}
 			}
 
 			List<Contact> c;
 			App->GetContacts(c);
 
 			// Set selected folder to Inbox by default
 			// if the user hasn't selected a folder already
 			if (App->ScribeState != ScribeWnd::ScribeExiting && App->Tree && !App->Tree->Selection())
 			{
 				LVariant StartInFolder;
 				Options->GetValue(OPT_StartInFolder, StartInFolder);
 
 				ScribeFolder *Start = NULL;
 				if (ValidStr(StartInFolder.Str()))
 				{
 					Start = App->GetFolder(StartInFolder.Str());
 				}
 				if (!Start)
 				{
 					Start = App->GetFolder(FOLDER_INBOX);
 				}
 				if (Start && App->Tree)
 				{
 					App->Tree->Select(Start);
 				}
 			}
 		}
 
 		Options->DeleteValue(OPT_CreateFoldersIfMissing);
 
 		// Set system folders
 		ScribeFolder *f = App->GetFolder(FOLDER_INBOX);
 		if (f) f->SetSystemFolderType(Store3SystemInbox);
 		f = App->GetFolder(FOLDER_OUTBOX);
 		if (f) f->SetSystemFolderType(Store3SystemOutbox);
 		f = App->GetFolder(FOLDER_SENT);
 		if (f) f->SetSystemFolderType(Store3SystemSent);
 		f = App->GetFolder(FOLDER_SPAM);
 		if (f) f->SetSystemFolderType(Store3SystemSpam);
 
 		return OnStatus(Status);
 	}
 };
 
 void ScribeWnd::LoadMailStores(std::function<void(bool)> Callback)
 {
 	if (auto s = new LoadMailStoreState(this, Callback))
 		s->Start();
 }
 
 void ScribeWnd::LoadFolders(std::function<void(bool)> Callback)
 {
 	AppState PrevState = ScribeState;
 	ScribeState = ScribeLoadingFolders;
 
 	// Setup Mailstores tag
 	{
 		LXmlTag *MailStores = GetOptions()->LockTag(OPT_MailStores, _FL);
 		if (!MailStores)
 		{
 			// Check if we can upgrade the old folder tag
 			char n[32];
 			sprintf_s(n, sizeof(n), "%s-Folders", LGetOsName());
 			LVariant OldFolders;
 			GetOptions()->GetValue(n, OldFolders);
 
 			// Create mail store element..
 			GetOptions()->CreateTag(OPT_MailStores);
 			if ((MailStores = GetOptions()->LockTag(OPT_MailStores, _FL)))
 			{
 				if (OldFolders.Str())
 				{
 					LXmlTag *Store = MailStores->CreateTag(OPT_MailStore);
 					if (Store)
 					{
 						char Opts[MAX_PATH_LEN];
 						LMakePath(Opts, sizeof(Opts), GetOptions()->GetFile(), "..");
 						auto Rel = LMakeRelativePath(Opts, OldFolders.Str());
 
 						Store->SetAttr(OPT_MailStoreLocation, Rel ? Rel.Get() : OldFolders.Str());
 
 						// No need to ask the user for a store name, it'll be
 						// asked later in this method anyway...
 
 						// Leave the old folder tag in the xml in case the user
 						// downgrades to v1.xx
 					}
 				}
 			}
 		}
 
 		GetOptions()->Unlock();
 		if (!MailStores)
 		{
 			if (Callback)
 				Callback(false);
 			return;
 		}
 	}
 
 	// Set loading flags
 	CmdSend.Enabled(false);
 	CmdReceive.Enabled(false);
 	CmdPreview.Enabled(false);
 
 	LoadMailStores([this, PrevState, Callback](auto Status)
 	{
 		if (Tree)
 		{
 			for (auto a: Accounts)
 			{
 				if (!a->Receive.Disabled() && a->Receive.IsPersistant())
 					a->Receive.Connect(0, false);
 			}
 		}
 
 		using BoolFn = std::function<void(bool)>;
 		auto FinishLoad = new BoolFn
 		(
 			[this, PrevState, Callback](bool Status)
 			{
 				if (ScribeState == ScribeExiting)
 				{
 					LCloseApp();
 				}
 				else
 				{
 					d->FoldersLoaded = true;
 					PostEvent(M_SCRIBE_LOADED);
 				}
 
 				if (ScribeState == ScribeExiting)
 					LCloseApp();
 				ScribeState = PrevState;
 
 				if (Callback)
 					Callback(Status);
 			}
 		);
 
 		if (Folders.Length() == 0)
 		{
 			auto Dlg = new ScribeFolderDlg(this);
 			Dlg->DoModal([this, Dlg, FinishLoad, Callback, &Status](auto dlg, auto id)
 			{
 				if (id == IDOK)
 				{
 					bool CreateMailStore = false;
 
 					if (Dlg->Create)
 					{
 						// create folders
 						if (LFileExists(Dlg->FolderFile))
 						{
 							if (LgiMsg(this, LLoadString(IDS_ERROR_FOLDERS_ALREADY_EXIST), AppName, MB_YESNO) == IDYES)
 								CreateMailStore = true;
 							else
 								LgiMsg(this, LLoadString(IDS_ERROR_WONT_OVERWRITE_FOLDERS), AppName);
 						}
 						else if ((Status = CreateFolders(Dlg->FolderFile)))
 							CreateMailStore = true;
 					}
 					else
 						CreateMailStore = true;
 
 					if (CreateMailStore)
 					{
 						LXmlTag *MailStores = GetOptions()->LockTag(OPT_MailStores, _FL);
 						if (MailStores)
 						{
 							LXmlTag *Store = MailStores->CreateTag(OPT_MailStore);
 							if (Store)
 							{
 								char p[MAX_PATH_LEN];
 								LMakePath(p, sizeof(p), GetOptions()->GetFile(), "..");
 								auto RelPath = LMakeRelativePath(p, Dlg->FolderFile);
 								Store->SetAttr(OPT_MailStoreLocation, RelPath ? RelPath.Get() : Dlg->FolderFile.Get());
 							}
 							GetOptions()->Unlock();
 
 							LoadMailStores(NULL);
 						}
 					}
 				}
 
 				if (id)
 					(*FinishLoad)(Status);
 				else if (Callback)
 					Callback(false);
 				delete FinishLoad;
 				delete dlg;
 			});
 		}
 		else
 		{
 			(*FinishLoad)(Status);
 			delete FinishLoad;
 		}
 	});
 }
 
 bool ScribeWnd::UnLoadFolders()
 {
 	if (FolderTasks.Length() > 0 ||
 		ScribeState == ScribeLoadingFolders)
 	{
 		// Um, we can't unload folders right now 
 		// something is already happening...
 		return false;
 	}
 
 	AppState PrevState = ScribeState;
 	ScribeState = ScribeUnloadingFolders;
 
 	OnSelect();
 
 	if (MailList)
 	{
 		ScribeFolder *Container = MailList->GetContainer();
 		if (Container)
 		{
 			// save folder settings
 			Container->SerializeFieldWidths();
 		}
 
 		MailList->SetContainer(NULL);
 		MailList->RemoveAll();
 	}
 
 	int Error = 0;
 	while (Thing::DirtyThings.Length() > 0)
 	{
 		if (!SaveDirtyObjects())
 		{	
 			Error++;
 			LgiTrace("%s:%i - SaveDirtyObjects failed.\n", _FL);
 
 			if (Error > 100)
 			{
 				// I think we're stuck...
 				return false;
 			}
 		}
 	}
 
 	// Unload IMAP folders...
 	for (auto a: Accounts)
 	{
 		if (!a->Receive.Disabled() &&
 			a->Receive.IsPersistant())
 		{
 			a->Receive.Disconnect();
 		}
 	}
 
 	if (GetOptions())
 	{
 		// Unload local folders...
 		LXmlTag *MailStores = GetOptions()->LockTag(OPT_MailStores, _FL);
 
 		for (size_t i=0; i<Folders.Length(); i++)
 		{
 			// Save the expanded state...
 			if (Folders[i].Root)
 			{
 				bool Expanded = Folders[i].Root->Expanded();
 
 				for (auto ms: MailStores->Children)
 				{
 					char *StoreName = ms->GetAttr(OPT_MailStoreName);
 					if (Folders[i].Name.Equals(StoreName))
 					{
 						ms->SetAttr(OPT_MailStoreExpanded, Expanded);
 						break;
 					}
 				}
 			}
 
 			DeleteObj(Folders[i].Root);
 			DeleteObj(Folders[i].Store);
 		}
 
 		if (MailStores)
 		{
 			GetOptions()->Unlock();
 			MailStores = NULL;
 		}
 	}
 
 	Folders.Length(0);
 	d->FoldersLoaded = false;
 
 	if (ScribeState == ScribeExiting)
 		LCloseApp();
 	ScribeState = PrevState;
 
 	return true;
 }
 
 void ScribeWnd::BuildDynMenus()
 {
 	if (MailMenu)
 	{
 		LString SendMail = LLoadString(IDS_SEND_MAIL);
 		LString ReceiveMail = LLoadString(IDS_RECEIVE_MAIL);
 		LString PreviewMail = LLoadString(IDS_PREVIEW_ON_SERVER);
 		auto ReceiveAll = LLoadString(IDS_RECEIVE_ALL_ACCOUNTS);
 
 		if (!CmdReceive.MenuItem && ReceiveAll)
 			CmdReceive.MenuItem = MailMenu->AppendItem(ReceiveAll, IDM_RECEIVE_ALL, true);
 
 		if (!SendMenu && SendMail)
 		{
 			auto s = SendMail.SplitDelimit("\t");
 			SendMenu = MailMenu->AppendSub(s[0]);
 		}
 
 		if (!ReceiveMenu && ReceiveMail)
 		{
 			auto s = ReceiveMail.SplitDelimit("\t");
 			ReceiveMenu = MailMenu->AppendSub(s[0]);
 		}
 
 		if (!PreviewMenu && PreviewMail)
 		{
 			auto s = PreviewMail.SplitDelimit("\t");
 			PreviewMenu = MailMenu->AppendSub(s[0]);
 		}
 	}
 
 	if (!NewTemplateMenu)
 	{
 		auto i = Menu->FindItem(IDM_NO_TEMPLATES);
 		if (i)
 		{
 			NewTemplateMenu = i->GetParent();
 		}
 	}
 	if (NewTemplateMenu)
 	{
 		NewTemplateMenu->Empty();
 
 		int d = 0;
 		ScribeFolder *Templates = GetFolder(FOLDER_TEMPLATES, NULL, true);
 		if (Templates)
 		{
 			Templates->LoadThings();
 
 			for (auto i: Templates->Items)
 			{
 				Mail *m = i->IsMail();
 				if (m)
 				{
 					NewTemplateMenu->AppendItem(m->GetSubject()
 													?
 													m->GetSubject()
 													:
 													(char*)"(no subject)",
 												IDM_NEW_FROM_TEMPLATE + d,
 												true);
 					d++;
 				}
 			}
 
 			if (d == 0)
 			{
 				NewTemplateMenu->AppendItem(LLoadString(IDS_NO_ITEMS_IN_FOLDER), -1, false);
 			}
 		}
 		else
 		{
 			NewTemplateMenu->AppendItem(LLoadString(IDS_NO_TEMPLATES), -1, false);
 		}
 	}
 }
 
 int ScribeWnd::GetToolbarHeight()
 {
 	return (Commands) ? MAX(Commands->Y()-1, 20) : 20;
 }
 
 LToolBar *ScribeWnd::LoadToolbar(LViewI *Parent, const char *File, LAutoPtr<LImageList> &Img)
 {
 	if (!Img)
 		Img.Reset(LLoadImageList(File));
 	if (!Img)
 	{
 		LAssert(!"Missing image resource.");
 		return NULL;
 	}
 
 	LToolBar *Tools = NULL;
 	if (Img)
 	{
 		Tools = new LToolBar;
 		if (Tools)
 			Tools->SetImageList(Img, Img->TileX(), Img->TileY(), false);
 	}
 	else
 	{
 		Tools = LgiLoadToolbar(Parent, File);
 	}
 
 	if (Tools)
 	{
 		LVariant SizeAdj;
 		LFont *f = Tools->GetFont();
 		if (f)
 		{
 			if (GetOptions()->GetValue(OPT_UiFontSize, SizeAdj))
 			{
 				SizeAdj.Cast(GV_INT32);
 				SizeAdj.Value.Int -= 2;
 				f->PointSize(f->PointSize()+SizeAdj.Value.Int);
 			}
 		}
 
 		Tools->GetCss(true)->BorderSpacing(LCss::Len(LCss::LenPx, SCRIBE_TOOLBAR_BORDER_SPACING_PX));
 		Tools->TextLabels(ShowToolbarText());
 	}
 
 	return Tools;
 }
 
 void ScribeWnd::SetListPane(LView *v)
 {
 	ThingList *ThingLst = dynamic_cast<ThingList*>(v);
 	DynamicHtml *Html = dynamic_cast<DynamicHtml*>(v);
 	if (!ThingLst)
 	{
 		DeleteObj(SearchView);
 		if (MailList)
 			MailList->RemoveAll();
 	}
 
 	v->Sunken(SUNKEN_CTRL);
 	if ((MailList = ThingLst))
 	{
 		DeleteObj(TitlePage);
 		if (GetCtrlValue(IDM_ITEM_FILTER))
 		{
 			OnCommand(IDM_ITEM_FILTER, 0, NULL);
 		}
 	}
 	else
 	{
 		TitlePage = Html;
 	}
 	
 	SetLayout();
 }
 
 bool ScribeWnd::SetItemPreview(LView *v)
 {
 	v->Sunken(SUNKEN_CTRL);
 	if (d->SubSplit->IsAttached())
 	{
 		if (d->LastLayout == 2)
 		{
 			Splitter->SetViewAt(1, v);
 		}
 		else
 		{
 			d->SubSplit->SetViewAt(1, v);
 		}
 
 		return true;
 	}
 
 	return false;
 }
 
 ScribeWnd::LayoutMode ScribeWnd::GetEffectiveLayoutMode()
 {
 	LVariant Mode;
 	GetOptions()->GetValue(OPT_LayoutMode, Mode);
 	ScribeFolder *Cur = GetCurrentFolder();
 	
 	if (Cur && Cur->IsRoot())
 	{
 		Mode = FoldersAndList;
 	}
 
 	if (Mode.CastInt32() == 0)
 	{
 		Mode = FoldersListAndPreview;
 	}	
 	
 	return (LayoutMode) Mode.CastInt32();
 }
 
 void ScribeWnd::SetLayout(LayoutMode Mode)
 {
 	// int TreeWidth = Tree ? Tree->X() : 200;
 	// int PreviewHt = PreviewPanel ? PreviewPanel->Y() : 200;
 
 	if (Mode > 0)
 	{
 		LVariant v;
 		GetOptions()->SetValue(OPT_LayoutMode, v = (int)Mode);
 	}
 
 	Mode = GetEffectiveLayoutMode();
 
 	if (!Splitter)
 		return;
 
 	bool JustPreviewPane =	(Mode == FoldersAndList && d->LastLayout == FoldersListAndPreview) ||
 							(Mode == FoldersListAndPreview && d->LastLayout == FoldersAndList);
 
 	LView *Content = NULL;
 	if (TitlePage)
 		Content = TitlePage;
 	else if (MailList)
 		Content = MailList;
 
 	if (JustPreviewPane)
 	{
 		// Optimized path for hide/show the preview pane that doesn't destroy the tree
 		// control and cause it to lose focus... otherwise we can't set it's focus due
 		// to some weird windows interaction.
 		switch (Mode)
 		{
 			default:
 			case FoldersListAndPreview:
 			{
 				if (Content)
 					Content->Sunken(SUNKEN_CTRL);
 				if (PreviewPanel)
 					PreviewPanel->Sunken(SUNKEN_CTRL);
 
 				Splitter->SetViewAt(1, d->SubSplit);
 				d->SubSplit->SetVertical(true);
 				
 				int Idx = 0;
 				if (SearchView)
 					d->SubSplit->SetViewAt(Idx++, SearchView);				
 				d->SubSplit->SetViewAt(Idx++, Content);
 				d->SubSplit->SetViewAt(Idx++, PreviewPanel);
 				break;
 			}
 			case FoldersAndList:
 			{
 				if (Content)
 					Content->Sunken(SUNKEN_CTRL);
 				
 				if (SearchView)
 				{
 					#if LGI_VIEW_HANDLE
 					if (!d->SubSplit->Handle())
 						Splitter->SetViewAt(1, d->SubSplit);
 					#endif
 					d->SubSplit->SetVertical(true);
 					Splitter->SetViewAt(1, d->SubSplit);
 
 					int Idx = 0;
 					if (SearchView)
 						d->SubSplit->SetViewAt(Idx++, SearchView);				
 					d->SubSplit->SetViewAt(Idx++, Content);
 				}
 				else
 				{
 					d->SubSplit->Detach();
 					Splitter->SetViewAt(1, Content);
 				}
 				break;
 			}
 		}
 	}
 	else
 	{		
 		if (Tree)
 			Tree->Sunken(SUNKEN_CTRL);
 		if (Content)
 			Content->Sunken(SUNKEN_CTRL);
 		if (PreviewPanel)
 			PreviewPanel->Sunken(SUNKEN_CTRL);
 		switch (Mode)
 		{
 			default:
 			case FoldersListAndPreview:
 			{
 				Splitter->SetVertical(false);
 				d->SubSplit->SetVertical(true);
 				Splitter->SetViewAt(0, Tree);
 				Splitter->SetViewAt(1, d->SubSplit);
 
 				int Idx = 0;
 				if (SearchView)
 					d->SubSplit->SetViewAt(Idx++, SearchView);
 				d->SubSplit->SetViewAt(Idx++, Content);
 				d->SubSplit->SetViewAt(Idx++, PreviewPanel);
 
 				DeleteObj(d->SearchSplit);
 				break;
 			}
 			case PreviewOnBottom:
 			{
 				Splitter->SetVertical(true);
 				d->SubSplit->SetVertical(false);
 				Splitter->SetViewAt(0, d->SubSplit);
 				Splitter->SetViewAt(1, PreviewPanel);
 
 				d->SubSplit->SetViewAt(0, Tree);
 				if (SearchView)
 				{
 					if (!d->SearchSplit)
 						d->SearchSplit = new LBox;
 					d->SubSplit->SetViewAt(1, d->SearchSplit);
 					d->SearchSplit->SetVertical(true);
 					d->SearchSplit->SetViewAt(0, SearchView);
 					d->SearchSplit->SetViewAt(1, Content);
 				}
 				else
 				{
 					d->SubSplit->SetViewAt(1, Content);
 					DeleteObj(d->SearchSplit);
 				}
 				break;
 			}
 			case FoldersAndList:
 			{
 				Splitter->SetVertical(false);
 				Splitter->SetViewAt(0, Tree);
 				
 				if (SearchView)
 				{
 					d->SubSplit->SetVertical(true);
 					Splitter->SetViewAt(1, d->SubSplit);
 					d->SubSplit->SetViewAt(0, SearchView);
 					d->SubSplit->SetViewAt(1, Content);
 				}
 				else
 				{
 					d->SubSplit->Detach();
 					Splitter->SetViewAt(1, Content);
 				}
 				DeleteObj(d->SearchSplit);
 				break;
 			}
 			case ThreeColumn:
 			{
 				Splitter->SetVertical(false);
 				Splitter->SetViewAt(0, Tree);
 				
 				if (SearchView)
 				{
 					d->SubSplit->SetVertical(true);
 					Splitter->SetViewAt(1, d->SubSplit);
 					d->SubSplit->SetViewAt(0, SearchView);
 					d->SubSplit->SetViewAt(1, Content);
 				}
 				else
 				{
 					d->SubSplit->Detach();
 					Splitter->SetViewAt(1, Content);
 				}
 				
 				Splitter->SetViewAt(2, PreviewPanel);
 				DeleteObj(d->SearchSplit);
 				break;
 			}
 		}
 	}
 
 	if (!SearchView)
 	{
 		LVariant Pos = 200;
 		GetOptions()->GetValue(OPT_SplitterPos, Pos);
 		if (Pos.CastInt32() < 10)
 			Pos = 200;
 		Splitter->Value(Pos.CastInt32());
 
 		LRect r = Splitter->GetPos();
 		r.x2++;
 		Splitter->SetPos(r);
 
 		if (d->SubSplit->IsAttached())
 		{
 			Pos = 200;
 			GetOptions()->GetValue(OPT_SubSplitPos, Pos);
 			if (Pos.CastInt32() < 10)
 				Pos = 200;
 			d->SubSplit->Value(Pos.CastInt32());
 		}
 	}
 	
 	PourAll();
 	#ifdef LINUX
 	LYield();
 	#endif
 
 	d->LastLayout = Mode;
 }
 
 void ScribeWnd::SetupUi()
 {
 	// Show the window
 	if (!SerializeState(GetOptions(), OPT_ScribeWndPos, true))
 	{
 		LRect r(0, 0, 1023, 767);
 		SetPos(r);
 		MoveToCenter();
 	}
 
 	Visible(true);
 
 	// Main toolbar
 	Commands = LoadToolbar(this, GetResourceFile(ResToolbarFile), ToolbarImgs);
 	if (Commands)
 	{
 		Commands->Attach(this);
 		#ifdef MAC
 		Commands->Raised(false);
 		#else
 		Commands->Raised(RAISED_LOOK);
 		#endif
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_NEW_EMAIL)), IDM_NEW_EMAIL, TBT_PUSH, true, IMG_NEW_MAIL);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_NEW_CONTACT)), IDM_NEW_CONTACT, TBT_PUSH, true, IMG_NEW_CONTACT);
 		Commands->AppendSeparator();
 
 		CmdSend.ToolButton = Commands->AppendButton(RemoveAmp(LLoadString(IDS_SEND)), IDM_SEND_MAIL, TBT_PUSH, true, IMG_SEND);
 		Commands->AppendButton("+", IDM_RECEIVE_AND_SEND, TBT_PUSH, true, -2);
 		CmdReceive.ToolButton = Commands->AppendButton(RemoveAmp(LLoadString(IDS_RECEIVE)), IDM_RECEIVE_MAIL, TBT_PUSH, true, IMG_RECEIVE);
 		CmdPreview.ToolButton = Commands->AppendButton(RemoveAmp(LLoadString(IDS_PREVIEW)), IDM_PREVIEW_POP3, TBT_PUSH, true, IMG_PREVIEW);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_DELETE)), IDM_DELETE, TBT_PUSH, true, IMG_TRASH);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_SPAM)), IDM_DELETE_AS_SPAM, TBT_PUSH, true, IMG_DELETE_SPAM);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_REPLY)), IDM_REPLY, TBT_PUSH, true, IMG_REPLY);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_REPLYALL)), IDM_REPLY_ALL, TBT_PUSH, true, IMG_REPLY_ALL);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_FORWARD)), IDM_FORWARD, TBT_PUSH, true, IMG_FORWARD);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_BOUNCE)), IDM_BOUNCE, TBT_PUSH, true, IMG_BOUNCE);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_PRINT)), IDM_PRINT, TBT_PUSH, true, IMG_PRINT);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_CALENDAR)), IDM_CALENDAR, TBT_PUSH, true, IMG_CALENDAR);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_ITEM_FILTER)), IDM_ITEM_FILTER, TBT_TOGGLE, true, IMG_SEARCH);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_THREAD)), IDM_THREAD, TBT_TOGGLE, true, IMG_THREADS);
 		d->ShowConsoleBtn = Commands->AppendButton(RemoveAmp(LLoadString(IDS_SHOW_CONSOLE)), IDM_SHOW_CONSOLE, TBT_PUSH, true, IMG_CONSOLE_NOMSG);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_HELP)), IDM_HELP, TBT_PUSH, true, IMG_HELP);
 
 		Commands->Customizable(GetOptions(), OPT_ScribeWndToolbar);
 		if (d->ScriptToolbar.Reset(new LScriptUi(Commands)))
 			d->ScriptToolbar->SetupCallbacks(this, 0, 0, LApplicationToolbar);
 		PourAll();
 	}
 
 	CmdSend.Enabled(false);
 	CmdReceive.Enabled(false);
 
 	// Preview and status windows
 	PreviewPanel = new LPreviewPanel(this);
 	StatusPanel = new AccountStatusPanel(this, ImageList);
 	if (PreviewPanel &&
 		StatusPanel)
 	{
 		#ifdef MAC
 		StatusPanel->Raised(false);
 		#else
 		StatusPanel->Raised(RAISED_LOOK);
 		#endif
 		StatusPanel->Attach(this);
 
 		PourAll();
 	}
 
 	// Splitter window, for folders and item list
 	Tree = new MailTree(this);
 	if (ImageList)
 	{
 		Tree->AskImage(true);
 		Tree->SetImageList(ImageList, false);
 	}
 
 	d->SubSplit = new LBox;
 	
 	Splitter = new LBox;
 	if (Splitter)
 	{
 		Splitter->Attach(this);
 		#ifdef MAC
 		Splitter->Raised(false);
 		#else
 		Splitter->Raised(RAISED_LOOK);
 		#endif
 
 		SetLayout();
 	}
 
 
 	#if WINNATIVE
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_SMALL));
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_ERR));
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_MAIL));
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_BLANK));
 	#else
 	TrayIcon.Load(_T("tray_small.png"));
 	TrayIcon.Load(_T("tray_error.png"));
 	TrayIcon.Load(_T("tray_mail.png"));
 	#endif
 	
 	LStringPipe s(256);
 	LVariant UserName;
 	
 	s.Print("%s", AppName);
 	if (GetOptions()->GetValue(OPT_UserName, UserName))
 	{
 		s.Print(" [%s]", UserName.Str());
 	}
 	auto AppTitle = s.NewLStr();
 	TrayIcon.Name(AppTitle);
 	Name(AppTitle);
 
 	TrayIcon.Value(TRAY_ICON_NORMAL);
 	TrayIcon.Visible(true);
 
 	auto Item = Menu->FindItem(IDM_SCRIPTING_CONSOLE);
 	if (Item)
 	{
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_ShowScriptConsole, v))
 		{
 			Item->Checked(v.CastInt32() != 0);
 			LScribeScript::Inst->ShowScriptingWindow(Item->Checked());
 		}
 	}
 
 	if (Tree)
 	{
 		Tree->Focus(true);
 	}
 }
 
 Thing *ScribeWnd::CreateItem(int Type, ScribeFolder *Folder, bool Ui)
 {
 	auto FolderStore = Folder && Folder->GetObject() ? Folder->GetObject()->GetStore() : NULL;
 	auto DefaultStore = GetDefaultMailStore();
 	auto Store = FolderStore ? FolderStore : (DefaultStore ? DefaultStore->Store : NULL);
 	if (!Store)
 	{
 		LAssert(!"no store");
 		LgiTrace("%s:%i - No store for creating calendar object.\n", _FL);
 		return NULL;
 	}
 
 	auto Obj = Store->Create(Type);
 	if (!Obj)
 	{
 		LAssert(!"create failed");
 		LgiTrace("%s:%i - store failed to create object.\n", _FL);
 		return NULL;
 	}
 
 	#define HANDLE_CREATE_ITEM(Magic, Type)					\
 		case Magic:											\
 		{													\
 			auto o = new Type(this, Obj);					\
 			if (!o)											\
 			{												\
 				LgiTrace("%s:%i - Alloc failed.\n", _FL);	\
 				break;										\
 			}												\
 			if (Folder) o->SetParentFolder(Folder);			\
 			if (Ui) o->DoUI();								\
 			return o;										\
 		}
 
 
 	switch ((uint32_t)Type)
 	{
 		case MAGIC_MAIL:
 		{
 			// create a new mail message
 			Mail *m = new Mail(this, Obj);
 			if (!m)
 			{
 				LgiTrace("%s:%i - Alloc failed.\n", _FL);
 				break;
 			}
 
 			if (!m->GetObject())
 			{
 				m->DecRef();
 				return 0;
 			}
 
 			m->OnCreate();
 
 			if (Folder)
 				m->SetParentFolder(Folder);
 
 			if (Ui)
 				m->DoUI();
 
 			return m;
 		}
 		HANDLE_CREATE_ITEM(MAGIC_CONTACT, Contact)
 		HANDLE_CREATE_ITEM(MAGIC_CALENDAR, Calendar)
 		HANDLE_CREATE_ITEM(MAGIC_FILTER, Filter)
 		HANDLE_CREATE_ITEM(MAGIC_GROUP, ContactGroup)
 		default:
 			LAssert(!"Unhandled object type.");
 			break;
 	}
 
 	return NULL;
 }
 
 void ScribeWnd::OnPaint(LSurface *pDC)
 {
 	#if 0
 	pDC->Colour(LColour::Red);
 	pDC->Rectangle();
 	#else
 	LCssTools Tools(this);
 	auto c = GetClient();
 	// c.Offset(0, -26);
 	Tools.PaintContent(pDC, c);
 	#endif
 }
 
 int CompareContacts(Contact **a, Contact **b)
 {
 	if (a && b)
 	{
 		auto A = (*a)->GetFirst();
 		auto B = (*b)->GetFirst();
 		if (A && B)
 			return _stricmp(A, B);
 	}
 
 	return 0;
 }
 
 bool ScribeWnd::OpenAMail(ScribeFolder *Folder)
 {
 	if (Folder &&
 		Tree)
 	{
 		Folder->LoadThings();
 
 		for (auto i: Folder->Items)
 		{
 			Mail *m = i->IsMail();
 			if (m && !(m->GetFlags() & MAIL_READ))
 			{
 				Tree->Select(Folder);
 				m->DoUI();
 				return true;
 			}
 		}
 
 		for (auto *t=Folder->GetChild(); t; t=t->GetNext())
 		{
 			ScribeFolder *f = dynamic_cast<ScribeFolder*>(t);
 			if (OpenAMail(f))
 			{
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 void AddContactToMenu(LSubMenu *Menu, Contact *c, ssize_t Index)
 {
 	if (!c || Index < 0)
 		return;
 
 	auto Email = c->GetEmail();
 	if (!Email)
 		return;
 
 	// has an email, list it
 	auto First = c->GetFirst();
 	auto Last = c->GetLast();
 	if (First || Last)
 	{
 		char Buf[256];
 		sprintf_s(Buf, sizeof(Buf), "%s %s", (First)?First:"", (Last)?Last:"");
 		auto Item = Menu->AppendItem(Buf, TRAY_CONTACT_BASE + (int)Index, true);
 		if (Item) Item->Icon(ICON_CONTACT);
 	}
 }
 
 void ScribeWnd::AddContactsToMenu(LSubMenu *Menu)
 {
 	if (!Menu)
 		return;
 
 	d->TrayMenuContacts.Sort(CompareContacts);
 	if (((ssize_t)d->TrayMenuContacts.Length() << 4) > GdcD->Y() - 200)
 	{
 		// Group contacts by starting letter
 		LArray<Contact*> Alpha[26];
 		LArray<Contact*> Other;
 		for (auto c: d->TrayMenuContacts)
 		{
 			auto First = c->GetFirst();
 			auto Last = c->GetLast();
 			auto Email = c->GetEmail();
 			if (Email)
 			{
 				// has an email, list it
 				if (First || Last)
 				{
 					auto Name = First?First:Last;
 					if
 					(
 						(*Name >= 'a' && *Name <= 'z')
 						||
 						(*Name >= 'A' && *Name <= 'Z')
 					)
 					{
 						int Ind = tolower(*Name) - 'a';
 						if (Ind >= 0 && Ind < CountOf(Alpha))
 							Alpha[Ind].Add(c);
 						else
 							Other.Add(c);
 					}
 					else
 						Other.Add(c);
 				}
 			}
 		}
 
 		for (int i=0; i<CountOf(Alpha); i++)
 		{
 			if (Alpha[i].Length() > 0)
 			{
 				char Group[64];
 				sprintf_s(Group, sizeof(Group), "%c...", 'a' + i);
 				auto Sub = Menu->AppendSub(Group);
 				if (Sub)
 				{
 					for (auto c: Alpha[i])
 						AddContactToMenu(Sub, c, d->TrayMenuContacts.IndexOf(c));
 				}
 			}
 		}
 
 		if (Other.Length())
 		{
 			auto Sub = Menu->AppendSub("Other...");
 			if (Sub)
 			{
 				for (auto c: Other)
 					AddContactToMenu(Sub, c, d->TrayMenuContacts.IndexOf(c));
 			}
 		}
 	}
 	else
 	{
 		// Display all...
 		for (size_t i=0; i<d->TrayMenuContacts.Length(); i++)
 		{
 			AddContactToMenu(Menu, d->TrayMenuContacts[i], i);
 		}
 	}
 }
 
 void ScribeWnd::OnUrl(const char *Url)
 {
 	LUri u(Url);
 	if (u.sProtocol && !_stricmp(u.sProtocol, "mailto"))
 	{
 		CreateMail(0, Url, 0);
 	}
 }
 
 void ScribeWnd::OnReceiveFiles(LArray<const char*> &Files)
 {
 	int UnknownFormats = 0;
 	int64 Period = LCurrentTime() - LastDrop;
 
 	if (Period > 500) // Lock out drops within 500ms of an LGI drop
 	{
 		LString sSend, sPages;
 		bool HasSend = LAppInst->GetOption("send", sSend);
 		bool HasPrint = LAppInst->GetOption("p", sPages);
 		LArray<Mail*> NewMail;
 
 		for (unsigned i=0; i<Files.Length(); i++)
 		{
 			auto f = Files[i];
 			LString MimeType = ScribeGetFileMimeType(f);
 
 			if (MimeType)
 			{
 				Thing *t = NULL;
 				
 				if (!_stricmp(MimeType, sMimeVCard))
 				{
 					t = CreateItem(MAGIC_CONTACT, NULL, false);
 				}
 				else if (!_stricmp(MimeType, sMimeVCalendar))
 				{
 					t = CreateItem(MAGIC_CALENDAR, NULL, false);
 				}
 				else if (!_stricmp(MimeType, sMimeMessage))
 				{
 					t = CreateItem(MAGIC_MAIL, NULL, false);
 				}
 				else if (!_stricmp(MimeType, sMimeMbox))
 				{
 					// What should I do here?
 				}
 				else UnknownFormats++;
 
 				if (t)
 				{
 					LAutoPtr<LFile> str(new LFile);
 					if (str->Open(f, O_READ))
 					{
 						if (t->Import(t->AutoCast(str), MimeType))
 						{
 							if (HasSend)
 							{
 								Mail *m = t->IsMail();
 								if (m)
 								{
 									NewMail.Add(m);
 									m->SetFlags(m->GetFlags() | MAIL_CREATED | MAIL_READ);
 								}
 							}
 							else
 							{
 								t->DoUI();
 							}
 						}
 					}
 				}
 			}
 			else UnknownFormats++;
 		}
 
 		bool SendNow = sSend ? atoi(sSend) != 0 : false;
 		for (unsigned i=0; i<NewMail.Length(); i++)
 		{
 			Mail *m = NewMail[i];
 			if (SendNow)
 			{
 				m->SetFlags(m->GetFlags() | MAIL_READY_TO_SEND);
 				m->Save();
 			}
 			else if (HasPrint)
 			{
 				ThingPrint(NULL, m, GetPrinter(), 0, sPages ? atoi(sPages) : 0);
 			}
 			else
 			{
 				m->DoUI();
 			}
 		}
 		if (SendNow)
 			Send();
 	}
 }
 
 void ScribeWnd::OnTrayClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		#ifndef MAC
 		// No support for different mouse button info so the default
 		// action is to show the sub-menu of contacts and actions.
 		if (m.IsContextMenu())
 		#endif
 		{
 			LWindow::OnTrayClick(m);
 		}
 		#ifndef MAC
 		else if (m.Left())
 		{
 			if (m.Double())
 			{
 				if (Mail::NewMailLst.Length() > 0)
 				{
 					ScribeFolder *InBox = GetFolder(FOLDER_INBOX);
 					OpenAMail(InBox);
 				}
 			}
 			else
 			{
 				if (GetZoom() == LZoomMin)
 				{
 					SetZoom(LZoomNormal);
 				}
 				else
 				{
 					if (Obscured())
 						SetZoom(LZoomNormal);  // Bounce in front, first.
 					else
 						SetZoom(LZoomMin);
 				}
 				Visible(true);
 
 				MoveOnScreen();
 				Raise();
 
 				if (MailList)
 				{
 					MailList->Focus(true);
 				}
 			}
 		}
 		else if (m.Middle())
 		{
 			Mail::NewMailLst.Empty();
 		}
 		#endif
 	}
 }
 
 void ScribeWnd::OnTrayMenu(LSubMenu &m)
 {
 	m.SetImageList(ImageList, false);
 	d->TrayMenuContacts.Length(0);
 
 	#ifdef MAC
 	m.AppendItem(LLoadString(IDS_OPEN), IDM_OPEN);
 	m.AppendSeparator();
 	#endif
 
 	LHashTbl<ConstStrKey<char,false>,Contact*> Added;
 	LArray<ScribeFolder*> Srcs = GetThingSources(MAGIC_CONTACT);
 	for (auto c: Srcs)
 	{
 		c->LoadThings();
 		for (auto i: c->Items)
 		{
 			Contact *c = i->IsContact();
 			if (!c) continue;
 
 			bool IsAdded = false;
 			auto Emails = c->GetEmails();
 			for (auto e: Emails)
 			{
 				if (Added.Find(e))
 					IsAdded = true;
 			}
 
 			if (Emails.Length() && !IsAdded)
 			{
 				for (auto e: Emails)
 					Added.Add(e, c);
 				d->TrayMenuContacts.Add(c);
 			}
 		}
 	}
 	AddContactsToMenu(&m);
 
 	m.AppendSeparator();
 
 	if (Mail::NewMailLst.Length() > 0)
 	{
 		int i=0;
 		for (auto ml: Mail::NewMailLst)
 		{
 			LStringPipe p;
 			
 			// This code figures out how many UTF characters to print. We
 			// can't split a UTF character because downstream conversions
 			// will fail.
 			const char *Subj = ml->GetSubject();
 			if (!Subj)
 				Subj = "(No Subject)";
 			LUtf8Ptr u((uint8_t*)Subj);
 			while ((int32)u && u.GetPtr() - (uchar*)Subj < 64)
 				u++;
 			ssize_t Bytes = u.GetPtr() - (uchar*)Subj;
 			
 			p.Print("%.*s, %s <%s>",
 					Bytes,
 					Subj?Subj:(char*)"(No Subject)",
 					ml->GetFromStr(FIELD_NAME),
 					ml->GetFromStr(FIELD_EMAIL));
 			LAutoString a(p.NewStr());
 			
 			LAssert(LIsUtf8(a));
 			
 			auto Item = m.AppendItem(a, TRAY_MAIL_BASE+i++, true);
 			if (Item)
 			{
 				Item->Icon(ICON_UNREAD_MAIL);
 			}
 		}
 		m.AppendSeparator();
 	}
 
 	if (GetZoom() == LZoomMin)
 	{
 		m.AppendItem(LLoadString(IDS_OPEN), IDM_OPEN, true);
 	}
 
 	auto NewMail = m.AppendItem(LLoadString(IDS_NEW_EMAIL), IDM_NEW_EMAIL);
 	if (NewMail) NewMail->Icon(ICON_UNSENT_MAIL);
 	m.AppendItem(LLoadString(IDS_EXIT), IDM_EXIT);
 }
 
 void ScribeWnd::OnTrayMenuResult(int MenuId)
 {
 	switch (MenuId)
 	{
 		case IDM_OPEN:
 		{
 			if (GetZoom() == LZoomMin)
 			{
 				SetZoom(LZoomNormal);
 			}
 
 			Visible(true);
 			Raise();
 			
 			if (MailList)
 			{
 				MailList->Focus(true);
 			}
 			break;
 		}
 		case IDM_NEW_EMAIL:
 		{
 			CreateMail();
 			break;
 		}
 		case IDM_EXIT:
 		{
 			d->IngoreOnClose = true;
 			PostEvent(M_CLOSE);
 			break;
 		}
 		default:
 		{
 			auto i = MenuId - TRAY_CONTACT_BASE;
 			Contact *c = d->TrayMenuContacts.IdxCheck(i) ? d->TrayMenuContacts[i] : NULL;
 			if (c)
 			{
 				CreateMail(c);
 			}
 
 			Mail *m = Mail::NewMailLst[MenuId - TRAY_MAIL_BASE];
 			if (m)
 			{
 				Mail::NewMailLst.Delete(m);
 				m->DoUI();
 			}
 			break;
 		}
 	}
 }
 
 void ScribeWnd::OnZoom(LWindowZoom Action)
 {
 	if (Action == LZoomMin)
 	{
 		LVariant i;
 		if (GetOptions()->GetValue(OPT_MinimizeToTray, i) && i.CastInt32())
 		{
 			Visible(false);
 		}
 	}
 }
 
 struct UserInput
 {
 	std::function<void(LString)> Callback;
 	LView *Parent;
 	LString Msg;
 	bool Password;
 
 	UserInput()
 	{
 		Password = false;
 	}
 };
 
 void ScribeWnd::GetUserInput(LView *Parent, LString Msg, bool Password, std::function<void(LString)> Callback)
 {
 	if (InThread())
 	{
 		auto Inp = new LInput(Parent ? Parent : this, "", Msg, AppName, Password);
 		Inp->DoModal([this, Inp, Callback](auto dlg, auto id)
 		{
 			if (Callback)
 				Callback(id ? Inp->GetStr() : LString());
 			delete dlg;
 		});
 	}
 
 	auto i = new UserInput;
 	i->Parent = Parent;
 	i->Msg = Msg;
 	i->Password = Password;
 	i->Callback = Callback;
 	if (!PostEvent(M_GET_USER_INPUT, (LMessage::Param)i))
 	{
 		LAssert(!"PostEvent failed.");
 		if (Callback)
 			Callback(LString());
 	}
 }
 
 LMessage::Result ScribeWnd::OnEvent(LMessage *Msg)
 {
 	TrayIcon.OnEvent(Msg);
 	BayesianFilter::OnEvent(Msg);
 	
 	switch (Msg->Msg())
 	{
 		case M_UNIT_TEST:
 		{
 			LAutoPtr<LJson> j((LJson*)Msg->A());
 			if (!j) break;
 
 			auto cmd = j->Get("cmd");
 			if (!cmd) break;
 
 			if (cmd.Equals("somecmd"))
 			{
 				
 			}
 			break;
 		}
 		case M_CALENDAR_SOURCE_EVENT:
 		{
 			CalendarSource *cs = (CalendarSource*)Msg->A();
 			LAutoPtr<LMessage> m((LMessage*)Msg->B());
 			if (cs && m)
 				cs->OnEvent(m);
 			break;
 		}
 		case M_GET_USER_INPUT:
 		{
 			LAutoPtr<UserInput> i((UserInput*)Msg->A());
 			LAssert(i);
 			LAssert(InThread()); // Least we get stuck in an infinite loop
 			
 			GetUserInput(i->Parent, i->Msg, i->Password, i->Callback);
 			break;
 		}
 		case M_SET_HTML:
 		{
 			LAutoPtr<LString> Html((LString*)Msg->A());
 			if (PreviewPanel && Html)
 			{
 				LVariant Ret;
 				LArray<LVariant*> Arg;
 				Arg.Add(new LVariant(Html->Get()));
 				PreviewPanel->CallMethod(DomToStr(SdSetHtml), &Ret, Arg);
 				Arg.DeleteObjects();
 			}
 			break;
 		}
 		case M_NEW_CONSOLE_MSG:
 		{
 			if (d->ShowConsoleBtn)
 				d->ShowConsoleBtn->Image(IDM_CONSOLE_MSGS);
 			break;
 		}
 		case M_NEEDS_CAP:
 		{
 			LAutoString c((char*)Msg->A());
 			LAutoString param((char*)Msg->B());
 			NeedsCapability(c, param);
 			return 0;
 			break;
 		}
 		case M_STORAGE_EVENT:
 		{
 			LDataStoreI *Store = LDataStoreI::Map.Find((int)Msg->A());
 			if (Store)
 				Store->OnEvent((void*)Msg->B());
 			break;
 		}
 		case M_SCRIBE_SET_MSG_FLAG:
 		{
 			LAutoString p((char*)Msg->A());
 			if (p)
 			{
 				char *d = strrchr(p, '/');
 				if (d)
 				{
 					*d++ = 0;
 					ScribeFolder *f = GetFolder(p);
 					if (f)
 					{
 						LUri u;
 						LString a = u.DecodeStr(d);
 						f->GetMessageById(a, [this, NewFlag=(int)Msg->B()](auto r)
 						{
 							if (r)
 							{
 								int ExistingFlags = r->GetFlags();
 								r->SetFlags(ExistingFlags | NewFlag);
 							}
 						});
 					}
 				}
 			}
 			break;
 		}
 		case M_SCRIBE_DEL_THING:
 		{
 			Thing *t = (Thing*)Msg->A();
 			DeleteObj(t);
 			break;
 		}
 		case M_SCRIBE_LOADED:
 		{
 			if (d->FoldersLoaded)
 			{
 				// Ok let the user in
 				CmdSend.Enabled(true);
 				CmdReceive.Enabled(true);
 				CmdPreview.Enabled(true);
 			}
 			break;
 		}
 		case M_SCRIBE_THREAD_DONE:
 		{
 			// Finialize connection
 			AccountThread *Thread = (AccountThread*) Msg->A();
 			Accountlet *Acc = (Accountlet*) Msg->B();
 			if (Thread && Acc)
 			{
 				OnAfterConnect(Acc->GetAccount(), Acc->IsReceive());
 
 				d->NewMailTimeout = 2;
 				Acc->OnThreadDone();
 			}
 			else
 			{
 				LAssert(0);
 			}
 			break;
 		}
 		case M_SCRIBE_MSG:
 		{
 			char *m = (char*)Msg->A();
 			if (m)
 			{
 				if (Msg->B())
 				{
 					if (LgiMsg(this, m, AppName, MB_YESNO) == IDYES)
 					{
 						PostEvent(M_COMMAND, IDM_OPTIONS, 0);						
 					}
 				}
 				else
 				{
 					LgiMsg(this, "%s", AppName, MB_OK, m);
 				}
 
 				DeleteArray(m);
 			}
 			break;
 		}
 		/*
 		case M_SCRIBE_LOG_MSG:
 		{
 			List<LogEntry> *Log = (List<LogEntry>*)Msg->A();
 			LAutoPtr<LogEntry> Entry((LogEntry*)Msg->B());
 
 			if (ScribeState != ScribeExiting &&
 				Log &&
 				Entry)
 			{
 				Log->Insert(Entry.Release());
 
 				// Trim long list...
 				while (Log->Length() > 1024)
 				{
 					LogEntry *e = Log->First();
 					Log->Delete(e);
 					DeleteObj(e);
 				}
 			}
 			break;
 		}
 		*/
 		case M_SCRIBE_NEW_MAIL:
 		{
 			if (Lock(_FL))
 			{
 				if (NewMailDlg)
 				{
 					NewMailDlg->AddThings(&Mail::NewMailLst);
 				}
 				Unlock();
 			}
 			break;
 		}
 		case M_SCRIBE_OPEN_THING:
 		{
 			Thing *t = (Thing*) Msg->A();
 			if (t)
 			{
 				t->DoUI();
 			}
 			break;
 		}
 		case M_SCRIBE_ITEM_SELECT:
 		{
 			if (!MailList || !IsAttached())
 				break;
 
 			List<Thing> Things;
 			MailList->GetSelection(Things);
 			OnSelect(&Things);
 			break;
 		}
 		case M_URL:
 		{
 			LAutoPtr<LString> Url((LString*)Msg->A());
 			if (Url)
 			{
 				LUri u(*Url);
 				if (u.sProtocol && !_stricmp(u.sProtocol, "mailto"))
 				{
 					Mailto mt(this, *Url);
 					if (mt.To.Length() > 0)
 					{
 						Thing *t = CreateItem(MAGIC_MAIL, NULL, false);
 						if (t)
 						{
 							Mail *m = t->IsMail();
 							if (m)
 							{
 								mt.Apply(m);
 								m->DoUI();
 							}
 							else DeleteObj(t);
 						}
 					}
 				}
 			}
 			break;
 		}
 	}
 
 	return LWindow::OnEvent(Msg);
 }
 
 bool ScribeWnd::IsMyEmail(const char *Email)
 {
 	if (Email)
 	{
 		LVariant e;
 		for (auto a : *GetAccounts())
 		{
 			LVariant e = a->Identity.Email();
 			if (e.Str() && _stricmp(Email, e.Str()) == 0)
 			{
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 int ScribeWnd::GetMaxPages()
 {
 	return d->PrintMaxPages;
 }
 
 void ScribeWnd::ThingPrint(std::function<void(bool)> Callback, ThingType *m, LPrinter *Printer, LView *Parent, int MaxPages)
 {
 	d->PrintMaxPages = MaxPages;
 	
 	if (!Printer)
 		Printer = GetPrinter();
 	if (!Printer)
 	{
 		if (Callback) Callback(false);
 		return;
 	}
 	Thing *t = dynamic_cast<Thing*>(m);
 	if (!t)
 	{
 		if (Callback) Callback(false);
 		return;
 	}
 		
 	auto Events = new ScribePrintContext(this, t);
 	Printer->Print(	Events,
 					[this, Events, Parent, Printer, Callback](auto pages)
 					{
 						if (pages == Events->OnBeginPrintError)
 						{
 							LgiMsg(Parent, "Printing failed: %s", AppName, MB_OK, Printer->GetErrorMsg().Get());
 							if (Callback)
 								Callback(false);
 						}
 						else if (Callback)
 						{
 							Callback(true);
 						}
 
 						delete Events;
 					},
 					AppName,
 					-1,
 					Parent ? Parent : this);
 }
 
 bool ScribeWnd::MailReplyTo(Mail *m, bool All)
 {
 	bool Status = false;
 
 	if (m)
 	{
 		LDataStoreI *Store = m->GetObject() ? m->GetObject()->GetStore() : NULL;
 		LDataI *NewMailObj = Store && Store->GetInt(FIELD_STORE_TYPE) == Store3Sqlite ? Store->Create(MAGIC_MAIL) : NULL;
 		
 		Mail *NewMail = new Mail(this, NewMailObj);
 		if (NewMail)
 		{
 			if (NewMail->GetObject())
 			{
 				NewMail->OnReply(m, All, true);
 
 				LView *w = NewMail->DoUI();
 				if (w)
 				{
 					LViewI *t = w->FindControl(IDC_TEXT);
 					if (t)
 					{
 						t->Focus(true);
 					}
 				}
 
 				Status = true;
 			}
 			else DeleteObj(NewMail);
 		}
 	}
 
 	return Status;
 }
 
 bool ScribeWnd::MailForward(Mail *m)
 {
 	bool Status = false;
 
 	if (m)
 	{
 		Mail *NewMail = new Mail(this);
 		if (NewMail)
 		{
 			if (NewMail->OnForward(m, true))
 			{
 				NewMail->DoUI();
 				Status = true;
 			}
 			else
 			{
 				NewMail->DecRef();
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool ScribeWnd::MailBounce(Mail *m)
 {
 	bool Status = false;
 
 	if (m)
 	{
 		Mail *NewMail = new Mail(this);
 		if (NewMail)
 		{
 			if (NewMail->OnBounce(m, true))
 			{
 				NewMail->DoUI();
 				Status = true;
 			}
 			else
 			{
 				DeleteObj(NewMail);
 			}
 		}
 	}
 
 	return Status;
 }
 
 Mail *ScribeWnd::CreateMail(Contact *c, const char *Email, const char *Name)
 {
 	Mail *m = dynamic_cast<Mail*>(CreateItem(MAGIC_MAIL, NULL, false));
 	if (m)
 	{
 		bool IsMailTo = false;
 		if (Email)
 		{
 			IsMailTo = _strnicmp(Email, "mailto:", 7) == 0;
 			if (IsMailTo)
 			{
 				Mailto mt(this, Email);
 				mt.Apply(m);
 			}
 		}
 
 		MailUi *UI = dynamic_cast<MailUi*>(m->DoUI());
 		if (UI)
 		{
 			if (c)
 			{
 				UI->AddRecipient(c);
 			}
 
 			if (Email && !IsMailTo)
 			{
 				UI->AddRecipient(Email, Name);
 			}
 		}
 	}
 
 	return m;
 }
 
 Mail *ScribeWnd::LookupMailRef(const char *MsgRef, bool TraceAllUids)
 {
 	if (!MsgRef)
 		return 0;
 	
 	LAutoString p(NewStr(MsgRef));
 	char *RawUid = strrchr(p, '/');
 	if (RawUid)
 	{
 		*RawUid++ = 0;
 		LUri u;
 		LString Uid = u.DecodeStr(RawUid);
 		
 		// Try the mail message map first...
 		Mail *m = Mail::GetMailFromId(Uid);
 		if (m)
 			return m;
 
 		// Ok, not found, so look in last known folder...
 		ScribeFolder *f = GetFolder(p);
 		if (f)
 		{
 			for (auto t : f->Items)
 			{
 				Mail *m = t->IsMail();
 				if (m)
 				{
 					auto s = m->GetMessageId();
 					if (s && !strcmp(s, Uid))
 					{
 						return m;
 					}
 					
 					if (TraceAllUids)
 						LgiTrace("\t%s\n", s);
 				}
 			}
 		}
 	}
 
 	return 0;
 }
 
 void ScribeWnd::OnBayesAnalyse(const char *Msg, const char *WhiteListEmail)
 {
 	LString s, q;
 	s.Printf("<html><body style='background:L_MED;'><pre>%s</pre>", Msg);
 	if (WhiteListEmail)
 	{
 		q.Printf(LLoadString(IDS_REMOVE_WHITELIST), WhiteListEmail);
 		s += LString("<br>") + q;
 	}
 	s += "</body></html>";
 	LHtmlMsg([this, WhiteListEmail=LString(WhiteListEmail)](auto result)
 			{
 				if (result == IDYES)
 					RemoveFromWhitelist(WhiteListEmail);
 			},
 			this,
 			s,
 			AppName,
 			WhiteListEmail ? MB_YESNO : MB_OK);
 }
 
 bool ScribeWnd::OnBayesResult(const char *MailRef, double Rating)
 {
 	Mail *m = LookupMailRef(MailRef);
 	if (m)
 		return OnBayesResult(m, Rating);
 	#ifdef _DEBUG
 	else
 	{
 		LgiTrace("%s:%i - error finding mail ref: %s\n", _FL, MailRef);
 		LookupMailRef(MailRef, true);
 		LAssert(!"We should always be able to resolve the reference, unless m is completely deleted");
 	}
 	#endif
 	
 	return false;
 }
 
 bool ScribeWnd::OnBayesResult(Mail *m, double Rating)
 {
 	if (!m)
 		return false;
 
 	LVariant v;
 	GetOptions()->GetValue(OPT_BayesThreshold, v);
 	double BayesThresh = v.CastDouble();
 	if (BayesThresh < 0.1) BayesThresh = 0.1;
 	if (BayesThresh > 1.0) BayesThresh = 1.0;
 
 	if (Rating < BayesThresh)
 	{
 		// Not spam, so we continue new mail processing
 		if (m->NewEmail == Mail::NewEmailBayes)
 		{
 			List<Mail> Nm;
 			Nm.Insert(m);
 			m->NewEmail = Mail::NewEmailGrowl;
 			OnNewMail(&Nm, true);
 		}
 		return false;
 	}
 
 	// Spam is pink!
 	m->SetMarkColour(Rgb32(255, 0, 0));
 	m->SetFlags(m->GetFlags() | MAIL_BAYES_SPAM);
 
 	ScribeBayesianFilterMode FilterMode = BayesOff;
 	if (GetOptions()->GetValue(OPT_BayesFilterMode, v))
 		FilterMode = (ScribeBayesianFilterMode)v.CastInt32();
 		
 	if (FilterMode == BayesTrain)
 	{
 		// Move to folder
 		LVariant MoveToPath;
 		if (!GetOptions()->GetValue(OPT_BayesMoveTo, MoveToPath))
 		{
 			MoveToPath = "/Spam/Probably";
 		}
 		ScribeFolder *f = GetFolder(MoveToPath.Str());
 		if (f)
 		{
 			LArray<Thing*> Items;
 			Items.Add(m);
 			f->MoveTo(Items, false, [this, m](auto result, auto status)
 			{			
 				List<Mail> obj;
 				obj.Insert(m);
 				OnNewMail(&obj, false);
 			});
 		}
 	}
 	else
 	{
 		m->DeleteAsSpam(this);
 	}
 
 	return true;
 }
 
 static int AccountCmp(ScribeAccount *a, ScribeAccount *b, int Data)
 {
 	return a->Identity.Sort() - b->Identity.Sort();
 }
 
 class ScribePasteState : public LProgressDlg
 {
 	ScribeWnd *App = NULL;
 	ScribeFolder *Folder = NULL;
 	LAutoPtr<uint8_t, true> Data;
 	ssize_t Size = 0;
 	LDataStoreI::StoreTrans Trans;
 	LProgressPane *LoadPane = NULL, *SavePane = NULL;
 	ScribeClipboardFmt *tl = NULL;
 	uint32_t Errors = 0;
 	ssize_t Idx = 0;
 
 	enum PasteState
 	{
 		LoadingThings,
 		SavingThings,
 	}	State = LoadingThings;
 
 public:
 	ScribePasteState(ScribeWnd *app, ScribeFolder *folder, LAutoPtr<uint8_t, true> data, ssize_t size) :
 		LProgressDlg(app),
 		App(app),
 		Folder(folder),
 		Data(data),
 		Size(size)
 	{
 		// Paste 'ScribeThingList'
 		tl = (ScribeClipboardFmt*)Data.Get();
 
 		Trans = Folder->GetObject()->GetStore()->StartTransaction();
 
 		LoadPane = ItemAt(0);
 		LoadPane->SetDescription("Loading objects...");
 		LoadPane->SetRange(tl->Length());
 
 		SavePane = Push();
 		SavePane->SetRange(tl->Length());
 		SavePane->SetDescription("Saving: No errors...");
 
 		// LProgressDlg will do a SetPulse in it's OnCreate
 	}
 
 	void OnPulse()
 	{
 		auto Start = LCurrentTime();
 		static int TimeSlice = 300; //ms
 
 		if (State == LoadingThings)
 		{
 			while (	Idx < tl->Length() &&
 					!IsCancelled() &&
 					LCurrentTime() - Start < TimeSlice)
 			{
 				Thing *t = tl->ThingAt(Idx++);
 				if (!t)
 					continue;
 
 				auto Obj = t->GetObject();
 				if (Obj->GetInt(FIELD_LOADED) < Store3Loaded)
 					Obj->SetInt(FIELD_LOADED, Store3Loaded);
 			}
 
 			Value(Idx);
 			if (Idx >= tl->Length())
 			{
 				State = SavingThings;
 				Idx = 0;
 			}
 		}
 		else if (State == SavingThings)
 		{
 			while (	Idx < tl->Length() &&
 					!IsCancelled() &&
 					LCurrentTime() - Start < TimeSlice)
 			{
 				Thing *t = tl->ThingAt(Idx++);
 				if (!t)
 					continue;
 
 				auto Obj = t->GetObject();
 				LAssert(Obj->GetInt(FIELD_LOADED) == Store3Loaded); // Load loop should have done this already
 
 				Thing *Dst = App->CreateItem(Obj->Type(), Folder, false);
 				if (Dst)
 				{
 					*Dst = *t;
 					Dst->Update();
 					if (!Dst->Save(Folder))
 					{
 						LString s;
 						s.Printf("Saving: " LPrintfSSizeT " error(s)", ++Errors);
 						SetDescription(s);
 					}
 				}
 				else Errors++;
 			}
 
 			SavePane->Value(Idx);
 			if (Idx >= tl->Length())
 			{
 				if (Errors > 0)
 					LgiMsg(this, "Failed to save %i of %i objects.", AppName, MB_OK, Errors, tl->Length());
 				Quit();
 				return;
 			}
 		}
 
 		LProgressDlg::OnPulse();
 	}
 };
 
 int ScribeWnd::OnCommand(int Cmd, int Event, OsView WndHandle)
 {
 	// Send mail multi-menu
 	if (Cmd >= IDM_SEND_FROM &&
 		Cmd <= IDM_SEND_FROM + (ssize_t)Accounts.Length())
 	{
 		Send(Cmd - IDM_SEND_FROM);
 		return 0;
 	}
 
 	// Receive mail multi-menu
 	if (Cmd >= IDM_RECEIVE_FROM &&
 		Cmd < IDM_RECEIVE_FROM + (ssize_t)Accounts.Length())
 	{
 		Receive(Cmd - IDM_RECEIVE_FROM);
 		return 0;
 	}
 
 	// Preview mail multi-menu
 	if (Cmd >= IDM_PREVIEW_FROM &&
 		Cmd < IDM_PREVIEW_FROM + (ssize_t)Accounts.Length())
 	{
 		Preview(Cmd - IDM_PREVIEW_FROM);
 		return 0;
 	}
 
 	// Identity multi-menu
 	if (Cmd >= IDM_IDENTITY_BASE &&
 		Cmd <= IDM_IDENTITY_BASE + (ssize_t)Accounts.Length())
 	{
 		SetCurrentIdentity(Cmd - IDM_IDENTITY_BASE - 1);
 		return 0;
 	}
 
 	// Is this a script tool?
 	if (LScribeScript::Inst &&
 		Cmd >= IDM_TOOL_SCRIPT_BASE &&
 		Cmd < IDM_TOOL_SCRIPT_BASE + (int)d->Scripts.Length())
 	{
 		// Do tools menu callback... find the right callback....
 		LArray<LScriptCallback*> c;
 		if (GetScriptCallbacks(LToolsMenu, c))
 		{
 			for (unsigned i=0; i<c.Length(); i++)
 			{
 				if (c[i]->Func &&
 					c[i]->Param == Cmd)
 				{
 					// Call the callback
 					char Msg[MAX_PATH_LEN];
 					LScribeScript::Inst->GetLog()->Write
 						(
 							Msg,
 							sprintf_s(Msg, sizeof(Msg), "\n\nRunning tool script '%s'...\n", c[i]->Script->Code->GetFileName())
 						);
 
 					// Setup the arguments...
 					LScriptArguments Args(NULL);
 					Args.New() = new LVariant((LDom*)this);
 					Args.New() = new LVariant(Cmd);
 
 					// Call the method
 					ExecuteScriptCallback(*c[i], Args);
 
 					// Cleanup
 					Args.DeleteObjects();
 					break;
 				}
 			}
 		}
 		return 0;
 	}
 
 	// New from template multi-menu
 	if (Cmd >= IDM_NEW_FROM_TEMPLATE &&
 		Cmd < IDM_NEW_FROM_TEMPLATE + 100)
 	{
 		int Index = Cmd - IDM_NEW_FROM_TEMPLATE;
 		ScribeFolder *Templates = GetFolder(FOLDER_TEMPLATES);
 		if (Templates)
 		{
 			Templates->LoadThings();
 
 			for (auto i: Templates->Items)
 			{
 				Mail *m = i->IsMail();
 				if (m)
 				{
 					if (Index == 0)
 					{
 						Thing *t = CreateItem(MAGIC_MAIL, 0, false); // GetFolder(FOLDER_OUTBOX)
 						Mail *NewMail = IsMail(t);
 						if (NewMail)
 						{
 							*NewMail = (Thing&)*m;
 							NewMail->DoUI();
 							break;
 						}
 					}
 					Index--;
 				}
 			}
 		}
 		return 0;
 	}
 
 	switch (Cmd)
 	{
 		// File menu
 		case IDM_MANAGE_MAIL_STORES:
 		{
 			auto Dlg = new ManageMailStores(this);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				LAutoPtr<LDialog> mem(dlg);
 				if (id)
 				{
 					SaveOptions();
 
 					if (!UnLoadFolders())
 						return;
 
 					LXmlTag *Ms = GetOptions()->LockTag(OPT_MailStores, _FL);
 					if (Ms)
 					{
 						while (Ms->Children.Length())
 							delete Ms->Children[0];
 					
 						LXmlTag *t = Dlg->Options.GetChildTag(OPT_MailStores);
 						if (t)
 						{
 							for (auto c: t->Children)
 							{
 								LXmlTag *n = new LXmlTag;
 								n->Copy(*c, true);
 								Ms->InsertTag(n);
 							}
 						}
 
 						GetOptions()->Unlock();
 					}
 
 					LVariant v;
 					GetOptions()->SetValue(OPT_CreateFoldersIfMissing, v = true);
 
 					if (!Dlg->Options.GetValue(OPT_StartInFolder, v))
 						v.Empty();
 					GetOptions()->SetValue(OPT_StartInFolder, v);
 
 					LoadFolders(NULL);
 				}
 			});
 			break;
 		}
 		case IDM_REPLICATE:
 		{
 			auto Dlg = new ReplicateDlg(this);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 				{
 					UnLoadFolders();
 					Dlg->StartProcess();
 					// Don't delete dialog... let it run
 				}
 				else delete dlg;
 			});
 			break;
 		}
 		case IDM_SECURITY:
 		{
 			// Check for user perm password...
 			// No point allow any old one to edit the security settings.
 			auto ShowDialog = [this]()
 			{
 				auto Dlg = new SecurityDlg(this);
 				Dlg->DoModal(NULL);
 			};
 
 			LPassword p;
 			if (p.Serialize(GetOptions(), OPT_UserPermPassword, false))
 			{
 				GetAccessLevel(this, PermRequireUser, "Security Settings", [ShowDialog](bool Allow)
 				{
 					if (Allow)
 						ShowDialog();
 				});
 			}
 			else
 			{
 				ShowDialog();
 			}
 			break;
 		}
 		case IDM_OPTIONS:
 		{
 			LVariant ShowTotals;
 			GetOptions()->GetValue(OPT_ShowFolderTotals, ShowTotals);
 
 			// do the dialog
 			auto Dlg = new OptionsDlg(this);
 			Dlg->DoModal([this, Dlg, ShowTotals](auto dlg, auto id)
 			{
 				if (id)
 				{
 					// set up the POP3 accounts
 					SetupAccounts();
 					SaveOptions();
 
 					// close any IMAP accounts that are now disabled.
 					for (auto a : Accounts)
 					{
 						if (a->Receive.IsConfigured() &&
 							a->Receive.IsPersistant())
 						{
 							if (a->Receive.Disabled())
 								a->Receive.Disconnect();
 							else
 								Receive(a->GetIndex());
 						}
 					}
 
 					// List/Tree view options update
 					LVariant i;
 					if (GetOptions()->GetValue(OPT_ShowFolderTotals, i) &&
 						i.CastInt32() != ShowTotals.CastInt32())
 					{
 						Tree->UpdateAllItems();
 					}
 					if (GetOptions()->GetValue(OPT_PreviewLines, i))
 					{
 						Mail::PreviewLines = i.CastInt32() != 0;
 					}
 					if (MailList)
 					{
 						if (GetOptions()->GetValue(OPT_GridLines, i))
 						{
 							MailList->DrawGridLines(i.CastInt32() != 0);
 						}
 						MailList->Invalidate();
 					}
 
 					// date formats
 					if (GetOptions()->GetValue(OPT_DateFormat, i))
 					{
 						int Idx = i.CastInt32();
 						if (Idx >= 0 && Idx < CountOf(DateTimeFormats))
 						{
 							LDateTime::SetDefaultFormat(DateTimeFormats[Idx]);
 						}
 					}
 					if (GetOptions()->GetValue(OPT_AdjustDateTz, i))
 						Mail::AdjustDateTz = i.CastInt32() == 0;
 
 					// SSL debug logging
 					if (GetOptions()->GetValue(OPT_DebugSSL, i))
 						SslSocket::DebugLogging = i.CastInt32() != 0;
 
 					// Html edit menu
 					if (GetOptions()->GetValue(OPT_EditControl, i))
 					{
 						auto mi = Menu->FindItem(IDM_HTML_EDITOR);
 						if (mi) mi->Checked(i.CastInt32() != 0);
 					}
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_WORK_OFFLINE:
 		{
 			if (WorkOffline)
 			{
 				WorkOffline->Checked(!WorkOffline->Checked());
 				LVariant v;
 				GetOptions()->SetValue(OPT_WorkOffline, v = WorkOffline->Checked());
 
 				if (!WorkOffline->Checked())
 				{
 					// Offline -> Online transition.
 
 					// Check if any pending messages are in the Outbox
 					ScribeFolder *Outbox = GetFolder(FOLDER_OUTBOX);
 					if (Outbox)
 					{
 						bool HasMailToSend = false;
 
 						for (auto t: Outbox->Items)
 						{
 							Mail *m = t->IsMail();
 							if (m)
 							{
 								if (TestFlag(m->GetFlags(), MAIL_READY_TO_SEND))
 								{
 									HasMailToSend = true;
 									break;
 								}
 							}
 						}
 
 						if (HasMailToSend)
 						{
 							PostEvent(M_COMMAND, IDM_SEND_MAIL,
 								#ifndef __GTK_H__
 								(LMessage::Param)Handle()
 								#else
 								0
 								#endif
 								);
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDM_ITEM_FILTER:
 		{
 			if (GetCtrlValue(IDM_ITEM_FILTER))
 			{
 				if ((SearchView = new LSearchView(this)))
 				{
 					SearchView->Focus(true);
 					SetLayout();
 				}
 			}
 			else
 			{
 				DeleteObj(SearchView);
 			}
 
 			ScribeFolder *Folder = GetCurrentFolder();
 			if (Folder)
 			{
 				Folder->Populate(MailList);
 			}
 			break;
 		}
 		case IDM_PRINT:
 		{
 			if (MailList)
 			{
 				List<LListItem> Sel;
 				if (MailList->LList::GetSelection(Sel))
 				{
 					for (auto i: Sel)
 					{
 						ThingType *t = dynamic_cast<ThingType*>(i);
 						ThingPrint(NULL, t);
 					}
 				}
 			}
 			break;
 		}
 		case IDM_PRINTSETUP:
 		{
 			auto *p = GetPrinter();
 			if (p && p->Browse(this))
 			{
 				LString Str;
 				if (p->Serialize(Str, true))
 				{
 					LVariant v;
 					GetOptions()->SetValue(OPT_PrintSettings, v = Str);
 				}
 			}
 			break;
 		}
 		case IDM_PAGE_SETUP:
 		{
 			auto Dlg = new ScribePageSetup(this, GetOptions());
 			Dlg->DoModal(NULL);
 			break;
 		}
 		case IDM_EXIT:
 		{
 			LMouse m;
 			GetMouse(m);
 			d->IngoreOnClose = m.Ctrl();
 			LCloseApp();
 			break;
 		}
 
 		// Edit menu
 		case IDM_FIND:
 		{
 			auto v = GetFocus();
 			LDocView *doc = dynamic_cast<LDocView*>(v);
 			if (doc)
 			{
 				doc->DoFind(NULL);
 			}
 			else
 			{
 				ScribeFolder *Folder = GetCurrentFolder();
 				OpenFinder(this, Folder);
 			}
 			break;
 		}
 		case IDM_COPY:
 		{
 			if (MailList && MailList->Focus())
 			{
 				List<Thing> Lst;
 				if (!MailList->GetSelection(Lst))
 					break;
 
 				// Copy 'ScribeThingList'
 				ScribeClipboardFmt *tl = ScribeClipboardFmt::Alloc(Lst);
 				if (!tl)
 					break;
 
 				LClipBoard Clip(this);
 				if (Clip.IsOpen())
 				{
 					if (!Clip.Binary(d->ClipboardFormat, (uchar*)tl, tl->Sizeof(), true))
 					{
 						LgiMsg(this, "Couldn't set the clipboard data.", AppName, MB_OK);
 					}
 				}
 				else
 				{
 					LgiMsg(this, "Couldn't open the clipboard.", AppName, MB_OK);
 				}
 
 				free(tl);
 			}
 			else
 			{
 				LViewI *v = LAppInst->GetFocus();
 				if (v)
 					v->PostEvent(M_COPY);
 			}
 			break;
 		}
 		case IDM_PASTE:
 		{
 			LViewI *v = LAppInst->GetFocus();
 			if (v && v->GetWindow() != (LWindow*)this)
 			{
 				v->PostEvent(M_PASTE);
 				break;
 			}
 			
 			if (!MailList->Focus() && !Tree->Focus())
 			{
 				LgiTrace("%s:%i - List/Tree doesn't have focus.\n");
 				break;
 			}
 
 			ScribeFolder *Folder = dynamic_cast<ScribeFolder*>(Tree->Selection());
 			if (!Folder || !Folder->GetObject())
 			{
 				LgiMsg(this, "No current folder.", AppName, MB_OK);
 				break;
 			}
 
 			LClipBoard Clip(this);
 			if (!Clip.IsOpen())
 			{
 				LgiMsg(this, "Couldn't open the clipboard.", AppName, MB_OK);
 				break;
 			}
 
 			LAutoPtr<uint8_t, true> Data;
 			ssize_t Size = 0;
 			if (!Clip.Binary(d->ClipboardFormat, Data, &Size))
 			{
 				LgiMsg(this, "Couldn't get the clipboard data.", AppName, MB_OK);
 				break;
 			}
 
 			if (ScribeClipboardFmt::IsThing(Data.Get(), Size))
 			{
 				new ScribePasteState(this, Folder, Data, Size);
 			}
 			break;
 		}
 		case IDM_DELETE:
 		{
 			LViewI *f = LAppInst->GetFocus();
 			LEdit *e = dynamic_cast<LEdit*>(f);
 			if (e)
 			{
 				// This handles the case where on a mac the menu eats the delete key, even
 				// when the edit control needs it
 				LKey k(LK_DELETE, 0);
 				k.Down(true);
 				f->OnKey(k);
 				k.Down(false);
 				f->OnKey(k);
 			}
 			else
 			{
 				OnDelete();
 			}
 			break;
 		}
 		case IDM_DELETE_AS_SPAM:
 		{
 			if (MailList)
 			{
 				List<LListItem> Sel;
 				MailList->GetSelection(Sel);
 				int Index = -1;
 
 				for (auto i: Sel)
 				{
 					Mail *m = IsMail(i);
 					if (m)
 					{
 						if (Index < 0)
 						{
 							Index = MailList->IndexOf(i);
 						}
 						m->DeleteAsSpam(this);
 					}
 				}
 
 				if (Index >= 0)
 				{
 					LListItem *i = MailList->ItemAt(Index);
 					if (!i)
 						i = MailList->ItemAt(MailList->Length()-1);
 					if (i)
 						i->Select(true);
 				}
 			}
 			break;
 		}
 		case IDM_REFRESH:
 		{
 			ScribeFolder *f = GetCurrentFolder();
 			if (!f)
 				break;
 			
 			const char *s = DomToStr(SdRefresh);
 			f->GetFldObj()->OnCommand(s);
 			break;
 		}
 
 		// Mail menu
 		case IDM_NEW_EMAIL:
 		{
 			CreateMail();
 			break;
 		}
 		case IDM_SET_READ:
 		case IDM_SET_UNREAD:
 		{
 			ScribeFolder *f = GetCurrentFolder();
 			if (!f)
 				break;
 
 			bool SetRead = Cmd == IDM_SET_READ;
 			f->LoadThings();
 
 			LArray<LDataI*> Change;
 			for (auto t: f->Items)
 			{
 				Mail *m = t->IsMail();
 				if (m && m->Select())
 					Change.Add(m->GetObject());
 			}
 
 			LVariant v = MAIL_READ;
 			LDataStoreI *Store = f->GetObject()->GetStore();
 			if (Store->Change(Change, FIELD_FLAGS, v, SetRead ? OpPlusEquals : OpMinusEquals) == Store3Error)
 			{
 				for (auto t : f->Items)
 				{
 					Mail *m = t->IsMail();
 					if (!m)
 						continue;
 
 					if (!m->Select())
 						continue;
 
 					if (SetRead)
 						m->SetFlags(m->GetFlags() | MAIL_READ);
 					else
 						m->SetFlags(m->GetFlags() & ~MAIL_READ);
 				}
 			}
 			break;
 		}
 		case IDM_REPLY:
 		case IDM_REPLY_ALL:
 		{
 			if (MailList)
 				MailReplyTo(IsMail(MailList->GetSelected()), (Cmd == IDM_REPLY_ALL));
 			break;
 		}
 		case IDM_FORWARD:
 		{
 			if (MailList)
 				MailForward(IsMail(MailList->GetSelected()));
 			break;
 		}
 		case IDM_BOUNCE:
 		{
 			if (MailList)
 				MailBounce(IsMail(MailList->GetSelected()));
 			break;
 		}
 		case IDM_SEND_MAIL:
 		{
 			Send();
 			break;
 		}
 		case IDM_RECEIVE_AND_SEND:
 		{
 			d->SendAfterReceive = true;
 			PostEvent(M_COMMAND, IDM_RECEIVE_MAIL, (LMessage::Param)FindControl(IDM_RECEIVE_MAIL));
 			break;
 		}
 		case IDM_THREAD:
 		{
 			if (MailList)
 			{
 				ScribeFolder *f = GetCurrentFolder();
 				if (f)
 				{
 					f->SetThreaded(!f->GetThreaded());
 					f->Populate(MailList);
 				}
 			}
 			break;
 		}
 		case IDM_RECEIVE_ALL:
 		{
 			#define LOG_RECEIVE_ALL		0
 			int i = 0;
 			
 			Accounts.Sort(AccountCmp);
 			
 			for (auto a : Accounts)
 			{
 				#if LOG_RECEIVE_ALL
 				auto name = a->Identity.Name();
 				auto email = a->Identity.Email();
 				LString desc;
 				desc.Printf("%s/%s", name.Str(), email.Str());
 				#endif
 				
 				if (!a->Receive.IsConfigured())
 				{
 					#if LOG_RECEIVE_ALL
 					LgiTrace("%s:%i - %i/%s not configured.\n", _FL, a->GetIndex(), desc.Get());
 					#endif
 				}
 				else if (a->Receive.Disabled() > 0)
 				{
 					#if LOG_RECEIVE_ALL
 					LgiTrace("%s:%i - %i/%s is disabled.\n", _FL, a->GetIndex(), desc.Get());
 					#endif
 				}
 				else
 				{
 					#if LOG_RECEIVE_ALL				
 					LgiTrace("%s:%i - %i/%s will connect.\n", _FL, a->GetIndex(), desc.Get());
 					#endif
 					Receive(a->GetIndex());
 				}
 				i++;
 			}
 			break;
 		}
 		case IDM_RECEIVE_MAIL:
 		{
 			LVariant Def;
 			if (GetOptions()->GetValue(OPT_Pop3DefAction, Def) && Def.CastInt32() == 0)
 				return OnCommand(IDM_RECEIVE_ALL, 0, NULL);
 
 			Receive(0);
 			break;
 		}
 		case IDM_PREVIEW_POP3:
 		{
 			LArray<ScribeAccount*> Account;
 
 			Accounts.Sort(AccountCmp);
 
 			for (auto a: Accounts)
 			{
 				if (!a->Receive.IsConfigured())
 					continue;
 				
 				auto Protocol = ProtocolStrToEnum(a->Receive.Protocol().Str());
 				if (Protocol == ProtocolPop3)
 				{
 					Account.Add(a);
 					break;
 				}
 			}
 			
 			if (Account.Length() == 1)
 				OpenPopView(this, Account);
 
 			break;
 		}
 
 		case IDM_CALENDAR:
 		{
 			extern void OpenCalender(ScribeFolder *folder);
 
 			ScribeFolder *Folder = GetFolder(FOLDER_CALENDAR);
 			if (Folder)
 			{
 				OpenCalender(Folder);
 			}
 			break;
 		}
 
 		// Contact menu
 		case IDM_NEW_CONTACT:
 		{
 			CreateItem(MAGIC_CONTACT, NULL);
 			break;
 		}
 		case IDM_NEW_GROUP:
 		{
 			CreateItem(MAGIC_GROUP, NULL);
 			break;
 		}
 
 		// Filter menu
 		case IDM_NEW_FILTER:
 		{
 			Thing *t = CreateItem(MAGIC_FILTER, NULL, false);
 			if (t)
 			{
 				t->IsFilter()->SetIncoming(true);
 				t->DoUI();
 			}
 			break;
 		}
 		case IDM_FILTER_CURRENT_FOLDER:
 		{
 			ScribeFolder *Folder = GetCurrentFolder();
 			if (Folder)
 			{
 				List<Filter> Filters;
 				GetFilters(Filters, false, false, true);
 
 				List<Mail> Src;
 				for (auto i: Folder->Items)
 				{
 					if (i->IsMail())
 					{
 						Src.Insert(i->IsMail());
 					}
 				}
 
 				if (!Src[0])
 				{
 					LgiMsg(this, LLoadString(IDS_NO_MAIL_TO_FILTER), AppName);
 				}
 				else
 				{
 					Filter::ApplyFilters(this, Filters, Src);
 				}
 			}
 			break;
 		}
 		case IDM_FILTER_SELECTION:
 		{
 			ScribeFolder *Folder = GetCurrentFolder();
 			if (Folder)
 			{
 				List<Filter> Filters;
 				GetFilters(Filters, false, false, true);
 
 				List<Mail> Src;
 				for (auto i: Folder->Items)
 				{
 					if (i->IsMail() && i->Select())
 					{
 						Src.Insert(i->IsMail());
 					}
 				}
 
 				if (Src.Length())
 				{
 					Filter::ApplyFilters(this, Filters, Src);
 				}
 			}
 			break;
 		}
 		case IDM_DEBUG_FILTERS:
 		{
 			auto i = Menu->FindItem(IDM_DEBUG_FILTERS);
 			if (i)
 			{
 				i->Checked(!i->Checked());
 			}
 			break;
 		}
 		case IDM_HTML_EDITOR:
 		{
 			auto i = Menu->FindItem(IDM_HTML_EDITOR);
 			if (i)
 			{
 				i->Checked(!i->Checked());
 				
 				LVariant v;
 				GetOptions()->SetValue(OPT_EditControl, v = i->Checked() ? 1 : 0);
 			}
 			break;
 		}
 		case IDM_FILTERS_DISABLE:
 		{
 			if (d->DisableUserFilters)
 			{
 				d->DisableUserFilters->Checked(!d->DisableUserFilters->Checked());
 
 				LVariant v;
 				GetOptions()->SetValue(OPT_DisableUserFilters, v = d->DisableUserFilters->Checked());
 			}			
 			break;
 		}
 		case IDM_BUILD_BAYES_DB:
 		{
 			BuildSpamDb();
 			break;
 		}
 		case IDM_BAYES_STATS:
 		{
 			BuildStats();
 			break;
 		}
 		case IDM_BAYES_SETTINGS:
 		{
 			auto Dlg = new BayesDlg(this);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 				{
 					LVariant i;
 					if (GetOptions()->GetValue(OPT_BayesFilterMode, i))
 					{
 						ScribeBayesianFilterMode m = ((ScribeBayesianFilterMode)i.CastInt32());
 						if (m != BayesOff)
 						{
 							LVariant SpamPath, ProbablyPath;
 							GetOptions()->GetValue(OPT_SpamFolder, SpamPath);
 							GetOptions()->GetValue(OPT_BayesMoveTo, ProbablyPath);
 											
 							if (m == BayesFilter)
 							{
 								ScribeFolder *Spam = GetFolder(SpamPath.Str());
 								if (!Spam)
 								{
 							
 									LMailStore *RelevantStore = GetMailStoreForPath(SpamPath.Str());
 									if (RelevantStore)
 									{
 										LString p = SpamPath.Str();
 										LString::Array a = p.SplitDelimit("/");
 									
 										Spam = RelevantStore->Root;
 										for (unsigned i=1; i<a.Length(); i++)
 										{
 											ScribeFolder *c = Spam->GetSubFolder(a[i]);
 											if (!c)
-												c = Spam->CreateSubDirectory(a[i], MAGIC_MAIL);
+												c = Spam->CreateSubFolder(a[i], MAGIC_MAIL);
 											Spam = c;
 										}
 									}
 								}
 							
 								if (Spam)
 								{
 									LVariant v;
 									GetOptions()->SetValue(OPT_HasSpam, v = 1);
 								}
 							}
 							else if (m == BayesTrain)
 							{
 								ScribeFolder *Probably = GetFolder(ProbablyPath.Str());
 								if (!Probably)
 								{
 									LgiMsg(this, "Couldn't find the folder '%s'", AppName, MB_OK, ProbablyPath.Str());
 								}
 							}
 						}
 					}
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_BAYES_CHECK:
 		{
 			List<LListItem> Sel;
 			if (MailList) MailList->GetSelection(Sel);
 
 			for (auto i: Sel)
 			{
 				Thing *t = dynamic_cast<Thing*>(i);
 				if (t)
 				{
 					Mail *m = t->IsMail();
 					if (m)
 					{
 						d->BayesLog.Empty();
 						
 						double SpamRating = 0.0;
 						IsSpam(SpamRating, m, true);
 						break;
 					}
 				}
 			}
 			break;
 		}
 
 		// Tools menu
 		case IDM_SCRIPTING_CONSOLE:
 		case IDM_SHOW_CONSOLE:
 		{
 			ShowScriptingConsole();
 
 			if (d->ShowConsoleBtn)
 				d->ShowConsoleBtn->Image(IMG_CONSOLE_NOMSG);
 			break;
 		}
 		case IDM_EXPORT_TEXT_MBOX:
 		{
 			Export_UnixMBox(this);
 			break;
 		}
 		case IDM_IMPORT_CSV:
 		{
 			ImportCsv(this);
 			break;
 		}
 		case IDM_EXPORT_CSV:
 		{
 			ExportCsv(this);
 			break;
 		}
 		case IDM_IMPORT_EML:
 		{
 			ImportEml(this);
 			break;
 		}
 		case IDM_EXPORT_SCRIBE:
 		{
 			ExportScribe(this, NULL/* default mail store */);
 			break;
 		}
 		case IDM_IMPORT_TEXT_MBOX:
 		{
 			Import_UnixMBox(this);
 			break;
 		}
 		case IDM_IMP_EUDORA_ADDR:
 		{
 			Import_EudoraAddressBook(this);
 			break;
 		}
 		case IDM_IMP_MOZILLA_ADDR:
 		{
 			Import_MozillaAddressBook(this);
 			break;
 		}
 		case IDM_IMP_MOZILLA_MAIL:
 		{
 			Import_MozillaMail(this);
 			break;
 		}
 		#if WINNATIVE
 		case IDM_IMPORT_OUTLOOK_PAB:
 		{
 			Import_OutlookContacts(this);
 			break;
 		}
 		case IDM_IMPORT_OUTLOOK_ITEMS:
 		{
 			Import_Outlook(this, IMP_OUTLOOK);
 			break;
 		}
 		case IDM_EXPORT_OUTLOOK_ITEMS:
 		{
 			Export_Outlook(this);
 			break;
 		}
 		#endif
 		case IDM_IMP_MBX_EMAIL:
 		{
 			Import_OutlookExpress(this, false); // v4
 			break;
 		}
 		case IDM_IMP_DBX_EMAIL:
 		{
 			Import_OutlookExpress(this); // v5
 			break;
 		}
 		case IDM_IMPORT_NS_CONTACTS:
 		{
 			Import_NetscapeContacts(this);
 			break;
 		}
 		case IDM_CHECK_UPDATE:
 		{
 			LVariant v;
 			GetOptions()->GetValue(OPT_SoftwareUpdateIncBeta, v);
 			SoftwareUpdate(this, true, v.CastInt32() != 0, [](auto goingToUpdate)
 			{
 				if (goingToUpdate)
 					LCloseApp();
 			});
 			break;
 		}
 		case IDM_LOGOUT:
 		{
 			CurrentAuthLevel = PermRequireNone; 
 			auto i = Menu->FindItem(IDM_LOGOUT);
 			if (i)
 				i->Enabled(false);
 			break;
 		}
 		case IDM_LAYOUT1:
 		{
 			LVariant v;
 			int TwoThirds = GetClient().Y() >> 1;
 			GetOptions()->SetValue(OPT_SplitterPos, v = 200);
 			GetOptions()->SetValue(OPT_SubSplitPos, v = TwoThirds);
 			SetLayout(FoldersListAndPreview);
 			break;
 		}
 		case IDM_LAYOUT2:
 		{
 			LVariant v;
 			int TwoThirds = GetClient().Y() >> 1;
 			GetOptions()->SetValue(OPT_SplitterPos, v = TwoThirds);
 			GetOptions()->SetValue(OPT_SubSplitPos, v = 200);
 			SetLayout(PreviewOnBottom);
 			break;
 		}
 		case IDM_LAYOUT3:
 		{
 			LVariant v;
 			GetOptions()->SetValue(OPT_SplitterPos, v = 200);
 			SetLayout(FoldersAndList);
 			break;
 		}
 		case IDM_LAYOUT4:
 		{
 			LVariant v;
 			GetOptions()->SetValue(OPT_SplitterPos, v = 200);
 			GetOptions()->SetValue(OPT_SubSplitPos, v);
 			SetLayout(ThreeColumn);
 			break;
 		}
 		case IDM_CRASH:
 		{
 			int *Crash = 0;
 			*Crash = true;
 			break;
 		}
 		case IDM_DUMP_MEM:
 		{
 			LDumpMemoryStats(0);
 			break;
 		}
 		case IDM_SCRIPT_DEBUG:
 		{
 			LVariant v;
 			if (GetOptions())
 				GetOptions()->SetValue(OPT_ScriptDebugger, v = true);
 
 			LVirtualMachine *vm = new LVirtualMachine(d);
 			if (!vm)
 				break;
 
 			LVmDebugger *dbg = vm->OpenDebugger();
 			if (!dbg)
 				break;
 
 			dbg->OwnVm(true);
 			break;
 		}
 		case IDM_SCRIPT_BREAK_ON_WARN:
 		{
 			auto mi = GetMenu()->FindItem(IDM_SCRIPT_BREAK_ON_WARN);
 			if (!mi)
 				break;
 			LVirtualMachine::BreakOnWarning = !mi->Checked();
 			mi->Checked(LVirtualMachine::BreakOnWarning);
 			break;
 		}
 		case IDM_UNIT_TESTS:
 		{
 			#ifdef _DEBUG
 			UnitTests([this](auto ok)
 			{
 				LgiMsg(this, "UnitTest status: %i", AppName, MB_OK, ok);
 			});
 			#endif
 			break;
 		}
 
 		// Help menu
 		case IDM_HELP:
 		{
 			LaunchHelp("index.html");
 			// LgiMsg(this, LLoadString(IDS_ERROR_NO_HELP), AppName, MB_OK);
 			break;
 		}
 		case IDM_FEEDBACK:
 		{
 			LVariant e;
 			if (GetOptions()->GetValue("author", e))
 				CreateMail(0, e.Str());
 			else
 				CreateMail(0, AuthorEmailAddr);
 			break;
 		}
 		case IDM_MEMECODE:
 		{
 			LExecute(AuthorHomepage);
 			break;
 		}
 		case IDM_HOMEPAGE:
 		{
 			LVariant hp;
 			if (GetOptions()->GetValue("homepage", hp))
 				LExecute(hp.Str());
 			else
 				LExecute(ApplicationHomepage);
 			break;
 		}
 		case IDM_VERSION_HISTORY:
 		{
 			LExecute("http://www.memecode.com/site/ver.php?id=445");
 			break;
 		}
 		case IDM_DEBUG_INFO:
 		{
 			char s[256];
 			sprintf_s(s, sizeof(s), "%s#debug", ApplicationHomepage);
 			LExecute(s);
 			break;
 		}
 		case IDM_TUTORIALS:
 		{
 			LExecute("http://www.memecode.com/scribe/tutorials");
 			break;
 		}
 		case IDM_INSCRIBE_LINK:
 		{
 			LExecute(CommercialHomepage);
 			break;
 		}
 		case IDM_SCRIBE_FAQ:
 		{
 			LExecute(FaqHomepage);
 			break;
 		}
 		case IDM_ABOUT:
 		{
 			extern void ScribeAbout(ScribeWnd *Parent);
 			ScribeAbout(this);
 			break;
 		}
 		default:
 		{			
 			if (d->ScriptToolbar)
 				d->ScriptToolbar->ExecuteCallbacks(this, 0, 0, Cmd);
 			break;
 		}
 	}
 
 	return 0;
 }
 
 void ScribeWnd::OnDelete()
 {
 	LVariant ConfirmDelete;
 	GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 	if (!ConfirmDelete.CastInt32() ||
 		LgiMsg(this, LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 	{
 		LArray<LDataI*> Del;
 		
 		if (Tree && Tree->Focus())
 		{
 			ScribeFolder *Item = dynamic_cast<ScribeFolder*>(Tree->Selection());
 			if (Item)
 			{
 				Tree->OnDelete(Item, false);
 			}
 		}
 		else if (MailList
 			#ifdef MAC
 			&& MailList->Focus()
 			#endif
 			)
 		{
 			List<LListItem> Sel;
 			MailList->GetSelection(Sel);
 
 			for (auto i: Sel)
 			{
 				Thing *t = dynamic_cast<Thing*>(i);
 				if (t)
 					Del.Add(t->GetObject());
 			}
 
 			if (Del.Length())
 			{
 				auto Store = Del[0]->GetStore();
 				Store->Delete(Del, true);
 			}
 			else LgiTrace("%s:%i - Nothing to delete\n", _FL);
 
 			#ifndef MAC
 			MailList->Focus(true);
 			#endif
 		}
 	}
 }
 
 int ScribeWnd::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_THING_LIST:
 		{
 			if (n.Type == LNotifyReturnKey)
 			{
 				LListItem *i = MailList ? MailList->GetSelected() : 0;
 				Thing *t = dynamic_cast<Thing*>(i);
 				if (t)
 				{
 					t->DoUI();
 				}
 			}
 			else if (n.Type == LNotifyDeleteKey)
 			{
 				/* This is now handled by the menu
 				OnDelete();
 				return true;
 				*/
 			}
 			
 			if (SearchView &&
 				MailList)
 			{
 				SearchView->OnNotify(Ctrl, n);
 			}
 			break;
 		}
 		case IDC_TEXT:
 		{
 			if (PreviewPanel)
 			{
 				PreviewPanel->OnNotify(Ctrl, n);
 			}
 			break;
 		}
 	}
 
 	return 0;
 }
 
 void ScribeWnd::AddThingSrc(ScribeFolder *src)
 {
 	if (!d->ThingSources.HasItem(src))
 		d->ThingSources.Add(src);
 }
 
 void ScribeWnd::RemoveThingSrc(ScribeFolder *src)
 {
 	d->ThingSources.Delete(src);
 }
 
 LArray<ScribeFolder*> ScribeWnd::GetThingSources(Store3ItemTypes Type)
 {
 	LArray<ScribeFolder*> a;
 	for (auto f: d->ThingSources)
 	{
 		if (f->GetItemType() == Type &&
 			!f->IsInTrash())
 		{
 			a.Add(f);
 		}
 	}
 	return a;
 }
 
 bool ScribeWnd::LogFilterActivity()
 {
 	auto i = Menu->FindItem(IDM_DEBUG_FILTERS);
 	return i ? i->Checked() : false;
 }
 
 bool ScribeWnd::CreateFolders(LAutoString &FileName)
 {
 	bool Status = false;
 
 	if (FileName)
 	{
 		char *Ext = LGetExtension(FileName);
 		if (!Ext)
 		{
 			char File[300];
 			strcpy_s(File, sizeof(File), FileName);
 			strcat(File, ".mail3");
 			FileName.Reset(NewStr(File));
 		}
 
 		// Create objects, and then close the file.. it'll be reloaded later
 		LAutoPtr<LDataStoreI> m(CreateDataStore(FileName, true));
 		if (m)
 		{
 			m->GetRoot(true);
 			Status = true;
 		}
 		else LgiTrace("%s:%i - CreateDataStore failed.\n", _FL);
 	}
 	else LgiTrace("%s:%i - No file name for CreateFolder.\n", _FL);
 
 	return Status;
 }
 
 bool ScribeWnd::CompactFolders(LMailStore &Store, bool Interactive)
 {
 	if (!Store.Store)
 		return false;
 
 	auto Dlg = new Store3Progress(this, Interactive);
 
 	Dlg->SetDescription(LLoadString(IDS_CHECKING_OBJECTS));
 
 	bool Offline = false;
 	if (WorkOffline)
 	{
 		Offline = WorkOffline->Checked();
 		WorkOffline->Checked(true);
 	}
 
 	Store.Store->Compact(this, Dlg, [this, Offline, Dlg](auto status)
 	{
 		LAssert(InThread());
 
 		if (WorkOffline)
 			WorkOffline->Checked(Offline);
 
 		delete Dlg;
 	});
 
 	return true;
 }
 
 CalendarSource *CalendarSource::Create(ScribeWnd *App, const char *ObjName, const char *Id)
 {
 	if (!Stricmp(ObjName, "RemoteCalendarSource"))
 		return new RemoteCalendarSource(App, Id);
 	return new FolderCalendarSource(App, Id);
 }
 
 int ScribeWnd::GetCalendarSources(LArray<CalendarSource*> &Out)
 {
 	static bool Loaded = false;
 
 	if (!Loaded)
 	{
 		Loaded = true;
 		CalendarSource::SetCreateIn(NULL);
 
 		LVariant Create;
 		GetOptions()->GetValue(OPT_CalendarCreateIn, Create);
 
 		// This should be a list of all calendar folders in ANY mail store...
 		auto CalFlds = GetThingSources(MAGIC_CALENDAR);
 
 		LXmlTag *t = GetOptions()->LockTag(OPT_CalendarSources, _FL);
 		if (t)
 		{
 			bool AutoPopulate = t->Children.Length() == 0;
 
 			for (auto c: t->Children)
 			{
 				auto s = CalendarSource::Create(this,
 												c->GetAttr(CalendarSource::OptObject),
 												c->GetTag());
 				if (s && s->Read())
 				{
 					// Add known source...
 					if (!Stricmp(Create.Str(), c->GetTag()))
 					{
 						CalendarSource::SetCreateIn(s);							
 					}
 
 					// Remove from CalFlds
 					FolderCalendarSource *Fcs = dynamic_cast<FolderCalendarSource*>(c);
 					if (Fcs)
 					{
 						auto Path = Fcs->GetPath();
 						for (auto c: CalFlds)
 						{
 							if (c->GetPath().Equals(Path))
 							{
 								CalFlds.Delete(c);
 								break;
 							}
 						}
 					}
 				}
 			}
 
 			if (AutoPopulate)
 			{
 				// Now CalFlds should be a list of all calendar folders NOT in the source XML tag
 				for (auto c: CalFlds)
 				{
 					FolderCalendarSource *s = new FolderCalendarSource(this);
 					if (s)
 					{
 						// So add an entry to track it...
 						auto Path = c->GetPath();
 						s->SetPath(Path);
 						s->SetDisplay(true);
 						s->SetColour(CalendarSource::FindUnusedColour());
 						s->Write();
 					}
 				}
 			}
 		
 			GetOptions()->Unlock();
 		}
 
 		if (!CalendarSource::GetCreateIn() &&
 			CalendarSource::GetSources().Length())
 		{
 			CalendarSource::SetCreateIn(CalendarSource::GetSources().ItemAt(0));
 		}
 	}
 
 	for (unsigned i=0; i<CalendarSource::GetSources().Length(); i++)
 		Out.Add(CalendarSource::GetSources().ItemAt(i));
 	return (int)Out.Length();
 }
 
 int ScribeWnd::GetFolderType(ScribeFolder *f)
 {
 	if (!f)
 		return -1;
 
 	for (SystemFolderInfo *fi = SystemFolders; fi->PathOption; fi++)
 	{
 		bool Check = true;
 		if (fi->HasOption)
 		{
 			LVariant v;
 			if (GetOptions()->GetValue(fi->HasOption, v))
 				Check = v.CastInt32() != 0;
 		}
 		if (Check)
 		{		
 			ScribeFolder *c = GetFolder(fi->Id);
 			if (c == f)
 				return fi->Id;
 		}
 	}
 
 	return -1;
 }
 
 ScribeFolder *ScribeWnd::GetCurrentFolder()
 {
 	if (Tree)
 	{
 		auto *Item = Tree->Selection();
 		if (Item)
 		{
 			return dynamic_cast<ScribeFolder*>(Item);
 		}
 	}
 
 	return 0;
 }
 
 bool ScribeWnd::GetSystemPath(int Folder, LVariant &Path)
 {
 	char KeyName[64];
 	sprintf_s(KeyName, sizeof(KeyName), "Folder-%i", Folder);
 	return GetOptions()->GetValue(KeyName, Path);
 }
 
 LMailStore *ScribeWnd::GetMailStoreForIdentity(const char *IdEmail)
 {
 	LVariant Tmp;
 	if (!IdEmail)
 	{
 		// Get current identity
 		ScribeAccount *Cur = GetCurrentAccount();
 		if (Cur)
 		{
 			Tmp = Cur->Identity.Email();
 			IdEmail = Tmp.Str();
 		}
 	}
 	
 	if (!IdEmail)
 		return NULL;
 	
 	ScribeAccount *a = NULL;
 	for (auto Acc : Accounts)
 	{
 		LVariant e = Acc->Identity.Email();
 		if (e.Str() && !_stricmp(e.Str(), IdEmail))
 		{
 			a = Acc;
 			break;
 		}
 	}
 	if (!a)
 		return NULL;
 
 	LVariant DestPath = a->Receive.DestinationFolder();
 	if (!DestPath.Str())
 		return NULL;
 	
 	return GetMailStoreForPath(DestPath.Str());
 }
 
 ScribeFolder *ScribeWnd::GetFolder(int Id, LDataI *s)
 {
 	if (s)
 	{
 		for (auto &f: Folders)
 			if (s->GetStore() == f.Store)
 				return GetFolder(Id, &f);
 	}
 
 	return GetFolder(Id);
 }
 
 ScribeFolder *ScribeWnd::GetFolder(int Id, LMailStore *Store, bool Quiet)
 {
 	char KeyName[64];
 	sprintf_s(KeyName, sizeof(KeyName), "Folder-%i", Id);
 	LVariant FolderName;
 	bool NoOption = false;
 
 	if (GetOptions()->GetValue(KeyName, FolderName))
 	{
 		if (ValidStr(FolderName.Str()) &&
 			strlen(FolderName.Str()) > 0)
 		{
 			ScribeFolder *c = GetFolder(FolderName.Str(), Store);
 			if (c)
 			{
 				return c;
 			}
 			else if (!Quiet)
 			{
 				LgiTrace("%s:%i - '%s' doesn't exist.\n",
 					_FL, FolderName.Str());
 			}
 		}
 	}
 	else if (!Quiet)
 	{
 		// LgiTrace("%s:%i - No option '%s'\n", _FL, KeyName);
 		NoOption = true;
 	}
 
 	switch (Id)
 	{
 		case FOLDER_INBOX:
 		case FOLDER_OUTBOX:
 		case FOLDER_SENT:
 		case FOLDER_TRASH:
 		case FOLDER_CONTACTS:
 		case FOLDER_TEMPLATES:
 		case FOLDER_FILTERS:
 		case FOLDER_CALENDAR:
 		case FOLDER_GROUPS:
 		case FOLDER_SPAM:
 		{
 			ScribeFolder *c = GetFolder(DefaultFolderNames[Id], Store);
 			if (!c)
 			{
 				// if (!Quiet)
 				// LgiTrace("%s:%i - Default folder '%s' doesn't exist.\n", _FL, DefaultFolderNames[Id]);
 			}
 			else if (NoOption)
 			{
 				auto p = c->GetPath();
 				GetOptions()->SetValue(KeyName, FolderName = p.Get());
 			}
 			return c;
 		}
 	}
 
 	return NULL;
 }
 
 bool ScribeWnd::OnMailStore(LMailStore **MailStore, bool Add)
 {
 	if (!MailStore)
 	{
 		LAssert(!"No mail store pointer?");
 		return false;
 	}
 	
 	if (Add)
 	{
 		*MailStore = &Folders.New();
 		if (*MailStore)
 			return true;
 	}
 	else
 	{
 		ssize_t Idx = *MailStore - &Folders[0];
 		if (Idx >= 0 && Idx < (ssize_t)Folders.Length())
 		{
 			Folders.DeleteAt(Idx, true);
 			*MailStore = NULL;
 			return true;
 		}
 		else
 		{
 			LAssert(!"Index out of range.");
 		}
 	}
 	
 	return false;
 }
 
 LMailStore *ScribeWnd::GetMailStoreForPath(const char *Path)
 {
 	if (!Path)
 		return NULL;
 
 	auto t = LString(Path).SplitDelimit("/");
 	if (t.Length() > 0)
 	{
 		const char *First = t[0];
 		
 		// Find the mail store that that t[0] refers to
 		for (unsigned i=0; i<Folders.Length(); i++)
 		{
 			if (Folders[i].IsOk())
 			{
 				const char *RootStr = Folders[i].Root->GetText();
 				if (RootStr && !_stricmp(RootStr, First))
 				{
 					return &Folders[i];
 				}
 			}
 		}
 	}
 	
 	return NULL;
 }
 
 ScribeFolder *ScribeWnd::GetFolder(const char *Name, LMailStore *s)
 {
 	ScribeFolder *Folder = 0;
 
 	if (ValidStr(Name))
 	{
 		LString Sep("/");
 		auto t = LString(Name).Split(Sep);
 		LMailStore tmp;
 		LString TmpName;
 
 		if (t.Length() > 0)
 		{
 			if (!s)
 			{
 				s = GetMailStoreForPath(Name);
 				if (!s)
 				{
 					// IMAP folders?
 					for (auto a: Accounts)
 					{
 						ScribeProtocol Proto = a->Receive.ProtocolType();
 						if (Proto == ProtocolImapFull)
 						{
 							ScribeFolder *Root = a->Receive.GetRootFolder();
 							if (Root)
 							{
 								const char *RootStr = Root->GetText();
 								if (RootStr &&
 									a->Receive.GetDataStore() &&
 									!_stricmp(RootStr, t[0]))
 								{
 									tmp.Root = Root;
 									tmp.Store = a->Receive.GetDataStore();
 									s = &tmp;
 									break;
 								}
 							}
 						}
 					}
 				}
 				if (s)
 				{
 					if (*Name == '/') Name++;
 					Name = strchr(Name, '/');
 					if (!Name)
 						Name = "/";
 				}
 			}
 			else if (s->Root)
 			{
 				// Check if the store name is on the start of the folder
 				auto RootName = s->Root->GetName(true);
 				if (RootName.Equals(t[0]))
 				{
 					LString::Array a;
 					for (unsigned i=1; i<t.Length(); i++)
 					{
 						a.New() = t[i];
 					}
 					TmpName = Sep.Join(a);
 					Name = TmpName;
 				}
 			}
 		}
 
 		if (!s)
 		{
 			s = GetDefaultMailStore();
 		}
 
 		if (s && Name)
 		{
 			if (_stricmp(Name, "/") == 0)
 				return s->Root;
 		
 			Folder = s->Root ? s->Root->GetSubFolder(Name) : 0;
 		}
 	}
 
 	return Folder;
 }
 
 void ScribeWnd::Update(int What)
 {
 	if (What & UPDATE_TREE)
 	{
 		Tree->Invalidate();
 		return;
 	}
 
 	if (What & UPDATE_LIST)
 	{
 		if (MailList) MailList->Invalidate();
 		return;
 	}
 }
 
 void ScribeWnd::DoDebug(char *s)
 {
 }
 
 Thing *ScribeWnd::CreateThingOfType(Store3ItemTypes Type, LDataI *obj)
 {
 	Thing *t = NULL;
 	switch (Type)
 	{
 		case MAGIC_CONTACT:
 		{
 			t = new Contact(this, obj);
 			break;
 		}
 		case MAGIC_MAIL:
 		{
 			t = new Mail(this, obj);
 			break;
 		}
 		case MAGIC_ATTACHMENT:
 		{
 			t = new Attachment(this, obj);
 			break;
 		}
 		case MAGIC_FILTER:
 		{
 			t = new Filter(this, obj);
 			break;
 		}
 		case MAGIC_CALENDAR:
 		{
 			t = new Calendar(this, obj);
 			break;
 		}
 		case MAGIC_GROUP:
 		{
 			t = new ContactGroup(this, obj);
 			break;
 		}
 		default:
 			break;
 	}
 
 	if (t)
 	{
 		t->App = this;
 	}
 
 	return t;
 }
 
 void ScribeWnd::GetFilters(List<Filter> &Filters, bool JustIn, bool JustOut, bool JustInternal)
 {
 	auto Srcs = GetThingSources(MAGIC_FILTER);
 	for (auto f: Srcs)
 	{
 		for (auto t: f->Items)
 		{
 			Filter *Ftr = t->IsFilter();
 			if (Ftr)
 			{
 				if (JustIn && !Ftr->GetIncoming())
 					continue;
 
 				if (JustOut && !Ftr->GetOutgoing())
 					continue;
 				
 				if (JustInternal && !Ftr->GetInternal())
 					continue;
 
 				Filters.Insert(Ftr);
 			}
 		}
 	}
 
 	extern int FilterCompare(Filter *a, Filter *b, NativeInt Data);
 	Filters.Sort(FilterCompare);
 }
 
 bool ScribeWnd::ShowToolbarText()
 {
 	LVariant i;
 	if (GetOptions()->GetValue(OPT_ToolbarText, i))
 	{
 		return i.CastInt32() != 0;
 	}
 
 	GetOptions()->SetValue(OPT_ToolbarText, i = true);
 	return true;
 }
 
 void ScribeWnd::HashContacts(LHashTbl<StrKey<char,false>,Contact*> &Contacts, ScribeFolder *Folder, bool Deep)
 {
 	if (!Folder)
 	{
 		// Default item is the contacts folder
 		Folder = GetFolder(FOLDER_CONTACTS);
 
 		// Also look at all the contact sources...
 		auto Srcs = GetThingSources(MAGIC_CONTACT);
 		for (auto Src: Srcs)
 		{
 			for (auto t: Src->Items)
 			{
 				Contact *c = t->IsContact();
 				if (!c)
 					continue;
 
 				auto emails = c->GetEmails();
 				for (auto e: emails)
 				{
 					if (!Contacts.Find(e))
 						Contacts.Add(e, c);
 				}
 			}
 		}
 	}
 
 	// recurse through each folder and make a list
 	// of every contact object we find.
 	if (Folder)
 	{
 		Folder->LoadThings();
 
 		for (auto t: Folder->Items)
 		{
 			Contact *c = t->IsContact();
 			if (c)
 			{
 				auto Emails = c->GetEmails();
 				for (auto e: Emails)
 					if (e && !Contacts.Find(e))
 						Contacts.Add(e, c);
 			}
 		}
 
 		for (auto f = Folder->GetChildFolder(); Deep && f; f = f->GetNextFolder())
 		{
 			HashContacts(Contacts, f, Deep);
 		}
 	}
 }
 
 List<Contact> *ScribeWnd::GetEveryone()
 {
 	return &Contact::Everyone;
 }
 
 bool ScribeWnd::GetContacts(List<Contact> &Contacts, ScribeFolder *Folder, bool Deep)
 {
 	LArray<ScribeFolder*> Folders;
 
 	if (!Folder)
 	{
 		Folders = GetThingSources(MAGIC_CONTACT);
 		auto f = GetFolder(FOLDER_CONTACTS);
 		if (f && !Folders.HasItem(f))
 			Folders.Add(f);
 	}
 	else
 		Folders.Add(Folder);
 
 	if (!Folders.Length())
 		return false;
 
 	for (auto f: Folders)
 	{
 		// recurse through each folder and make a list
 		// of every contact object we find.
 		ScribePerm Perm = f->GetFolderPerms(ScribeReadAccess);
 		bool Safe = CurrentAuthLevel >= Perm;
 		if (Safe)
 		{
 			f->LoadThings();
 	
 			for (auto t: f->Items)
 			{
 				Contact *c = t->IsContact();
 				if (c)
 					Contacts.Insert(c);
 			}
 
 			for (ScribeFolder *c = f->GetChildFolder(); Deep && c; c = c->GetNextFolder())
 				GetContacts(Contacts, c, Deep);
 		}
 	}
 	
 	return true;
 }
 
 /*
 	This function goes through the database and checks for some
 	basic requirements and fixes things up if they aren't ok.
 */
 bool ScribeWnd::ValidateFolder(LMailStore *s, int Id)
 {
 	char OptName[32];
 	sprintf_s(OptName, sizeof(OptName), "Folder-%i", Id);
 	
 	LVariant Path;
 	if (!GetOptions()->GetValue(OptName, Path))
 	{
 		char Opt[256];
 		sprintf_s(Opt, sizeof(Opt), "/%s", DefaultFolderNames[Id]);
 		GetOptions()->SetValue(OptName, Path = Opt);
 	}
 	
 	// If the path name has the store name at the start, strip that off...
 	LString Sep("/");
 	LString::Array Parts = LString(Path.Str()).Split(Sep);
 	if (Parts.Length() > 1)
 	{
 		if (Parts[0].Equals(s->Name))
 		{
 			Parts.DeleteAt(0, true);
 			Path = Sep.Join(Parts);
 		}
 		else
 		{
 			LMailStore *ms = GetMailStoreForPath(Path.Str());
 			if (ms)
 			{
 				s = ms;
 			}
 			else
 			{
 				// Most likely the user has renamed something and broken the
 				// path. Lets just error out instead of creating the wrong folder
 				return false;
 			}			
 		}
 	}
 	
 	// Now resolve the path...
 	ScribeFolder *Folder = GetFolder(Path.Str(), s);
 	if (!Folder)
 	{
 		char *p = Path.Str();
 		if (_strnicmp(p, "/IMAP ", 6) != 0)
 		{
 			LAssert(DefaultFolderTypes[Id] != MAGIC_NONE);
-			Folder = s->Root->CreateSubDirectory(*p=='/'?p+1:p, DefaultFolderTypes[Id]);
+			Folder = s->Root->CreateSubFolder(*p=='/'?p+1:p, DefaultFolderTypes[Id]);
 		}
 	}
 	
 	if (!Folder)
 		return false;
 
 	Folder->SetDefaultFields();
 	return true;
 }
 
 void ScribeWnd::Validate(LMailStore *s)
 {
 	// Check for all the basic folders
 
 	int Errors = 0;	
 	for (SystemFolderInfo *fi = SystemFolders; fi->PathOption; fi++)
 	{
 		bool Check = true;
 		if (fi->HasOption)
 		{
 			LVariant v;
 			if (GetOptions()->GetValue(fi->HasOption, v))
 				Check = v.CastInt32() != 0;
 		}
 		if (Check)
 		{
 			if (!ValidateFolder(s, fi->Id))
 				Errors++;
 		}
 	}
 
 	if (Errors &&
 		LgiMsg(this,
 				"There were errors validating the system folders."
 				"Would you like to review the mail store's system folder paths?",
 				AppName,
 				MB_YESNO) == IDYES)
 	{
 		PostEvent(M_COMMAND, IDM_MANAGE_MAIL_STORES);
 	}
 }
 
 ThingFilter *ScribeWnd::GetThingFilter()
 {
 	return SearchView;
 }
 
 ScribeAccount *ScribeWnd::GetSendAccount()
 {
 	LVariant DefSendAcc = 0;
 
 	if (!GetOptions()->GetValue(OPT_DefaultSendAccount, DefSendAcc))
 	{
 		for (auto a : Accounts)
 			if (a->Send.Server().Str())
 				return a;
 	}
 
 	ScribeAccount *i = Accounts.ItemAt(DefSendAcc.CastInt32());
 	if (i && i->Send.Server().Str())
 		return i;
 
 	return NULL;
 }
 
 LPrinter *ScribeWnd::GetPrinter()
 {
 	if (!d->PrintOptions)
 		d->PrintOptions.Reset(new LPrinter);
 	return d->PrintOptions;
 }
 
 int ScribeWnd::GetActiveThreads()
 {
 	int Status = 0;
 	for (auto i: Accounts)
 	{
 		if (i->IsOnline())
 		{
 			Status++;
 		}
 	}
 	return Status;
 }
 
 class DefaultClientDlg : public LDialog
 {
 public:
 	bool DontWarn;
 	DefaultClientDlg(LView *parent)
 	{
 		DontWarn = false;
 		SetParent(parent);
 		LoadFromResource(IDD_WARN_DEFAULT);
 		MoveToCenter();
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case ID_YES:
 			case ID_NO:
 			{
 				LCheckBox *DW;
 				if (GetViewById(IDC_DONT_WARN, DW))
 				{
 					DontWarn = DW->Value() != 0;
 				}
 				EndModal(Ctrl->GetId() == ID_YES);
 				break;
 			}
 		}
 		return 0;
 	}
 
 };
 
 #if WINNATIVE
 struct DefaultClient
 {
 	char DefIcon[MAX_PATH_LEN];
 	char CmdLine[MAX_PATH_LEN];
 	char DllPath[MAX_PATH_LEN];
 
 	DefaultClient()
 	{
 		auto Exe = LGetExeFile();
 		sprintf_s(DefIcon, sizeof(DefIcon), "%s,1", Exe.Get());
 		sprintf_s(CmdLine, sizeof(CmdLine), "\"%s\" /m \"%%1\"", Exe.Get());
 		LMakePath(DllPath, sizeof(DllPath), Exe, "../ScribeMapi.dll");
 	}
 	
 	bool IsWindowsXp()
 	{
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		if
 		(
 			(
 				Os == LGI_OS_WIN32
 				||
 				Os == LGI_OS_WIN64
 			)
 			&&
 			Ver.Length() > 1
 			&&
 			Ver[0] == 5
 			&&
 			Ver[1] == 1
 		)
 			return true;
 		
 		return false;
 	}
 	
 	bool InstallMailto(bool Write)
 	{
 		LAutoPtr<LRegKey> mailto = CheckKey(Write, "HKCR\\mailto");
 		if (!mailto)
 			return false;
 		if (!CheckString(Write, mailto, NULL, "URL:MailTo Protocol"))
 			return false;
 		
 		LAutoPtr<LRegKey> deficon = CheckKey(Write, "HKCR\\mailto\\DefaultIcon");
 		if (!deficon)
 			return false;
 		if (!CheckString(Write, deficon, NULL, DefIcon))
 			return false;
 
 		LAutoPtr<LRegKey> shell = CheckKey(Write, "HKCR\\mailto\\shell");
 		if (!shell)
 			return false;
 		if (!CheckString(Write, shell, NULL, "open"))
 			return false;
 			
 		LAutoPtr<LRegKey> cmd = CheckKey(Write, "HKCR\\mailto\\shell\\open\\command");
 		if (!cmd)
 			return false;
 		if (!CheckString(Write, cmd, NULL, CmdLine))
 			return false;
 		
 			
 		return true;
 	}
 
 	LAutoPtr<LRegKey> CheckKey(bool Write, const char *Key, ...) const
 	{
 		char Buffer[512];
 		va_list Arg;
 		va_start(Arg, Key);
 		vsprintf_s(Buffer, sizeof(Buffer), Key, Arg);
 		va_end(Arg);
 		
 		LAutoPtr<LRegKey> k(new LRegKey(Write, Buffer));
 		if (k && Write && !k->IsOk())
 		{
 			if (!k->Create())
 			{
 				k.Reset();
 				LgiTrace("%s:%i - Failed to create '%s'\n", _FL, Buffer);
 			}
 		}
 		
 		return k;
 	}
 
 	bool CheckInt(bool Write, LRegKey *k, const char *Name, uint32_t Value)
 	{
 		if (!k)
 		{
 			LgiTrace("%s:%i - No key: '%s'\n", _FL, Name);
 			return false;
 		}
 
 		uint32_t Cur;
 		if (!k->GetInt(Name, Cur))
 			Cur = Value + 1;
 		
 		if (Cur == Value)
 			return true;
 
 		if (Write)
 		{
 			bool Status = k->SetInt(Name, Value);
 			if (!Status)
 				LgiTrace("%s:%i - Failed to set key '%s': '%s' to %i\n", _FL, k->Name(), Name, Value);
 			return Status;
 		}
 		
 		return false;
 	}
 	
 	bool CheckString(bool Write, LRegKey *k, const char *StrName, const char *StrValue)
 	{
 		if (!k)
 		{
 			LgiTrace("%s:%i - No key: '%s' to '%s'\n", _FL, StrName, StrValue);
 			return false;
 		}
 
 		LString v;
 		if (k->GetStr(StrName, v))
 		{
 			bool Same = Stricmp(v.Get(), StrValue) == 0;
 			if (Write && !Same)
 			{
 				bool Status = k->SetStr(StrName, StrValue);
 				if (!Status)
 					LgiTrace("%s:%i - Failed to set key '%s': '%s' to '%s'\n", _FL, k->Name(), StrName, StrValue);
 				return Status;
 			}
 			
 			return Same;
 		}
 		else if (Write)
 		{
 			bool Status = k->SetStr(StrName, StrValue);
 			if (!Status)
 				LgiTrace("%s:%i - Failed to set key '%s': '%s' to '%s'\n", _FL, k->Name(), StrName, StrValue);
 			return Status;
 		}
 		
 		return false;
 	}
 
 	bool IsDefault()
 	{
 		LAutoPtr<LRegKey> mail = CheckKey(false, "HKCU\\Software\\Clients\\Mail");
 		if (!mail)
 			return false;
 		
 		LString v;
 		if (!mail->GetStr(NULL, v))
 			return false;
 		
 		return !_stricmp(v, "Scribe");
 	}
 
 	bool SetDefault() const
 	{
 		LAutoPtr<LRegKey> mail = CheckKey(true, "HKCU\\Software\\Clients\\Mail");
 		if (!mail)
 			return false;
 			
 		// Set the default client in the current user tree.
 		mail->SetStr(NULL, "Scribe");
 
 		// Configure the mailto handler
 		const char *Base = "HKEY_ROOT";
 		bool Error = false;
 		LRegKey Mt(true, "%s\\mailto", Base);
 		if (Mt.IsOk() || Mt.Create())
 		{
 			if (!Mt.SetStr(0, "URL:MailTo Protocol") ||
 				!Mt.SetStr("URL Protocol", ""))
 				Error = true;
 		}
 		else
 		{
 			LgiTrace("%s:%i - Couldn't open/create registry key (err=%i).\n", _FL, GetLastError());
 			Error = true;
 		}
 
 		LRegKey Di(true, "%s\\mailto\\DefaultIcon", Base);
 		if (Di.IsOk() || Di.Create())
 		{
 			if (!Di.SetStr(0, DefIcon))
 				Error = true;
 		}
 		else
 		{
 			LgiTrace("%s:%i - Couldn't open/create registry key (err=%i).\n", _FL, GetLastError());
 			Error = true;
 		}
 
 		LRegKey c(true, "%s\\mailto\\shell\\open\\command", Base);
 		if (c.IsOk() || c.Create())
 		{
 			if (!c.SetStr(NULL, CmdLine))
 				Error = true;
 		}
 		else
 		{
 			LgiTrace("%s:%i - Couldn't open/create registry key (err=%i).\n", _FL, GetLastError());
 			Error = true;
 		}
 		
 		return Error;
 	}
 
 	bool InstallAsClient(char *Base, bool Write)
 	{
 		// Create software client entry, to put Scribe in the Internet Options for mail clients.
 		LAutoPtr<LRegKey> mail = CheckKey(Write, "%s\\Software\\Clients\\Mail", Base);
 		if (!mail)
 			return false;
 
 		LAutoPtr<LRegKey> app = CheckKey(Write, "%s\\Software\\Clients\\Mail\\Scribe", Base);
 		if (!app)
 			return false;
 		if (!CheckString(Write, app, NULL, AppName))
 			return false;
 		if (!CheckString(Write, app, "DllPath", DllPath))
 			return false;
 
 		LAutoPtr<LRegKey> shell = CheckKey(Write, "%s\\Software\\Clients\\Mail\\Scribe\\shell\\open\\command", Base);
 		if (!shell)
 			return false;
 		if (!CheckString(Write, shell, NULL, CmdLine))
 			return false;
 
 		LAutoPtr<LRegKey> icon = CheckKey(Write, "%s\\Software\\Clients\\Mail\\Scribe\\DefaultIcon", Base);
 		if (!icon)
 			return false;
 		if (!CheckString(Write, icon, NULL, DefIcon))
 			return false;
 
 		LAutoPtr<LRegKey> proto = CheckKey(Write, "%s\\Software\\Classes\\Protocol\\mailto", Base);
 		if (!proto)
 			return false;
 		if (!CheckString(Write, proto, NULL, "URL:MailTo Protocol"))
 			return false;
 		if (!CheckString(Write, proto, "URL Protocol", ""))
 			return false;
 		if (!CheckInt(Write, proto, "EditFlags", 0x2))
 			return false;
 
 		LAutoPtr<LRegKey> proto_cmd = CheckKey(Write, "%s\\Software\\Classes\\Protocol\\mailto\\shell\\open\\command", Base);
 		if (!proto_cmd)
 			return false;
 		if (!CheckString(Write, proto_cmd, NULL, CmdLine))
 			return false;
 		
 		return true;
 	}
 	
 	struct FileType
 	{
 		char *Name;
 		char *Desc;
 		int Icon;
 	};
 	
 	static FileType FileTypes[];
 	
 	bool Win7Install(bool Write)
 	{
 		// http://msdn.microsoft.com/en-us/library/windows/desktop/cc144154%28v=vs.85%29.aspx
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		if
 		(
 			(
 				Os == LGI_OS_WIN32
 				||
 				Os == LGI_OS_WIN64
 			)
 			&&
 			Ver[0] >= 6)
 		{
 			char Path[MAX_PATH_LEN];
 			auto Exe = LGetExeFile();
 
 			for (int i=0; FileTypes[i].Name; i++)
 			{
 				LAutoPtr<LRegKey> base = CheckKey(Write, "HKEY_CLASSES_ROOT\\%s", FileTypes[i].Name);
 				if (!base)
 					return false;
 				if (!CheckString(Write, base, NULL, FileTypes[i].Desc))
 					return false;
 
 				LAutoPtr<LRegKey> r = CheckKey(Write, "HKEY_CLASSES_ROOT\\%s\\shell\\Open\\command", FileTypes[i].Name);
 				if (!r)
 					return false;
 				sprintf_s(Path, sizeof(Path), "\"%s\" -u \"%%1\"", Exe.Get());
 				if (!CheckString(Write, r, NULL, Path))
 					return false;
 
 				LAutoPtr<LRegKey> ico = CheckKey(Write, "HKEY_CLASSES_ROOT\\%s\\DefaultIcon", FileTypes[i].Name);
 				if (!ico)
 					return false;
 				sprintf_s(Path, sizeof(Path), "%s,%i", Exe.Get(), FileTypes[i].Icon);
 				if (!CheckString(Write, ico, NULL, Path))
 					return false;
 			}
 			
 			LAutoPtr<LRegKey> r = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities");
 			if (!r)
 				return false;
 			if (!CheckString(Write, r, "ApplicationDescription", "Scribe is a small lightweight email client.") &&
 				!CheckString(Write, r, "ApplicationName", "Scribe") &&
 				!CheckString(Write, r, "ApplicationIcon", DefIcon))
 				return false;
 			
 			LAutoPtr<LRegKey> as = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities\\FileAssociations");
 			if (!as)
 				return false;
 			if (!CheckString(Write, as, ".eml", "Scribe.Email") &&
 				!CheckString(Write, as, ".msg", "Scribe.Email") &&
 				!CheckString(Write, as, ".mbox", "Scribe.Folder") &&
 				!CheckString(Write, as, ".mbx", "Scribe.Folder") &&
 				!CheckString(Write, as, ".ics", "Scribe.Calendar") &&
 				!CheckString(Write, as, ".vcs", "Scribe.Calendar") &&
 				!CheckString(Write, as, ".vcf", "Scribe.Contact") &&
 				!CheckString(Write, as, ".mail3", "Scribe.MailStore"))
 				return false;
 
 			LAutoPtr<LRegKey> ua = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities\\UrlAssociations");
 			if (!ua)
 				return false;
 			if (!CheckString(Write, ua, "mailto", "Scribe.Mailto"))
 				return false;
 			
 			LAutoPtr<LRegKey> a = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\RegisteredApplications");
 			if (!a)
 				return false;
 			if (!CheckString(Write, a, "Scribe", "SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities"))
 				return false;
 		}
 		
 		return true;
 	}
 
 	void Win7Uninstall()
 	{
 		for (int i=0; FileTypes[i].Name; i++)
 		{
 			LRegKey base(true, "HKEY_CLASSES_ROOT\\%s", FileTypes[i].Name);
 			base.DeleteKey();
 		}
 	}
 };
 
 DefaultClient::FileType DefaultClient::FileTypes[] =
 {
 	{ "Scribe.Email", "Email", 2 },
 	{ "Scribe.Folder", "Mailbox", 0 },
 	{ "Scribe.Calendar", "Calendar Event", 6 },
 	{ "Scribe.Contact", "Contact", 4 },
 	{ "Scribe.MailStore", "Mail Store", 0 },
 	{ "Scribe.Mailto", "Mailto Protocol", 0 },
 	{ 0, 0 }
 };
 #endif
 
 void ScribeWnd::SetDefaultHandler()
 {
 	#if WINNATIVE
 
 	if (LAppInst->GetOption("noreg"))
 		return;
 		
 	LVariant RegisterClient;
 	if (!GetOptions()->GetValue(OPT_RegisterWindowsClient, RegisterClient))
 		RegisterClient = true;
 	
 	if (!RegisterClient.CastInt32())
 		return;
 
 	// Create IE mail client entries for local machine and current user
 	DefaultClient Def;
 	bool OldAssert = LRegKey::AssertOnError;
 	LRegKey::AssertOnError = false;
 	bool RegistryOk =	(
 							!Def.IsWindowsXp()
 							||
 							Def.InstallMailto(true)
 						)
 						&&
 						Def.InstallAsClient("HKLM", true)
 						&&
 						Def.Win7Install(true);
 	LRegKey::AssertOnError = OldAssert;
 	if (!RegistryOk)
 	{
 		// Need write permissions to fix up the registry?
 		NeedsCapability("RegistryWritePermissions");
 		return;
 	}
 
 	// Check if the user wants us to be the default client
 	LVariant n = true;
 	GetOptions()->GetValue(OPT_CheckDefaultEmail, n);
 	if (n.CastInt32())
 	{
 		// HKEY_CURRENT_USER\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\mailto\UserChoice
 		
 		LRegKey::AssertOnError = false;
 		bool IsDef = Def.IsDefault();
 		if (!IsDef)
 		{
 			// Ask the user...
 			auto Dlg = new DefaultClientDlg(this);
 			Dlg->DoModal([this, Dlg, Def, OldAssert](auto dlg, auto id)
 			{
 				if (id)
 				{
 					auto Error = !Def.SetDefault();
 					LVariant v;
 					GetOptions()->SetValue(OPT_CheckDefaultEmail, v = (int) (!Dlg->DontWarn));
 					OnSetDefaultHandler(Error, OldAssert);
 				}
 				delete dlg;
 			});
 		}
 		else OnSetDefaultHandler(false, OldAssert);
 	}
 
 	#endif
 }
 
 void ScribeWnd::OnSetDefaultHandler(bool Error, bool OldAssert)
 {
 	#if WINDOWS
 	LRegKey::AssertOnError = OldAssert;
 	#endif
 	if (Error)
 		NeedsCapability("RegistryWritePermissions");
 }
 
 void ScribeWnd::OnSelect(List<Thing> *l, bool ChangeEvent)
 {
 	Mail *m = (l && l->Length() == 1) ? (*l)[0]->IsMail() : 0;
 
 	if (Commands)
 	{
 		bool NotCreated = m && !TestFlag(m->GetFlags(), MAIL_CREATED);
 
 		Commands->SetCtrlEnabled(IDM_DELETE, l && l->Length() > 0);
 		Commands->SetCtrlEnabled(IDM_DELETE_AS_SPAM, l && l->Length() > 0);
 		Commands->SetCtrlEnabled(IDM_PRINT, l && l->Length() == 1);
 		
 		Commands->SetCtrlEnabled(IDM_REPLY, NotCreated);
 		Commands->SetCtrlEnabled(IDM_REPLY_ALL, NotCreated);
 		Commands->SetCtrlEnabled(IDM_FORWARD, m != 0);
 		Commands->SetCtrlEnabled(IDM_BOUNCE, m != 0);
 	}
 
 	if (PreviewPanel && GetEffectiveLayoutMode() != 3)
 	{
 		if (!PreviewPanel->IsAttached())
 		{
 			SetItemPreview(PreviewPanel);
 		}
 
 		Thing *t = (l && l->Length() == 1) ? (*l)[0] : 0;
 		PreviewPanel->OnThing(t, ChangeEvent);
 		
 		/*
 		if (d->Debug)
 			d->Debug->OnThing(t);
 		*/
 	}
 }
 
 class SpellErrorInst
 {
 public:
 	int Id;
 	LString Word;
 	LString::Array Suggestions;
 
 	SpellErrorInst(int id)
 	{
 		Id = id;
 		// Decor = LCss::TextDecorSquiggle;
 		// DecorColour.Rgb(255, 0, 0);		
 	}
 	
 	~SpellErrorInst()
 	{
 	}
 
 	bool OnMenu(LSubMenu *m)
 	{
 		if (Suggestions.Length())
 		{
 			for (unsigned i=0; i<Suggestions.Length() && i<10; i++)
 			{
 				m->AppendItem(Suggestions[i], 100 + i, true);
 			}
 
 			m->AppendSeparator();
 		}
 
 		char Buf[256];
 		sprintf_s(Buf, sizeof(Buf), LLoadString(IDS_ADD_TO_DICTIONARY, "Add '%s' to dictionary"), Word.Get());
 		m->AppendItem(Buf, 1, true);
 		return true;
 	}
 	
 	void OnMenuClick(int i)
 	{
 		if (i == 1)
 		{
 			// Add to dictionary...
 			/*
 			if (PostThreadEvent(SpellHnd, M_ADD_WORD, (LMessage::Param) new LString(Word)))
 			{
 				// FIXME
 				LAssert(!"Impl me.");
 				// View->PostEvent(M_DELETE_STYLE, (LMessage::Param) dynamic_cast<LTextView3::LStyle*>(this));
 			}
 			*/
 		}
 		else if (i >= 100 && i < 100 + (int)Suggestions.Length())
 		{
 			// Change spelling..
 			char *Replace = Suggestions[i - 100];
 			if (Replace)
 			{
 				char16 *w = Utf8ToWide(Replace);
 				if (w)
 				{
 					/*
 					int NewLen = StrlenW(w);
 					if (NewLen > Len)
 					{
 						// Bigger...
 						memcpy(View->NameW() + Start, w, Len * sizeof(char16));
 						View->Insert(Start + Len, w + Len, NewLen - Len);
 					}
 					else if (NewLen < Len)
 					{
 						// Smaller...
 						memcpy(View->NameW() + Start, w, NewLen * sizeof(char16));
 						View->Delete(Start + NewLen, Len - NewLen);
 					}
 					else
 					{
 						// Just copy...
 						memcpy(View->NameW() + Start, w, Len * sizeof(char16));
 						RefreshLayout(Start, Len);
 					}
 					*/
 
 					DeleteArray(w);
 				}
 			}
 		}
 	}
 };
 
 class MailTextView : public LTextView3
 {
 	ScribeWnd *App;
 	LSpellCheck *Thread;
 	LColour c[8];
 	LHashTbl<IntKey<int>, SpellErrorInst*> ErrMap;
 
 	SpellErrorInst *NewErrorInst()
 	{
 		int Id;
 		while (ErrMap.Find(Id = LRand(10000)))
 			;
 		SpellErrorInst *Inst = new SpellErrorInst(Id);
 		if (!Inst) return NULL;
 		ErrMap.Add(Id, Inst);
 		return Inst;
 	}
 
 public:
 	MailTextView(ScribeWnd *app, int Id, int x, int y, int cx, int cy, LFontType *FontType) :
 		LTextView3(Id, x, y, cx, cy, FontType)
 	{
 		App = app;
 		Thread = 0;
 
 		int i=0;
 		c[i++].Rgb(0x80, 0, 0);
 		c[i++].Rgb(0, 0x80, 0);
 		c[i++].Rgb(0, 0, 0x80);
 		c[i++].Rgb(0x80, 0x80, 0);
 		c[i++].Rgb(0x80, 0, 0x80);
 		c[i++].Rgb(0, 0x80, 0x80);
 		c[i++].Rgb(0x80, 0x80, 0x80);
 		c[i++].Rgb(0xc0, 0xc0, 0xc0);
 
 		for (i=0; i<CountOf(c); i++)
 		{
 			char s[64];
 			sprintf_s(s, sizeof(s), "colour-LC_REPLY_LVL_%i", i + 1);
 			LColour::GetConfigColour(s, c[i]);
 		}
 	}
 
 	~MailTextView()
 	{
 	}
 
 	void PourStyle(size_t Start, ssize_t Length)
 	{
 		LTextView3::PourStyle(Start, Length);
 
 		if (!GetReadOnly())
 		{
 			ssize_t Origin = Start;
 			ssize_t Len = Length;
 			while (Start > 0 && !StrchrW(SpellDelim, Text[Start-1]))
 				Start--;
 
 			if (Len > 0)
 			{
 				// Text being added
 				Len += Origin - Start;
 				while ((ssize_t)Start + Len < Size && !StrchrW(SpellDelim, Text[Start + Len]))
 					Len++;
 			}
 			else if (Len < 0)
 			{
 				// Text being deleted
 				Len = Origin - Start;
 				while ((ssize_t)Start + Len < Size && !StrchrW(SpellDelim, Text[Start + Len]))
 					Len++;
 			}
 
 			if (!Thread)
 				Thread = App->GetSpellThread();
 			if (Thread && Len > 0)
 			{
 				LString Str(Text+Start, Len);
 				LArray<LVariant> Params;
 				Thread->Check(AddDispatch(), Str, Start, Len, &Params);
 			}
 
 			// Adjust all the positions of the styles after this.
 			for (auto s = Style.begin(); s != Style.end(); )
 			{
 				if (s->Start >= Origin &&
 					s->Owner == 1)
 				{
 					if (Length < 0 &&
 						s->Start < Origin - Length)
 					{
 						// In the deleted text...
 						Style.Delete(s);
 						continue;
 					}
 
 					// After the deleted text
 					s->Start += Length;
 					LAssert(s->Start >= 0);
 				}
 
 				s++;
 			}
 		}
 	}
 
 	void PourText(size_t Start, ssize_t Len)
 	{
 		LTextView3::PourText(Start, Len);
 
 		for (auto l: Line)
 		{
 			int n=0;
 			char16 *t = Text + l->Start;
 			char16 *e = t + l->Len;
 			while ((*t == ' ' || *t == '>') && t < e)
 				if (*t++ == '>') n++;
 
 			if (n > 0)
 				l->c = c[(n-1)%CountOf(c)];
 		}
 	}
 
 	LMessage::Result OnEvent(LMessage *m)
 	{
 		switch (m->Msg())
 		{
 			case M_CHECK_TEXT:
 			{
 				LAutoPtr<LSpellCheck::CheckText> Ct((LSpellCheck::CheckText*)m->A());
 				if (!Ct || !Thread)
 					break;
 				
 				// Clear existing spelling error styles
 				ssize_t Start = Ct->Start;
 				ssize_t End = Start + Ct->Len;
 				for (auto i = Style.begin(); i != Style.end(); )
 				{
 					if (i->End() < (size_t)Start ||
 						i->Start >= End)
 					{
 						// Outside the area we are re-styling.
 						i++;
 					}
 					else
 					{
 						if (i->Owner == STYLE_SPELLING)
 						{
 							// Existing error style inside the area
 							Style.Delete(i);
 						}
 						else
 						{
 							// Existing non-error style...
 							i++;
 						}
 					}
 				}
 
 				// Insert the new styles
 				for (auto Ct: Ct->Errors)
 				{
 					SpellErrorInst *ErrInst = NewErrorInst();
 					LAutoPtr<LTextView3::LStyle> Style(new LTextView3::LStyle(STYLE_SPELLING));
 					if (Style && ErrInst)
 					{
 						Style->View = this;
 						Style->Start = Ct.Start;
 						Style->Len = Ct.Len;
 						Style->Font = GetFont();
 						Style->Data = ErrInst->Id;
 						Style->DecorColour = LColour::Red;
 						Style->Decor = LCss::TextDecorSquiggle;
 
 						ErrInst->Word = LString(Text + Style->Start, Style->End());
 						ErrInst->Suggestions = Ct.Suggestions;
 						
 						InsertStyle(Style);
 					}
 				}
 
 				// Update the screen...
 				Invalidate();
 				break;
 			}
 			case M_DELETE_STYLE:
 			{
 				/*
 				LTextView3::LStyle *s = (LTextView3::LStyle*)m->A();
 				if (s && Style.HasItem(s))
 				{
 					Style.Delete(s);
 					Invalidate();
 				}
 				else LAssert(0);
 				*/
 				break;
 			}
 		}
 
 		return LTextView3::OnEvent(m);
 	}
 
 	bool OnStyleClick(LStyle *style, LMouse *m)
 	{
 		switch (style->Owner)
 		{
 			case STYLE_URL:
 			{
 				if (m->Left() &&
 					m->Down() &&
 					m->Double())
 				{
 					LString s(Text + style->Start, style->Len);
 					LUri u(s);
 					if
 					(
 						(u.sProtocol && !_stricmp(u.sProtocol, "mailto"))
 						||
 						LIsValidEmail(s)
 					)
 					{
 						Mailto m(App, s);
 						Mail *email = App->CreateMail();
 						if (email)
 						{
 							m.Apply(email);
 							email->DoUI();
 							return true;
 						}
 					}
 					else
 					{
 						// Web link?
 						LExecute(s);
 					}
 				}
 				break;
 			}
 			default:
 				return false;
 		}
 
 		return true;
 	}
 };
 
 LDocView *ScribeWnd::CreateTextControl(int Id, const char *MimeType, bool Editor, Mail *m)
 {
 	LDocView *Ctrl = 0;
 	
 	// Get the default font
 	LFontType FontType;
 	bool UseFont = FontType.Serialize(GetOptions(), OPT_EditorFont, false);
 
 	if (Editor)
 	{
 		if (!Stricmp(MimeType, sTextHtml))
 		{		
 			// Use the built in html editor
 			LRichTextEdit *Rte;
 			if ((Ctrl = Rte = new LRichTextEdit(Id)))
 			{
 				if (UseFont)
 					Ctrl->SetFont(FontType.Create(), true);
 				
 				// Give the control the speller settings:
 				LVariant Check, Lang, Dict;
 				if (GetOptions()->GetValue(OPT_SpellCheck, Check) &&
 					Check.CastInt32() != 0)
 				{
 					if (GetOptions()->GetValue(OPT_SpellCheckLanguage, Lang))
 						Rte->SetValue(LDomPropToString(SpellCheckLanguage), Lang);
 					if (GetOptions()->GetValue(OPT_SpellCheckDictionary, Dict))
 						Rte->SetValue(LDomPropToString(SpellCheckDictionary), Dict);
 					
 					
 					// Set the spell thread:
 					LSpellCheck *t = GetSpellThread();
 					if (t)
 						Rte->SetSpellCheck(t);
 				}
 			}
 		}
 		else
 		{
 			// Use the built in plain text editor
 			Ctrl = new MailTextView(this, Id, 0, 0, 200, 200, (UseFont) ? &FontType : 0);
 		}
 	}
 	else
 	{
 		// Create a view only control for the mime type:
 		LDocView *HtmlCtrl = NULL;
 		if (!MimeType ||
 			!Stricmp(MimeType, sTextPlain) ||
 			!Stricmp(MimeType, sMultipartEncrypted))
 		{
 			Ctrl = new MailTextView(this, Id, 0, 0, 200, 200, (UseFont) ? &FontType : 0);
 		}
 		else
 		{
 			HtmlCtrl = Ctrl = new Html1::LHtml(Id, 0, 0, 200, 200);
 		}
 		
 		if (HtmlCtrl && UseFont)
 		{
 			LVariant LoadImg;
 			if (GetOptions()->GetValue(OPT_HtmlLoadImages, LoadImg))
 				HtmlCtrl->SetLoadImages(LoadImg.CastInt32() != 0);
 			HtmlCtrl->SetFont(FontType.Create(), true);
 		}
 	}
 
 	if (Ctrl)
 	{
 		Ctrl->SetUrlDetect(true);
 		Ctrl->SetAutoIndent(true);
 
 		LVariant WrapOption;
 		if (GetOptions()->GetValue(OPT_WordWrap, WrapOption))
 		{
 			if (WrapOption.CastInt32())
 			{
 				LVariant WrapCols = 80;
 				GetOptions()->GetValue(OPT_WrapAtColumn, WrapCols);
 				Ctrl->SetWrapAtCol(WrapCols.CastInt32());
 			}
 			else
 			{
 				Ctrl->SetWrapAtCol(0);
 			}
 		}
 	}
 
 	return Ctrl;
 }
 
 void ScribeWnd::GrowlInfo(LString title, LString text)
 {
 	LGrowl *g = d->GetGrowl();
 	if (!g)
 		return;
 
 	LAutoPtr<LGrowl::LNotify> n(new LGrowl::LNotify);
 	n->Name = "info";
 	n->Title = title;
 	n->Text = text;
 	g->Notify(n);
 }
 
 void ScribeWnd::GrowlOnMail(Mail *m)
 {
 	LVariant v;
 	LAutoPtr<LGrowl::LNotify> n(new LGrowl::LNotify);
 	n->Name = "new-mail";
 	n->Title = m->GetSubject();
 	
 	int Len = 64;
 	char sLen[16];
 	sprintf_s(sLen, sizeof(sLen), "%i", Len);
 	if (m->GetVariant("BodyAsText", v, sLen))
 	{
 		char *s = v.Str();
 		if (s)
 		{
 			int Words = 0;
 			bool Lut[256];
 			memset(Lut, 0, sizeof(Lut));
 			Lut[(int)' '] = Lut[(int)'\t'] = Lut[(int)'\r'] = Lut[(int)'\n'] = true;
 			char *c;
 			for (c = s; *c && Words < 30; )
 			{
 				while (*c && Lut[(int)*c]) c++;
 				while (*c && !Lut[(int)*c]) c++;
 				Words++;
 			}
 			
 			n->Text.Set(s, c - s);
 		}
 	}
 	
 	LGrowl *g = d->GetGrowl();
 	if (g)
 	{
 		g->Notify(n);
 		m->NewEmail = Mail::NewEmailTray;
 	}
 }
 
 void ScribeWnd::OnNewMailSound()
 {
 	static uint64 PrevTs = 0;
 	auto Now = LCurrentTime();
 	if (Now - PrevTs > 30000)
 	{
 		PrevTs = Now;
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_NewMailSoundFile, v) &&
 			LFileExists(v.Str()))
 		{
 			LPlaySound(v.Str(), SND_ASYNC);
 		}
 	}
 }
 
 void ScribeWnd::OnFolderSelect(ScribeFolder *f)
 {
 	if (SearchView)
 		SearchView->OnFolder();
 }
 
 void ScribeWnd::OnNewMail(List<Mail> *MailObjs, bool Add)
 {
 	if (!MailObjs)
 		return;
 
 	LVariant v;
 	bool ShowDetail = MailObjs->Length() < 5;
 	List<Mail> NeedsFiltering;
 	LArray<Mail*> NeedsBayes;
 	LArray<Mail*> NeedsGrowl;
 	LArray<ScribeFolder*> Resort;
 
 	for (auto m: *MailObjs)
 	{
 		if (Add)
 		{
 			#if DEBUG_NEW_MAIL
 			LgiTrace("%s:%i - NewMail.OnNewMail t=%p, uid=%s, mode=%s\n",
 				_FL, (Thing*)m, m->GetServerUid().ToString().Get(), toString(m->NewEmail));
 			#endif
 
 			switch (m->NewEmail)
 			{
 				case Mail::NewEmailNone:
 				{
 					auto Loaded = m->GetLoaded();
 					#if DEBUG_NEW_MAIL
 					LgiTrace("%s:%i - NewMail.OnNewMail.GetLoaded=%i uid=%s\n", _FL, (int)Loaded, m->GetServerUid().ToString().Get());
 					#endif
 					if (Loaded != Store3Loaded)
 					{
 						LOG_STORE("\tOnNewMail calling SetLoaded.\n");
 						m->SetLoaded();
 						m->NewEmail = Mail::NewEmailLoading;
 					}
 					else
 					{
 						m->NewEmail = Mail::NewEmailFilter;
 						LOG_STORE("\tOnNewMail none->NeedsFiltering.\n");
 						NeedsFiltering.Insert(m);
 					}
 					break;
 				}
 				case Mail::NewEmailLoading:
 				{
 					auto Loaded = m->GetLoaded();
 					if (Loaded == Store3Loaded)
 					{
 						m->NewEmail = Mail::NewEmailFilter;
 						NeedsFiltering.Insert(m);
 
 						if (m->GetFolder() &&
 							!Resort.HasItem(m->GetFolder()))
 						{
 							Resort.Add(m->GetFolder());
 						}
 					}
 					break;
 				}
 				case Mail::NewEmailFilter:
 				{
 					NeedsFiltering.Insert(m);
 					break;
 				}
 				case Mail::NewEmailBayes:
 				{
 					NeedsBayes.Add(m);
 					break;
 				}
 				case Mail::NewEmailGrowl:
 				{
 					if (d->Growl)
 					{
 						NeedsGrowl.Add(m);
 						break;
 					}
 					else
 					{
 						m->NewEmail = Mail::NewEmailTray;
 						// no Growl loaded so fall through to new tray mail
 					}
 				}
 				case Mail::NewEmailTray:
 				{
 					LAssert(m->GetObject());
 					Mail::NewMailLst.Insert(m);
 					OnNewMailSound();
 					break;
 				}
 				default:
 				{
 					LAssert(!"Hmmm what happen?");
 					break;
 				}
 			}
 		}
 		else
 		{
 			#if DEBUG_NEW_MAIL
 			LgiTrace("%s:%i - NewMail.OnNewMail.RemoveNewMail t=%p, uid=%s\n",
 				_FL, (Thing*)m, m->GetServerUid().ToString().Get());
 			#endif
 
 			Mail::NewMailLst.Delete(m);
 			
 			if (m->NewEmail == Mail::NewEmailFilter)
 				m->NewEmail = Mail::NewEmailNone;
 		}
 	}
 
 	if (Add)
 	{
 		// Do filtering
 		if (NeedsFiltering.Length())
 		{
 			List<Filter> Filters;
 			if (!GetOptions()->GetValue(OPT_DisableUserFilters, v) ||
 				!v.CastInt32())
 			{
 				GetFilters(Filters, true, false, false);
 			}
 		
 			if (Filters.Length() > 0)
 			{
 				// Run the filters
 				#if DEBUG_NEW_MAIL
 				LgiTrace("%s:%i - NewMail.OnNewMail.Filtering %i mail through %i filters\n",
 					_FL, (int)NeedsFiltering.Length(), (int)Filters.Length());
 				#endif
 				Filter::ApplyFilters(NULL, Filters, NeedsFiltering);
 				
 				// All the email not filtered now needs to be sent to the bayes filter.
 				for (auto m: NeedsFiltering)
 				{
 					if (m->NewEmail == Mail::NewEmailBayes)
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnNewMail.NeedsBayes t=%p, msgid=%s\n",
 							_FL, (Thing*)m, m->GetMessageId());
 						#endif
 
 						NeedsBayes.Add(m);
 					}
 					else if (m->NewEmail == Mail::NewEmailGrowl)
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnNewMail.NeedsGrowl t=%p, msgid=%s\n",
 							_FL, (Thing*)m, m->GetMessageId());
 						#endif
 
 						NeedsGrowl.Add(m);
 					}
 				}
 			}
 		}
 
 		// Do bayes
 		if (NeedsBayes.Length())
 		{
 			ScribeBayesianFilterMode FilterMode = BayesOff;
 			if (GetOptions()->GetValue(OPT_BayesFilterMode, v))
 				FilterMode = (ScribeBayesianFilterMode)v.CastInt32();
 
 			for (unsigned i=0; i<NeedsBayes.Length(); i++)
 			{
 				Mail *m = NeedsBayes[i];
 				if (FilterMode != BayesOff)
 				{
 					double Rating = 0.0;
 					
 					// This adds the mail to a message ID map, so even if it moves we
 					// can do the filtering later on when the Bayesian result is returned.
 					m->MailMessageIdMap();
 					
 					// Start the Bayesian rating process off
 					Store3Status Status = IsSpam(Rating, m);
 					if (Status == Store3Success)
 					{
 						// Bayes done... this stops OnBayesResult from passing it back to OnNewMail
 						m->NewEmail = Mail::NewEmailGrowl;
 						
 						// Process bayes result
 						if (!OnBayesResult(m, Rating))
 						{
 							// Not spam... so on to growl
 							#if DEBUG_NEW_MAIL
 							LgiTrace("%s:%i - NewMail.Bayes.NeedsGrowl t=%p, msgid=%s\n",
 								_FL, (Thing*)m, m->GetMessageId());
 							#endif
 
 							NeedsGrowl.Add(m);
 						}
 						else
 						{
 							// Is spam... do nothing...
 							#if DEBUG_NEW_MAIL
 							LgiTrace("%s:%i - NEW_MAIL: Bayes->IsSpam t=%p, msgid=%s\n",
 								_FL, (Thing*)m, m->GetMessageId());
 							#endif
 
 							m->NewEmail = Mail::NewEmailNone;
 							m = 0;
 						}
 					}
 					else
 					{
 						// Didn't get classified immediately, so it'll be further
 						// processed when OnBayesResult gets called later.
 					}
 				}
 				else
 				{
 					// Bayes filter not active... move it to growl
 					m->NewEmail = Mail::NewEmailGrowl;
 					NeedsGrowl.Add(m);
 				}
 			}
 		}
 
 		if (NeedsGrowl.Length())
 		{
 			if (d->Growl)
 			{
 				if (!ShowDetail)
 				{
 					LAutoPtr<LGrowl::LNotify> n(new LGrowl::LNotify);
 					n->Name = "new-mail";
 					n->Title = "New Mail";
 					n->Text.Printf("%i new messages", (int)MailObjs->Length());
 					d->Growl->Notify(n);
 				}
 				else
 				{
 					for (unsigned i=0; i<NeedsGrowl.Length(); i++)
 					{
 						auto m = NeedsGrowl[i];
 						
 						#ifdef _DEBUG
 						auto state =
 						#endif
 						m->GetLoaded();
 						LAssert(state == Store3Loaded);
 
 						// If loaded then notify			                
 						GrowlOnMail(m);
 					}
 				}
 			}
 
 			for (unsigned i=0; i<NeedsGrowl.Length(); i++)
 			{
 				auto m = NeedsGrowl[i];
 				m->NewEmail = Mail::NewEmailTray;
 
 				#if DEBUG_NEW_MAIL
 				LgiTrace("%s:%i - NewMail.OnNewMail.Growl->Tray t=%p, msgid=%s\n",
 					_FL, (Thing*)m, m->GetMessageId());
 				#endif
 
 				LAssert(m->GetObject());
 				Mail::NewMailLst.Insert(m);
 				OnNewMailSound();
 			}
 		}
 
 		if (GetOptions()->GetValue(OPT_NewMailNotify, v) &&
 			v.CastInt32())
 		{
 			PostEvent(M_SCRIBE_NEW_MAIL);
 		}
 
 		for (unsigned i=0; i<Resort.Length(); i++)
 		{
 			#if DEBUG_NEW_MAIL
 			auto Path = Resort[i]->GetPath();
 			LgiTrace("%s:%i - NewMail.OnNewMail.Resort=%s\n", _FL, Path.Get());
 			#endif
 
 			Resort[i]->ReSort();
 		}
 	}
 }
 
 LColour ScribeWnd::GetColour(int i)
 {
 	static LColour MailPreview;
 	static LColour UnreadCount;
 	#define ReadColDef(Var, Tag, Default)		\
 		case Tag: \
 		{ \
 			if (!Var.IsValid()) \
 			{ \
 				Var = Default; \
 				LColour::GetConfigColour("Colour."#Tag, Var); \
 			} \
 			return Var; \
 			break; \
 		}
 
 	switch (i)
 	{
 		ReadColDef(MailPreview, L_MAIL_PREVIEW, LColour(0, 0, 255));
 		ReadColDef(UnreadCount, L_UNREAD_COUNT, LColour(0, 0, 255));
 		default:
 		{
 			return LColour((LSystemColour)i);
 			break;
 		}
 	}
 
 	return LColour();
 }
 
 bool WriteXmlTag(LStream &p, LXmlTag *t)
 {
 	const char *Tag = t->GetTag();
 	bool ValidTag = ValidStr(Tag) && !IsDigit(Tag[0]);
 	if (ValidTag)
 		p.Print("<%s", Tag);
 	else
 	{
 		LAssert(0);
 		return false;
 	}
 
 	LXmlTree Tree;
 	static const char *EncodeEntitiesAttr	= "\'<>\"\n";
 	for (unsigned i=0; i<t->Attr.Length(); i++)
 	{
 		auto &a = t->Attr[i];
 
 		// Write the attribute name
 		p.Print(" %s=\"", a.GetName());
 		
 		// Encode the value
 		if (!Tree.EncodeEntities(&p, a.GetValue(), -1, EncodeEntitiesAttr))
 		{
 			LAssert(0);
 			return false;
 		}
 
 		// Write the delimiter
 		p.Write((void*)"\"", 1);
 
 		if (i<t->Attr.Length()-1 /*&& TestFlag(d->Flags, GXT_PRETTY_WHITESPACE)*/)
 		{
 			p.Write((void*)"\n", 1);
 		}
 	}
 	
 	p.Write(">", 1);
 	
 	return true;
 }
 
 LString ScribeWnd::ProcessReplyForwardTemplate(Mail *m, Mail *r, char *Xml, int &Cursor, const char *MimeType)
 {
 	LStringPipe p(256);
 
 	if (m && r && Xml)
 	{
 		bool IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 		LMemStream mem(Xml, strlen(Xml));
 		LXmlTag x;
 		LXmlTree t(GXT_KEEP_WHITESPACE | GXT_NO_DOM);
 		if (t.Read(&x, &mem, 0))
 		{
 			ScribeDom Dom(this);
 			Dom.Email = m;
 
 			if (IsHtml)
 			{
 				const char *EncodeEntitiesContent	= "\'<>\"";
 				
 				for (auto Tag: x.Children)
 				{
 					if (!WriteXmlTag(p, Tag))
 					{
 						break;
 					}
 					
 					for (const char *c = Tag->GetContent(); c; )
 					{
 						const char *s = strstr(c, "<?");
 						const char *e = s ? strstr(s + 2, "?>") : NULL;
 						if (s && e)
 						{
 							if (s > c)
 							{
 								t.EncodeEntities(&p, (char*)c, s - c, EncodeEntitiesContent);
 							}
 							s += 2;
 							
 							LString Var = LString(s, e - s).Strip();
 							LVariant v;
 							if (Var)
 							{
 								LString::Array parts = Var.SplitDelimit(" ");
 								if (parts.Length() > 0)
 								{
 									if (Dom.GetValue(parts[0], v))
 									{
 										for (unsigned mod = 1; mod < parts.Length(); mod++)
 										{
 											LString::Array m = parts[mod].SplitDelimit("=", 1);
 											if (m.Length() == 2)
 											{
 												if (m[0].Equals("quote"))
 												{
 													LVariant Quote;
 													if (Dom.GetValue(m[1], Quote))
 													{
 														LVariant WrapColumn;
 														if (!GetOptions()->GetValue(OPT_WrapAtColumn, WrapColumn) ||
 															WrapColumn.CastInt32() <= 0)
 															WrapColumn = 76;
 															
 														WrapAndQuote(p, Quote.Str(), WrapColumn.CastInt32(), v.Str(), NULL, MimeType);
 														v.Empty();
 													}
 												}
 											}
 										}
 										
 										switch (v.Type)
 										{
 											case GV_STRING:
 											{
 												p.Push(v.Str());
 												break;
 											}
 											case GV_DATETIME:
 											{
 												p.Push(v.Value.Date->Get());
 												break;
 											}
 											case GV_NULL:
 												break;
 											default:
 											{
 												LAssert(!"Unsupported type.");
 												break;
 											}
 										}
 									}
 								}
 							}
 							
 							c = e + 2;
 						}
 						else
 						{						
 							p.Print("%s", c);
 							break;
 						}
 					}
 				}
 			}
 			else
 			{			
 				LArray<LXmlTag*> Tags;
 				Tags.Add(&x);
 				for (auto Tag: x.Children)
 				{
 					Tags.Add(Tag);
 				}
 				
 				for (unsigned i=0; i<Tags.Length(); i++)
 				{
 					LXmlTag *Tag = Tags[i];
 					
 					LVariant v;
 					if (Tag->GetTag() && Dom.GetValue(Tag->GetTag(), v))
 					{
 						char *s = v.Str();
 						if (s)
 						{
 							const char *Quote;
 							if ((Quote = Tag->GetAttr("quote")))
 							{
 								LVariant q, IsQuote;
 								GetOptions()->GetValue(OPT_QuoteReply, IsQuote);
 								if (r->GetValue(Quote, q))
 								{
 									Quote = q.Str();
 								}
 								else
 								{
 									Quote = "> ";
 								}
 
 								if (Quote && IsQuote.CastInt32())
 								{
 									LVariant WrapColumn;
 									if (!GetOptions()->GetValue(OPT_WrapAtColumn, WrapColumn) ||
 										WrapColumn.CastInt32() <= 0)
 										WrapColumn = 76;
 										
 									WrapAndQuote(p, Quote, WrapColumn.CastInt32(), s);
 								}
 								else
 								{
 									p.Push(s);
 								}
 							}
 							else
 							{
 								p.Push(s);
 							}
 						}
 						else if (v.Type == GV_DATETIME &&
 								 v.Value.Date)
 						{
 							char b[64];
 							v.Value.Date->Get(b, sizeof(b));
 							p.Push(b);
 						}
 					}
 					else if (Tag->IsTag("cursor"))
 					{
 						int Size = (int)p.GetSize();
 						char *Buf = new char[Size+1];
 						if (Buf)
 						{
 							p.Peek((uchar*)Buf, Size);
 							Buf[Size] = 0;
 							RemoveReturns(Buf);
 
 							Cursor = LCharLen(Buf, "utf-8");
 							DeleteArray(Buf);
 						}
 					}
 
 					if (Tag->GetContent())
 					{
 						p.Push(Tag->GetContent());
 					}
 				}
 			}
 		}
 	}
 
 	return p.NewLStr();
 }
 
 LAutoString	ScribeWnd::ProcessSig(Mail *m, char *Xml, const char *MimeType)
 {
 	LStringPipe p;
 
 	if (!m || !Xml)
 		return LAutoString();
 	
 	if (MimeType && !_stricmp(MimeType, sTextHtml))
 		p.Write(Xml, strlen(Xml));
 	else
 	{
 		LMemStream mem(Xml, strlen(Xml));
 		LXmlTag x;
 		LXmlTree t(GXT_KEEP_WHITESPACE|GXT_NO_DOM);
 		if (t.Read(&x, &mem, 0))
 		{
 			for (auto Tag: x.Children)
 			{
 				if (Tag->IsTag("random-line"))
 				{
 					char *FileName = 0;
 					if ((FileName = Tag->GetAttr("Filename")))
 					{
 						LFile f(FileName);
 						if (f)
 						{
 							auto Lines = f.Read().SplitDelimit("\r\n");
 							char *RandomLine = Lines[LRand((unsigned)Lines.Length())];
 							if (RandomLine)
 							{
 								p.Push(RandomLine);
 							}
 						}
 					}
 				}
 				else if (Tag->IsTag("random-paragraph"))
 				{
 					char *FileName = 0;
 					if ((FileName = Tag->GetAttr("Filename")))
 					{
 						char *File = LReadTextFile(FileName);
 						if (File)
 						{
 							List<char> Para;
 							for (char *f=File; f && *f; )
 							{
 								// skip whitespace
 								while (strchr(" \t\r\n", *f)) f++;
 								if (*f)
 								{
 									char *Start = f;
 									char *n;
 									while ((n = strchr(f, '\n')))
 									{
 										f = n + 1;
 										if (f[1] == '\n' ||
 											(f[1] == '\r' && f[2] == '\n'))
 										{
 											break;
 										}
 									}
 									if (f == Start) f += strlen(f);
 
 									Para.Insert(NewStr(Start, f-Start));
 								}
 							}
 							DeleteArray(File);
 
 							char *RandomPara = Para.ItemAt(LRand((int)Para.Length()));
 							if (RandomPara)
 							{
 								p.Push(RandomPara);
 							}
 
 							Para.DeleteArrays();
 						}
 					}
 				}
 				else if (Tag->IsTag("include-file"))
 				{
 					char *FileName = 0;
 					if ((FileName = Tag->GetAttr("filename")))
 					{
 						char *File = LReadTextFile(FileName);
 						if (File)
 						{
 							p.Push(File);
 							DeleteArray(File);
 						}
 					}
 				}
 				else if (Tag->IsTag("quote-file"))
 				{
 					char *FileName = 0;
 					char *QuoteStr = 0;
 					if ((FileName = Tag->GetAttr("filename")) &&
 						(QuoteStr = Tag->GetAttr("Quote")))
 					{
 					}
 				}
 				else
 				{
 					p.Push(Tag->GetContent());
 				}
 			}
 		}
 	}
 
 	return LAutoString(p.NewStr());
 }
 
 // Get the effective permissions for a resource.
 //
 // This method can be used by both sync and async code:
 // In sync mode, don't supply a callback (ie = NULL) and the return value will be:
 //		Store3Error - no access
 //		Store3Delayed - no access, asking the user for password
 //		Store3Success - allow immediate access
 //
 // In async mode, supply a callback and wait for the response.
 //		callback(false) - no access
 //		callback(true) - allow immediate access
 // in this mode the same return values as sync mode are used.
 Store3Status ScribeWnd::GetAccessLevel(LViewI *Parent, ScribePerm Required, const char *ResourceName, std::function<void(bool)> Callback)
 {
 	if (Required >= CurrentAuthLevel)
 	{
 		if (Callback) Callback(true);
 		return Store3Success;
 	}
 	
 	if (!Parent)
 		Parent = this;
 	
 	switch (Required)
 	{
 		default:
 			break;
 		case PermRequireUser:
 		{
 			LPassword p;
 			if (!p.Serialize(GetOptions(), OPT_UserPermPassword, false))
 			{
 				if (Callback) Callback(true);
 				return Store3Success;
 			}
 
 			char Msg[256];
 			sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_ASK_USER_PASS), ResourceName);
 				
 			auto d = new LInput(Parent, "", Msg, AppName, true);
 			d->DoModal([this, d, p, Callback](auto dlg, auto id)
 			{
 				if (id && d->GetStr())
 				{
 					char Pass[256];
 					p.Get(Pass);
 					bool Status = strcmp(Pass, d->GetStr()) == 0;
 					if (Status)
 					{
 						CurrentAuthLevel = PermRequireUser;
 						
 						auto i = Menu->FindItem(IDM_LOGOUT);
 						if (i) i->Enabled(true);
 						if (Callback) Callback(true);
 					}
 					else
 					{
 						if (Callback) Callback(false);
 					}
 				}
 				delete dlg;
 			});
 
 			return Store3Delayed;
 		}
 		case PermRequireAdmin:
 		{
 			LString Key;
 			Key.Printf("Scribe.%s", OPT_AdminPassword);
 			auto Hash = LAppInst->GetConfig(Key);
 			if (ValidStr(Hash))
 			{
 				if (Callback) Callback(false);
 				return Store3Error;
 			}
 
 			uchar Bin[256];
 			ssize_t BinLen = 0;
 			if ((BinLen = ConvertBase64ToBinary(Bin, sizeof(Bin), Hash, strlen(Hash))) != 16)
 			{
 				LgiMsg(Parent, "Admin password not correctly encoded.", AppName);
 				if (Callback) Callback(false);
 				return Store3Error;
 			}
 
 			auto d = new LInput(Parent, "", LLoadString(IDS_ASK_ADMIN_PASS), AppName, true);
 			d->DoModal([this, d, Bin, Callback](auto dlg, auto id)
 			{
 				if (id && d->GetStr())
 				{
 					unsigned char Digest[16];
 					char Str[256];
 					sprintf_s(Str, sizeof(Str), "%s admin", d->GetStr().Get());
 					MDStringToDigest(Digest, Str);
 						
 					if (memcmp(Bin, Digest, 16) == 0)
 					{
 						CurrentAuthLevel = PermRequireAdmin;
 						auto i = Menu->FindItem(IDM_LOGOUT);
 						if (i) i->Enabled(true);
 						if (Callback) Callback(true);
 					}
 					else
 					{
 						if (Callback) Callback(false);
 					}
 				}
 				delete dlg;
 			});
 
 			return Store3Delayed;
 		}
 	}
 
 	if (Callback) Callback(true);
 	return Store3Success;
 }
 
 void ScribeWnd::GetAccountSettingsAccess(LViewI *Parent, ScribeAccessType AccessType, std::function<void(bool)> Callback)
 {
 	LVariant Level = (int)PermRequireNone;
 	
 	// Check if user level access is required
 	char *Opt = (char*)(AccessType == ScribeReadAccess ? OPT_AccPermRead : OPT_AccPermWrite);
 	GetOptions()->GetValue(Opt, Level);
 
 	/*
 	// Check if admin access is required
 	char *Admin = GetScribeAccountPerm((char*) (AccessType == ScribeReadAccess ? "Read" : "Write"));
 	if (Admin && _stricmp(Admin, "Admin") == 0)
 	{
 		Level = PermRequireAdmin;
 	}
 	*/
 
 	GetAccessLevel(Parent ? Parent : this, (ScribePerm)Level.CastInt32(), "Account Settings", Callback);
 }
 
 LMutex *ScribeWnd::GetLock()
 {
 	return _Lock;
 }
 
 void ScribeWnd::OnBeforeConnect(ScribeAccount *Account, bool Receive)
 {
 	if (Receive)
 	{
 		Account->Receive.Enabled(false);
 	}
 	else
 	{
 		Account->Send.Enabled(true);
 	}
 
 	if (StatusPanel)
 	{
 		StatusPanel->Invalidate();
 	}
 }
 
 void ScribeWnd::OnAfterConnect(ScribeAccount *Account, bool Receive)
 {
 	if (Account)
 	{
 		SaveOptions();
 		if (ScribeState == ScribeExiting)
 		{
 			LCloseApp();
 		}
 	}
 
 	if (Receive)
 	{
 		Account->Receive.Enabled(true);
 	}
 	else
 	{
 		Account->Send.Enabled(true);
 	}
 
 	if (StatusPanel)
 	{
 		StatusPanel->Invalidate();
 	}
 
 	if (d->SendAfterReceive)
 	{
 		bool Online = false;
 		for (auto a: Accounts)
 		{
 			bool p = a->Receive.IsPersistant();
 			bool o = a->Receive.IsOnline();
 			if (!p && o)
 			{
 				Online = true;
 				break;
 			}
 		}
 		if (!Online)
 		{
 			Send(-1, true);
 			d->SendAfterReceive = false;
 		}
 	}
 }
 
 void ScribeWnd::Send(int Which, bool Quiet)
 {
 	if (ScribeState == ScribeExiting)
 		return;
 
 	if (Which < 0)
 	{
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_DefaultSendAccount, v))
 			Which = v.CastInt32();
 	}
 
 	LArray<ScribeFolder*> Outboxes;
 	unsigned i;
 	for (i=0; i<Folders.Length(); i++)
 	{
 		ScribeFolder *OutBox = GetFolder(FOLDER_OUTBOX, &Folders[i]);
 		if (OutBox)
 		{
 			OutBox->LoadThings();
 			Outboxes.Add(OutBox);
 		}
 	}
 
 	if (Outboxes.Length() < 1)
 	{
 		LgiMsg(this, LLoadString(IDS_NO_OUTGOING_FOLDER), AppName, MB_OK);
 		return;
 	}
 
 	int MailToSend = 0;
 	List<SendAccountlet> Acc;
 	SendAccountlet *Default = 0;
 	
 	{
 		// Create list of accounts
 		for (auto a: Accounts)
 		{
 			Acc.Insert(&a->Send);
 			a->Send.Outbox.DeleteObjects();
 		
 			if (Which < 0 || a->GetIndex() == Which)
 				Default = &a->Send;
 		}
 		
 		// If the default it not in the list try the first one..
 		if (!Default)
 			Default = Acc[0];
 	}
 
 	for (i=0; i<Outboxes.Length(); i++)
 	{
 		ScribeFolder *OutBox = Outboxes[i];
 		for (auto t: OutBox->Items)
 		{
 			Mail *m = t->IsMail();
 			if (!m)
 				continue;
 
 			uint32_t Flags = m->GetFlags();
 			if (!TestFlag(Flags, MAIL_SENT) &&
 				TestFlag(Flags, MAIL_READY_TO_SEND))
 			{
 				LDataIt To = m->GetObject()->GetList(FIELD_TO);
 				if (To && To->Length())
 				{
 					LAutoPtr<ScribeEnvelope> Out(new ScribeEnvelope);
 					if (Out)
 					{
 						if (m->OnBeforeSend(Out))
 						{
 							SendAccountlet *Send = 0;
 							for (auto a: Acc)
 							{
 								LVariant Ie = a->GetAccount()->Identity.Email();
 								if (ValidStr(Ie.Str()) &&
 									a->OnlySendThroughThisAccount())
 								{
 									if (Ie.Str() &&
 										m->GetFromStr(FIELD_EMAIL) &&
 										_stricmp(Ie.Str(), m->GetFromStr(FIELD_EMAIL)) == 0)
 									{
 										Send = a;
 										break;
 									}
 								}
 							}
 
 							if (!Send)
 							{
 								Send = Default;
 							}
 							
 							if (Send)
 							{
 								LAssert(Out->To.Length() > 0);
 								Out->SourceFolder = OutBox->GetPath();
 								Send->Outbox.Add(Out.Release());
 								MailToSend++;
 							}
 						}
 					}
 				}
 				else
 				{
 					LgiMsg(	this,
 							LLoadString(IDS_ERROR_NO_RECIPIENTS),
 							AppName,
 							MB_OK,
 							m->GetSubject() ? m->GetSubject() : (char*)"(none)");
 				}
 			}
 		}
 	}
 
 	if (MailToSend)
 	{
 		for (auto a: Acc)
 		{
 			if (a->Outbox.Length() > 0 && !a->IsOnline())
 			{
 				if (a->IsConfigured())
 				{
 					a->Connect(0, Quiet);
 				}
 				else
 				{
 					auto d = new LAlert(this,
 							AppName,
 							LLoadString(IDS_ERROR_NO_CONFIG_SEND),
 							LLoadString(IDS_CONFIGURE),
 							LLoadString(IDS_CANCEL));
 					d->DoModal([this, d, a](auto dlg, auto id)
 					{
 						if (id == 1)
 							a->GetAccount()->InitUI(this, 1, NULL);
 						delete dlg;
 					});
 				}
 			}
 		}
 	}
 	else
 	{
 		LgiMsg(this, LLoadString(IDS_NO_MAIL_TO_SEND), AppName, MB_OK, Outboxes[0]->GetText());
 	}
 }
 
 void ScribeWnd::Receive(int Which)
 {
 	#define LOG_RECEIVE		0
 	
 	if (ScribeState == ScribeExiting)
 	{
 		LgiTrace("%s:%i - Won't receive, is trying to exit.\n", _FL);
 		return;
 	}
 
 	for (ScribeAccount *i: Accounts)
 	{
 		if (i->GetIndex() != Which)
 			continue;
 			
 		if (i->Receive.IsOnline())
 		{
 			#if LOG_RECEIVE
 			LgiTrace("%s:%i - %i already online.\n", _FL, Which);
 			#endif
 		}
 		else if (i->Receive.Disabled() > 0)
 		{
 			#if LOG_RECEIVE
 			LgiTrace("%s:%i - %i is disabled.\n", _FL, Which);
 			#endif
 		}
 		else if (!i->Receive.IsConfigured())
 		{
 			#if LOG_RECEIVE
 			LgiTrace("%s:%i - %i is not configured.\n", _FL, Which);
 			#endif
 
 			auto a = new LAlert(this,
 					AppName,
 					LLoadString(IDS_ERROR_NO_CONFIG_RECEIVE),
 					LLoadString(IDS_CONFIGURE),
 					LLoadString(IDS_CANCEL));
 			a->DoModal([this, a, i](auto dlg, auto id)
 			{
 				if (id == 1)
 					i->InitUI(this, 2, NULL);
 				delete dlg;
 			});
 		}
 		else
 		{
 			i->Receive.Connect(0, false);
 		}
 		break;
 	}
 }
 
 bool ScribeWnd::GetHelpFilesPath(char *Path, int PathSize)
 {
 	const char *Index = "index.html";
 	char Install[MAX_PATH_LEN];
 	strcpy_s(Install, sizeof(Install), ScribeResourcePath());
 	
 	for (int i=0; i<5; i++)
 	{
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), Install, "help");
 		LMakePath(p, sizeof(p), p, Index);
 		LgiTrace("Trying '%s'\n", p);
 		if (LFileExists(p))
 		{
 			LTrimDir(p);
 			strcpy_s(Path, PathSize, p);
 			return true;
 		}
 		#ifdef MAC
 		LMakePath(p, sizeof(p), Install, "Resources/Help");
 		LMakePath(p, sizeof(p), p, Index);
 		// LgiTrace("Trying '%s'\n", p);
 		if (LFileExists(p))
 		{
 			LTrimDir(p);
 			strcpy_s(Path, PathSize, p);
 			return true;
 		}
 		#endif
 		LTrimDir(Install); // Try all the parent folders...
 	}
 
 	LArray<const char*> Ext;
 	LArray<char*> Help;
 	Ext.Add("index.html");
 	LMakePath(Install, sizeof(Install), ScribeResourcePath(), "..");
 	LRecursiveFileSearch(Install, &Ext, &Help);
 	for (unsigned i=0; i<Help.Length(); i++)
 	{
 		if (stristr(Help[i], "leveldb"))
 			continue;
 		strcpy_s(Path, PathSize, Help[i]);
 		LTrimDir(Path);
 		Help.DeleteArrays();
 		return true;
 	}
 	
 	return false;
 }
 
 bool ScribeWnd::LaunchHelp(const char *File)
 {
 	if (File)
 	{
 		char *Hash = 0;
 		LBrowser *Browse = 0;
 		
 		// Find help files...
 		char Path[MAX_PATH_LEN];
 		if (!GetHelpFilesPath(Path, sizeof(Path)))
 		{
 			LgiTrace("%s:%i - GetHelpFilesPath failed.\n", _FL);
 			goto HelpError;
 		}
 
 		// Add filename...
 		LMakePath(Path, sizeof(Path), Path, File);
 		
 		// Check existance...
 		Hash = strrchr(Path, '#');
 		if (Hash) *Hash = 0;
 		if (!LFileExists(Path))
 		{
 			LgiTrace("%s:%i - FileExists('%s') failed.\n", _FL, Path);
 			goto HelpError;
 		}
 		if (Hash) *Hash = '#';
 
 		#if USE_INTERNAL_BROWSER
 
 		Browse = new LBrowser(this, "Help");
 		if (Browse)
 		{
 			Browse->AddPath(ScribeResourcePath());
 			Browse->SetEvents(d);
 			return Browse->SetUri(Path);
 		}
 
 		#else
 
 			#ifdef MAC
 
 			if (LExecute(Path))
 				return true;
 			
 			#else
 
 			if (Hash) *Hash = '#';
 			
 			// Get browser...
 			char Browser[256];
 			if (!LGetAppForMimeType("application/browser", Browser, sizeof(Browser)))
 			{
 				LgiTrace("%s:%i - LGetAppForMimeType('text/html') failed.\n", _FL);
 				goto HelpError;
 			}
 			
 			// Execute browser to view help...
 			char Uri[256];
 			sprintf_s(Uri, sizeof(Uri), "\"file://%s\"", Path);
 			#ifdef WIN32
 			char *c;
 			while (c = strchr(Uri, '\\')) *c = '/';
 			#endif
 
 			LgiTrace("LaunchHelp('%s','%s').\n", Browser, Uri);
 			if (!LExecute(Browser, Uri))
 			{
 				LgiTrace("%s:%i - LExecute('%s','%s') failed.\n", _FL, Browser, Uri);
 				goto HelpError;
 			}
 			return true;
 			
 			#endif
 
 		#endif
 		
 		HelpError:
 		LgiMsg(this, LLoadString(IDS_ERROR_NO_HELP), AppName, MB_OK);
 	}
 	
 	return false;
 }
 
 void ScribeWnd::Preview(int Which)
 {
 	LArray<ScribeAccount*> a;
 	a.Add(Accounts[Which]);
 	OpenPopView(this, a);
 }
 
 bool MergeSegments(LDataPropI *DstProp, LDataPropI *SrcProp, LDom *Dom)
 {
 	LDataI *Src = dynamic_cast<LDataI *>(SrcProp);
 	LDataI *Dst = dynamic_cast<LDataI *>(DstProp);
 	if (!Dst || !Src)
 		return false;
 
 	Store3MimeType Mt(Src->GetStr(FIELD_MIME_TYPE));
 	if (Mt.IsText())
 	{
 		// Set the headers...
 		Dst->SetStr(FIELD_INTERNET_HEADER, Src->GetStr(FIELD_INTERNET_HEADER));
 
 		// Do mail merge of data part...
 		LAutoStreamI Data = Src->GetStream(_FL);
 		if (Data)
 		{
 			// Read data out into a string string...
 			LAutoString Str(new char[(int)Data->GetSize()+1]);
 			Data->Read(Str, (int)Data->GetSize());
 			Str[Data->GetSize()] = 0;
 
 			// Do field insert and save result to segment
 			char *Merged = ScribeInsertFields(Str, Dom);
 			LAutoStreamI Mem(new LMemStream(Merged, strlen(Merged)));
 			Dst->SetStream(Mem);
 		}
 	}
 	else
 	{
 		// Straight copy...
 		Dst->CopyProps(*Src);
 	}
 
 	// Merge children segments as well
 	LDataIt Sc = Src->GetList(FIELD_MIME_SEG);
 	LDataIt Dc = Dst->GetList(FIELD_MIME_SEG);
 	if (Dc && Sc)
 	{
 		for (unsigned i=0; i<Sc->Length(); i++)
 		{
 			// Create new dest child, and merge the source child across
 			LDataPropI *NewDestChild = Dc->Create(Dst->GetStore());
 			if (!MergeSegments(NewDestChild, (*Sc)[i], Dom))
 				return false;
 
 			LDataI *NewDest = dynamic_cast<LDataI*>(NewDestChild);
 			if (NewDest)
 				NewDest->Save(Dst);
 		}
 	}
 
 	return true;
 }
 
 // Either 'FileName' or 'Source' will be valid
 void ScribeWnd::MailMerge(LArray<ListAddr*> &Contacts, const char *FileName, Mail *Source)
 {
 	ScribeFolder *Outbox = GetFolder(FOLDER_OUTBOX);
 
 	if (Outbox && Contacts.Length() && (FileName || Source))
 	{
 		LAutoPtr<Mail> ImportEmail;
 		if (FileName)
 		{
 			LAutoPtr<LFile> File(new LFile);
 			if (File->Open(FileName, O_READ))
 			{
 				Thing *t = CreateItem(MAGIC_MAIL, Outbox, false);
 				ImportEmail.Reset(Source = t->IsMail());
 				if (!Source->Import(Source->AutoCast(File), sMimeMessage))
 				{
 					Source = 0;
 				}
 			}
 		}
 		
 		if (Source)
 		{
 			List<Mail> Msgs;
 			ScribeDom Dom(this);
 
 			// Do the merging of the document with the database
 			for (unsigned i=0; i<Contacts.Length(); i++)
 			{
 				ListAddr *la = Contacts[i];
 				RecipientItem *ri = (*la)[0];
 				Contact *c = ri ? ri->GetContact() : 0;
 				Contact *temp = new Contact(this);
 				if (!c)
 				{
 					temp->SetFirst(la->sName);
 					temp->SetEmail(la->sAddr);
 					c = temp;
 				}
 
 				Dom.Con = c;
 				Thing *t = CreateItem(MAGIC_MAIL, Outbox, false);
 				if (t)
 				{
 					Dom.Email = t->IsMail();
 					
 					LAutoString s;
 					if (s.Reset(ScribeInsertFields(Source->GetSubject(), &Dom)))
 						Dom.Email->SetSubject(s);
 					LDataPropI *Recip = Dom.Email->GetTo()->Create(Dom.Email->GetObject()->GetStore());
 					if (Recip)
 					{
 						Recip->CopyProps(*Dom.Con->GetObject());
 						Recip->SetInt(FIELD_CC, 0);
 						Dom.Email->GetTo()->Insert(Recip);
 					}
 					MergeSegments(	Dom.Email->GetObject()->GetObj(FIELD_MIME_SEG),
 									Source->GetObject()->GetObj(FIELD_MIME_SEG),
 									&Dom);
 
 					Msgs.Insert(Dom.Email);
 				}
 
 				temp->DecRef();
 			}
 
 			// Ask user what to do
 			if (Msgs[0])
 			{
 				char Msg[256];
 				sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_MAIL_MERGE_Q), Msgs.Length());
 				
 				auto Ask = new LAlert(this, AppName, Msg,
 					LLoadString(IDS_SAVE_TO_OUTBOX), LLoadString(IDS_CANCEL));
 
 				Ask->DoModal([this, Msgs, Outbox](auto dlg, auto id)
 				{
 					switch (id)
 					{
 						case 1: // Save To Outbox
 						{
 							for (size_t i=0; i<Msgs.Length(); i++)
 							{
 								Msgs[i]->Save(Outbox);
 							}
 							break;
 						}
 						case 2: // Cancel
 						{
 							for (size_t i=0; i<Msgs.Length(); i++)
 							{
 								Msgs[i]->OnDelete();
 							}
 							break;
 						}
 					}
 					delete dlg;
 				});
 			}
 			else
 			{
 				LgiMsg(this, LLoadString(IDS_MAIL_MERGE_EMPTY), AppName);
 			}
 		}
 	}
 }
 
 ScribeFolder *CastFolder(LDataI *f)
 {
 	if (!f)
 	{
 		LAssert(!"Null pointer");
 		return 0;
 	}
 
 	if (f->Type() == MAGIC_FOLDER)
 	{
 		return (ScribeFolder*)f->UserData;
 	}
 
 	return 0;
 }
 
 Thing *CastThing(LDataI *t)
 {
 	if (!t)
 	{
 		LAssert(!"Null pointer");
 		return 0;
 	}
 
 	if (t->Type() == MAGIC_FOLDER)
 	{
 		LAssert(!"Shouldn't be a folder");
 		return 0;
 	}
 
 	return (Thing*)t->UserData;
 }
 
 LString _GetUids(LArray<LDataI*> &items)
 {
 	LString::Array a;
 	for (auto i: items)
 		a.New().Printf(LPrintfInt64, i->GetInt(FIELD_SERVER_UID));
 	return LString(",").Join(a);
 }
 
 /// Received new items from a storage backend.
 void ScribeWnd::OnNew(
 	/// The parent folder of the new item
 	LDataFolderI *Parent,
 	/// All the new items
 	LArray<LDataI*> &NewItems,
 	/// The position in the parent folder or -1
 	int Pos,
 	/// Non-zero if the object is a new email.
 	bool IsNew)
 {
 	ScribeFolder *Fld = CastFolder(Parent);
 	int UnreadDiff = 0;
 
 	if (Stricmp(Parent->GetStr(FIELD_FOLDER_NAME), "Contacts") &&
 		Stricmp(Parent->GetStr(FIELD_FOLDER_NAME), "Calendar"))
 	{
 		LOG_STORE("OnNew(%s, %s, %i, %i)\n", Parent->GetStr(FIELD_FOLDER_NAME), _GetUids(NewItems).Get(), Pos, IsNew);
 	}
 
 	if (!Fld)
 	{
 		// When this happens the parent hasn't been loaded by the UI thread
 		// yet, so if say the IMAP back end notices a new sub-folder then we
 		// can safely ignore it until such time as the UI loads the parent
 		// folder. At which point the child we got told about here will be 
 		// loaded anyway.
 
 		#if DEBUG_NEW_MAIL
 		LDataFolderI *p = dynamic_cast<LDataFolderI*>(Parent);
 		LgiTrace("%s:%i - NewMail.OnNew no UI object for '%s'\n", _FL, p ? p->GetStr(FIELD_FOLDER_NAME) : NULL);
 		#endif
 		return;
 	}
 	
 	if (!Parent || !NewItems.Length())
 	{
 		LAssert(!"Param error");
 		return;
 	}
 
 	for (auto cb: d->Store3EventCallbacks)
 		cb->OnNew(Parent, NewItems, Pos, IsNew);
 
 	List<Mail> NewMail;
 	for (auto Item: NewItems)
 	{
 		if (Item->Type() == MAGIC_FOLDER)
 		{
 			// Insert new folder into the right point on the tree...
 			LDataFolderI *SubObject = dynamic_cast<LDataFolderI*>(Item);
 			if (!SubObject)
 			{
 				LAssert(!"Not a valid folder.");
 				continue;
 			}
 			
 			
 			ScribeFolder *Sub = CastFolder(SubObject);
 			// LgiTrace("OnNew '%s', Sub=%p Children=%i\n", SubObject->GetStr(FIELD_FOLDER_NAME), Sub, SubObject->SubFolders().Length());
 
 			if (!Sub)
 			{
 				// New folder...
 				if ((Sub = new ScribeFolder))
 				{
 					Sub->App = this;
 					Sub->SetObject(SubObject, false, _FL);
 
 					Fld->Insert(Sub);
 				}
 			}
 			else
 			{
 				// Existing folder...
 				Fld->Insert(Sub, Pos);
 			}
 		}
 		else
 		{
 			Thing *t = CastThing(Item);
 			if (!t)
 			{
 				// Completely new thing...
 				t = CreateThingOfType((Store3ItemTypes) Item->Type(), Item);
 			}
 			
 			if (t)
 			{
 				if (t->DeleteOnAdd.Obj)
 				{
 					// Complete a delayed move
 					auto OldFolder = t->App->GetFolder(t->DeleteOnAdd.Path);
 					if (!OldFolder)
 					{
 						LgiTrace("%s:%i - Couldn't resolve old folder '%s'\n", _FL, t->DeleteOnAdd.Path.Get());
 					}
 					else
 					{
 						auto OldItem = t->DeleteOnAdd.Obj;
 						if (!OldFolder->Items.HasItem(OldItem))
 							LgiTrace("%s:%i - Couldn't find old obj.\n", _FL);
 						else
 							OldItem->OnDelete();
 					}
 				}
 
 				t->SetParentFolder(Fld);
 				Fld->Update();
 
 				if (Fld->Select())
 				{
 					// Existing thing...
 					t->SetFieldArray(Fld->GetFieldArray());
 
 					ThingFilter *Filter = GetThingFilter();
 					if (!Filter || Filter->TestThing(t))
 					{
 						MailList->Insert(t, -1, false);
 					}
 				}
 
 				Mail *m = t->IsMail();
 				if (m)
 				{
 					// LgiTrace("OnNew %p\n", m->GetObject());
 					UnreadDiff += TestFlag(m->GetFlags(), MAIL_READ) ? 0 : 1;
 
 					#if DEBUG_NEW_MAIL
 					LgiTrace("%s:%i - NewMail.OnNew t=%p uid=%s IsNew=%i\n", _FL, t, m->GetServerUid().ToString().Get(), IsNew);
 					#endif
 
 					if (IsNew)
 					{
 						LAssert(!NewMail.HasItem(m));
 						NewMail.Insert(m);
 					}
 				}
 
 				t->Update();
 			}
 		}
 	}
 
 	if (UnreadDiff)
 		Fld->OnUpdateUnRead(UnreadDiff, false);
 
 	if (MailList && Fld->Select())
 		MailList->Sort(ListItemCompare, (NativeInt)Fld);
 
 	if (NewMail.Length())
 		OnNewMail(&NewMail);
 }
 
 void ScribeWnd::OnPropChange(LDataStoreI *store, int Prop, LVariantType Type)
 {
 	switch (Prop)
 	{
 		case FIELD_IS_ONLINE:
 		{
 			// This is in case we receive a message after the app has shutdown and
 			// deleted 'this'.
 			if (ScribeState > ScribeRunning)
 				break;
 			
 			if (StatusPanel)
 				StatusPanel->Invalidate();
 			
 			for (auto a : Accounts)
 			{
 				if (a->Receive.GetDataStore() == store)
 				{
 					int64 Online = store->GetInt(FIELD_IS_ONLINE);
 
 					auto Old = ScribeState;
 
 					// This prevents the folders unloading during this call.
 					// Which causes crashes.
 					ScribeState = ScribeLoadingFolders;
 
 					a->Receive.OnOnlineChange(Online != 0);
 					ScribeState = Old;
 					break;
 				}
 			}
 			break;
 		}
 	}
 }
 
 void ScribeWnd::SetContext(const char *file, int line)
 {
 	d->CtxFile = file;
 	d->CtxLine = line;
 }
 
 bool ScribeWnd::OnChange(LArray<LDataI*> &items, int FieldHint)
 {
 	bool UpdateSelection = false;
 	List<Mail> NewMail;
 	ScribeFolder *Parent = 0;
 
 	// LOG_STORE("OnChange(%i, %i)\n", (int)items.Length(), FieldHint);
 	LAssert(d->CtxFile != NULL);
 
 	for (unsigned c=0; c<d->Store3EventCallbacks.Length(); c++)
 	{
 		d->Store3EventCallbacks[c]->OnChange(items, FieldHint);
 	}
 
 	for (unsigned i=0; i<items.Length(); i++)
 	{
 		LDataI *Item = items[i];
 		Thing *t;
 
 		if (Item->Type() == MAGIC_FOLDER)
 		{
 			auto ItemFolder = dynamic_cast<LDataFolderI*>(Item);
 			ScribeFolder *fld = CastFolder(ItemFolder);
 			if (fld)
 			{
 				if (FieldHint == FIELD_STATUS)
 				{
 					// This is the delayed folder load case:
 					fld->IsLoaded(true);
 					if (fld->Select())
 						fld->Populate(GetMailList());
 				}
 				else
 				{
 					fld->Update();
 				}
 			}
 			else
 			{
 				// LAssert(!"Can't cast to folder?");
 			}
 		}
 		else if ((t = CastThing(Item)))
 		{
 			ThingUi *Ui = t->GetUI();
 			if (Ui)
 				Ui->OnChange();
 				
 			Mail *m = t->IsMail();
 			if (m)
 			{
 				auto StoreFlags = Item->GetInt(FIELD_FLAGS);
 
 				#if 0
 				LgiTrace("App.OnChange(%i) handler %p: %s -> %s\n", 
 					FieldHint, m,
 					EmailFlagsToStr(m->FlagsCache).Get(),
 					EmailFlagsToStr(StoreFlags).Get());
 				#endif
 				
 				if (TestFlag(m->FlagsCache, MAIL_NEW) &&
 					!TestFlag(StoreFlags, MAIL_NEW))
 				{
 					Mail::NewMailLst.Delete(m);
 					Parent = m->GetFolder();
 				}
 					
 				if (m->FlagsCache != StoreFlags)
 				{
 					// LgiTrace("%s:%i - OnChange mail flags changed.\n", _FL);
 					m->SetFlagsCache(StoreFlags, false, false);
 					Parent = m->GetFolder();
 				}
 
 				if (m->NewEmail == Mail::NewEmailLoading)
 				{
 					auto Loaded = m->GetLoaded();
 					if (Loaded < Store3Loaded)
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnChange.GetBody t=%p, uid=%s, mode=%s, loaded=%s (%s:%i)\n",
 							_FL, (Thing*)m, m->GetServerUid().ToString().Get(),
 							toString(m->NewEmail), toString(Loaded),
 							d->CtxFile, d->CtxLine);
 						#endif
 
 						m->GetBody();
 					}
 					else
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnChange.NewMail t=%p, uid=%s, mode=%s, loaded=%s (%s:%i)\n",
 							_FL, (Thing*)m, m->GetServerUid().ToString().Get(),
 							toString(m->NewEmail), toString(Loaded),
 							d->CtxFile, d->CtxLine);
 						#endif
 
 						NewMail.Insert(m);
 					}
 				}
 			}
 			else if (t->IsCalendar())
 			{
 				for (auto cv: CalendarView::CalendarViews)
 					cv->OnContentsChanged();
 			}
 
+			#ifdef _DEBUG
+			if (FieldHint == FIELD_MIME_SEG)
+			{
+				// This was a hack to fix a dumb bug in a dev build... so so dumb.
+				t->SetDirty();
+			}
+			else 
+			#endif
 			if (FieldHint != FIELD_FLAGS)
 			{
 				// Call the on load handler...
 				t->IsLoaded(true);
 			}
 
 			if (t->GetList())
 			{
 				t->Update();
 				if (FieldHint != FIELD_FLAGS)
 					UpdateSelection |= t->Select();
 			}
 		}
 	}
 
 	if (MailList && UpdateSelection)
 	{
 		List<Thing> Sel;
 		if (MailList->GetSelection(Sel))
 		{
 			OnSelect(&Sel, true);
 		}
 	}
 
 	if (Parent)
 		Parent->OnUpdateUnRead(0, true);
 
 	if (NewMail.Length())
 		OnNewMail(&NewMail);
 
 	d->CtxFile = NULL;
 	d->CtxLine = 0;
 	return true;
 }
 
 ContactGroup *ScribeWnd::FindGroup(char *SearchName)
 {
 	ScribeFolder *g = GetFolder(FOLDER_GROUPS);
 	if (!g || !SearchName)
 		return 0;
 
 	g->LoadThings();
 	for (Thing *t: g->Items)
 	{
 		ContactGroup *Grp = t->IsGroup();
 		if (!Grp)
 			continue;
 
 		auto Name = Grp->GetObject()->GetStr(FIELD_GROUP_NAME);
 		if (Name)
 		{
 			if (!_stricmp(Name, SearchName))
 			{
 				return Grp;
 			}
 		}
 	}
 
 	return 0;
 }
 
 bool ScribeWnd::Match(LDataStoreI *Store, LDataPropI *Address, int ObjType, LArray<LDom*> &Matches)
 {
 	if (!Store || !Address)
 		return 0;
 
 	// char *Addr = Address->GetStr(ObjType == MAGIC_CONTACT ? FIELD_EMAIL : FIELD_NAME);
 	auto Addr = Address->GetStr(FIELD_EMAIL);
 	if (!Addr)
 		return 0;
 
 	List<Contact> *l = GetEveryone();
 	if (!l)
 		return 0;
 
 	Matches.Length(0);
 
 	if (ObjType == MAGIC_CONTACT)
 	{
 		for (auto c: *l)
 		{
 			if (strchr(Addr, '@'))
 			{
 				auto Emails = c->GetEmails();
 				for (auto e: Emails)
 				{
 					if (e.Equals(Addr))
 					{
 						Matches.Add(c);
 						break;
 					}
 				}
 			}
 		}
 	}
 	else if (ObjType == MAGIC_GROUP)
 	{
 		ScribeFolder *g = GetFolder(FOLDER_GROUPS);
 		if (!g)
 			return false;
 
 		g->LoadThings();
 		for (auto t: g->Items)
 		{
 			ContactGroup *Grp = t->IsGroup();
 			if (!Grp)
 				continue;
 
 			List<char> GrpAddr;
 			if (!Grp->GetAddresses(GrpAddr))
 				continue;
 
 			for (auto a: GrpAddr)
 			{
 				if (_stricmp(a, Addr) == 0)
 				{
 					Matches.Add(t);
 					break;
 				}
 			}
 
 			GrpAddr.DeleteArrays();
 		}
 	}
 
 
 	return Matches.Length() > 0;
 }
 
 bool ScribeWnd::OnMove(LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items)
 {
 	if (!new_parent || items.Length() == 0)
 		return false;
 
 	bool Status = false;
 
 	for (auto cb: d->Store3EventCallbacks)
 		cb->OnMove(new_parent, old_parent, items);
 
 	ScribeFolder *New = CastFolder(new_parent);
 	ScribeFolder *Old = old_parent ? CastFolder(old_parent) : NULL;
 	if (New)
 	{
 		ssize_t SelIdx = -1;
 		for (unsigned n=0; n<items.Length(); n++)
 		{
 			switch ((uint32_t)items[n]->Type())
 			{
 				case MAGIC_FOLDER:
 				{
 					ScribeFolder *i = CastFolder(items[n]);
 					if (i)
 					{
 						i->Detach();
 						New->Insert(i);
 						Status = true;
 					}
 					break;
 				}
 				default:
 				{
 					Thing *t = CastThing(items[n]);
 					if (t)
 					{
 						int UnreadMail = t->IsMail() ? !TestFlag(t->IsMail()->GetFlags(), MAIL_READ) : false;
 
 						if (Old && UnreadMail)
 							Old->OnUpdateUnRead(-1, false);
 
 						if (t->GetList())
 						{
 							if (t->Select() && SelIdx < 0)
 								SelIdx = t->GetList()->IndexOf(t);
 							t->GetList()->Remove(t);
 						}
 						
 						// This closes the user interface if the object is being moved to the trash...
 						if (New->GetSystemFolderType() == Store3SystemTrash)
 							t->SetUI();
 
 						t->SetParentFolder(New);
 						if (New->Select())
 						{
 							MailList->Insert(t);
 							MailList->ReSort();
 						}
 						if (UnreadMail) New->OnUpdateUnRead(1, false);
 						if (New->GetItemType() == MAGIC_ANY &&
 							t->IsMail())
 						{
 							Mail::NewMailLst.Delete(t->IsMail());
 						}
 
 						Status = true;
 					}
 					break;
 				}
 			}
 		}
 
 		if (MailList && SelIdx >= 0 && MailList->Length() > 0)
 		{
 			if (SelIdx >= (ssize_t)MailList->Length())
 				SelIdx = MailList->Length()-1;
 			MailList->Value(SelIdx);
 		}
 	}
 
 	return Status;
 }
 
 bool ScribeWnd::OnDelete(LDataFolderI *Parent, LArray<LDataI*> &Items)
 {
 	int UnreadAdjust = 0;
 	int SelectIdx = -1;
 
 	LOG_STORE("OnDelete(%s, %i)\n", Parent->GetStr(FIELD_FOLDER_NAME), (int)Items.Length());
 
 	if (!Items.Length())
 		return false;
 
 	for (unsigned c=0; c<d->Store3EventCallbacks.Length(); c++)
 	{
 		d->Store3EventCallbacks[c]->OnDelete(Parent, Items);
 	}
 
 	ScribeFolder *Fld = NULL;
 	for (unsigned i=0; i<Items.Length(); i++)
 	{
 		LDataI *Item = Items[i];
 
 		if (Item->Type() == MAGIC_FOLDER)
 		{
 			// Insert new folder into the right point on the tree...
 			ScribeFolder *Sub = CastFolder(Item);
 			if (!Sub)
 				return true;
 
 			LgiTrace("OnDelete folder %p (%i)\n", (ThingType*)Sub, ThingType::DirtyThings.HasItem(Sub));
 			// Remove the deleted object from the dirty queue...
 			ThingType::DirtyThings.Delete(Sub);
 			// And make sure it can't get dirty again...
 			Sub->SetWillDirty(false);
 
 			// Remove all the children
 			LDataIterator<LDataI*> &SubItems = Sub->GetFldObj()->Children();
 			LArray<LDataI*> Children;
 			for (LDataI *c = SubItems.First(); c; c = SubItems.Next())
 			{
 				Children.Add(c);
 			}
 			OnDelete(Sub->GetFldObj(), Children);
 
 			// Remove the UI element
 			Sub->Remove();
 			
 			// Free the memory for the object
 			DeleteObj(Sub);
 		}
 		else
 		{
 			Fld = Parent ? CastFolder(Parent) : 0;
 			if (!Fld)
 				return false;
 
 			Thing *t = CastThing(Item);
 			if (!t)
 			{
 				// This happens when the item moves from one store to another
 				// of a different type and a copy of the old object is made. The
 				// 'Thing' is detached from 'Item' and attached to the new LDataI
 				// object.
 
 				// However if the object is an unread email... we should still decrement the 
 				// folder's unread count.
 				if (Item->Type() == MAGIC_MAIL &&
 					!(Item->GetInt(FIELD_FLAGS) & MAIL_READ))
 				{
 					Fld->OnUpdateUnRead(-1, false);
 				}
 			}
 			else
 			{
 				LAssert(!Fld || Fld == t->GetFolder());
 				
 				// LgiTrace("OnDelete thing %p (%i)\n", (ThingType*)t, ThingType::DirtyThings.HasItem(t));
 				
 				// Remove the deleted object from the dirty queue...
 				ThingType::DirtyThings.Delete(t);
 				// And make sure it can't get dirty again...
 				t->SetWillDirty(false);
 				
 				// Was the thing currently being previewed?
 				if (PreviewPanel && PreviewPanel->GetCurrent() == t)
 					PreviewPanel->OnThing(0, false);
 
 				// Was the object selected in the thing list?
 				if (Fld && Fld->Select())
 				{
 					// If so, select an adjacent item.
 					if (SelectIdx < 0 && t->Select())
 						SelectIdx = MailList->IndexOf(t);
 					MailList->Remove(t);
 				}
 
 				// Was the object an unread email?
 				Mail *m = t->IsMail();
 				if (m)
 				{
 					if (!TestFlag(m->GetFlags(), MAIL_READ) && Fld)
 						UnreadAdjust--;
 					Mail::NewMailLst.Delete(m);
 				}
 
 				t->SetUI();
 				t->SetParentFolder(NULL);
 				t->SetObject(NULL, false, _FL);
 
 				if (Fld)
 					Fld->Update();
 
 				if (!t->DecRef())
 				{
 					t->SetDirty(false);
 					t->SetWillDirty(false);
 				}
 			}
 		}
 	}
 
 	if (Fld)
 		Fld->OnUpdateUnRead(UnreadAdjust, false);
 
 	if (SelectIdx >= 0)
 	{
 		LListItem *i = MailList->ItemAt(SelectIdx);
 		if (!i && MailList->Length() > 0)
 			i = MailList->ItemAt(MailList->Length()-1);
 		if (i)
 			i->Select(true);
 	}
 
 	return true;
 }
 
 bool ScribeWnd::AddStore3EventHandler(LDataEventsI *callback)
 {
 	if (!d->Store3EventCallbacks.HasItem(callback))
 	{
 		d->Store3EventCallbacks.Add(callback);
 	}
 	return true;
 }
 
 bool ScribeWnd::RemoveStore3EventHandler(LDataEventsI *callback)
 {
 	d->Store3EventCallbacks.Delete(callback);
 	return true;
 }
 
 bool ScribeWnd::OnMailTransferEvent(MailTransferEvent *t)
 {
 	if (!Lock(_FL))
 		return false;
 
 	LAssert(t);
 	d->Transfers.Add(t);
 	Unlock();
 	
 	return true;
 }
 
 bool ScribeWnd::OnTransfer()
 {
 	LVariant v;
 	LArray<MailTransferEvent*> Local;
 	
 	// Lock the transfer list
 	if (Lock(_FL))
 	{
 		// Take out a bunch of emails...
 		for (int i=0; i<5 && d->Transfers.Length() > 0; i++)
 		{
 			auto t = d->Transfers[0];
 			LAssert(t);
 			d->Transfers.DeleteAt(0, true);
 
 			// Save them to a local array
 			Local.Add(t);
 		}
 
 		Unlock();
 
 		if (Local.Length() == 0)
 			// Didn't get any
 			return false;
 	}
 
 	LArray<LDataStoreI::StoreTrans> Trans;
 	for (auto &f: Folders)
 	{
 		if (f.Store)
 			Trans.New() = f.Store->StartTransaction();
 	}
 
 	for (auto Transfer: Local)
 	{
 		ReceiveStatus NewStatus = MailReceivedError;
 
 		if (!Transfer)
 		{
 			LAssert(0);
 			continue;
 		}
 		
 		// We have to set Transfer->Status to something other than "waiting"
 		// in all branches of this loop. Otherwise the account thread will hang.
 		
 		Accountlet *Acc = Transfer->Account;
 		#if DEBUG_NEW_MAIL
 		LgiTrace(	"%s:%i - NewMail.OnTransfer t=%p receive=%i act=%i\n",
 					_FL, Transfer, Acc->IsReceive(), Transfer->Action);
 		#endif
 		if (Acc->IsReceive())
 		{
 			switch (Transfer->Action)
 			{
 				default: break;
 				case MailDownload:
 				case MailDownloadAndDelete:
 				{
 					// Import newly received mail from file
 					ReceiveAccountlet *Receive = dynamic_cast<ReceiveAccountlet*>(Acc);
 					if (Receive)
 					{
 						LVariant Path = Receive->DestinationFolder();
 						ScribeFolder *Inbox = Path.Str() ? GetFolder(Path.Str()) : NULL;
 						if (!Inbox)
 							Inbox = GetFolder(FOLDER_INBOX);
 
 						if (Inbox)
 						{
 							Mail *m = new Mail(this, Inbox->GetObject()->GetStore()->Create(MAGIC_MAIL));
 							if (m)
 							{
 								// Just in case
 								m->SetParentFolder(Inbox);
 								
 								// Set the new flag...
 								m->SetFlags(m->GetFlags() | MAIL_NEW, true, false);
 
 								// Set the account to, which is used to map the email back
 								// to the incoming account in the case that the headers
 								// don't have the correct "To" information.
 								m->SetAccountId(Receive->Id());
 
 								// Decode the email
 								m->OnAfterReceive(Transfer->Rfc822Msg);
 								
 								LVariant v;
 								m->SetServerUid(v = Transfer->Uid);
 
 								// Save to permanent storage
 								if (m->Save(Inbox))
 								{
 									m->SetDirty(false);
 									
 									NewStatus = MailReceivedOk;
 
 									// Only after we've safely stored the email can we 
 									// actually mark it as downloaded.
 									if (Transfer->Uid)
 									{
 										Receive->AddMsg(Transfer->Uid);
 									}
 								}
 								else LgiTrace("%s:%i - Error: Couldn't save mail to folders.\n", _FL);
 							}
 							else LgiTrace("%s:%i - Error: Memory alloc failed.\n", _FL);
 						}
 						else LgiTrace("%s:%i - Error: No Inbox.\n", _FL);
 					}
 					else LgiTrace("%s:%i - Error: Bad ptr.\n", _FL);
 					
 					break;
 				}
 				case MailHeaders:
 				{
 					LList *Lst;
 					if (Transfer->Msg &&
 						(Lst = Transfer->GetList()))
 					{
 						//LgiTrace("Using Lst=%p\n", Lst);
 						Lst->Insert(Transfer->Msg);
 						NewStatus = MailReceivedOk;
 					}
 					break;
 				}
 			}
 		}
 		else if (Transfer->Send)
 		{
 			ScribeFolder *Outbox = GetFolder(Transfer->Send->SourceFolder);
 			if (!Outbox)
 				Outbox = GetFolder(FOLDER_OUTBOX);
 			if (!Outbox)
 				break;
 				
 			Outbox->GetMessageById(Transfer->Send->MsgId, [this, Transfer](auto m)
 			{
 				if (!m)
 				{
 					LAssert(!"Where is the email?");
 					LgiTrace("%s:%i - Can't find outbox for msg id '%s'\n", _FL, Transfer->Send->MsgId.Get());
 				}
 				else
 				{
 					if (Transfer->OutgoingHeaders)
 					{
 						m->SetInternetHeader(Transfer->OutgoingHeaders);
 						DeleteArray(Transfer->OutgoingHeaders);
 					}
 					
 					m->OnAfterSend();
 					m->Save();
 
 					// Do filtering
 					LVariant DisableFilters;
 					GetOptions()->GetValue(OPT_DisableUserFilters, DisableFilters);
 					if (!DisableFilters.CastInt32())
 					{
 						// Run the filters
 						List<Filter> Filters;
 						GetFilters(Filters, false, true, false);
 						if (Filters[0])
 						{													
 							List<Mail> In;
 							In.Insert(m);
 							
 							Filter::ApplyFilters(0, Filters, In);
 						}
 					}
 
 					// Add to bayesian spam whitelist...
 					LVariant v;
 					ScribeBayesianFilterMode FilterMode = BayesOff;
 					GetOptions()->GetValue(OPT_BayesFilterMode, v);
 					FilterMode = (ScribeBayesianFilterMode) v.CastInt32();
 
 					if (FilterMode != BayesOff &&
 						m->GetObject())
 					{
 						LDataIt To = m->GetObject()->GetList(FIELD_TO);
 						if (To)
 						{
 							for (LDataPropI *a = To->First();
 								a;
 								a = To->Next())
 							{
 								if (a->GetStr(FIELD_EMAIL))
 									WhiteListIncrement(a->GetStr(FIELD_EMAIL));
 							}
 						}
 					}
 
 					// FIXME:
 					// NewStatus = MailReceivedOk;
 				}
 			});
 		}
 
 		#if DEBUG_NEW_MAIL
 		LgiTrace(	"%s:%i - NewMail.OnTransfer t=%p NewStatus=%i\n",
 					_FL, Transfer, NewStatus);
 		#endif
 
 		if (NewStatus != MailReceivedOk)
 		{
 			// So tell the thread not to delete it from the server
 			LgiTrace("%s:%i - Mail[%i] error: %s\n", _FL, Transfer->Index, ReceiveStatusName(Transfer->Status));
 			Transfer->Action = MailNoop;
 		}
 
 		Transfer->Status = NewStatus;
 	}
 
 	return Local.Length() > 0;
 }
 
 bool ScribeWnd::OnIdle()
 {
 	bool Status = false;
 	
 	for (auto a : Accounts)
 		Status |= a->Receive.OnIdle();
 
 	Status |= OnTransfer();
 
 	LMessage m(M_SCRIBE_IDLE);
 	BayesianFilter::OnEvent(&m);
 
 	SaveDirtyObjects();	
 
 	#ifdef _DEBUG
 	static uint64_t LastTs = 0;
 	auto Now = LCurrentTime();
 	if (Now - LastTs >= 1000)
 	{
 		LastTs = Now;
 		if (Thing::DirtyThings.Length() > 0)
 			LgiTrace("%s:%i - Thing::DirtyThings=" LPrintfInt64 "\n", _FL, Thing::DirtyThings.Length());
 	}
 	#endif
 
 	return Status;
 }
 
 void ScribeWnd::OnScriptCompileError(const char *Source, Filter *f)
 {
 	const char *CompileMsg = LLoadString(IDS_ERROR_SCRIPT_COMPILE);
 	LArray<const char*> Actions;
 	Actions.Add(LLoadString(IDS_SHOW_CONSOLE));
 	Actions.Add(LLoadString(IDS_OPEN_SOURCE));
 	Actions.Add(LLoadString(IDS_OK));
 	if (!d->Bar)
 	{
 		// FYI Capabilities are handled in ScribeWnd::StartAction.
 		d->ErrSource = Source;
 		d->ErrFilter = f;
 		d->Bar = new MissingCapsBar(this, &d->MissingCaps, CompileMsg, this, Actions);
 		AddView(d->Bar, 2);
 		AttachChildren();
 		OnPosChange();
 	}
 }
 
 #ifdef _DEBUG
 #include "Store3Mail3/Mail3.h"
 
 class NoSaveOptions : public LOptionsFile
 {
 	bool Serialize(bool Write) { return true; }
 public:
 	NoSaveOptions(LOptionsFile *opts) :
 		LOptionsFile(PortableMode, AppName)
 	{
 	}
 };
 
 struct ScribeUnitTest
 {
 	uint64_t StartTs = 0;
 	int Timeout = 5000;
 
 	virtual ~ScribeUnitTest() {}
 	virtual void OnTimeout() {}
 	virtual void Run(std::function<void(bool)> Callback) = 0;
 
 	virtual void OnPulse()
 	{
 		if (StartTs != 0 &&
 			LCurrentTime() - StartTs >= Timeout)
 		{
 			LgiTrace("%s:%i - UnitTest timed out.\n", _FL);
 			StartTs = 0;
 			OnTimeout();
 		}
 	}
 };
 
 struct UnitTestState :
 	public LView::ViewEventTarget,
 	public LThread,
 	public LCancel
 {
 	ScribeWnd *App = NULL;
 	NoSaveOptions *Opts = NULL;
 	std::function<void(bool)> Callback;
 	LArray<ScribeUnitTest*> Tests;
 	LAutoPtr<ScribeUnitTest> t;
 	bool Status = true;
 	bool IsFinished = false;
 
 	// Old app state..
 	LAutoPtr<LOptionsFile> OldOpts;
 	LArray<LMailStore> OldFolders;
 
 	UnitTestState(ScribeWnd *app, std::function<void(bool)> callback);
 	~UnitTestState();
 	LMessage::Result OnEvent(LMessage *Msg) override;
 	bool Iterate();
 	bool Done();
 	int Main() override;
 	LDataStoreI *CreateTestMail3();
 
 	// Wrappers for protected elements:
 	LArray<LMailStore> &GetFolders() { return App->Folders; }
 	void UnLoadFolders() { App->UnLoadFolders(); }
 };
 
 #define UnitTestFail()	{ if (Callback) Callback(false); return; }
 #define UnitTestPass()	{ if (Callback) Callback(true); return; }
 
 // Basic load mail3 folder...
 struct LoadMailStore1 : public ScribeUnitTest
 {
 	UnitTestState *s;
 	LString folderPath;
 	bool GotCallback = false;
 	std::function<void(bool)> Callback;
 
 	LoadMailStore1(UnitTestState *state) : s(state)
 	{
 	}
 
 	~LoadMailStore1()
 	{
 		if (folderPath)
 		{
 			s->UnLoadFolders();
 
 			LFile::Path p = folderPath;
 			p--;
 			FileDev->RemoveFolder(p, true);
 		}
 		LAssert(GotCallback);
 	}
 
 	// Do operations on mail store before we try and load it...
 	virtual void OnMailStore(LDataStoreI *store) {}
 	virtual void ConfigureLoadMailStoreState(LoadMailStoreState *state) {}
 
 	void OnTimeout()
 	{
 		GotCallback = true;
 		Callback(false); // This should delete 'this'
 	}
 
 	void Run(std::function<void(bool)> cb)
 	{
 		Callback = cb;
 
 		if (auto store = s->CreateTestMail3())
 		{
 			folderPath = store->GetStr(FIELD_NAME);
 			OnMailStore(store);
 			delete store;
 		}
 
 		// Setup the options saying what folders to load...
 		s->Opts->CreateTag(OPT_MailStores);
 		auto MailStores = s->Opts->LockTag(OPT_MailStores, _FL);
 		if (MailStores == NULL)
 			UnitTestFail();
 
 		auto ms = MailStores->CreateTag(OPT_MailStore);
 		ms->SetAttr(OPT_MailStoreLocation, folderPath);
 		ms->SetAttr(OPT_MailStoreDisable, "0");
 		ms->SetAttr(OPT_MailStoreName, "testing");
 
 		s->Opts->Unlock();
 		if (!ms)
 			UnitTestFail();
 
 		// Try the load...
 		if (auto state = new LoadMailStoreState(s->App, [this](auto status)
 			{
 				GotCallback = true;
 
 				auto &Folders = s->GetFolders();
 				if (Folders.Length() == 0)
 					UnitTestFail()
 
 				bool found = false;
 				for (auto &f: Folders)
 				{
 					if (f.Path == folderPath &&
 						f.Store != NULL)
 					{
 						found = true;
 						break;
 					}
 				}
 				if (!found)
 					UnitTestFail();
 
 				Callback(status);
 			})
 		)
 		{
 			ConfigureLoadMailStoreState(state);
 			state->Start();
 		}
 	}
 };
 
 // This tests the DB schema upgrade functionality of the mail3 store.
 struct LoadMailStore2 : public LoadMailStore1
 {
 	LoadMailStore2(UnitTestState *state) :
 		LoadMailStore1(state)
 	{
 	}
 
 	void OnMailStore(LDataStoreI *store) override
 	{
 		auto ms3 = dynamic_cast<LMail3Store*>(store);
 		if (!ms3)
 			UnitTestFail();
 
 		// Delete a field from the database so that we force an "upgrade"
 		LMail3Store::LStatement s(ms3, "alter table Calendar rename column DateModified to DateMod");
 		if (!s.Exec())
 			UnitTestFail();
 	}
 
 	// This is a simple placeholder dialog to simulate asking the user to
 	// upgrade the mail store. It then returns a 'Yes' to the callback after
 	// a few seconds.
 	struct UpgradeYes : public LWindow
 	{
 		UnitTestState *s;
 		LoadMailStoreState::IntCb Cb;
 
 		UpgradeYes(UnitTestState *state, LoadMailStoreState::IntCb cb) :
 			s(state),
 			Cb(cb)
 		{
 			Name("Upgrade Dlg");
 			
 			// Just needs to be open long enough to run the msg loop a bit.
 			SetPulse(500);
 
 			LRect r(0, 0, 100, 100);
 			SetPos(r);
 			MoveSameScreen(s->App);
 
 			if (Attach(NULL))
 				Visible(true);
 		}
 
 		void OnPulse()
 		{
 			Cb(IDYES);
 			Quit();
 		}
 	};
 
 	void ConfigureLoadMailStoreState(LoadMailStoreState *state) override
 	{
 		state->AskStoreUpgrade = [this](auto path, auto detail, auto cb)
 		{
 			new UpgradeYes(s, cb);
 		};
 	}
 };
 
 UnitTestState::UnitTestState(ScribeWnd *app, std::function<void(bool)> callback) :
 	LView::ViewEventTarget(app, M_UNIT_TEST_TICK),
 	LThread("UnitTestState"),
 	App(app),
 	Callback(callback)
 {
 	OldOpts = App->d->Options;
 	OldFolders.Swap(App->Folders);
 	App->d->Options.Reset(Opts = new NoSaveOptions(OldOpts));
 
 	Tests.Add(new LoadMailStore1(this));
 	Tests.Add(new LoadMailStore2(this));
 	
 	LgiTrace("%s:%i - Starting with " LPrintfInt64 " unit tests.\n", _FL, Tests.Length());
 	Run();
 }
 
 UnitTestState::~UnitTestState()
 {
 	Cancel();
 
 	// Restore app state...
 	App->d->Options = OldOpts;
 	OldFolders.Swap(App->Folders);
 
 	WaitForExit();
 }
 
 LMessage::Result UnitTestState::OnEvent(LMessage *Msg)
 {
 	if (!IsFinished &&
 		Msg->Msg() == M_UNIT_TEST_TICK)
 	{
 		if (t)
 			t->OnPulse();
 		else
 			Iterate();
 	}
 	return 0;
 }
 
 bool UnitTestState::Iterate()
 {
 	if (Tests.Length() == 0)
 		return Done();
 		
 	t.Reset(Tests[0]);
 	Tests.DeleteAt(0, true);
 	t->StartTs = LCurrentTime();
 	LgiTrace("%s:%i - Running unit test..\n", _FL);
 	t->Run([this](auto ok)
 	{
 		LgiTrace("%s:%i - Unit test status: %i\n", _FL, ok);
 		Status &= ok;
 		t.Reset(); // Reset for the next unit test.
 	});
 
 	return true;
 }
 
 bool UnitTestState::Done()
 {
 	// Stop more tick events..
 	IsFinished = true;
 	Cancel();
 
 	if (Callback)
 		Callback(Status);
 
 	delete this;
 	return true;
 }
 
 int UnitTestState::Main()
 {
 	while (!IsCancelled())
 	{
 		PostEvent(M_UNIT_TEST_TICK);
 		LSleep(500);
 	}
 
 	return 0;
 }
 
 LDataStoreI *UnitTestState::CreateTestMail3()
 {
 	LFile::Path p(ScribeTempPath());
 	p += "UnitTesting";
 	if (!p.Exists())
 		FileDev->CreateFolder(p);
 	p += "Folders.mail3";
 
 	return App->CreateDataStore(p, true);
 }
 
 void ScribeWnd::UnitTests(std::function<void(bool)> Callback)
 {
 	UnLoadFolders();
 	new UnitTestState(this, Callback);
 }
 
 #endif
diff --git a/src/ScribeFolder.cpp b/src/ScribeFolder.cpp
--- a/src/ScribeFolder.cpp
+++ b/src/ScribeFolder.cpp
@@ -1,4430 +1,4108 @@
 /*
 **	FILE:			ScribeFolder.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			17/1/2000
 **	DESCRIPTION:	Scribe folder's
 **
 **	Copyright (C) 2000-2002, Matthew Allen
 **		fret@memecode.com
 */
 
 // Includes
 #include "Scribe.h"
 #include "lgi/common/DropFiles.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/QuickSort.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/TextFile.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/ClipBoard.h"
 
 #include "Calendar.h"
 #include "resdefs.h"
 #include "ReplicateDlg.h"
 #include "FolderTask.h"
 
 //////////////////////////////////////////////////////////////////////////////
 #if WINNATIVE
 #include "lgi/common/Com.h"
 #endif
 
 class LDndFilePromise
 	#if defined(WINDOWS)
 	#elif defined(__GTK_H__)
 	#elif defined(MAC)
 	#endif
 {
 	LStream *Src;
 	#if WINNATIVE
 	FILEGROUPDESCRIPTOR Gd;
 	#elif defined(__GTK_H__)
 	#elif defined(MAC)
 	#endif
 	
 public:
 	LDndFilePromise(LDragData &dd, LStream *src, LString FileName)
 	{
 		Src = src;
 		
 		#if WINNATIVE
 		
 			ZeroObj(Gd);
 			Gd.cItems = 1;
 			
 			// CLSID Fd.clsid;
 			// SIZEL Fd.sizel;
 			// POINTL Fd.pointl;
 			// FILETIME Fd.ftCreationTime;
 			// FILETIME Fd.ftLastAccessTime;
 			// FILETIME Fd.ftLastWriteTime;
 			
 			FILEDESCRIPTOR &Fd = Gd.fgd[0];
 			Fd.dwFlags = FD_ATTRIBUTES | FD_PROGRESSUI;
 			Fd.dwFileAttributes = FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_NORMAL;
 
 			int64 Sz = Src->GetSize();
 			if (Sz >= 0)
 			{
 				Fd.dwFlags |= FD_FILESIZE;
 				Fd.nFileSizeHigh = Sz >> 32;
 				Fd.nFileSizeLow = Sz & 0xffffffff;
 			}
 
 			auto Leaf = FileName.RFind(DIR_STR);
 			LAutoWString FnW(Utf8ToWide(Leaf >= 0 ? FileName(Leaf+1,-1) : FileName));
 			Strcpy(Fd.cFileName, CountOf(Fd.cFileName), FnW.Get());
 
 			LVariant &v = dd.Data[0];
 			v.SetBinary(sizeof(Gd), &Gd);
 		
 		#elif defined(__GTK_H__)
 
 			LAssert(!"Not impl.");
 
 		#elif LGI_COCOA
 		
 			LAssert(!"Not impl.");
 		
 		#elif LGI_CARBON
 		
 			// See Apple: Technical Note TN1085
 			// https://web.archive.org/web/20080725134839/http://developer.apple.com/technotes/tn/tn1085.html
 		
 			// flavorTypePromiseHFS = 'phfs'
 			PromiseHFSFlavor Promise;
 			ZeroObj(Promise);
 			Promise.fileType = 'mbox';
 			Promise.fileCreator = '****';
 			Promise.promisedFlavor = kDragPromisedFlavor; // 'fssP'
 			int Sz = sizeof(Promise);
 
 			LVariant &v1 = dd.Data[0];
 			v1.SetBinary(sizeof(Promise), &Promise, false);
 		
 			// The Dnd code will add the 2nd part of the promise
 			// There isn't the visibility into that API at this level
 
 		#else
 
 			#error "Impl me."
 
 		#endif
 	}
 	
 	~LDndFilePromise()
 	{
 		#if defined(WINDOWS)
 		#elif defined(__GTK_H__)
 		#elif defined(MAC)
 		#endif
 	}
 
 	#if defined(WINDOWS)
 	#elif defined(__GTK_H__)
 	#elif defined(MAC)
 	#endif
 
 	int AddContents(LDragData &dd)
 	{
 		dd.Data[0] = Src;
 		return 1;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 #define PROFILE_POPULATE			0
 #define PROFILE_LOAD_THINGS			0
 
 int FoldersCurrentlyLoading =		0;
 
 char ScribeFolderObject[] = "com.memecode.Folder";
 
 class ScribeFolderPriv
 {
 public:
 	int8 IsInbox = -1;
 	bool InUpdateUnread = false;
 	LAutoPtr<LDisplayString> DsBase;
 	LAutoPtr<LDisplayString> DsUnread;
 	LAutoPtr<LDndFilePromise> FilePromise;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 ScribeFolder::ScribeFolder()
 {
 	d = new ScribeFolderPriv;
 }
 
 ScribeFolder::~ScribeFolder()
 {
 	bool IsRoot = !GetParent();
 
 	if (CurState != FldState_Idle)
 	{
 		// int Cur = FoldersCurrentlyLoading;
 
 		#ifdef _DEBUG
 		LAssert(!"Can't delete folder while it's busy.");
 		#else
 		LgiMsg(	App,
 				"Can't unload folder while busy. Please report what\n"
 				"you were attempting to do to fret@memecode.com",
 				"Scribe Error",
 				MB_OK);
 		#endif
 		return;
 	}
 
 	switch (GetItemType())
 	{
 		case MAGIC_CALENDAR:
 			CalendarSource::FolderDelete(this);
 			// fall through
 		case MAGIC_CONTACT:
 		case MAGIC_FILTER:
 		case MAGIC_GROUP:
 			App->RemoveThingSrc(this);
 			break;
 		default:
 			break;
 	}
 	
 	if (View())
 	{
 		bool IsMe = View()->GetContainer() == this;
 		// bool IsSelect = Select();
 		
 		View()->DeletePlaceHolders();
 		
 		if (IsMe)
 		{
 			View()->SetContainer(0);
 			View()->RemoveAll();
 		}
 	}
 
 	Thing *t;
 	int i = 0;
 	while ((t = Items[i]))
 	{
 		if (!t->DecRef())
 			i++;
 	}
 
 	Update();
 	EmptyFieldList();
 	DeleteObj(d);
 
 	ScribeFolder *f = GetChildFolder();
 	DeleteObj(f);
 	if (!IsRoot)
 	{
 		f = GetNextFolder();
 		DeleteObj(f);
 	}
 
 	// Don't delete 'Object' here, it's owned by the backend storage object
 }
 
 bool ScribeFolder::SetObject(LDataI *o, bool InDestructor, const char *File, int Line)
 {
 	if (CurState != FldState_Idle)
 	{
 		LAssert(!"Can't set object while folder is not idle.");
 		return false;
 	}
 
 	return LDataUserI::SetObject(o, InDestructor, File, Line);
 }
 
 void ScribeFolder::UpdateOsUnread()
 {
 	#ifdef WIN32
 	if (App->GetFolder(FOLDER_INBOX) == this)
 	{
 		LHashTbl<StrKey<char,false>, int> Un(0, -1);
 
 		// Pre-populate 'Un' with our email accounts
 		List<ScribeAccount> *Acc = App->GetAccounts();
 		if (Acc)
 		{
 			for (auto a: *Acc)
 			{
 				LVariant e = a->Identity.Email();
 				if (e.Str())
 					Un.Add(e.Str(), 0);
 			}
 		}
 
 		// Scan folder for unread email...		
 		for (auto t : Items)
 		{
 			Mail *m = t->IsMail();
 			if (m)
 			{
 				if (!TestFlag(m->GetFlags(), MAIL_READ))
 				{
 					ScribeAccount *a = m->GetAccountSentTo();
 					if (a)
 					{
 						LVariant Email;
 						Email = a->Identity.Email();
 						if (Email.Str())
 						{
 							int Cur = Un.Find(Email.Str());
 							Un.Add(Email.Str(), Cur + 1);
 						}
 					}
 				}
 			}
 		}
 
 		#if 0
 		// Set system email status
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		if ((Os == LGI_OS_WIN32 || Os == LGI_OS_WIN64) && (Ver[0] > 5 || (Ver[0] == 5 && Ver[1] > 0)))
 		{
 			char e[256];
 			LgiGetExeFile(e, sizeof(e));
 
 			typedef HRESULT (__stdcall *pSHSetUnreadMailCount)(LPCWSTR pszMailAddress, DWORD dwCount,LPCWSTR pszShellExecuteCommand);
 			LLibrary Shell32("shell32");
 			pSHSetUnreadMailCount SHSetUnreadMailCount = (pSHSetUnreadMailCount) Shell32.GetAddress("SHSetUnreadMailCountW");
 			if (SHSetUnreadMailCount)
 			{
 				LVariant Exe;
 				Exe = e;
 
 				char *k;
 				for (int u=Un.First(&k); u>=0; u=Un.Next(&k))
 				{
 					LVariant Email = k;
 					SHSetUnreadMailCount(Email.WStr(), u, Exe.WStr());
 				}
 			}
 		}
 		#endif
 	}
 	#endif
 }
 
 void ScribeFolder::SetLoadOnDemand()
 {
 	if ((LoadOnDemand = new LTreeItem))
 	{
 		Expanded(false);
 		LoadOnDemand->SetText((char*)LLoadString(IDS_LOADING));
 		Insert(LoadOnDemand);
 	}
 }
 
 void ScribeFolder::GetMessageById(const char *Id, std::function<void(Mail*)> Callback)
 {
 	if (!Id)
 	{
 		if (Callback) Callback(NULL);
 		return;
 	}
 
 	LoadThings(NULL, [this, Id=LString(Id), Callback](auto s)
 	{
 		if (s < Store3Delayed)
 		{
 			if (Callback) Callback(NULL);
 			return;
 		}
 
 		for (auto t : Items)
 		{
 			Mail *r = t->IsMail();
 			if (!r)
 				continue;
 		
 			auto rid = r->GetMessageId();
 			if (!Stricmp(rid, Id.Get()))
 			{
 				if (Callback)
 					Callback(r);
 				return;
 			}
 		}
 	});
 }
 
 bool ScribeFolder::InsertThing(Thing *t)
 {
 	bool Status = false;
 
 	if (t && Select() && View())
 	{
 		// Filter
 		ThingFilter *Filter = App->GetThingFilter();
 		t->SetFieldArray(FieldArray);
 		if (!Filter || Filter->TestThing(t))
 		{
 			if (t->GetList() != View())
 			{
 				View()->Insert(t);
 				#if WINNATIVE
 				UpdateWindow(View()->Handle());
 				#endif
 			}
 		}
 		Status = true;
 	}
 
 	return Status;
 }
 
 bool ScribeFolder::GetThreaded()
 {
 	return GetObject() ? GetObject()->GetInt(FIELD_FOLDER_THREAD) != 0 : false;
 }
 
 void ScribeFolder::SetThreaded(bool t)
 {
 	if (GetObject() && GetThreaded() ^ t)
 	{
 		GetObject()->SetInt(FIELD_FOLDER_THREAD, t);
 		SetDirty();
 	}
 }
 
 ThingList *ScribeFolder::View()
 {
 	return	App ? App->GetMailList() : 0;
 }
 
 bool ScribeFolder::HasFieldId(int Id)
 {
 	auto o = GetFldObj();
 	if (o)
 	{
 		for (LDataPropI *f = o->Fields().First(); f; f = o->Fields().Next())
 		{
 			if (Id == f->GetInt(FIELD_ID))
 			{
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 void ScribeFolder::SetFolderPerms(LView *Parent, ScribeAccessType Access, ScribePerm Perm, std::function<void(bool)> Callback)
 {
 	ScribePerm Current = GetFolderPerms(Access);	
 	int Field = (Access == ScribeReadAccess) ? FIELD_FOLDER_PERM_READ : FIELD_FOLDER_PERM_WRITE;
 
 	if (GetObject() && Current != Perm)
 	{
 		App->GetAccessLevel(Parent, Current, GetPath(), [this, Field, Perm, Callback](auto Allow)
 		{
 			if (Allow)
 			{
 				GetObject()->SetInt(Field, Perm);
 				SetDirty();
 			}
 			if (Callback)
 				Callback(Allow);
 		});
 	}
 	else
 	{
 		if (Callback)
 			Callback(true); // i.e. not changing
 	}
 }
 
 ScribePerm ScribeFolder::GetFolderPerms(ScribeAccessType Access)
 {
 	int Field = (Access == ScribeReadAccess) ? FIELD_FOLDER_PERM_READ : FIELD_FOLDER_PERM_WRITE;
 	return GetObject() ? (ScribePerm)GetObject()->GetInt(Field) : PermRequireNone;
 }
 
 Store3Status ScribeFolder::CopyTo(ScribeFolder *NewParent, int NewIndex)
 {
 	Store3Status Copied = Store3Error;
 
 	if (NewParent == GetParent())
 	{
 		NewParent->GetObject()->GetStore();
 	}
 	else if (GetObject() &&
 			GetObject()->GetStore() &&
 			NewParent->GetObject() &&
 			NewParent->GetObject()->GetStore())
 	{
 		// Find or create the destination folder
 		LDataFolderI *Dst = 0;
 		auto Name = GetObject()->GetStr(FIELD_FOLDER_NAME);
 		for (ScribeFolder *f = NewParent->GetChildFolder(); f; f = f->GetNextFolder())
 		{
 			auto n = f->GetObject()->GetStr(FIELD_FOLDER_NAME);
 			if (n && !_stricmp(n, Name))
 			{
 				Dst = f->GetFldObj();
 			}
 		}
 
 		if (!Dst)
 		{
 			// Create sub-folder
 			if ((Dst = dynamic_cast<LDataFolderI*>(NewParent->GetObject()->GetStore()->Create(GetObject()->Type()))))
 			{
 				Dst->CopyProps(*GetObject());
 				if (Dst->Save(NewParent->GetObject()) == Store3Error)
 					return Store3Error;
 			}
 			else return Store3Error;
 		}
 
 		if (Dst)
 		{
 			Copied = Store3ReplicateFolders(App, Dst, GetFldObj(), true, false, 0);
 		}
 	}
 	else LAssert(!"Pointer error");
 
 	return Copied;
 }
 
 Store3Status ScribeFolder::SetFolder(ScribeFolder *f, int Param)
 {
 	Store3Status Moved = Store3Error;
 
 	if (f == this)
 	{
 		LAssert(0);
 	}
 	else if (f &&
 			GetObject() &&
 			GetObject()->GetStore() &&
 			f->GetObject() &&
 			f->GetObject()->GetStore())
 	{
 		if (GetObject()->GetStore() == f->GetObject()->GetStore())
 		{
 			// Simple in storage movement
 			LArray<LDataI*> Mv;
 			Mv.Add(GetObject());
 			Moved = GetObject()->GetStore()->Move(f->GetFldObj(), Mv);
 			if (Moved && Param >= 0)
 			{
 				GetObject()->SetInt(FIELD_FOLDER_INDEX, Param);
 			}
 		}
 		else
 		{
 			// Cross storage movement...
 
 			// Find or create the destinate folder
 			LDataFolderI *Dst = 0;
 			int Idx = 0;
 			auto Name = GetObject()->GetStr(FIELD_FOLDER_NAME);
 			for (ScribeFolder *c = f->GetChildFolder(); c; c = c->GetNextFolder(), Idx++)
 			{
 				auto n = c->GetObject()->GetStr(FIELD_FOLDER_NAME);
 				if (n && !_stricmp(n, Name))
 				{
 					Dst = c->GetFldObj();
 					break;
 				}
 			}
 
 			if (!Dst)
 			{
 				Dst = dynamic_cast<LDataFolderI*>(f->GetObject()->GetStore()->Create(f->Type()));
 			}
 			else
 			{
 				ScribeFolder *c = CastFolder(dynamic_cast<LDataFolderI*>(Dst));
 				if (c)
 				{
 					c->Remove();
 					Param = Idx;
 					DeleteObj(c);
 				}
 			}
 
 			if (Dst)
 			{
 				if (View())
 					View()->RemoveAll();
 
 				// Clean up all the items and sub-folders, they will be created by the 
 				// replication code calling "OnNew".
 				Thing *t;
 				while ((t = Items[0]))
 				{
 					t->DecRef();
 					Items.Delete(t);
 				}
 				
 				// Delete the child folders...
 				ScribeFolder *Cf;
 				while ((Cf = GetChildFolder()))
 				{
 					DeleteObj(Cf);
 				}
 
 				// Copy ourself over...
 				Dst->CopyProps(*GetObject());
 				
 				LDataFolderI *Old = GetFldObj();
 				SetObject(Dst, false, _FL);				
 
 				// Save the object to the new store...
 				Store3Status s = GetObject()->Save(f->GetObject());
 				if (s != Store3Error)
 				{
 					// And replicate all the children objects...
 					Moved = Store3ReplicateFolders(App, GetFldObj(), Old, true, true, 0);
 				}
 			}
 			else LAssert(!"Not a valid folder");
 		}
 
 		if (Moved == Store3Success)
 		{
 			// Move LTreeItem node...
 			f->Insert(this, Param);
 			Select(true);
 			LoadFolders();
 
 			// Adjust all the other indexes so that it's remembered
 			ScribeFolder *p = GetFolder();
 			if (p)
 			{
 				int Idx = 0;
 				for (p = p->GetChildFolder(); p; p = p->GetNextFolder())
 				{
 					p->SetSortIndex(Idx++);
 					p->SetDirty();
 				}
 			}
 		}
 	}
 	else LAssert(!"Pointer error");
 
 	return Moved;
 }
 
 Store3Status ScribeFolder::DeleteAllThings(std::function<void(Store3Status)> Callback)
 {
 	if (!GetFldObj())
 		return Store3Error;
 		
 	Store3Status r = GetFldObj()->DeleteAllChildren();
 	if (r == Store3Error)
 	{
 		LAssert(!"DeleteAllChildren failed.");
 	}
 	else if (r == Store3Success)
 	{
 		LAssert(Items.Length() == 0);
 		OnUpdateUnRead(0, true);
 		Update();
 	}
 
 	return r;
 }
 
 Store3Status ScribeFolder::DeleteThing(Thing *t, std::function<void(Store3Status)> Callback)
 {
 	Store3Status Status = Store3Error;
 
 	if (t && t->GetObject())
 	{
 		if (t->IsAttachment())
 		{
 			#ifdef _DEBUG
 			Mail *m =
 			#endif
 			t->IsAttachment()->GetOwner();
 			LAssert(m && Items.HasItem(m));
 		}
 
 		if (t->GetObject()->Delete())
 		{
 			t->SetParentFolder(NULL);
 			if (View())
 				View()->Remove(t);
 		}
 	}
 
 	return Status;
 }
 
 Store3Status ScribeFolder::WriteThing(Thing *t, std::function<void(Store3Status)> Callback)
 {
 	if (!t)
 	{
 		if (Callback) Callback(Store3Error);
 		return Store3Error;
 	}
 
 	auto ParentFolder = GetFolder();
 	auto Path = ParentFolder ? ParentFolder->GetPath() : NULL;
 
 	auto OnAllow = [this, t, Callback]()
 	{
 		// Generic thing storage..
 		bool Create = !t->GetObject();
 		if (Create)
 			t->SetObject(GetObject()->GetStore()->Create(t->Type()), false, _FL);
 
 		if (!t->GetObject())
 		{
 			LAssert(!"No object?");
 			LgiTrace("%s:%i - No object to save.\n", _FL);
 			if (Callback) Callback(Store3Error);
 			return;
 		}
 
 		// saving a thing that already has an item on disk
 		auto Obj = GetObject();
 		auto Status = t->GetObject()->Save(Obj);
 		if (Status != Store3Error)
 		{
 			// The ScribeWnd::OnNew will take care of inserting the item into the
 			// right folder, updating the unread count, any filtering etc.
 			t->OnSerialize(true);
 			if (Callback) Callback(Status);
 		}
 		else
 		{
 			if (Create)
 				t->SetObject(NULL, false, _FL);
 			LgiTrace("%s:%i - Object->Save returned %i.\n", _FL, Status);
 			if (Callback) Callback(Store3Error);
 		}
 	};
 
 	if (App)
 		App->GetAccessLevel(App,
 							GetWriteAccess(),
 							Path,
 							[OnAllow](auto Allow)
 							{
 								if (Allow)
 									OnAllow();
 							});
 	else
 		OnAllow();	
 
 	return Store3Success;
 }
 
 int ThingContainerNameCmp(LTreeItem *a, LTreeItem *b, NativeInt d)
 {
 	ScribeFolder *A = dynamic_cast<ScribeFolder*>(a);
 	ScribeFolder *B = dynamic_cast<ScribeFolder*>(b);
 	if (A && B)
 	{
 		const char *s1 = A->GetText();
 		const char *s2 = B->GetText();
 		const char *Empty = "";
 		return _stricmp(s1?s1:Empty, s2?s2:Empty);
 	}
 	else LAssert(!"Invalid objects.");
 
 	return 0;
 }
 
 int ThingContainerIdxCmp(LTreeItem *a, LTreeItem *b, NativeInt d)
 {
 	ScribeFolder *A = dynamic_cast<ScribeFolder*>(a);
 	ScribeFolder *B = dynamic_cast<ScribeFolder*>(b);
 	if (A && B)
 	{
 		int Aidx = A->GetSortIndex();
 		int Bidx = B->GetSortIndex();
 		if (Aidx >= 0 || Bidx >= 0)
 		{
 			return Aidx - Bidx;
 		}
 	}
 	else LAssert(!"Invalid objects.");
 
 	return 0;
 }
 
 void ScribeFolder::SortSubfolders()
 {
 	int i = 0;
 	ScribeFolder *c;
 
 	LTreeItem::Items.Sort(ThingContainerNameCmp);
 
 	for (c = GetChildFolder(); c; c = c->GetNextFolder())
 	{
 		c->SetSortIndex(i++);
 		c->SetDirty();
 	}
 
 	GetTree()->UpdateAllItems();
 	GetTree()->Invalidate();
 }
 
 void ScribeFolder::DoContextMenu(LMouse &m)
 {
 	MailTree *mt = dynamic_cast<MailTree*>(GetTree());
 	LScriptUi s(new LSubMenu);
 	List<Mail> Templates;
 	bool ForceDelete = m.Shift();
 	bool IsTrash = false;
 	bool IsSystem = false;
 
 	if (!s.Sub)
 		return;
 
 	IsTrash = GetItemType() == MAGIC_ANY;
 	IsSystem = App->GetFolderType(this) >= 0;
 
 	if (App->GetFolderType(this) == FOLDER_OUTBOX)
 	{
 		s.Sub->AppendItem(LLoadString(IDS_MARK_ALL_SEND), IDM_MARK_SEND, true);
 	}
 
 	if (IsTrash)
 	{
 		s.Sub->AppendItem(LLoadString(IDS_EMPTY), IDM_EMPTY, true);
 		s.Sub->AppendItem(LLoadString(IDS_MARK_ALL_READ), IDM_MARK_ALL_READ, true);
 	}
 	else if (!IsRoot())
 	{
 		auto *LiteralNew = LLoadString(IDS_NEW);
 		const char *Type = 0;
 		switch (GetItemType())
 		{
 			case MAGIC_MAIL:
 				Type = LLoadString(IDS_MAIL);
 				break;
 			case MAGIC_CONTACT:
 				Type = LLoadString(IDS_CONTACT);
 				break;
 			case MAGIC_CALENDAR:
 				Type = LLoadString(IDS_CAL_EVENT);
 				break;
 			case MAGIC_FILTER:
 				Type = LLoadString(IDS_FILTER);
 				break;
 			default:
 				break;
 		}
 
 		if (Type)
 		{
 			char Str[256];
 			sprintf_s(Str, sizeof(Str), "%s %s", LiteralNew, Type);
 			s.Sub->AppendItem(Str, IDM_NEW_EMAIL, true);
 		}
 	}
 
 	switch (GetItemType())
 	{
 		case MAGIC_CONTACT:
 		{
 			char Str[256];
 			const char *LiteralEmail = LLoadString(IDS_EMAIL);
 
 			sprintf_s(Str, sizeof(Str), "%s '%s'", LiteralEmail, GetText());
 			s.Sub->AppendItem(Str, IDM_EMAIL_GROUP, true);
 
 			ScribeFolder *f = App->GetFolder(FOLDER_TEMPLATES);
 			if (f)
 			{
 				// FIXME
 				f->LoadThings();
 
 				auto Merge = s.Sub->AppendSub(LLoadString(IDS_MERGE_TEMPLATE));
 				if (Merge)
 				{
 					int n = 0;
 					for (auto t: f->Items)
 					{
 						Mail *m = t->IsMail();
 						if (m)
 						{
 							Templates.Insert(m);
 							Merge->AppendItem(m->GetSubject()?m->GetSubject():(char*)"(no subject)", IDM_MERGE_TEMPLATE_BASE+n++, true);
 						}
 					}
 				}
 			}
 			else
 			{
 				s.Sub->AppendItem(LLoadString(IDS_MERGE_TEMPLATE), 0, false);
 			}
 
 			s.Sub->AppendItem(LLoadString(IDS_MERGE_FILE), IDM_MERGE_FILE, true);
 			break;
 		}
 		case MAGIC_MAIL:
 		{
 			if (!IsRoot())
 			{
 				s.Sub->AppendItem(LLoadString(IDC_COLLECT_SUB_MAIL), IDM_COLLECT_MAIL, true);
 				s.Sub->AppendItem(LLoadString(IDS_MARK_ALL_READ), IDM_MARK_ALL_READ, true);
 
 				if (GetObject() &&
 					GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 				{
 					s.Sub->AppendItem(LLoadString(IDC_UNDELETE), IDM_UNDELETE, true);
 					s.Sub->AppendItem("Expunge", IDM_EXPUNGE, true);
 					s.Sub->AppendItem(LLoadString(IDC_REFRESH), IDM_REFRESH, true);
 				}
 			}
 			break;
 		}
 		default:
 			break;
 	}
 
 	if (s.Sub->ItemAt(0))
 	{
 		s.Sub->AppendSeparator();
 	}
 
 	s.Sub->AppendItem(LLoadString(IDS_FIND), IDM_FIND, true);
 	s.Sub->AppendSeparator();
 
 	bool HasFolderTask = App->HasFolderTasks();
 	bool FolderOp = !HasFolderTask && !IsRoot();
 	s.Sub->AppendItem(LLoadString(IDS_DELETEFOLDER), IDM_DELETE, FolderOp && ((!IsTrash && !IsSystem) || ForceDelete));
 	s.Sub->AppendItem(LLoadString(IDS_CREATESUBFOLDER), IDM_CREATE_SUB, !HasFolderTask && CanHaveSubFolders(GetItemType()));
 	s.Sub->AppendItem(LLoadString(IDS_RENAMEFOLDER), IDM_RENAME, FolderOp);
 	
 	auto ExportMimeType = GetStorageMimeType();
 	s.Sub->AppendItem(LLoadString(IDS_EXPORT), IDM_EXPORT, FolderOp && ExportMimeType != NULL);
 	s.Sub->AppendSeparator();
 
 	s.Sub->AppendItem(LLoadString(IDS_SORT_SUBFOLDERS), IDM_SORT_SUBFOLDERS, true);
 	s.Sub->AppendItem(LLoadString(IDS_COPY_PATH), IDM_COPY_PATH, true);
 	s.Sub->AppendItem(LLoadString(IDS_PROPERTIES), IDM_PROPERTIES, true);
 
 	LArray<LScriptCallback*> Callbacks;
 	if (App->GetScriptCallbacks(LFolderContextMenu, Callbacks))
 	{
 		LScriptArguments Args(NULL);
 
 		Args[0] = new LVariant(App);
 		Args[1] = new LVariant(this);
 		Args[2] = new LVariant(&s);
 
 		for (auto c: Callbacks)
 			App->ExecuteScriptCallback(*c, Args);
 
 		Args.DeleteObjects();
 	}
 
 	m.ToScreen();
 	LPoint Scr = _ScrollPos();
 	m.x -= Scr.x;
 	m.y -= Scr.y;
 
 	int Msg = s.Sub->Float(GetTree(), m.x, m.y);
 	switch (Msg)
 	{
 		case IDM_NEW_EMAIL:
 		{
 			switch (GetItemType())
 			{
 				case MAGIC_MAIL:
 				case MAGIC_CONTACT:
 				case MAGIC_CALENDAR:
 				case MAGIC_FILTER:
 				{
 					if (App)
 						App->CreateItem(GetItemType(), this);
 					break;
 				}
 				default:
 					break;
 			}
 			break;
 		}
 		case IDM_MARK_SEND:
 		{
 			for (Thing *i: Items)
 			{
 				Mail *m = i->IsMail();
 				if (m)
 				{
 					m->SetFlags(MAIL_READY_TO_SEND | MAIL_READ | MAIL_CREATED);
 					m->SetDirty();
 					m->Update();
 				}
 			}
 			break;
 		}
 		case IDM_EMAIL_GROUP:
 		{
 			if (App)
 			{
 				Mail *m = dynamic_cast<Mail*>(App->CreateItem(MAGIC_MAIL, NULL, false));
 				if (m)
 				{
 					MailUi *UI = dynamic_cast<MailUi*>(m->DoUI());
 					if (UI)
 					{
 						List<Contact> Cts;
 						App->GetContacts(Cts, this);
 						for (auto c: Cts)
 						{
 							UI->AddRecipient(c);
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDM_FIND:
 		{
 			ScribeFolder *Folder = (ScribeFolder*) GetTree()->Selection();
 			OpenFinder(App, Folder);
 			break;
 		}
 		case IDM_CREATE_SUB:
 		{
 			if (mt)
 				mt->OnCreateSubDirectory(this);
 			break;
 		}
 		case IDM_DELETE:
 		{
 			if (mt)
 				mt->OnDelete(this, ForceDelete);
 			break;
 		}
 		case IDM_RENAME:
 		{
 			auto Dlg = new FolderNameDlg(mt, GetName(true));
 			Dlg->DoModal([this, Dlg, mt](auto dlg, auto id)
 			{
 				if (id && ValidStr(Dlg->Name))
 				{
 					// check for folder name conflicts...
 					ScribeFolder *ParentFolder = GetFolder();
 					LString Path;
 					if (ParentFolder)
 					    Path = ParentFolder->GetPath();
 					if (Path)
 					{
 						char s[256];
 						sprintf_s(s, sizeof(s), "%s/%s", Path.Get(), Dlg->Name);
 						if (App->GetFolder(s))
 						{
 							LgiMsg(mt, LLoadString(IDS_SUBFLD_NAME_CLASH), AppName, MB_OK);
 							return;
 						}
 					}
 
 					// change the folders name...
 					OnRename(Dlg->Name);
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_EXPORT:
 		{
 			LString DropName = LGetLeaf(GetDropFileName());
 			if (!DropName)
 			{
 				LgiTrace("%s:%i - Failed to create folder name.\n", _FL);
 				break;
 			}
 
 			auto s = new LFileSelect(mt);
 			s->Name(DropName);
 			s->Save([this, ExportMimeType](auto s, auto ok)
 			{
 				LAutoPtr<LFileSelect> mem(s);
 				if (ok)
 				{
 					if (LFileExists(s->Name()))
 					{
 						LString a, b;
 						a.Printf(LLoadString(IDS_ERROR_FILE_EXISTS), s->Name());
 						b.Printf("\n%s\n", LLoadString(IDS_ERROR_FILE_OVERWRITE));
 						if (LgiMsg(GetTree(), a + b, AppName, MB_YESNO) == IDNO)
 							return;
 					}
 
 					LAutoPtr<LFile> f(new LFile);
 					if (!f || !f->Open(s->Name(), O_WRITE))
 					{
 						LgiTrace("%s:%i - Failed to open '%s' for writing.\n", _FL, s->Name());
 						return;
 					}
 					
 					f->SetSize(0);
 					LAutoPtr<LStreamI> str(f.Release());
 					ExportAsync(str, ExportMimeType);
 				}
 			});
 			break;
 		}
 		case IDM_EMPTY:
 		{
 			if (App->GetMailList())
 			{
 				App->GetMailList()->RemoveAll();
 				
 				LArray<LDataI*> Del;
 				for (ScribeFolder *c = GetChildFolder(); c; c = c->GetNextFolder())
 					Del.Add(c->GetObject());
 				if (Del.Length())
 					GetObject()->GetStore()->Delete(Del, false);
 
 				DeleteAllThings([mt](auto status)
 				{
 					mt->Invalidate();
 				});
 			}
 			break;
 		}
 		case IDM_SORT_SUBFOLDERS:
 		{
 			SortSubfolders();	
 			break;
 		}
 		case IDM_PROPERTIES:
 		{
 			mt->OnProperties(this);
 			break;
 		}
 		case IDM_COPY_PATH:
 		{
 			LClipBoard c(GetTree());
 			#ifdef WINDOWS
 				LAutoWString w(Utf8ToWide(GetPath()));
 				c.TextW(w);
 			#else
 				c.Text(GetPath());
 			#endif
 			break;
 		}
 		case IDM_COLLECT_MAIL:
 		{
 			CollectSubFolderMail();
 			break;
 		}
 		case IDM_MARK_ALL_READ:
 		{
 			LArray<LDataI*> Change;
 			for (auto c : Items)
 			{
 				Mail *m = c->IsMail();
 				if (m)
 				{
 					if (!TestFlag(m->GetFlags(), MAIL_READ))
 						Change.Add(m->GetObject());
 				}
 			}
 
 			LVariant v = MAIL_READ;
 			if (GetObject()->GetStore()->Change(Change, FIELD_FLAGS, v, OpPlusEquals) == Store3Error)
 			{
 				LProgressDlg Prog(GetTree(), 500);
 				Prog.SetRange(Change.Length());
 				
 				// FIXME!!
 				// Prog.SetYieldTime(200);
 
 				Prog.SetDescription("Marking email...");
 				for (auto c : Change)
 				{
 					auto t = CastThing(c);
 					Mail *m = t ? t->IsMail() : NULL;
 					if (m)
 						m->SetFlags(m->GetFlags() | MAIL_READ, false, false);
 					Prog++;
 					if (Prog.IsCancelled())
 						break;
 				}
 
 				OnUpdateUnRead(0, true);
 			}
 			break;
 		}
 		case IDM_MERGE_FILE:
 		{
 			auto s = new LFileSelect(mt);
 			s->Type("Email Template", "*.txt;*.eml");
 			s->Open([this](auto dlg, auto id)
 			{
 				if (id)
 				{
 					LArray<ListAddr*> Recip;
 					for (auto i: Items)
 					{
 						Recip.Add(new ListAddr(i->IsContact()));
 					}
 					App->MailMerge(Recip, dlg->Name(), 0);
 					Recip.DeleteObjects();
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_UNDELETE:
 		{
 			const char *s = DomToStr(SdUndelete);
 			GetFldObj()->OnCommand(s);
 			break;
 		}
 		case IDM_EXPUNGE:
 		{
 			const char *s = DomToStr(SdExpunge);
 			GetFldObj()->OnCommand(s);
 			break;
 		}
 		case IDM_REFRESH:
 		{
 			const char *s = DomToStr(SdRefresh);
 			GetFldObj()->OnCommand(s);
 			break;
 		}
 		default:
 		{
 			Mail *Template = Templates[Msg - IDM_MERGE_TEMPLATE_BASE];
 			if (Template)
 			{
 				LArray<ListAddr*> Recip;
 				for (auto i: Items)
 				{
 					Recip.Add(new ListAddr(i->IsContact()));
 				}
 				App->MailMerge(Recip, 0, Template);
 				Recip.DeleteObjects();
 			}
 			else
 			{
 				// Handle any installed callbacks for menu items
 				for (unsigned i=0; i<s.Callbacks.Length(); i++)
 				{
 					LScriptCallback &Cb = s.Callbacks[i];
 					if (Cb.Param == Msg)
 					{
 						LScriptArguments Args(NULL);
 
 						Args[0] = new LVariant(App);
 						Args[1] = new LVariant(this);
 						Args[2] = new LVariant(Cb.Param);
 							
 						App->ExecuteScriptCallback(Cb, Args);
 					}
 				}
 			}
 			break;
 		}
 	}
 }
 
 bool ScribeFolder::IsInTrash()
 {
 	ScribeFolder *p = this;
 	while ((p = p->GetFolder()))
 	{
 		if (p->GetItemType() == MAGIC_ANY)
 			return true;
 	}
 
 	return false;
 }
 
 /// This just adds certain folder types as a group ware source at the app level
 void ScribeFolder::OnItemType()
 {
 	switch (GetItemType())
 	{
 		case MAGIC_CONTACT:
 		case MAGIC_FILTER:
 		case MAGIC_CALENDAR:
 		case MAGIC_GROUP:
 			App->AddThingSrc(this);
 			break;
 		default:
 			break;
 	}
 }
 
 bool ScribeFolder::LoadFolders()
 {
 	// static int64 Last = 0;
 
 	auto FldObj = GetFldObj();
 	if (!FldObj)
 		return true;
 
 	CurState = FldState_Loading;
 	FoldersCurrentlyLoading++;
 		
 	LHashTbl<PtrKey<LDataI*>, ScribeFolder*> Loaded;
 	for (ScribeFolder *c = GetChildFolder(); c; c = c->GetNextFolder())
 	{
 		Loaded.Add(c->GetObject(), c);
 	}
 
 	LDataFolderI *s;
 	auto &Sub = FldObj->SubFolders();
 	for (unsigned sIdx = 0;
 			Sub.GetState() == Store3Loaded &&
 			sIdx < Sub.Length();
 			sIdx++)
 	{
 		if (!(s = Sub[sIdx]))
 			break;
 
 		if (!Loaded.Find(s))
 		{
 			ScribeFolder *n = new ScribeFolder;
 			if (n)
 			{
 				n->App = App;
 				n->SetObject(s, false, _FL);
 				Insert(n);
 
 				SetWillDirty(false);
 				Expanded(GetOpen() != 0);
 				SetWillDirty(true);
 
 				n->LoadFolders();
 				n->OnItemType();
 			}
 
 			#if 0
 			int64 Now = LCurrentTime();
 			if (Now - Last > 500)
 			{
 				LYield();
 				Last = Now;
 			}
 			#endif
 		}
 	}
 
 	LTreeItem::Items.Sort(ThingContainerIdxCmp);
 		
 	CurState = FldState_Idle;
 	FoldersCurrentlyLoading--;
 
 	return true;
 }
 
 class LoadProgressItem : public LListItem
 {
 	int n;
 	int Total;
 	int64 Last;
 
 public:
 	LoadProgressItem(int t)
 	{
 		n = 0;
 		Total = t;
 		Last = LCurrentTime();
 	}
 
 	void SetPos(int i)
 	{
 		n = i;
 
 		if (n % 32 == 0)
 		{
 			int64 Now = LCurrentTime();
 			if (Now > Last + 500)
 			{
 				if (Parent)
 				{
 					Parent->Invalidate(&Pos, true);
 					
 					#ifdef MAC
 					LYield();
 					#endif
 				}
 				Last = Now;
 			}
 			LSleep(0);
 		}
 	}
 
 	void OnPaint(ItemPaintCtx &Ctx)
 	{
 		int x = n * 150 / Total;
 		LRect &r = Ctx;
 
 		Ctx.pDC->Colour(L_FOCUS_SEL_BACK);
 		Ctx.pDC->Rectangle(r.x1, r.y1, r.x1 + x, r.y2);
 		Ctx.pDC->Colour(L_MED);
 		Ctx.pDC->Rectangle(r.x1 + x + 1, r.y1, r.x1 + 150, r.y2);
 		Ctx.pDC->Colour(L_WORKSPACE);
 		Ctx.pDC->Rectangle(r.x1 + 151, r.y1, r.x2, r.y2);
 	}
 };
 
 class LoadingItem : public LListItem
 {
 	LDataIterator<LDataI*> *Iter;
 	LString s;
 
 public:
 	LoadingItem(LDataIterator<LDataI*> *it)
 	{
 		_UserPtr = NULL;
 		if ((Iter = it))
 		{
 			Iter->SetProgressFn([this](ssize_t pos, ssize_t sz)
 			{
 				this->s.Printf("%.1f%%", (double)pos * 100 / sz);
 				this->Update();
 			});
 		}
 	}
 
 	~LoadingItem()
 	{
 		if (Iter)
 			Iter->SetProgressFn(NULL);
 	}
 
 	bool SetText(const char *str, int i)
 	{
 		s = str;
 		Update();
 		return true;
 	}
 
 	void OnPaint(LItem::ItemPaintCtx &Ctx)
 	{
 		LString msg;
 		auto loading = LLoadString(IDS_LOADING);
 		if (s)
 			msg.Printf("%s %s", loading, s.Get());
 		else
 			msg = loading;
 
 		LDisplayString d(LSysFont, msg);
 		LSysFont->Colour(L_TEXT, L_WORKSPACE);
 		LSysFont->Transparent(false);
 		d.Draw(Ctx.pDC, (Ctx.X()-d.X())/2, Ctx.y1, &Ctx);
 	}
 
 	void Select(bool b)
 	{
 	}
 };
 
 bool ScribeFolder::UnloadThings()
 {
 	bool Status = true;
 
 	if (IsLoaded())
 	{
 		// LgiTrace("Unloading %s, Items=%i\n", GetPath(), Items.Length());
 
 		// Emptying the item list, leave the store nodes around though
 		Thing *t;
 		while ((t = Items[0]))
 		{
 			if (t->GetDirty())
 			{
 				t->Save(0);
 			}
 
 			t->SetObject(NULL, false, _FL);
 			t->DecRef();
 		}
 
 		Items.Empty();
 		IsLoaded(false);
 		GetObject()->SetInt(FIELD_LOADED, false);
 	}
 
 	return Status;
 }
 
 #define DEBUG_PROF_LOAD_THINGS		0
 #if DEBUG_PROF_LOAD_THINGS
 	#define PROFILE(str) 			prof.Add("Add");
 .Add(str)
 #else
 	#define PROFILE(str)
 #endif
 
 void ScribeFolder::ContinueLoading(int OldUnread, std::function<void(Store3Status)> Callback)
 {
 	auto FldObj = GetFldObj();
 
 	WhenLoaded(_FL,
 		[this, OldUnread, Callback, FldObj]()
 		{
 			// This is called when all the Store3 objects are loaded
 			int Unread = OldUnread;
 			if (Unread < 0)
 				Unread = GetUnRead();
 
 			Loading.Reset();
 
 			auto &Children = GetFldObj()->Children();
 			if (Children.GetState() != Store3Loaded)
 			{
 				LAssert(!"Really should be loaded by now.");
 				return;
 			}
 
 			for (auto c = Children.First(); c; c = Children.Next())
 			{
 				auto t = CastThing(c);
 				if (t)
 				{
 					// LAssert(Items.HasItem(t));
 				}
 				else if ((t = App->CreateThingOfType((Store3ItemTypes) c->Type(), c)))
 				{
 					t->SetObject(c, false, _FL);
 					t->SetParentFolder(this);
 					t->OnSerialize(false);
 				}
 			}
 
 			int NewUnRead = 0;
 			for (auto t: Items)
 			{
 				if (t->GetFolder() != this)
 				{
 					#ifdef _DEBUG
 					char s[256];
 					sprintf_s(s, sizeof(s),
 						"%s:%i - Error, thing not parented correctly: this='%s', child='%x'\n",
 						_FL,
 						GetText(0),
 						t->GetObject() ? t->GetObject()->Type() : 0);
 					printf("%s", s);
 					LgiMsg(App, s, AppName);
 					#endif
 			
 					t->SetFolder(this);
 				}
 
 				Mail *m = t->IsMail();
 				if (m)
 					NewUnRead += (m->GetFlags() & MAIL_READ) ? 0 : 1;
 
 				t->SetFieldArray(FieldArray);
 			}
 
 			if (Unread != NewUnRead)
 				OnUpdateUnRead(NewUnRead - Unread, false);
 
 			Update();
 
 			if (d->IsInbox < 0 && App)
 			{
 				d->IsInbox = App->GetFolder(FOLDER_INBOX) == this;
 				if (d->IsInbox > 0)
 					UpdateOsUnread();
 			}
 
 			if (Callback)
 				Callback(Store3Success);
 		},
 		0);
 
 	if (!IsLoaded())
 	{
 		bool Ui = Tree ? Tree->InThread() : false;
 		if (Ui)
 			Tree->Capture(false);
 
 		auto &Children = FldObj->Children();
 		auto Status = Children.GetState();
 		if (Status != Store3Loaded)
 		{
 			if (View() && Loading.Reset(Ui ? new LoadingItem(&Children) : NULL))
 				View()->Insert(Loading);
 
 			return; // Ie deferred or error...
 		}
 
 		IsLoaded(true);
 	}
 }
 
 Store3Status ScribeFolder::LoadThings(LViewI *Parent, std::function<void(Store3Status)> Callback)
 {
 	int OldUnRead = GetUnRead();
 
 	auto FldObj = GetFldObj();
 	if (!FldObj)
 	{
 		LgiTrace("%s:%i - No folder object.\n", _FL);
 		return Store3Error;
 	}
 
 	if (!Parent)
 		Parent = App;
 
 	auto Path = GetPath();
 	if (!App || !Path)
 	{
 		LAssert(!"We should probably always have an 'App' and 'Path' ptrs...");
 		return Store3Error;
 	}
 
 	auto Access = App->GetAccessLevel(
 		Parent,
 		GetReadAccess(),
 		Path,
 		[this, OldUnRead, Callback](auto access)
 		{
 			if (access)
 				ContinueLoading(OldUnRead, Callback);
 			else if (Callback)
 				Callback(Store3NoPermissions);
 		});
 
 	if (Access == Store3Error)
 	{		
 		// No read access:
 		LgiTrace("%s:%i - Folder read access denied.\n", _FL);
 
 		// Emptying the item list, leave the store nodes around though
 		for (auto t: Items)
 			t->SetObject(NULL, false, _FL);
 
 		Items.Empty();
 		IsLoaded(false);
 		
 		Update();
 	}
 		
 	return Access;
 }
 
 void ScribeFolder::OnRename(char *NewName)
 {
 	if (!NewName)
 		return;
 
 	int FolderType = App->GetFolderType(this);
 
 	SetName(NewName, true); // Calls update too..
 	SetDirty();
 
 	if (FolderType >= 0)
 	{
 		// it's a system folder so reflect the changes in
 		// the system folder tracking options.
 		char KeyName[32];
 		sprintf_s(KeyName, sizeof(KeyName), "Folder-%i", FolderType);
 		auto Path = GetPath();
 		if (Path)
 		{
 			LVariant v = Path.Get();
 			App->GetOptions()->SetValue(KeyName, v);
 		}
 	}
 }
 
 void ScribeFolder::OnDelete()
 {
 	if (GetObject())
 	{
 		char Msg[256];
  		sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_DELETE_FOLDER_DLG), GetText());
 		int Result = LgiMsg(App, Msg, AppName, MB_YESNO);
 		if (Result == IDYES)
 		{
 			if (App->GetMailList())
 				App->GetMailList()->RemoveAll();
 
 			ScribeFolder *Parent = GetFolder();
 			LArray<LDataI*> Del;
 			Del.Add(GetObject());
 			if (GetObject()->GetStore()->Delete(Del, true))
 			{
 				if (Parent)
 					Parent->Select(true);
 			}
 		}
 	}
 }
 
-ScribeFolder *ScribeFolder::GetSubFolder(const char *Path)
-{
-	ScribeFolder *Folder = 0;
-	
-	if (Path)
-	{
-		if (*Path == '/') Path++;
-
-		char Name[256];
-		char *Sep = strchr((char*)Path, '/');
-		if (Sep)
-		{
-			ZeroObj(Name);
-			memcpy(Name, Path, Sep-Path);
-		}
-		else
-		{
-			strcpy_s(Name, sizeof(Name), Path);
-		}
-
-		LTreeItem *Starts[2] =
-		{
-			GetChild(),
-			IsRoot() ? GetNext() : 0
-		};
-
-		for (int s=0; !Folder && s<CountOf(Starts); s++)
-		{
-			for (LTreeItem *i=Starts[s]; i; i=i->GetNext())
-			{
-				ScribeFolder *f = dynamic_cast<ScribeFolder*>(i);
-				if (f)
-				{
-					auto n = f->GetName(true);
-					if (n.Equals(Name))
-					{
-						if (Sep)
-							Folder = f->GetSubFolder(Sep+1);
-						else
-							Folder = f;
-						break;
-					}
-				}
-			}
-		}
-	}
-
-	return Folder;
-}
-
 bool ScribeFolder::ReindexField(int OldIndex, int NewIndex)
 {
 	if (!GetFldObj())
 		return false;
 	
 	auto &Flds = GetFldObj()->Fields();
 	if (GetFldObj()->Fields().Length() <= 0)
 		return false;
 
 	LDataPropI *f = Flds[OldIndex];
 	if (!f)
 		return false;
 
 	Flds.Delete(f);
 	Flds.Insert(f, OldIndex < NewIndex ? NewIndex - 1 : NewIndex);
 
 	int i=0;
 	FieldArray.Length(0);
 	for (f = Flds.First(); f; f = Flds.Next())
 	{
 		auto Id = f->GetInt(FIELD_ID);
 		FieldArray[i++] = (int)Id;
 	}
 
 	for (auto t: Items)
 		t->SetFieldArray(FieldArray);
 
 	SetDirty();
 	return true;
 }
 
 int ScribeFolder::_UnreadChildren()
 {
 	int Status = 0;
 
 	for (ScribeFolder *f=GetChildFolder(); f; f=f->GetNextFolder())
 	{
 		int u = f->GetUnRead();
 		if (u > 0)
 			Status += u;
 
 		Status += f->_UnreadChildren();
 	}
 
 	return Status;
 }
 
 void ScribeFolder::_PourText(LPoint &Size)
 {
 	if (!d)
 		return;
 
 	const char *Text = GetText();
 	Size.x = Size.y = 0;
 	
 	if (Text && !d->DsBase)
 	{
 		if (GetUnRead() > 0 || ChildUnRead)
 		{
 			const char *StartCount = strrchr(Text, '(');
 			ssize_t NameLen = StartCount ? StartCount-Text : strlen(Text);
 
 			LFont *b = (App->GetBoldFont()) ? App->GetBoldFont() : GetTree()->GetFont();
 
 			d->DsBase.Reset(new LDisplayString(b, Text, NameLen));
 			d->DsUnread.Reset(new LDisplayString(GetTree()->GetFont(), StartCount));
 		}
 		else
 		{
 			d->DsBase.Reset(new LDisplayString(GetTree()->GetFont(), Text));
 		}
 	}
 	
 	if (d->DsBase)
 		Size.x += d->DsBase->X();
 	if (d->DsUnread)
 		Size.x += d->DsUnread->X();
 
 	Size.x += 4;
 	Size.y = MAX(16, LSysFont->GetHeight());
 }
 
 void ScribeFolder::_PaintText(LItem::ItemPaintCtx &Ctx)
 {
 	if (!d)
 		return;
 		
 	LRect *_Text = _GetRect(TreeItemText);
 	if (d->DsBase)
 	{
 		LFont *f = d->DsBase->GetFont();
 		int Tab = f->TabSize();
 		f->TabSize(0);
 		f->Transparent(false);
 		f->Colour(Ctx.Fore, Ctx.TxtBack);
 
 		d->DsBase->Draw(Ctx.pDC, _Text->x1 + 2, _Text->y1 + 1, _Text);
 		if (d->DsUnread)
 		{
 			f = d->DsUnread->GetFont();
 			f->Transparent(true);
 
 			LColour UnreadCol(App->GetColour(L_UNREAD_COUNT));
 			if
 			(
 				abs
 				(
 					(UnreadCol.GetGray() - Ctx.Back.GetGray())
 				)
 				< 80
 			)
 			{
 				// too close.. use fore
 				f->Colour(Ctx.Fore, Ctx.TxtBack);
 			}
 			else
 			{
 				// contrast ok.. use unread
 				f->Colour(UnreadCol, Ctx.TxtBack);
 			}
 			
 			d->DsUnread->Draw(Ctx.pDC, _Text->x1 + 2 + d->DsBase->X(), _Text->y1 + 1);
 		}
 
 		f->TabSize(Tab);
 		
 		if (Ctx.x2 > _Text->x2)
 		{
 			Ctx.pDC->Colour(Ctx.Back);
 			Ctx.pDC->Rectangle(_Text->x2 + 1, Ctx.y1, Ctx.x2, Ctx.y2);
 		}
 	}
 	else
 	{
 		Ctx.pDC->Colour(Ctx.Back);
 		Ctx.pDC->Rectangle(&Ctx);
 	}
 }
 
 bool ScribeFolder::Save(ScribeFolder *Into)
 {
 	bool Status = false;
 	
 	if (GetObject())
 	{
 		// saving a disk object
 		Store3Status s = GetObject()->Save();
 		if (s != Store3Error)
 		{
 			Status = true;
 			SetDirty(false);
 		}
 		else
 		{
 			LAssert(0);
 		}
 	}
 
 	return Status;
 }
 
 void ScribeFolder::OnExpand(bool b)
 {
 	if (b && LoadOnDemand)
 	{
 		DeleteObj(LoadOnDemand);
 		
 		if (App->ScribeState != ScribeWnd::ScribeExiting)
 		{
 			ScribeWnd::AppState Prev = App->ScribeState;
 			App->ScribeState = ScribeWnd::ScribeLoadingFolders;
 			LoadFolders();
 			if (App->ScribeState == ScribeWnd::ScribeExiting)
 			{
 				LCloseApp();
 				return;
 			}
 			App->ScribeState = Prev;
 		}
 	}
 
 	OnUpdateUnRead(0, false);
 
 	SetDirty(((uchar)b) != GetOpen());
 	SetOpen(b);
 }
 
 bool ScribeFolder::OnKey(LKey &k)
 {
 	#ifndef WINDOWS
     //  This is being done by the VK_APPS key on windows... 
 	if (k.IsContextMenu())
 	{
 		if (k.Down())
 		{
 			LMouse m;
 			m.x = 5;
 			m.y = 5;
 			m.ViewCoords = true;
 			m.Target = GetTree();
 			DoContextMenu(m);
 		}
 		return true;
 	}
 	#endif
 	
 	return false;
 }
 
 #define DefField(id, wid) \
 { \
 	LDataPropI *Fld = Fields.Create(GetFldObj()->GetStore()); \
 	if (Fld) \
 	{ \
 		Fld->SetInt(FIELD_ID, id); \
 		Fld->SetInt(FIELD_WIDTH, wid); \
 		Fields.Insert(Fld); \
 	} \
 }
 
 void ScribeFolder::SetDefaultFields(bool Force)
 {
 	if (!GetFldObj())
 		return;
 
 	if (Force || GetFldObj()->Fields().Length() <= 0)
 	{
 		LDataIterator<LDataPropI*> &Fields = GetFldObj()->Fields();
 		Fields.DeleteObjects();
 
 		int FolderType = App ? App->GetFolderType(this) : -1;
 		if (FolderType == FOLDER_OUTBOX ||
 			FolderType == FOLDER_SENT)
 		{
 			DefField(FIELD_PRIORITY, 10);
 			DefField(FIELD_FLAGS, 15);
 					
 			DefField(FIELD_TO, 150);
 			DefField(FIELD_SUBJECT, 250);
 			DefField(FIELD_SIZE, 80);
 			DefField(FIELD_DATE_SENT, 100);
 		}
 		else
 		{
 			switch (GetItemType())
 			{
 				case MAGIC_MAIL:
 				{
 					DefField(FIELD_PRIORITY, 10);
 					DefField(FIELD_FLAGS, 10);
 					
 					DefField(FIELD_FROM, 150);
 					DefField(FIELD_SUBJECT, 250);
 					DefField(FIELD_SIZE, 80);
 					DefField(FIELD_DATE_SENT, 100);
 					break;
 				}
 				case MAGIC_CONTACT:
 				{
 					DefField(FIELD_FIRST_NAME, 200);
 					DefField(FIELD_LAST_NAME, 200);
 					DefField(FIELD_EMAIL, 300);
 					break;
 				}
 				case MAGIC_CALENDAR:
 				{
 					DefField(FIELD_CAL_SUBJECT, 200);
 					DefField(FIELD_CAL_START_UTC, 150);
 					DefField(FIELD_CAL_END_UTC, 150);
 					break;
 				}
 				case MAGIC_FILTER:
 				{
 					for (int i=0; DefaultFilterFields[i]; i++)
 					{
 						DefField(DefaultFilterFields[i], i == 0 ? 200 : 100);
 					}
 					break;
 				}
 				case MAGIC_GROUP:
 				{
 					DefField(FIELD_GROUP_NAME, 300);
 					break;
 				}
 				default:
 					break;
 			}
 		}
 
 		// set for save
 		SetDirty(Fields.Length() > 0);
 	}
 	else
 	{
 		// already has fields, so don't interfere with them
 	}
 }
 
 LString ScribeFolder::GetPath()
 {
 	LString::Array p;
 
 	ScribeFolder *f = this;
 	while (f)
 	{
 		auto name = f->GetName(true);
 		if (name)
 			p.Add(name);
 		f = dynamic_cast<ScribeFolder*>(f->GetParent());
 	}
 
 	LString dir = "/";
 	return dir + dir.Join(p.Reverse());
 }
 
 void ScribeFolder::SetName(const char *Name, bool Encode)
 {
 	if (Name)
 	{
 		d->DsBase.Reset();
 		d->DsUnread.Reset();
 		NameCache.Reset();
 
 		if (GetObject())
 			GetObject()->SetStr(FIELD_FOLDER_NAME, Name);
 		SetText(Name); // Calls update
 	}
 }
 
 LString ScribeFolder::GetName(bool Decode)
 {
 	if (!GetObject())
 		return NULL;
 
 	auto In = GetObject()->GetStr(FIELD_FOLDER_NAME);
 	if (!In)
 		return NULL;
 
 	if (Decode)
 		return LUrlDecode(In);
 	else
 		return In;
 }
 
 void ScribeFolder::Update()
 {
 	if (Tree && !Tree->InThread())
 	{
 		// LgiTrace("%s:%i - Update not in thread?\n", _FL);
 		return;
 	}
 
 	d->DsBase.Reset();
 	d->DsUnread.Reset();
 	NameCache.Reset();
 	LTreeItem::Update();
 }
 
 const char *ScribeFolder::GetText(int i)
 {
 	if (!NameCache)
 	{
 		LString Name = GetName(true);
 		if (!Name)
 			return "...loading...";
 		
 		size_t NameLen = strlen(Name) + 40;
 		NameCache.Reset(new char[NameLen]);
 		if (NameCache)
 		{
 			bool ShowTotals = false;
 			LVariant v;
 			if (App->GetOptions()->GetValue(OPT_ShowFolderTotals, v))
 				ShowTotals = v.CastInt32() != 0;
 
 			int c = sprintf_s(NameCache, NameLen, "%s", Name.Get());
 			
 			auto ItemType = GetItemType();
 			if (ItemType &&
 				(ShowTotals || GetUnRead() || ChildUnRead))
 			{			
 				c += sprintf_s(NameCache+c, NameLen-c, " (");
 				if (ItemType == MAGIC_MAIL ||
 					ItemType == MAGIC_ANY)
 				{
 					const char *Ch = ChildUnRead ? "..." : "";
 
 					if (ShowTotals)
 						c += sprintf_s(NameCache+c, NameLen-c, "%i%s/", GetUnRead(), Ch);
 					else if (GetUnRead())
 						c += sprintf_s(NameCache+c, NameLen-c, "%i%s", GetUnRead(), Ch);
 					else if (ChildUnRead)
 						c += sprintf_s(NameCache+c, NameLen-c, "...");
 				}
 				if (ShowTotals)
 				{
 					if (IsLoaded())
 						c += sprintf_s(NameCache+c, NameLen-c, "%zi", Items.Length());
 					else
 						c += sprintf_s(NameCache+c, NameLen-c, "?");
 				}
 				c += sprintf_s(NameCache+c, NameLen-c, ")");
 			}
 		}
 	}
 
 	return NameCache;
 }
 
 int ScribeFolder::GetImage(int Flags)
 {
 	if (GetItemType() == MAGIC_ANY)
 	{
 		return ICON_TRASH;
 	}
 
 	if (Flags)
 	{
 		return ICON_OPEN_FOLDER;
 	}
 
 	switch (GetItemType())
 	{
 		case MAGIC_MAIL:
 			return ICON_FOLDER_MAIL;
 		case MAGIC_CONTACT:
 			return ICON_FOLDER_CONTACTS;
 		case MAGIC_FILTER:
 			return ICON_FOLDER_FILTERS;
 		case MAGIC_CALENDAR:
 			return ICON_FOLDER_CALENDAR;
 		case MAGIC_NONE:
 			return ICON_MAILBOX;
 		default:
 			return ICON_CLOSED_FOLDER;
 	}
 }
 
 class NullMail : public Mail
 {
 	Thing &operator =(Thing &c) override
 	{
 		return *this;
 	}
 
 public:
 	NullMail(ScribeWnd *App, MContainer *c, ScribeFolder *f) : Mail(App)
 	{
 		SetFlags(MAIL_READ | MAIL_CREATED);
 		Container = c;
 		SetParentFolder(f);
 		SetSubject((char*)LLoadString(IDS_MISSING_PARENT));
 	}
 
 	~NullMail()
 	{
 		SetParentFolder(NULL);
 	}
 
 	bool IsPlaceHolder() override
 	{
 		return true;
 	}
 	
 	const char *GetText(int i) override
 	{
 		// Clear all the fields
 		return 0;
 	}
 
 	int Compare(LListItem *Arg, ssize_t Field) override
 	{
 		// Use the first mail to sort into position
 		if (Container)
 		{
 			MContainer *c = Container->Children.Length() ? Container->Children[0] : 0;
 			if (c && c->Message)
 			{
 				return c->Message->Compare(Arg, Field);
 			}
 		}
 
 		return -1;
 	}
 
 	void OnMouseClick(LMouse &m) override
 	{
 		// Disable the mouse click
 	}
 
 	bool SetDirty(bool b = true) override
 	{
 		// Don't set it to dirty, otherwise the dirty object
 		// clean up code will save it into the outbox.
 		return true;
 	}
 };
 
 template <class T>
 int TrashCompare(T *pa, T *pb, NativeInt Data)
 {
 	ScribeFolder *f = (ScribeFolder*)Data;
 	Thing *a = dynamic_cast<Thing*>(pa);
 	Thing *b = dynamic_cast<Thing*>(pb);
 	if (!a || !b)
 		return 0;
 
 	int type = a->Type() - b->Type();
 	if (type)
 		return type;
 
 	int col = f->GetSortCol();
 	int *defs = a->GetDefaultFields();
 	if (!defs || !defs[col])
 		return 0;
 
 	return (f->GetSortAscend() ? 1 : -1) * a->Compare(b, defs[col]);
 }
 
 template int TrashCompare<LListItem>(LListItem *pa, LListItem *pb, NativeInt Data);
 
 int ListItemCompare(LListItem *a, LListItem *b, NativeInt Data)
 {
 	ScribeFolder *f = (ScribeFolder*)Data;
 	return (f->GetSortAscend() ? 1 : -1) * a->Compare(b, f->GetSortField());
 }
 
 int ThingCompare(Thing *a, Thing *b, NativeInt Data)
 {
 	ScribeFolder *f = (ScribeFolder*)Data;
 	return (f->GetSortAscend() ? 1 : -1) * a->Compare(b, f->GetSortField());
 }
 
 int ThingSorter(Thing *a, Thing *b, ThingSortParams *Params)
 {
 	return (Params->SortAscend ? 1 : -1) * a->Compare(b, Params->SortField);
 }
 
 bool ScribeFolder::Thread()
 {
 	bool Status = false;
 
 	if (GetItemType() == MAGIC_MAIL)
 	{
 		int Thread = GetThreaded();
 		ThingList *Lst = View();
 
 		List<Mail> m;
 		for (auto t: Items)
 		{
 			Mail *e = t->IsMail();
 			if (e)
 			{
 				if (Thread)
 				{
 					m.Insert(e);
 				}
 				else if (e->Container)
 				{
 					DeleteObj(e->Container);
 				}
 			}
 		}
 
 		if (Lst && m[0])
 		{
 			// Thread
 			LArray<MContainer*> Containers;
 			MContainer::Thread(m, Containers);
 			
 			LAssert(m.Length() == Items.Length());
 
 			// Insert blank items for missing thread parents
 			for (unsigned i=0; i<Containers.Length(); i++)
 			{
 			    MContainer *c = Containers[i];
 				if (!c->Message)
 				{
 					LAssert(c->Children.Length() > 1);
 
 					c->Message = new NullMail(App, c, this);
 					if (c->Message)
 					{
 						Lst->PlaceHolders.Insert(c->Message);
 						if (View() && c->Message)
 						{
 							c->Message->SetFieldArray(FieldArray);
 							Items.Insert(c->Message);
 						}
 					}
 				}
 			}
 			
 			// Sort root list
 			LArray<MContainer*> Containers2 = Containers;
 			ThingSortParams Params;
 			Params.SortAscend = GetSortAscend();
 			Params.SortField = GetSortField();
 
             #if 0
 			for (int i=0; i<Containers.Length(); i++)
 			{
 				// LAssert(Containers[i] == Containers2[i]);
 				char *Str1 = Containers[i]->Message ? Containers[i]->Message->GetFieldText(Params.SortField) : NULL;
 				LgiTrace("%p(%s)\n", Containers[i], Str1);
 			}
 
 			Containers.Sort(ContainerCompare);
 
 			LQuickSort(Base, Containers2.Length(), ContainerSorter, &Params);
 			
 			for (int i=0; i<Containers.Length(); i++)
 			{
 				// LAssert(Containers[i] == Containers2[i]);
 				char *Str1 = Containers[i]->Message ? Containers[i]->Message->GetFieldText(Params.SortField) : NULL;
 				char *Str2 = Containers2[i]->Message ? Containers2[i]->Message->GetFieldText(Params.SortField) : NULL;
 				LgiTrace("%p(%s), %p(%s) - %s\n", Containers[i], Str1, Containers2[i], Str2, Containers[i]!=Containers2[i]?"DIFFERENT":"");
 			}
 			#else
 			MContainer **Base = &Containers[0];
 	        if (Containers.Length() > 1)
 	    		LQuickSort(Base, Containers.Length(), ContainerSorter, &Params);
 
             /*
 			for (int i=0; i<Containers.Length(); i++)
 			{
 				char *Str1 = Containers[i]->Message ? Containers[i]->Message->GetFieldText(Params.SortField) : NULL;
 				LgiTrace("%p(%s)\n", Containers[i]->Message, Str1);
 			}
 			LgiTrace("\n");
 			*/
     	    #endif
 
 			// Position and index the thread tree
 			int Index = 0;
 			for (unsigned i=0; i<Containers.Length(); i++)
 			{
 				Containers[i]->Pour(Index, 0, 0, i < Containers.Length()-1, &Params);
 			}
 			
 			// Sort all the items by index			
 			Items.Sort(ContainerIndexer);
 			Status = true;
 			
 			/*
 			int Idx = 0;
 			for (Thing *t = Items.First(); t; t = Items.Next(), Idx++)
 			{
 			    Mail *m = t->IsMail();
 			    if (m)
 			    {
 			        char *Str = m->GetFieldText(Params.SortField);
 			        LgiTrace("%i,%i %p %s\n", Idx, m->Container ? m->Container->Index : -1, m, Str);
 			    }
 			}
 			*/
 		}
 	}
 	else
 	{
 		for (auto t: Items)
 		{
 			Mail *e = t->IsMail();
 			if (e)
 				DeleteObj(e->Container);
 		}
 	}
 
 	return Status;
 }
 
 struct SortPairInt
 {
 	Thing *t;
 	uint64 ts;
 
 	void SetDate(Thing *th, int sf)
 	{
 		t = th;
 		auto obj = th->GetObject();
 		// Store3State loaded = (Store3State)obj->GetInt(FIELD_LOADED);
 		auto dt = obj->GetDate(sf);
 		ts = dt && dt->Year() ? dt->Ts() : 0;
 	}
 
 	void SetInt(Thing *th, int sf)
 	{
 		t = th;
 		auto obj = th->GetObject();
 		// Store3State loaded = (Store3State)obj->GetInt(FIELD_LOADED);
 		ts = obj->GetInt(sf);
 	}
 
 	static int Compare(SortPairInt *a, SortPairInt *b)
 	{
 		int64_t diff = (int64_t)a->ts - (int64_t)b->ts;
 		if (diff < 0) return -1;
 		return diff > 0 ? 1 : 0;
 	}
 };
 
 struct SortPairStr
 {
 	Thing *t;
 	const char *ts;
 
 	void SetStr(Thing *th, int sf)
 	{
 		t = th;
 		ts = th->GetObject()->GetStr(sf);
 	}
 
 	static int Compare(SortPairStr *a, SortPairStr *b)
 	{
 		return stricmp(a->ts ? a->ts : "", b->ts ? b->ts : "");
 	}
 };
 
 bool ScribeFolder::SortItems()
 {
 	int sf = GetSortField();
 	LVariantType type = GV_NULL;
 	auto StartTs = LCurrentTime();
 	const static int TimeOut = 2/*sec*/ * 1000;
 
 	switch (sf)
 	{
 		case FIELD_DATE_SENT:
 		case FIELD_DATE_RECEIVED:
 			type = GV_DATETIME;
 			break;
 		case FIELD_SUBJECT:
 			type = GV_STRING;
 			break;
 		default:			
 			return false;
 	}
 
 	LArray<SortPairInt> intPairs;
 	LArray<SortPairStr> strPairs;
 	bool intType =	type == GV_DATETIME ||
 					type == GV_INT32 ||
 					type == GV_INT64;
 	if (intType)
 	{
 		intPairs.Length(Items.Length());
 		int n = 0;
 		auto s = intPairs.AddressOf();
 		
 		if (type == GV_DATETIME)
 		{
 			for (auto i: Items)
 			{
 				s[n++].SetDate(i, sf);
 				if (n % 50 == 0 && LCurrentTime() - StartTs >= TimeOut)
 					return false;
 			}
 		}
 		else
 		{
 			for (auto i: Items)
 			{
 				s[n++].SetInt(i, sf);
 				if (n % 50 == 0 && LCurrentTime() - StartTs >= TimeOut)
 					return false;
 			}
 		}
 	
 		intPairs.Sort(SortPairInt::Compare);
 	}
 	else if (type == GV_STRING)
 	{
 		strPairs.Length(Items.Length());
 		int n = 0;
 		auto s = strPairs.AddressOf();
 		
 		for (auto i: Items)
 			s[n++].SetStr(i, sf);
 	
 		strPairs.Sort(SortPairStr::Compare);
 	}
 
 	Items.Empty();
 
 	if (intType)
 	{
 		if (GetSortAscend())
 			for (auto i: intPairs) Items.Add(i.t);
 		else
 			for (auto it = intPairs.rbegin(); it != intPairs.end(); it--)
 				Items.Add((*it).t);
 	}
 	else
 	{
 		if (GetSortAscend())
 			for (auto i: strPairs) Items.Add(i.t);
 		else
 			for (auto it = strPairs.rbegin(); it != strPairs.end(); it--)
 				Items.Add((*it).t);
 	}
 
 	return true;
 }
 
 void ScribeFolder::Populate(ThingList *list)
 {
 LProfile Prof("ScribeFolder::Populate", 1000);
 
 	App->OnSelect();
 
 	if (!GetFldObj() || !list)
 		return;
 
 	CurState = FldState_Populating;
 		
 	ScribeFolder *Prev = list->GetContainer();
 	bool Refresh = Prev == this;
 
 	// Remove old items from list
 Prof.Add("Delete Placeholders");
 	list->DeletePlaceHolders();
 	list->RemoveAll();
 
 	if (!Refresh || list->GetColumns() == 0 || GetItemType() == MAGIC_FILTER)
 	{
 		if (Prev)
 		{
 			// save previous folders settings
 			Prev->SerializeFieldWidths();
 		}
 
 Prof.Add("Empty cols");
 		LVariant GridLines;
 		if (App->GetOptions()->GetValue(OPT_GridLines, GridLines))
 		{
 			list->DrawGridLines(GridLines.CastInt32() != 0);
 		}
 		list->EmptyColumns();
 
 Prof.Add("Set def fields");
 		bool ForceDefaultFields = GetItemType() == MAGIC_FILTER;
 		if (GetFldObj()->Fields().Length() <= 0 || ForceDefaultFields)
 		{
 			SetDefaultFields(ForceDefaultFields);
 		}
 			
 		// Add fields to list view
 		int n = 0;
 		LArray<int> Empty;
 		for (auto t: Items)
 		{
 			t->SetFieldArray(Empty);
 		}
 		LRect *Bounds = 0;
 		if (App->GetIconImgList())
 		{
 			Bounds = App->GetIconImgList()->GetBounds();
 		}
 
 		switch (GetItemType())
 		{
 			case MAGIC_ANY:
 			{
 				list->AddColumn("", 170);
 				list->AddColumn("", 170);
 				list->AddColumn("", 170);
 				list->AddColumn("", 170);
 				break;
 			}
 			default:
 			{
 				n = 0;
 				FieldArray.Length(0);
 					
 				for (LDataPropI *i = GetFldObj()->Fields().First(); i; i = GetFldObj()->Fields().Next())
 				{
 					int FieldId = (int)i->GetInt(FIELD_ID);
 					const char *FName = LLoadString(FieldId);
 					int Width = (int)i->GetInt(FIELD_WIDTH);
 					const char *FieldText = FName ? FName : i->GetStr(FIELD_NAME);
 					LAssert(FieldText != NULL);
 						
 					LItemColumn *c = list->AddColumn(FieldText, Width);
 					if (c)
 					{
 						switch (i->GetInt(FIELD_ID))
 						{
 							case FIELD_PRIORITY:
 							{
 								int x = 12;
 								if (Bounds)
 								{
 									x = Bounds[ICON_PRIORITY_BLACK].X() + 7;
 								}							
 								c->Width(x);
 
 								c->Image(ICON_PRIORITY_BLACK);
 								c->Resizable(false);
 								break;
 							}
 							case FIELD_FLAGS:
 							{
 								int x = 14;
 								if (Bounds)
 								{
 									x = Bounds[ICON_FLAGS_BLACK].X() + 7;
 								}							
 								c->Width(x);
 
 								c->Image(ICON_FLAGS_BLACK);
 								c->Resizable(false);
 								break;
 							}
 							case FIELD_SIZE:
 							{
 								c->TextAlign(LCss::Len(LCss::AlignRight));
 								break;
 							}
 						}
 					}
 						
 					FieldArray[n++] = (int)i->GetInt(FIELD_ID);
 				}
 				break;
 			}
 		}
 
 		// Add all items to list
 		if (View())
 		{
 			View()->SetContainer(this);
 
 			// tell the list who we are
 			if (GetSortCol() >= 0)
 			{
 				// set current sort settings
 				View()->SetSort(GetSortCol(), GetSortAscend());
 			}
 		}
 
 Prof.Add("Load things");
 		// FIXME:
 		LoadThings();
 	}
 
 	// Filter
 	List<LListItem> Is;
 
 	// Do any threading/sorting
 	static LString SortMsg;
 	if (!Thread() &&
 		GetSortField())
 	{
 		SortMsg.Printf("Sorting " LPrintfInt64 " items", Items.Length());
 Prof.Add(SortMsg);
 		if (GetItemType() == MAGIC_ANY)
 		{
 			Items.Sort(TrashCompare<Thing>, (NativeInt)this);
 		}
 		else
 		{
 			// Sort..
 			// if (!SortItems())
 			Items.Sort(ThingCompare, (NativeInt)this);
 		}
 	}
 
 	// Do any filtering...
 Prof.Add("Filtering");
 	ThingFilter *Filter = App->GetThingFilter();
 	auto FilterStart = LCurrentTime();
 	size_t Pos = 0;
 	for (auto t: Items)
 	{
 		t->SetFieldArray(FieldArray);
 		if (!Filter || Filter->TestThing(t))
 		{
 			// Add anyway... because all items are not part of list
 			Is.Insert(t);
 		}
 
 		if ((LCurrentTime()-FilterStart) > 300)
 		{
 			if (!Loading && Loading.Reset(new LoadingItem(NULL)))
 				list->Insert(Loading, 0);
 			if (Loading)
 			{
 				LString s;
 				s.Printf(LPrintfInt64 " of " LPrintfInt64 ", %.1f%%",
 					Pos, Items.Length(), (double)Pos * 100 / Items.Length());
 				Loading->SetText(s);
 			}
 			FilterStart = LCurrentTime();
 		}
 
 		Pos++;
 	}
 
 Prof.Add("Inserting");
 	if (View() && Is[0])
 	{
 		View()->Insert(Is, -1, true);
 	}
 
 Prof.Add("Deleting");
 	list->DeletePlaceHolders();
 	Loading.Reset();
 
 Prof.Add("OnSelect");
 	GetFldObj()->OnSelect(true);
 	CurState = FldState_Idle;
 }
 
 void ScribeFolder::OnUpdateUnRead(int Offset, bool ScanItems)
 {
 	if (!d->InUpdateUnread)
 	{
 		d->InUpdateUnread = true;
 
 		int OldUnRead = GetUnRead();
 
 		d->DsBase.Reset();
 		d->DsUnread.Reset();
 		NameCache.Reset();
 
 		if (ScanItems)
 		{
 			if (GetItemType() == MAGIC_MAIL ||
 				GetItemType() == MAGIC_ANY)
 			{
 				size_t Count = 0;
 
 				for (auto t: Items)
 				{
 					Mail *m = t->IsMail();
 					if (m && !TestFlag(m->GetFlags(), MAIL_READ))
 						Count++;
 				}
 
 				SetUnRead((int32_t)Count);
 			}
 		}
 		else if (Offset != 0)
 		{
 			SetUnRead(GetUnRead() + Offset);
 		}
 
 		if (GetUnRead() < 0)
 			SetUnRead(0);
 
 		if (OldUnRead != GetUnRead())
 		{
 			for (LTreeItem *i = GetParent(); i; i = i->GetParent())
 			{
 				ScribeFolder *tc = dynamic_cast<ScribeFolder*>(i);
 				if (tc && tc->GetParent())
 					tc->OnUpdateUnRead(0, false);
 			}
 
 			SetDirty();
 			if (d->IsInbox > 0)
 				UpdateOsUnread();
 		}
 	
 		ChildUnRead = Expanded() ? 0 : _UnreadChildren();
 		Update();
 
 		d->InUpdateUnread = false;
 	}
 }
 
 void ScribeFolder::EmptyFieldList()
 {
 	if (GetFldObj())
 		GetFldObj()->Fields().DeleteObjects();
 }
 
 void ScribeFolder::SerializeFieldWidths(bool Write)
 {
 	if (GetFldObj() && View())
 	{
 		// LAssert(View()->GetColumns() == Object->Fields().Length());
 		
 		int Cols = MIN(View()->GetColumns(), (int)GetFldObj()->Fields().Length());
 		for (int i=0; i<Cols; i++)
 		{
 			LItemColumn *c = View()->ColumnAt(i);
 			LDataPropI *f = GetFldObj()->Fields()[i];
 			if (c && f)
 			{
 				if (f->GetInt(FIELD_WIDTH) != c->Width())
 				{
 					if (Write)
 					{
 						c->Width((int)f->GetInt(FIELD_WIDTH));
 					}
 					else
 					{
 						f->SetInt(FIELD_WIDTH, c->Width());
 						SetDirty();
 					}
 				}
 			}
 			else LAssert(0);
 		}
 	}
 }
 
 void ScribeFolder::OnProperties(int Tab)
 {
 	if (!GetObject())
 		return;
 
 	SerializeFieldWidths();
 	if (View())
 	{
 		SetSort(View()->GetSortCol(), View()->GetSortAscending());
 	}
 
 	OpenFolderProperties(this, Tab, [this](auto repop)
 	{
 		if (repop)
 		{
 			SetDirty();
 			SerializeFieldWidths(true);
 			Populate(View());
 		}
 	});
 }
 
-ScribeFolder *ScribeFolder::CreateSubDirectory(const char *Name, int Type)
+ScribeFolder *ScribeFolder::GetSubFolder(const char *Path)
+{
+	if (!Path)
+		return NULL;
+
+	if (*Path == '/')
+		Path++;
+
+	ScribeFolder *Folder = NULL;
+	char Name[256];
+	auto Sep = strchr((char*)Path, '/');
+	if (Sep)
+	{
+		ZeroObj(Name);
+		memcpy(Name, Path, Sep-Path);
+	}
+	else
+	{
+		strcpy_s(Name, sizeof(Name), Path);
+	}
+
+	LTreeItem *Starts[2] =
+	{
+		GetChild(),
+		IsRoot() ? GetNext() : 0
+	};
+
+	for (int s=0; !Folder && s<CountOf(Starts); s++)
+	{
+		for (auto i = Starts[s]; i; i = i->GetNext())
+		{
+			ScribeFolder *f = dynamic_cast<ScribeFolder*>(i);
+			if (f)
+			{
+				auto n = f->GetName(true);
+				if (n.Equals(Name))
+				{
+					if (Sep)
+						Folder = f->GetSubFolder(Sep+1);
+					else
+						Folder = f;
+					break;
+				}
+			}
+		}
+	}
+
+	return Folder;
+}
+
+ScribeFolder *ScribeFolder::CreateSubFolder(const char *Name, int Type)
 {
 	ScribeFolder *NewFolder = 0;
 	auto ThisObj = dynamic_cast<LDataFolderI*>(GetObject());
 	if (Name && ThisObj && ThisObj->GetStore())
 	{
 		LDataI *Fld = GetObject()->GetStore()->Create(MAGIC_FOLDER);
 		if (Fld)
 		{
 			LDataFolderI *Obj = dynamic_cast<LDataFolderI*>(Fld);
 			if (Obj)
 			{
 				NewFolder = new ScribeFolder;
 				if (NewFolder)
 				{
 					NewFolder->App = App;
 					NewFolder->SetObject(Obj, false, _FL);
 
 					// Set name and type
 					NewFolder->SetName(Name, true);
 					NewFolder->GetObject()->SetInt(FIELD_FOLDER_TYPE, Type);
 
 					ThisObj->SubFolders();
 					if (NewFolder->GetObject()->Save(ThisObj))
 					{
 						Insert(NewFolder);
 						NewFolder->SetDefaultFields();
 						NewFolder->OnItemType();
 					}
 					else
 					{
 						DeleteObj(NewFolder);
 					}
 				}
 			}
 		}
 	}
 	return NewFolder;
 }
 
 bool ScribeFolder::Delete(LArray<Thing*> &Items, bool ToTrash)
 {
 	if (!App)
 		return false;
 
 	List<Mail> NotNew;
 	LArray<LDataI*> Del;
 	LDataStoreI *Store = NULL;
 	for (auto i: Items)
 	{
 		if (i->IsPlaceHolder())
 		{
 			i->DecRef();
 		}
 		else
 		{
 			Mail *m = i->IsMail();
 			if (m)
 				NotNew.Insert(m);
 
 			auto ObjStore = i->GetObject() ? i->GetObject()->GetStore() : NULL;
 			if (!Store)
 				Store = ObjStore;
 			if (Store == ObjStore)
 				Del.Add(i->GetObject());
 			else
 				LAssert(!"All objects must have the same store.");
 		}
 	}
 
 	if (NotNew.Length())
 		App->OnNewMail(&NotNew, false);
 
 	if (Del.Length() == 0)
 		return true;
 	if (!Store)
 	{
 		LgiTrace("%s:%i - No Store?\n", _FL);
 		return false;
 	}
 
 	if (!Store->Delete(Del, ToTrash))
 	{
 		LgiTrace("%s:%i - Store.Delete failed.\n", _FL);
 		return false;
 	}
 
 	return true;
 }
 
 class MoveToState
 {
 	ScribeWnd *App = NULL;
 
 	// Input
 	ScribeFolder *Folder = NULL;
 	LArray<Thing*> Items;
 	bool CopyOnly;
 	std::function<void(bool, LArray<Store3Status>&)> Callback;
 
 	// Output
 	bool Result = false; // Overall success/failure
 	LArray<Store3Status> Status; // Per item status
 
 	// State
 	LArray<LDataI*> InStoreMove; // Object in the same store...
 	LDataI *FolderObj = NULL;
 	LDataStoreI *FolderStore = NULL;
 	ScribeMailType NewBayesType = BayesMailUnknown;
 	LHashTbl<PtrKey<Thing*>, int> Map;
 	int NewFolderType = -1;
 	bool BuildDynMenus = false;
 	bool BayesInc = false;
 	size_t Moves = 0;
 
 	// Returns true if the object is deleted.
 	bool SetStatus(int i, Store3Status s)
 	{
 		LAssert(Status[i] == Store3NotImpl);
 		Status[i] = s;
 
 		LAssert(Moves > 0);
 		Moves--;
 
 		if (Moves > 0)
 			return false;
 		
 		OnMovesDone();
 		return true;
 	}
 
 public:
 	MoveToState(ScribeFolder *folder,
 				LArray<Thing*> &items,
 				bool copyOnly,
 				std::function<void(bool, LArray<Store3Status>&)> callback) :
 		Folder(folder),
 		Items(items),
 		CopyOnly(copyOnly),
 		Callback(callback)
 	{
 		// Validate parameters
 		if (Folder &&
 			(App = Folder->App))
 		{
 			LVariant v;
 			if (App->GetOptions()->GetValue(OPT_BayesIncremental, v))
 				BayesInc = v.CastInt32() != 0;
 		}
 		else
 		{
 			delete this;
 			return;
 		}
 
 		if ((FolderObj = Folder->GetObject()))
 		{
 			FolderStore = Folder->GetObject()->GetStore();
 		}
 
 		Status.Length(Moves = Items.Length());
 		for (auto &s: Status)
 			s = Store3NotImpl;
 
 		auto FolderItemType = Folder->GetItemType();
 		auto ThisFolderPath = Folder->GetPath();
 		NewBayesType = App->BayesTypeFromPath(ThisFolderPath);
 		NewFolderType = App->GetFolderType(Folder);
 		ScribeFolder *TemplatesFolder = App->GetFolder(FOLDER_TEMPLATES);
 		BuildDynMenus = Folder == TemplatesFolder;
 
 		for (unsigned i=0; i<Items.Length(); i++)
 		{
 			auto t = Items[i];
 			if (!t || !t->GetObject())
 			{
 				if (SetStatus(i, Store3Error))
 					return;
 				continue;
 			}
 
 			auto ThingItemType = t->Type();
 			if (FolderItemType != ThingItemType && FolderItemType != MAGIC_ANY)
 			{
 				if (SetStatus(i, Store3Error))
 					return;
 				continue;
 			}
 			
 			ScribeFolder *Old = t->GetFolder();
 			LString Path;
 			if (Old)
 			{
 				Path = Old->GetPath();
 		
 				if (Old == TemplatesFolder)
 					// Moving to or from the templates folder... update the menu
 					BuildDynMenus = true;
 			}
 
 			if (Old && Path)
 			{
 				bool IsDeleted = false;
 				App->GetAccessLevel(App,
 									Old->GetFolderPerms(ScribeWriteAccess),
 									Path,
 									[this, i, t, &IsDeleted](bool Allow)
 									{
 										if (Allow)
 											IsDeleted = Move(i, t);
 										else
 											IsDeleted = SetStatus(i, Store3NoPermissions);
 									});
 				// If the callback has already been executed and the object is deleted, exit immediately.
 				if (IsDeleted)
 					return;
 			}
 			else
 			{
 				if (Move(i, t))
 					return;
 			}
 		}
 
 	}
 
 	// This must call SetStatus once and only once for each item it's called with.
 	// Returns true if the SetStatus call indicates deletion.
 	// 'this' will be invalid after SetStatus returns true.
 	bool Move(int i, Thing *t)
 	{
 		ScribeMailType OldBayesType = BayesMailUnknown;
 		if (BayesInc &&
 			t->IsMail() &&
 			TestFlag(t->IsMail()->GetFlags(), MAIL_READ))
 		{
 			OldBayesType = App->BayesTypeFromPath(t->IsMail());
 		}
 
 		ScribeFolder *Old = t->GetFolder();
 		Store3Status r = Store3NotImpl;
 
 		int OldFolderType = Old ? App->GetFolderType(Old) : -1;
 		if ( (OldFolderType == FOLDER_TRASH || OldFolderType == FOLDER_SENT) &&
 				NewFolderType == FOLDER_TRASH)
 		{
 			// Delete for good
 			r = Old ? Old->DeleteThing(t, NULL) : Store3Error;
 		}
 		else
 		{
 			// If this folder is currently selected...
 			if (Folder->Select())
 			{
 				// Insert item into list
 				t->SetFieldArray(Folder->FieldArray);
 			}
 
 			if (CopyOnly)
 			{
 				LDataI *NewT = FolderStore->Create(t->Type());
 				if (NewT)
 				{
 					NewT->CopyProps(*t->GetObject());
 					r = NewT->Save(Folder->GetObject());
 				}
 				else
 				{
 					r = Store3Error;
 				}
 			}
 			else
 			{
 				if (NewFolderType != FOLDER_TRASH &&
 					OldBayesType != NewBayesType)
 				{
 					App->OnBayesianMailEvent(t->IsMail(), OldBayesType, NewBayesType);
 				}
 
 				// Move to this folder
 				auto o = t->GetObject();
 				if (o && o->GetStore() == FolderStore)
 				{
 					InStoreMove.Add(o);
 					Map.Add(t, i);
 					r = Store3Delayed;
 				}
 				else
 				{
 					// Out of store more... use the old single object method... for the moment..
 					r = t->SetFolder(Folder);
 					if (r == Store3Success)
 					{
 						// Remove from the list..
 						if (Old && Old->Select() && App->GetMailList())
 							App->GetMailList()->Remove(t);
 					}
 				}
 			}
 		}
 
 		if (r == Store3Success)
 			t->OnMove();
 
 		return SetStatus(i, r);
 	}
 
 	void OnMovesDone()
 	{
 		if (InStoreMove.Length())
 		{
 			Store3Status s = Store3NotImpl;
 			auto Fld = dynamic_cast<LDataFolderI*>(Folder->GetObject());
 			if (!Fld)
 				s = Store3Error;
 			else
 				s = FolderStore->Move(Fld, InStoreMove);
 
 			Result = s >= Store3Delayed;
 
 			for (auto p: Map)
 			{
 				Status[p.value] = s;
 
 				if (s == Store3Success)
 				{
 					LAssert(p.key->GetFolder() == Folder);
 					LAssert(Items.HasItem(p.key));
 					
 					p.key->OnMove();
 				}
 			}
 		}
 
 		if (BuildDynMenus)
 			// Moving to or from the templates folder... update the menu
 			App->BuildDynMenus();
 
 		if (Callback)
 			Callback(Result, Status);
 
 		delete this;
 	}
 };
 
 void ScribeFolder::MoveTo(LArray<Thing*> &Items, bool CopyOnly, std::function<void(bool, LArray<Store3Status>&)> Callback)
 {
 	if (Items.Length() == 0)
 		return;
 	if (!GetObject() || !App)
 		return;
 
 	new MoveToState(this, Items, CopyOnly, Callback);
 }
 
 int ThingFilterCompare(Thing *a, Thing *b, NativeInt Data)
 {
 	Filter *A = a->IsFilter();
 	Filter *B = b->IsFilter();
 	return (A && B) ? A->GetIndex() - B->GetIndex() : 0;
 }
 
 void ScribeFolder::ReSort()
 {
 	if (View() && Select())
 	{
 		View()->SetSort(GetSortCol(), GetSortAscend());
 	}
 }
 
 void ScribeFolder::SetSort(int Col, bool Ascend, bool CanDirty)
 {
 	if (GetItemType() == MAGIC_FILTER)
 	{
 		// Remove any holes in the indexing
 		int i = 1;
 		Items.Sort(ThingFilterCompare);
 
 		for (auto t : Items)
 		{
 			Filter *f = t->IsFilter();
 			if (f)
 			{
 				if (f->GetIndex() != i)
 				{
 					f->SetIndex(i);
 				}
 
 				i++;
 			}
 		}
 	}
 
 	if (GetSortCol() != Col ||
 		GetSortAscend() != (uchar)Ascend)
 	{
 		GetObject()->SetInt(FIELD_SORT, (Col + 1) * (Ascend ? 1 : -1));
 
 		if (CanDirty)
 			SetDirty();
 	}
 }
 
 int ScribeFolder::GetSortField()
 {
 	int Status = 0;
 	int Col = GetSortCol();
 
 	if (Col >= 0 && Col < (int)FieldArray.Length())
 		Status = FieldArray[Col];
 
 	return Status;
 }
 
 class FolderStream : public LStream
 {
 	ScribeFolder *f;
 
 	// Current index into the thing array
 	int Idx;
 	
 	// Total known size of stream...
 	int64 Sz;
 
 	// A memory buffer containing just the encoded 'Thing'
 	LMemStream Mem;
 
 	LString FolderMime;
 
 public:
 	FolderStream(ScribeFolder *folder) : Mem(512 << 10)
 	{
 		f = folder;
 		Idx = 0;
 		Sz = 0;
 
 		switch (f->GetItemType())
 		{
 			case MAGIC_MAIL:
 				FolderMime = sMimeMbox;
 				break;
 			case MAGIC_CONTACT:
 				FolderMime = sMimeVCard;
 				break;
 			case MAGIC_CALENDAR:
 				FolderMime = sMimeVCalendar;
 				break;
 			default:
 				LAssert(!"Need a mime type?");
 				break;
 		}
 	}
 
 	int GetIndex() { return Idx; }
 	int Open(const char *Str = 0,int Int = 0) { return true; }
 	bool IsOpen() { return true; }
 	int Close() { return 0; }
 	
 	int64 GetSize()
 	{
 		return -1;
 	}
 	
 	int64 SetSize(int64 Size)
 	{
 		return -1;
 	}
 	
 	int64 GetPos()
 	{
 		return -1;
 	}
 	
 	int64 SetPos(int64 pos)
 	{
 		// This means that IStream::Seek return E_NOTIMPL, which is important
 		// for windows to support copies of unknown size.
 		return -1;
 	}
 	
 	ssize_t Read(void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		// Read from stream..
 		int64 Remaining = Mem.GetSize() - Mem.GetPos();
 		if (Remaining <= 0)
 		{
 			Thing *t = Idx < (ssize_t)f->Items.Length() ? f->Items[Idx++] : NULL;
 			if (t)
 			{
 				Mem.SetSize(0);
 				
 				// We can't allow Export to delete the Mem object, we own it.
 				// So create a proxy object for it.
 				LAutoPtr<LStreamI> cp(new LProxyStream(&Mem));
 				
 				if (t->Export(cp, FolderMime))
 					Sz += Mem.GetSize();
 				else
 					LAssert(0);
 				
 				Mem.SetPos(0);
 			}
 			else return 0;
 		}
 
 		Remaining = Mem.GetSize() - Mem.GetPos();
 		if (Remaining > 0)
 		{
 			int Common = (int)MIN(Size, Remaining);
 			ssize_t Rd = Mem.Read(Buffer, Common);
 			if (Rd > 0)
 				return Rd;
 			else
 				LAssert(0);
 		}
 		
 		return 0;
 	}
 	
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		LAssert(0);
 		return 0;
 	}
 
 	LStreamI *Clone()
 	{
 		LAssert(0);
 		return NULL;
 	}
 };
 
 // ScribeFolder drag'n'drop
 bool ScribeFolder::GetFormats(LDragFormats &Formats)
 {
 	if (GetItemType() == MAGIC_MAIL ||
 		GetItemType() == MAGIC_CONTACT ||
 		GetItemType() == MAGIC_CALENDAR)
 	{
 		Formats.SupportsFileStreams();
 	}
 
 	Formats.Supports(ScribeFolderObject);
 	return Formats.Length() > 0;
 }
 
 bool ScribeFolder::OnBeginDrag(LMouse &m)
 { 
 	if (GetParent())
 		Drag(Tree, m.Event, DROPEFFECT_MOVE | DROPEFFECT_COPY);
 	return true;
 }
 
 void ScribeFolder::OnEndData()
 {
 	DropFileName.Empty();
 }
 
 LString ScribeFolder::GetDropFileName()
 {
 	LAutoString Fn(MakeFileName(GetObject()->GetStr(FIELD_FOLDER_NAME), 0));
 	DropFileName = Fn;
 
 	if (GetItemType() == MAGIC_MAIL)
 		DropFileName += ".mbx";
 	else if (GetItemType() == MAGIC_CONTACT)
 		DropFileName += ".vcf";
 	else if (GetItemType() == MAGIC_CALENDAR)
 		DropFileName += ".ics";
 	else if (GetItemType() == MAGIC_FILTER)
 		DropFileName += ".xml";
 
 	return DropFileName;
 }
 
 bool ScribeFolder::GetData(LArray<LDragData> &Data)
 {
 	ssize_t DataSet = 0;
 	
 	for (unsigned idx=0; idx<Data.Length(); idx++)
 	{
 		LDragData &dd = Data[idx];
 		
 		if (dd.IsFormat(LGI_StreamDropFormat))
 		{
 			LAutoStreamI s(new FolderStream(this));
 			if (s)
 			{
 				s->SetPos(0);
 				
 				auto Fn = GetDropFileName();
 				auto MimeType = sMimeMbox;
 				auto r = dd.AddFileStream(LGetLeaf(Fn), MimeType, s);
 				LAssert(r);
 			}
 
 			DataSet = dd.Data.Length();
 		}
 		else if (dd.IsFormat(LGI_FileDropFormat))
 		{
 			LMouse m;
 			if (App->GetMouse(m, true))
 			{
 				LString::Array Files;
 
 				if (GetDropFileName())
 				{
 					LAutoPtr<LFile> f(new LFile);
 					if (f->Open(DropFileName, O_WRITE))
 					{
 						if (GetItemType() == MAGIC_MAIL)
 							Export(AutoCast(f), sMimeMbox);
 						else if (GetItemType() == MAGIC_CONTACT)
 							Export(AutoCast(f), sMimeVCard);
 						else if (GetItemType() == MAGIC_CALENDAR)
 							Export(AutoCast(f), sMimeVCalendar);
 					}
 				}
 
 				if (DropFileName)
 				{
 					Files.Add(DropFileName.Get());
 					if (CreateFileDrop(&dd, m, Files))
 					{
 						DataSet++;
 					}
 					else LgiTrace("%s:%i - CreateFileDrop failed.\n", _FL);
 				}
 				else LgiTrace("%s:%i - No drop file name.\n", _FL);
 			}
 			else LgiTrace("%s:%i - GetMouse failed.\n", _FL);
 		}
 		else if (dd.IsFormat(ScribeFolderObject))
 		{
 			ScribeClipboardFmt *Fmt = ScribeClipboardFmt::Alloc(true, 1);
 			if (Fmt)
 			{
 				Fmt->FolderAt(0, this);
 				dd.Data[0].SetBinary(Fmt->Sizeof(), Fmt);
 				DataSet++;
 
 				free(Fmt);
 			}
 		}
 	}
 
 	return DataSet > 0;
 }
 
 void ScribeFolder::CollectSubFolderMail(ScribeFolder *To)
 {
 	if (!To) To = this;
 
 	LoadThings(NULL, [this, To](auto Status)
 	{
 		LArray<Thing*> Items;
 		for (auto Item: Items)
 		{
 			if (To != this && Item->IsMail())
 				Items.Add(Item);
 		}
 		To->MoveTo(Items, false, NULL);
 
 		for (ScribeFolder *f = GetChildFolder(); f; f = f->GetNextFolder())
 		{
 			f->CollectSubFolderMail(To);
 		}
 	});
 }
 
 void ScribeFolder::OnReceiveFiles(LArray<const char*> &Files)
 {
 	if (Files.Length())
 	{
 		for (unsigned i=0; i<Files.Length(); i++)
 		{
 			auto File = Files[i];
 
 			// Ask OS what mime type the file is
 			LString MimeType = ScribeGetFileMimeType(File);
 			// printf("[%i]=%s %s\n", i, File, MimeType.Get());
 
 			// Import the file...
 			LAutoPtr<LTextFile> f(new LTextFile);
 			if (f->Open(File, O_READ))
 				Import(AutoCast(f), MimeType);
 		}
 	}
 }
 
 // Import/export
 bool ScribeFolder::GetFormats(bool Export, LString::Array &MimeTypes)
 {
 	MimeTypes.Add(sMimeMbox);
 
 	if (!Export)
 		MimeTypes.Add(sMimeMessage);
 
 	return MimeTypes.Length() > 0;
 }
 
-class MboxParser : public LStringPipe
-{
-	LStreamI *Src = NULL;
-	int Hdrs = 0;
-	bool NewMsg = true;
-	LArray<char> Buf;
-	int64 Pos = 0;
-	bool Eof = false;
-	
-	bool IsMessageHdr(LString c)
-	{
-		// check that it's a from line
-		auto parts = c.SplitDelimit(" \r");
-		if (parts.Length() >= 7 &&
-			parts.Length() <= 9 &&
-			parts[0].Equals("From"))
-		{
-			return true;
-		}
-
-		return false;
-	}
-
-	struct Blk
-	{
-		uint8_t *ptr;
-		ssize_t size;
-	};
-
-	struct Blocks : public LArray<Blk>
-	{
-		ssize_t Bytes = 0;
-
-		Blocks(LMemQueue *q)
-		{
-			q->Iterate([this](auto ptr, auto size)
-			{
-				auto &b = New();
-				
-				b.ptr = ptr;
-				b.size = size;
-				Bytes += size;
-
-				return true;
-			});
-		}
-
-		LString GetLine(size_t idx, size_t offset)
-		{
-			char buf[256];
-			int ch = 0;
-
-			for (size_t i = idx; i < Length(); i++)
-			{
-				auto &b = (*this)[i];
-				auto p = b.ptr + offset;
-				auto end = b.ptr + b.size;
-				while (p < end)
-				{
-					if (*p == '\n' || ch == sizeof(buf)-1)
-						return LString(buf, ch);
-
-					buf[ch++] = *p++;
-				}
-			}
-
-			return LString();
-		}
-
-		bool ValidateSeparator(LString ln)
-		{
-			auto p = ln.SplitDelimit();
-
-			if (p.Length() < 7)
-				return false;
-
-			if (!p[0].Equals("From"))
-				return false;
-
-			if (p[1].Find("@") < 0)
-				return false;
-
-			bool hasYear = false;
-			bool hasTime = false;
-			for (int i=2; i<p.Length(); i++)
-			{
-				auto &s = p[i];
-				if (s.Length() == 4)
-				{
-					auto val = s.Int();
-					if (val >= 1800 && val < 2200)
-						hasYear = true;
-				}
-				else if (s.Find(":") > 0)
-				{
-					int colons = 0, nonDigits = 0;
-					for (auto p = s.Get(); *p; p++)
-						if (*p == ':')
-							colons++;
-						else if (!IsDigit(*p))
-							nonDigits++;
-					if (colons == 2 && nonDigits == 0)
-						hasTime = true;
-				}
-			}
-
-			return hasYear && hasTime;
-		}
-
-		ssize_t FindBoundary(ssize_t start)
-		{
-			const char *key = "\nFrom ";
-			const char *k = key + 1;
-			size_t idx = 0;
-			ssize_t offset = 0;
-
-			if (Bytes == 0)
-				return -1;
-
-			if (start < 0 || start >= Bytes)
-			{
-				LAssert(!"Start out of range.");
-				return -1;
-			}
-
-			// Seek to the right starting block...
-			while (idx < Length())
-			{
-				auto &b = (*this)[idx];
-				if (start < b.size)
-					break;
-				start -= b.size;
-				offset += b.size;
-				idx++;
-			}
-			
-			// Start searching for the key...
-			while (idx < Length())
-			{
-				auto &b = (*this)[idx];
-				
-				auto end = b.ptr + b.size;
-				for (auto p = b.ptr + start; p < end; p++)
-				{
-					if (*k == *p)
-					{
-						if (*++k == 0)
-						{
-							// Found the "From " part, but lets check the rest of the line.
-							// Should be in the format:
-							//		From sender date more-info
-							auto blkAddr = (p - b.ptr) - 4;
-							LString ln = GetLine(idx, blkAddr);
-							if (ln && ValidateSeparator(ln))
-								return offset + blkAddr;
-						}
-					}
-					else k = key;
-				}
-
-				offset += b.size;
-				idx++;
-			}
-
-			return -1;
-		}
-
-		LRange FindMsg(MboxParser &parser)
-		{
-			auto start = FindBoundary(0);
-			if (start > 0)
-				LgiTrace("%s:%i - Usually the start should be 0, but it's " LPrintfSSizeT "?\n",
-					_FL, start);
-
-			if (start >= 0)
-			{
-				auto end = FindBoundary(start + 5);
-				if (end > start)
-				{
-					return LRange(start, end - start);
-				}
-				else if (parser.Eof)
-				{
-					return LRange(start, Bytes);
-				}
-			}
-
-			return LRange(-1, 0);
-		}
-	};
-
-public:
-	MboxParser(LStreamI *s) : LStringPipe(128 << 10)
-	{
-		Src = s;
-		// _debug = true;
-		Buf.Length(128 << 10);
-	}
-
-	bool ReadSource()
-	{
-		auto rd = Src->Read(Buf.AddressOf(), Buf.Length());
-		if (rd <= 0)
-		{
-			// Src stream is empty or in an error state..
-			Eof = true;
-			return false;
-		}
-
-		auto wr = Write(Buf.AddressOf(), Buf.Length());
-		if (wr <= 0)
-		{
-			LgiTrace("%s:%i - Failed to write to local buffer.\n", _FL);
-			return false;
-		}
-
-		return true;
-	}
-
-	LAutoPtr<LStreamI> ReadMessage()
-	{
-		LAutoPtr<LStreamI> m;
-
-		while (true)
-		{
-			Blocks blks(this);
-			auto r = blks.FindMsg(*this);
-			if (r.Start >= 0)
-			{
-				LMemStream *ms = NULL;
-
-				/*
-				LgiTrace("ReadMsg " LPrintfInt64 " %s\n", Pos, r.GetStr());
-				auto InitPos = Pos;
-				*/
-
-				Pos += r.Len;
-				m.Reset(ms = new LMemStream(this, r.Start, r.Len));
-
-				/* Debugging...
-				auto key = "The package name is vmware_addons.";
-				auto base = ms->GetBasePtr();
-				auto result = Strnistr(base, key, m->GetSize());
-				if (result)
-					LgiTrace("Found the Key @ " LPrintfInt64 "\n", InitPos + (result - base));
-				*/
-				break;
-			}
-			else if (!ReadSource())
-			{
-				r = blks.FindMsg(*this);
-				if (r.Start >= 0)
-					m.Reset(new LMemStream(this, r.Start, r.Len));
-				break;
-			}
-		}
-
-		return m;
-	}
-};
-
-class ImportFolderTask : public FolderTask
-{
-	LDataStoreI::StoreTrans trans;
-	LAutoPtr<MboxParser> Parser;
-	
-public:
-	ImportFolderTask(ScribeFolder *fld, LAutoPtr<LStreamI> in, LString mimeType, ThingType::IoProgressCallback cb) :
-		FolderTask(fld, in, mimeType, cb)
-	{
-		SetDescription(LLoadString(IDS_MBOX_READING));
-		SetType("K");
-		SetScale(1.0/1024.0);
-		SetRange(Stream->GetSize());
-
-		trans = fld->GetObject()->GetStore()->StartTransaction();
-	}
-	
-	bool TimeSlice()
-	{
-		auto Start = LCurrentTime();
-		bool Eof = false;
-
-		if (!Parser)
-			Parser.Reset(new MboxParser(Stream));
-		
-		while ( Parser
-				&&
-				LCurrentTime() - Start < WORK_SLICE_MS
-		        &&
-		        !IsCancelled())
-		{
-			auto Msg = Parser->ReadMessage();
-			if (Msg)
-			{
-				Mail *m = dynamic_cast<Mail*>(App->CreateItem(MAGIC_MAIL, Folder, false));
-				if (m)
-				{
-					m->OnAfterReceive(Msg);
-					m->SetFlags(MAIL_RECEIVED|MAIL_READ);
-					m->Save();
-					m->Update();
-				}
-				else
-				{
-					Eof = true;
-					break;
-				}
-			}
-			else
-			{
-				Eof = true;
-				break;
-			}
-
-			Value(Stream->GetPos());
-		}
-		
-		return !Eof;
-	}
-};
-
 ThingType::IoProgress ScribeFolder::Import(IoProgressImplArgs)
 {
 	if (Stricmp(mimeType, sMimeMbox) == 0 ||
 		Stricmp(mimeType, "text/x-mail") == 0)
 	{
 		// Mail box format...
 		ThingType::IoProgress p(Store3Delayed);
 		p.prog = new ImportFolderTask(this, stream, mimeType, cb);
 		return p;
 	}
 	else if (Stricmp(mimeType, sMimeVCard) == 0)
 	{
 		VCard Io;
 		Thing *t;
 		bool Error = false;
 		int Imported = 0;
 		int Idx = 0;
 
 		while ((t = App->CreateItem(GetItemType(), 0, false)))
 		{
 			Contact *c = t->IsContact();
 			if (!c)
 			{
 				t->DecRef();
 				Error = true;
 				break;
 			}
 
 			if (Io.Import(c->GetObject(), stream))
 			{
 				const char *First = 0, *Last = 0;
 				c->GetField(FIELD_FIRST_NAME, First);
 				c->GetField(FIELD_LAST_NAME, Last);
 				LgiTrace("Import %i %s %s\n", Idx, First, Last);
 
 				if (t->Save(this))
 				{
 					Imported++;
 				}
 				else
 				{
 					Error = true;
 					break;
 				}
 			}
 			else
 			{
 				t->DecRef();
 				break;
 			}
 
 			Idx++;
 		}
 		
 		if (Error)
 		{
 			LgiMsg(	App,
 					LLoadString(IDS_ERROR_IMPORT_COUNT),
 					AppName, MB_OK,
 					LLoadString(IDC_CONTACTS),
 					Imported);
 			IoProgressError("Contact import error.");
 		}
 
 		IoProgressSuccess();
 	}
 	else if (Stricmp(mimeType, sMimeVCalendar) == 0)
 	{
 		VCal Io;
 		Thing *t;
 
 		while ((t = App->CreateItem(GetItemType(), this, false)))
 		{
 			if (Io.Import(t->GetObject(), stream))
 			{
 				if (!t->Save(this))
 					IoProgressError("Contact save failed.");
 			}
 			else
 			{
 				t->DecRef();
 				break;
 			}
 		}
 
 		IoProgressSuccess();
 	}
 	else if (GetObject())
 	{
 		Thing *t = App->CreateThingOfType(GetItemType(), GetObject()->GetStore()->Create(GetItemType()));
 		if (!t)
 			IoProgressError("Failed to create contact");
 
 		if (!t->Import(stream, mimeType))
 		{
 			t->DecRef();
 			IoProgressError("Contact import failed.");
 		}
 
 		if (!t->Save(this))
 		{
 			t->DecRef();
 			IoProgressError("Contact save failed.");
 		}
 
 		IoProgressSuccess();
 	}
 	
 	IoProgressNotImpl();
 }
 
 class FolderExportTask : public LProgressDlg
 {
 	LAutoPtr<LStreamI> Out;
 	ScribeFolder *Folder;
 	LString MimeType;
 	int Idx;
 	bool HasError = false;
 
 public:
 	// Minimum amount of time to do work.
 	constexpr static int WORK_SLICE_MS		= 130;
 	// This should be larger then WORK_SLICE_MS to allow message loop to process
 	constexpr static int PULSE_MS			= 200;
 
 	FolderExportTask(LAutoPtr<LStreamI> out, ScribeFolder *folder, LString mimeType) : LProgressDlg(folder->App)
 	{
 		Out = out;
 		Folder = folder;
 		MimeType = mimeType;
 		Idx = 0;
 		Ts = LCurrentTime();
 		Folder->App->OnFolderTask(this, true);
 
 		bool Mbox = _stricmp(MimeType, sMimeMbox) == 0;
 
 		// Clear the files contents
 		Out->SetSize(0);
 
 		// Setup progress UI
 		SetDescription(Mbox ? LLoadString(IDS_MBOX_WRITING) : (char*)"Writing...");
 		SetRange(Folder->Items.Length());
 		
 		switch (Folder->GetItemType())
 		{
 			case MAGIC_MAIL:
 				SetType(LLoadString(IDS_EMAIL));
 				break;
 			case MAGIC_CALENDAR:
 				SetType(LLoadString(IDS_CALENDAR));
 				break;
 			case MAGIC_CONTACT:
 				SetType(LLoadString(IDS_CONTACT));
 				break;
 			case MAGIC_GROUP:
 				SetType("Groups");
 				break;
 			default:
 				SetType("Objects");
 				break;
 		}
 
 		SetPulse(PULSE_MS);
 		SetAlwaysOnTop(true);
 	}
 	
 	~FolderExportTask()
 	{
 		Folder->App->OnFolderTask(this, false);
 	}
 	
 	bool OnRequestClose(bool OsClose)
 	{
 		return true;
 	}
 	
 	void OnPulse()
 	{
 		LProgressDlg::OnPulse();
 		PostEvent(M_EXPORT_NEXT);
 	}
 	
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		if (Msg->Msg() == M_EXPORT_NEXT)
 		{
 			auto StartTs = LCurrentTime();
 			while (	!IsCancelled() &&
 					(LCurrentTime() - StartTs) < WORK_SLICE_MS)
 			{
 				if (Idx >= (ssize_t)Folder->Items.Length())
 				{
 					Quit();
 					break;
 				}
 
 				// Process all the container's items
 				Thing *t = Folder->Items[Idx++];
 				if (t)
 				{
 					if (t->Export(Out, MimeType, NULL))
 					{
 						Value(Idx);
 					}
 					else
 					{
 						HasError = true;
 						LgiMsg(this, "Error exporting items.", AppName);
 						Quit();
 					}
 				}
 			}			
 			return 0;
 		}
 
 		return LProgressDlg::OnEvent(Msg);
 	}
 };
 
 
 // This is the mime type used to storage objects on disk
 const char *ScribeFolder::GetStorageMimeType()
 {
 	auto Type = GetItemType();
 	switch (Type)
 	{
 		case MAGIC_MAIL:
 			return sMimeMbox;
 		case MAGIC_CALENDAR:
 			return sMimeVCalendar;
 		case MAGIC_CONTACT:
 			return sMimeVCard;
 		case MAGIC_FILTER:
 			return sMimeXml;
 		default:
 			LgiTrace("%s:%i - Unsupported storage type: %s\n", _FL, Store3ItemTypeName(Type));
 			break;
 	}
 	
 	return NULL;
 }
 
 void ScribeFolder::ExportAsync(LAutoPtr<LStreamI> f, const char *MimeType, std::function<void(LProgressDlg*)> Callback)
 {
 	if (!MimeType)
 	{
 		LAssert(!"No Mimetype");
 		if (Callback) Callback(NULL);
 		return;
 	}
 
 	LoadThings(	NULL,
 				[
 					this,
 					Str = f.Release(),
 					MimeType = LString(MimeType),
 					Callback
 				]
 				(auto Status)
 				{
 					LAutoPtr<LStreamI> f(Str);
 					FolderExportTask *Task = NULL;
 					if (Status == Store3Success)
 						Task = new FolderExportTask(f, this, MimeType);
 					if (Callback)
 						Callback(Task);
 				});
 }
 
 ThingType::IoProgress ScribeFolder::Export(IoProgressImplArgs)
 {
 	IoProgress ErrStatus(Store3Error);
 	if (!mimeType)
 	{
 		ErrStatus.errMsg = "No mimetype.";
 		if (cb) cb(&ErrStatus, NULL);
 		return ErrStatus;
 	}
 		
 	if (!LoadThings())
 	{
 		ErrStatus.errMsg = "Failed to load things.";
 		if (cb) cb(&ErrStatus, NULL);
 		return ErrStatus;
 	}
 
 	IoProgress Status(Store3Delayed);
 	Status.prog = new ExportFolderTask(this, stream, mimeType, cb);
 	return Status;
 }
 
 size_t ScribeFolder::Length()
 {
 	if (GetItemType() == MAGIC_MAIL)
 	{
 		ThingList *v = View();
 		if (v)
 			return v->Length();
 	}
 
 	if (IsLoaded())
 		return Items.Length();
 
 	return GetItems();
 }
 
 ssize_t ScribeFolder::IndexOf(Mail *m)
 {
 	if (GetItemType() == MAGIC_MAIL)
 	{
 		ThingList *v = View();
 		if (v)
 			return v->IndexOf(m);
 	
 		return Items.IndexOf(m);
 	}
 
 	return -1;
 }
 
 Mail *ScribeFolder::operator [](size_t i)
 {
 	if (GetItemType() == MAGIC_MAIL)
 	{
 		ThingList *v = View();
 		if (v)
 			return dynamic_cast<Mail*>(v->ItemAt(i));
 
 		Thing *t = Items[i];
 		if (t)
 			return t->IsMail();
 	}
 
 	return NULL;
 }
 
 bool ScribeFolder::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdType: // Type: Int32
 		{
 			Value = GetObject()->Type();
 			break;
 		}
 		case SdName: // Type: String
 		{
 			Value = GetName(true).Get();
 			break;
 		}
 		case SdPath: // Type: String
 		{
 			auto p = GetPath();
 			if (p)
 				Value = p;
 			else
 				return false;
 			break;
 		}
 		case SdUnread: // Type: Int32
 		{
 			Value = GetUnRead();
 			break;
 		}
 		case SdLength: // Type: Int32
 		{
 			Value = (int32)Items.Length();
 			break;
 		}
 		case SdItem: // Type: Thing[]
 		{
 			Value.Empty();
 
 			LoadThings(); // Use in sync mode, no callback
 
 			// This call back HAS to set value one way or another...
 			if (Array)
 			{
 				bool IsNumeric = true;
 				for (auto *v = Array; *v; v++)
 				{
 					if (!IsDigit(*v))
 					{
 						IsNumeric = false;
 						break;
 					}
 				}
 
 				if (IsNumeric)
 				{
 					int Idx = atoi(Array);
 					if (Idx >= 0 && Idx < (ssize_t)Items.Length())
 					{
 						Value = (LDom*) Items[Idx];
 						return true;
 					}
 				}
 				else // Is message ID?
 				{
 					for (auto t : Items)
 					{
 						Mail *m = t->IsMail();
 						if (!m)
 							break;
 
 						auto Id = m->GetMessageId();
 						if (Id && !strcmp(Id, Array))
 						{
 							Value = (LDom*)t;
 							return true;
 						}
 					}
 				}
 			}
 			else if (Value.SetList())
 			{
 				for (auto t : Items)
 					Value.Value.Lst->Insert(new LVariant((LDom*)t));
 				return true;
 			}
 			break;
 		}
 		case SdItemType: // Type: Int32
 		{
 			Value = GetItemType();
 			break;
 		}
 		case SdScribe: // Type: ScribeWnd
 		{
 			Value = (LDom*)App;
 			break;
 		}
 		case SdChild: // Type: ScribeFolder
 		{
 			Value = (LDom*)GetChildFolder();
 			break;
 		}
 		case SdNext: // Type: ScribeFolder
 		{
 			Value = (LDom*)GetNextFolder();
 			break;
 		}
 		case SdSelected: // Type: Thing[]
 		{
 			if (!Select() ||
 				!Value.SetList())
 				return false;
 			
 			List<Thing> a;
 			if (!App->GetMailList()->GetSelection(a))
 				return false;
 			
 			for (auto t: a)
 			{
 				Value.Value.Lst->Insert(new LVariant(t));
 			}
 			break;
 		}
 		case SdExpanded: // Type: Boolean
 		{
 			Value = Expanded();
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool ScribeFolder::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdName: // Type: String
 		{
 			char *s = Value.CastString();
 			if (ValidStr(s))
 				OnRename(s);
 			else
 				return false;
 			break;
 		}
 		case SdExpanded: // Type: Boolean
 		{
 			Expanded(Value.CastInt32() != 0);
 			break;
 		}
 		default:
 			return false;
 	}
 	
 	return true;
 }
 
 bool ScribeFolder::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType m = StrToDom(MethodName);
 	switch (m)
 	{
 		case SdLoad: // Type: ()
 		{
 			LoadThings(App);
 			// FIXME: Callback for status?
 			return true;
 		}
 		case SdSelect: // Type: ()
 		{
 			Select(true);
 			return true;
 		}
 		case SdImport: // Type: (String FileName, String MimeType)
 		{
 			*ReturnValue = false;
 			if (Args.Length() != 2)
 				LgiTrace("%s:%i - Error: expecting 2 arguments to 'Import'.\n", _FL);
 			else
 			{
 				auto FileName = Args[0]->Str();
 				LAutoPtr<LFile> f(new LFile);
 				if (f->Open(FileName, O_READ))
 				{
 					auto p = Import(AutoCast(f), Args[1]->Str());
 					*ReturnValue = p.status;
 				}
 				else
 					LgiTrace("%s:%i - Error: Can't open '%s' for reading.\n", _FL, FileName);
 			}
 			break;
 		}
 		case SdExport: // Type: (String FileName, String MimeType)
 		{
 			*ReturnValue = false;
 			if (Args.Length() != 2)
 				LgiTrace("%s:%i - Error: expecting 2 arguments to 'Export'.\n", _FL);
 			else
 			{
 				auto FileName = Args[0]->Str();
 				LAutoPtr<LFile> f(new LFile);
 				if (f->Open(FileName, O_WRITE))
 				{
 					auto p = Export(AutoCast(f), Args[1]->Str());
 					*ReturnValue = p.status;
 				}
 				else
 					LgiTrace("%s:%i - Error: Can't open '%s' for writing.\n", _FL, FileName);
 			}
 			break;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 void ScribeFolder::OnRethread()
 {
 	if (GetThreaded())
 	{
 		Thread();
 	}
 }
 
diff --git a/src/ScribeFolderSelect.cpp b/src/ScribeFolderSelect.cpp
--- a/src/ScribeFolderSelect.cpp
+++ b/src/ScribeFolderSelect.cpp
@@ -1,400 +1,400 @@
 /*
 **	FILE:			ScribeFolderSelect.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			1/6/1999
 **	DESCRIPTION:	Scribe Folder Selection
 **
 **	Copyright (C) 1999, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 
 #include "Scribe.h"
 #include "lgi/common/Button.h"
 #include "resdefs.h"
 
 class FolderDlgPriv;
 class ScribeFolderTree : public LTree
 {
 	void AddFolder(FolderDlgPriv *d, LTreeItem *i, ScribeFolder *f);
 
 public:
 	ScribeFolderTree(int id, int x, int y, int cx, int cy);
 
 	void Setup(FolderDlgPriv *d, ScribeFolder *Root, const char *InitSel);
 	LString Get2();
 };
 
 class FolderDlgPriv
 {
 public:
 	FolderDlg *Dlg = NULL;
 	ScribeWnd *App = NULL;
 	bool CreateNew = false;
 	int LimitTo = MAGIC_NONE;
 	LString Path;
 	LString DefaultNewFolderName;
 	LString Filter;
 	ScribeFolderTree *View = NULL;
 
 	FolderDlgPriv(ScribeWnd *app, FolderDlg *t, bool create)
 	{
 		CreateNew = create;
 		Dlg = t;
 		App = app;
 	}
 
 	void OnFilter();
 };
 
 //////////////////////////////////////////////////////////////////////////////
 struct FolderLeaf : public LTreeItem
 {
 	FolderDlgPriv *d;
 	ScribeFolder *Folder;
 	bool isRoot = false;
 
 	FolderLeaf(FolderDlgPriv *priv, ScribeFolder *folder, bool isroot = false)
 	{
 		d = priv;
 		Folder = folder;
 		isRoot = isroot;
 	}
 
 	bool IsSelectable()
 	{
 		auto fType = Folder ? Folder->GetItemType() : 0;
 		return	d->LimitTo == MAGIC_NONE ||
 				d->LimitTo == MAGIC_ANY ||
 				(Folder && d->LimitTo == fType);
 	}
 
 	const char *GetText(int i=0) override
 	{
 		if (!Folder)
 			return "<error>";
 		if (isRoot)
 			return "Folders";
 
 		return Folder->GetText(i);
 	}
 
 	int GetImage(int Flags = 0) override
 	{
 		if (IsSelectable())
 		{
 			return (Flags) ? ICON_OPEN_FOLDER : ICON_CLOSED_FOLDER;
 		}
 
 		return ICON_DISABLED_FOLDER;
 	}
 
 	ScribeFolder *GetFolder()
 	{
 		return Folder;
 	}
 
 	void OnSelect() override
 	{
 		LViewI *Parent = Tree->LView::GetParent();
 		if (Parent)
 		{
 			Parent->SetCtrlEnabled(IDOK, IsSelectable());
 			Parent->SetCtrlEnabled(IDC_NEW_FOLDER, IsSelectable() && d->CreateNew);
 		}
 	}
 };
 
 void FolderDlgPriv::OnFilter()
 {
 	// Initialize visible
 	View->ForAllItems([vis = Filter ? LCss::DispNone : LCss::DispBlock](auto i)
 	{
 		FolderLeaf *l = dynamic_cast<FolderLeaf*>(i);
 		if (!l) return;
 		
 		l->GetCss(true)->Display(vis);
 	});
 
 	// Find matching items...
 	View->ForAllItems([this](auto i)
 	{
 		FolderLeaf *l = dynamic_cast<FolderLeaf*>(i);
 		if (!l) return;
 
 		auto nm = l->GetText();
 		if (Stristr(nm, this->Filter.Get()))
 		{
 			l->GetCss(true)->Display(LCss::DispBlock);
 
 			for (auto p = l->GetParent(); p; p = p->GetParent())
 			{
 				FolderLeaf *lp = dynamic_cast<FolderLeaf*>(p);
 				if (lp) lp->GetCss(true)->Display(LCss::DispBlock);
 			}
 		}
 	});
 
 	View->UpdateAllItems();
 	View->Invalidate();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 class LFolderCtrlFactory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (!Stricmp(Class, "ScribeFolderTree"))
 			return new ScribeFolderTree(-1, 0, 0, 100, 100);
 
 		return 0;
 	}
 
 }	FolderCtrlFactory;
 
 ScribeFolderTree::ScribeFolderTree(int id, int x, int y, int cx, int cy) :
 	LTree(id, x, y, cx, cy, "")
 {
 	SetObjectName(Res_Custom);
 	Sunken(true);
 	AskImage(true);
 }
 
 void ScribeFolderTree::Setup(FolderDlgPriv *d, ScribeFolder *Root, const char *InitSel)
 {
 	if (!Root)
 	{
 		LAssert(!"No root");
 		return;
 	}
 		
 	auto Leaf = new FolderLeaf(d, Root, true);
 	if (!Leaf)
 	{
 		LAssert(!"Alloc failed.");
 		return;
 	}
 
 	Insert(Leaf);
 	AddFolder(d, Leaf, Root);
 
 	ScribeFolder *f = Root;
 	while ((f = f->GetNextFolder()))
 	{
 		Leaf = new FolderLeaf(d, f);
 		if (Leaf)
 		{
 			Insert(Leaf);
 			AddFolder(d, Leaf, f);
 		}
 	}
 
 	if (InitSel)
 	{
 		auto Path = LString(InitSel).SplitDelimit("/");
 		LTreeNode *n = this;
 		for (unsigned i=0; i<Path.Length(); i++)
 		{
 			FolderLeaf *Match = 0;
 			for (FolderLeaf *c = dynamic_cast<FolderLeaf*>(n->GetChild()); c;
 								c = dynamic_cast<FolderLeaf*>(c->GetNext()))
 			{
 				auto s = c->GetFolder()->GetName(true);
 				if (s.Equals(Path[i]))
 				{
 					Match = c;
 					break;
 				}
 			}
 
 			if (Match)
 				n = Match;
 			else
 				break;
 		}
 
 		LTreeItem *it = dynamic_cast<LTreeItem*>(n);
 		if (it)
 			it->Select(true);
 	}
 
 	UpdateAllItems();
 }
 
 void ScribeFolderTree::AddFolder(FolderDlgPriv *d, LTreeItem *i, ScribeFolder *f)
 {
 	if (!i || !f)
 	{
 		LAssert(!"Missing param");
 		return;
 	}
 
 	f->LoadFolders();
 
 	for (ScribeFolder *Folder = f->GetChildFolder(); Folder; Folder = Folder->GetNextFolder())
 	{
 		FolderLeaf *Leaf = new FolderLeaf(d, Folder);
 		if (Leaf)
 		{
 			i->Insert(Leaf);
 			AddFolder(d, Leaf, Folder);
 			i->Expanded(true);
 		}
 	}
 }
 
 LString ScribeFolderTree::Get2()
 {
 	LString a;
 	FolderLeaf *Leaf = dynamic_cast<FolderLeaf*>(Selection());
 	if (Leaf)
 	{
 		ScribeFolder *Folder = Leaf->GetFolder();
 		if (Folder)
 			a = Folder->GetPath();
 	}
 
 	return a;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 FolderDlg::FolderDlg(	LViewI *parent,
 						ScribeWnd *app,
 						int LimitToType,
 						ScribeFolder *Root,
 						const char *InitialSelect,
 						bool AllowCreate,
 						char *DefaultNewFolderName,
 						char *DialogMsg)
 {
 	d = new FolderDlgPriv(app, this, AllowCreate);
 	d->DefaultNewFolderName = DefaultNewFolderName;
 	d->LimitTo = LimitToType;
 	SetParent(parent);
 
 	if (LoadFromResource(IDD_FOLDER_SELECT))
 	{
 		MoveToCenter();
 
 		if (GetViewById(IDC_FOLDERS, d->View))
 		{
 			if (!Root)
 			{
 				LMailStore *Def = d->App->GetDefaultMailStore();
 				if (Def)
 				{
 					Root = Def->Root;
 					while (Root->GetPrev())
 					{
 						Root = dynamic_cast<ScribeFolder*>(Root->GetPrev());
 					}
 				}
 			}
 			
 			d->View->Setup(d, Root, InitialSelect);
 			d->View->SetImageList(d->App->GetIconImgList(), false);
 		}
 
 		LViewI *msg;
 		if (DialogMsg && GetViewById(IDC_FOLDER_MSG, msg))
 		{
 			msg->Name(DialogMsg);
 		}
 	}
 
 	SetCtrlEnabled(IDOK, false);
 	SetCtrlEnabled(IDC_NEW_FOLDER, false);
 }
 
 FolderDlg::~FolderDlg()
 {
 	DeleteObj(d);
 }
 
 char *FolderDlg::Get()
 {
 	return d->Path;
 }
 
 int FolderDlg::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_FOLDERS:
 		{
 			if (n.Type == LNotifyItemDoubleClick)
 			{
 				if (d->View)
 					d->Path = d->View->Get2();
 
 				EndModal(1);
 			}
 			break;
 		}
 		case IDC_NEW_FOLDER:
 		{
 			auto Cur = d->View->Get2();
 			if (!Cur)
 				break;
 
 			Store3ItemTypes Type[] = { MAGIC_MAIL, MAGIC_CONTACT, MAGIC_FILTER, MAGIC_CALENDAR, MAGIC_GROUP };
 			bool Enable[] = {true, true, true, true, true};
 			CreateSubFolderDlg Dlg(this, 0, Enable, d->DefaultNewFolderName);
 			ScribeFolder *f = d->App->GetFolder(Cur);
 			if (!f)
 				break;
 
 			ScribeFolder *Sub = f->GetSubFolder(Dlg.SubName);
 			if (!Sub)
-				Sub = f->CreateSubDirectory(Dlg.SubName, Type[Dlg.SubType]);
+				Sub = f->CreateSubFolder(Dlg.SubName, Type[Dlg.SubType]);
 			if (!Sub)
 				break;
 
 			LTreeItem *s = d->View->Selection();
 			if (!s)
 				break;
 
 			FolderLeaf *NewLeaf = new FolderLeaf(d, Sub);
 			s->Insert(NewLeaf);
 			NewLeaf->Select(true);
 			NewLeaf->ScrollTo();
 			break;
 		}
 		case IDC_FILTER:
 		{
 			LString n = Ctrl->Name();
 			if (d->Filter != n)
 			{
 				d->Filter = n;
 				d->OnFilter();
 			}
 			break;
 		}
 		case IDC_CLEAR:
 		{
 			d->Filter.Empty();
 			SetCtrlName(IDC_FILTER, NULL);
 			d->OnFilter();
 			break;
 		}
 		case IDOK:
 		{
 			if (d->View)
 				d->Path = d->View->Get2();
 
 			EndModal(1);
 			break;
 		}
 		case IDCANCEL:
 		{
 			EndModal(0);
 			break;
 		}
 	}
 
 	return 0;
 }
diff --git a/src/ScribeFolderTree.cpp b/src/ScribeFolderTree.cpp
--- a/src/ScribeFolderTree.cpp
+++ b/src/ScribeFolderTree.cpp
@@ -1,827 +1,827 @@
 /*
 **	FILE:			ScribeFolderTree.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			17/1/2000
 **	DESCRIPTION:	Scribe Folder Tree
 **
 **	Copyright (C) 2000-2002, Matthew Allen
 **		fret@memecode.com
 */
 
 // Includes
 #include "Scribe.h"
 #include "lgi/common/DropFiles.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/RtfHtml.h"
 #include "resdefs.h"
 #include "ScribeListAddr.h"
 #include "lgi/common/ProgressDlg.h"
 #if WINNATIVE
 #include "OutlookDropSupport.cpp"
 #endif
 #include "lgi/common/LgiRes.h"
 
 //////////////////////////////////////////////////////////////////////////////
 int FolderSorter(ScribeFolder *a, ScribeFolder *b, int d)
 {
 	auto A = a->GetName(true);
 	auto B = b->GetName(true);
 	return A && B ? _stricmp(A, B) : 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 MailTree::MailTree(ScribeWnd *app) : LTree(100, 0, 0, 100, 100, "")
 {
 	App = app;
 	LastHit = 0;
 	LastWasRoot = -1;
 
 	Sunken(false);
 }
 
 MailTree::~MailTree()
 {
 }
 
 void MailTree::OnCreate()
 {
 	SetWindow(this);	
 }
 
 ssize_t MailTree::Sizeof()
 {
 	LAssert(0);
 	return 0;
 }
 
 bool MailTree::Serialize(LFile &f, bool Write)
 {
 	bool Status = false;
 	LAssert(0);
 	return Status;
 }
 
 #ifdef _DEBUG
 const char *GetCompareHdrs(LDataI *Mail, LDataI *a)
 {
 	auto s = a->GetStr(FIELD_INTERNET_HEADER);
 	if (!s && Mail)
 		s = Mail->GetStr(FIELD_INTERNET_HEADER);
 	return s;
 }
 
 void CompareTrimWhite(LArray<char> &a)
 {
 	while (a.Length() > 0 && strchr(WhiteSpace, a[a.Length()-1]))
 		a.Length(a.Length()-1);
 
 	a.Add(0);
 }
 
 char *CompareChar(char a)
 {
 	static char buf[4][16];
 	static int next = 0;
 
 	char *b = buf[next++];
 	if (next >= 4) next = 0;
 	if (a < ' ' || ((uint8_t)a) >= 0x80)
 		sprintf_s(b, 16, "0x%2.2X", a);
 	else
 		sprintf_s(b, 16, "'%c'", a);
 	return b;
 }
 
 struct SegMap
 {
 	LDataI *a, *b;
 };
 
 bool CompareSegments(LDataI *MailA, LDataI *MailB, LDataI *a, LDataI *b, LStream &p)
 {
 	const char *s1, *s2;
 
 	// Check headers
 	s1 = GetCompareHdrs(MailA, a);
 	s2 = GetCompareHdrs(MailB, b);
 	if (s1 && s2 && strcmp(s1, s2))
 	{
 		p.Print("Seg.Headers(%p,%p),", a, b);
 		return false;
 	}
 	else if ((s1 != 0) ^ (s2 != 0))
 	{
 		p.Print("Seg.HeaderPtrs,");
 		return false;		
 	}
 
 	// Check data
 	LAutoStreamI da = a->GetStream(_FL);
 	LAutoStreamI db = b->GetStream(_FL);
 	if (da && db)
 	{
 		LAutoString TransferEncoding(s1?InetGetHeaderField(s1, "Content-Transfer-Encoding"):0);
 		bool IsText = true;
 		if (TransferEncoding && !_stricmp(TransferEncoding, "base64"))
 			IsText = false;
 
 		if (IsText)
 		{
 			// Text compare
 			LArray<char> bufa, bufb;
 			if (bufa.Length((uint32_t) da->GetSize()) &&
 				bufb.Length((uint32_t) db->GetSize()))
 			{
 				da->Read(&bufa[0], bufa.Length());
 				db->Read(&bufb[0], bufb.Length());
 				CompareTrimWhite(bufa);
 				CompareTrimWhite(bufb);
 				char *ta = &bufa[0], *tb = &bufb[0];
 				do
 				{
 					if (*ta != *tb)
 					{
 						p.Print("Seg.TextBody(%s != %s @ %i, %p, %p),", CompareChar(*ta), CompareChar(*tb), ta - &bufa[0], a, b);
 						return false;
 					}
 					ta++;
 					tb++;
 
 					if (*ta == '\r') ta++;
 					if (*tb == '\r') tb++;
 				}
 				while (*ta && *tb);
 			}
 			else
 			{
 				p.Print("Seg.TextMemAlloc(" LPrintfInt64 "," LPrintfInt64 "),", da->GetSize(), db->GetSize());
 				return false;
 			}
 		}
 		else
 		{
 			// Binary compare
 			if (da->GetSize() != db->GetSize())
 			{
 				p.Print("Seg.DataSize(" LPrintfInt64 "," LPrintfInt64 "),", da->GetSize(), db->GetSize());
 				return false;
 			}
 			else
 			{
 				char bufa[1024], bufb[1024];
 				for (int64 i=0; i<da->GetSize(); )
 				{
 					ssize_t ra = da->Read(bufa, sizeof(bufa));
 					ssize_t rb = db->Read(bufb, sizeof(bufb));
 					if (ra == rb)
 					{
 						if (memcmp(bufa, bufb, ra))
 						{
 							p.Print("Seg.DataCmp,");
 							return false;
 						}
 
 						i += ra;
 					}
 					else
 					{
 						p.Print("Seg.DataRead,");
 						return false;
 					}
 				}
 			}
 		}
 	}
 	else if ((da != 0) ^ (db != 0))
 	{
 		p.Print("Seg.Data(%p[%p,%I64i],%p[%p,%I64i]),",
 			a, da.Get(), da ? da->GetSize() : 0,
 			b, db.Get(), db ? db->GetSize() : 0);
 		return false;
 	}
 
 	LDataIt ac = a->GetList(FIELD_MIME_SEG);
 	LDataIt bc = b->GetList(FIELD_MIME_SEG);
 	if (ac && bc)
 	{
 		if (ac->Length() != bc->Length())
 		{
 			p.Print("Seg.ChildLength,");
 			return false;
 		}
 		else
 		{
 			LArray<SegMap> Map;
 			LDataI *Seg;
 			for (Seg = dynamic_cast<LDataI*>(ac->First());
 				Seg;
 				Seg = dynamic_cast<LDataI*>(ac->Next()))
 			{
 				Map.New().a = Seg;
 			}
 
 			for (Seg = dynamic_cast<LDataI*>(bc->First());
 				Seg;
 				Seg = dynamic_cast<LDataI*>(bc->Next()))
 			{
 				auto hdr_b = Seg->GetStr(FIELD_INTERNET_HEADER);
 				bool Matched = false;
 				for (unsigned i=0; i<Map.Length(); i++)
 				{
 					SegMap &m = Map[i];
 					if (m.b == 0)
 					{
 						// Compare on data size?
 						bool Close = false;
 						bool Exact = false;
 						LAutoStreamI da = m.a->GetStream(_FL);
 						LAutoStreamI db = Seg->GetStream(_FL);
 						if (da && db)
 						{
 							int64 size_a = da->GetSize();
 							int64 size_b = db->GetSize();
 							int64 diff = size_a - size_b;
 							if (diff < 0) diff = -diff;
 							if (diff == 0)
 								Exact = true;
 							else if (diff < 8)
 								Close = true;
 						}
 
 						// What about headers?
 						auto hdr_a = m.a->GetStr(FIELD_INTERNET_HEADER);
 						if (hdr_a && hdr_b)
 						{
 							if (_stricmp(hdr_a, hdr_b))
 							{
 								Close = false;
 								Exact = false;
 							}
 						}
 
 						if (Close || Exact)
 						{
 							// Match
 							m.b = Seg;
 							Matched = true;
 							break;
 						}
 					}
 				}
 
 				if (!Matched)
 				{
 					for (unsigned i=0; i<Map.Length(); i++)
 					{
 						SegMap &m = Map[i];
 						if (m.b == 0)
 						{
 							auto hdr_a = m.a->GetStr(FIELD_INTERNET_HEADER);
 							if (hdr_a && hdr_b)
 							{
 								if (!_stricmp(hdr_a, hdr_b))
 								{
 									// Match
 									m.b = Seg;
 									break;
 								}
 							}
 						}
 					}
 				}
 			}
 
 			unsigned i;
 			for (i=0; i<Map.Length(); i++)
 			{
 				SegMap &m = Map[i];
 				p.Print("Map[%i] = %p - %p\r\n", i, m.a, m.b);
 			}
 
 			for (i=0; i<Map.Length(); i++)
 			{
 				SegMap &m = Map[i];
 				if (m.a && m.b)
 				{
 					if (!CompareSegments(0, 0, m.a, m.b, p))
 						return false;
 				}
 			}
 		}
 	}
 	else if ((ac != 0) ^ (bc != 0))
 	{
 		p.Print("Seg.Children,");
 		return false;
 	}
 
 	return true;
 }
 
 void CompareDumpSegs(LStream &p, LDataI *mail, LDataI *s, int depth = 0)
 {
 	char sp[256];
 	int i = depth * 3;
 	memset(sp, ' ', i);
 	sp[i] = 0;
 
 	auto hdr = GetCompareHdrs(mail, s);
 	LAutoString ContentType(hdr ? InetGetHeaderField(hdr, "Content-Type") : 0);
 	if (ContentType)
 	{
 		char *Colon = strchr(ContentType, ';');
 		if (Colon) *Colon = 0;
 	}
 	LAutoStreamI Data = s->GetStream(_FL);
 	p.Print("%s%p - %s (%I64i)\r\n", sp, s, ContentType.Get(), Data?Data->GetSize():-1);
 
 	LDataIt c = s->GetList(FIELD_MIME_SEG);
 	if (c)
 	{
 		for (LDataI *a = dynamic_cast<LDataI*>(c->First()); a; a = dynamic_cast<LDataI*>(c->Next()))
 		{
 			CompareDumpSegs(p, 0, a, depth+1);
 		}
 	}
 
 	if (mail)
 		p.Print("\r\n");
 }
 #endif
 
 void MailTree::OnItemClick(LTreeItem *Item, LMouse &m)
 {
 	if (m.Down() && m.IsContextMenu())
 	{
 		Select(Item);
 
 		ScribeFolder *t = dynamic_cast<ScribeFolder*>(Item);
 		if (t)
 			t->DoContextMenu(m);
 	}
 }
 
 void MailTree::OnItemSelect(LTreeItem *Item)
 {
 	if (LastWasRoot ^ (int8)Item->IsRoot())
 	{
 		if (Item->IsRoot())
 		{
 		    if (App->GetItemList())
 		        App->GetItemList()->RemoveAll();
 			App->SetListPane(new DynamicHtml(App, "title.html"));
 		}
 		else
 		{
 			App->SetListPane(new ThingList(App));
 		}
 	}
 
 	if (Things() && !Item->IsRoot())
 	{
 		ScribeFolder *C = dynamic_cast<ScribeFolder*>(Item);
 		if (C)
 		{
 			C->Populate(Things());
 			App->SetCtrlValue(IDM_THREAD, C->GetThreaded());
 			App->OnFolderSelect(C);
 		}
 	}
 	else
 	{
 		App->SetCtrlValue(IDM_THREAD, false);
 	}
 
 	LastWasRoot = Item ? Item->IsRoot() : false;
 }
 
 void MailTree::OnCreateSubDirectory(ScribeFolder *Item)
 {
 	// setup type list...
 	Store3ItemTypes Type[] = { MAGIC_MAIL, MAGIC_CONTACT, MAGIC_FILTER, MAGIC_CALENDAR, MAGIC_GROUP };
 	int i=0;
 	for (int n=0; n<CountOf(Type); n++)
 	{
 		if (Type[n] == Item->GetItemType())
 		{
 			i = n;
 			break;
 		}
 	}
 
 	// do ui..
 	bool Enable[] =
 	{
 		Item->CanHaveSubFolders(MAGIC_MAIL),
 		Item->CanHaveSubFolders(MAGIC_CONTACT),
 		Item->CanHaveSubFolders(MAGIC_FILTER),
 		Item->CanHaveSubFolders(MAGIC_CALENDAR),
 		Item->CanHaveSubFolders(MAGIC_GROUP)
 	};
 	
 	auto Dlg = new CreateSubFolderDlg(this, i, Enable);
 	Dlg->DoModal([this, Dlg, Item, Type](auto dlg, auto code)
 	{
 		if (code &&
 			ValidStr(Dlg->SubName) &&
 			Dlg->SubType >= 0)
 		{
 			// check the name doesn't conflict..
 			auto Path = Item->GetPath();
 			if (Path)
 			{
 				LString s;
 				s.Printf("%s/%s", Path.Get(), Dlg->SubName.Get());
 				if (App->GetFolder(s))
 				{
 					LgiMsg(this, LLoadString(IDS_SUBFLD_NAME_CLASH), AppName, MB_OK);
 					Dlg->SubName.Empty();
 				}
 			}
 
 			if (Dlg->SubName)
 			{
 				// insert the folder...
-				Item->CreateSubDirectory(Dlg->SubName, Type[Dlg->SubType]);
+				Item->CreateSubFolder(Dlg->SubName, Type[Dlg->SubType]);
 			}
 		}
 
 		delete dlg;
 	});
 }
 
 void MailTree::OnDelete(ScribeFolder *Item, bool Force)
 {
 	if (Item)
 	{
 		int FolderType = App->GetFolderType(Item);
 		if (!Force && FolderType >= 0)
 		{
 			char Msg[256];
 			sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_DELETE_SYS_FOLDER), DefaultFolderNames[FolderType]);
 			LgiMsg(this, Msg, AppName, MB_OK);
 		}
 		else
 		{
 			Item->OnDelete();
 		}
 	}
 }
 
 void MailTree::OnProperties(ScribeFolder *Item)
 {
 	if (Item)
 	{
 		Item->OnProperties();
 	}
 }
 
 LMessage::Result MailTree::OnEvent(LMessage *Msg)
 {
 	return LTree::OnEvent(Msg);
 }
 
 extern char ScribeFolderObject[];
 
 int MailTree::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	int Status = DROPEFFECT_NONE;
 
 	LastHit = ItemAtPoint(Pt.x, Pt.y);
 	
 	if (LastHit)
 	{
 		List<char> Accepted;
 
 		Formats.Supports(ScribeThingList);
 		Formats.Supports(ScribeFolderObject);
 		Formats.SupportsFileDrops();
 		#if WINNATIVE
 		Formats.Supports(CFSTR_FILEDESCRIPTOR);
 		#endif
 		#ifdef MAC
 		Formats.Supports(LGI_StreamDropFormat);
 		#endif
 
 		if (Formats.GetSupported().Length())
 		{
 			SelectDropTarget(LastHit);
 			Status = KeyState & LGI_EF_CTRL ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
 		}
 	}
 
 	return Status;
 }
 
 static int FolderItemCmp(LTreeItem *a, LTreeItem *b, NativeInt UserData)
 {
 	ScribeFolder *ta = dynamic_cast<ScribeFolder*>(a);
 	ScribeFolder *tb = dynamic_cast<ScribeFolder*>(b);
 	if (ta && tb)
 	{
 		int64 IndexA = ta->GetObject()->GetInt(FIELD_FOLDER_INDEX);
 		int64 IndexB = tb->GetObject()->GetInt(FIELD_FOLDER_INDEX);
 		return (int)IndexA - (int)IndexB;
 	}
 	
 	return 0;
 }
 
 int MailTree::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	int Status = DROPEFFECT_NONE;
 	ScribeFolder *Leaf = dynamic_cast<ScribeFolder*>(LastHit);
 	#if WINNATIVE
 	LString FileDescFmt = CFSTR_FILEDESCRIPTOR;
 	#endif
 
 	SelectDropTarget(0);
 	if (App)
 		App->SetLastDrop();
 
 	for (unsigned idx=0; idx<Data.Length() && Leaf!=NULL; idx++)
 	{
 		LDragData &dd = Data[idx];
 		bool ThingDrop = dd.IsFormat(ScribeThingList);
 		bool FolderDrop = dd.IsFormat(ScribeFolderObject);
 		if (ThingDrop || FolderDrop)
 		{
 			if (dd.Data.Length() == 0 ||
 				dd.Data[0].Type != GV_BINARY)
 			{
 				continue;
 			}
 
 			ssize_t Errors = 0, Count = 0;
 			LVariant &v = dd.Data.First();
 
 			if (ScribeClipboardFmt::IsFolder(v.Value.Binary.Data, v.Value.Binary.Length))
 			{
 				ScribeClipboardFmt *Fmt = (ScribeClipboardFmt*) v.Value.Binary.Data;
 				Count = Fmt->Length();
 
 				ScribeFolder *Root = dynamic_cast<ScribeFolder*>(ItemAt(0));
 
 				for (ssize_t i=0; i<Fmt->Length(); i++)
 				{
 					ScribeFolder *Folder = Fmt->FolderAt(i);
 					if (Folder)
 					{
 						if (Folder == Leaf ||
 							Folder == Root ||
 							Leaf->GetItemType() == MAGIC_ANY)
 						{
 							// they're dragging onto themselves or
 							// dragging the whole mail tree around or
 							// dragging a folder into the trash
 							// just quit out now...
 							return DROPEFFECT_NONE;
 						}
 
 						bool CopyOp = (KeyState & LGI_EF_CTRL) != 0;
 
 						auto FinishFolderOp = [this, Folder, Leaf, CopyOp](int Res)
 						{
 							int SystemFolder = App->GetFolderType(Folder);
 							auto OldPath = Folder->GetPath();
 							Store3Status Status = Store3Error;
 							ScribeFolder *OldParent = Folder->GetFolder();
 							ScribeFolder *NewParent = NULL;
 							int Index = 0;
 
 							if (Res == 1)
 							{
 								// Attach next
 								NewParent = Leaf->GetFolder();
 								if (NewParent)
 								{
 									// Work out the index
 									for (LTreeItem *Item = NewParent->GetChild(); Item && Item!=Leaf; Item=Item->GetNext())
 									{
 										Index++;
 									}
 									Index++;
 								}
 							}
 							else if (Res == 2)
 							{
 								// Attach child
 								NewParent = Leaf;
 							}
 							else return;
 
 							if (SystemFolder >= 0 &&
 								NewParent->GetObject()->GetStore() != OldParent->GetObject()->GetStore())
 							{
 								LgiMsg(App, "Can't move system folders to a different mail store.", AppName, MB_OK);
 								return;
 							}
 
 							if (CopyOp)
 							{
 								// Copy
 								Status = Folder->CopyTo(NewParent, Index);
 							}
 							else
 							{
 								LDataFolderI *fo = Folder->GetFldObj();
 								if (NewParent == OldParent)
 								{
 									// Re-index only...
 									// int64 OldIndex = fo->GetInt(FIELD_FOLDER_INDEX);
 									if (fo->SetInt(FIELD_FOLDER_INDEX, Index))
 									{
 										// Change the UI to match...
 										NewParent->Sort(FolderItemCmp);
 										Status = Store3Success;
 									}
 								}
 								else
 								{
 									// Move
 									Status = Folder->SetFolder(NewParent, Index);
 									if (Status)
 									{
 										NewParent->Sort(FolderItemCmp);
 									}
 								}
 							}
 								
 							if (Status == Store3Success &&
 								SystemFolder >= 0 &&
 								!CopyOp)
 							{
 								// Update the system path location if it's changed...
 								auto NewPath = Folder->GetPath();
 								if (OldPath &&
 									NewPath &&
 									strcmp(OldPath, NewPath) != 0)
 								{
 									LVariant v;
 									v = NewPath;
 									LString SysFolderName;
 									SysFolderName.Printf("Folder-%i", SystemFolder);
 									App->GetOptions()->SetValue(SysFolderName, v);
 								}
 							}
 						};
 
 						int Res = 2;
 						if (Leaf->GetFolder() != NULL)
 						{
 							auto Dlg = new LAlert(	this,
 													LLoadString(CopyOp ? IDS_COPY_FOLDER : IDS_MOVE_FOLDER),
 													LLoadString(IDS_MOVE_ATTACH),
 													LLoadString(IDS_NEXT_FOLDER),
 													LLoadString(IDS_SUB_FOLDER),
 													LLoadString(IDS_CANCEL));
 							Dlg->DoModal([this, Dlg, FinishFolderOp](auto dlg, auto Res)
 							{
 								if (Res > 0)
 									FinishFolderOp(Res);
 								delete dlg;
 							});
 						}
 						else FinishFolderOp(Res);
 					}
 				}
 			}
 			else if (ScribeClipboardFmt::IsThing(v.Value.Binary.Data, v.Value.Binary.Length))
 			{
 				ScribeClipboardFmt *Fmt = (ScribeClipboardFmt*) v.Value.Binary.Data;
 				LDataStoreI::StoreTrans Trans = Leaf->GetObject()->GetStore()->StartTransaction();
 				bool CopyOnly = (KeyState & LGI_EF_CTRL) != 0;
 				Count = Fmt->Length();
 
 				LArray<Thing*> Items;
 				for (ssize_t i=0; i<Count; i++)
 				{
 					Thing *Thg = Fmt->ThingAt(i);
 					if (Thg)
 						Items.Add(Thg);
 				}
 
 				if (Items.Length())
 				{
 					LArray<Store3Status> ItemStatus;
 					Leaf->MoveTo(Items, CopyOnly, NULL);
 					// Fixme: Impl MoveTo Callback
 					for (auto s: ItemStatus)
 						if (s == Store3Error)
 							Errors++;
 				}
 			}
 			else LAssert(!"Unknown drop format.");
 
 			App->Update();
 
 			if (Errors)
 			{
 				LgiMsg(this, LLoadString(IDS_MOVE_ERROR), AppName, MB_OK, Errors, Count);
 			}
 			else
 			{
 				Status = DROPEFFECT_COPY;
 			}
 			
 			// We don't need to process any other data types... we're done.
 			break;
 		}
 		else if (dd.IsFileDrop())
 		{
 			if (dd.Data.Length() > 0)
 			{
 				LDropFiles Files(dd.Data[0]);
 				Leaf->OnReceiveFiles(Files);
 				Status = DROPEFFECT_COPY;
 			}
 		}
 		#if WINNATIVE
 		else if (_stricmp(dd.Format, FileDescFmt) == 0)
 		{
 			if (dd.Data.Length() == 0 ||
 				dd.Data[0].Type != GV_BINARY)
 				continue;
 			
 			// Get file list...
 			LString::Array Files;
 			FILEGROUPDESCRIPTOR *FileGroup = (FILEGROUPDESCRIPTOR*) dd.Data[0].Value.Binary.Data;
 
 			if (OnDropFileGroupDescriptor(FileGroup, Files))
 			{
 				// Process dropped files
 				LArray<const char*> FileLst;
 				for (auto &f : Files)
 					FileLst.Add(f.Get());
 				Leaf->OnReceiveFiles(FileLst);
 
 				// Clean up
 				for (auto f : Files)
 				{
 					FileDev->Delete(f, false);
 				}
 			}
 			else if (DataObject)
 			{
 				for (int i=0; true; i++)
 				{
 					FORMATETC Format;
 					Format.cfFormat = RegisterClipboardFormat(CFSTR_FILECONTENTS);
 					Format.dwAspect = DVASPECT_CONTENT;
 					Format.lindex = i;
 					Format.tymed = TYMED_ISTORAGE;
 					Format.ptd = 0;
 
 					STGMEDIUM Medium;
 					ZeroObj(Medium);
 
 					HRESULT res = DataObject->GetData(&Format, &Medium);
 					if (SUCCEEDED(res))
 					{
 						if (Medium.tymed == TYMED_ISTORAGE)
 						{
 							OutlookIStorage Dec(App, Medium.pstg, false);
 
 							int Type = Dec.GetType();
 							if (Type == Leaf->GetItemType())
 							{
 								switch (Type)
 								{
 									case MAGIC_MAIL:
 									{
 										Mail *m = Dec.GetMail();
 										if (m)
 										{
 											m->App = App;
 											m->Save(Leaf);
 											Status = DROPEFFECT_COPY;
 										}
 										break;
 									}
 									case MAGIC_CONTACT:
 									{
 										Contact *c = Dec.GetContact();
 										if (c)
 										{
 											c->App = App;
 											c->Save(Leaf);
 											Status = DROPEFFECT_COPY;
 										}
 										break;
 									}
 								}
 							}
 						}
 
 						ReleaseStgMedium(&Medium);
 					}
 					else break;
 				}
 			}
 		}
 		#endif
 	}
 
 	return Status;
 }
 
diff --git a/src/ScribeMail.cpp b/src/ScribeMail.cpp
--- a/src/ScribeMail.cpp
+++ b/src/ScribeMail.cpp
@@ -1,10317 +1,10317 @@
 /*
 **	FILE:			ScribeMail.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			11/11/98
 **	DESCRIPTION:	Scribe Mail Object and UI
 **
 **	Copyright (C) 1998-2003, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/timeb.h>
 #include <math.h>
 
 #include "Scribe.h"
 #include "ScribePageSetup.h"
 #include "lgi/common/Popup.h"
 #include "lgi/common/ColourSelect.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/Html.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/ThreadEvent.h"
 #include "lgi/common/GdcTools.h"
 #include "lgi/common/Charset.h"
 
 #include "../src/common/Coding/ScriptingPriv.h"
 #include "PrintPreview.h"
 #include "ScribeListAddr.h"
 #include "PrintContext.h"
 #include "lgi/common/LgiRes.h"
 #include "Encryption/GnuPG.h"
 #include "ObjectInspector.h"
 #include "lgi/common/EventTargetThread.h"
 #include "Store3Common.h"
 #include "Tables.h"
 #include "Calendar.h"
 #include "CalendarView.h"
 #include "AddressSelect.h"
 #include "Store3Imap/ScribeImap.h"
 #include "lgi/common/TextConvert.h"
 #include "lgi/common/FileSelect.h"
 
 #include "resdefs.h"
 #include "resource.h"
 #include "lgi/common/Printer.h"
 #include "lgi/common/SubProcess.h"
 
 #define SAVE_HEADERS					0
 
 static char MsgIdEncodeChars[] = "%/";
 static char ScribeReplyClass[] = "scribe_reply";
 static char ScribeReplyStyles[] =	"margin-left: 0.5em;\n"
 									"padding-left: 0.5em;\n"
 									"border-left: 1px solid #ccc;";
 
 char DefaultTextReplyTemplate[] =
 {
 	"---------- Original Message ----------\n"
 	"To: <mail.to[0].name> &lt;<mail.to[0].email>&gt;\n"
 	"From: <mail.from.name> &lt;<mail.from.email>&gt;\n"
 	"Subject: <mail.subject>\n"
 	"Date: <mail.datesent>\n"
 	"\n"
 	"<mail.bodyastext quote=scribe.quote>\n"
 	"<cursor>\n"
 	"<mail.sig>\n"
 };
 
 char DefaultHtmlReplyTemplate[] =
 {
 	"<html>\n"
 	"<head>\n"
 	"<style>\n"
 	"	.Style1 {\n"
 	"		color: #919191;\n"
 	"	}\n"
 	"	.Style2 {\n"
 	"		font-weight: bold;\n"
 	"	}\n"
 	"	.Style3 {\n"
 	"		color: #ae0000;\n"
 	"	}\n"
 	"	</style>\n"
 	"</head>\n"
 	"<body>\n"
 	"	<p><span class='Style1'>---------- Original Message ----------</span><br>\n"
 	"	<b>To:</b> &lt;?mail.tohtml?&gt;<br>\n"
 	"	<b>From:</b> &lt;?mail.fromhtml?&gt;<br>\n"
 	"	<b>Subject:</b> &lt;?mail.subject?&gt;<br>\n"
 	"	<b>Date:</b> &lt;?mail.datesent?&gt;<br>\n"
 	"	<br>\n"
 	"	<span class='Style3'>&lt;?mail.bodyastext quote=scribe.quote?&gt;</span><br>\n"
 	"	&lt;?cursor?&gt;<br>\n"
 	"	&lt;?mail.sig[html]?&gt;</p>\n"
 	"</body>\n"
 	"</html>\n"
 };
 
 class DepthCheck
 {
 	int &i;
 
 public:
 	constexpr static int MaxDepth = 5;
 
 	DepthCheck(int &val) : i(val)
 	{
 		i++;
 		if (!*this)
 			LAssert(!"Recursion?");
 	}
 
 	~DepthCheck()
 	{
 		i--;
 	}
 
 	operator bool() const
 	{
 		return i < MaxDepth;
 	}
 };
 
 void CollectAttachments(LArray<LDataI*> *Attachments,
 						LArray<LDataI*> *Related,
 						LDataI **Text,
 						LDataI **Html,
 						LDataPropI *d,
 						Store3MimeType *ParentMime = NULL)
 {
 	if (!d)
 		return;
 
 	Store3MimeType Mt(d->GetStr(FIELD_MIME_TYPE));
 	auto FileName = d->GetStr(FIELD_NAME);
 	if (!Mt)
 		Mt = "text/plain";
 	
 	// printf("Collect %s %s\n", (char*)Mt, FileName);
 	
 	auto Att = dynamic_cast<LDataI*>(d);
 	if (ParentMime && Att && ParentMime->IsRelated() && Related)
 	{
 		auto Id = d->GetStr(FIELD_CONTENT_ID);
 		if (ValidStr(Id))
 		{
 			if (Related)
 				Related->Add(Att);
 			Att = NULL;
 		}
 		else if (Mt.IsHtml() && Html)
 		{
 			*Html = Att;
 			Att = NULL;
 		}
 	}
 
 	if (Att)
 	{
 		if (ValidStr(FileName))
 		{
 			if (Attachments)
 				Attachments->Add(Att);
 		}
 		else if (Mt.IsHtml())
 		{
 			if (Html)
 				*Html = Att;
 		}
 		else if (Mt.IsPlainText())
 		{
 			if (Text)
 				*Text = Att;
 		}
 		else if (!Mt.IsMultipart())
 		{
 			if (Attachments)
 				Attachments->Add(Att);
 		}
 
 		/*
 		if (d->GetInt(FIELD_SIZE) < (512 << 10))
 			a.Add(dynamic_cast<LDataI*>(d));
 		*/
 	}
 
 	auto It = d->GetList(FIELD_MIME_SEG);
 	if (It)
 	{
 		for (auto i = It->First(); i; i = It->Next())
 			CollectAttachments(Attachments, Related, Text, Html, i, Mt.IsMultipart() ? &Mt : NULL);
 	}
 }
 
 void RemoveReturns(char *s)
 {
 	// Delete out the '\r' chars.
 	char *In = s;
 	char *Out = s;
 	while (*In)
 	{
 		if (*In != '\r')
 		{
 			*Out++ = *In;
 		}
 		In++;
 	}
 	*Out++ = 0;
 }
 
 class XmlSaveStyles : public LXmlTree
 {
 	void OnParseComment(LXmlTag *Ref, const char *Comment, ssize_t Bytes)
 	{
 		if (Ref && Ref->IsTag("style"))
 		{
 			Ref->SetContent(Comment, Bytes);
 		}
 	}
 
 public:
 	XmlSaveStyles(int flags) : LXmlTree(flags)
 	{
 	}
 };
 
 bool ExtractHtmlContent(LString &OutHtml,
 						LString &Charset,
 						LString &Styles,
 						const char *InHtml)
 {
 	if (!InHtml)
 		return false;
 
 	XmlSaveStyles t(GXT_NO_ENTITIES | GXT_NO_DOM | GXT_NO_HEADER);
 	LXmlTag r;
 	LMemStream mem(InHtml, strlen(InHtml), false);
 	if (!t.Read(&r, &mem))
 		return false;
 	bool InHead = false;
 	LStringPipe Style;
 
 	r.Children.SetFixedLength(false);
 	for (auto It = r.Children.begin(); It != r.Children.end(); )
 	{
 		LXmlTag *c = *It;
 
 		if (c->IsTag("style"))
 		{
 			if (ValidStr(c->GetContent()))
 				Style.Print("%s\n", c->GetContent());
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("/head"))
 		{
 			InHead = false;
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("body"))
 		{
 			// We remove this tag, but KEEP the content... if any
 			if (ValidStr(c->GetContent()))
 			{
 				c->SetTag(NULL);
 				It++;
 			}
 			else
 			{
 				// No content, remove entirely.
 				c->Parent = NULL;
 				r.Children.Delete(It);
 				DeleteObj(c);
 			}
 		}
 		else if (InHead || 
 				c->IsTag("html") ||
 				c->IsTag("/html") ||
 				c->IsTag("/body") ||
 				c->IsTag("/style"))
 		{
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("head"))
 		{
 			InHead = true;
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else
 			It++;
 	}
 
 	LStringPipe p;
 	t.Write(&r, &p);
 	OutHtml = p.NewLStr();
 	Styles = Style.NewLStr();
 
 	#if 0
 	LgiTrace("InHtml=%s\n", InHtml);
 	LgiTrace("OutHtml=%s\n", OutHtml.Get());
 	LgiTrace("Styles=%s\n", Styles.Get());
 	#endif
 	
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 char MailToStr[] = "mailto:";
 char SubjectStr[] = "subject=";
 char ContentTypeDefault[] = "Content-type: text/plain; charset=us-ascii";
 
 extern LString HtmlToText(const char *Html, const char *InitialCharSet);
 extern LString TextToHtml(const char *Txt, const char *Charset);
 
 class ImageResizeThread : public LEventTargetThread
 {
 	LOptionsFile *Opts;
 
 public:
 	class Job
 	{
 		#ifdef __GTK_H__
 		/* This object may not exist when the worker is finished.
 			However LAppInst->PostEvent can handle that so we'll allow
 			it, so long as it's never used in the Sink->PostEvent form.	*/
 		LViewI *Sink;
 		#else
 		OsView Sink;
 		#endif
 
 	public:
 		LString FileName;
 		LAutoStreamI Data;
 
 		void SetSink(LViewI *v)
 		{
 			#if !LGI_VIEW_HANDLE
 			Sink = v;
 			#else
 			Sink = v->Handle();
 			#endif
 		}
 
 		bool PostEvent(int Msg, LMessage::Param a = 0, LMessage::Param b = 0)
 		{
 			#ifdef __GTK_H__
 			return LAppInst->PostEvent(Sink, Msg, a, b);
 			#else
 			return LPostEvent(Sink, Msg, a, b);
 			#endif
 		}
 	};
 
 	ImageResizeThread(LOptionsFile *opts) : LEventTargetThread("ImageResize")
 	{
 		Opts = opts;
 	}
 
 	void Resize(LAutoPtr<ImageResizeThread::Job> &Job)
 	{
 		LVariant Qual = 80, Px = 1024, SizeLimit = 200, v;
 		Opts->GetValue(OPT_ResizeJpegQual, Qual);
 		Opts->GetValue(OPT_ResizeMaxPx, Px);
 		Opts->GetValue(OPT_ResizeMaxKb, SizeLimit);
 
 		LAutoStreamI Input = Job->Data;
 		LAutoStreamI MemBuf(new LMemFile(4 << 10));
 		int64 FileSize = Input->GetSize();
 
 		LStream *sImg = dynamic_cast<LStream*>(Input.Get());
 		LAutoPtr<LSurface> Img(GdcD->Load(sImg, Job->FileName));
 		if (Img)
 		{
 			int iPx = Px.CastInt32();
 			int iKb = SizeLimit.CastInt32();
 			
 			if (Img->X() > iPx ||
 				Img->Y() > iPx ||
 				FileSize >= iKb << 10)
 			{
 				// Create a JPEG filter
 				auto Jpeg = LFilterFactory::New(".jpg", FILTER_CAP_WRITE, NULL);
 				if (Jpeg)
 				{
 					// Re-sample the image...
 					double XScale = (double) Img->X() / iPx;
 					double YScale = (double) Img->Y() / iPx;
 					// double Aspect = (double) Img->X() / Img->Y();
 					double Scale = XScale > YScale ? XScale : YScale;
 					if (Scale > 1.0)
 					{
 						int Nx = (int)(Img->X() / Scale + 0.001);
 						int Ny = (int)(Img->Y() / Scale + 0.001);
 						
 						LAutoPtr<LSurface> ResizedImg(new LMemDC(Nx, Ny, Img->GetColourSpace()));
 						if (ResizedImg)
 						{
 							if (ResampleDC(ResizedImg, Img))
 							{
 								Img = ResizedImg;
 							}
 						}
 					}
 																
 					// Compress the image..
 					LXmlTag Props;
 					Props.SetValue(LGI_FILTER_QUALITY, Qual);
 					Props.SetValue(LGI_FILTER_SUBSAMPLE, v = 1); // 2x2
 					Jpeg->Props = &Props;
 					if (Jpeg->WriteImage(dynamic_cast<LStream*>(MemBuf.Get()), Img) == LFilter::IoSuccess)
 					{
 						Job->Data = MemBuf;
 					}
 				}
 			}
 		}
 		
 		Job->PostEvent(M_RESIZE_IMAGE, (LMessage::Param)Job.Get());
 		Job.Release(); // Do this after the post event... so the deref doesn't crash.
 	}
 	
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		switch (Msg->Msg())
 		{
 			case M_RESIZE_IMAGE:
 			{
 				LAutoPtr<Job> j((Job*)Msg->A());
 				if (j)
 					Resize(j);
 				break;
 			}
 		}
 		
 		return 0;
 	}	
 };
 
 #include "lgi/common/RichTextEdit.h"
 #include "../src/common/Widgets/Editor/RichTextEditPriv.h"
 
 class MailRendererScript : public LThread, public LCancel, public LDom
 {
 	Mail *m;
 	LScriptCallback *cb;
 
 public:
 	MailRendererScript(Mail *ml, LScriptCallback *script) : m(ml), cb(script), LThread("MailRendererScript")
 	{
 		Run();
 	}
 
 	~MailRendererScript()
 	{
 		Cancel(true);
 		while (!IsExited())
 			LSleep(1);
 	}
 
 	int Main()
 	{
 		LVirtualMachine Vm;				
 		LScriptArguments Args(&Vm);
 		Args.New() = new LVariant(m->App);
 		Args.New() = new LVariant(m);
 		Args.New() = new LVariant((LDom*)this);
 		m->App->ExecuteScriptCallback(*cb, Args);
 		Args.DeleteObjects();
 		return 0;
 	}
 
 	bool CallMethod(const char *MethodName, LVariant *Ret, LArray<LVariant*> &Args)
 	{
 		ScribeDomType Method = StrToDom(MethodName);
 
 		*Ret = false;
 		switch (Method)
 		{		
 			case SdGetTemp:
 			{
 				*Ret = ScribeTempPath();
 				break;
 			}
 			case SdExecute:
 			{
 				*Ret = false;
 				if (Args.Length() >= 3)
 				{
 					auto Dir = Args[0]->Str();
 					auto Exe = Args[1]->Str();
 					auto Arg = Args[2]->Str();
 					if (Dir && Exe && Arg)
 					{
 						LSubProcess p(Exe, Arg);
 						p.SetInitFolder(Dir);
 						if (p.Start())
 						{
 							char Buf[256];
 							LStringPipe Out;
 							Out.Print("%s %s\n", Exe, Arg);
 
 							ssize_t Rd;
 							while (p.IsRunning() && !IsCancelled())
 							{
 								Rd = p.Read(Buf, sizeof(Buf));
 								if (Rd < 0)
 									break;
 								if (Rd == 0)
 									LSleep(1);
 								else
 									Out.Write(Buf, Rd);
 							}
 
 							while (!IsCancelled() && (Rd = p.Read(Buf, sizeof(Buf))) > 0)
 								Out.Write(Buf, Rd);
 
 							// LgiTrace("%s:%i - Process:\n%s\n", _FL, Out.NewLStr().Get());
 							if (p.IsRunning())
 								p.Kill();
 							else
 								*Ret = true;
 						}
 					}
 				}
 				break;
 			}
 			case SdSetHtml:
 			{
 				if (!IsCancelled() && Args.Length() > 0)
 				{
 					LView *Ui = m->GetUI();
 					if (!Ui)
 					{
 						// Maybe hasn't finished opening the UI?
 						LSleep(100);
 						Ui = m->GetUI();
 					}
 					if (!Ui)
 						Ui = m->App;
 					if (Ui)
 						Ui->PostEvent(M_SET_HTML, (LMessage::Param)new LString(Args[0]->Str()));
 				}
 				break;
 			}
 			default:
 				LAssert(!"Unsupported call.");
 				return false;
 		}
 
 		return true;
 	}
 };
 
 class MailPrivate
 {
 	LAutoPtr<ImageResizeThread> Resizer;
 	Mail *m;
 
 public:
 	struct HtmlBody
 	{
 		LString Html, Charset, Styles;
 	};
 	LAutoPtr<HtmlBody> Body;
 	LAutoPtr<MailRendererScript> Renderer;
 	LString MsgIdCache;
 	LString DomainCache;
 	int InSetFlags = 0;
 	int InSetFlagsCache = 0;
 	
 	MailPrivate(Mail *mail)
 	{
 		m = mail;
 	}
 	
 	void OnSave()
 	{
 		Resizer.Reset();
 	}
 
 	HtmlBody *GetBody()
 	{
 		if (!Body && !Body.Reset(new HtmlBody))
 			return NULL;
 		
 		if (ValidStr(m->GetHtml()))
 		{
 			ExtractHtmlContent(	Body->Html,
 								Body->Charset,
 								Body->Styles,
 								m->GetHtml());
 		}
 		else if (ValidStr(m->GetBody()))
 		{
 		    Body->Charset = m->GetCharSet();
 			Body->Html = TextToHtml(m->GetBody(), Body->Charset);
 		}
 		
 		return Body;
 	}
 
 	bool AddResizeImage(Attachment *File)
 	{
 		if (!File || !m->GetUI())
 			return false;
 		
 		if (!Resizer)
 			Resizer.Reset(new ImageResizeThread(m->App->GetOptions()));
 		
 		if (!Resizer)
 			return false;
 
 		LAutoStreamI Obj = File->GetObject()->GetStream(_FL);
 		if (!Obj)
 			return false;
 
 		ImageResizeThread::Job *j = new ImageResizeThread::Job;
 		if (!j)
 			return false;
 
 		// The user interface will handle the response...				
 		j->SetSink(m->GetUI());
 		j->FileName = File->GetName();					
 
 		// Make a complete copy of the stream...
 		j->Data.Reset(new LMemStream(Obj, 0, -1));
 	
 		// Post the work over to the thread...
 		Resizer->PostEvent(M_RESIZE_IMAGE, (LMessage::Param)j);
 
 		// Mark the image resizing						
 		File->SetIsResizing(true);
 		
 		return true;
 	}	
 };
 
 bool Mail::ResizeImage(Attachment *a)
 {
 	return d->AddResizeImage(a);
 }
 
 AttachmentList::AttachmentList(int id, int x, int y, int cx, int cy, MailUi *ui)
 	: LList(id, x, y, cx, cy, 0)
 {
 	Ui = ui;
 }
 
 AttachmentList::~AttachmentList()
 {
 	RemoveAll();
 }
 
 void AttachmentList::OnItemClick(LListItem *Item, LMouse &m)
 {
 	LList::OnItemClick(Item, m);
 
 	if (!Item &&
 		m.IsContextMenu() &&
 		Ui)
 	{
 		LSubMenu RClick;
 		RClick.AppendItem(LLoadString(IDS_ATTACH_FILE), IDM_OPEN, true);
 		switch (RClick.Float(this, m))
 		{
 			case IDM_OPEN:
 			{
 				Ui->PostEvent(M_COMMAND, IDM_ATTACH_FILE, 0);
 				break;
 			}
 		}
 	}
 }
 
 bool AttachmentList::OnKey(LKey &k)
 {
 	if (k.vkey == LK_DELETE)
 	{
 		if (k.Down())
 		{
 			List<LListItem> s;
 			if (GetSelection(s))
 			{
 				Attachment *a = dynamic_cast<Attachment*>(s[0]);
 				if (a)
 				{
 					a->OnDeleteAttachment(this, true);
 				}
 			}
 		}
 		
 		return true;
 	}
 	
 	return LList::OnKey(k);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 int Strnlen(const char *s, int n)
 {
 	int i = 0;
 	if (s)
 	{
 		if (n < 0)
 		{
 			while (*s++)
 			{
 				i++;
 			}
 		}
 		else
 		{
 			while (*s++ && n-- > 0)
 			{
 				i++;
 			}
 		}
 	}
 
 	return i;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 MailContainer::~MailContainer()
 {
 	MailContainerIter *i;
 	while ((i = Iters[0]))
 	{
 		Iters.Delete(i);
 		if (i->Container)
 		{
 			i->Container = 0;
 		}
 	}
 }
 
 MailContainerIter::MailContainerIter()
 {
 	Container = 0;
 }
 
 MailContainerIter::~MailContainerIter()
 {
 	if (Container)
 	{
 		Container->Iters.Delete(this);
 	}
 }
 
 void MailContainerIter::SetContainer(MailContainer *c)
 {
 	Container = c;
 	if (Container)
 	{
 		Container->Iters.Insert(this);
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 uint32_t MarkColours32[IDM_MARK_MAX] =
 {
 	Rgb32(255, 0, 0),	// red
 	Rgb32(255, 166, 0),	// orange
 	Rgb32(255, 222, 0),	// yellow
 	Rgb32(0, 0xa0, 0),	// green
 	Rgb32(0, 0xc0, 255),// cyan
 	Rgb32(0, 0, 255),	// blue
 	Rgb32(192, 0, 255),	// purple
 	Rgb32(128, 128, 128) // grey
 };
 
 ItemFieldDef MailFieldDefs[] =
 {
 	{"To", SdTo,							GV_STRING,		FIELD_TO},
 	{"From", SdFrom,						GV_STRING,		FIELD_FROM},
 	{"Subject", SdSubject,					GV_STRING,		FIELD_SUBJECT},
 	{"Size", SdSize,						GV_INT64,		FIELD_SIZE},
 	{"Received Date", SdReceivedDate,		GV_DATETIME,	FIELD_DATE_RECEIVED},
 	{"Send Date", SdSendDate,				GV_DATETIME,	FIELD_DATE_SENT},
 	{"Body", SdBody,						GV_STRING,		FIELD_TEXT},
 	{"Internet Header", SdInternetHeader,	GV_STRING,		FIELD_INTERNET_HEADER, IDC_INTERNET_HEADER},
 	{"Message ID", SdMessageId, 			GV_STRING,		FIELD_MESSAGE_ID},
 	{"Priority", SdPriority, 				GV_INT32,		FIELD_PRIORITY},
 	{"Flags", SdFlags, 						GV_INT32,		FIELD_FLAGS},
 	{"Html", SdHtml, 						GV_STRING,		FIELD_ALTERNATE_HTML},
 	{"Label", SdLabel, 						GV_STRING,		FIELD_LABEL},
 	{"From Contact", SdContact,				GV_STRING,		FIELD_FROM_CONTACT_NAME},
 	
 	{"File", SdFile, 						GV_STRING,		FIELD_CACHE_FILENAME},
 	{"ImapFlags", SdImapFlags, 				GV_STRING,		FIELD_CACHE_FLAGS},
 	{"ImapSeq", SdFile, 					GV_INT32,		FIELD_IMAP_SEQ},
 	{"ImapUid", SdImapFlags, 				GV_INT32,		FIELD_SERVER_UID},
 	{"ReceivedDomain", SdReceivedDomain,	GV_STRING,		FIELD_RECEIVED_DOMAIN},
 	{"MessageId", SdMessageId,				GV_STRING,		FIELD_MESSAGE_ID},
 	
 	{0}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 class LIdentityItem : public LListItem
 {
 	ScribeWnd *App;
 	ScribeAccount *Acc;
 	char *Txt;
 
 public:
 	LIdentityItem(ScribeWnd *app, ScribeAccount *acc)
 	{
 		App = app;
 		Acc = acc;
 		Txt = 0;
 
 		LVariant e, n;
 		if (Acc)
 		{
 			n = Acc->Identity.Name();
 			e = Acc->Identity.Email();
 		}
 		else
 		{
 			LAssert(!"No account specified");
 		}
 
 		if (e.Str() && n.Str())
 		{
 			char t[256];
 			sprintf_s(t, sizeof(t), "%s <%s>", n.Str(), e.Str());
 			Txt = NewStr(t);
 		}
 		else if (e.Str())
 		{
 			Txt = NewStr(e.Str());
 		}
 		else if (n.Str())
 		{
 			Txt = NewStr(n.Str());
 		}
 		else
 		{
 			Txt = NewStr("(error)");
 		}
 	}
 	
 	~LIdentityItem()
 	{
 		DeleteArray(Txt);
 	}
 
 	ScribeAccount *GetAccount()
 	{
 		return Acc;
 	}
 
 	const char *GetText(int i)
 	{
 		switch (i)
 		{
 			case 0:
 			{
 				return Txt;
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 class LIdentityDropDrop : public LPopup
 {
 	ScribeWnd *App;
 	Mail *Email;
 	LList *Lst;
 
 public:
 	LIdentityDropDrop(ScribeWnd *app, Mail *mail, LView *owner) :
 		LPopup(owner)
 	{
 		App = app;
 		Email = mail;
 		LRect r(0, 0, 300, 100);
 		SetPos(r);
 		Children.Insert(Lst = new LList(IDC_LIST, 2, 2, X()-4, Y()-4));
 		if (Lst)
 		{
 			Lst->SetParent(this);
 			Lst->AddColumn("Identity", Lst->GetClient().X());
 			Lst->MultiSelect(false);
 
 			if (App)
 			{
 				Lst->Insert(new LIdentityItem(App, 0));
 
 				for (auto a : *App->GetAccounts())
 				{
 					if (a->Identity.Name().Str())
 					{
 						Lst->Insert(new LIdentityItem(App, a));
 					}
 				}
 				
 				/*
 				for (LListItem *i = List->First(); i; i = List->Next())
 				{
 					LIdentityItem *Item = dynamic_cast<LIdentityItem*>(i);
 					if (Item)
 					{
 						char *IdEmail = a->Send.IdentityEmail();
 						if (Email &&
 							IdEmail &&
 							Email->From->Addr &&
 							_stricmp(Email->From->Addr, IdEmail) == 0)
 						{
 							Item->Select(true);
 						}
 					}
 				}
 				*/
 			}
 		}
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		LRect r(GetClient());
 		LWideBorder(pDC, r, DefaultRaisedEdge);
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_LIST:
 			{
 				if (n.Type == LNotifyItemClick)
 				{
 					Visible(false);
 
 					LIdentityItem *NewFrom = dynamic_cast<LIdentityItem*>(Lst->GetSelected());
 					if (Email && NewFrom)
 					{
 						// ScribeAccount *a = NewFrom->GetAccount();
 						if (Email->GetUI())
 						{
 							LList *FromList;
 							if (GetViewById(IDC_FROM, FromList))
 							{
 								// Change item data
 
 								/* FIXME
 								DeleteArray(Email->From->Name);
 								DeleteArray(Email->From->Addr);
 								DeleteArray(Email->Reply->Name);
 								DeleteArray(Email->Reply->Addr);
 								
 								if (a)
 								{
 									Email->From->Addr = NewStr(a->Send.IdentityEmail().Str());
 									Email->From->Name = NewStr(a->Send.IdentityName().Str());
 									Email->Reply->Addr = NewStr(a->Send.IdentityReplyTo().Str());
 									if (Email->Reply->Addr)
 									{
 										Email->Reply->Name = NewStr(Email->From->Name);
 									}
 								}
 								else
 								{
 									LVariant e, n, r;
 									App->GetOptions()->GetValue(OPT_EmailAddr, e);
 									App->GetOptions()->GetValue(OPT_UserName, n);
 									App->GetOptions()->GetValue(OPT_ReplyToEmail, n);
 									Email->From->Addr = NewStr(e.Str());
 									Email->From->Name = NewStr(n.Str());
 									Email->Reply->Addr = NewStr(r.Str());
 									if (Email->Reply->Addr)
 									{
 										Email->Reply->Name = NewStr(Email->From->Name);
 									}
 								}
 
 								// Change UI
 								FromList->Empty();
 								LDataPropI *na = new LDataPropI(Email->From);
 								if (na)
 								{
 									na->CC = MAIL_ADDR_FROM;
 									FromList->Insert(na);
 								}
 								*/
 							}
 						}
 					}
 				}
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 LSubMenu*
 BuildMarkMenu(	LSubMenu *MarkMenu,
 				MarkedState MarkState,
 				uint32_t SelectedMark,
 				bool None,
 				bool All,
 				bool Select)
 {
 	int SelectedIndex = -1;
 
 	// Build image list
 	LImageList *ImgLst = new LImageList(16, 16);
 	if (ImgLst &&
 		ImgLst->Create(16 * CountOf(MarkColours32), 16, System32BitColourSpace))
 	{
 		// ImgLst->Colour(1);
 		ImgLst->Colour(L_MED);
 		ImgLst->Rectangle();
 
 		for (int i=0; i<CountOf(MarkColours32); i++)
 		{
 			if (MarkState == MS_One &&
 				MarkColours32[i] == SelectedMark)
 			{
 				ImgLst->Colour(L_LOW);
 				ImgLst->Box(i*16+1, 0, i*16+15, 14);
 				SelectedIndex = i;
 			}
 
 			ImgLst->Colour(MarkColours32[i], 32);
 			ImgLst->Rectangle(i*16+3, 2, i*16+13, 12);
 		}
 	}
 
 	// Build Submenu
 	if (MarkMenu && ImgLst)
 	{
 		ImgLst->Update(-1);
 		MarkMenu->SetImageList(ImgLst);
 
 		LMenuItem *Item = NULL;
 		if (None)
 		{
 			Item = MarkMenu->AppendItem(LLoadString(IDS_NONE), Select ? IDM_SELECT_NONE : IDM_UNMARK, MarkState != MS_None);
 		}
 		if (All)
 		{
 			Item = MarkMenu->AppendItem(LLoadString(IDS_ALL), Select ? IDM_SELECT_ALL : IDM_MARK_ALL, true);
 		}
 		if (Item)
 		{
 			MarkMenu->AppendSeparator();
 		}
 
 		for (int i=0; i<CountOf(MarkColours32); i++)
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), " (%i, %i, %i)", R32(MarkColours32[i]), G32(MarkColours32[i]), B32(MarkColours32[i]));
 			Item = MarkMenu->AppendItem(s,
 										((Select) ? IDM_MARK_SELECT_BASE : IDM_MARK_BASE) + i,
 										(MarkState != 1) || (i != SelectedIndex));
 			if (Item)
 			{
 				Item->Icon(i);
 			}
 		}
 	}
 
 	return MarkMenu;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 char *WrapLines(char *Str, int Len, int WrapColumn)
 {
 	if (Str &&
 		Len > 0 &&
 		WrapColumn > 0)
 	{
 		LMemQueue Temp;
 		int LastWhite = -1;
 		int StartLine = 0;
 		int XPos = 0;
 		int i;
 
 		for (i=0; Str[i] && i<Len; i++)
 		{
 			if (Str[i] == ' ')
 			{
 				int Len = LastWhite - StartLine;
 				if (XPos >= WrapColumn && Len > 0)
 				{
 					Temp.Write((uchar*) Str+StartLine, Len);
 					Temp.Write((uchar*) "\n", 1);
 					XPos = 0;
 					StartLine = StartLine + Len + 1;
 					LastWhite = -1;
 				}
 				else
 				{
 					LastWhite = i;
 					XPos++;
 				}
 			}
 			else if (Str[i] == '\t')
 			{
 				XPos = ((XPos + 7) / 8) * 8;
 			}
 			else if (Str[i] == '\n')
 			{
 				Temp.Write((uchar*) Str+StartLine, i - StartLine + 1);
 				XPos = 0;
 				StartLine = i+1;
 			}
 			else
 			{
 				XPos++;
 			}
 		}
 
 		Temp.Write((uchar*) Str+StartLine, i - StartLine + 1);
 
 		int WrapLen = (int)Temp.GetSize();
 		char *Wrapped = new char[WrapLen+1];
 		if (Wrapped)
 		{
 			Temp.Read((uchar*) Wrapped, WrapLen);
 			Wrapped[WrapLen] = 0;
 
 			return Wrapped;
 		}
 	}
 
 	return Str;
 }
 
 char *DeHtml(const char *Str)
 {
 	char *r = 0;
 	if (Str)
 	{
 		LMemQueue Buf;
 		char Buffer[256];
 
 		auto s = Str;
 		while (s && *s)
 		{
 			// Search for start of next tag
 			const char *Start = s;
 			const char *End = Start;
 			for (; *End && *End != '<'; End++);
 			
 			// Push pre-tag data onto pipe
 			size_t Len = End-Start;
 			for (size_t i=0; i<Len; )
 			{
 				size_t n;
 				for (n=0; n<sizeof(Buffer) && i<Len; i++)
 				{
 					if (Start[i] != '\n' &&
 						Start[i] != '\r' &&
 						Start[i] != '\t')
 					{
 						if (_strnicmp(Start+i, "&nbsp", 5) == 0)
 						{
 							Buffer[n++] = ' ';
 							i += 5;
 							if (Start[i] != ';') i--;
 						}
 						else if (_strnicmp(Start+i, "&copy", 4) == 0)
 						{
 							Buffer[n++] = 'c';
 							i += 5;
 							if (Start[i] != ';') i--;
 						}
 						else
 						{
 							Buffer[n++] = Start[i];
 						}
 					}
 					else if (Start[i] == '\n')
 					{
 						Buffer[n++] = ' ';
 					}
 				}
 
 				Buf.Write((uchar*)Buffer, n);
 			}
 
 			if (*End == '<')
 			{
 				char Temp[32];
 				int n;
 				End++;
 				for (n=0;
 					n<sizeof(Temp)-1 &&
 					End[n] &&
 					End[n] != ' ' &&
 					End[n] != '>';
 					n++)
 				{
 					Temp[n] = End[n];
 				}
 				Temp[n] = 0;
 
 				if (_stricmp(Temp, "br") == 0 ||
 					_stricmp(Temp, "li") == 0)
 				{
 					Buf.Write((uchar*) "\n", 1);
 				}
 				else if (_stricmp(Temp, "p") == 0 ||
 						 _stricmp(Temp, "/tr") == 0 ||
 						 _stricmp(Temp, "/ul") == 0)
 				{
 					Buf.Write((uchar*) "\n\n", 2);
 				}
 			}
 
 			// Start to end of tag
 			for (; *End && *End != '>'; End++);
 			s = End + 1;
 		}
 
 		int Len = (int)Buf.GetSize();
 		r = new char[Len+1];
 		if (r)
 		{
 			Buf.Read((uchar*)r, Len);
 			r[Len] = 0;
 		}
 	}
 
 	return r;
 }
 
 char *ExtractCodePage(char *ContentType)
 {
 	// int Status = -1;
 
 	if (ContentType)
 	{
 		const char *Match = "charset=";
 		char *Charset = stristr(ContentType, Match);
 		if (Charset)
 		{
 			Charset += strlen(Match);
 			char Delim = ' ';
 			if (*Charset == '\'' ||
 				*Charset == '\"')
 			{
 				Delim = *Charset++;
 			}
 
 			char Str[256];
 			char *Out = Str;
 			while (	*Charset &&
 					*Charset != Delim &&
 					*Charset != ';')
 			{
 				*Out++ = *Charset++;
 			}
 			*Out++ = 0;
 
 			return ValidStr(Str) ? NewStr(Str) : 0;
 		}
 	}
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 extern ItemFieldDef CalendarFields[];
 extern ItemFieldDef FilterFieldDefs[];
 extern ItemFieldDef GroupFieldDefs[];
 
 ItemFieldDef *FieldLists[] =
 {
 	MailFieldDefs,
 	ContactFieldDefs,
 	CalendarFields,
 	FilterFieldDefs,
 	GroupFieldDefs,
 	0
 };
 
 ItemFieldDef *GetFieldDefByName(char *Name)
 {
 	if (Name)
 	{
 		static LHashTbl<ConstStrKey<char,false>, ItemFieldDef*> Lut(256);
 		if (Lut.Length() == 0)
 		{
 			for (ItemFieldDef **l=FieldLists; *l; l++)
 			{
 				for (ItemFieldDef *i = *l; i->FieldId; i++)
 				{
 					if (i->Option)
 						Lut.Add(i->Option, i);
 				}
 			}
 		}
 
 		return (ItemFieldDef*) Lut.Find(Name);
 	}
 
 	return 0;
 }
 
 static bool FieldLutInit = false;
 static LArray<ItemFieldDef*> IdToFieldLut;
 
 ItemFieldDef *GetFieldDefById(int Id)
 {
 	if (!FieldLutInit)
 	{
 		FieldLutInit = true;
 
 		for (ItemFieldDef **l=FieldLists; *l; l++)
 		{
 			for (ItemFieldDef *i = *l; i->FieldId; i++)
 			{
 				IdToFieldLut[i->FieldId] = i;
 			}
 		}
 	}
 
 	if (Id >= 0 && Id < (int)IdToFieldLut.Length())
 		return IdToFieldLut[Id];
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 void Log(char *File, char *Str, ...)
 {
 	#if defined WIN32
 	const char *DefFile = "c:\\temp\\list.txt";
 	#else
 	const char *DefFile = "/home/list.txt";
 	#endif
 
 	if (Str)
 	{
 		LFile f;
 		if (f.Open((File) ? File : DefFile, O_WRITE))
 		{
 			char Buf[1024];
 			va_list Arg;
 
 			va_start(Arg, Str);
 			vsprintf_s(Buf, sizeof(Buf), Str, Arg);
 			va_end(Arg);
 
 			f.Seek(0, SEEK_END);
 			f.Write(Buf, (int)strlen(Buf));
 		}
 	}
 	else
 	{
 		LFile f;
 		if (f.Open((File) ? File : DefFile, O_WRITE))
 		{
 			f.SetSize(0);
 		}
 	}
 }
 
 char *NewPropStr(LOptionsFile *Options, char *Name)
 {
 	LVariant n;
 	if (Options->GetValue(Name, n) && n.Str() && strlen(n.Str()) > 0)
 	{
 		return NewStr(n.Str());
 	}
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Columns of controls
 #define MAILUI_Y						0
 
 #define	IDM_REMOVE_GRTH					1000
 #define IDM_REMOVE_GRTH_SP				1001
 #define IDM_REMOVE_HTML					1002
 #define IDM_CONVERT_B64_TO_BIN			1003
 #define IDM_CONVERT_BIN_TO_B64			1004
 
 #define RECIP_SX						500
 #define ADD_X							(RECIP_X + RECIP_SX + 10)
 #ifdef MAC
 #define	ADD_RECIP_BTN_X					36
 #else
 #define	ADD_RECIP_BTN_X					20
 #endif
 
 #define CONTENT_BORDER					3
 
 #if defined WIN32
 
 	#define DLG_X						15
 	#define DLG_Y						30
 
 #else
 
 	#define DLG_X						6
 	#define DLG_Y						6
 
 #endif
 
 MailUi::MailUi(Mail *item, MailContainer *container) :
 	ThingUi(item, LLoadString(IDS_MAIL_MESSAGE))
 {
 	// Init everything to 0
 	Container = container;
 	if (!item || !item->App)
 	{
 		LAssert(!"Invalid ptrs");
 		return;
 	}
 
     // This allows us to hook iconv conversion events
     LFontSystem::Inst()->Register(this);
     
     // This allows us to hook missing image library events
     GdcD->Register(this);
 
 	// Read/Write access
 	bool ReadOnly = !TestFlag(GetItem()->GetFlags(), MAIL_CREATED | MAIL_BOUNCE);
 	int MinButY = 0;
 
 	// Get position
 	LRect r(150, 150, 800, 750);
 	SetPos(r);
 	int FontHeight = GetFont()->GetHeight();
 
 	LVariant v;
 	LOptionsFile *Options = App ? App->GetOptions() : 0;
 	if (Options)
 	{
 		if (Options->GetValue("MailUI.Pos", v))
 		{
 			r.SetStr(v.Str());
 		}
 	}
 	SetPos(r);
 	MoveSameScreen(App);
 
 	Name(LLoadString(IDS_MAIL_MESSAGE));
 
 	#if WINNATIVE
 	CreateClassW32("Scribe::MailUi", LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_MAIL)));
 	#endif
 	bool IsCreated = TestFlag(GetItem()->GetFlags(), MAIL_CREATED);
 
 	if (Attach(0))
 	{
 		DropTarget(true);
 
 		// Setup main toolbar
 		Commands.Toolbar = App->LoadToolbar(this,
 											App->GetResourceFile(ResToolbarFile),
 											App->GetToolbarImgList());
 		if (Commands.Toolbar)
 		{
 			Commands.Toolbar->Raised(false);
 			Commands.Toolbar->Attach(this);
 
 			BtnSend = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SEND)), IDM_SEND_MSG, TBT_PUSH, !ReadOnly, IMG_SEND);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnSave = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE)), IDM_SAVE, TBT_PUSH, !ReadOnly, IMG_SAVE);
 			BtnSaveClose = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE_CLOSE)), IDM_SAVE_CLOSE, TBT_PUSH, !ReadOnly, IMG_SAVE_AND_CLOSE);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_DELETE)), IDM_DELETE_MSG, TBT_PUSH, true, IMG_TRASH);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SPAM)), IDM_DELETE_AS_SPAM, TBT_PUSH, true, IMG_DELETE_SPAM);
 			BtnAttach = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_ATTACH_FILE)), IDM_ATTACH_FILE, TBT_PUSH, !ReadOnly, IMG_ATTACH_FILE);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnReply = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_REPLY)), IDM_REPLY, TBT_PUSH, ReadOnly, IMG_REPLY);
 			BtnReplyAll = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_REPLYALL)), IDM_REPLY_ALL, TBT_PUSH, ReadOnly, IMG_REPLY_ALL);
 			BtnForward = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_FORWARD)), IDM_FORWARD, TBT_PUSH, ReadOnly, IMG_FORWARD);
 			BtnBounce = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_BOUNCE)), IDM_BOUNCE, TBT_PUSH, ReadOnly, IMG_BOUNCE);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnPrev = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_PREV_MSG)), IDM_PREV_MSG, TBT_PUSH, true, IMG_PREV_ITEM);
 			BtnNext = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_NEXT_MSG)), IDM_NEXT_MSG, TBT_PUSH, true, IMG_NEXT_ITEM);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_HIGH_PRIORITY)), IDM_HIGH_PRIORITY, TBT_TOGGLE, true, IMG_HIGH_PRIORITY);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_LOW_PRIORITY)), IDM_LOW_PRIORITY, TBT_TOGGLE, true, IMG_LOW_PRIORITY);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_READ_RECEIPT)), IDM_READ_RECEIPT, TBT_TOGGLE, true, IMG_READ_RECEIPT);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_PRINT)), IDM_PRINT, TBT_PUSH, true, IMG_PRINT);
 
 			for (LViewI *w: Commands.Toolbar->IterateViews())
 				MinButY = MAX(MinButY, w->Y());
 
 			Commands.Toolbar->Customizable(App->GetOptions(), "MailWindowToolbar");
 			Commands.SetupCallbacks(App, this, GetItem(), LThingUiToolbar);
 		}
 
 		// Setup to/from panels
 		LVariant AlwaysShowFrom;
 		if (IsCreated)
 			App->GetOptions()->GetValue(OPT_MailShowFrom, AlwaysShowFrom);
 
 		bool ShowFrom = !IsCreated &&
 						!TestFlag(GetItem()->GetFlags(), MAIL_BOUNCE);
 
 		LDisplayString Recip(LSysFont, LLoadString(IDS_RECIPIENTS));
 		LAutoPtr<LCheckBox> ReplyChk(new LCheckBox(IDC_USE_REPLY_TO, 21,
 													#ifdef MAC
 													1,
 													#else
 													6,
 													#endif
 													-1, -1, "Reply To"));
 		int ReplyChkPx = ReplyChk ? ReplyChk->X() : 0;
 		int RECIP_X = 20 + MAX(ReplyChkPx, Recip.X()) + 10;
 		int EditHeight = FontHeight + 6;
 
 		LVariant HideGpg;
 		if (!item->App->GetOptions()->GetValue(OPT_HideGnuPG, HideGpg) ||
 			HideGpg.CastInt32() == 0)
 		{
 			GpgUi = new MailUiGpg(	App,
 									this,
 									21,
 									RECIP_X,
 									!ReadOnly && !TestFlag(GetItem()->GetFlags(), MAIL_SENT));
 			if (GpgUi)
 				GpgUi->Attach(this);
 		}
 		
 		ToPanel = new LPanel(LLoadString(IDS_TO), FontHeight * 8, !ShowFrom);
 		if (ToPanel)
 		{
 		    int Cy = 4;
 			ToPanel->AddView(SetTo = new LCombo(IDC_SET_TO, 20, Cy, 60, EditHeight, 0));
 			if (SetTo)
 			{
 				SetTo->Insert(LLoadString(IDS_TO));
 				SetTo->Insert(LLoadString(IDS_CC));
 				SetTo->Insert(LLoadString(IDS_BCC));
 				
 				if (SetTo->GetPos().x2 + 10 > RECIP_X)
 				    RECIP_X = SetTo->GetPos().x2 + 10;
 			}
 			
 			ToPanel->AddView(Entry = new LEdit(IDC_ENTRY, RECIP_X, Cy, RECIP_SX, EditHeight, ""));
 			
 			Cy = SetTo->GetPos().y2 + 5;
 
 			ToPanel->AddView(To = new AddressList(App, IDC_TO, RECIP_X, Cy, RECIP_SX, ToPanel->GetOpenSize() - Cy - 6));
 			if (To)
 				To->SetImageList(App->GetIconImgList(), false);
 			ToPanel->AddView(new LTextLabel(IDC_STATIC, 20, Cy, -1, -1, LLoadString(IDS_RECIPIENTS)));
 			
 			ToPanel->Raised(false);
 			ToPanel->Attach(this);
 		}
 
 		FromPanel = new LPanel(LLoadString(IDS_FROM), FontHeight + 13, AlwaysShowFrom.CastInt32() || ShowFrom);
 		if (FromPanel)
 		{
 			FromPanel->AddView(new LTextLabel(IDC_STATIC, 21,
 										#ifdef MAC
 										8,
 										#else
 										4,
 										#endif
 										-1, -1, LLoadString(IDS_FROM)));
 
 			if (ShowFrom)
 			{
 				FromPanel->AddView(FromList = new AddressList(App, IDC_FROM, RECIP_X, 2, RECIP_SX, EditHeight));
 			}
 			else
 			{
 				FromPanel->AddView(FromCbo = new LCombo(IDC_FROM, RECIP_X, 2, RECIP_SX, EditHeight, 0));
 			}
 
 			if (IsCreated)
 			{
 				LCheckBox *Chk;
 				auto Label = LLoadString(IDS_ALWAYS_SHOW);
 				FromPanel->AddView(Chk = new LCheckBox(IDC_SHOW_FROM, ADD_X,
 														#ifdef MAC
 														1,
 														#else
 														6,
 														#endif
 														-1, -1, Label));
 				if (Chk) Chk->Value(AlwaysShowFrom.CastInt32());
 			}
 
 			FromPanel->Raised(false);
 			FromPanel->Attach(this);
 		}
 
 		ReplyToPanel = new LPanel("Reply To:", FontHeight + 13, false);
 		if (ReplyToPanel)
 		{
 			ReplyToPanel->Raised(false);
 			ReplyToPanel->AddView(ReplyToChk = ReplyChk.Release());
 			ReplyToPanel->AddView(ReplyToCbo = new LCombo(IDC_REPLY_TO_ADDR, RECIP_X, 2, RECIP_SX, EditHeight, 0));
 			ReplyToPanel->Attach(this);
 		}
 
 		SubjectPanel = new LPanel(LLoadString(IDS_SUBJECT), -(LSysFont->GetHeight() + 16));
 		if (SubjectPanel)
 		{
 			SubjectPanel->Raised(false);
 			SubjectPanel->AddView(			new LTextLabel(IDC_STATIC, 21, 8, -1, -1, LLoadString(IDS_SUBJECT)));
 			SubjectPanel->AddView(Subject = new LEdit(IDC_SUBJECT, RECIP_X, 4, RECIP_SX, EditHeight, ""));
 			SubjectPanel->Attach(this);
 		}
 
 		CalendarPanel = new LPanel(LLoadString(IDC_CALENDAR), -(LSysFont->GetHeight() + 16), false);
 		if (CalendarPanel)
 		{
 			CalendarPanel->Raised(false);
 			LTableLayout *t = new LTableLayout(IDC_TABLE);
 			if (t)
 			{
 				t->GetCss(true)->Margin(LCss::Len(LCss::LenPx, LTableLayout::CellSpacing));
 				t->GetCss()->Width(LCss::LenAuto);
 				t->GetCss()->Height(LCss::LenAuto);
 
 				CalendarPanel->AddView(t);
 				auto c = t->GetCell(0, 0);
 				
 				c->Width(LCss::Len(LCss::LenPx, RECIP_X - (LTableLayout::CellSpacing * 2)));
 				c->PaddingLeft(LCss::Len(LCss::LenPx, 21 - LTableLayout::CellSpacing));
 				c->Debug = true;
 
 				c->Add(new LTextLabel(IDC_STATIC, 0, 0, -1, -1, LLoadString(IDS_CALENDAR)));
 				c = t->GetCell(1, 0);
 				c->Add(new LButton(IDC_ADD_CAL_EVENT, 0, 0, -1, -1, LLoadString(IDS_ADD_CAL)));
 				c = t->GetCell(2, 0);
 				c->Add(new LButton(IDC_ADD_CAL_EVENT_POPUP, 0, 0, -1, -1, LLoadString(IDS_ADD_CAL_POPUP)));
 				c = t->GetCell(3, 0);
 				c->Add(CalPanelStatus = new LTextLabel(IDC_STATIC, 0, 0, -1, -1, NULL));
 			}
 
 			CalendarPanel->Attach(this);
 		}
 
 		Tab = new LTabView(IDC_MAIL_UI_TABS, 0, 0, 1000, 1000, 0);
 		if (Tab)
 		{
 			Tab->GetCss(true)->PaddingTop("3px");
 
 			// Don't attach text and html controls here, because OnLoad will do it later...
 			TabText = Tab->Append(LLoadString(IDS_TEXT));
 			TabHtml = Tab->Append("HTML");
 
 			TabAttachments = Tab->Append(LLoadString(IDS_ATTACHMENTS));
 			TabHeader = Tab->Append(LLoadString(IDS_INTERNETHEADER));
 
 			if (TabAttachments)
 			{
 				TabAttachments->Append(Attachments = new AttachmentList(IDC_ATTACHMENTS,
 																		CONTENT_BORDER,
 																		CONTENT_BORDER,
 																		200,
 																		200,
 																		this));
 
 				if (Attachments)
 				{
 					Attachments->AddColumn(LLoadString(IDS_FILE_NAME), 160);
 					Attachments->AddColumn(LLoadString(IDS_SIZE), 80);
 					Attachments->AddColumn(LLoadString(IDS_MIME_TYPE), 100);
 					Attachments->AddColumn(LLoadString(IDS_CONTENT_ID), 250);
 				}
 			}
 
 			if (TabHeader)
 			{
 				TabHeader->Append(Header = new LTextView3(	IDC_INTERNET_HEADER,
 															CONTENT_BORDER,
 															CONTENT_BORDER,
 															100,
 															20));
 				if (Header)
 				{
 					Header->Sunken(true);
 				}
 			}
 
 			LTabPage *Fields = Tab->Append(LLoadString(IDS_FIELDS));
 			if (Fields)
 			{
 				Fields->LoadFromResource(IDD_MAIL_FIELDS);
 				
 				LTableLayout *l;
 				if (GetViewById(IDC_TABLE, l))
 				{
 				    l->SetPourLargest(false);
 				}
 			}
 
 			Tab->Attach(this);
 
 			// Colours
 			LColourSelect *Colour;
 			if (GetViewById(IDC_COLOUR, Colour))
 			{
 				LArray<LColour> c32;
 				for (int i=0; i<CountOf(MarkColours32); i++)
 					c32.New().Set(MarkColours32[i], 32);
 				Colour->SetColourList(&c32);
 			}
 			else LAssert(!"No colour control?");
 		}
 
 		PourAll();
 
 		if (Commands.Toolbar)
 		{
 			if (ToPanel)
 				ToPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 			if (FromPanel)
 				FromPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 			if (ReplyToPanel)
 				ReplyToPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 		}
 
 		SetIcon("About64px.png");
 		OnLoad();
 		_Running = true;
 		Visible(true);
 		RegisterHook(this, LKeyEvents);
 		LResources::StyleElement(this);
 	}
 }
 
 MailUi::~MailUi()
 {
 	DeleteObj(TextView);
 
 	if (Attachments)
 	{
 		Attachments->RemoveAll();
 	}
 	LOptionsFile *Options = (GetItem() && App) ? App->GetOptions() : 0;
 	if (Options)
 	{
 		LRect p = GetPos();
 		if (p.x1 >= 0 &&
 			p.y1 >= 0)
 		{
 			LVariant v = p.GetStr();
 			Options->SetValue("MailUI.Pos", v);
 		}
 	}
 
 	Tab = 0;
 	if (GetItem())
 	{
 		GetItem()->Ui = NULL;
 	}
 	else LgiTrace("%s:%i - Error: no item to clear UI ptr?\n", _FL);
 
 	// We delete the LView here because objects
 	// need to have their virtual tables intact
 	_Delete();
 }
 
 Mail *MailUi::GetItem()
 {
 	return _Item ? _Item->IsMail() : 0;
 }
 
 void MailUi::SetItem(Mail *m)
 {
 	if (_Item)
 	{
 		Mail *old = _Item->IsMail();
 		if (old)
 			old->Ui = NULL;
 		else
 			LAssert(0);
 		_Item = NULL;
 	}
 
 	if (m)
 	{
 		_Item = m;
 		m->Ui = this;
 	}
 }
 
 bool MailUi::SetDirty(bool Dirty, bool Ui)
 {
 	bool b = ThingUi::SetDirty(Dirty, Ui);
 	
 	if (MetaFieldsDirty && !Dirty)
 	{
 		Mail *m = GetItem();
 		if (m)
 		{
 			LColourSelect *Colour;
 			if (GetViewById(IDC_COLOUR, Colour))
 			{
 				uint32_t Col = (uint32_t)Colour->Value();
 				m->SetMarkColour(Col);
 			}
 			else LgiTrace("%s:%i - Can't find IDC_COLOUR\n", _FL);
 
 			auto s = GetCtrlName(IDC_LABEL);
 			m->SetLabel(s);
 			
 			if (m->GetObject()->GetInt(FIELD_STORE_TYPE) != Store3Imap) // Imap knows to save itself.
 				m->SetDirty();
 			m->Update();
 		}
 		
 		MetaFieldsDirty = false;
 	}
 	
 	return b;
 }
 
 #define IDM_FILTER_BASE		2000
 #define IDM_CHARSET_BASE	3000
 void AddActions(LSubMenu *Menu, List<Filter> &Filters, LArray<ScribeFolder*> Folders)
 {
 	if (!Menu)
 		return;
 
 	auto StartLen = Menu->Length();
 
 	for (auto Folder: Folders)
 	{
 		for (ScribeFolder *f=Folder->GetChildFolder(); f; f=f->GetNextFolder())
 		{
 			auto Sub = Menu->AppendSub(f->GetName(true));
 			if (Sub)
 			{
 				auto Item = Sub->GetParent();
 				if (Item) Item->Icon(ICON_CLOSED_FOLDER);
 				Sub->SetImageList(Menu->GetImageList(), false);
 				f->LoadThings();
 				AddActions(Sub, Filters, {f});
 			}
 		}
 
 		List<Filter> a;
 		Folder->LoadThings();
 		for (auto t: Folder->Items)
 		{
 			a.Insert(t->IsFilter());
 		}
 
 		a.Sort(FilterCompare);
 
 		for (auto i: a)
 		{
 			LVariant Name;
 			if (i->GetVariant("Name", Name) && Name.Str())
 			{
 				char n[256];
 				strcpy_s(n, sizeof(n), Name.Str());
 				for (char *s=n; *s; s++)
 				{
 					if (*s == '&')
 					{
 						memmove(s + 1, s, strlen(s)+1);
 						s++;
 					}
 				}
 
 				auto Item = Menu->AppendItem(n, (int) (IDM_FILTER_BASE + Filters.Length()), true);
 				if (Item)
 				{
 					Item->Icon(ICON_FILTER);
 					Filters.Insert(i);
 				}
 			}
 		}
 	}
 
 	if (StartLen == Menu->Length())
 	{
 		char s[64];
 		sprintf_s(s, sizeof(s), "(%s)", LLoadString(IDS_EMPTY));
 		Menu->AppendItem(s, 0, false);
 	}
 }
 
 bool MailUi::OnViewKey(LView *v, LKey &k)
 {
 	if (k.Down() && k.CtrlCmd() && !k.Alt())
 	{
 		switch (k.vkey)
 		{
 			case LK_RETURN:
 			{
 				PostEvent(M_COMMAND, IDM_SEND_MSG);
 				return true;
 			}
 			case LK_UP:
 			{
 				SeekMsg(-1);
 				return true;
 			}
 			case LK_DOWN:
 			{
 				SeekMsg(1);
 				return true;
 			}
 		}
 		switch (k.c16)
 		{
 			case 'p':
 			case 'P':
 			{
 				App->ThingPrint(NULL, GetItem(), NULL, this);
 				break;
 			}
 			case 'f':
 			case 'F':
 			{
 				if (Tab->Value() == 0)
 				{
 					if (TextView)
 						TextView->DoFind(NULL);
 				}
 				else if (Tab->Value() == 1)
 				{
 					if (HtmlView)
 						HtmlView->DoFind(NULL);
 				}
 				return true;
 			}
 			case 'r':
 			case 'R':
 			{
 				OnCommand(IDM_REPLY, 0, NULL);
 				return true;
 			}
 			case 'w':
 			case 'W':
 			{
 				if (OnRequestClose(false))
 					Quit();
 				return true;
 			}
 			case 's':
 			case 'S':
 			{
 				if (IsDirty())
 				{
 					SetDirty(false);
 				}
 				return true;
 			}
 			case '1':
 			{
 				Tab->Value(0);
 				if (TextView) TextView->Focus(true);
 				return true;
 			}
 			case '2':
 			{
 				Tab->Value(1);
 				if (HtmlView) HtmlView->Focus(true);
 				return true;
 			}
 		}
 	}
 
 	return ThingUi::OnViewKey(v, k);
 }
 
 void MailUi::SerializeText(bool FromCtrl)
 {
 	if (GetItem() && TextView)
 	{
 		if (FromCtrl)
 		{
 			GetItem()->SetBody(TextView->Name());
 		}
 		else
 		{
 			TextView->Name(GetItem()->GetBody());
 		}
 	}
 }
 
 const char *FilePart(const char *Uri)
 {
 	const char *Dir = Uri + strlen(Uri) - 1;
 	while (Dir > Uri &&
 		Dir[-1] != '/' &&
 		Dir[-1] != '\\')
 	{
 		Dir--;
 	}
 	
 	return Dir;
 }
 
 void MailUi::OnAttachmentsChange()
 {
 	Attachments->ResizeColumnsToContent();
 
 	if (GetItem())
 	{
 		TabAttachments->GetCss(true)->FontBold(GetItem()->Attachments.Length() > 0);
 		TabAttachments->OnStyleChange();
 	}
 }
 
 bool MailUi::NeedsCapability(const char *Name, const char *Param)
 {
     if (!InThread())
     {
         PostEvent(M_NEEDS_CAP, (LMessage::Param)NewStr(Name));
     }
     else
     {
         if (!Name)
             return false;
             
         if (Caps.Find(Name))
             return true;
 
         Caps.Add(Name, true);
 
 	    char msg[256];
 		LArray<const char *> Actions;
 		LAutoPtr<LColour> Back;
 	    
 	    if (!_stricmp(Name, "RemoteContent"))
 	    {
 			Actions.Add(LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT));
 			Actions.Add(LLoadString(IDS_SHOW_REMOTE_CONTENT));
 
 			Back.Reset(new LColour(L_LOW));
 			strcpy_s(msg, sizeof(msg),
 					LLoadString
 					(
 						IDS_REMOTE_CONTENT_MSG,
 						"To protect your privacy Scribe has blocked the remote content in this message."
 					));
 	    }
 	    else
 	    {
 			Actions.Add(LLoadString(IDS_INSTALL));
 			int ch = 0;
 			for (auto k : Caps)
 				ch += sprintf_s(msg+ch, sizeof(msg)-ch, "%s%s", ch?", ":"", k.key);
 			ch += sprintf_s(msg+ch, sizeof(msg)-ch, " is required to display this content.");
 		}
     		
         if (!MissingCaps)
         {
             MissingCaps = new MissingCapsBar(this, &Caps, msg, App, Actions, Back);
 
 			auto c = IterateViews();
 			auto Idx = c.IndexOf(GpgUi);
 			AddView(MissingCaps, (int)Idx+1);
             AttachChildren();
             OnPosChange();
         }
         else
         {
 		    MissingCaps->SetMsg(msg);
         }
     }
 
     return true;
 }
 
 void MailUi::OnCloseInstaller()
 {
 	if (MissingCaps)
 	{
 		DeleteObj(MissingCaps);
 		PourAll();
 	}
 }
 
 void MailUi::OnInstall(LCapabilityTarget::CapsHash *Caps, bool Status)
 {
 }
 
 void MailUi::OnChildrenChanged(LViewI *Wnd, bool Attaching)
 {
 	if (Wnd == (LViewI*)MissingCaps &&
 		!Attaching)
 	{
 		MissingCaps = NULL;
 		PourAll();
 	}
 }
 
 LDocView *MailUi::GetDoc(const char *MimeType)
 {
 	if (!MimeType)
 	{
 		MimeType = sTextPlain;
 		LVariant v;
 		if (App->GetOptions()->GetValue(OPT_DefaultAlternative, v) &&
 			v.CastInt32() > 0)
 			MimeType = sTextHtml;
 	}
 	
 	LAssert(MimeType != NULL);
 	
 	if (!_stricmp(MimeType, sTextPlain))
 		return TextView;
 	else if (!_stricmp(MimeType, sTextHtml))
 		return HtmlView;
 	else
 		LAssert(!"Invalid mime type.");
 	
 	return NULL;
 }
 
 bool MailUi::SetDoc(LDocView *v, const char *MimeType)
 {
 	if (!MimeType)
 	{
 		MimeType = sTextPlain;
 		LVariant v;
 		if (App->GetOptions()->GetValue(OPT_DefaultAlternative, v) &&
 			v.CastInt32() > 0)
 			MimeType = sTextHtml;
 	}
 	
 	LAssert(MimeType != NULL);
 
 	if (!_stricmp(MimeType, sTextPlain))
 	{
 		LTextView3 *Txt = static_cast<LTextView3*>(v);
 		if (Txt)
 		{
 			if (Txt != TextView)
 			{
 				DeleteObj(TextView);
 				TextView = Txt;
 				if (TabText && !TextView->IsAttached())
 					TabText->Append(TextView);
 			}
 			TextLoaded = true;
 			if (_Running)
 				TabText->Select();
 		}
 		else
 		{
 			LAssert(!"Invalid ctrl.");
 			return false;
 		}
 	}
 	else if (!_stricmp(MimeType, sTextHtml))		
 	{
 		LDocView *Html = dynamic_cast<LDocView*>(v);
 		if (Html)
 		{
 			if (Html != HtmlView)
 			{
 				DeleteObj(HtmlView);
 				HtmlView = Html;
 
 				LCapabilityClient *cc = dynamic_cast<LCapabilityClient*>(v);
 				if (cc)
 					cc->Register(this);
 
 				if (TabHtml && !HtmlView->IsAttached())
 					TabHtml->Append(HtmlView);
 			}
 			HtmlLoaded = true;
 			if (_Running)
 				TabHtml->Select();
 		}
 		else
 		{
 			LAssert(!"Invalid ctrl.");
 			return false;
 		}
 	}
 	else
 	{
 		LAssert(!"Invalid mime type.");
 		return false;
 	}
 
     return true;
 }
 
 bool MailUi::IsWorking(int Set)
 {
 	if (!GetItem())
 		return false;
 
 	// Are any of the attachments busy doing something?
 	LDataI *AttachPoint = GetItem() && Set >= 0 ? GetItem()->GetFileAttachPoint() : NULL;
 
 	List<Attachment> Attachments;
 	if (GetItem()->GetAttachments(&Attachments))
 	{
 		// Attachment *Match = NULL;
 		for (auto a: Attachments)
 		{
 			if (Set >= 0)
 			{
 				a->SetIsResizing(Set != 0);
 				if (AttachPoint)
 				{
 					a->GetObject()->Save(AttachPoint);
 				}
 			}
 			else if (a->GetIsResizing())
 			{
 				return true;
 			}
 		}
 	}
 	
 	// Check rich text control as well...
 	auto Rte = dynamic_cast<LRichTextEdit*>(HtmlView);
 	if (Rte)
 	{
 		if (Rte->IsBusy())
 		{
 			return true;
 		}
 	}
 
 	return false;
 }
 
 class BusyPanel : public LPanel
 {
 public:
 	BusyPanel() : LPanel("Working...", LSysFont->GetHeight() << 1)
 	{
 		LViewI *v;
 		LCss::ColorDef Bk(LColour(255, 128, 0));
 		GetCss(true)->BackgroundColor(Bk);
 
 		AddView(v = new LTextLabel(IDC_STATIC, 30, 5, -1, -1, "Still resizing images..."));
 		v->GetCss(true)->BackgroundColor(Bk);
 
 		AddView(v = new LButton(IDCANCEL, 200, 3, -1, -1, LLoadString(IDS_CANCEL)));
 		v->GetCss(true)->NoPaintColor(Bk);
 	}
 };
 
 void MailUi::SetCmdAfterResize(int Cmd)
 {
 	if (CmdAfterResize == 0)
 	{
 		CmdAfterResize = Cmd;
 		if (!WorkingDlg)
 		{
 			WorkingDlg = new BusyPanel;
 			if (WorkingDlg)
 			{
 				AddView(WorkingDlg, 1);
 				AttachChildren();
 				OnPosChange();
 			}
 		}
 	}
 }
 
 bool MailUi::OnRequestClose(bool OsClose)
 {
 	bool Working = IsWorking();
 	if (Working)
 	{
 		SetCmdAfterResize(IDM_SAVE_CLOSE);
 		return false;
 	}
 	
 	return ThingUi::OnRequestClose(OsClose);
 }
 
 void MailUi::OnChange()
 {
 	if (!IsDirty())
 		OnLoad();
 }
 
 struct MailUiNameAddr
 {
 	LString Name, Addr;
 	
 	MailUiNameAddr(const char *name = 0, const char *addr = 0)
 	{
 		Name = name;
 		Addr = addr;
 	}
 };
 
 void MailUi::OnLoad()
 {
 	bool Edit = false;
 	bool ReadOnly = true;
 	Mail *Item = GetItem();
 
 	_Running = false;
 
 	if (Item &&
 		Item->App)
 	{
 		Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 		ReadOnly = !TestFlag(Item->GetFlags(), MAIL_CREATED | MAIL_BOUNCE);
 
 		if (Entry)
 		{
 			Entry->Name("");
 		}
 
 		if (To)
 		{
 			To->OnInit(Item->GetTo());
 		}
 
 		if (FromCbo)
 		{
 			LHashTbl<StrKey<char,false>, MailUiNameAddr*> ReplyToAddrs;
 			const char *Template = "%s <%s>";
 			FromCbo->Empty();
 
 			int Idx = -1;
 			LVariant DefName, DefAddr;
 
 			// LOptionsFile *Opts = Item->Window->GetOptions();
 			for (auto a : *Item->App->GetAccounts())
 			{
 				LVariant Name = a->Identity.Name();
 				LVariant Addr = a->Identity.Email();
 				LVariant ReplyTo = a->Identity.ReplyTo();
 				
 				if (!a->IsValid() || a->Send.Disabled())
 					continue;
 				
 				if (ReplyTo.Str())
 				{
 					if (!ReplyToAddrs.Find(ReplyTo.Str()))
 						ReplyToAddrs.Add(ReplyTo.Str(), new MailUiNameAddr(Name.Str(), ReplyTo.Str()));
 				}
 				else if (Addr.Str())
 				{
 					if (!ReplyToAddrs.Find(Addr.Str()))
 						ReplyToAddrs.Add(Addr.Str(), new MailUiNameAddr(Name.Str(), Addr.Str()));
 				}
 
 				if (Name.Str() && Addr.Str())
 				{
 					if (!DefAddr.Str() ||
 						_stricmp(DefAddr.Str(), Addr.Str()))
 					{
 						auto FromAddr = Item->GetFromStr(FIELD_EMAIL);
 						if (FromAddr && _stricmp(Addr.Str(), FromAddr) == 0)
 						{
 							Idx = (int)FromCbo->Length();
 						}
 
 						LString p;
 						p.Printf(Template, Name.Str(), Addr.Str());
 						
 						int Id = a->Receive.Id();
 						int CurLen = (int)FromCbo->Length();
 						
 						LAssert(Id != 0);
 						
 						FromAccountId[CurLen] = Id;
 						
 						FromCbo->Insert(p);
 					}
 				}
 			}
 			
 			if (Idx < 0)
 			{
 				auto FromName = Item->GetFromStr(FIELD_NAME);
 				auto FromAddr = Item->GetFromStr(FIELD_EMAIL);
 				if (FromAddr)
 				{
 					LStringPipe p;
 					if (FromName)
 						p.Print(Template, FromName, FromAddr);
 					else
 						p.Print("<%s>", FromAddr);
 					LAutoString s(p.NewStr());
 					FromAccountId[FromCbo->Length()] = -1;
 					Idx = (int)FromCbo->Length();
 					FromCbo->Insert(s);
 					FromCbo->Value(Idx);
 				}
 			}
 			else
 			{
 				FromCbo->Value(Idx);
 			}
 
 			if (ReplyToAddrs.Length() > 0 && ReplyToCbo)
 			{
 				auto CurAddr = Item->GetReply() ? Item->GetReply()->GetStr(FIELD_EMAIL) : NULL;
 				int CurIdx = -1;
 				// for (MailUiNameAddr *na = ReplyToAddrs.First(); na; na = ReplyToAddrs.Next())
 				for (auto na : ReplyToAddrs)
 				{
 					char s[256];
 					sprintf_s(s, sizeof(s), Template, na.value->Name.Get(), na.value->Addr.Get());
 					if (CurAddr && !_stricmp(na.value->Addr, CurAddr))
 						CurIdx = (int)ReplyToCbo->Length();
 					
 					ReplyToCbo->Insert(s);
 				}
 				if (CurIdx >= 0)
 				{
 					ReplyToCbo->Value(CurIdx);
 					ReplyToChk->Value(true);
 				}
 				else
 				{
 					ReplyToChk->Value(false);
 				}
 			}
 			ReplyToAddrs.DeleteObjects();
 		}
 		else if (FromList)
 		{
 			FromList->Empty();
 			ListAddr *na = new ListAddr(App, Item->GetFrom());
 			if (na)
 			{
 				na->CC = MAIL_ADDR_FROM;
 				na->OnFind();
 				FromList->Insert(na);
 			}
 		}
 
 		if (Subject)
 		{
 			Subject->Name(Item->GetSubject());
 			
 			char Title[140];
 			auto Subj = Item->GetSubject();
 			if (Subj)
 				sprintf_s(Title, sizeof(Title), "%s - %.100s", LLoadString(IDS_MAIL_MESSAGE), Subj);
 			else
 				sprintf_s(Title, sizeof(Title), "%s", LLoadString(IDS_MAIL_MESSAGE));
 			Title[sizeof(Title)-1] = 0;
 			for (char *s = Title; *s; s++)
 				if (*s == '\n' || *s == '\r') *s = ' ';
 			Name(Title);
 		}
 
 		int64_t Rgb32 = Item->GetMarkColour();
 		SetCtrlValue(IDC_COLOUR, Rgb32 > 0 ? Rgb32 : -1);
 		SetCtrlName(IDC_LABEL, Item->GetLabel());
 
 		char Date[256];
 		Item->GetDateReceived()->Get(Date, sizeof(Date));
 		SetCtrlName(IDC_RECEIVED_DATE, Date);
 		Item->GetDateSent()->Get(Date, sizeof(Date));
 		SetCtrlName(IDC_SENT_DATE, Date);
 
 		TextLoaded = false;
 		HtmlLoaded = false;
 
 		auto TextContent = Item->GetBody();
 		auto HtmlContent = Item->GetHtml();
 
 		Sx = Sy = -1;
 
 		LDocView *DocView = NULL;
 		if (TabText &&
 			(DocView = Item->CreateView(this, sTextPlain, true, -1, !Edit)))
 		{
 			if (DocView == HtmlView)
 			{
 				// CreateView converted the text to HTML to embed Emojis. If we have
 				// actual HTML content it'll overwrite the text portion, so we need
 				// to move the HTML control to the text tab to leave room for actual HTML.
 				DeleteObj(TextView);
 				TextView = HtmlView;
 				HtmlView = NULL;
 				TextView->Detach();
 				TabText->Append(TextView);
 				TextLoaded = true;
 				HtmlLoaded = false;
 			}
 			
 			if (!TextView && Edit)
 			{
 				// What the? Force creation of control...
 				LAssert(!"Must have an edit control.");
 				LDocView *Dv = App->CreateTextControl(IDC_TEXT_VIEW, sTextPlain, Edit, GetItem());
 				if (Dv)
 					SetDoc(Dv, sTextPlain);
 				LAssert(TextView != NULL);
 			}
 			
 			if (TextView)
 			{
 				TextView->Visible(true);
 				
 				// This needs to be below the resize of the control so that
 				// any wrapping has already been done and thus the scroll
 				// bar is laid out already.
 				if (Item->Cursor > 0)
 					TextView->SetCaret(Item->Cursor, false);
 
 				TabText->GetCss(true)->FontBold(ValidStr(TextContent));
 				TabText->OnStyleChange();
 			}
 		}
 
 		bool ValidHtml = ValidStr(HtmlContent);
 		if (TabHtml &&
 			Item->CreateView(this, sTextHtml, true, -1, !Edit) &&
 			HtmlView)
 		{
 			HtmlView->Visible(true);
 			if (Item->Cursor > 0)
 				HtmlView->SetCaret(Item->Cursor, false);
 
 			TabHtml->GetCss(true)->FontBold(ValidHtml);
 			TabHtml->OnStyleChange();
 		}
 		
 		LVariant DefTab;
 		Item->App->GetOptions()->GetValue(Edit ? OPT_EditControl : OPT_DefaultAlternative, DefTab);
 		CurrentEditCtrl = (Edit || ValidHtml) && DefTab.CastInt32();
 		Tab->Value(CurrentEditCtrl);
 		HtmlCtrlDirty = !ValidHtml;
 		TextCtrlDirty = !ValidStr(TextContent);
 
 		if (CalendarPanel)
 		{
 			auto CalEvents = GetItem()->GetCalendarAttachments();
 			CalendarPanel->Open(CalEvents.Length() > 0);
 		}
 
 		OnPosChange();
 
 		if (Attachments)
 		{
 			Attachments->RemoveAll();
 			
 			List<Attachment> Files;
 			if (Item->GetAttachments(&Files))
 			{
 				for (auto a: Files)
 					Attachments->Insert(a);
 			}
 
 			OnAttachmentsChange();
 		}
 
 		if (Header)
 		{
 			LAutoString Utf((char*)LNewConvertCp("utf-8", Item->GetInternetHeader(), "iso-8859-1"));
 			Header->Name(Utf);
 			Header->SetEnv(Item);
 		}
 
 		bool Update =	(Item->GetFlags() & MAIL_READ) == 0 &&
 						(Item->GetFlags() & MAIL_CREATED) == 0;
 		if (Update)
 		{
 			Item->SetFlags(Item->GetFlags() | MAIL_READ);
 		}
 
 		if (Commands.Toolbar)
 		{
 			int p = Item->GetPriority();
 			Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, p < MAIL_PRIORITY_NORMAL);
 			Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, p > MAIL_PRIORITY_NORMAL);
 			Commands.Toolbar->SetCtrlValue(IDM_READ_RECEIPT, TestFlag(Item->GetFlags(), MAIL_READ_RECEIPT));
 		}
 	}
 
 	if (Item->GetFlags() & (MAIL_CREATED | MAIL_BOUNCE))
 	{
 		if (Entry)
 			Entry->Focus(true);
 	}
 	else
 	{
 		if (TextView)
 			TextView->Focus(true);
 	}
 
 	if (BtnPrev && BtnNext)
 	{
 		if (Item && Container)
 		{
 			/*
 			int Items = Item->GetList()->Length();
 			int i = Item->GetList()->IndexOf(Item);
 			*/
 
 			auto Items = Container->Length();
 			auto i = Container->IndexOf(Item);
 
 			BtnPrev->Enabled(i < (ssize_t)Items - 1);
 			BtnNext->Enabled(i > 0);
 		}
 		else
 		{
 			BtnPrev->Enabled(false);
 			BtnNext->Enabled(false);
 		}
 	}
 
 	if (BtnSend) BtnSend->Enabled(!ReadOnly);
 	if (BtnSave) BtnSave->Enabled(!ReadOnly);
 	if (BtnSaveClose) BtnSaveClose->Enabled(!ReadOnly);
 	if (BtnAttach) BtnAttach->Enabled(!ReadOnly);
 
 	if (BtnReply) BtnReply->Enabled(ReadOnly);
 	if (BtnReplyAll) BtnReplyAll->Enabled(ReadOnly);
 	if (BtnForward) BtnForward->Enabled(true);
 	if (BtnBounce) BtnBounce->Enabled(ReadOnly);
 
 	if (Commands.Toolbar)
 	{
 		Commands.Toolbar->SetCtrlEnabled(IDM_HIGH_PRIORITY, Edit);
 		Commands.Toolbar->SetCtrlEnabled(IDM_LOW_PRIORITY, Edit);
 		Commands.Toolbar->SetCtrlEnabled(IDM_READ_RECEIPT, Edit);
 	}
 
 	_Running = true;
 }
 
 void MailUi::OnSave()
 {
 	if (!GetItem())
 		return;
 
 	if (GetItem()->GetFlags() & MAIL_SENT)
 	{
 		// Save a copy instead of over writing the original sent email
 		Mail *Copy = new Mail(App, GetItem()->GetObject()->GetStore()->Create(MAGIC_MAIL));
 		if (Copy)
 		{
 			*Copy = *_Item;
 			Copy->SetFlags(MAIL_READ | MAIL_CREATED, true);
 			Copy->SetFolder(GetItem()->GetFolder());				
 			Copy->SetDateSent(0);
 			SetItem(Copy);
 		}
 	}
 
 	Mail *Item = GetItem();
 	if (To)
 	{
 		To->OnSave(Item->GetObject()->GetStore(), Item->GetTo());
 	}
 	
 	LMailStore *AccountMailStore = NULL;
 	
 	if (FromCbo && Item->GetFrom() && FromAccountId.Length() > 0)
 	{
 		int64 CboVal = FromCbo->Value();
 		LAssert(CboVal < (ssize_t)FromAccountId.Length());
 		int AccountId = FromAccountId[(int)CboVal];
 		
 		LDataPropI *Frm = Item->GetFrom();
 		if (AccountId < 0)
 		{
 			// From is a literal address, not an account ID. This can happen when bouncing email.
 			Mailto mt(App, FromCbo->Name());
 			if (mt.To.Length() == 1)
 			{
 				AddressDescriptor *a = mt.To[0];
 				if (a)
 				{
 					Frm->SetStr(FIELD_NAME, a->sName);
 					Frm->SetStr(FIELD_EMAIL, a->sAddr);
 				}
 			}
 			else LAssert(0);
 		}
 		else if (AccountId > 0)
 		{
 			ScribeAccount *a = Item->App->GetAccountById(AccountId);
 			if (a)
 			{
 				Frm->SetStr(FIELD_NAME, a->Identity.Name().Str());
 				Frm->SetStr(FIELD_EMAIL, a->Identity.Email().Str());
 			}
 			else LAssert(!"From account missing.");
 			
 			// Find the associated mail store for this account. Hopefully we can put any new
 			// mail into the mail store that the account is using.
 			// 
 			// Check for IMAP mail store?
 			AccountMailStore = a->Receive.GetMailStore();
 			if (!AccountMailStore)
 			{
 				// Nope... what about a receive path?
 				LVariant DestFolder = a->Receive.DestinationFolder();
 				if (ValidStr(DestFolder.Str()))
 				{
 					AccountMailStore = Item->App->GetMailStoreForPath(DestFolder.Str());
 				}
 			}
 		}
 		else LAssert(!"No account id.");
 	}
 	
 	LDataPropI *ReplyObj = Item->GetReply();
 	if (ReplyToCbo != NULL &&
 		ReplyObj != NULL   &&
 		ReplyToChk != NULL &&
 		ReplyToChk->Value())
 	{		
 		Mailto mt(App, ReplyToCbo->Name());
 		if (mt.To.Length() == 1)
 		{
 			AddressDescriptor *a = mt.To[0];
 			if (a && a->sAddr)
 			{
 				if (a->sName)
 					ReplyObj->SetStr(FIELD_NAME, a->sName);
 				ReplyObj->SetStr(FIELD_EMAIL, a->sAddr);
 			}			
 		}
 	}
 
 	Item->SetSubject(Subject->Name());
 
 	Item->SetLabel(GetCtrlName(IDC_LABEL));
 	
 	auto c32 = GetCtrlValue(IDC_COLOUR);
 	Item->SetMarkColour(c32);
 
 	LDocView *Ctrl = CurrentEditCtrl ? HtmlView : TextView;
 	if (Ctrl)
 	{
 		// Delete all existing data...
 		Item->SetBody(0);
 		Item->SetBodyCharset(0);
 		Item->SetHtml(0);
 		Item->SetHtmlCharset(0);
 
 		const char *MimeType = Ctrl->GetMimeType();
 		const char *Charset = Ctrl->GetCharset();
 		if (!_stricmp(MimeType, sTextHtml))
 		{
 			LArray<LDocView::ContentMedia> Media;
 
 			// Set the HTML part
 			LString HtmlFormat;
 			if (!Ctrl->GetFormattedContent("text/html", HtmlFormat, &Media))
 				HtmlFormat = Ctrl->Name();
 			Item->SetHtml(HtmlFormat);
 			Item->SetHtmlCharset(Charset);
 
 			// Also set a text version for the alternate
 			LString TxtFormat;
 			if (!Ctrl->GetFormattedContent(sTextPlain, TxtFormat))
 			{
 				TxtFormat = HtmlToText(Item->GetHtml(), Charset);
 			}
 			if (TxtFormat)
 			{
 				Item->SetBody(TxtFormat);
 				Item->SetBodyCharset(Charset);
 			}
 
 			auto Obj = Item->GetObject();
 
 			// This clears any existing multipart/related objects...
 			Obj->SetObj(FIELD_HTML_RELATED, NULL);
 
 			if (Media.Length() > 0)
 			{
 				// Make a table of existing attachments so that we don't duplicate
 				// these new ones.
 				LArray<LDataI*> Objs;
 				LHashTbl<ConstStrKey<char,false>,LDataI*> Map;
 				if (GetItem()->GetAttachmentObjs(Objs))
 				{
 					for (auto i : Objs)
 					{
 						auto Cid = i->GetStr(FIELD_CONTENT_ID);
 						if (Cid)
 							Map.Add(Cid, i);
 					}
 				}
 
 				// If there are media attachments, splice them into the MIME tree.
 				// This should go after setting the text part so that the right
 				// MIME alternative structure is generated.
 				auto Store = Obj->GetStore();
 				for (auto &Cm : Media)
 				{
 					LDataI *a = Store->Create(MAGIC_ATTACHMENT);
 					if (a)
 					{
 						LAssert(Cm.Valid());
 						
 						auto Existing = Map.Find(Cm.Id);
 						if (Existing)
 						{
 							// Delete the existing attachment
 							Thing *t = CastThing(Existing);
 							Attachment *a = t ? t->IsAttachment() : NULL;
 							if (a)
 							{
 								// Delete both the Attachment and it's store object...
 								auto it = GetItem();
 								it->DeleteAttachment(a);
 							}
 							else
 							{
 								// There is Attachment object for the LDataI.... but we can
 								// still delete it from the store.
 								LArray<LDataI*> del;
 								del.Add(Existing);
 								Existing->GetStore()->Delete(del, false);
 							}
 						}
 
 						LgiTrace("Adding related: %s %s " LPrintfInt64 "\n",
 							Cm.FileName.Get(),
 							Cm.MimeType.Get(),
 							Cm.Stream->GetSize());
 
 						a->SetStr(FIELD_CONTENT_ID, Cm.Id);
 						a->SetStr(FIELD_NAME, Cm.FileName);
 						a->SetStr(FIELD_MIME_TYPE, Cm.MimeType);
 						a->SetStream(Cm.Stream);
 						
 						Obj->SetObj(FIELD_HTML_RELATED, a);
 					}
 				}
 			}
 		}
 		else
 		{
 			auto Text = Ctrl->Name();
 			Item->SetBody(Text);
 			Item->SetBodyCharset(Charset);
 		}
 	}
 
 	#if SAVE_HEADERS
 	char *Headers = Header ? Header->Name() : 0;
 	if (Headers)
 	{
 		DeleteArray(Item->InternetHeader);
 		Item->InternetHeader = NewStr(Headers);
 	}
 	#endif
 
 	Item->GetMessageId(true);
 	Item->CreateMailHeaders();
 	Item->Update();
 	
 	ScribeFolder *Folder = Item->GetFolder();
 
 	// Now get the associated outbox for this mail
 	ScribeFolder *Outbox = Item->App->GetFolder(FOLDER_OUTBOX, AccountMailStore);
 	
 	auto Fld = Folder ? Folder : Outbox;
 	LAssert(Fld != NULL);
 	bool Status = Fld ? Item->Save(Fld) : false;
 	if (Status)
 	{
 		LArray<LDataI*> c;
 		c.Add(Item->GetObject());
 
 		Item->App->SetContext(_FL);
 		Item->App->OnChange(c, 0);
 	}
 }
 
 bool MailUi::AddRecipient(AddressDescriptor *Addr)
 {
 	if (Addr && To)
 	{
 		ListAddr *La = dynamic_cast<ListAddr *>(Addr);
 		if (La)
 		{
 			To->Insert(La);
 			return true;
 		}
 	}
 	return false;
 }
 
 bool MailUi::AddRecipient(Contact *c)
 {
 	ListAddr *La = new ListAddr(c);
 	if (La)
 	{
 		To->Insert(La);
 		return true;
 	}
 
 	return false;
 }
 
 bool MailUi::AddRecipient(const char *Email, const char *Name)
 {
 	ListAddr *La = new ListAddr(App, Email, Name);
 	if (La)
 	{
 		To->Insert(La);
 		return true;
 	}
 
 	return false;
 }
 
 bool MailUi::SeekMsg(int delta)
 {
 	bool Status = false;
 
 	if (Container)
 	{
 		Mail *Item = GetItem();
 		auto Index = Container->IndexOf(Item);
 		Mail *Next = Index >= 0 ? (*Container)[Index + delta] : 0;
 		if (Next)
 		{
 			SetDirty(false); // called OnSave() if necessary
 			_Running = false;
 
 			if (Item->Ui)
 			{
 				// close any existing user interface
 				if (Item->Ui != this)
 				{
 					Item->Ui->Quit();
 				}
 				else
 				{
 					Item->Ui = 0;
 				}
 			}
 			if (Header)
 				Header->SetEnv(0);
 
 			Caps.Empty();
 			SetItem(Next);
 			Item = GetItem();
 
 			// select this item in the list
 			if (Item->GetList())
 			{
 				Item->GetList()->Select(Item);
 				Item->ScrollTo();
 			}
 
 			Status = true;
 
 			OnLoad();
 			_Running = true;
 		}
 	}
 
 	return Status;
 }
 
 int MailUi::HandleCmd(int Cmd)
 {
 	switch (Cmd)
 	{
 		case IDM_READ_RECEIPT:
 		{
 			if (Commands.Toolbar)
 			{
 				int f = GetItem()->GetFlags();
 				if (Commands.Toolbar->GetCtrlValue(IDM_READ_RECEIPT))
 				{
 					SetFlag(f, MAIL_READ_RECEIPT);
 				}
 				else
 				{
 					ClearFlag(f, MAIL_READ_RECEIPT);
 				}
 				GetItem()->SetFlags(f);
 			}
 			break;
 		}
 		case IDM_HIGH_PRIORITY:
 		{
 			if (Commands.Toolbar)
 			{
 				GetItem()->SetPriority(Commands.Toolbar->GetCtrlValue(IDM_HIGH_PRIORITY) ? MAIL_PRIORITY_HIGH : MAIL_PRIORITY_NORMAL);
 				SetDirty(true);
 
 				Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, GetItem()->GetPriority() < MAIL_PRIORITY_NORMAL);
 				Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, GetItem()->GetPriority() > MAIL_PRIORITY_NORMAL);
 			}
 			break;
 		}
 		case IDM_LOW_PRIORITY:
 		{
 			if (Commands.Toolbar)
 			{
 				GetItem()->SetPriority(Commands.Toolbar->GetCtrlValue(IDM_LOW_PRIORITY) ? MAIL_PRIORITY_LOW : MAIL_PRIORITY_NORMAL);
 				SetDirty(true);
 
 				Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, GetItem()->GetPriority() < MAIL_PRIORITY_NORMAL);
 				Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, GetItem()->GetPriority() > MAIL_PRIORITY_NORMAL);
 			}
 			break;
 		}
 		case IDM_PREV_MSG:
 		{
 			SeekMsg(1);
 			break;
 		}
 		case IDM_NEXT_MSG:
 		{
 			SeekMsg(-1);
 			break;
 		}
 		case IDM_SEND_MSG:
 		{
 			bool Working = IsWorking();
 			if (Working)
 			{
 				SetCmdAfterResize(Cmd);
 				break;
 			}
 
 			if (!GetItem() || !App)
 			{
 				LAssert(!"Missing item or window ptr.");
 				break;
 			}
 			
 			// Normal save
 			bool IsInPublicFolder = GetItem()->GetFolder() && GetItem()->GetFolder()->IsPublicFolders();
 			if (IsInPublicFolder)
 			{
 				auto i = GetItem();
 				LDateTime n;
 				n.SetNow();
 				i->SetDateSent(&n);
 				i->Update();
 			}
 
 			OnDataEntered();
 			OnSave();
 			SetDirty(false, false);
 			GetItem()->Send(true);
 			Quit();
 			return 0;
 		}
 		case IDM_DELETE_MSG:
 		{
 			LVariant ConfirmDelete, DelDirection;
 			App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 			App->GetOptions()->GetValue(OPT_DelDirection, DelDirection);
 			int WinAction = DelDirection.CastInt32() - 1; // -1 == Next, 0 == Close, 1 == Prev
 
 			if (!ConfirmDelete.CastInt32() ||
 				LgiMsg(this, LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 			{
 				Mail *Del = GetItem()->GetObject() ? GetItem() : 0;
 				if (Del)
 				{
 					if (!Del->GetObject()->IsOnDisk())
 						Del = 0;
 				}
 				
 				if (!WinAction || !SeekMsg(WinAction))
 				{
 					SetItem(0);
 					PostEvent(M_CLOSE);
 				}
 				
 				if (Del && Del->GetObject())
 				{
 					Del->OnDelete();
 				}
 			}
 			break;
 		}
 		case IDM_DELETE_AS_SPAM:
 		{
 			LVariant DelDirection;
 			App->GetOptions()->GetValue(OPT_DelDirection, DelDirection);
 			int WinAction = DelDirection.CastInt32() - 1; // -1 == Next, 0 == Close, 1 == Prev
 			
 			if (GetItem())
 			{
 				Mail *Del = GetItem()->GetObject() ? GetItem() : 0;
 
 				if (!WinAction || !SeekMsg(WinAction))
 				{
 					SetItem(0);
 					PostEvent(M_CLOSE);
 				}
 
 				if (Del)
 				{
 					Del->DeleteAsSpam(this);
 				}
 			}
 			break;
 		}
 		case IDM_SAVE:
 		{
 			OnDataEntered();
 			SetDirty(false, false);
 			break;
 		}
 		case IDM_SAVE_CLOSE:
 		{
 			bool Working = IsWorking();
 			if (Working)
 			{
 				SetCmdAfterResize(Cmd);
 				break;
 			}
 
 			OnDataEntered();
 			SetDirty(false, false);
 			// fall thru
 		}
 		case IDM_CLOSE:
 		{
 			Quit();
 			return 0;
 		}
 		case IDM_REPLY:
 		case IDM_REPLY_ALL:
 		{
 			App->MailReplyTo(GetItem(), Cmd == IDM_REPLY_ALL);
 			SetDirty(false);
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_FORWARD:
 		{
 			App->MailForward(GetItem());
 			if (IsDirty())
 				OnSave();
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_BOUNCE:
 		{
 			App->MailBounce(GetItem());
 			OnSave();
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_PRINT:
 		{
 			if (GetItem() && App)
 			{
 				if (IsDirty())
 				{
 					OnDataEntered();
 					OnSave();
 				}
 				App->ThingPrint(NULL, GetItem(), 0, this);
 			}
 			break;
 		}
 		case IDM_ATTACH_FILE:
 		{
 			auto Select = new LFileSelect(this);
 			Select->MultiSelect(true);
 			Select->Type("All files", LGI_ALL_FILES);
 			Select->Open([this](auto dlg, auto status)
 			{
 				if (status)
 				{
 					Mail *m = GetItem();
 					if (m)
 					{
 						for (size_t i=0; i<dlg->Length(); i++)
 						{
 							char File[MAX_PATH_LEN];
 							if (!LResolveShortcut((*dlg)[i], File, sizeof(File)))
 							{
 								strcpy_s(File, sizeof(File), (*dlg)[i]);
 							}
 
 							Attachment *a = m->AttachFile(this, File);
 							if (a && Attachments)
 							{
 								Attachments->Insert(a);
 								Attachments->ResizeColumnsToContent();
 							}
 						}
 					}
 				}
 				delete dlg;
 			});
 			break;
 		}
 		default:
 		{
 			if (Commands.ExecuteCallbacks(App, this, GetItem(), Cmd))
 				return true;
 			
 			return false;
 		}
 	}
 
 	return true;
 }
 
 int MailUi::OnCommand(int Cmd, int Event, OsView From)
 {
 	if (GpgUi)
 	{
 		GpgUi->DoCommand(Cmd, [this, Cmd](auto r)
 		{
 			if (!r)
 				HandleCmd(Cmd);
 		});
 	}
 	else
 	{
 		HandleCmd(Cmd);
 	}
 
 	return LWindow::OnCommand(Cmd, Event, From);
 }
 
 LArray<Attachment*> Mail::GetCalendarAttachments()
 {
 	List<Attachment> Attachments;
 	if (!GetAttachments(&Attachments))
 		return false;
 
 	LArray<Attachment*> Cal;
 	for (auto a: Attachments)
 	{
 		LString Mt = a->GetMimeType();
 		if (Mt.Equals("text/calendar"))
 			Cal.Add(a);
 	}
 
 	return Cal;
 }
 
 bool MailUi::AddCalendarEvent(bool AddPopupReminder)
 {
 	LString Msg;
 	auto Result = GetItem()->AddCalendarEvent(this, AddPopupReminder, &Msg);
 
 	auto css = CalPanelStatus->GetCss(true);
 	if (Result) css->Color(LCss::ColorInherit);
 	else css->Color(LColour::Red);
 	CalPanelStatus->Name(Msg);
 
 	return Result;
 }
 
 
 bool Mail::AddCalendarEvent(LViewI *Parent, bool AddPopupReminder, LString *Msg)
 {
 	LString Err, s;
 	auto Cal = GetCalendarAttachments();
 	int NewEvents = 0, DupeEvents = 0, Processed = 0, Cancelled = 0, NotMatched = 0;
 	ScribeFolder *Folder = NULL;
 	if (Cal.Length() == 0)
 	{
 		Err = "There are no attached events to add.";
 		goto OnError;
 	}
 
 	Folder = App->GetFolder(FOLDER_CALENDAR);
 	if (!Folder)
 	{
 		Err = "There no calendar folder to save to.";
 		goto OnError;
 	}
 
 	for (auto a: Cal)
 	{
 		auto Event = App->CreateThingOfType(MAGIC_CALENDAR);
 		if (Event)
 		{
 			LString Mt = a->GetMimeType();
 			LAutoPtr<LStreamI> Data(a->GotoObject(_FL));
 			if (Data)
 			{
 				if (Event->Import(AutoCast(Data), Mt))
 				{
 					auto c = Event->IsCalendar();
 					auto obj = c ? c->GetObject() : NULL;
 					if (!obj)
 						continue;
 					
 					if (AddPopupReminder)
 					{
 						LString s;
 						s.Printf("%g,%i,%i,", 10.0, CalMinutes, CalPopup);
 						obj->SetStr(FIELD_CAL_REMINDERS, s);
 					}
 					
 					// Is it a cancellation?
 					auto Status = obj->GetStr(FIELD_CAL_STATUS);
 					auto IsCancel = Stristr(Status, "CANCELLED") != NULL;
 					if (!IsCancel)
 					{
 						// Does the folder already have a copy of this event?
 						bool AlreadyAdded = false;
 						for (auto t: Folder->Items)
 						{
 							auto Obj = t->IsCalendar();
 							if (Obj && *Obj == *c)
 							{
 								AlreadyAdded = true;
 								break;
 							}
 						}
 
 						if (AlreadyAdded)
 						{
 							DupeEvents++;
 						}
 						else
 						{
 							// Write the event to the folder
 							auto Status = Folder->WriteThing(Event);
 							if (Status > Store3Error)
 							{
 								NewEvents++;
 								Event = NULL;
 							}
 						}
 					}
 					else
 					{
 						// Cancellation processing
 						auto Uid = obj->GetStr(FIELD_UID);
 						Thing *Match = NULL;
 						for (auto t: Folder->Items)
 						{
 							auto tCal = t->IsCalendar();
 							if (tCal && tCal->GetObject())
 							{
 								auto tUid = tCal->GetObject()->GetStr(FIELD_UID);
 								if (!Stricmp(Uid, tUid))
 								{
 									Match = t;
 									break;
 								}
 							}
 						}
 						if (Match)
 						{
 							if (!Parent || LgiMsg(Parent, "Delete cancelled event?", "Calendar", MB_YESNO) == IDYES)
 							{
 								auto f = Match->GetFolder();
 								LArray<Thing*> items;
 								items.Add(Match);
 								f->Delete(items, true);
 								Cancelled++;
 							}
 						}
 						else NotMatched++;
 					}
 				}
 				else LgiTrace("%s:%i - vCal event import failed.\n", _FL);
 			}
 			else LgiTrace("%s:%i - GotoObject failed.\n", _FL);
 
 			if (Event)
 				Event->DecRef();
 		}
 		else LgiTrace("%s:%i - CreateThingOfType failed.\n", _FL);
 	}
 
 	Processed = NewEvents + DupeEvents;
 	if (Processed != Cal.Length())
 	{
 		Err.Printf("There were errors processing %i events, check the console.", (int)Cal.Length() - Processed);
 		goto OnError;
 	}
 
 	if (NewEvents || DupeEvents)
 		s.Printf("%i new events, %i duplicates.", NewEvents, DupeEvents);
 	else
 		s.Printf("%i events cancelled, %i not matched.", Cancelled, NotMatched);
 
 	if (Msg)
 		*Msg = s;
 
 	if (Processed > 0)
 	{
 		for (auto v: CalendarView::CalendarViews)
 			v->OnContentsChanged();
 	}
 
 	return true;
 
 OnError:
 	if (Msg)
 		*Msg = Err;
 	return false;
 }
 
 int MailUi::OnNotify(LViewI *Col, LNotification n)
 {
 	if (dynamic_cast<LPanel*>(Col))
 	{
 		Sx = Sy = -1;
 		OnPosChange();
 		return 0;
 	}
 
 	if (GpgUi)
 	{
 		if (n.Type == LNotifyItemDelete &&
 			Col == (LViewI*)GpgUi)
 		{
 			GpgUi = NULL;			
 		}
 		else
 		{
 			int r = GpgUi->OnNotify(Col, n);
 			if (r)
 				return r;
 		}
 	}	
 
 	int CtrlId = Col->GetId();
 	switch (CtrlId)
 	{
 		case IDC_MAIL_UI_TABS:
 		{
 			Mail *Item = GetItem();
 			if (!Item)
 				break;
 			// bool Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 			
 			if (n.Type == LNotifyValueChanged)
 			{
 				switch (Col->Value())
 				{
 					case 0: // Text tab
 					{
 						if (!TextLoaded)
 						{
 							Item->CreateView(this, sTextPlain, true, -1);
 							OnPosChange();
 						}
 						
 						if (CurrentEditCtrl == 1)
 						{
 							if (HtmlView &&
 								TextView &&
 								TextCtrlDirty)
 							{
 								// Convert HTML to Text here...
 								TextCtrlDirty = false;
 								auto Html = HtmlView->Name();
 								if (Html)
 								{
 									LString Txt = HtmlToText(Html, HtmlView->GetCharset());
 									if (Txt)
 										TextView->Name(Txt);
 								}
 							}
 
 							CurrentEditCtrl = 0;
 						}
 						break;
 					}
 					case 1: // Html tab
 					{
 						if (!HtmlLoaded)
 						{
 							Item->CreateView(this, sTextHtml, true, -1);
 							OnPosChange();
 						}
 
 						if (CurrentEditCtrl == 0)
 						{
 							if (HtmlView &&
 								TextView &&
 								HtmlCtrlDirty)
 							{
 								// Convert Text to HTML here...
 								HtmlCtrlDirty = false;
 								auto Text = TextView->Name();
 								if (Text)
 								{
 									LString Html = TextToHtml(Text, TextView->GetCharset());
 									if (Html)
 										HtmlView->Name(Html);
 								}
 							}
 
 							CurrentEditCtrl = 1;
 						}
 						break;
 					}
 					default: // Do nothing on other tabs..
 						break;
 				}
 			}
 			else if (n.Type == LNotifyItemClick)
 			{
 				LMouse m;
 				if (!Col->GetMouse(m))
 					break;
 				
 				int TabIdx = Tab->HitTest(m);
 				if (TabIdx == 0 || TabIdx == 1)
 				{
 					if (Item && m.IsContextMenu())
 					{
 						LSubMenu s;
 						s.AppendItem(LLoadString(IDS_DELETE), IDM_DELETE);
 						
 						m.ToScreen();
 						int Cmd = s.Float(this, m.x, m.y, false);
 						if (Cmd == IDM_DELETE)
 						{
 							if (TabIdx == 0) // Txt
 							{
 								Item->SetBody(NULL);
 								Item->SetBodyCharset(NULL);
 								TextView->Name(NULL);
 
 								if (TabText)
 								{
 									TabText->GetCss(true)->FontBold(false);
 									TabText->OnStyleChange();
 								}
 								TextCtrlDirty = false;
 							}
 							else // HTML
 							{
 								Item->SetHtml(NULL);
 								Item->SetHtmlCharset(NULL);
 								HtmlView->Name(NULL);
 
 								if (TabHtml)
 								{
 									TabHtml->GetCss(true)->FontBold(false);
 									TabHtml->OnStyleChange();
 								}
 								HtmlCtrlDirty = false;
 							}
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDC_FROM:
 		{
 			if (_Running &&
 				FromCbo &&
 				n.Type == LNotifyValueChanged)
 				SetDirty(true);
 			break;
 		}
 		case IDC_SHOW_FROM:
 		{
 			LVariant Show = Col->Value();;
 			App->GetOptions()->SetValue(OPT_MailShowFrom, Show);
 			break;
 		}
 		case IDC_LAUNCH_HTML:
 		{
 			char File[MAX_PATH_LEN];
 			if (GetItem() &&
 				GetItem()->WriteAlternateHtml(File))
 			{
 				LExecute(File);
 			}
 			break;
 		}
 		case IDC_ENTRY:
 		{
 			if (Entry)
 			{
 				if (ValidStr(Entry->Name()))
 				{
 					if (!Browse)
 					{
 						Browse = new AddressBrowse(App, Entry, To, SetTo);
 					}
 				}
 				if (Browse)
 				{
 					Browse->OnNotify(Entry, n);
 				}
 				
 				if (n.Type == LNotifyReturnKey)
 				{
 					OnDataEntered();
 				}
 			}
 			break;
 		}
 		case IDC_SET_TO:
 		{
 			if (SetTo)
 			{
 				AddMode = (int)SetTo->Value();
 			}
 			break;
 		}
 		case IDC_SEND:
 		{
 			OnCommand(IDM_SEND_MSG, 0,
 				#if LGI_VIEW_HANDLE
 				Col->Handle()
 				#else
 				(OsView)NULL
 				#endif
 				);
 			break;
 		}
 		#if SAVE_HEADERS
 		case IDC_INTERNET_HEADER: 
 		#endif
 		case IDC_TEXT_VIEW:
 		case IDC_HTML_VIEW:
 		{
 			Mail *Item = GetItem();
 			if (!Item)
 				break;
 			bool Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 
 			if
 			(
 				(
 					n.Type == LNotifyDocChanged
 					||
 					n.Type == LNotifyCharsetChanged
 					||
 					n.Type == LNotifyFixedWidthChanged
 					||
 					(!IgnoreShowImgNotify && n.Type == LNotifyShowImagesChanged)
 				)
 				&&
 				_Running
 			)
 			{
 				if (GetItem())
 					GetItem()->OnNotify(Col, n);
 				SetDirty(true);
 				
 				if (Edit)
 				{
 					if (CtrlId == IDC_TEXT_VIEW)
 					{
 						CurrentEditCtrl = 0;
 						HtmlCtrlDirty = true;						
 						TabText->GetCss(true)->FontBold(true);
 						TabText->OnStyleChange();
 					}
 					else if (CtrlId == IDC_HTML_VIEW)
 					{
 						CurrentEditCtrl = 1;
 						TextCtrlDirty = true;						
 						TabHtml->GetCss(true)->FontBold(true);
 						TabHtml->OnStyleChange();
 					}
 
 					// LgiTrace("%s:%i - OnNotify: TextLoaded=%i, HtmlLoaded=%i\n", _FL, TextLoaded, HtmlLoaded);
 				}
 			}
 			break;
 		}
 		case IDC_ATTACHMENTS:
 		{
 			if (n.Type == LNotifyItemInsert ||
 				n.Type == LNotifyItemDelete)
 			{
 				// fall thru
 			}
 			else
 			{
 				break;
 			}
 		}
 		case IDC_TO:
 		{
 			if
 			(
 				_Running
 				&&
 				(
 					n.Type == LNotifyItemInsert
 					||
 					n.Type == LNotifyItemDelete
 					||
 					n.Type == LNotifyItemChange
 				)
 			)
 			{
 				SetDirty(true);
 			}
 			break;
 		}
 		case IDC_COLOUR:
 		{
 			if (_Running && GetItem())
 			{
 				MetaFieldsDirty = true;
 				OnDirty(true);
 			}
 			break;
 		}
 		case IDC_LABEL:
 		{
 			if (_Running)
 			{
 				MetaFieldsDirty = true;
 				OnDirty(true);
 			}
 			break;
 		}
 		case IDC_SUBJECT:
 		{
 			if (_Running)
 			{
 				SetDirty(true);
 			}
 			break;
 		}
 		case IDCANCEL:
 		{
 			if (CmdAfterResize)
 			{
 				int Cmd = CmdAfterResize;
 				CmdAfterResize = 0;
 				IsWorking(false);		
 				
 				OnCommand(Cmd, 0, NULL);
 			}
 			break;
 		}
 		case IDC_ADD_CAL_EVENT:
 		{
 			AddCalendarEvent(false);
 			break;
 		}
 		case IDC_ADD_CAL_EVENT_POPUP:
 		{
 			AddCalendarEvent(true);
 			break;
 		}
 	}
 	return 0;
 }
 
 void MailUi::OnDataEntered()
 {
 	auto Name = Entry->Name();
 	if (ValidStr(Name))
 	{
 		List<AddressDescriptor> New;
 		
 		// Decode the entries
 		Mailto mt(App, Name);
 		New = mt.To;
 		mt.To.Empty();
 		
 		if (mt.Subject &&
 			!ValidStr(GetCtrlName(IDC_SUBJECT)))
 		{
 			SetCtrlName(IDC_SUBJECT, mt.Subject);
 		}
 
 		// Add the new entries
 		List<Contact> Cache;
 		App->GetContacts(Cache);
 		AddressDescriptor *ad;
 		while ((ad = New[0]))
 		{
 			New.Delete(ad);
 
 			ListAddr *t = dynamic_cast<ListAddr*>(ad);
 			if (t)
 			{
 				t->CC = (EmailAddressType)GetCtrlValue(IDC_SET_TO);
 				t->OnFind(&Cache);
 				To->Insert(t, 0);
 			}
 			else
 			{
 				DeleteObj(ad);
 			}
 		}
 
 		// Clear the entry box for the next one
 		Entry->Name("");
 		Entry->Select(-1, -1);
 	}
 }
 
 void MailUi::OnPosChange()
 {	
 	LWindow::OnPosChange();
 
 	if (Tab && (Sx != X() || Sy != Y()))
 	{
 		Sx = X();
 		Sy = Y();
 
 		LRect r = Tab->GetCurrent()->GetClient();
 		r.Inset(CONTENT_BORDER, CONTENT_BORDER);
 
 		if (TextView)
 			TextView->SetPos(r, true);
 
 		if (HtmlView)
 			HtmlView->SetPos(r, true);
 
 		if (Attachments)
 			Attachments->SetPos(r, true);
 
 		if (Header)
 			Header->SetPos(r, true);
 	}
 }
 
 void MailUi::OnPaint(LSurface *pDC)
 {
 	LCssTools Tools(this);
 	Tools.PaintContent(pDC, GetClient());
 }
 
 void MailUi::OnPulse()
 {
 	if (IsDirty() && TextView && GetItem())
 	{
 		// Ui -> Object
 		OnSave();
 		
 		// Object -> Disk
 		GetItem()->Save(0);
 	}
 	else
 	{
 		SetPulse();
 	}
 }
 
 void MailUi::OnDirty(bool Dirty)
 {
 	SetCtrlEnabled(IDM_SAVE, Dirty);
 	SetCtrlEnabled(IDM_SAVE_CLOSE, Dirty);
 	
 	if (Dirty)
 	{
 		SetPulse(60 * 1000); // every minute
 	}
 	else
 	{
 		SetPulse();
 	}
 }
 
 bool MailUi::CallMethod(const char *Name, LVariant *Dst, LArray<LVariant*> &Arg)
 {
 	ScribeDomType Method = StrToDom(Name);
 
 	*Dst = false;
 	switch (Method)
 	{
 		case SdShowRemoteContent: // Type: ()
 			if (HtmlView)
 			{
 				bool Always = Arg.Length() > 0 ? Arg[0]->CastBool() : false;
 				if (Always && GetItem())
 				{
 					auto From = GetItem()->GetFrom();
 					if (From)
 						App->RemoteContent_AddSender(From->GetStr(FIELD_EMAIL), true);
 					else
 						LgiTrace("%s:%i - No from address.\n", _FL);
 				}
 
 				IgnoreShowImgNotify = true;
 				HtmlView->SetLoadImages(true);
 				IgnoreShowImgNotify = false;
 				PostEvent(M_UPDATE);
 				*Dst = true;
 			}
 			break;
 		case SdSetHtml: // Type: (String Html)
 			if (HtmlView)
 			{
 				if (Arg.Length() > 0)
 				{
 					HtmlView->Name(Arg[0]->Str());
 					*Dst = true;
 				}
 			}
 			break;
 		default:
 			return false;
 	}
 	
 	return true;	
 }
 
 LMessage::Result MailUi::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_SET_HTML:
 		{
 			LAutoPtr<LString> s((LString*)Msg->A());
 			if (s && HtmlView)
 				HtmlView->Name(*s);
 			break;
 		}
 		case M_NEEDS_CAP:
 		{
 			LAutoString c((char*)Msg->A());
 			NeedsCapability(c);
 			return 0;
 		}
 		case M_RESIZE_IMAGE:
 		{
 			LAutoPtr<ImageResizeThread::Job> Job((ImageResizeThread::Job*)Msg->A());
 			if (Job && GetItem())
 			{
 				// Find the right attachment...
 				List<Attachment> Attachments;
 				if (GetItem()->GetAttachments(&Attachments))
 				{
 					Attachment *Match = NULL;
 					for (auto a: Attachments)
 					{
 						LString Nm = a->GetName();
 						if (Nm.Equals(Job->FileName))
 						{
 							Match = a;
 							break;
 						}
 					}
 					if (Match)
 					{
 						if (Job->Data)
 							Match->Set(Job->Data);
 						
 						auto Mt = Match->GetMimeType();
 						if (_stricmp(Mt, "image/jpeg"))
 						{
 							auto Name = Match->GetName();
 							char *Ext = LGetExtension(Name);
 							if (Ext)
 								*Ext = 0;
 							LString NewName = Name;
 							NewName += "jpg";
 							Match->SetName(NewName);
 							Match->SetMimeType("image/jpeg");
 						}
 						
 						Match->SetIsResizing(false);
 						
 						LDataI *AttachPoint = GetItem()->GetFileAttachPoint();
 						if (AttachPoint)
 						{
 							// Do final save to the mail store...
 							Match->GetObject()->Save(AttachPoint);
 						}
 						else
 						{
 							LAssert(0);
 							Match->DecRef();
 							Match = NULL;
 						}
 						
 						if (CmdAfterResize)
 						{
 							bool Working = IsWorking();
 							if (!Working)
 							{
 								// All resizing work is done...
 								OnCommand(CmdAfterResize, 0, NULL);
 								return 0;
 							}
 						}
 					}
 					else LAssert(!"No matching attachment image to store resized image in.");
 				}
 			}
 			break;
 		}
 		#if WINNATIVE
 		case WM_COMMAND:
 		{
 			LAssert((NativeInt)Commands.Toolbar != 0xdddddddd);
 
 			if (Commands.Toolbar && Commands.Toolbar->Handle() == (HWND)Msg->b)
 			{
 				return LWindow::OnEvent(Msg);
 			}
 			break;
 		}
 		#endif
 	}
 
 	return LWindow::OnEvent(Msg);
 }
 
 void MailUi::OnReceiveFiles(LArray<const char*> &Files)
 {
 	List<Attachment> Att;
 	GetItem()->GetAttachments(&Att);
 
 	for (unsigned i=0; i<Files.Length(); i++)
 	{
 		auto FileName = Files[i];
 		bool Add = true;
 		char Path[MAX_PATH_LEN];
 
 		if (!LResolveShortcut(FileName, Path, strlen(Path)))
 		{
 			strcpy_s(Path, sizeof(Path), FileName);
 		}
 
 		for (auto a: Att)
 		{
 			char *f = Path;
 			while (strchr(f, '\\'))
 			{
 				f = strchr(f, '\\') + 1;
 			}
 
 			if (_stricmp(a->GetName(), f) == 0)
 			{
 				int Result = LgiMsg(this, LLoadString(IDS_ATTACH_WARNING_DLG), LLoadString(IDS_ATTACHMENTS), MB_YESNO);
 				if (Result == IDNO)
 				{
 					Add = false;
 					break;
 				}
 			}
 		}
 
 		if (Add)
 		{
 			Attachment *a = GetItem()->AttachFile(this, Path);
 			if (a)
 			{
 				Attachments->Insert(a);
 				Attachments->ResizeColumnsToContent();
 			}
 		}
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 bool Mail::PreviewLines = false;
 bool Mail::RunMailPipes = true;
 List<Mail> Mail::NewMailLst;
 bool Mail::AdjustDateTz = true;
 LHashTbl<ConstStrKey<char>,Mail*> Mail::MessageIdMap;
 
 Mail::Mail(ScribeWnd *app, LDataI *object) : Thing(app, object)
 {
 	DefaultObject(object);
 	d = new MailPrivate(this);
 	_New();
 }
 
 Mail::~Mail()
 {
     if (GetObject())
     {
         auto Id = GetObject()->GetStr(FIELD_MESSAGE_ID);
         if (Id)
             MessageIdMap.Delete(Id);
     }
 
 	NewMailLst.Delete(this);
 	_Delete();
 	DeleteObj(d);
 }
 
 void Mail::_New()
 {
 	SendAttempts = 0;
 	Container = 0;
 	FlagsCache = -1;
 	PreviewCacheX = 0;
 	Cursor = 0;
 	ParentFile = 0;
 	PreviousMail = 0;
 	NewEmail = NewEmailNone;
 	
 	Ui = 0;
 	TotalSizeCache = -1;
 }
 
 void Mail::_Delete()
 {
 	if (ParentFile)
 	{
 		ParentFile->SetMsg(0);
 	}
 
 	UnloadAttachments();
 	PreviewCache.DeleteObjects();
 	DeleteObj(Container);
 
 	if (Ui)
 		Ui->PostEvent(M_CLOSE);
 	if (Ui)
 		Ui->SetItem(0);
 }
 
 bool Mail::AppendItems(LSubMenu *Menu, const char *Param, int Base)
 {
 	auto Remove = Menu->AppendSub(LLoadString(IDS_REMOVE));
 	if (Remove)
 	{
 		Remove->AppendItem("'>'", IDM_REMOVE_GRTH, true);
 		Remove->AppendItem("'> '", IDM_REMOVE_GRTH_SP, true);
 		Remove->AppendItem(LLoadString(IDS_HTML_TAGS), IDM_REMOVE_HTML, true);
 	}
 
 	auto FilterMenu = Menu->AppendSub(LLoadString(IDS_FILTER));
 	if (FilterMenu)
 	{
 		FilterMenu->SetImageList(App->GetIconImgList(), false);
 		Actions.Empty();
 		AddActions(FilterMenu, Actions, App->GetThingSources(MAGIC_FILTER));
 	}
 
 	auto Convert = Menu->AppendSub(LLoadString(IDS_CONVERT_SELECTION));
 	if (Convert)
 	{
 		Convert->AppendItem("To Base64", IDM_CONVERT_BIN_TO_B64, true);
 		Convert->AppendItem("To Binary", IDM_CONVERT_B64_TO_BIN, true);
 	}
 	
 	if (!TestFlag(GetFlags(), MAIL_CREATED))
 	{
 		auto Charset = Menu->AppendSub(LLoadString(L_CHANGE_CHARSET));
 		if (Charset)
 		{
 			int n=0;
 			for (LCharset *c = LGetCsList(); c->Charset; c++, n++)
 				Charset->AppendItem(c->Charset, IDM_CHARSET_BASE + n, c->IsAvailable());
 		}
 	}
 
 	return true;
 }
 
 bool Mail::OnMenu(LDocView *View, int Id, void *Context)
 {
 	const char *RemoveStr = 0;
 
 	switch (Id)
 	{
 		case IDM_REMOVE_GRTH:
 		{
 			RemoveStr = ">";
 			break;
 		}
 		case IDM_REMOVE_GRTH_SP:
 		{
 			RemoveStr = "> ";
 			break;
 		}
 		case IDM_REMOVE_HTML:
 		{
 			auto s = View ? View->Name() : 0;
 			if (s)
 			{
 				auto n = DeHtml(s);
 				if (n)
 				{
 					View->Name(n);
 					DeleteArray(n);
 				}
 			}
 			break;
 		}
 		default:
 		{
 			if (Id >= IDM_CHARSET_BASE)
 			{
 				int n=0;
 				LCharset *c;
 				for (c = LGetCsList(); c->Charset; c++, n++)
 				{
 					if (Id - IDM_CHARSET_BASE == n)
 					{
 						break;
 					}
 				}
 				if (c->Charset)
 				{
 					SetBodyCharset((char*)c->Charset);
 					SetDirty();
 					if (GetBodyCharset() && Ui)
 					{
 						Ui->OnLoad();
 					}
 				}
 			}
 			else if (Id >= IDM_FILTER_BASE)
 			{
 				Filter *Action = Actions[Id-IDM_FILTER_BASE];
 				if (Action)
 				{
 					// Save the message...
 					SetDirty(false);
 
 					// Hide the mail window...
 					if (Ui) Ui->Visible(false);
 
 					// Do the action
 					bool Stop;
 					Mail *This = this;
 					Action->DoActions(This, Stop);
 					if (This != this)
 						break;
 
 					if (Ui) DeleteObj(Ui);
 
 					return true;
 				}
 			}
 			break;
 		}
 		#ifdef _DEBUG
 		case IDM_CONVERT_BIN_TO_B64:
 		{
 			char *t = View->GetSelection();
 			if (t)
 			{
 				size_t In = strlen(t);
 				size_t Len = BufferLen_BinTo64(In);
 				char *B64 = new char[Len+1];
 				if (B64)
 				{
 					ConvertBinaryToBase64(B64, Len, (uchar*)t, In);
 					B64[Len] = 0;
 
 					char Temp[256];
 					ConvertBase64ToBinary((uchar*)Temp, sizeof(Temp), B64, Len);
 
 					char16 *Str = Utf8ToWide(B64);
 					if (Str)
 					{
 						LTextView3 *Tv = dynamic_cast<LTextView3*>(View);
 						if (Tv)
 						{
 							Tv->DeleteSelection();
 							Tv->Insert(Tv->GetCaret(), Str, Len);
 						}
 						DeleteArray(Str);
 					}
 					DeleteArray(B64);
 				}
 			}
 			break;
 		}
 		case IDM_CONVERT_B64_TO_BIN:
 		{
 			char *t = View->GetSelection();
 			if (t)
 			{
 				size_t In = strlen(t);
 				size_t Len = BufferLen_64ToBin(In);
 				char *Bin = new char[Len+1];
 				if (Bin)
 				{
 					ssize_t Out = ConvertBase64ToBinary((uchar*)Bin, Len, t, In);
 					Bin[Out] = 0;
 
 					char16 *Str = Utf8ToWide(Bin, Out);
 					if (Str)
 					{
 						LTextView3 *Tv = dynamic_cast<LTextView3*>(View);
 						if (Tv)
 						{
 							Tv->DeleteSelection();
 							Tv->Insert(Tv->GetCaret(), Str, Out);
 						}
 						DeleteArray(Str);
 					}
 					DeleteArray(Bin);
 				}
 			}
 			break;
 		}
 		#endif
 	}
 
 	if (RemoveStr)
 	{
 		size_t TokenLen = strlen(RemoveStr);
 		auto s = View ? View->Name() : 0;
 		if (s)
 		{
 			LMemQueue Temp;
 			auto Start = s;
 			const char *End;
 
 			while (*Start)
 			{
 				// seek to EOL
 				for (End = Start; *End && *End != '\n'; End++);
 				End++;
 				ssize_t Len = End - Start;
 
 				if (_strnicmp(Start, RemoveStr, TokenLen) == 0)
 				{
 					Temp.Write((uchar*)Start + TokenLen, Len - TokenLen);
 				}
 				else
 				{
 					Temp.Write((uchar*)Start, Len);
 				}
 
 
 				Start = End;
 			}
 
 			int Size = (int)Temp.GetSize();
 			char *Buf = new char[Size+1];
 			if (Buf)
 			{
 				Temp.Read((uchar*) Buf, Size);
 				Buf[Size] = 0;
 				View->Name(Buf);
 				DeleteArray(Buf);
 			}
 
 		}
 	}
 
 	return true;
 }
 
 LDocumentEnv::LoadType Mail::GetContent(LoadJob *&j)
 {
 	if (!j)
 		return LoadError;
 
 	LUri Uri(j->Uri);
 	if
 	(
 		Uri.sProtocol &&
 		(
 			!_stricmp(Uri.sProtocol, "http") ||
 			!_stricmp(Uri.sProtocol, "https") ||
 			!_stricmp(Uri.sProtocol, "ftp")
 		)
 	)
 	{
 		// We don't check OPT_HtmlLoadImages here because it's done elsewhere:
 		// - ScribeWnd::CreateTextControl calls LHtml::SetLoadImages with the value from OPT_HtmlLoadImages
 		// - LTag::LoadImage checks LHtml::GetLoadImages
 		//
 		// If there is a remote job here, it's because it's probably whitelisted.			
 		if (!Worker)		
 			Worker = App->GetImageLoader();
 		if (!Worker)
 			return LoadError;
 
 		Worker->AddJob(j);
 		j = 0;
 		return LoadDeferred;
 	}
 	else if (Uri.sProtocol && !_stricmp(Uri.sProtocol, "file"))
 	{
 		if (!_strnicmp(Uri.sPath, "//", 2))
 		{
 			// This seems to hang the windows CreateFile function...
 		}
 		else
 		{
 			// Is it a local file then?
 			if (j->pDC.Reset(GdcD->Load(Uri.sPath)))
 			{
 				return LoadImmediate;
 			}
 		}
 	}
 	else
 	{
 		List<Attachment> Files;
 		if (GetAttachments(&Files))
 		{
 			auto Dir = FilePart(j->Uri);
 			
 			Attachment *a = NULL;
 			for (auto It = Files.begin(); It != Files.end(); It++)
 			{
 				a = *It;
 
 				if (_strnicmp(j->Uri, "cid:", 4) == 0)
 				{
 					char *ContentId = j->Uri + 4;
 					auto AttachmentId = a->GetContentId();
 					if (AttachmentId)
 					{
 						if (AttachmentId[0] == '<')
 						{
 							auto s = AttachmentId + 1;
 							auto e = strrchr(s, '>');
 							if (e)
 							{
 								ssize_t len = e - s;
 								if (strlen(ContentId) == len &&
 									!strncmp(s, ContentId, len))
 									break;
 							}
 						}
 						else if (!strcmp(AttachmentId, ContentId))
 						{
 							break;
 						}
 					}
 				}
 				else
 				{
 					auto Name = a->GetName();
 					if (Name)
 					{
 						auto NameDir = FilePart(Name);
 						if (_stricmp(NameDir, Dir) == 0)
 						{
 							break;
 						}
 					}
 				}
 			}
 
 			if (a)
 			{
 				j->MimeType = a->GetMimeType();
 				j->ContentId = a->GetContentId();
 
 				if (j->Pref == LoadJob::FmtStream)
 				{
 					j->Filename = a->GetName();
 					j->Stream = a->GetObject()->GetStream(_FL);
 					return LoadImmediate;
 				}
 				else
 				{
 					char *Tmp = ScribeTempPath();
 					if (Tmp)
 					{
 						auto File = a->GetName();
 						auto Ext = LGetExtension(File);
 						char s[MAX_PATH_LEN] = "";
 						LString part;
 						do
 						{
 							if (part.Printf("%x.%s", LRand(), Ext) < 0)
 								return LoadError;
 							if (!LMakePath(s, sizeof(s), Tmp, part))
 								return LoadError;
 						}
 						while (LFileExists(s));
 
 						if (a->SaveTo(s, true))
 						{
 							if (j->Pref == LoadJob::FmtFilename)
 							{
 								j->Filename = s;
 								return LoadImmediate;
 							}
 							else
 							{
 								int Promote = GdcD->SetOption(GDC_PROMOTE_ON_LOAD, 0);
 								j->pDC.Reset(GdcD->Load(s));
 								j->Filename = a->GetName();
 								GdcD->SetOption(GDC_PROMOTE_ON_LOAD, Promote);
 								FileDev->Delete(s, false);
 								return LoadImmediate;
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	return LoadError;
 }
 
 class MailCapabilities : public LLayout
 {
     LArray<LAutoString> MissingCaps;
     LDocView *Doc;
     LButton *Install;
 
 public:
     MailCapabilities(LDocView *d)
     {
         Doc = d;
         Install = 0;
     }
     
 	const char *GetClass() { return "MailCapabilities"; }
 	
     void OnPosChange()
     {
         LRect c = GetClient();
         if (MissingCaps.Length())
         {
             if (!Install)
             {
                 if ((Install = new LButton(IDOK, 0, 0, -1, -1, "Install")))
                     Install->Attach(this);
             }
             
             LRect r = c;
             r.x1 = r.x2 - Install->X();
             r.y2 -= 7;
             Install->SetPos(r);
         }
     }
     
     void OnPaint(LSurface *pDC)
     {
         LRect cli = GetClient();
         if (MissingCaps.Length())
         {
             char Msg[256];
             int c = sprintf_s(Msg, sizeof(Msg), "This content requires ");
             for (unsigned i=0; i<MissingCaps.Length(); i++)
                 c += sprintf_s(Msg+c, sizeof(Msg)-c, "%s%s", i ? ", " : "", MissingCaps[i].Get());
             c += sprintf_s(Msg+c, sizeof(Msg)-c, " to display correctly");
             
             LDisplayString ds(LSysFont, Msg);
             LSysFont->Transparent(false);
             LSysFont->Colour(L_TEXT, L_MED);
             ds.Draw(pDC, cli.x1, cli.y1, &cli);
         }
         else
         {
             pDC->Colour(L_MED);
             pDC->Rectangle();
         }
     }
 };
 
 LDocView *Mail::CreateView(	MailViewOwner *Owner,
 							LString MimeType,
 							bool Sunken,
 							size_t MaxBytes,
 							bool NoEdit)
 {
 	bool Created = TestFlag(GetFlags(), MAIL_CREATED);
 	bool Edit = NoEdit ? false : Created;
 	bool ReadOnly = !Created;
 	bool DisabledLook = false;
 	LString TextMem;
 	LVariant DefAlt;
 	App->GetOptions()->GetValue(OPT_DefaultAlternative, DefAlt);
 
 	auto TextBody = GetBody();
 	auto TextCharset = GetBodyCharset();
 	
 	auto HtmlBody = GetHtml();
 	auto HtmlCharset = GetHtmlCharset();
 
 	const char *CtrlType = NULL;
 
 	if (!MimeType)
 	{
 		bool TextValid = TextBody != NULL;
 		bool HtmlValid = HtmlBody != NULL;
 
 		if (TextValid && HtmlValid)
 			MimeType = DefAlt.CastInt32() ? sTextHtml : sTextPlain;
 		else if (TextValid)
 			MimeType = sTextPlain;
 		else if (HtmlValid)
 			MimeType = sTextHtml;
 		else
 		{
 			auto rootSeg = GetObject()->GetObj(FIELD_MIME_SEG);
 			if (rootSeg)
 				MimeType = rootSeg->GetStr(FIELD_MIME_TYPE);
 			if (!MimeType)
 				return NULL;
 
 			// This is the 'multipart/encrypted' case here...
 			TextMem.Printf("'%s' content.", MimeType.Get());
 			TextBody = TextMem;
 			DisabledLook = ReadOnly = true;
 		}
 	}
 	
 	#ifdef WINDOWS
 	if (DefAlt.CastInt32() == 2 && MimeType == sTextHtml)
 		CtrlType = sApplicationInternetExplorer;
 	else
 	#endif
 		CtrlType = MimeType;
 
 	const char *Content, *Charset;
 	if (MimeType == sTextHtml)
 	{
 		Content = HtmlBody;
 		Charset = HtmlCharset;
 	}
 	else
 	{
 		Content = TextBody;
 		Charset = TextCharset;
 	}
 
 	// Emoji check
 	LVariant NoEmoji;
 	App->GetOptions()->GetValue(OPT_NoEmoji, NoEmoji);
 
 	// Check if the control needs changing
 	LDocView *View = Owner->GetDoc(MimeType);
 	if (View)
 	{
 		const char *ViewMimeType = View->GetMimeType();
 		if (MimeType != ViewMimeType)
 		{
 			Owner->SetDoc(NULL, ViewMimeType);
 			View = NULL;
 		}
 	}
 
 	if (!View)
 	{
 		View = App->CreateTextControl(	MimeType == sTextHtml ? IDC_HTML_VIEW : IDC_TEXT_VIEW,
 										MimeType,
 										Edit,
 										this);
 	}
 
 	if (!View)
 		return NULL;
 
 	// Control setup
 	View->Sunken(Sunken);
 	View->SetReadOnly(ReadOnly);
 	View->SetEnv(this);
 
 	if (DisabledLook)
 	{
 		View->GetCss(true)->BackgroundColor(L_MED);
 		View->GetCss()->Color(L_LOW);
 	}
 	else
 	{
 		View->GetCss(true)->BackgroundColor(LCss::ColorInherit);
 		View->GetCss()->Color(LCss::ColorInherit);
 	}
 		
 	LVariant UseCid = true;
 	View->SetValue(LDomPropToString(HtmlImagesLinkCid), UseCid);
 		
 	LVariant LoadImages;
 	App->GetOptions()->GetValue(OPT_HtmlLoadImages, LoadImages);
 	bool AppLoadImages = LoadImages.CastInt32() != 0;
 	bool MailLoadImages = TestFlag(GetFlags(), MAIL_SHOW_IMAGES);
 	const char *SenderAddr = GetFrom() ? GetFrom()->GetStr(FIELD_EMAIL) : NULL;
 	auto SenderStatus = App->RemoteContent_GetSenderStatus(SenderAddr);
 		
 	View->SetLoadImages
 	(
 		SenderStatus != RemoteNeverLoad
 		&&
 		(
 			AppLoadImages ||
 			MailLoadImages ||
 			SenderStatus == RemoteAlwaysLoad
 		)
 	);
 
     // Attach control
 	Owner->SetDoc(View, MimeType);
 	LCharset *CsInfo = LGetCsInfo(Charset);
 
 	// Check for render scripts
 	LArray<LScriptCallback*> Renderers;
 	LString RenderMsg = "Rendering...";
 	if (App->GetScriptCallbacks(LRenderMail, Renderers))
 	{
 		for (auto r: Renderers)
 		{
 			LVirtualMachine Vm;
 				
 			LScriptArguments Args(&Vm);
 			Args.New() = new LVariant(App);
 			Args.New() = new LVariant(this);
 			Args.New() = new LVariant((void*)NULL);
 			bool Status = App->ExecuteScriptCallback(*r, Args);
 			Args.DeleteObjects();
 			if (Status)
 			{
 				auto Ret = Args.GetReturn();
 				if (Ret->IsString() || Ret->CastInt32())
 				{
 					if (Ret->IsString())
 						RenderMsg = Ret->Str();
 					d->Renderer.Reset(new MailRendererScript(this, r));
 					break;
 				}
 			}
 		}
 	}
 
 	if (d->Renderer)
 	{
 		LString Nm;
 		if (MimeType.Equals(sTextHtml))
 			Nm.Printf("<html><body>%s</body></html>", RenderMsg.Get());
 		else
 			Nm = RenderMsg;
 		View->Name(Nm);
 	}
 	else
 	{
 		// Send the data to the control
 		size_t ContentLen = Content ? strlen(Content) : 0;
 		Html1::LHtml *Html = dynamic_cast<Html1::LHtml*>(View);
 		if (MimeType.Equals(sTextHtml))
 		{
 			if (CsInfo)
 			{
 				int OverideDocCharset = *Charset == '>' ? 1 : 0;
 				View->SetCharset(Charset + OverideDocCharset);
 				if (Html)
 					Html->SetOverideDocCharset(OverideDocCharset != 0);
 			}
 			else
 			{
 				View->SetCharset(0);
 				if (Html)
 					Html->SetOverideDocCharset(0);
 			}
 
 			View->Name(Content);
 		}
 		else
 		{
 			LAutoPtr<uint32_t,true> Utf32((uint32_t*)LNewConvertCp("utf-32",
             														Content,
             														Charset ? Charset : (char*)"utf-8",
             														MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
 			if (Utf32)
 			{
 				int Len = 0;
 				while (Utf32[Len])
 					Len++;
 					
 				#if 0
 				LFile f;
 				if (f.Open("c:\\temp\\utf32.txt", O_WRITE))
 				{
 					uchar bom[4] = { 0xff, 0xfe, 0, 0 };
 					f.Write(bom, 4);
 					f.Write(Utf32, Len * sizeof(uint32));
 					f.Close();
 				}
 				#endif
 			}
 			
 			LAutoWString Wide;
 			Wide.Reset((char16*)LNewConvertCp(LGI_WideCharset,
 												Content,
 												Charset ? Charset : (char*)"utf-8",
 												MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
 			if (Wide)
 			{
 				View->NameW(Wide);
 			}
 			else
 			{
 				// Fall back... try and show something at least
 				LAutoString t(NewStr(Content, MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
 				if (t)
 				{
 					uint8_t *i = (uint8_t*)t.Get();
 					while (*i)
 					{
 						if (*i & 0x80)
 							*i &= 0x7f;
 						i++;
 					}
 					
 					View->Name(t);
 				}
 				else
 					View->NameW(0);
 			}
 
 			View->SetFixedWidthFont(TestFlag(GetFlags(), MAIL_FIXED_WIDTH_FONT));
 		}
 	}
 
 	return View;
 }
 
 bool Mail::OnNavigate(LDocView *Parent, const char *Uri)
 {
 	if (Uri)
 	{
 		if
 		(
 			_strnicmp(Uri, "mailto:", 7) == 0
 			||
 			(
 				strchr(Uri, '@')
 				&&
 				!strchr(Uri, '/')
 			)
 		)
 		{
 			// Mail address
 			return App->CreateMail(0, Uri, 0) != 0;
 		}
 		else
 		{
 			return LDefaultDocumentEnv::OnNavigate(Parent, Uri);
 		}
 	}
 
 	return false;
 }
 
 void Mail::Update()
 {
 	TotalSizeCache = -1;
 	LListItem::Update();
 }
 
 LString::Array ParseIdList(const char *In)
 {
 	LString::Array result;
 
     if (!In)
         return result;
         
     while (*In && strchr(WhiteSpace, *In))
         In++;
 
     if (*In == '<')
     {
         // Standard msg-id list..
 	    for (auto s = In; s && *s; )
 	    {
 		    s = strchr(s, '<');
 		    if (!s)
 				break;
 		    while (*s == '<') s++;
 
             char *e = strchr(s, '>');
             if (e)
             {
 	            result.New().Set(s, e-s);
 	            s = e + 1;
             }
             else break;
 	    }
     }
     else
     {
         // Non compliant msg-id list...
         const char Delim[] = ", \t\r\n";
 	    for (auto s = In; s && *s; )
 	    {
 	        if (strchr(Delim, *s))
 	            s++;
 		    else
 		    {
 	            auto Start = s;
 
 	            while (*s && !strchr(Delim, *s))
 	                s++;
 	            
 				result.New().Set(Start, s - Start);
 		    }
 	    }
 	}
 
 	return result;
 }
 
 void Base36(char *Out, uint64 In)
 {
 	while (In)
 	{
 		int p = (int)(In % 36);
 		if (p < 10)
 		{
 			*Out++ = '0' + p;
 		}
 		else
 		{
 			*Out++ = 'A' + p - 10;
 		}
 		In /= 36;
 	}
 
 	*Out++ = 0;
 }
 
 void Mail::ClearCachedItems()
 {
 	TotalSizeCache = -1;
 	PreviewCacheX = -1;
 	PreviewCache.DeleteObjects();
 
 	Attachment *a;
 	int i = 0;
 	while ((a = Attachments[i]))
 	{
 		if (!a->DecRef())
 			i++;
 	}
 }
 
 void Mail::NewRecipient(char *Email, char *Name)
 {
 	LDataPropI *a = GetTo()->Create(GetObject()->GetStore());
 	if (a)
 	{
 		a->SetStr(FIELD_EMAIL, Email);
 		a->SetStr(FIELD_NAME, Name);
 		GetTo()->Insert(a);
 	}
 }
 
 void Mail::PrepSend()
 {
 	// Set flags and other data
 	SetDirty();
 
 	int OldFlags = GetFlags();
 	SetFlags((OldFlags | MAIL_READY_TO_SEND) & ~MAIL_SENT); // we want to send now...
 
 	// Check we're in the Outbox
 	ScribeFolder *OutBox = App->GetFolder(FOLDER_OUTBOX, GetObject());
 	if (OutBox)
 	{
 		ScribeFolder *f = GetFolder();
 		if (!f || f != OutBox)
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			OutBox->MoveTo(Items, false);
 		}
 	}
 }
 
 bool Mail::Send(bool Now)
 {
 	// Check for any "on before send" callbacks:
 	bool AllowSend = true;
 	LArray<LScriptCallback*> Callbacks;
 	if (App->GetScriptCallbacks(LMailOnBeforeSend, Callbacks))
 	{
 		for (unsigned i=0; AllowSend && i<Callbacks.Length(); i++)
 		{
 			LScriptCallback &c = *Callbacks[i];
 			if (c.Func)
 			{
 				LVirtualMachine Vm;
 				
 				LScriptArguments Args(&Vm);
 				Args.New() = new LVariant(App);
 				Args.New() = new LVariant(this);
 				if (App->ExecuteScriptCallback(c, Args))
 				{
 					if (!Args.GetReturn()->CastInt32())
 						AllowSend = false;
 				}
 
 				Args.DeleteObjects();
 			}
 		}
 	}
 	
 	if (!AllowSend)
 		return false;
 
 	// Set the ready to send flag..
 	bool IsInPublicFolder = GetFolder() && GetFolder()->IsPublicFolders();
 	if (!IsInPublicFolder)
 	{
 		PrepSend();
 
 		if (Now)
 		{
 			// Kick off send thread if relevant
 			LVariant Offline;
 			App->GetOptions()->GetValue(OPT_WorkOffline, Offline);
 			if (!Offline.CastInt32() && !IsInPublicFolder)
 			{
 				App->PostEvent(M_COMMAND, IDM_SEND_MAIL, (LMessage::Param)Handle());
 			}
 		}
 	}
 
 	return true;
 }
 
 bool Mail::MailMessageIdMap(bool Add)
 {
     if (Add)
     {
 		auto LoadState = GetLoaded();
 		if (LoadState < Store3Headers)
 		{
 			LAssert(!"Not loaded yet.");
 			LStackTrace("MailMessageIdMap msg not loaded yet: %i\n", LoadState);
 			return false;
 		}
 
 		// char *ObjId = GetObject()->GetStr(FIELD_MESSAGE_ID);
 		auto Id = GetMessageId(true);
 		if (!Id)
 		{
 			LAssert(!"No message ID? Impossible!");
 			GetMessageId(true);
 			return false;
 		}
 
 		#if 0
 		LgiTrace("MailMessageIdMap(%i) Old=%s Id=%s Mail=%p\n", Add, ObjId, Id, this);
 		#endif
 		return MessageIdMap.Add(Id, this);
     }
     else
     {
         auto Id = GetMessageId();
     	#if 0
         LgiTrace("MailMessageIdMap(%i) Id=%s Mail=%p\n", Add, Id, this);
         #endif
         return MessageIdMap.Delete(Id);
     }
 }
 
 Mail *Mail::GetMailFromId(const char *Id)
 {
     Mail *m = MessageIdMap.Find(Id);
     // LgiTrace("GetMailFromId(%s)=%p\n", Id, m);
     return m;
 }
 
 bool Mail::SetMessageId(const char *MsgId)
 {
 	if (LAppInst->InThread())
 	{
         LAssert(GetObject() != NULL);
         
         auto OldId = GetObject()->GetStr(FIELD_MESSAGE_ID);
 		if (OldId)
 		    MessageIdMap.Delete(OldId);
 
 		LAutoString m(NewStr(MsgId));
 		LAutoString s(TrimStr(m, "<>"));
 		if (GetObject()->SetStr(FIELD_MESSAGE_ID, s))
 			SetDirty();
 			
 		return s != 0;
 	}
 	else
 	{
 		// No no no NO NON NOT NADA.
 		LAssert(0);
 	}
 
 	return false;
 }
 
 LAutoString Mail::GetThreadIndex(int TruncateChars)
 {
     LAutoString Id;
     LAutoString Raw(InetGetHeaderField(GetInternetHeader(), "Thread-Index"));
     if (Raw)
     {
         Id = ConvertThreadIndex(Raw, TruncateChars);
     }
     
     return Id;
 }
 
 const char *Mail::GetMessageId(bool Create)
 {
     LAssert(GetObject() != NULL);
  	
  	d->MsgIdCache = GetObject()->GetStr(FIELD_MESSAGE_ID);
  	if (!d->MsgIdCache)
 	{
 		bool InThread = GetCurrentThreadId() == LAppInst->GetGuiThreadId();
 
 		LAutoString Header(InetGetHeaderField(GetInternetHeader(), "Message-ID"));
 		if (Header)
 		{
 			LAssert(InThread);
 			if (InThread)
 			{
 				auto Ids = ParseIdList(Header);
 				SetMessageId(d->MsgIdCache = Ids[0]);
 			}
 		}
 
 		if (!d->MsgIdCache && Create)
 		{
 			LAssert(InThread);
 			
 			if (InThread)
 			{
 				auto FromEmail = GetFromStr(FIELD_EMAIL);
 				const char *At = FromEmail ? strchr(FromEmail, '@') : 0;
 				LVariant Email;
 				if (!At)
 				{
 					if (App->GetOptions()->GetValue(OPT_Email, Email) && Email.Str())
 					{
 						At = strchr(Email.Str(), '@');
 					}
 					else
 					{
 						At = "@domain.com";
 					}
 				}
 				
 				if (At)
 				{
 					char m[96], a[32], b[32];
 					Base36(a, LCurrentTime());
 					Base36(b, LRand(RAND_MAX));
 					sprintf_s(m, sizeof(m), "<%s.%i%s%s>", a, LRand(RAND_MAX), b, At);
 					if (GetObject()->SetStr(FIELD_MESSAGE_ID, m))
 						SetDirty();
 					
 				 	d->MsgIdCache = GetObject()->GetStr(FIELD_MESSAGE_ID);
 				}
 				else LgiTrace("%s:%i - Error, no '@' in %s.\n", _FL, FromEmail);
 			}
 			else LgiTrace("%s:%i - Error, not in thread.\n", _FL);
 		}
 	}
 	else
 	{
 		d->MsgIdCache = d->MsgIdCache.Strip("<>").Strip();
 	}
 
 	LAssert
 	(
 		(!d->MsgIdCache && !Create)
 		||
 		(d->MsgIdCache && !strchr(d->MsgIdCache, '\n'))
 	);
 
 	return d->MsgIdCache;
 }
 
 bool Mail::GetReferences(LString::Array &Ids)
 {
 	LAutoString References(InetGetHeaderField(GetInternetHeader(), "References"));
 	if (References)
 	{
 		Ids = ParseIdList(References);
 	}
 
 	LAutoString InReplyTo(InetGetHeaderField(GetInternetHeader(), "In-Reply-To"));
 	if (InReplyTo)
 	{
 		auto To = ParseIdList(InReplyTo);
 		
 		bool Has = false;
 		auto &r = To[0];
 		if (r)
 		{
 		    for (auto h: Ids)
 		    {
 		        if (!strcmp(h, r))
 		            Has = true;
 		    }
     		
 		    if (!Has)
 		    {
 			    To.Delete(r);
 			    Ids.New() = r;
 		    }
 		}
 		
 		To.DeleteArrays();
 	}
 	
 	if (Ids.Length() == 0)
 	{
 	    LAutoString Id = GetThreadIndex(5);
         if (Id)
         {
             size_t Len = strlen(Id);
             size_t Bytes = Len >> 1;
             if (Bytes >= 22)
             {
                 Ids.New() = Id.Get();
             }
         }
 	}
 	
 	return Ids.Length() > 0;
 }
 
 LString AddrToHtml(LDataPropI *a)
 {
 	LString s;
 	if (a)
 	{
 		auto Name = a->GetStr(FIELD_NAME);
 		auto Addr = a->GetStr(FIELD_EMAIL);
 		LXmlTree t;
 		LAutoString eName(t.EncodeEntities(Name));
 		LAutoString eAddr(t.EncodeEntities(Addr));
 
 		if (Name && Addr)
 			s.Printf("<a href=\"mailto:%s\">%s</a>", eAddr.Get(), eName.Get());
 		else if (Name)
 			s = eName.Get();
 		else if (Addr)
 			s.Printf("<a href=\"mailto:%s\">%s</a>", eAddr.Get(), eAddr.Get());
 	}
 
 	return s;
 }
 
 LDataPropI *FindMimeSeg(LDataPropI *s, char *Type)
 {
 	if (!s)
 		return 0;
 
 	const char *Mt = s->GetStr(FIELD_MIME_TYPE);
 	if (!Mt) Mt = "text/plain";
 	if (!_stricmp(Type, Mt))
 		return s;
 
 	LDataIt c = s->GetList(FIELD_MIME_SEG);
 	if (!c)
 		return 0;
 
 	for (LDataPropI *i=c->First(); i; i=c->Next())
 	{
 		LDataPropI *Child = FindMimeSeg(i, Type);
 		if (Child)
 			return Child;
 	}
 
 	return 0;
 }
 
 bool Mail::GetAttachmentObjs(LArray<LDataI*> &Objs)
 {
 	if (!GetObject())
 		return false;
 
 	CollectAttachments(&Objs, NULL, NULL, NULL, GetObject()->GetObj(FIELD_MIME_SEG));
 	return Objs.Length() > 0;
 }
 
 void DescribeMime(LStream &p, LDataI *Seg)
 {
 	auto Mt = Seg->GetStr(FIELD_MIME_TYPE);
 	p.Print("%s", Mt);
 	auto Cs = Seg->GetStr(FIELD_CHARSET);
 	if (Cs) p.Print("&nbsp;-&nbsp;%s", Cs);
 	p.Print("<br>\n");
 
 	LDataIt c = Seg->GetList(FIELD_MIME_SEG);
 	if (c && c->First())
 	{
 		p.Print("<div style='padding-left:1em;'>\n");
 		for (LDataPropI *i=c->First(); i; i=c->Next())
 		{
 			LDataI *a = dynamic_cast<LDataI*>(i);
 			if (a)
 				DescribeMime(p, a);
 		}
 		p.Print("</div>\n");
 	}
 }
 
 bool Mail::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdFrom: // Type: ListAddr
 		{
 			Value = GetFrom();
 			break;
 		}
 		case SdFromHtml: // Type: String
 		{
 			LString s = AddrToHtml(GetFrom());
 			if (s.Length() == 0)
 				return false;
 			Value = s;
 			break;
 		}
 		case SdContact: // Type: Contact
 		{
 			if (!GetFrom())
 				return false;
 
 			auto Addr = GetFrom()->GetStr(FIELD_EMAIL);
 			if (!Addr)
 				return false;
 			
 			Contact *c = Contact::LookupEmail(Addr);
 			if (!c)
 				return App->GetVariant("NoContact", Value);
 
 			Value = (LDom*)c;
 			break;
 		}
 		case SdTo: // Type: ListAddr[]
 		{
 			if (Array)
 			{
 				LDataIt To = GetTo();
 
 				int Idx = atoi(Array);
 				bool Create = false;
 				if (Idx < 0)			
 				{
 					Create = true;
 					Idx = -Idx;
 				}
 
 				LDataPropI *a = Idx < (int)To->Length() ? (*To)[Idx] : 0;
 				if (!a && Create)
 				{
 					if ((a = To->Create(GetObject()->GetStore())))
 					{
 						To->Insert(a);
 					}
 				}
 
 				Value = a;
 			}
 			else if (Value.SetList())
 			{
 				LDataIt To = GetTo();
 				for (LDataPropI *a=To->First(); a; a=To->Next())
 				{
 					LVariant *Recip = new LVariant;
 					if (Recip)
 					{
 						*Recip = a;
 						Value.Value.Lst->Insert(Recip);
 					}
 				}
 			}
 			else return false;
 			break;
 		}
 		case SdToHtml: // Type: String
 		{
 			if (GetTo())
 			{
 				LStringPipe p;
 				for (LDataPropI *t=GetTo()->First(); t; t=GetTo()->Next())
 				{
 					if (p.GetSize())
 						p.Write((char*)", ", 2);
 					LString s = AddrToHtml(t); 
 					if (s)
 						p.Write(s, s.Length());
 				}
 				Value.Type = GV_STRING;
 				Value.Value.String = p.NewStr();
 			}
 			break;
 		}
 		case SdSubject: // Type: String
 		{
 			Value = GetSubject();
 			break;
 		}
 		case SdBody: // Type: String
 		{
 			if (Array)
 			{
 				auto Body = GetBody();
 				LAutoString h;
 
 				for (auto c = Body; c && *c; )
 				{
 					while (*c && strchr(WhiteSpace, *c)) c++;
 					auto Start = c;
 					while (*c && *c != ':' && *c != '\n') c++;
 					if (*c == ':')
 					{
 						if (Start[0] == '\"' && c[1] == '\"')
 							c++;
 
 						LString s(Start, c - Start);
 						s = s.Strip("\'\" \t[]<>{}:");
 						if (s.Equals(Array))
 						{
 							// Match...
 							c++;
 							while (*c && strchr(WhiteSpace, *c)) c++;
 							Start = c;
 							while (*c && *c != '\n') c++;
 							while (c > Start && strchr(WhiteSpace, c[-1])) c--;
 
 							h.Reset(NewStr(Start, c - Start));
 							break;
 						}
 						else
 						{
 							while (*c && *c != '\n')
 								c++;
 						}
 					}
 
 					if (*c == '\n')
 						c++;
 				}
 
 				if (h)
 				{
 					if (GetBodyCharset())
 					{
 						char *u = (char*)LNewConvertCp("utf-8", h, GetBodyCharset());
 						if (u)
 						{
 							Value.OwnStr(u);
 						}
 						else
 						{
 							Value.OwnStr(h.Release());
 						}
 					}
 					else
 					{
 						Value.OwnStr(h.Release());
 					}
 				}
 			}
 			else
 			{
 				Value = GetBody();
 			}
 			break;
 		}
 		case SdBodyAsText: // Type: String
 		{
 			size_t MaxSize = Atoi(Array);
 			auto Txt = GetBody();
 			auto Html = GetHtml();
 
 			if (ValidStr(Txt) && ValidStr(Html))
 			{
 				LVariant Def;
 				App->GetOptions()->GetValue(OPT_DefaultAlternative, Def);			
 				if (Def.CastInt32())
 				{
 					goto DoHtml;
 				}
 				goto DoText;
 			}
 			else if (ValidStr(Txt))
 			{
 				DoText:
 				LAutoString CharSet = GetCharSet();
 				if (CharSet)
 				{
 					size_t TxtLen = strlen(Txt);
 					Value.OwnStr((char*)LNewConvertCp("utf-8", Txt, CharSet, MIN(TxtLen, MaxSize)));
 				}
 				else
 					Value = Txt;
 			}
 			else if (ValidStr(Html))
 			{
 				DoHtml:
 				auto cs = GetHtmlCharset();
 				auto v = HtmlToText(Html, cs);
 				Value = v.Get();
 			}
 			else return false;
 			break;
 		}
 		case SdBodyAsHtml: // Type: String
 		{
 			// int MaxSize = ValidStr(Array) ? atoi(Array) : -1;
 
 			MailPrivate::HtmlBody *b = d->GetBody();
 			if (!b)
 				return false;
 			
 			LStringPipe p;
 			p.Print("<div class='%s'>\n%s\n</div>\n", ScribeReplyClass, b->Html.Get());
 			Value.OwnStr(p.NewStr());
 			LgiTrace("Value=%s\n", Value.Str());
 			break;
 		}
 		case SdHtmlHeadFields: // Type: String
 		{
 			MailPrivate::HtmlBody *b = d->GetBody();
 			if (!b)
 				return false;
 			
 			LStringPipe p;
 			if (ValidStr(b->Charset))
 				p.Print("\t<meta charset=\"%s\">\n", b->Charset.Get());
 
 			p.Print("\t<style>\n");
 			if (ValidStr(b->Styles))
 			{
 				// rewrite the style rules to change 'body' to 'div.scribe_reply'.
 				// Otherwise the source document's styles spill over into the edit
 				// section of the reply
 				const char *s = b->Styles;
 				LCss::Store Store;
 				if (Store.Parse(s))
 				{
 					LCss::SelArray *Body = Store.TypeMap.Find("body");
 					if (Body)
 					{
 						for (unsigned i=0; i<Body->Length(); i++)
 						{
 							LCss::Selector *Sel = (*Body)[i];
 							if (Sel)
 							{
 								for (unsigned p=0; p<Sel->Parts.Length(); p++)
 								{
 									LCss::Selector::Part &Part = Sel->Parts[p];
 									const char *sBody = "body";
 									if (Part.Type == LCss::Selector::SelType &&
 										Part.Value &&
 										!_stricmp(Part.Value, sBody))
 									{
 										Part.Value.Reset(NewStr("div"));
 										
 										LCss::Selector::Part cls;
 										cls.Type = LCss::Selector::SelClass;
 										cls.Value.Reset(NewStr(ScribeReplyClass));
 										Sel->Parts.AddAt(p + 1, cls);
 										break;
 									}
 								}
 							}
 						}
 					}
 					
 					// Output modified styles to the string buffer
 					Store.ToString(p);
 				}
 			}
 			
 			// Add our own styles at the end, overwriting source doc styles...
 			p.Print("\tdiv.%s { %s }\n",
 					ScribeReplyClass,
 					ScribeReplyStyles);
 					
 			p.Print("\t</style>");
 		
 			Value.OwnStr(p.NewStr());
 			break;
 		}
 		case SdMessageId: // Type: String
 		{
 			Value = GetMessageId();
 			return true;
 		}
 		case SdInternetHeaders: // Type: String
 		{
 			Value = GetInternetHeader();
 			break;
 		}
 		case SdInternetHeader: // Type: String[]
 		{
 			if (!Array || !GetInternetHeader())
 				return false;
 
 			LAutoString s(InetGetHeaderField(GetInternetHeader(), Array));
 			if (s)
 				Value = s;
 			else
 				Value.Empty();
 			break;
 		}
 		case SdPriority: // Type: Int32
 		{
 			Value = (int)GetPriority();
 			break;
 		}
 		case SdHtml: // Type: String
 		{
 			Value = GetHtml();
 			break;
 		}
 		case SdFlags: // Type: Int32
 		{
 			if (Array)
 			{
 				int Flag = StringToMailFlag(Array);
 				Value = (GetFlags() & Flag) != 0;
 			}
 			else
 			{
 				Value = (int)GetFlags();
 			}
 			break;
 		}
 		case SdFolder: // Type: ScribeFolder
 		{
 			ScribeFolder *f = GetFolder();
 			if (!f)
 				return false;
 			Value = (LDom*)f;
 			break;
 		}
 		case SdScribe: // Type: ScribeWnd
 		{
 			Value = (LDom*)App;
 			break;
 		}
 		case SdMail: // Type: Mail
 		{
 			Value = PreviousMail;
 			break;
 		}
 		case SdDateSent: // Type: DateTime
 		{
 			Value = GetDateSent();
 			break;
 		}
 		case SdDateReceived: // Type: DateTime
 		{
 			Value = GetDateReceived();
 			break;
 		}
 		case SdSig: // Type: String
 		{
 			bool Type = false;
 			if (Array && stristr(Array, "html"))
 				Type = true;
 			Value = GetSig(Type);
 			break;
 		}
 		case SdSize: // Type: Int64
 		{
 			Value = TotalSizeof();
 			break;
 		}
 		case SdLabel: // Type: String
 		{
 			Value = GetLabel();
 			break;
 		}
 		case SdAttachments: // Type: Int32
 		{
 			LArray<LDataI*> Lst;
 			GetAttachmentObjs(Lst);
 			Value = (int)Lst.Length();
 			break;
 		}
 		case SdAttachment: // Type: Attachment[]
 		{
 			List<Attachment> Files;
 			if (GetAttachments(&Files) && Array)
 			{
 				int i = atoi(Array);
 				Value = Files[i];
 				if (Value.Type == GV_DOM)
 					return true;
 			}
 			
 			LAssert(!"Not a valid attachment?");
 			return false;
 		}
 		case SdMimeTree: // Type: String
 		{
 			LDataI *Root = dynamic_cast<LDataI*>(GetObject()->GetObj(FIELD_MIME_SEG));
 			if (!Root)
 				return false;
 			
 			LStringPipe p(256);
 			DescribeMime(p, Root);
 			Value.OwnStr(p.NewStr());
 			break;
 		}
 		case SdUi: // Type: LView
 		{
 			Value = Ui;
 			break;
 		}
 		case SdType: // Type: Int32
 		{
 			Value = GetObject()->Type();
 			break;
 		}
 		case SdSelected: // Type: Bool
 		{
 			Value = Select();
 			break;
 		}
 		case SdRead: // Type: Bool
 		{
 			Value = (GetFlags() & MAIL_READ) != 0;
 			break;
 		}
 		case SdShowImages: // Type: Bool
 		{
 			Value = (GetFlags() & MAIL_SHOW_IMAGES) != 0;
 			break;
 		}
 		case SdColour: // Type: Int32
 		{
 			Value = GetMarkColour();
 			break;
 		}
 		case SdReceivedDomain: // Type: String
 		{
 			Value = GetFieldText(FIELD_RECEIVED_DOMAIN);
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 #define DomSetStr(Dom, Fld)							\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_STRING)		\
 			GetObject()->SetStr(Fld, Value.Str());		\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 #define DomSetInt(Dom, Fld)							\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_INT32)		\
 			GetObject()->SetInt(Fld, Value.Value.Int);	\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 #define DomSetDate(Dom, Fld)						\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_DATETIME)	\
 			GetObject()->SetDate(Fld, Value.Value.Date);	\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 bool Mail::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		DomSetStr(SdSubject, FIELD_SUBJECT)
 		DomSetStr(SdMessageId, FIELD_MESSAGE_ID)
 		DomSetStr(SdInternetHeaders, FIELD_INTERNET_HEADER)
 		DomSetInt(SdPriority, FIELD_PRIORITY)
 		DomSetDate(SdDateSent, FIELD_DATE_SENT)
 		DomSetDate(SdDateReceived, FIELD_DATE_RECEIVED)
 		case SdBody:
 		{
 			if (!SetBody(Value.Str()))
 				return false;
 			break;
 		}
 		case SdHtml:
 		{
 			if (!SetHtml(Value.Str()))
 				return false;
 			break;
 		}
 		case SdRead:
 		{
 			if (Value.CastInt32())
 				SetFlags(GetFlags() | MAIL_READ);
 			else
 				SetFlags(GetFlags() & ~MAIL_READ);
 			break;
 		}
 		case SdColour:
 		{
 			auto u32 = Value.IsNull() ? 0 : (uint32_t)Value.CastInt32();
 			if (!SetMarkColour(u32))
 				return false;
 			break;
 		}
 		case SdShowImages:
 		{
 			if (Value.CastInt32())
 				SetFlags(GetFlags() | MAIL_SHOW_IMAGES);
 			else
 				SetFlags(GetFlags() & ~MAIL_SHOW_IMAGES);
 			break;
 		}
 		case SdSelected:
 		{
 			Select(Value.CastInt32() != 0);
 			break;
 		}
 		case SdLabel:
 		{
 			if (!SetLabel(Value.Str()))
 				return false;
 			break;
 		}
 		case SdFlags:
 		{
 			if (Array)
 			{
 				int Flag = StringToMailFlag(Array);
 				if (Value.CastInt32())
 					// Set
 					SetFlags(GetFlags() | Flag);
 				else
 					SetFlags(GetFlags() & ~Flag);
 			}
 			else
 			{
 				SetFlags(Value.CastInt32());
 			}
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	SetDirty();
 	Update();
 	return true;
 }
 
 bool Mail::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType Fld = StrToDom(MethodName);
 	switch (Fld)
 	{
 		default:
 			break;
 		case SdSend: // Type: ([Bool SendNow = true])
 		{
 			bool Now = Args.Length() > 0 ? Args[0]->CastInt32() != 0 : true;
 			bool Result = Send(Now);
 			if (ReturnValue)
 				*ReturnValue = Result;
 			return true;
 		}
 		case SdAddCalendarEvent: // Type: ([Bool AddPopupReminder])
 		{
 			bool AddPopupReminder = Args.Length() > 0 ? Args[0]->CastInt32() != 0 : true;
 			bool Result = AddCalendarEvent(NULL, AddPopupReminder, NULL);
 			if (ReturnValue)
 				*ReturnValue = Result;
 			return true;
 		}
 		case SdGetRead: // Type: ()
 		{
 			*ReturnValue = (GetFlags() & MAIL_READ) != 0;
 			return true;
 		}
 		case SdSetRead: // Type: (Bool IsRead = true)
 		{
 			bool Rd = Args.Length() ? Args[0]->CastInt32() != 0 : true;
 			auto Flags = GetFlags();
 			if (Rd) SetFlags(Flags | MAIL_READ);
 			else SetFlags(Flags & ~MAIL_READ);
 			*ReturnValue = true;
 			return true;
 		}
 		case SdBayesianChange: // Type: (int SpamWordOffset, int HamWordOffset)
 		{
 			if (Args.Length() != 2)
 			{
 				LgiTrace("%s:%i - Invalid arg count, expecting (int SpamWordOffset, int HamWordOffset)\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto SpamWordOffset = Args[0]->CastInt32();
 			auto HamWordOffset = Args[1]->CastInt32();
 
 			if (SpamWordOffset > 1)
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailSpam);
 			else if (SpamWordOffset < 0)
 				App->OnBayesianMailEvent(this, BayesMailSpam, BayesMailUnknown);
 			
 			if (HamWordOffset > 1)
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailHam);
 			else if (HamWordOffset < 1)
 				App->OnBayesianMailEvent(this, BayesMailHam, BayesMailUnknown);
 			break;
 		}
 		case SdBayesianScore: // Type: ()
 		{
 			double Result;
 			if (App->IsSpam(Result, this))
 			{
 				*ReturnValue = Result;
 				return true;
 			}
 			break;
 		}
 		case SdSearchHtml: // Type: (String SearchExpression)
 		{
 			if (Args.Length() != 2)
 			{
 				LgiTrace("%s:%i - Method needs 1 argument.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto Html = GetHtml();
 			if (!Html)
 			{
 				LgiTrace("%s:%i - No HTML to parse.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 				
 			// auto Cs = GetHtmlCharset();
 			SearchHtml(ReturnValue, Html, Args[0]->Str(), Args[1]->Str());
 			return true;
 		}
 		case SdDeleteAsSpam: // Type: ()
 		{
 			DeleteAsSpam(App);
 			return true;
 		}
 	}
 	
 	return Thing::CallMethod(MethodName, ReturnValue, Args);
 }
 
 char *Mail::GetDropFileName()
 {
 	if (!DropFileName)
 	{
 		LString Subj = GetSubject();
 		Subj = Subj.Strip(" \t\r\n.");
 		DropFileName.Reset(MakeFileName(ValidStr(Subj) ? Subj.Get() : (char*)"Untitled", "eml"));
 	}
 	return DropFileName;
 }
 
 bool Mail::GetDropFiles(LString::Array &Files)
 {
 	if (!GetDropFileName())
 		return false;
 
 	if (!LFileExists(DropFileName))
 	{
 		LAutoPtr<LFile> F(new LFile);
 		if (F->Open(DropFileName, O_WRITE))
 		{
 			F->SetSize(0);
 			if (!Export(AutoCast(F), sMimeMessage))
 				return false;
 		}
 		else return false;
 	}
 
 	if (!LFileExists(DropFileName))
 		return false;
 
 	Files.Add(DropFileName.Get());
 	return true;
 }
 
 OsView Mail::Handle()
 {
 	return
 		#if LGI_VIEW_HANDLE
 		(Ui) ? Ui->Handle() :
 		#endif
 		NULL;
 }
 
 Thing &Mail::operator =(Thing &t)
 {
 	Mail *m = t.IsMail();
 	if (m)
 	{
 		#define CopyStr(dst, src) \
 			{ DeleteArray(dst); dst = NewStr(src); }
 			
 		/*
 		for (LDataPropI *a = m->GetTo()->First(); a; a = m->GetTo()->Next())
 		{
 			LDataPropI *NewA = GetTo()->Create(Object->GetStore());
 			if (NewA)
 			{
 				*NewA = *a;
 				GetTo()->Insert(NewA);
 			}
 		}
 		*/
 
 		if (GetObject() && m->GetObject())
 		{
 			GetObject()->CopyProps(*m->GetObject());
 		}
 		else LAssert(!"This shouldn't happen right?");
 
 		Update();
 	}
 
 	return *this;
 }
 
 bool Mail::HasAlternateHtml(Attachment **Attach)
 {
 	// New system of storing alternate HTML in a Mail object field.
 	if (GetHtml()) return true;
 
 	// Old way of storing alternate HTML, in an attachment.
 	// pre v1.53
 	List<Attachment> Files;
 	if (GetAttachments(&Files))
 	{
 		for (auto a: Files)
 		{
 			if ((_stricmp(a->GetText(0), "attachment.html") == 0 ||
 				_stricmp(a->GetText(0), "index.html") == 0) &&
 				(a->GetMimeType() ? _stricmp(a->GetMimeType(), "text/html") == 0 : 1))
 			{
 				if (Attach)
 				{
 					*Attach = a;
 				}
 
 				return true;
 			}
 		}
 	}
 
 	// None found
 	return false;
 }
 
 char *Mail::GetAlternateHtml(List<Attachment> *Refs)
 {
 	char *Status = 0;
 	Attachment *Attach = 0;
 	if (HasAlternateHtml(&Attach))
 	{
 		if (GetHtml())
 		{
 			// New system of storing alternate HTML in a Mail object field.
 			Status = NewStr(GetHtml());
 		}
 		else if (Attach)
 		{
 			// Old way of storing alternate HTML, in an attachment.
 			// pre v1.53
 			char *Ptr;
 			ssize_t Size;
 			if (Attach->Get(&Ptr, &Size))
 			{
 				Status = NewStr((char*)Ptr, Size);
 			}
 		}
 
 		if (Status && Refs)
 		{
 			// Turn all the cid: references into file names...
 			LStringPipe Out;
 			
 			char *n;
 			for (char *s=Status; *s; s=n)
 			{
 				n = stristr(s, "\"cid:");
 				if (n)
 				{
 					// Extract cid
 					n++;
 					Out.Push(s, n-s);
 					s = n += 4;
 					while (*n && !strchr("\"\' >", *n)) n++;
 					char *Cid = NewStr(s, n-s);
 					if (Cid)
 					{
 						// Find attachment
 						List<Attachment> Files;
 						if (GetAttachments(&Files))
 						{
 							for (auto a: Files)
 							{
 								if (a->GetContentId() &&
 									strcmp(a->GetContentId(), Cid) == 0)
 								{
 									Refs->Insert(a);
 									Out.Push(a->GetName());
 								}
 							}
 						}
 					}					
 				}
 				else
 				{
 					Out.Push(s);
 					break;
 				}
 			}
 
 			DeleteArray(Status);
 			Status = Out.NewStr();
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::WriteAlternateHtml(char *DstFile, int DstFileLen)
 {
 	bool Status = false;
 	char *Tmp = ScribeTempPath();
 
 	List<Attachment> Refs;
 	char *Html;
 	if (Tmp &&
 		(Html = GetAlternateHtml(&Refs)))
 	{
 		char FileName[256];
 
 		LMakePath(FileName, sizeof(FileName), Tmp, "Alt.html");
 		if (DstFile)
 		{
 			strcpy_s(DstFile, DstFileLen, FileName);
 		}
 
 		LFile f;
 		if (f.Open(FileName, O_WRITE))
 		{
 			size_t Len = strlen(Html);
 			Status = f.Write(Html, Len) == Len;
 			f.Close();
 		}
 
 		DeleteArray(Html);
 
 		for (auto a: Refs)
 		{
 			LMakePath(FileName, sizeof(FileName), Tmp, a->GetName());
 			FileDev->Delete(FileName, false);
 			a->SaveTo(FileName);
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::DeleteAttachment(Attachment *File)
 {
 	bool Status = false;
 	if (File)
 	{
 		if (Attachments.HasItem(File))
 		{
 			Attachments.Delete(File);
 			if (File->GetObject())
 			{
 				auto r = File->GetObject()->Delete();
 				if (r > Store3Error)
 				{
 					auto o = File->GetObject();
 					if (o->IsOrphan())
 						o = NULL; // SetObject will delete...
 					File->SetObject(NULL, false, _FL);
 					DeleteObj(o);
 				}
 			}
 
 			File->DecRef();
 			File = NULL;
 
 			if (Attachments.Length() == 0)
 			{
 				// Remove attachments flag
 				SetFlags(GetFlags() & (~MAIL_ATTACHMENTS));
 			}
 
 			Update();
 
 			if (Ui)
 			{
 				Ui->OnAttachmentsChange();
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::UnloadAttachments()
 {
 	for (auto it = Attachments.begin(); it != Attachments.end(); )
 	{
 		Attachment *a = *it;
 		if (!a->DecRef())
 			it++;
 	}
 
 	return true;
 }
 
 LArray<Attachment*> Mail::GetAttachments()
 {
 	LArray<Attachment*> result;
 
 	LArray<LDataI*> Lst;
 	if (GetAttachmentObjs(Lst))
 	{
 		LHashTbl<PtrKey<LDataI*>, bool> Loaded;
 		for (size_t i=0; i<Attachments.Length(); i++)
 		{
 			Loaded.Add(Attachments[i]->GetObject(), true);
 		}
 
 		// Load attachments
 		for (unsigned i=0; i<Lst.Length(); i++)
 		{
 			LDataI *Att = Lst[i];
 			if (!Loaded.Find(Att))
 			{
 				Attachment *k = new Attachment(App, Att);
 				if (k)
 				{
 					k->SetOwner(this);
 					Attachments.Insert(k);
 				}
 			}
 		}
 	}
 
 	for (auto a: Attachments)
 	{
 		if (a->GetObject()->UserData != a)
 			LAssert(!"Wut?");
 		else
 			result.Add(a);
 	}
 	
 	return result;
 }
 
 bool Mail::GetAttachments(List<Attachment> *Files)
 {
 	if (!Files)
 		return false;
 	auto files = GetAttachments();
 	for (auto a: files)
 		Files->Add(a);
 	return true;
 }
 
 int64 Mail::TotalSizeof()
 {
 	if (TotalSizeCache < 0)
 	{
 		int Size = GetObject() ? (int)GetObject()->GetInt(FIELD_SIZE) : -1;
 		if (Size >= 0)
 		{
 			TotalSizeCache = Size;
 		}
 		else
 		{
 			TotalSizeCache =	((GetBody()) ? strlen(GetBody()) : 0) +
 								((GetHtml()) ? strlen(GetHtml()) : 0);
 
 			List<Attachment> Attachments;
 			if (GetAttachments(&Attachments))
 			{
 				for (auto a: Attachments)
 				{
 					TotalSizeCache += a->GetSize();
 				}
 			}
 		}
 	}
 
 	return TotalSizeCache;
 }
 
 bool Mail::_GetListItems(List<LListItem> &l, bool All)
 {
 	LList *ParentList = LListItem::Parent;
 
 	l.Empty();
 
 	if (All)
 	{
 		if (ParentList)
 		{
 			ParentList->GetAll(l);
 		}
 		else
 		{
 			l.Insert(this);
 		}
 	}
 	else
 	{
 		if (ParentList)
 		{
 			ParentList->GetSelection(l);
 		}
 		else if (Select())
 		{
 			l.Insert(this);
 		}
 	}
 
 	return l.Length() > 0;
 }
 
 void Mail::GetThread(List<Mail> &Thread)
 {
 	MContainer *c;
 	for (c=Container; c->Parent; c=c->Parent);
 	List<MContainer> Stack;
 	Stack.Insert(c);
 	while ((c=Stack[0]))
 	{
 		Stack.Delete(c);
 		
 		for (unsigned i=0; i<c->Children.Length(); i++)
 		    Stack.Insert(c->Children[i]);
 		
 		if (c->Message && !Thread.HasItem(c->Message))
 		{
 			Thread.Insert(c->Message);
 		}
 	}
 }
 
 void Mail::SetListRead(bool Read)
 {
 	List<LListItem> Sel;
 	if (!_GetListItems(Sel, false))
 		return;
 
 	LArray<LDataI*> a;
 	for (auto t: Sel)
 	{
 		auto m = dynamic_cast<Mail*>(t);
 		if (!m)
 			continue;
 
 		bool isRead = (m->GetFlags() & MAIL_READ) != 0;
 		if (Read ^ isRead)
 			a.Add(m->GetObject());
 	}
 
 	if (!a.Length())
 		return;
 
 	auto Store = a[0]->GetStore();
 	if (!Store)
 	{
 		LAssert(0);
 		return;
 	}
 
 	LVariant read = MAIL_READ;
 	Store->Change(a, FIELD_FLAGS, read, Read ? OpPlusEquals : OpMinusEquals);
 }
 
 void SetFolderCallback(LInput *Dlg, LViewI *EditCtrl, void *Param)
 {
 	ScribeWnd *App = (ScribeWnd*) Param;
 	auto Str = EditCtrl->Name();
 	auto Select = new FolderDlg(Dlg, App, MAGIC_MAIL, 0, Str);
 	Select->DoModal([Select, EditCtrl](auto dlg, auto id)
 	{
 		if (id)
 			EditCtrl->Name(Select->Get());
 		delete dlg;
 	});
 }
 
 void Mail::DoContextMenu(LMouse &m, LView *p)
 {
 	#ifdef _DEBUG
 	LAutoPtr<LProfile> Prof(new LProfile("Mail::DoContextMenu"));
 	Prof->HideResultsIfBelow(100);
 	#endif
 	
 	if (!p)
 		p = Parent;
 
 	// open the right click menu
 	MarkedState MarkState = MS_None;
 	
 	// Pre-processing for marks
 	List<LListItem> Sel;
 	if (_GetListItems(Sel, false))
 	{
 		int Marked = 0;
 		for (auto t: Sel)
 		{
 			Mail *m = dynamic_cast<Mail*>(t);
 			if (m)
 			{
 				if (m->GetMarkColour())
 				{
 					Marked++;
 				}
 			}
 		}
 
 		if (Marked == 1)
 		{
 			MarkState = MS_One;
 		}
 		else if (Marked)
 		{
 			MarkState = MS_Multiple;
 		}
 	}
 
 	#ifdef _DEBUG
 	Prof->Add("CreateMenu");
 	#endif
 
 	// Create menu
 	LScriptUi s(new LSubMenu);
 	if (s.Sub)
 	{
 		/*
 		Keyboard shortcuts:
 
 		o - Open
 		d - Delete
 		x - Export
 		e - Set read
 		u - Set unread
 		r - Reply
 		a - Reply all
 		f - Forward
 		b - Bounce
 		m - Mark
 		s - Select marked
 		c - Create filter
 		i - Inspect
 		p - Properties
 		
 		*/
 		LMenuItem *i;
 		s.Sub->SetImageList(App->GetIconImgList(), false);
 
 		s.Sub->AppendItem(LLoadString(IDS_OPEN), IDM_OPEN, true);
 		i = s.Sub->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE, true);
 		i->Icon(ICON_TRASH);
 		s.Sub->AppendItem(LLoadString(IDS_EXPORT), IDM_EXPORT, true);
 		int AttachBaseMsg = 10000;
 
 		#ifdef _DEBUG
 		Prof->Add("GetAttachments");
 		#endif
 
 		List<Attachment> AttachLst;
 		if (GetAttachments(&AttachLst) &&
 			AttachLst[0])
 		{
 			LSubMenu *Attachments = s.Sub->AppendSub(LLoadString(IDS_SAVE_ATTACHMENT_AS));
 			if (Attachments)
 			{
 				int n=0;
 				for (auto a: AttachLst)
 				{
 					auto Name = a->GetName();
 					Attachments->AppendItem(Name?Name:(char*)"Attachment.txt", AttachBaseMsg+(n++), true);
 				}
 			}
 		}
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Read/Unread");
 		#endif
 
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_SET_READ), 'e'), IDM_SET_READ, true);
 		i->Icon(ICON_READ_MAIL);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_SET_UNREAD), 'u'), IDM_SET_UNREAD, true);
 		i->Icon(ICON_UNREAD_MAIL);
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Reply/Bounce");
 		#endif
 
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_REPLY), 'r'), IDM_REPLY, true);
 		i->Icon(ICON_FLAGS_REPLY);
 		s.Sub->AppendItem(AddAmp(LLoadString(IDS_REPLYALL), 'a'), IDM_REPLY_ALL, true);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_FORWARD), 'f'), IDM_FORWARD, true);
 		i->Icon(ICON_FLAGS_FORWARD);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_BOUNCE), 'b'), IDM_BOUNCE, true);
 		i->Icon(ICON_FLAGS_BOUNCE);
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Thread");
 		#endif
 
 		if (App->GetCtrlValue(IDM_THREAD))
 		{
 			auto Thread = s.Sub->AppendSub(LLoadString(IDS_THREAD));
 			if (Thread)
 			{
 				Thread->AppendItem(LLoadString(IDS_THREAD_SELECT), IDM_SELECT_THREAD);
 				Thread->AppendItem(LLoadString(IDS_THREAD_DELETE), IDM_DELETE_THREAD);
 				Thread->AppendItem(LLoadString(IDS_THREAD_IGNORE), IDM_IGNORE_THREAD);
 				s.Sub->AppendSeparator();
 			}
 		}
 
 		#ifdef _DEBUG
 		Prof->Add("Mark");
 		#endif
 
 		auto MarkMenu = s.Sub->AppendSub(AddAmp(LLoadString(IDS_MARK), 'm'));
 		if (MarkMenu)
 		{
 			BuildMarkMenu(MarkMenu, MarkState, (uint32_t)GetMarkColour(), true);
 		}
 
 		MarkMenu = s.Sub->AppendSub(AddAmp(LLoadString(IDS_SELECT_MARKED), 's'));
 		if (MarkMenu)
 		{
 			BuildMarkMenu(MarkMenu, MS_Multiple, 0, true, true, true);
 		}
 
 		s.Sub->AppendSeparator();
 		s.Sub->AppendItem(AddAmp(LLoadString(IDS_INSPECT), 'i'), IDM_INSPECT);
 		s.Sub->AppendItem(LLoadString(IDS_REPARSE), IDM_REPARSE);
 		s.Sub->AppendItem(LLoadString(IDS_PROPERTIES), IDM_PROPERTIES);
 
 		#ifdef _DEBUG
 		Prof->Add("ScriptCallbacks");
 		#endif
 
 		LArray<LScriptCallback*> Callbacks;
 		if (App->GetScriptCallbacks(LThingContextMenu, Callbacks))
 		{
 			LScriptArguments Args(NULL);
 			Args[0] = new LVariant(App);
 			Args[1] = new LVariant(this);
 			Args[2] = new LVariant(&s);
 			
 			for (auto c: Callbacks)
 				App->ExecuteScriptCallback(*c, Args);
 			
 			Args.DeleteObjects();
 		}
 
 		m.ToScreen();
 		int Result;
 
 		#ifdef _DEBUG
 		Prof.Reset();
 		#endif
 
 		int Btn = 0;
 		if (m.Left())
 			Btn = LSubMenu::BtnLeft;
 		else if (m.Right())
 			Btn = LSubMenu::BtnRight;
 
 		Result = s.Sub->Float(p, m.x, m.y);
 		switch (Result)
 		{
 			case IDM_OPEN:
 			{
 				DoUI();
 				break;
 			}
 			case IDM_DELETE:
 			{
 				LVariant ConfirmDelete = false;
 				App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 				if (!ConfirmDelete.CastInt32() ||
 					LgiMsg(GetList(), LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 				{
 					if (_GetListItems(Sel, false))
 					{
 						int Index = -1;
 						LList *TheList = LListItem::Parent;
 						LArray<Thing*> Items;
 
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (m)
 							{
 								if (Index < 0) Index = TheList->IndexOf(m);
 								Items.Add(m);
 							}
 						}
 						
 						GetFolder()->Delete(Items, true);
 
 						if (Index >= 0)
 						{
 							LListItem *i = TheList->ItemAt(Index);
 							if (i) i->Select(true);
 						}
 					}
 				}
 				break;
 			}
 			case IDM_EXPORT:
 			{
 				ExportAll(Parent, sMimeMessage, NULL);
 				break;
 			}
 			case IDM_REPLY:
 			case IDM_REPLY_ALL:
 			{
 				App->MailReplyTo(this, Result == IDM_REPLY_ALL);
 				SetDirty(false);
 				break;
 			}
 			case IDM_FORWARD:
 			{
 				App->MailForward(this);
 				SetDirty(false);
 				break;
 			}
 			case IDM_BOUNCE:
 			{
 				App->MailBounce(this);
 				SetDirty(false);
 				break;
 			}
 			case IDM_SET_READ:
 			{
 				SetListRead(true);
 				break;
 			}
 			case IDM_SET_UNREAD:
 			{
 				SetListRead(false);
 				break;
 			}
 			case IDM_INSPECT:
 			{
 				OnInspect();
 				break;
 			}
 			case IDM_PROPERTIES:
 			{
 				OnProperties();
 				break;
 			}
 			case IDM_SELECT_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->Select(true);
 					}
 				}
 				break;
 			}
 			case IDM_DELETE_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->OnDelete();
 					}
 				}
 				break;
 			}
 			case IDM_IGNORE_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->SetFlags(m->GetFlags() | MAIL_IGNORE | MAIL_READ);
 					}
 				}
 				break;
 			}
 			case IDM_REPARSE:
 			{
 				if (!_GetListItems(Sel, false))
 					break;
 
 				for (auto s: Sel)
 				{
 					Mail *m = dynamic_cast<Mail*>(s);
 					if (m)
 						m->Reparse();
 				}
 				break;
 			}
 			case IDM_UNMARK:
 			case IDM_SELECT_NONE:
 			case IDM_SELECT_ALL:
 			default:
 			{
 				if (Result == IDM_UNMARK ||
 					(Result >= IDM_MARK_BASE && Result < IDM_MARK_BASE+CountOf(MarkColours32)))
 				{
 					bool Marked = Result != IDM_UNMARK;
 
 					if (_GetListItems(Sel, false))
 					{
 						COLOUR Col32 = Marked ? MarkColours32[Result - IDM_MARK_BASE] : 0;
 
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (m)
 							{
 								if (m->SetMarkColour(Col32))
 								{
 									if (m->GetObject()->GetInt(FIELD_STORE_TYPE) != Store3Imap) // Imap knows to save itself.
 										m->SetDirty();
 								}
 								m->Update();
 							}
 						}
 					}
 				}
 				else if (Result == IDM_SELECT_NONE ||
 						 Result == IDM_SELECT_ALL ||
 						(Result >= IDM_MARK_SELECT_BASE && Result < IDM_MARK_SELECT_BASE+CountOf(MarkColours32)))
 				{
 					bool None = Result == IDM_SELECT_NONE;
 					bool All = Result == IDM_SELECT_ALL;
 					uint32_t c32 = MarkColours32[Result - IDM_MARK_SELECT_BASE];
 
 					if (_GetListItems(Sel, true))
 					{
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (!m)
 								break;
 
 							auto CurCol = m->GetMarkColour();
 							if (None)
 							{
 								m->Select(CurCol <= 0);
 							}
 							else
 							{
 								if (CurCol > 0)
 								{
 									if (All)
 									{
 										m->Select(true);
 									}
 									else
 									{
 										m->Select(CurCol && CurCol == c32);
 									}
 								}
 								else
 								{
 									m->Select(false);
 								}
 							}
 						}
 					}
 				}
 				else if (Result >= AttachBaseMsg &&
 						 Result < AttachBaseMsg + (ssize_t)AttachLst.Length())
 				{
 					// save attachment as...
 					Attachment *a = AttachLst.ItemAt(Result - AttachBaseMsg);
 					if (a)
 					{
 						a->OnSaveAs(Parent);
 					}
 				}
 				else
 				{
 					// Handle any installed callbacks for menu items
 					for (unsigned i=0; i<s.Callbacks.Length(); i++)
 					{
 						LScriptCallback &Cb = s.Callbacks[i];
 						if (Cb.Param == Result)
 						{
 							LScriptArguments Args(NULL);
 							Args[0] = new LVariant(App);
 							Args[1] = new LVariant(this);
 							Args[2] = new LVariant(Cb.Param);
 							
 							App->ExecuteScriptCallback(Cb, Args);
 						}
 					}
 				}
 				break;
 			}
 		}
 
 		DeleteObj(s.Sub);
 	}
 }
 
 void Mail::OnMouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		if (!m.IsContextMenu())
 		{
 			if (m.Double())
 			{
 				// open the UI for the Item
 				DoUI();
 			}
 		}
 		else
 		{
 			DoContextMenu(m);
 		}
 	}
 }
 
 void Mail::OnCreate()
 {
 	LOptionsFile *Options = App->GetOptions();
 	LVariant v;
 	if (GetObject()) GetObject()->SetInt(FIELD_FLAGS, MAIL_CREATED);
 
 	// Get identity and set from info
 	ScribeAccount *Ident = App->GetCurrentAccount();
 	if (Ident)
 	{
 		v = Ident->Identity.Name();
 		GetFrom()->SetStr(FIELD_NAME, v.Str());
 		v = Ident->Identity.Email();
 		GetFrom()->SetStr(FIELD_EMAIL, v.Str());
 		
 		v = Ident->Identity.ReplyTo();
 		if (v.Str())
 			GetReply()->SetStr(FIELD_REPLY, v.Str());
 	}
 	else
 	{
 		LAssert(!"No identity selected");
 	}
 
 	LVariant EditCtrl;
 	App->GetOptions()->GetValue(OPT_EditControl, EditCtrl);
 	LAutoString Sig = GetSig(EditCtrl.CastInt32() != 0, Ident);
 	if (!Sig && EditCtrl.CastInt32())
 	{
 		Sig = GetSig(false, Ident);
 		SetBody(Sig);
 	}
 	else if (EditCtrl.CastInt32())
 	{
 		SetHtmlCharset("utf-8");
 		SetHtml(Sig);
 	}
 	else
 	{
 		SetBodyCharset("utf-8");
 		SetBody(Sig);
 	}
 
 	LVariant ClipRecip;
 	if (Options->GetValue(OPT_RecipientFromClipboard, ClipRecip) &&
 		ClipRecip.CastInt32())
 	{
 		LClipBoard Clip(App);
 		char *Txt = Clip.Text();
 		if (Txt && strchr(Txt, '@') && strlen(Txt) < 100)
 		{
 			for (char *s=Txt; *s; s++)
 			{
 				if (*s == '\n' || *s == '\r')
 				{
 					*s = 0;
 				}
 			}
 
 			Mailto mt(App, Txt);
 
 			for (auto a: mt.To)
 			{
 				LDataPropI *OldA = dynamic_cast<LDataPropI*>(a);
 				if (OldA)
 				{
 					LDataPropI *NewA = GetTo()->Create(GetObject()->GetStore());
 					if (NewA)
 					{
 						NewA->CopyProps(*OldA);
 						GetTo()->Insert(NewA);
 					}
 				}
 			}
 			mt.To.Empty();
 			
 			if (mt.Subject && !ValidStr(GetSubject()))
 			{
 				SetSubject(mt.Subject);
 			}
 
 			/*
 			if (_strnicmp(Txt, MailToStr, 7) == 0)
 			{
 				char *Question = strchr(Txt + 7, '?');
 				if (Question)
 				{
 					*Question = 0;
 					Question++;
 
 					int Len = strlen(SubjectStr);
 					if (_strnicmp(Question, SubjectStr, Len) == 0)
 					{
 						Subject = NewStr(Question + Len);
 					}
 				}
 
 				La->Addr = NewStr(Txt + 7);
 			}
 			else
 			{
 				La->Addr = NewStr(Txt);
 			}
 
 			To.Insert(La);
 			*/
 		}
 	}
 
 	Update();
 }
 
 void Mail::Reparse()
 {
 	#ifdef _DEBUG
 	_debug = true;
 	#endif
 
 	// This temporarily removes the attachments that will be 
 	// deleted by the call to ParseHeaders after this...
 	ClearCachedItems();
 
 	Thing::Reparse();
 }
 
 void Mail::CreateMailHeaders()
 {
 	LStringPipe Hdrs(256);
 	MailProtocol Protocol;
 	LVariant HideId;
     App->GetOptions()->GetValue(OPT_HideId, HideId);
 	Protocol.ProgramName = GetFullAppName(!HideId.CastInt32());
 		
 	LDataI *Obj = GetObject();
 	if (Obj && ::CreateMailHeaders(App, Hdrs, Obj, &Protocol))
 	{
 		LAutoString FullHdrs(Hdrs.NewStr());
 		Obj->SetStr(FIELD_INTERNET_HEADER, FullHdrs);
 	}
 	else LAssert(!"CreateMailHeaders failed.");
 }
 
 bool Mail::OnBeforeSend(ScribeEnvelope *Out)
 {
 	if (!Out)
 	{
 		LAssert(!"No output envelope.");
 		return false;
 	}
 	
 	// First check the email from address...
 	if (!ValidStr(GetFrom()->GetStr(FIELD_EMAIL)))
 	{
 		LOptionsFile *Options = App->GetOptions();
 		if (Options)
 		{
 			ScribeAccount *Ident = App->GetAccounts()->ItemAt(App->GetCurrentIdentity());
 			if (Ident)
 			{
 				LVariant v = Ident->Identity.Email();
 				GetFrom()->SetStr(FIELD_EMAIL, v.Str());
 				v = Ident->Identity.Name();
 				GetFrom()->SetStr(FIELD_NAME, v.Str());
 			}
 		}
 	}
 
 	Out->From = GetFromStr(FIELD_EMAIL);
 	LDataIt To = GetTo();
 	ContactGroup *Group = NULL;
 	for (LDataPropI *t = To->First(); t; t = To->Next())
 	{
 		LString Addr = t->GetStr(FIELD_EMAIL);
 		if (LIsValidEmail(Addr))
 			Out->To.New() = Addr;
 		else if ((Group = LookupContactGroup(App, Addr)))
 		{
 			LString::Array a = Group->GetAddresses();
 			Out->To.Add(a);
 		}
 	}
 
 	LDataPropI *Root = GetObject()->GetObj(FIELD_MIME_SEG);
 	if (!Root)
 	{
 		LAssert(!"No root element.");
 		return false;
 	}
 
 	// Check the headers have been created..
 	if (!Root->GetStr(FIELD_INTERNET_HEADER))
 		CreateMailHeaders();
 
 	Out->MsgId = GetMessageId(true);
 	
 	// Convert the mime stream
 	LMime Mime(ScribeTempPath());
 	LTempStream Buf(ScribeTempPath());
 	
 	Store3ToLMime(&Mime, Root);
 	
 	// Do the encode
 	if (!Mime.Text.Encode.Push(&Buf))
 	{
 		LAssert(!"Mime encode failed.");
 		return false;
 	}
 
 	Out->References = GetReferences();
 	Out->FwdMsgId = GetFwdMsgId();
 	Out->BounceMsgId = GetBounceMsgId();
 	
 	// Read the resulting string into the output envelope
 	int Sz = (int)Buf.GetSize();
 	Out->Rfc822.Length(Sz);
 	Buf.SetPos(0);
 	Buf.Read(Out->Rfc822.Get(), Sz);
 	Out->Rfc822.Get()[Sz] = 0;
 
 	return true;
 }
 
 void Mail::OnAfterSend()
 {
 	int f = GetFlags();
 	f |= MAIL_SENT | MAIL_READ;	// set sent flag
 	f &= ~MAIL_READY_TO_SEND;	// clear read to send flag
 
 	// LgiTrace("Setting flags: %x\n", f);
 	SetFlags(f);
 
 	LDateTime n;
 	n.SetNow();
 	SetDateSent(&n);
 	// LString s = GetDateSent()->Get();
 	// LgiTrace("Setting sent date: %s\n", s.Get());
 
 	Update();
 	SetDirty();
 
 	if (App)
 	{
 		ScribeFolder *Sent = App->GetFolder(FOLDER_SENT, GetObject());
 		if (Sent)
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			Sent->MoveTo(Items, false);
 		}
 	}
 }
 
 bool Mail::OnBeforeReceive()
 {
 	return true;
 }
 
 enum MimeDecodeMode
 {
 	MODE_FIELDS,
 	MODE_WAIT_MSG,
 	MODE_SEGMENT,
 	MODE_WAIT_TYPE,
 	MODE_WAIT_BOUNDRY
 };
 
 #define MF_UNKNOWN						1
 #define MF_SUBJECT						2
 #define MF_TO							3
 #define MF_FROM							4
 #define MF_REPLY_TO						5
 #define MF_CONTENT_TYPE					6
 #define MF_CC							7
 #define MF_CONTENT_TRANSFER_ENCODING	9
 #define MF_DATE_SENT					10
 #define MF_PRIORITY						11
 #define MF_COLOUR						12
 #define MF_DISPOSITIONNOTIFICATIONTO	13
 
 void MungCharset(Mail *Msg, bool &HasRealCs, ScribeAccount *Acc)
 {
 	if (ValidStr(Msg->GetBodyCharset()))
 	{
 		HasRealCs = true;
 	}
 
 	if (Acc)
 	{
 		// LCharset *Cs = 0;
 		if (Msg->GetBodyCharset() &&
 			stristr(Msg->GetBodyCharset(), "ascii") &&
 			Acc->Receive.AssumeAsciiCharset().Str())
 		{
 			Msg->SetBodyCharset(Acc->Receive.AssumeAsciiCharset().Str());
 			HasRealCs = false;
 		}
 		else if (!ValidStr(Msg->GetBodyCharset()) ||
 				!LGetCsInfo(Msg->GetBodyCharset()))
 		{
 			Msg->SetBodyCharset(Acc->Receive.Assume8BitCharset().Str());
 			HasRealCs = false;
 		}
 	}
 }
 
 bool Mail::OnAfterReceive(LStreamI *Msg)
 {
 	if (!Msg)
 	{
 		LAssert(!"No input.");
 		return false;
 	}
 
 	// Clear the codepage setting here so that we can
 	// check later, down the bottom we must set it to
 	// the default if it's not set anywhere along the
 	// way.
 	SetBodyCharset(0);
 
 	auto obj = GetObject();
 	if (!obj)
 	{
 		LAssert(!"No storage object.");
 		return false;
 	}
 
 	if (!obj->SetRfc822(Msg))
 	{
-		LAssert(!"Failed to set mime content.");
+		LgiTrace("%s:%i - SetRfc822 failed with '%s'\n", _FL, obj->GetStr(FIELD_ERROR));
 		return false;
 	}
 
 	// Now parse them into the meta fields...
 	obj->ParseHeaders();
 	
 	ScribeAccount *Acc = GetAccountSentTo();
 	LAutoString ContentType;
 	
 	// Fill out any Contact's TimeZone if missing
 	LAutoString DateStr(InetGetHeaderField(GetInternetHeader(), "Date"));
 	LDateTime DateObj;
 	if (DateStr &&
 		DateObj.Decode(DateStr))
 	{
 	    double SenderTz = DateObj.GetTimeZoneHours();
 	    if (SenderTz != 0.0)
 	    {
 		    ListAddr *Sender = dynamic_cast<ListAddr*>(GetFrom());
 		    if (Sender)
 		    {
 				auto It = Sender->begin();
 				if (*It)
 				{
 					Contact *c = (*It)->GetContact();
 					if (c)
 					{
 						const char *Tz = "";
 						if (!c->Get(OPT_TimeZone, Tz) ||
 							atof(Tz) != SenderTz)
 						{
 							char s[32];
 							sprintf_s(s, sizeof(s), "%.1f", SenderTz);
 							c->Set(OPT_TimeZone, s);
 							c->SetDirty(true);
 						}
 					}
 				}
 		    }
 	    }
 	}
 
 	auto BodyText = GetBody();
 	if (BodyText)
 	{
 		if (!GetBodyCharset())
 		{
 			if (Acc && Acc->Receive.Assume8BitCharset().Str())
 			{
 				SetBodyCharset(Acc->Receive.Assume8BitCharset().Str());
 			}
 			else
 			{
 				SetBodyCharset("us-ascii");
 			}
 		}
 
 		LStringPipe NewBody;
 		LArray<LDataI*> Files;
 		if (DecodeUuencodedAttachment(obj->GetStore(), Files, &NewBody, BodyText))
 		{
 			LDataI *AttachPoint = GetFileAttachPoint();
 			if (AttachPoint)
 			{
 				for (unsigned i=0; i<Files.Length(); i++)
 				{
 					Files[i]->SetStr(FIELD_MIME_TYPE, sAppOctetStream);
 					Files[i]->Save(AttachPoint);
 				}
 
 				SetDirty(!TestFlag(GetFlags(), MAIL_ATTACHMENTS));
 				SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 
 				LAutoString n(NewBody.NewStr());
 				SetBody(n);
 
 				Update();
 				if (Ui) Ui->OnAttachmentsChange();
 			}
 		}
 	}
 
 	LDateTime n;
 	n.SetNow();
 	SetDateReceived(&n);
 
 	Update();
 	SetDirty();
 
 	// Call any 'after receive' callbacks
 	LArray<LScriptCallback*> Callbacks;
 	if (App->GetScriptCallbacks(LMailOnAfterReceive, Callbacks))
 	{
 		for (auto c: Callbacks)
 		{
 			if (!c->Func)
 				continue;
 
 			LVirtualMachine Vm;				
 			LScriptArguments Args(&Vm);
 			Args.New() = new LVariant(App);
 			Args.New() = new LVariant(this);
 			App->ExecuteScriptCallback(*c, Args);
 			Args.DeleteObjects();
 		}
 	}
 
 	return true;
 }
 
 ThingUi *Mail::GetUI()
 {
 	return Ui;
 }
 
 LVariant Mail::GetServerUid()
 {
 	LVariant v;
 	
 	if (GetObject())
 	{
 		auto Type = (Store3Backend)GetObject()->GetInt(FIELD_STORE_TYPE);
 		if (Type == Store3Imap)
 			v = GetObject()->GetInt(FIELD_SERVER_UID);
 		else
 			v = GetObject()->GetStr(FIELD_SERVER_UID);
 	}
 	else LAssert(!"No object.");
 
 	return v;
 }
 
 bool Mail::SetServerUid(LVariant &v)
 {
 	if (!GetObject())
 		return false;
 	
 	Store3Status s;
 	if (GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 		s = GetObject()->SetInt(FIELD_SERVER_UID, v.CastInt32());
 	else
 		s = GetObject()->SetStr(FIELD_SERVER_UID, v.Str());
 
 	return s > Store3Error;
 }
 
 bool Mail::SetObject(LDataI *o, bool IsDestructor, const char *File, int Line)
 {
 	bool b = LDataUserI::SetObject(o, IsDestructor, File, Line);
 	if (b)
 	{
 		// Clear out stale attachment objects...
 		UnloadAttachments();
 	}
 	return b;
 }
 
 bool Mail::SetUI(ThingUi *new_ui)
 {
 	MailUi *NewMailUi = dynamic_cast<MailUi*>(new_ui);
 	if (NewMailUi == Ui)
 		return true;
 
 	if (Ui)
 	{
 		LWindow *w = Ui;
 		Ui->SetItem(0);
 		w->Quit();
 		LAssert(Ui == NULL);
 	}
 	
 	if (new_ui)
 	{
 		Ui = dynamic_cast<MailUi*>(new_ui);
 		if (Ui)
 			Ui->SetItem(this);
 		else
 			LAssert(!"Incorrect object.");
 	}
 	
 	return true;
 }
 
 ThingUi *Mail::DoUI(MailContainer *c)
 {
 	if (App &&
 		!Ui)
 	{
 		if (App->InThread())
 		{
 			Ui = new MailUi(this, c ? c : GetFolder());
 		}
 		else
 		{
             App->PostEvent(M_SCRIBE_OPEN_THING, (LMessage::Param)this, 0);
 		}
 	}
 
 	if (Ui)
 	{
 		#if WINNATIVE
 		SetActiveWindow(Ui->Handle());
 		#endif
 	}
 
 	return Ui;
 }
 
 int Mail::Compare(LListItem *t, ssize_t Field)
 {
 	Thing *T = (Thing*)t->_UserPtr;
 	Mail *m = T ? T->IsMail() : 0;
 	if (m)
 	{
 		static int Fields[] = {FIELD_FROM, FIELD_SUBJECT, FIELD_SIZE, FIELD_DATE_RECEIVED};
 		if (Field < 0)
 		{
 			auto i = -Field - 1;
 			if (i >= 0 && i < CountOf(Fields))
 			{
 				Field = Fields[i];
 			}
 		}
 
 		LVariant v1, v2;
 		const char *s1 = "", *s2 = "";
 		switch (Field)
 		{
 			case 0:
 			{
 				break;
 			}
 			case FIELD_TO:
 			{
 				LDataPropI *a1 = GetTo()->First();
 				if (a1)
 				{
 					if (a1->GetStr(FIELD_NAME)) s1 = a1->GetStr(FIELD_NAME);
 					else if (a1->GetStr(FIELD_EMAIL)) s1 = a1->GetStr(FIELD_EMAIL);
 				}
 
 				LDataPropI *a2 = m->GetTo()->First();
 				if (a2)
 				{
 					if (a2->GetStr(FIELD_NAME)) s2 = a2->GetStr(FIELD_NAME);
 					else if (a2->GetStr(FIELD_EMAIL)) s2 = a2->GetStr(FIELD_EMAIL);
 				}
 				break;
 			}
 			case FIELD_FROM:
 			{
 				LDataPropI *f1 = GetFrom();
 				LDataPropI *f2 = m->GetFrom();
 
 				if (f1->GetStr(FIELD_NAME)) s1 = f1->GetStr(FIELD_NAME);
 				else if (f1->GetStr(FIELD_EMAIL)) s1 = f1->GetStr(FIELD_EMAIL);
 
 				if (f2->GetStr(FIELD_NAME)) s2 = f2->GetStr(FIELD_NAME);
 				else if (f2->GetStr(FIELD_EMAIL)) s2 = f2->GetStr(FIELD_EMAIL);
 				break;
 			}
 			case FIELD_SUBJECT:
 			{
 				s1 = GetSubject();
 				s2 = m->GetSubject();
 				break;
 			}
 			case FIELD_SIZE:
 			{
 				return (int) (TotalSizeof() - m->TotalSizeof());
 				break;
 			}
 			case FIELD_DATE_SENT:
 			{
 			    auto Sent1 = GetDateSent();
 			    auto Sent2 = m->GetDateSent();
 			    if (!Sent1 || !Sent2)
 			        break;
 				return Sent1->Compare(Sent2);
 				break;
 			}
 			case FIELD_DATE_RECEIVED:
 			{
 				return GetDateReceived()->Compare(m->GetDateReceived());
 				break;
 			}
 			case FIELD_PRIORITY:
 			{
 				return GetPriority() - m->GetPriority();
 				break;
 			}
 			case FIELD_FLAGS:
 			{
 				int Mask = MAIL_FORWARDED | MAIL_REPLIED | MAIL_READ;
 				return (GetFlags() & Mask) - (m->GetFlags() & Mask);
 				break;
 			}
 			case FIELD_LABEL:
 			{
 				if (GetLabel()) s1 = GetLabel();
 				if (m->GetLabel()) s2 = m->GetLabel();
 				break;
 			}
 			case FIELD_MESSAGE_ID:
 			{
 				s1 = GetMessageId();
 				s2 = m->GetMessageId();
 				break;
 			}
 			case FIELD_FROM_CONTACT_NAME:
 			{
 				s1 = GetFieldText(FIELD_FROM_CONTACT_NAME);
 				s2 = m->GetFieldText(FIELD_FROM_CONTACT_NAME);
 				break;
 			}
 			case FIELD_SERVER_UID:
 			{
 				v1 = GetServerUid();
 				v2 = m->GetServerUid();
 				if (v1.Str() && v2.Str())
 				{
 					s1 = v1.Str();
 					s2 = v2.Str();					
 				}
 				else
 				{
 					auto diff = v1.CastInt64() - v2.CastInt64();
 					if (diff < 0) return -1;
 					return diff > 1;
 				}
 			}
 			default:
 			{
 				s1 = GetObject() ? GetObject()->GetStr((int)Field) : 0;
 				s2 = m->GetObject() ? m->GetObject()->GetStr((int)Field) : 0;
 				break;
 			}
 		}
 
 		const char *Empty = "";
 		return _stricmp(s1?s1:Empty, s2?s2:Empty);
 	}
 
 	return -1;
 }
 
 class MailPropDlg : public LDialog
 {
 	List<Mail> Lst;
 	LViewI *Table = NULL;
 
 	struct FlagInfo
 	{
 		int Flag = 0, Ctrl = 0;
 
 		void Set(int f, int c)
 		{
 			Flag = f;
 			Ctrl = c;
 		}
 	};
 	LArray<FlagInfo> Flags;
 
 public:
 	MailPropDlg(LView *Parent, List<Mail> &lst)
 	{
 		SetParent(Parent);
 		
 		Lst = lst;
 
 		Flags.New().Set(MAIL_SENT, IDC_SENT);
 		Flags.New().Set(MAIL_RECEIVED, IDC_RECEIVED);
 		Flags.New().Set(MAIL_CREATED, IDC_CREATED);
 		Flags.New().Set(MAIL_FORWARDED, IDC_FORWARDED);
 		Flags.New().Set(MAIL_REPLIED, IDC_REPLIED);
 		Flags.New().Set(MAIL_ATTACHMENTS, IDC_HAS_ATTACH);
 		Flags.New().Set(MAIL_READ, IDC_READ);
 		Flags.New().Set(MAIL_READY_TO_SEND, IDC_READY_SEND);
 
 		if (LoadFromResource(IDD_MAIL_PROPERTIES))
 		{
 			GetViewById(IDC_TABLE, Table);
 			LAssert(Table != NULL);
 			SetCtrlEnabled(IDC_OPEN_INSPECTOR, Lst.Length() == 1);
 			
 			for (auto &i: Flags)
 			{
 				int Set = 0;
 				for (auto m: Lst)
 				{
 					if (m->GetFlags() & i.Flag)
 						Set++;
 				}
 				
 				if (Set == Lst.Length())
 				{
 					SetCtrlValue(i.Ctrl, LCheckBox::CheckOn);
 				}
 				else if (Set)
 				{
 					LCheckBox *Cb;
 					if (GetViewById(i.Ctrl, Cb))
 						Cb->ThreeState(true);
 
 					SetCtrlValue(i.Ctrl, LCheckBox::CheckPartial);
 				}
 			}
 
 			SetCtrlEnabled(IDC_HAS_ATTACH, false);
 
 			char Msg[512] = "";
 			if (Lst.Length() == 1)
 			{
 				Mail *m = Lst[0];
 				auto mObj = m->GetObject();
 				if (mObj)
 				{
 					auto dt = mObj->GetDate(FIELD_DATE_RECEIVED);
 					sprintf_s(	Msg, sizeof(Msg),
 								LLoadString(IDS_MAIL_PROPS_DLG),
 								LFormatSize(mObj->GetInt(FIELD_SIZE)).Get(),
 								dt ? dt->Get().Get() : LLoadString(IDS_NONE),
 								mObj->GetStr(FIELD_DEBUG));
 
 					SetCtrlName(IDC_MSG_ID, mObj->GetStr(FIELD_MESSAGE_ID));
 				}
 			}
 			else
 			{
 				sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_MULTIPLE_ITEMS), Lst.Length());
 				SetCtrlEnabled(IDC_MSG_ID, false);
 			}
 			SetCtrlName(IDC_MAIL_DESCRIPTION, Msg);
 
 			MoveSameScreen(Parent);
 		}
 	}
 	
 	void OnPosChange()
 	{
 		if (Table)
 		{
 			LRect r = GetClient();
 			r.Inset(LTableLayout::CellSpacing, LTableLayout::CellSpacing);
 			Table->SetPos(r);
 		}
 	}
 
 	int OnNotify(LViewI *Ctr, LNotification n)
 	{
 		switch (Ctr->GetId())
 		{
 			case IDC_OPEN_INSPECTOR:
 			{
 				if (Lst.Length())
 					Lst[0]->OnInspect();
 				break;
 			}
 			case IDOK:
 			{
 				for (auto &i: Flags)
 				{
 					auto v = GetCtrlValue(i.Ctrl);
 					LAssert(v >= 0); // the control couldn't be found... check the .lr8 file
 					
 					for (auto m: Lst)
 					{
 						if (v == 1)
 							m->SetFlags(m->GetFlags() | i.Flag);
 						else if (v == 0)
 							m->SetFlags(m->GetFlags() & ~i.Flag);
 					}
 				}
 				// fall thru
 			}
 			case IDCANCEL:
 			{
 				EndModal(Ctr->GetId());
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 void Mail::OnInspect()
 {
 	new ObjectInspector(App, this);
 }
 
 void Mail::OnProperties(int Tab)
 {
 	List<LListItem> Sel;
 	if (GetList()->GetSelection(Sel))
 	{
 		List<Mail> Lst;
 		for (auto i: Sel)
 		{
 			Lst.Insert(dynamic_cast<Mail*>(i));
 		}
 		
 		if (Lst[0])
 		{
 			auto Dlg = new MailPropDlg(GetList(), Lst);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id == IDOK)
 				{
 					SetDirty();
 					Update();
 				}
 				delete dlg;
 			});
 		}
 	}
 }
 
 int Mail::GetImage(int SelFlags)
 {
 	if (TestFlag(GetFlags(), MAIL_READY_TO_SEND) &&
 		!TestFlag(GetFlags(), MAIL_SENT))
 	{
 		return ICON_UNSENT_MAIL;
 	}
 		
 	if (GetFlags() & MAIL_READ)
 	{
 		return (GetFlags() & MAIL_ATTACHMENTS) ? ICON_READ_ATT_MAIL : ICON_READ_MAIL;
 	}
 	else
 	{
 		return (GetFlags() & MAIL_ATTACHMENTS) ? ICON_UNREAD_ATT_MAIL : ICON_UNREAD_MAIL;
 	}
 
 	return ICON_READ_MAIL;
 }
 
 int *Mail::GetDefaultFields()
 {
 	return DefaultMailFields;
 }
 
 void Mail::DeleteAsSpam(LView *View)
 {
 	// Set read..
 	SetFlags(GetFlags() | MAIL_READ | MAIL_BAYES_SPAM, true);
 
 	// Remove from NewMail
 	NewMailLst.Delete(this);
 
 	LVariant DeleteOnServer, DeleteAttachments, SetRead;
 	auto Opts = App->GetOptions();
 	if (!Opts->GetValue(OPT_BayesDeleteOnServer, DeleteOnServer))
 		DeleteOnServer = false;
 	if (!Opts->GetValue(OPT_BayesDeleteAttachments, DeleteAttachments))
 		DeleteAttachments = false;
 	if (!Opts->GetValue(OPT_BayesSetRead, SetRead))
 		SetRead = false;
 
 	if (DeleteOnServer.CastBool())
 	{
 		// Tell the account it's spam... so that any further connects can
 		// delete it off the server.
 		ScribeAccount *a = GetAccountSentTo();
 		if (a)
 		{
 			auto ServerUid = GetServerUid();
 			if (ServerUid.Str())
 			{
 				a->Receive.DeleteAsSpam(ServerUid.Str());
 				SetServerUid(ServerUid = NULL);
 			}
 			else
 			{
 				LAutoString Uid(InetGetHeaderField(GetInternetHeader(), "X-UIDL"));
 				if (Uid)
 					a->Receive.DeleteAsSpam(Uid);
 			}
 		}
 		else
 		{
 			#if 0 // def _DEBUG
 			if (LgiMsg(Ui?(LView*)Ui:(LView*)App, "Debug: GetAccountSentTo failed. Debug?", AppName, MB_YESNO) == IDYES)
 			{
 				LAssert(0);
 			}
 			#endif
 		}
 	}
 
 	if (DeleteAttachments.CastBool())
 	{
 		// Delete all attachments... they're useless and more than likely
 		// just virii anyway.
 		List<Attachment> Files;
 		if (GetAttachments(&Files))
 		{
 			for (auto a: Files)
 			{
 				DeleteAttachment(a);
 			}
 			Files.Empty();
 		}
 	}
 
 	if (SetRead.CastInt32() != 0)
 	{
 		SetFlags(GetFlags() | MAIL_READ);
 	}
 
 	// Move it to the spam folder if it exists.
 	auto FolderPath = GetFolder()->GetPath();
 	auto Parts = FolderPath.SplitDelimit("/");
 	
 	if (Parts.Length() == 0)
 		LgiMsg(View, "Error: No folder path?", AppName);
 	else
 	{
 		LString SpamPath;
 		LString SpamLeaf = "Spam";
 		SpamPath.Printf("/%s/%s", Parts[0].Get(), SpamLeaf.Get());
 
 		ScribeFolder *Spam = App->GetFolder(SpamPath);
 		if (!Spam)
 		{
 			LMailStore *Ms = App->GetMailStoreForPath(FolderPath);
 			if (!Ms)
 			{
 				if (GetFolder()->GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 				{
 					Ms = App->GetDefaultMailStore();
 					if (Ms && Ms->Root)
 					{
 						Spam = Ms->Root->GetSubFolder(SpamLeaf);
 						if (!Spam)
-							Spam = Ms->Root->CreateSubDirectory(SpamLeaf, MAGIC_MAIL);
+							Spam = Ms->Root->CreateSubFolder(SpamLeaf, MAGIC_MAIL);
 					}
 				}
 				else
 					LgiMsg(View, "Error: Couldn't get mail store for '%s'.", AppName, MB_OK, FolderPath.Get());
 			}
 			else
-				Spam = Ms->Root->CreateSubDirectory("Spam", MAGIC_MAIL);
+				Spam = Ms->Root->CreateSubFolder("Spam", MAGIC_MAIL);
 		}
 
 		if (Spam && Spam != GetFolder())
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			Spam->MoveTo(Items, false, [View](auto result, auto status)
 			{
 				if (!result)
 					LgiMsg(View, "Error: Couldn't move email to spam folder.", AppName);
 			});
 		}
 	}
 }
 
 void Mail::SetFlagsCache(int64_t NewFlags, bool IgnoreReceipt, bool UpdateScreen)
 {
 	if (FlagsCache == NewFlags)
 		return;
 
 	DepthCheck Depth(d->InSetFlagsCache);
 		
 	bool Read1 = TestFlag(FlagsCache, MAIL_READ);
 	bool Read2 = TestFlag(NewFlags, MAIL_READ);
 	bool ChangeRead = Read1 ^ Read2;
 
 	// LgiTrace("%p::SetFlagsCache: %s -> %s\n", this, EmailFlagsToStr(FlagsCache).Get(), EmailFlagsToStr(StoreFlags).Get());
 	FlagsCache = NewFlags;
 
 	if (ChangeRead && App)
 	{
 		if (Read2)
 		{
 			// Becoming read
 			List<Mail> Objs;
 			Objs.Insert(this);
 			App->OnNewMail(&Objs, false);
 			PreviewCache.DeleteObjects();
 
 			// Read receipt
 			if (!IgnoreReceipt &&
 				!TestFlag(NewFlags, MAIL_CREATED) &&
 				TestFlag(NewFlags, MAIL_READ_RECEIPT))
 			{
 				LAutoString Header(InetGetHeaderField(GetInternetHeader(), "Disposition-Notification-To"));
 				if (Header)
 				{
 					LAutoString Name, Addr;
 					DecodeAddrName(Header, Name, Addr, 0);
 					if (Addr)
 					{
 						if (LgiMsg(	Ui != 0 ? (LView*)Ui : (LView*)App,
 									LLoadString(IDS_RECEIPT_ASK),
 									AppName,
 									MB_YESNO,
 									GetSubject(),
 									GetFrom()->GetStr(FIELD_NAME),
 									GetFrom()->GetStr(FIELD_EMAIL),
 									(char*)Name,
 									(char*)Addr) == IDYES)
 						{
 							Mail *m = new Mail(App);
 							if (m)
 							{
 								m->App = App;
 
 								LDataPropI *ToAddr = m->GetTo()->Create(m->GetObject()->GetStore());
 								if (ToAddr)
 								{
 									ToAddr->SetStr(FIELD_NAME, Name);
 									ToAddr->SetStr(FIELD_EMAIL, Addr);
 									m->GetTo()->Insert(ToAddr);
 								}
 									
 								m->OnReceipt(this);
 								m->Save();
 								App->Send();
 							}
 						}
 					}
 				}
 			}
 
 			LVariant Inc;
 			if (App->GetOptions()->GetValue(OPT_BayesIncremental, Inc) &&
 				Inc.CastInt32())
 			{
 				// Incremental bayesian update
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailHam);
 			}
 		}
 
 		if (UpdateScreen)
 		{
 			// Changing read status
 			ScribeFolder *t = GetFolder();
 			if (t)
 				t->OnUpdateUnRead(0, true);
 		}
 	}
 
 	if (UpdateScreen || ChangeRead)
 	{
 		Update();
 	}
 }
 
 
 uint32_t Mail::GetFlags()
 {
 	if (GetObject())
 	{
 		// Make sure the objects are in sync...
 		auto StoreFlags = GetObject()->GetInt(FIELD_FLAGS);
 		if (FlagsCache < 0)
 			FlagsCache = StoreFlags;
 		else if (FlagsCache != StoreFlags)
 			SetFlagsCache(StoreFlags, false, true);
 	}
 
 	return (uint32_t)FlagsCache;
 }
 
 void Mail::SetFlags(ulong NewFlags, bool IgnoreReceipt, bool UpdateScreen)
 {
 	if (FlagsCache == NewFlags)
 		return;
 
 	DepthCheck SetFlagsDepth(d->InSetFlags);
 
 	if (GetObject())
 	{
 		Store3Status Result = GetObject()->SetInt(FIELD_FLAGS, NewFlags);
 		if (Result == Store3Success &&
 			GetObject()->IsOnDisk())
 		{
 			// Imap mail shouldn't fall in here.
 			SetDirty();
 		}
 	}
 	else
 	{
 		LAssert(0);
 		return;
 	}
 
 	SetFlagsCache(NewFlags, IgnoreReceipt, UpdateScreen);
 }
 
 const char *Mail::GetFieldText(int Field)
 {
 	static char Buf[512];
 
 	switch (Field)
 	{
 		case FIELD_TO:
 		{
 			size_t ch = 0;
 			Buf[0] = 0;
 			
 			LDataIt To = GetTo();
 			for (LDataPropI *a=To->First(); a; a=To->Next())
 			{
 				if (ch > 0)
 					ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, ", ");
 				
 				auto Name = a->GetStr(FIELD_NAME);
 				auto Addr = a->GetStr(FIELD_EMAIL);
 				auto n = Name ? Name : Addr;
 				if (!n)
 					continue;
 
 				// Is the buffer too small?
 				size_t n_len = strlen(n);
 				if (ch + n_len + 8 >= sizeof(Buf))
 				{
 					// Yes... just truncate it with "..." and bail.
 					ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, "...");
 					break;
 				}
 				ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, "%s", n);
 				
 				LAssert(ch < sizeof(Buf) - 1);
 			}
 			return Buf;
 			break;
 		}
 		case FIELD_FROM_CONTACT_NAME:
 		{
 			static bool InMethod = false;
 			if (!InMethod)
 			{
 				InMethod = true;
 				
 				LDataPropI *la = GetFrom();
 				if (la)
 				{
 					auto Email = la->GetStr(FIELD_EMAIL);
 					Contact *c = Contact::LookupEmail(Email);
 					if (c)
 					{
 						const char *f = 0, *l = 0;
 						c->Get(OPT_First, f);
 						c->Get(OPT_Last, l);
 						
 						if (f && l)
 							sprintf_s(Buf, sizeof(Buf), "%s %s", f, l);
 						else if (f)
 							strcpy_s(Buf, sizeof(Buf), f);
 						else if (l)
 							strcpy_s(Buf, sizeof(Buf), l);
 						else
 							Buf[0] = 0;
 
 						InMethod = false;
 						return Buf;
 					}
 				}
 				
 				InMethod = false;
 			}
 			else
 			{
 				LAssert(0);
 			}
 			
 			// fall through
 		}
 		case FIELD_FROM:
 		{
 		    LDataPropI *f = GetFrom();
 			auto n = f->GetStr(FIELD_NAME);
 		    if (n)
 		        return n;
 
 			auto e = f->GetStr(FIELD_EMAIL);
 			if (e)
 			    return e;
 			break;
 		}
 		case FIELD_SUBJECT:
 		{
 			auto s = GetSubject();
 			
 			if (Strchr(s, '\n'))
 			{
 				char *e = Buf + sizeof(Buf) - 1;
 				char *o = Buf;
 				for (auto i = s; o<e && *i; i++)
 				{
 					if (*i != '\n')
 						*o++ = *i;
 				}
 				*o++ = 0;
 				return Buf;
 			}
 			
 			return s;
 		}
 		case FIELD_SIZE:
 		{
 			if (TotalSizeCache < 0)
 				TotalSizeof();
 				
 			if (OptionSizeInKiB)
 			{
 				int ch = sprintf_s(Buf, sizeof(Buf), "%.0f KiB", (double)TotalSizeCache/1024.0);
 				if (ch > 4 + 3)
 				{
 					int digits = ch - 4;
 					char *s = Buf + ((digits % 3) ? digits % 3 : 3);
 					char *e = Buf + ch - 4;
 					while (s < e)
 					{
 						memmove(s + 1, s, strlen(s)+1);
 						*s = ',';
 						s += 3;
 					}
 				}
 			}
 			else
 				LFormatSize(Buf, sizeof(Buf), TotalSizeCache);
 			return Buf;
 		}
 		case FIELD_DATE_SENT:
 		{
 			auto DateSent = GetDateSent();
 			if (DateSent->Year())
 			{
 				LDateTime dt = *DateSent;
 				if (GetObject() &&
 					GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 				{
 					ValidateImapDate(dt);
 				}
 
 			    if (AdjustDateTz)
 			    {
                     if (dt.GetTimeZone() != LDateTime::SystemTimeZone())
     			        dt.SetTimeZone(LDateTime::SystemTimeZone(), true);
 				}
 
 				if (ShowRelativeDates)
 				{
 					auto rel = RelativeTime(dt);
 					strcpy_s(Buf, sizeof(Buf), rel ? rel : "#error:RelativeTime");
 				}
 				else
 				{
 					dt.Get(Buf, sizeof(Buf));
 				}
 			}
 			else
 			{
 				sprintf_s(Buf, sizeof(Buf), "(%s)", LLoadString(IDS_NONE, "None"));
 			}			
 			return Buf;
 		}
 		case FIELD_DATE_RECEIVED:
 		{
 			auto DateReceived = GetDateReceived();
 			if (DateReceived->Year())
 			{
 		        LDateTime dt = *DateReceived;
 			    if (AdjustDateTz)
 			    {
                     if (dt.GetTimeZone() != LDateTime::SystemTimeZone())
     			        dt.SetTimeZone(LDateTime::SystemTimeZone(), true);
 			    }
 
 				dt.Get(Buf, sizeof(Buf));
 				if (ShowRelativeDates)
 				{
 					auto rel = RelativeTime(dt);
 					strcpy_s(Buf, sizeof(Buf), rel ? rel : "#error:RelativeTime");
 				}
 				else
 				{
 				    dt.Get(Buf, sizeof(Buf));
 				}
 			}
 			else
 			{
 				sprintf_s(Buf, sizeof(Buf), "(%s)", LLoadString(IDS_NONE, "None"));
 			}			
 			return Buf;
 		}
 		case FIELD_TEXT:
 			return GetBody();
 		case FIELD_MESSAGE_ID:
 			return GetMessageId();
 		case FIELD_INTERNET_HEADER:
 			return GetInternetHeader();
 		case FIELD_ALTERNATE_HTML:
 			return GetHtml();
 		case FIELD_LABEL:
 			return GetLabel();
 		case FIELD_PRIORITY:
 		case FIELD_FLAGS:
 			return 0;
 		case FIELD_SERVER_UID:
 			sprintf_s(Buf, sizeof(Buf), "%i", GetObject() ? (int)GetObject()->GetInt(Field) : -1);
 			return Buf;
 		case FIELD_RECEIVED_DOMAIN:
 		{
 			if (!d->DomainCache)
 			{
 				if (!GetObject())
 					return NULL;
 
 				auto hdr = GetObject()->GetStr(FIELD_INTERNET_HEADER);
 				if (!hdr)
 					return NULL;
 
 				for (auto ln: LString(hdr).SplitDelimit("\n"))
 				{
 					if (ln.Find("Received: from") == 0)
 					{
 						auto p = ln.SplitDelimit();
 						if (p.Length() > 2)
 						{
 							auto t = p[2];
 							if (t.Find(".") > 0)
 								d->DomainCache = t.Strip("[]");
 						}
 					}
 				}
 			}
 
 			return d->DomainCache;
 		}
 		default:
 			return GetObject() ? GetObject()->GetStr(Field) : NULL;
 	}
 
 	return 0;
 }
 
 int Mail::DefaultMailFields[] =
 {
 	/*
 	FIELD_FLAGS,
 	FIELD_PRIORITY,
 	*/
 	FIELD_FROM,
 	FIELD_SUBJECT,
 	FIELD_SIZE,
 	FIELD_DATE_SENT
 };
 
 const char *Mail::GetText(int i)
 {
 	if (FieldArray.Length())
 	{
 		if (i >= 0 && i < (int)FieldArray.Length())
 			return GetFieldText(FieldArray[i]);
 	}
 	else if (i < CountOf(DefaultMailFields))
 	{
 		return GetFieldText(DefaultMailFields[i]);
 	}
 	
 	return NULL;
 }
 
 LDataI *Mail::GetFileAttachPoint()
 {
 	if (!GetObject())
 	{
 		LAssert(!"No object ptr.");
 		return 0;
 	}
 
 	auto Store = GetObject()->GetStore();
 	
 	// Check existing root node for "multipart/mixed"?
 	auto r = dynamic_cast<LDataI*>(GetObject()->GetObj(FIELD_MIME_SEG));
 	if (!r)
 	{
 		// Create one...
 		r = Store->Create(MAGIC_ATTACHMENT);
 		if (!r)
 		{		
 			LAssert(!"No MIME segment ptr.");
 			return NULL;
 		}
 		
 		r->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 		if (!GetObject()->SetObj(FIELD_MIME_SEG, r))
 		{
 			LAssert(!"Can't set MIME segment.");
 			return NULL;
 		}
 	}
 
 	auto Mt = r->GetStr(FIELD_MIME_TYPE);
 	if (!Stricmp(Mt, sMultipartMixed))
 	{
 		// Yes is it mixed... return that...
 		return r;
 	}
 
 	// No, a different type of segment, make the parent segment a "mixed", and attach the old segment to the mixed
 	auto Mixed = Store->Create(MAGIC_ATTACHMENT);
 	if (!Mixed)
 	{
 		LAssert(!"Failed to create MAGIC_ATTACHMENT.");
 		return NULL;
 	}
 
 	// Set the type...
 	Mixed->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 
 	// Re-parent the content to the mixed
 	if (!r->Save(Mixed))
 	{
 		LAssert(!"Can't reparent the content into the mixed seg.");
 		return NULL;
 	}
 
 	// Re-parent the mixed to the mail object
 	if (!Mixed->Save(GetObject()))
 	{
 		LAssert(!"Can't reparent the mixed seg into the mail object.");
 		return NULL;
 	}
 
 	return Mixed;
 }
 
 bool Mail::AttachFile(Attachment *File)
 {
 	bool Status = false;
 
 	if (File && !Attachments.HasItem(File))
 	{
 		LDataI *AttachPoint = GetFileAttachPoint();
 		if (AttachPoint)
 		{
 			if (File->GetObject()->Save(AttachPoint))
 			{
 				File->App = App;
 				File->SetOwner(this);
 				Attachments.Insert(File);
 
 				Status = true;
 
 				SetDirty(!TestFlag(GetFlags(), MAIL_ATTACHMENTS));
 				SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 
 				Update();
 
 				if (Ui)
 				{
 					Ui->OnAttachmentsChange();
 				}
 			}
 		}
 		else
 		{
 			File->DecRef();
 		}
 	}
 
 	return Status;
 }
 
 Attachment *Mail::AttachFile(LView *Parent, const char *FileName)
 {
 	LString MimeType = ScribeGetFileMimeType(FileName);
 	LVariant Resize = false;
 	if (!Strnicmp(MimeType.Get(), "image/", 6))
 	{
 		// Check if we have to do a image resize
 		App->GetOptions()->GetValue(OPT_ResizeImgAttachments, Resize);
 	}
 
 	auto AttachPoint = GetFileAttachPoint();
 	if (!AttachPoint)
 	{
 		LAssert(!"No attachment point in MIME heirarchy for file");
 		return NULL;
 	}
 	
 	auto File = new Attachment(	App,
 								GetObject()->GetStore()->Create(MAGIC_ATTACHMENT),
 								FileName);
 	if (File)
 	{
 		File->App = App;
 		if (Resize.CastInt32() || File->GetSize() > 0)
 		{
 			File->SetOwner(this);
 			Attachments.Insert(File);
 			if (Resize.CastInt32())
 				d->AddResizeImage(File);
 			else
 				File->GetObject()->Save(AttachPoint);
 			SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 			Update();
 
 			if (Ui)
 				Ui->OnAttachmentsChange();
 		}
 		else
 		{
 			LgiMsg(Parent, LLoadString(IDS_ERROR_FILE_EMPTY), AppName);
 			File->DecRef();
 			File = NULL;
 		}
 	}
 
 	return File;
 }
 
 bool Mail::Save(ScribeFolder *Into)
 {
 	bool Status = false;
 
 	if (!Into)
 	{
 	    if (GetFolder())
 		    Into = GetFolder();
 		else
 			Into = App->GetFolder(FOLDER_OUTBOX);
 	}
 
 	if (Into)
 	{
 		ScribeFolder *Old = GetFolder();
 
         if (!GetFolder())
         {
 	        SetParentFolder(Into);
 	    }
 	    else if (GetFolder() != Into)
 	    {
             // If this fails, you should really by using ScribeFolder::MoveTo to move
             // the item from it's existing location to the new folder...
             LAssert(!"Use MoveTo instead.");
             return false;
 	    }
 
 		Store3Status Result = Into->WriteThing(this);
 		if (Result != Store3Error)
 		{
 			Status = true;
 			SetDirty(false);
 			
 			if (Into &&
 				Into == App->GetFolder(FOLDER_TEMPLATES, NULL, true))
 			{
 				// saving into the templates folder... update the menu
 				App->BuildDynMenus();
 			}
 
 			if (Status && DropFileName)
 			{
 				FileDev->Delete(DropFileName, false);
 				DropFileName.Reset();
 			}
 		}
 		else
 		{
 			SetParentFolder(Old);
 		}
 	}
 	
 	// This frees the resizer thread... 
 	// so they aren't hanging around pointlessly
 	d->OnSave();	
 	
 	return Status;
 }
 
 struct WrapQuoteBlock
 {
 	int Depth;
 	LArray<char*> Text;
 };
 
 void WrapAndQuote(	LStream &Pipe,
 					const char *Quote,
 					int Wrap,
 					const char *Text,
 					const char *Cp,
 					const char *MimeType)
 {
 	int IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 	LAutoString In((char*) LNewConvertCp("utf-8", Text, Cp ? Cp : (char*)"utf-8"));
 	const char *QuoteStr = Quote;
 	if (In)
 	{
 		size_t QuoteChars = Strlen(QuoteStr);
 		char NewLine[8];
 		int NewLineLen = sprintf_s(NewLine, sizeof(NewLine), "%s", IsHtml ? "<br>\n" : "\n");
 
 		// Two step process, parse all the input into an array of paragraph blocks and then output each block
 		// in wrapped form
 		LArray<WrapQuoteBlock> Para;
 		
 		// 1) Parse all input into paragraphs
 		char *i = In;
 		while (*i)
 		{
 			// Parse out the next line...
 			char *e = i;
 			while (*e && *e != '\n')
 				e++;
 			ssize_t len = e - i;
 			int depth = 0;
 			for (int n=0; n<len; n++)
 			{
 				if (i[n] == '>')
 					depth++;
 				else if (i[n] != ' ' || i[n] != '\t')
 					break;
 			}
 			
 			if (Para.Length())
 			{
 				// Can this be added to the previous paragraph?
 				WrapQuoteBlock &Prev = Para[Para.Length()-1];
 				if (Prev.Depth == depth)
 				{
 					// Yes?!
 					Prev.Text.Add(NewStr(i, len));
 					i = *e ? e + 1 : e;
 					continue;
 				}
 			}
 
 			// Create a new paragraph
 			WrapQuoteBlock &New = Para.New();
 			New.Depth = depth;
 			New.Text.Add(NewStr(i, len));
 			
 			// Move current position to next line
 			i = *e ? e + 1 : e;
 		}
 		
 		// 2) Output all paragraphs
 		const char *PrefixCharacters = "> \t";
 		for (unsigned n=0; n<Para.Length(); n++)
 		{
 			WrapQuoteBlock &p = Para[n];
 			ssize_t CharPos = 0;
 			
 			if (QuoteStr)
 			{
 				Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 				CharPos += QuoteChars;
 			}
 			
 			// Each line has the format:
 			//		[QuoteStr][Prefix][TextWords][NewLine]
 			
 			LAutoString Prefix;
 			ssize_t PrefixChars = 0;
 			for (unsigned l=0; l<p.Text.Length(); l++)
 			{
 				char *Line = p.Text[l];
 				// int LineLen = strlen(Line);
 				bool HardNewLine = true; // LineLen < Wrap;
 				char *Start = Line;
 				while (*Start && strchr(PrefixCharacters, *Start))
 					Start++;
 
 				if (!l)
 				{
 					// Create the prefix string
 					PrefixChars = Start - Line;
 					Prefix.Reset(NewStr(Line, PrefixChars));
 					
 					// Write the prefix string for the current line...
 					Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 					CharPos += PrefixChars;
 				}
 				
 				// Output [Start:EndOfLine] unless we run out of space on this line
 				while (*Start)
 				{
 					// Find end of the word.
 					char *End = Start;
 					while (*End && strchr(WhiteSpace, *End))
 						End++;
 					while (*End && !strchr(WhiteSpace, *End))
 						End++;
 					ssize_t WordLen = End - Start;
 					LAssert(WordLen > 0);
 					if (WordLen == 0)
 						break; // This won't end well...
 					
 					if (Wrap > 0)
 					{
 						// Check if we can put this word on the current line without making it longer than 'Wrap'
 						if (CharPos + WordLen > Wrap)
 						{
 							// No it won't fit... so emit [NewLine][QuoteStr][Prefix]
 							Pipe.Write(NewLine, NewLineLen);
 							if (QuoteStr)
 								Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 							Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 							
 							// Now we are ready to write more words...
 							CharPos = QuoteChars + PrefixChars;
 						}
 						// else Yes it fits...
 					}
 					
 					// Write out the word...
 					if (IsHtml && Strnchr(Start, '<', WordLen))
 					{
 						for (auto *c = Start; c < Start + WordLen; c++)
 							if (*c == '<')
 								Pipe.Print("&lt;");
 							else if (*c == '>')
 								Pipe.Print("&gt;");
 							else
 								Pipe.Write(c, sizeof(*c));
 					}
 					else
 						Pipe.Write(Start, WordLen * sizeof(*Start));
 					CharPos += WordLen;
 					
 					Start = End;
 				}
 				
 				if (HardNewLine)
 				{
 					Pipe.Write(NewLine, NewLineLen);
 					if (QuoteStr)
 						Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 					Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 					CharPos = QuoteChars + PrefixChars;
 				}
 			}
 
 			// Finish the paragraph
 			Pipe.Write(NewLine, NewLineLen);
 		}		
 	}
 }
 
 void Mail::WrapAndQuote(LStringPipe &p, const char *Quote, int WrapAt)
 {
 	LString Mem;
 	LAutoString Cp;
 	if (!ValidStr(GetBody()))
 		Mem = HtmlToText(GetHtml(), GetHtmlCharset());
 	else
 		Cp = GetCharSet();
 	
 	::WrapAndQuote(p, Quote, WrapAt > 0 ? WrapAt : 76, Mem ? Mem.Get() : GetBody(), Cp);
 }
 
 LAutoString Mail::GetSig(bool HtmlVersion, ScribeAccount *Account)
 {
 	LAutoString r;
 	LVariant Xml;
 		
 	if (!Account)
 		Account = GetAccountSentTo();
 
 	if (Account)
 	{
 		if (HtmlVersion)
 			Xml = Account->Identity.HtmlSig();
 		else
 			Xml = Account->Identity.TextSig();
 	}
 	
 	if (Xml.Str())
 	{
 		r = App->ProcessSig(this, Xml.Str(), HtmlVersion ? sTextHtml : sTextPlain);
 	}
 
 	return r;
 }
 
 void Mail::ProcessTextForResponse(Mail *From, LOptionsFile *Options, ScribeAccount *Account)
 {
 	LStringPipe Temp;
 	LVariant QuoteStr, Quote, WrapAt;
 	Options->GetValue(OPT_QuoteReply, Quote);
 	Options->GetValue(OPT_WrapAtColumn, WrapAt);
 	Options->GetValue(OPT_QuoteReplyStr, QuoteStr);
 
 	From->WrapAndQuote(Temp, Quote.CastInt32() ? QuoteStr.Str() : NULL, WrapAt.CastInt32());
 	
 	LAutoString s = From->GetSig(false, Account);
 	if (s)
 		Temp.Write(s, strlen(s));
 
 	s.Reset(Temp.NewStr());
 	SetBody(s);
 	SetBodyCharset("utf-8");
 }
 
 ScribeAccount *Mail::GetAccountSentTo()
 {
 	ScribeAccount *Account = App->GetAccountById(GetAccountId());
 	if (!Account)
 	{
 		// Older style lookup based on to address...
 		for (auto a : *App->GetAccounts())
 		{
 			LVariant e = a->Identity.Email();
 			if (ValidStr(e.Str()))
 			{
 				for (LDataPropI *t=GetTo()->First(); t; t=GetTo()->Next())
 				{
 					auto Addr = t->GetStr(FIELD_EMAIL);
 					if (ValidStr(Addr))
 					{
 						if (_stricmp(Addr, e.Str()) == 0)
 						{
 							Account = a;
 							break;
 						}
 					}
 				}
 			}
 		}
 	}
 	return Account;
 }
 
 void Mail::OnReceipt(Mail *m)
 {
 	if (m)
 	{
 		SetFlags(MAIL_CREATED | MAIL_READY_TO_SEND);
 
 		ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 		if (!MatchedAccount)
 		{
 			MatchedAccount = App->GetAccounts()->ItemAt(App->GetCurrentIdentity());
 		}
 		if (MatchedAccount)
 		{
 			GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		}
 
 		char Sent[64];
 		m->GetDateReceived()->Get(Sent, sizeof(Sent));
 
 		char Read[64];
 		LDateTime t;
 		t.SetNow();
 		t.Get(Read, sizeof(Read));
 
 		char s[256];
 		sprintf_s(s, sizeof(s), 
 				LLoadString(IDS_RECEIPT_BODY),
 				GetFrom()->GetStr(FIELD_NAME),
 				GetFrom()->GetStr(FIELD_EMAIL),
 				Sent,
 				m->GetSubject(),
 				Read);
 		SetBody(s);
 
 		sprintf_s(s, sizeof(s), "Read: %s", m->GetSubject() ? m->GetSubject() : (char*)"");
 		SetSubject(s);
 	}
 }
 
 LString Mail::GetMailRef()
 {
 	LString Ret;
 
 	if (auto MsgId = GetMessageId(true))
 	{
 	    LAssert(!strchr(MsgId, '\n'));
 	    
 		ScribeFolder *Fld = GetFolder();
 		LString FldPath;
 		if (Fld)
 		    FldPath = Fld->GetPath();
 
 		if (FldPath)
 		{
 			LUri u;
 			auto a = u.EncodeStr(MsgId, MsgIdEncodeChars);
 			if (a)
 				Ret.Printf("%s/%s", FldPath.Get(), a.Get());
 		}
 		else
 		{
 			Ret = MsgId;
 		}
 	}
 	
 	return Ret;
 }
 
 void Mail::OnReply(Mail *m, bool All, bool MarkOriginal)
 {
 	if (!m)
 	    return;
 
 	SetWillDirty(false);
 
 	LVariant ReplyAllSetting = MAIL_ADDR_TO;
 	if (All)
 	{
 		App->GetOptions()->GetValue(OPT_DefaultReplyAllSetting, ReplyAllSetting);
 	}
 		
 	if (MarkOriginal)
 	{
 		// source email has been replyed to
 		m->SetFlags(m->GetFlags() | MAIL_READ);
 	}
 
 	// this email is ready to send
 	SetFlags(GetFlags() | MAIL_READ | MAIL_CREATED);
 
 	LDataPropI *ToAddr = GetTo()->Create(GetObject()->GetStore());
 	if (ToAddr)
 	{
 		bool CopyStatus;
 		auto From = m->GetFrom();
 		auto Reply = m->GetReply();
 		auto ReplyTo = Reply->GetStr(FIELD_EMAIL);
 		if (ReplyTo)
 			CopyStatus = ToAddr->CopyProps(*Reply);
 		else
 			CopyStatus = ToAddr->CopyProps(*From);
 		LAssert(CopyStatus);
 
 		ToAddr->SetInt(FIELD_CC, ReplyAllSetting.CastInt32());
 		GetTo()->Insert(ToAddr);
 	}
 
 	LVariant UserName, EmailAddr, ReplyTo;
 
 	ScribeAccount *a = App->GetCurrentAccount();
 	if (a)
 	{
 		UserName = a->Identity.Name();
 		EmailAddr = a->Identity.Email();
 		ReplyTo = a->Identity.ReplyTo();
 	}
 	else LAssert(!"No current account.");
 
 	if (All)
 	{
 		for (LDataPropI *a = m->GetTo()->First(); a; a = m->GetTo()->Next())
 		{
 			bool Same = App->IsMyEmail(a->GetStr(FIELD_EMAIL));
 			
 			bool AlreadyThere = false;
 			for (LDataPropI *r = GetTo()->First(); r; r=GetTo()->Next())
 			{
 				if (_stricmp(r->GetStr(FIELD_EMAIL), a->GetStr(FIELD_EMAIL)) == 0)
 				{
 					AlreadyThere = true;
 					break;
 				}
 			}
 
 			if (!Same && !AlreadyThere)
 			{
 				LDataPropI *New = GetTo()->Create(GetObject()->GetStore());
 				if (New)
 				{
 					New->SetInt(FIELD_CC, ReplyAllSetting.CastInt32());
 					New->SetStr(FIELD_EMAIL, a->GetStr(FIELD_EMAIL));
 					New->SetStr(FIELD_NAME, a->GetStr(FIELD_NAME));
 					GetTo()->Insert(New);
 				}
 			}
 		}
 	}
 
 	ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 	if (MatchedAccount &&
 		MatchedAccount->Identity.Email().Str())
 	{
 		GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 		GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		
 		ReplyTo = MatchedAccount->Identity.ReplyTo();
 		if (ReplyTo.Str())
 		{
 			GetReply()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 	else
 	{
 		GetFrom()->SetStr(FIELD_NAME, UserName.Str());
 		GetFrom()->SetStr(FIELD_EMAIL, EmailAddr.Str());
 
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, UserName.Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 
 	char Re[32];
 	sprintf_s(Re, sizeof(Re), "%s:", LLoadString(IDS_REPLY_PREFIX));
 
 	auto SrcSubject = (m->GetSubject()) ? m->GetSubject() : "";
 	if (_strnicmp(SrcSubject, Re, strlen(Re)) != 0)
 	{
 		size_t Len = strlen(SrcSubject) + strlen(Re) + 2;
 		char *s = new char[Len];
 		if (s)
 		{
 			sprintf_s(s, Len, "%s %s", Re, SrcSubject);
 			SetSubject(s);
 			DeleteArray(s);
 		}
 	}
 	else
 	{
 		SetSubject(m->GetSubject());
 	}
 
 	auto EditMimeType = App->EditCtrlMimeType();
 	auto Xml = App->GetReplyXml(EditMimeType);
 	if (ValidStr(Xml))
 	{
 		RemoveReturns(Xml);
 		PreviousMail = m;
 
 		LString Body = App->ProcessReplyForwardTemplate(m, this, Xml, Cursor, EditMimeType);
 		
 		LVariant EditCtrl;
 		if (App->GetOptions()->GetValue(OPT_EditControl, EditCtrl) &&
 			EditCtrl.CastInt32())
 		{
 			SetHtml(Body);
 		}
 		else
 		{			
 			SetBody(Body);
 			SetBodyCharset("utf-8");
 		}
 
 		PreviousMail = 0;
 	}
 	else
 	{
 		ProcessTextForResponse(m, App->GetOptions(), MatchedAccount);
 	}
 
 	// Reference
 	SetReferences(0);
 	auto MailRef = m->GetMailRef();
 	if (MailRef)
 		SetReferences(MailRef);
 
 	GetMessageId(true);
 	SetWillDirty(true);
 
 	ScribeFolder *Folder = m->GetFolder();
 	if (Folder && Folder->IsPublicFolders())
 	{
 		SetParentFolder(Folder);
 	}
 }
 
 bool Mail::OnForward(Mail *m, bool MarkOriginal, int WithAttachments)
 {
 	if (!m)
 	{
 		LAssert(!"No mail object.");
 		LgiTrace("%s:%i - No mail object.\n", _FL);
 		return false;
 	}
 
 	// ask about attachments?
 	List<Attachment> Attach;
 	if (m->GetAttachments(&Attach) &&
 		Attach.Length() > 0)
 	{
 		if (WithAttachments < 0)
 		{
 			LView *p = (m->Ui)?(LView*)m->Ui:(LView*)App;
 			int Result = LgiMsg(p, LLoadString(IDS_ASK_FORWARD_ATTACHMENTS), AppName, MB_YESNOCANCEL);
 			if (Result == IDYES)
 			{
 				WithAttachments = 1;
 			}
 			else if (Result == IDCANCEL)
 			{
 				return false;
 			}
 		}
 	}
 
 	if (MarkOriginal)
 	{
 		// source email has been forwarded
 		auto MailRef = m->GetMailRef();
 		if (MailRef)
 			SetFwdMsgId(MailRef);
 	}
 
 	// this email is ready to send
 	SetFlags(GetFlags() | MAIL_CREATED);
 	SetDirty();
 
 	LVariant UserName, EmailAddr, ReplyTo;
 	ScribeAccount *a = App->GetCurrentAccount();
 	if (a)
 	{
 		UserName = a->Identity.Name();
 		EmailAddr = a->Identity.Email();
 		ReplyTo = a->Identity.ReplyTo();
 	}
 	else LAssert(!"No current account.");
 
 	ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 	if (MatchedAccount &&
 		MatchedAccount->Identity.Email().Str())
 	{
 		GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 		GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		
 		ReplyTo = MatchedAccount->Identity.ReplyTo();
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 	else
 	{
 		GetFrom()->SetStr(FIELD_NAME, UserName.Str());
 		GetFrom()->SetStr(FIELD_EMAIL, EmailAddr.Str());
 
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, UserName.Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 
 	SetBodyCharset(0);
 
 	char PostFix[32];
 	sprintf_s(PostFix, sizeof(PostFix), "%s:", LLoadString(IDS_FORWARD_PREFIX));
 
 	auto SrcSubject = (m->GetSubject()) ? m->GetSubject() : "";
 	if (_strnicmp(SrcSubject, PostFix, strlen(PostFix)) != 0)
 	{
 		size_t Len = strlen(SrcSubject) + strlen(PostFix) + 2;
 		char *s = new char[Len];
 		if (s)
 		{
 			sprintf_s(s, Len, "%s %s", PostFix, SrcSubject);
 			SetSubject(s);
 			DeleteArray(s);
 		}
 	}
 	else
 	{
 		SetSubject(m->GetSubject());
 	}
 
 	// Wrap/Quote/Sig the text...
 	const char *EditMimeType = App->EditCtrlMimeType();
 	LAutoString Xml = App->GetForwardXml(EditMimeType);
 	if (ValidStr(Xml))
 	{
 		RemoveReturns(Xml);
 		PreviousMail = m;
 		
 		LString Body = App->ProcessReplyForwardTemplate(m, this, Xml, Cursor, EditMimeType);
 		
 		LVariant EditCtrl;
 		if (App->GetOptions()->GetValue(OPT_EditControl, EditCtrl) &&
 			EditCtrl.CastInt32())
 		{
 			SetHtml(Body);
 		}
 		else
 		{			
 			SetBody(Body);
 			SetBodyCharset("utf-8");
 		}
 
 		PreviousMail = 0;
 	}
 	else
 	{
 		ProcessTextForResponse(m, App->GetOptions(), MatchedAccount);
 	}
 
 	// Attachments
 	if (WithAttachments > 0)
 		for (auto From: Attach)
 			AttachFile(new Attachment(App, From));
 
 	// Set MsgId
 	GetMessageId(true);
 
 	// Unless the user edits the message it shouldn't be made dirty.
 	SetDirty(false);
 
 	return true;
 }
 
 bool Mail::OnBounce(Mail *m, bool MarkOriginal, int WithAttachments)
 {
 	if (m)
 	{
 		if (MarkOriginal)
 		{
 			// source email has been forwarded
 			auto MsgId = m->GetMessageId(true);
 			if (MsgId)
 			{
 				ScribeFolder *Fld = m->GetFolder();
 				LString FldPath;
 				if (Fld)
 				    FldPath = Fld->GetPath();
 
 				if (FldPath)
 				{
 					LUri u;
 					LString a = u.EncodeStr(MsgId, MsgIdEncodeChars);
 					if (a)
 					{
 						LString p;
 						p.Printf("%s/%s", FldPath.Get(), a.Get());
 						SetBounceMsgId(p);
 					}
 				}
 				else
 				{
 					SetBounceMsgId(MsgId);
 				}
 			}
 			else m->SetFlags(m->GetFlags() | MAIL_BOUNCED);
 		}
 		
 		*this = (Thing&)*m;
 
 		GetTo()->DeleteObjects();
 		SetFlags(MAIL_READ | MAIL_BOUNCE);
 		return true;
 	}
 	
 	return false;
 }
 
 void Mail::OnMeasure(LPoint *Info)
 {
 	LListItem::OnMeasure(Info);
 
 	if (PreviewLines &&
 		!(GetFlags() & MAIL_READ) &&
 		(!GetObject() || !GetObject()->GetInt(FIELD_DONT_SHOW_PREVIEW)))
 	{
     	LFont *PreviewFont = App->GetPreviewFont();
 		Info->y += PreviewFont ? PreviewFont->GetHeight() << 1 : 28;
 	}
 }
 
 void Mail::OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c)
 {
 	int Field = 0;
 	if (FieldArray.Length())
 	{
 		Field = i >= 0 && i < (int)FieldArray.Length() ? FieldArray[i] : 0;
 	}
 	else if (i >= 0 && i < CountOf(DefaultMailFields))
 	{
 		Field = DefaultMailFields[i];
 	}
 
 	if (Container &&
 		i >= 0 &&
 		Field == FIELD_SUBJECT)
 	{
 		LFont *f = Parent->GetFont();
 		auto Subj = GetSubject();
 
 		if (Container)
 		{
 			// Container needs to paint the subject...
 			Container->OnPaint(Ctx.pDC, Ctx, c, Ctx.Fore, Ctx.Back, f?f:LSysFont, Subj);
 		}
 	}
 	else
 	{
 		LListItem::OnPaintColumn(Ctx, i, c);
 
 		if (i >= 0 && App->GetIconImgList())
 		{
 			int Icon = -1;
 			
 			switch (Field)
 			{
 				case FIELD_PRIORITY:
 				{
 					switch (GetPriority())
 					{
 						case MAIL_PRIORITY_HIGH:
 						{
 							Icon = ICON_PRIORITY_HIGH;
 							break;
 						}
 						case MAIL_PRIORITY_LOW:
 						{
 							Icon = ICON_PRIORITY_LOW;
 							break;
 						}
 						default:
 							break;
 					}
 
 					break;
 				}
 				case FIELD_FLAGS:
 				{
 					if (GetFlags() & MAIL_BOUNCED)
 					{
 						Icon = ICON_FLAGS_BOUNCE;
 					}
 					else if (GetFlags() & MAIL_REPLIED)
 					{
 						Icon = ICON_FLAGS_REPLY;
 					}
 					else if (GetFlags() & MAIL_FORWARDED)
 					{
 						Icon = ICON_FLAGS_FORWARD;
 					}
 					break;
 				}
 				default:
 					break;
 			}
 
 			if (Icon >= 0)
 			{
 				LRect *b = App->GetIconImgList()->GetBounds();
 				if (b)
 				{
 					b += Icon;
 					int x = Ctx.x1 + ((Ctx.X()-b->X())/2) - b->x1;
 					int y = Ctx.y1 + ((MIN(Ctx.Y(), 16)-b->Y())/2) - b->y1;
 
 					LColour Back(Ctx.Back);
 					App->GetIconImgList()->Draw(Ctx.pDC, x, y, Icon, Back);
 				}
 			}
 		}
 	}
 }
 
 void Mail::OnPaint(LItem::ItemPaintCtx &InCtx)
 {
 	LItem::ItemPaintCtx Ctx = InCtx;
 	
 	int64_t MarkCol = GetMarkColour();
 	if (MarkCol > 0)
 	{
         LColour Col((uint32_t)MarkCol, 32);
         LColour CtxBack(Ctx.Back);
 		LColour Mixed = Col.Mix(CtxBack, MarkColourMix);
         Ctx.Back = Mixed;
 	}
 
 	if (Parent) ((ThingList*)Parent)->CurrentMail = this;
 	LListItem::OnPaint(Ctx);
 	if (Parent) ((ThingList*)Parent)->CurrentMail = 0;
 	LFont *PreviewFont = App->GetPreviewFont();
 	LFont *ColumnFont = Parent && Parent->GetFont() ? Parent->GetFont() : LSysFont;
 
 	if (Parent &&
 		PreviewLines &&
 		PreviewFont &&
 		ColumnFont &&
 		GetObject() &&
 		!GetObject()->GetInt(FIELD_DONT_SHOW_PREVIEW) &&
 		!(GetFlags() & MAIL_READ))
 	{
 		int y = ColumnFont->GetHeight() + 2;
 		int Space = (Ctx.Y() - y) >> 1;
 		int Line = MAX(PreviewFont->GetHeight(), Space);
 		PreviewFont->Transparent(true);
 
 		// Setup
 		if (PreviewCache.Length() == 0 || abs(PreviewCacheX - Ctx.X()) > 20)
 		{
 			PreviewCache.DeleteObjects();
 			PreviewCacheX = Ctx.X();
 
 			LVariant v;
 			if (GetValue("BodyAsText[1024]", v) &&
 				v.Str())
 			{
 				char16 *Base = Utf8ToWide(v.Str());
 				char16 *Txt = Base;
 				int i;
 				for (i=0; Txt[i]; i++)
 				{
 					if (Txt[i] < ' ')
 						Txt[i] = ' ';
 				}
 
 				auto TxtLen = StrlenW(Txt);
 				for (i=0; Txt && *Txt && i<2; i++)
 				{
 					LDisplayString *Temp = new LDisplayString(PreviewFont, Txt, MIN(1024, TxtLen));
 					if (Temp)
 					{
 						int W = Ctx.X()-18;
 						ssize_t Cx = Temp->CharAt(W);
 						if (Cx > 0 && Cx <= TxtLen)
 						{
 							LDisplayString *d = new LDisplayString(PreviewFont, Txt, Cx);
 							if (d)
 							{
 								PreviewCache.Insert(d);
 							}
 							DeleteObj(Temp);
 							Txt += Cx; // LSeekUtf8
 							TxtLen -= Cx;
 						}
 						else break;
 					}
 				}
 				DeleteArray(Base);
 			}
 		}
 
 		// Display
 		LColour PreviewCol(App->GetColour(L_MAIL_PREVIEW));
 		if (Select())
 		{
 			int GreyPrev = PreviewCol.GetGray();
 			int GreyBack = Ctx.Back.GetGray();
 			
 			int d = GreyPrev - GreyBack;
 			if (d < 0) d = -d;
 			if (d < 128)
 			{
 				// too near
 				PreviewFont->Colour(Ctx.Fore, Ctx.Back);
 			}
 			else
 			{
 				// ok
 				PreviewFont->Colour(PreviewCol, Ctx.Back);
 			}
 		}
 		else
 		{
 			PreviewFont->Colour(PreviewCol, Ctx.Back);
 		}
 
 		for (auto p: PreviewCache)
 		{
 			p->Draw(Ctx.pDC, Ctx.x1+16, Ctx.y1+y, 0);
 			y += Line;
 		}
 	}
 }
 
 bool Mail::GetFormats(bool Export, LString::Array &MimeTypes)
 {
 	if (Export)
 	{
 		MimeTypes.Add("text/plain");
 		MimeTypes.Add(sMimeMbox);
 	}
 
 	MimeTypes.Add(sMimeMessage);
 	return MimeTypes.Length() > 0;
 }
 
 Thing::IoProgress Mail::Import(IoProgressImplArgs)
 {
 	if (!mimeType)
 		IoProgressError("No mime type.");
 
 	if (Stricmp(mimeType, sMimeMessage))
 		IoProgressNotImpl();
 
 	// Single email..
 	OnAfterReceive(stream);
 
 	int Flags = GetFlags();
 	Flags &= ~MAIL_CREATED;
 	Flags |= MAIL_READ;
 	SetFlags(Flags);
 
 	Update();
 
 	IoProgressSuccess();
 }
 
 #define TIMEOUT_OBJECT_LOAD		20000
 
 Thing::IoProgress Mail::Export(IoProgressImplArgs)
 {
 	if (!mimeType)	
 		IoProgressError("No mimetype.");
 
 	if (!Stricmp(mimeType, "text/plain"))
 	{
 		LStringPipe Buf;
 		char Str[256];
 		char Eol[] = EOL_SEQUENCE;
 
 		// Addressee
 		if (GetFlags() & MAIL_CREATED)
 		{
 			Buf.Push("To:");
 			for (LDataPropI *a=GetTo()->First(); a; a=GetTo()->Next())
 			{
 				sprintf_s(Str, sizeof(Str), "\t%s <%s>%s", a->GetStr(FIELD_NAME), a->GetStr(FIELD_EMAIL), Eol);
 				Buf.Push(Str);
 			}
 		}
 		else
 		{
 			sprintf_s(Str, sizeof(Str), "From: %s <%s>%s", GetFrom()->GetStr(FIELD_NAME), GetFrom()->GetStr(FIELD_EMAIL), Eol);
 			Buf.Push(Str);
 		}
 
 		// Subject
 		sprintf_s(Str, sizeof(Str), "Subject: %s%s", GetSubject(), Eol);
 		Buf.Push(Str);
 
 		// Sent date
 		if (GetDateSent()->Year())
 		{
 			int ch = sprintf_s(Str, sizeof(Str), "Sent Date: ");
 			GetDateSent()->Get(Str+ch, sizeof(Str)-ch);
 		}
 		else
 		{
 			int ch = sprintf_s(Str, sizeof(Str), "Date Received: ");
 			GetDateReceived()->Get(Str+ch, sizeof(Str)-ch);
 		}
 		strcat(Str, Eol);
 		Buf.Push(Str);
 
 		// Body
 		Buf.Push(Eol);
 		Buf.Push(GetBody());
 
 		// Write the output
 		auto s = Buf.NewLStr();
 		if (!s)
 			IoProgressError("No data to output.");
 		stream->Write(s.Get(), s.Length());
 
 		IoProgressSuccess();
 	}
 	else if (!Stricmp(mimeType, sMimeMbox))
 	{
 		char Temp[256];
 		
 		// generate from header
 		sprintf_s(Temp, sizeof(Temp), "From %s ", GetFrom()->GetStr(FIELD_EMAIL));
 		struct tm Ft;
 		
 		ZeroObj(Ft);
 		LDateTime Rec = *GetDateReceived();
 		if (!Rec.Year())
 		    Rec.SetNow();
 		Ft.tm_sec = Rec.Seconds();			/* seconds after the minute - [0,59] */
 		Ft.tm_min = Rec.Minutes();			/* minutes after the hour - [0,59] */
 		Ft.tm_hour = Rec.Hours();			/* hours since midnight - [0,23] */
 		Ft.tm_mday = Rec.Day();			/* day of the month - [1,31] */
 		Ft.tm_mon = Rec.Month() - 1;		/* months since January - [0,11] */
 		Ft.tm_year = Rec.Year() - 1900;    /* years since 1900 */
 		Ft.tm_wday = Rec.DayOfWeek();
 
 		strftime(Temp+strlen(Temp), MAX_NAME_SIZE, "%a %b %d %H:%M:%S %Y", &Ft);
 		strcat(Temp, "\r\n");
 		
 		// write mail
 		stream->Write(Temp, strlen(Temp));
 		auto Status = Export(stream, sMimeMessage, [cb](auto io, auto stream)
 		{
 			if (io->status == Store3Success)
 				stream->Write((char*)"\r\n.\r\n", 2);
 			else if (io->status == Store3Delayed)
 				LAssert(!"We should never get delayed here... it's the callback!");
 
 			if (cb)
 				cb(io, stream);
 		});
 
 		return Status;
 	}
 	else if (!Stricmp(mimeType, sMimeMessage))
 	{
 		// This function can't be asynchronous, it must complete with UI or waiting for a callback.
 		// Because it is used by the drag and drop system. Which won't wait.
 		auto state = GetLoaded();
 		if (state != Store3Loaded)
 			IoProgressError("Mail not loaded.");
 
 		if (!GetObject())
 			IoProgressError("No store object.");
 		
 		auto Data = GetObject()->GetStream(_FL);
 		if (!Data)
 			IoProgressError("Mail for export has no data.");
 		
 		Data->SetPos(0);
 		LCopyStreamer Cp(512<<10);
 		if (Cp.Copy(Data, stream) <= 0)
 			IoProgressError("Mail copy stream failed.");
 
 		IoProgressSuccess();
 	}
 
 	IoProgressNotImpl();
 }
 
 char *Mail::GetNewText(int Max, const char *AsCp)
 {
 	LAutoString CharSet = GetCharSet();
 	char *Txt = 0;
 
 	// This limits the preview of the text to
 	// the first 64kb, which is reasonable.
 	int Len = Max > 0 ? Strnlen(GetBody(), Max) : -1;
 
 	// Convert or allocate the text.
 	if (CharSet)
 	{
 		Txt = (char*)LNewConvertCp(AsCp, GetBody(), GetBodyCharset(), Len);
 	}
 	else
 	{
 		Txt = NewStr(GetBody(), Len);
 	}
 
 	return Txt;
 }
 
 LAutoString Mail::GetCharSet()
 {
 	LAutoString Status;
 	LAutoString ContentType;
 
 	if (GetBodyCharset())
 	{
 		// If the charset has a stray colon...
 		char *Colon = strchr(GetBodyCharset(), ';');
 		// Kill it.
 		if (Colon) *Colon = 0;
 		
 		// Copy the string..
 		Status.Reset(NewStr(GetBodyCharset()));
 	}
 
 	if (!GetBodyCharset())
 	{
 		ContentType.Reset(InetGetHeaderField(GetInternetHeader(), "Content-Type"));
 		if (ContentType)
 		{
 			char *CharSet = stristr(ContentType, "charset=");
 			if (CharSet)
 			{
 				CharSet += 8;
 				if (*CharSet)
 				{
 					if (strchr("\"\'", *CharSet))
 					{
 						char Delim = *CharSet++;
 						char *e = CharSet;
 						
 						while (*e && *e != Delim)
 						{
 							e++;
 						}
 						Status.Reset(NewStr(CharSet, e - CharSet));
 					}
 					else
 					{
 						char *e = CharSet;
 						while (*e && (IsDigit(*e) || IsAlpha(*e) || strchr("-_", *e)))
 						{
 							e++;
 						}
 						Status.Reset(NewStr(CharSet, e - CharSet));
 					}
 				}
 			}
 		}
 
 		/*
 		// If it's not a valid charset...
 		if (!LGetCsInfo(Status))
 		{
 			// Then kill it.
 			Status.Reset();
 			if (GetBodyCharset())
 			{
 				SetBodyCharset(0);
 				SetDirty();
 			}
 		}
 		*/
 	}
 
 	return Status;
 }
 
 /* Old Body Printing Code
 
 	int Lines = 0;
 	char *n;
 	for (n=Body.Str(); n && *n; n++)
 	{
 		if (*n == '\n') Lines++;
 	}
 
 	char *c = Body.Str();
 	if (c)
 	{
 		c = WrapLines(c, c ? strlen(c) : 0, 76);
 
 		Lines = 0;
 		for (n=c; *n; n++)
 		{
 			if (*n == '\n') Lines++;
 		}
 
 		while (c && *c)
 		{
 			if (Cy + Line > r.y2)
 			{
 				pDC->EndPage();
 
 				if (Window->GetMaxPages() > 0 &&
 					++Page >= Window->GetMaxPages())
 				{
 					break;
 				}
 
 				pDC->StartPage();
 				Cy = 0;
 			}
 
 			char *Eol = strchr(c, '\n');
 			int Len = 0;
 			int Ret = 0;
 			if (Eol)
 			{
 				Len = (int) Eol - (int) c;
 				if (Len > 0 && c[Len-1] == '\r')
 				{
 					Len--;
 					Ret = 1;
 				}
 			}
 			else
 			{
 				Len = strlen(c);
 			}
 
 			MailFont->Text(pDC, r.x1, Cy, c, Len);
 			Cy += Line;
 			c += Len + Ret;
 			if (*c == '\n') c++;
 		}
 	}
 */
 
 int Mail::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_TEXT:
 		{
 			LDocView *Doc = dynamic_cast<LDocView*>(Ctrl);
 			if (Doc)
 			{
 				if (n.Type == LNotifyShowImagesChanged)
 				{
 					if (Doc->GetLoadImages() ^ TestFlag(GetFlags(), MAIL_SHOW_IMAGES))
 					{
 						if (Doc->GetLoadImages())
 						{
 							SetFlags(GetFlags() | MAIL_SHOW_IMAGES);
 						}
 						else
 						{
 							SetFlags(GetFlags() & ~MAIL_SHOW_IMAGES);
 						}
 					}
 				}
 
 				if (n.Type == LNotifyFixedWidthChanged)
 				{
 					bool DocFixed = Doc->GetFixedWidthFont();
 					bool MailFixed = TestFlag(GetFlags(), MAIL_FIXED_WIDTH_FONT);
 
 					if (DocFixed ^ MailFixed)
 					{
 						if (Doc->GetFixedWidthFont())
 						{
 							SetFlags(GetFlags() | MAIL_FIXED_WIDTH_FONT);
 						}
 						else
 						{
 							SetFlags(GetFlags() & ~MAIL_FIXED_WIDTH_FONT);
 						}
 					}
 				}
 
 				if (n.Type == LNotifyCharsetChanged &&
 					dynamic_cast<Html1::LHtml*>(Doc))
 				{
 					char s[256];
 					sprintf_s(s, sizeof(s), ">%s", Doc->GetCharset());
 					SetHtmlCharset(s);
 				}
 			}
 			break;
 		}
 	}
 
 	return 0;
 }
 
 void Mail::OnPrintHeaders(ScribePrintContext &Context)
 {
 	char Str[256];
 
 	// print document
 	LDrawListSurface *Page = Context.Pages.Last();
 	
 	int Line = Context.AppFont->GetHeight();
 	Page->SetFont(Context.AppFont);
     LDisplayString *Ds = Context.Text(LLoadString(IDS_MAIL_MESSAGE));
 	Context.CurrentY += Line;
 
 	LDataPropI *Ad = GetTo()->First();
 	if (Ad)
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(FIELD_TO));
 
         Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		for (; Ad; Ad = GetTo()->Next())
 		{
 			if (Ad->GetStr(FIELD_EMAIL) && Ad->GetStr(FIELD_NAME))
 			{
 				sprintf_s(Str, sizeof(Str), "%s <%s>", Ad->GetStr(FIELD_NAME), Ad->GetStr(FIELD_EMAIL));
 			}
 			else if (Ad->GetStr(FIELD_EMAIL))
 			{
 				strcpy_s(Str, sizeof(Str), Ad->GetStr(FIELD_EMAIL));
 			}
 			else if (Ad->GetStr(FIELD_EMAIL))
 			{
 				strcpy_s(Str, sizeof(Str), Ad->GetStr(FIELD_EMAIL));
 			}
 			else continue;
 
 			Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 			Context.CurrentY += Ds->Y();
 		}
 	}
 
 	if (GetFrom()->GetStr(FIELD_EMAIL) || GetFrom()->GetStr(FIELD_NAME))
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(FIELD_FROM));
 
         Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		if (GetFrom()->GetStr(FIELD_EMAIL) && GetFrom()->GetStr(FIELD_NAME))
 		{
 			sprintf_s(Str, sizeof(Str), "%s <%s>", GetFrom()->GetStr(FIELD_NAME), GetFrom()->GetStr(FIELD_EMAIL));
 		}
 		else if (GetFrom()->GetStr(FIELD_EMAIL))
 		{
 			strcpy_s(Str, sizeof(Str), GetFrom()->GetStr(FIELD_EMAIL));
 		}
 		else if (GetFrom()->GetStr(FIELD_NAME))
 		{
 			strcpy_s(Str, sizeof(Str), GetFrom()->GetStr(FIELD_NAME));
 		}
 		else Str[0] = 0;
 
 		Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 		Context.CurrentY += Ds->Y();
 	}
 	
 	{
 		// Subject
 		LString s;
 		const char *Subj = GetSubject();
 		s.Printf("%s: %s", LLoadString(FIELD_SUBJECT), Subj?Subj:"");
 		Context.Text(s);
 	}
 
 	{
 		// Date
 		LString s;
 		GetDateSent()->Get(Str, sizeof(Str));
 		s.Printf("%s: %s", LLoadString(IDS_DATE), Str);
 		Context.Text(s);
 	}
 
 	// attachment list...
 	List<Attachment> Attached;
 	if (GetAttachments(&Attached) &&
 		Attached.Length() > 0)
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(IDS_ATTACHMENTS));
 		Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		for (auto a: Attached)
 		{
 			char Size[32];
 			LFormatSize(Size, sizeof(Size), a->GetSize());
 			sprintf_s(Str, sizeof(Str), "%s (%s)", a->GetName(), Size);
 			Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 			Context.CurrentY += Ds->Y();
 		}
 	}
 
 	// separator line
 	LRect Sep(Context.MarginPx.x1, Context.CurrentY + (Line * 5 / 10), Context.MarginPx.x2, Context.CurrentY + (Line * 6 / 10));
 	Page->Rectangle(&Sep);
 	Context.CurrentY += Line;
 }
 
 void Mail::OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages)
 {
 	// Text printing
 	LDrawListSurface *Page = Context.Pages.Last();
 	LVariant Body;
 	if (!GetVariant("BodyAsText", Body) || !Body.Str())
 	{
 		LgiTrace("%s:%i - No content to print.\n", _FL);
 		return;
 	}
 
 	LAutoWString w(Utf8ToWide(Body.Str()));
 	if (!w)
 	{
 		LgiTrace("%s:%i - Utf8ToWide failed.\n", _FL);
 		return;
 	}
 
 	Page->SetFont(Context.MailFont);
 	
 	for (char16 *s = w; s && *s; )
 	{
 		// Find end of line..
 		char16 *n = StrchrW(s, '\n');
 		if (!n) n = s + StrlenW(s);
 		ssize_t LineLen = n - s;
 
 		// Find how many characters will fit on the page
 		ssize_t Fit = 0;
 		if (n > s)
 		{
 			LDisplayString a(Context.MailFont, s, MIN(LineLen, 1024));
 			Fit = a.CharAt(Context.MarginPx.X());
 		}
 		if (Fit < 0)
 		{
 			break;
 		}
 
 		char16 *e = s + Fit;
 
 		if (e < n)
 		{
 			// The whole line doesn't fit on the page...
 			// Find the best breaking opportunity before that...
 			#define ExtraBreak(c) (	( (c) >= 0x3040 && (c) <= 0x30FF ) ||	\
 									( (c) >= 0x3300 && (c) <= 0x9FAF )		\
 								)
 			char16 *StartE = e;
 			while (e > s)
 			{
 				if (e[-1] == ' ' || ExtraBreak(e[-1]))
 				{
 					break;
 				}
 				e--;
 			}
 			if (e == s)
 			{
 				e = StartE;
 			}
 		}
 
 		// Output the segment of text
 		bool HasRet = e > s ? e[-1] == '\r' : false;
 		LString Str(s, (e - s) - (HasRet ? 1 : 0));
 		Context.Text(Str);
 
 		// Update the pointers
 		s = e;
 		if (*s == '\n') s++;
 	}
 }
 
 /// \returns the number of pages printed
 int Mail::OnPrintHtml(ScribePrintContext &Context, LPrintPageRanges &Pages, LSurface *RenderedHtml)
 {
 	// HTML printing...
 	LDrawListSurface *Page = Context.Pages.Last();
 
 	// Work out the scaling from memory bitmap to page..
 	double MemScale = (double) Context.pDC->X() / (double) RenderedHtml->X();
 	
 	// Now paint the bitmap onto the existing page
 	int PageIdx = 0, Printed = 0;
 	for (int y = 0; y < RenderedHtml->Y(); PageIdx++)
 	{
 		if (Pages.InRanges(PageIdx))
 		{
 			// Work out how much bitmap we can paint onto the current page...
 			int PageRemaining = Context.MarginPx.Y() - Context.CurrentY;
 			int MemPaint = (int) (PageRemaining / MemScale);
 
 			// This is how much of the memory context we can fit on the page
 			LRect MemRect(0, y, RenderedHtml->X()-1, y + MemPaint - 1);
 			LRect Bnds = RenderedHtml->Bounds();
 			MemRect.Bound(&Bnds);
 		
 			// Work out how much page that is take up
 			int PageHeight = (int) (MemRect.Y() * MemScale);
 		
 			// This is the position on the page we are blting to
 			LRect PageRect(Context.MarginPx.x1, Context.CurrentY, Context.MarginPx.x2, Context.CurrentY + PageHeight - 1);
 		
 			// Do the blt
 			Page->StretchBlt(&PageRect, RenderedHtml, &MemRect);
 			Printed++;
 		
 			// Now move our position down the page..
 			Context.CurrentY += PageHeight;
 			if ((Context.MarginPx.Y() - Context.CurrentY) * 100 / Context.MarginPx.Y() < 5)
 			{
 				// Ok we hit the end of the page and need to go to the next page
 				Context.CurrentY = Context.MarginPx.y1;
 				Page = Context.NewPage();
 			}
 
 			y += MemRect.Y();
 		}
 	}
 
 	return Printed;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 size_t Mail::Length()
 {
 	size_t Status = 0;
 
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			Status++;
 		}
 	}
 
 	return Status;
 }
 
 ssize_t Mail::IndexOf(Mail *m)
 {
 	ssize_t Status = -1;
 
 	ssize_t n = 0;
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			if (a->GetMsg() == m)
 			{
 				Status = n;
 				break;
 			}
 			n++;
 		}
 	}
 
 	return Status;
 }
 
 Mail *Mail::operator [](size_t i)
 {
 	size_t n = 0;
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			if (n == i)
 				return a->GetMsg();
 			n++;
 		}
 	}
 
 	return NULL;
 }
 
 bool Mail::LoadFromFile(char *File)
 {
 	if (File)
 	{
 		LAutoPtr<LFile> f(new LFile);
 		if (f->Open(File, O_READ))
 		{
 			return Import(AutoCast(f), sMimeMessage);
 		}
 	}
 
 	return false;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 bool CreateMailAddress(LStream &Out, LDataPropI *Addr, MailProtocol *Protocol)
 {
     if (!Addr)
         return false;
 
     auto Email = Addr->GetStr(FIELD_EMAIL);
     if (!Email)
         return false;
     
 	auto Name = LEncodeRfc2047(Addr->GetStr(FIELD_NAME), NULL/*charset*/, &Protocol->CharsetPrefs);
 	if (Name)
 	{
 		if (Name.Find("\"") >= 0)
 			Out.Print("'%s' ", Name.Get());
 		else
 			Out.Print("\"%s\" ", Name.Get());
 	}
 
 	Out.Print("<%s>", Email);
 	return true;
 }
 
 bool CreateMailHeaders(ScribeWnd *App, LStream &Out, LDataI *Mail, MailProtocol *Protocol)
 {
 	bool Status = true;
 
 	// Setup
 	char Buffer[1025];
 
 	// Construct date
 	LDateTime Dt;
 	int TimeZone = Dt.SystemTimeZone();
 	Dt.SetNow();
 	sprintf_s(Buffer, sizeof(Buffer),
 			"Date: %s, %i %s %i %i:%2.2i:%2.2i %s%2.2d%2.2d\r\n",
 			LDateTime::WeekdaysShort[Dt.DayOfWeek()],
 			Dt.Day(),
 			LDateTime::MonthsShort[Dt.Month()-1],
 			Dt.Year(),
 			Dt.Hours(),
 			Dt.Minutes(),
 			Dt.Seconds(),
 			(TimeZone >= 0) ? "+" : "",
 			TimeZone / 60,
 			abs(TimeZone) % 60);
 	Status &= Out.Write(Buffer, strlen(Buffer)) > 0;
 
 	if (Protocol && Protocol->ProgramName)
 	{
 		// X-Mailer:
 		Status &= Out.Print("X-Mailer: %s\r\n", Protocol->ProgramName.Get()) > 0;
 	}
 
 	if (Protocol && Protocol->ExtraOutgoingHeaders)
 	{
 		for (char *s=Protocol->ExtraOutgoingHeaders; s && *s; )
 		{
 			char *e = s;
 			while (*e && *e != '\r' && *e != '\n') e++;
 			ssize_t l = e-s;
 			if (l > 0)
 			{
 				Status &= Out.Write(s, l) > 0;
 				Status &= Out.Write((char*)"\r\n", 2) > 0;
 			}
 			while (*e && (*e == '\r' || *e == '\n')) e++;
 			s = e;
 		}
 	}
 
 	int Priority = (int)Mail->GetInt(FIELD_PRIORITY);
 	if (Priority != MAIL_PRIORITY_NORMAL)
 	{
 		// X-Priority:
 		Status &= Out.Print("X-Priority: %i\r\n", Priority) > 0;
 	}
 
     uint32_t MarkColour = (uint32_t)Mail->GetInt(FIELD_COLOUR);
 	if (MarkColour)
 	{
 		// X-Color (HTML Colour Ref for email marking)
 		Status &= Out.Print("X-Color: #%2.2X%2.2X%2.2X\r\n",
 			                R24(MarkColour),
 			                G24(MarkColour),
 			                B24(MarkColour)) > 0;
 	}
 
 	// Message-ID:
 	auto MessageID = Mail->GetStr(FIELD_MESSAGE_ID);
 	if (MessageID)
 	{
 		for (auto m=MessageID; *m; m++)
 		{
 			if (*m <= ' ')
 			{
 				printf("%s:%i - Bad message ID '%s'\n", _FL, MessageID);
 				return false;
 			}			
 		}
 		
 		Status &= Out.Print("Message-ID: %s\r\n", MessageID) > 0;
 	}
 
 	// References:
 	auto References = Mail->GetStr(FIELD_REFERENCES);
 	if (ValidStr(References))
 	{
 		auto Dir = strrchr(References, '/');
 		LString Ref;
 		if (Dir)
 		{
 			LUri u;
 			Ref = u.DecodeStr(Dir + 1);
 		}
 		else
 			Ref = References;
 
 		if (*Ref == '<')
     		Status &= Out.Print("References: %s\r\n", Ref.Get()) > 0;
     	else
 	    	Status &= Out.Print("References: <%s>\r\n", Ref.Get()) > 0;
 	}
 
 	// To:
 	LDataIt Addr = Mail->GetList(FIELD_TO);
 	LArray<Store3Addr*> Objs;
 	LArray<LDataPropI*> To, Cc;
 	ContactGroup *Group;
 	for (unsigned i=0; i<Addr->Length(); i++)
 	{
 	    LDataPropI *a = (*Addr)[i];
 	    EmailAddressType AddrType = (EmailAddressType)a->GetInt(FIELD_CC);
 
 		LString Addr = a->GetStr(FIELD_EMAIL);
 		if (LIsValidEmail(Addr))
 		{
 			if (AddrType == MAIL_ADDR_CC)
 				Cc.Add(a);
 			else if (AddrType == MAIL_ADDR_TO)
 				To.Add(a);
 		}
 		else if ((Group = LookupContactGroup(App, Addr)))
 		{
 			Group->UsedTs.SetNow();
 
 			LString::Array Addrs = Group->GetAddresses();
 			for (unsigned n=0; n<Addrs.Length(); n++)
 			{
 				Store3Addr *sa = new Store3Addr(Group->GetObject()->GetStore(), NULL);
 				if (sa)
 				{
 					sa->Addr = Addrs[n];
 					Objs.Add(sa);
 
 					if (AddrType == MAIL_ADDR_CC)
 						Cc.Add(sa);
 					else if (AddrType == MAIL_ADDR_TO)
 						To.Add(sa);
 				}
 			}
 		}
 	}
 	if (To.Length())
 	{
 	    for (unsigned i=0; i<To.Length(); i++)
 	    {
 	        if (i)
 	            Out.Print(",\r\n\t");
 	        else
     	        Out.Print("To: ");
             
             if (!CreateMailAddress(Out, To[i], Protocol))
                 return false;
 	    }
 	    Out.Print("\r\n");
 	}
 	if (Cc.Length())
 	{
 	    for (unsigned i=0; i<Cc.Length(); i++)
 	    {
 	        if (i)
 	            Out.Print(",\r\n\t");
 	        else
     	        Out.Print("Cc: ");
             
             if (!CreateMailAddress(Out, Cc[i], Protocol))
                 return false;
 	    }
 	    Out.Print("\r\n");
 	}
 
 	// From:
 	LDataPropI *From = Mail->GetObj(FIELD_FROM);
 	if (From && From->GetStr(FIELD_EMAIL))
 	{
 		Out.Print("From: ");
 		if (!CreateMailAddress(Out, From, Protocol))
 		    return false;
 		Out.Print("\r\n");
 	}
 	else
 	{
 		LgiTrace("%s:%i - No from address.\n", _FL);
 		return false;
 	}
 
 	// Reply-To:
 	LDataPropI *Reply = Mail->GetObj(FIELD_REPLY);
 	if (Reply && ValidStr(Reply->GetStr(FIELD_EMAIL)))
 	{
 		Out.Print("Reply-To: ");
 		if (!CreateMailAddress(Out, Reply, Protocol))
 		    return false;
 		Out.Print("\r\n");
 	}
 
 	// Subject:
 	char *Subj = EncodeRfc2047(NewStr(Mail->GetStr(FIELD_SUBJECT)), 0, &Protocol->CharsetPrefs, 9);
 	sprintf_s(Buffer, sizeof(Buffer), "Subject: %s\r\n", (Subj) ? Subj : "");
 	Status &= Out.Write(Buffer, strlen(Buffer)) > 0;
 	DeleteArray(Subj);
 
 	// DispositionNotificationTo
 	uint8_t DispositionNotificationTo = TestFlag(Mail->GetInt(FIELD_FLAGS), MAIL_READ_RECEIPT);
 	if (DispositionNotificationTo && From)
 	{
 		int ch = sprintf_s(Buffer, sizeof(Buffer), "Disposition-Notification-To:");
 		char *Nme = EncodeRfc2047(NewStr(From->GetStr(FIELD_NAME)), 0, &Protocol->CharsetPrefs);
 		if (Nme)
 		{
 			ch += sprintf_s(Buffer+ch, sizeof(Buffer)-ch, " \"%s\"", Nme);
 			DeleteArray(Nme);
 		}
 		ch += sprintf_s(Buffer+ch, sizeof(Buffer)-ch, " <%s>\r\n", From->GetStr(FIELD_EMAIL));
 		Status &= Out.Write(Buffer, ch) > 0;
 	}
 	
 	// Content-Type
 	LDataPropI *Root = Mail->GetObj(FIELD_MIME_SEG);
 	if (Root)
 	{
 		auto MimeType = Root->GetStr(FIELD_MIME_TYPE);
 		auto Charset = Root->GetStr(FIELD_CHARSET);
 		if (MimeType)
 		{
 			LString s;
 			s.Printf("Content-Type: %s%s%s\r\n", MimeType, Charset?"; charset=":"", Charset?Charset:"");
 			Status &= Out.Write(s, s.Length()) == s.Length();
 		}
 	}
 	else LAssert(0);
 	
 	Objs.DeleteObjects();
 	return Status;
 }
diff --git a/src/ScribeUtils.cpp b/src/ScribeUtils.cpp
--- a/src/ScribeUtils.cpp
+++ b/src/ScribeUtils.cpp
@@ -1,2104 +1,2106 @@
 #include "Scribe.h"
 
 #include "lgi/common/Http.h"
 #include "lgi/common/DocView.h"
 #include "lgi/common/Store3.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/OpenSSLSocket.h"
 #include "lgi/common/LgiRes.h"
 
 #include "ScribeUtils.h"
 #include "ScribeDefs.h"
 #include "ScribeListAddr.h"
 #include "resdefs.h"
 #include "../src/common/Coding/ScriptingPriv.h"
 
 #define COMP_FUNCTIONS 1
 #include "lgi/common/ZlibWrapper.h"
 
 static char Ws[] = " \t\r\n";
 
 #include "chardet.h"
 
 LString DetectCharset(LString s)
 {
 	DetectObj *obj = detect_obj_init ();
 	if (!obj)
 		return LString();
 
 	LString cs;
 	if (detect_r(s.Get(), s.Length(), &obj) == CHARDET_SUCCESS &&
 		obj->confidence >= 0.75)
 		cs = obj->encoding;
 
+	#if 0
 	LgiTrace("%s:%i - encoding=%s, obj->confidence=%f, obj->bom=%i, str='%s'\n",
 		_FL, obj->encoding, obj->confidence, obj->bom, s.Get());
+	#endif
 	
 	detect_obj_free (&obj);
 	return cs;
 }
 
 const char *ScribeResourcePath()
 {
 	static char Res[MAX_PATH_LEN] = {0};
 	if (!Res[0])
 	{
 		#if defined(LINUX)
 			// Check for AppImage location
 			LFile::Path app(LSP_APP_INSTALL);
 			app += "../../usr/share/applications";
 			if (app.Exists())
 			{
 				strcpy_s(Res, sizeof(Res), app.GetFull());
 				LgiTrace("%s:%i - Res: %s.\n", _FL, Res);
 				return Res;
 			}
 			// else LgiTrace("%s:%i - Warning: app image resource '%s' doesn't exist.\n", _FL, app.GetFull().Get());
 			// else fall through to portable mode
 		#elif defined(MAC)
 			// Find resource folder in app bundle
 			LMakePath(Res, sizeof(Res), LGetExeFile(), "Contents/Resources");
 			return Res;
 		#endif
 		
 		#if !defined(MAC)
 		const char *Paths[] = {
 			"./resources",
 			"../resources",
 			"../../resources",
 		};
 		bool Found = false;
 		for (unsigned i=0; i<CountOf(Paths); i++)
 		{
 			// Exe relative mode
 			LFile::Path p(LSP_APP_INSTALL);
 			p += Paths[i];
 			if (p.Exists())
 			{
 				Found = true;
 				strcpy_s(Res, sizeof(Res), p.GetFull());
 				break;
 			}
 		}
 		if (!Found)
 			LgiTrace("Resource folder: '%s' doesn't exist.\n", Res);
 
 		#ifdef _DEBUG
 		if (!Found)
 			LAssert(!"Can't find resource folder");
 		#endif
 		#endif
 	}
 	return Res;	
 }
 
 LString::Array ScribeThemePaths()
 {
 	LString::Array r;
 	
 	LFile::Path ro(ScribeResourcePath());
 	ro += "Themes";
 	if (ro.Exists())
 		r.Add(ro.GetFull());
 	
 	LFile::Path rw(LSP_APP_ROOT);
 	rw += "Themes";
 	if (rw.Exists())
 		r.Add(rw.GetFull());
 	
 	return r;
 }
 
 LString AskOverwriteMsg(const char *FileName)
 {
 	LString a, b;
 	a.Printf(LLoadString(IDS_ERROR_FILE_EXISTS), FileName);
 	b.Printf("\n%s\n", LLoadString(IDS_ERROR_FILE_OVERWRITE));
 	a += b;
 	return a;
 }
 
 char *RemoveAmp(const char *s)
 {
 	static char b[256];
 
 	if (!s)
 		return NULL;
 
 
 	char *r = b;
 	while (*s && r < b + sizeof(b) - 1)
 	{
 		if (s[0] != '&' || s[1] == '&')
 			*r++ = *s;
 		s++;
 	}
 	*r++ = 0;
 	return b;
 }
 
 LString AddAmp(const char *menu, int shortcut)
 {
 	LString s = menu;
 	for (unsigned i=0; i<s.Length(); i++)
 	{
 		if (ToLower(s(i)) == ToLower(shortcut))
 		{
 			LString m = s(0,i) + "&" + s(i,-1);
 			return m;
 		}
 	}
 
 	return s;
 }
 
 void PushVariant(LStringPipe &p, LVariant &v)
 {
 	switch (v.Type)
 	{
 		default:
 			break;
 		case GV_STRING:
 		{
 			p.Push(v.Str());
 			break;
 		}
 		case GV_INT32:
 		{
 			char i[32];
 			sprintf_s(i, sizeof(i), "%i", v.Value.Int);
 			p.Push(i);
 			break;
 		}
 		case GV_DOUBLE:
 		{
 			char d[32];
 			sprintf_s(d, sizeof(d), "%f", v.Value.Dbl);
 			p.Push(d);
 			break;
 		}
 		case GV_DATETIME:
 		{
 			char d[64];
 			v.Value.Date->Get(d, sizeof(d));
 			p.Push(d);
 			break;
 		}
 	}
 }
 
 void PushArrayContent(LStringPipe &p, char *&s, LDom *Source)
 {
 	// Process inside of array index
 	while (s && *s)
 	{
 		// Skin ws
 		while (*s && strchr(Ws, *s)) s++;
 		
 		// Is end of array brackets?
 		if (*s == ']')
 		{
 			break;
 		}
 		else if (*s == '\'' || *s == '\"')
 		{
 			// String const
 			char Delim = *s++;
 			char *e = strchr(s, Delim);
 			if (e)
 			{
 				p.Push(s, e-s);
 				s = e + 1;
 			}
 			else
 			{
 				s += strlen(s);
 				break;
 			}
 		}
 		else
 		{
 			// Variable
 			LStringPipe Var;
 			char *e = s;
 			int Depth = 0;
 			while (*e && !strchr(Ws, *e))
 			{
 				if (*e == '[')
 				{
 					e++;
 					Var.Push(s, e-s);
 					PushArrayContent(Var, e, Source);
 					s = e;
 					Depth++;
 				}
 				else if (*e == ']')
 				{
 					if (Depth > 0 || e[1] == '.')
 					{
 						// Continue the variable
 						if (Depth) Depth--;
 						e++;
 					}
 					else
 					{
 						// End the var
 						break;
 					}
 				}
 				else
 				{
 					e++;
 				}
 			}
 			Var.Push(s, e-s);
 			
 			char *Tok = Var.NewStr();
 			if (Tok)
 			{
 				LVariant v;
 				if (Source->GetValue(Tok, v))
 				{
 					PushVariant(p, v);
 				}
 				else
 				{
 					p.Push(Tok);
 				}
 				DeleteArray(Tok);
 			}
 			
 			s = e;
 		}
 	}
 }
 
 char *ScribeInsertFields(const char *Template, LDom *Source)
 {
 	if (Template && Source)
 	{
 		LStringPipe p;
 
 		char *n;
 		for (const char *s=Template; s && *s; s = n)
 		{
 			n = strstr((char*)s, "<?");
 			if (n)
 			{
 				// Output what is before this point
 				p.Push(s, n-s);
 
 				// Find variable name and write it
 				n += 2;
 				
 				// Skip ws
 				while (*n && strchr(Ws, *n)) n++;
 				
 				LStringPipe Var;
 				bool GotEnd = false;
 				for (char *s = n; s && *s; )
 				{
 					char *e = s;
 					while (*e)
 					{
 						if
 						(
 							(*e == '[')
 							||
 							(e[0] == '?' && e[1] == '>')
 							||
 							strchr(Ws, *e)
 						)
 						{
 							break;
 						}
 						
 						e++;
 					}
 					
 					if (*e == '[')
 					{
 						e++;
 						Var.Push(s, e-s);
 						
 						// Process inside of array index
 						PushArrayContent(Var, e, Source);
 					}
 					else if (strchr(Ws, *e))
 					{
 						// Skip whitespace
 						Var.Push(s, e-s);
 						while (*e && strchr(Ws, *e))
 						{
 							e++;
 						}
 					}
 					else if (e[0] == '?' && e[1] == '>')
 					{
 						// End of var
 						Var.Push(s, e-s);
 						GotEnd = true;
 						n = e;
 						break;
 					}
 					else
 					{
 						// error
 						n = e;;
 						break;
 					}
 					
 					s = e;
 				}
 				
 				if (GotEnd)
 				{
 					char *Name = Var.NewStr();
 					if (Name)
 					{
 						char *i = Name, *o = Name;
 						while (*i)
 						{
 							if (*i == '=')
 							{
 								i++;
 								char h[] = {i[0], i[1], 0};
 								*o++ = htoi(h);
 								i += 2;
 							}
 							else
 							{
 								*o++ = *i++;
 							}
 						}
 						*o++ = 0;
 
 						LVariant v;
 						if (Source->GetValue(Name, v))
 						{
 							switch (v.Type)
 							{
 								default: break;
 								case GV_STRING:
 								{
 									p.Push(v.Str());
 									break;
 								}
 								case GV_INT32:
 								{
 									char i[32];
 									sprintf_s(i, sizeof(i), "%i", v.Value.Int);
 									p.Push(i);
 									break;
 								}
 								case GV_DOUBLE:
 								{
 									char d[32];
 									sprintf_s(d, sizeof(d), "%f", v.Value.Dbl);
 									p.Push(d);
 									break;
 								}
 								case GV_DATETIME:
 								{
 									char d[64];
 									v.Value.Date->Get(d, sizeof(d));
 									p.Push(d);
 									break;
 								}
 							}
 						}
 
 						DeleteArray(Name);
 					}
 					n += 2;
 				}
 			}
 			else
 			{
 				p.Push(s);
 				break;
 			}
 		}
 
 		return p.NewStr();
 	}
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 HttpImageThread::HttpImageThread(ScribeWnd *app, const char *proxy, LThreadTarget *First) : LThreadWorker(First, "HtmlImageLoader")
 {
 	App = app;
 	Proxy = proxy;
 	Cache = ScribeTempPath();
 	if (!LDirExists(Cache))
 		FileDev->CreateFolder(Cache);
 }
 
 HttpImageThread::~HttpImageThread()
 {
 }
 
 void HttpImageThread::DoJob(LThreadJob *j)
 {
 	LDocumentEnv::LoadJob *Job = dynamic_cast<LDocumentEnv::LoadJob*>(j);
 	if (!Job)
 		return;
 
 	char *d = strrchr(Job->Uri, '/');
 	if (!d)
 	{
 		Job->Status = LDocumentEnv::LoadJob::JobErr_Uri;
 		Job->Error.Printf("No '/' in uri '%s'", Job->Uri.Get());
 		return;
 	}
 
 	LString CachedFile = UriMap.Find(Job->Uri);
 	if (!CachedFile)
 	{
 		char *Ext = LGetExtension(++d);
 		auto Qm = Ext ? strchr(Ext, '?') : NULL;
 		auto Len = Qm ? Qm - Ext : Strlen(Ext);
 		char p[MAX_PATH_LEN];
 
 		for (int i=0; i<1000; i++)
 		{
 			char Hash[256];
 			sprintf_s(Hash, sizeof(Hash), "%x_%i.%.*s", LHash<uint32_t, uchar>((uchar*)d + 1, -1, true), i++, (int)Len, Ext);
 
 			if (!LMakePath(p, sizeof(p), Cache, Hash))
 			{
 				Job->Status = LDocumentEnv::LoadJob::JobErr_Path;
 				Job->Error.Printf("MakePath failed: '%s' + '%s'", Cache.Get(), Hash);
 				return;
 			}
 			if (!LFileExists(p))
 				break;
 		}
 
 		UriMap.Add(Job->Uri, CachedFile = p);
 	}
 
 	if (!LFileExists(CachedFile))
 	{
 		const char *InHeaders = "User-Agent: Memecode Scribe\r\n"
 								"Accept: text/html,application/xhtml+xml,application/xml,image/png,image/*;q=0.9,*/*;q=0.8\r\n"
 								"Accept-Encoding: gzip, deflate\r\n";
 
 		LFile f;
 		if (f.Open(CachedFile, O_READWRITE))
 		{
 			LUri Prox(Proxy);			
 			bool r = LgiGetUri(this, &f, &Job->Error, Job->Uri, InHeaders, Proxy ? &Prox : NULL);
 			f.Close();
 			if (!r)
 			{
 				Job->Status = LDocumentEnv::LoadJob::JobErr_GetUri;
 				FileDev->Delete(CachedFile, false);
 			}
 		}
 		else
 		{
 			Job->Status = LDocumentEnv::LoadJob::JobErr_FileOpen;
 		}
 	}
 	
 	if (LFileExists(CachedFile))
 	{
 		LString::Array Mime = LGetFileMimeType(CachedFile).Split("/");
 		if (Mime[0].Equals("image"))
 		{
 			int Promote = GdcD->SetOption(GDC_PROMOTE_ON_LOAD, 0);
 			Job->pDC.Reset(GdcD->Load(CachedFile));
 			GdcD->SetOption(GDC_PROMOTE_ON_LOAD, Promote);
 			if (Job->pDC)
 			{
 				Job->Status = LDocumentEnv::LoadJob::JobOk;
 			}
 			else
 			{
 				char *d = strrchr(CachedFile, DIR_CHAR);
 				Job->Error.Printf("%s:%i - LoadDC(%s) failed [%s].", _FL, d?d+1:CachedFile.Get(), Job->Uri.Get());
 				FileDev->Delete(CachedFile, false);
 				Job->Status = LDocumentEnv::LoadJob::JobErr_ImageFilter;
 			}
 		}
 		else
 		{
 			// Css???
 			LFile *f = new LFile;
 			if (f)
 			{
 				if (f->Open(CachedFile, O_READ))
 				{
 					Job->Stream.Reset(f);
 					Job->Status = LDocumentEnv::LoadJob::JobOk;
 				}
 				else
 				{
 					Job->Status = LDocumentEnv::LoadJob::JobErr_FileOpen;
 					Job->Error.Printf("%s:%i - Cant read from '%s' (err=%i).", _FL, CachedFile.Get(), f->GetError());
 					delete f;
 				}
 			}
 			else
 				Job->Status = LDocumentEnv::LoadJob::JobErr_NoMem;
 		}
 	}
 	else if (!Job->Error)
 	{
 		Job->Status = LDocumentEnv::LoadJob::JobErr_NoCachedFile;
 		Job->Error = "No file in cache";
 	}
 	
 	if (Job->Error)
 	{
 		LgiTrace("Image load failed: %s\n", Job->Error.Get());
 	}
 }
 
 char *ScribeTempPath()
 {
 	static char Tmp[MAX_PATH_LEN] = "";
 
 	if (Tmp[0] == 0)
 	{
 		if (LGetSystemPath(LSP_TEMP, Tmp, sizeof(Tmp)))
 		{
 			LMakePath(Tmp, sizeof(Tmp), Tmp, "Scribe");
 		}
 		else
 		{
 			LgiTrace("%s:%i - LgiGetSystemPath(LSP_TEMP) failed.\n", _FL);
 			return NULL;
 		}
 	}
 
 	if (!LDirExists(Tmp))
 	{
 		LError Err;
 		if (!FileDev->CreateFolder(Tmp, true, &Err))
 		{
 			LgiTrace("%s:%i - CreateFolder(%s) failed with %i\n", _FL, Tmp, Err.GetCode());
 			return NULL;
 		}
 	}
 
 	return Tmp;
 }
 
 void ClearTempPath()
 {
 	char *Tmp = ScribeTempPath();
 	if (Tmp)
 	{
 		if (!LDirExists(Tmp))
 			FileDev->CreateFolder(Tmp);
 
 		LDirectory d;
 		for (int b = d.First(Tmp); b; b = d.Next())
 		{
 			if (!d.IsDir())
 			{
 				char p[256];
 				d.Path(p, sizeof(p));
 				FileDev->Delete(p, false);
 			}
 		}
 	}	
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 #define BufferLen_64ToBin(l)		( ((l)*3)/4 )
 #define BufferLen_BinTo64(l)		( ((((l)+2)/3)*4) )
 
 int DecodeUuencodedChar(const char *&s)
 {
 	int Status = -1;
 
 	if (*s == 0x60)
 	{
 		Status = 0;
 		s++;
 	}
 	else if (*s >= (' ' + 64) || *s < ' ')
 	{
 		printf("%s:%i - Invalid uuencode char: %c (%i)\n",
 			_FL, *s, (uchar)*s);
 	}
 	else
 	{
 		Status = *s - ' ';
 		s++;
 	}
 	
 	return Status;
 }
 
 bool DecodeUuencodedLine(LStreamI *Out, const char *Text, ssize_t Len)
 {
 	bool Status = false;
 	if (Text && Len > 1)
 	{
 		uchar *Buf = new uchar[Len];
 		if (Buf)
 		{
 			const char *End = Text + Len;
 			const char *c = Text;
 			uchar *d = Buf;
 			int Count = DecodeUuencodedChar(c);
 			int Processed = 0;
 			
 			if (Count < 0)
 				return false;
 
 			while (c < End && *c)
 			{
 				int t[4];
 
 				// De-text
 				t[0] = DecodeUuencodedChar(c);
 				if (t[0] < 0) break;
 				t[1] = DecodeUuencodedChar(c);
 				if (t[1] < 0) break;
 				t[2] = DecodeUuencodedChar(c);
 				if (t[2] < 0) break;
 				t[3] = DecodeUuencodedChar(c);
 				if (t[3] < 0) break;
 				
 				// Convert to binary
 				uchar b[3] = {
 					(uchar) ((t[0] << 2) | ((t[1] & 0x30) >> 4)),
 					(uchar) (((t[1] & 0xF) << 4) | ((t[2] & 0x3C) >> 2)),
 					(uchar) (((t[2] & 0x3) << 6) | (t[3]))
 				};
 
 				// Push onto the output stream
 				switch (Count - Processed)
 				{
 					case 1:
 					{
 						*d++ = b[0];
 						Processed++;
 						break;
 					}
 					case 2:
 					{
 						*d++ = b[0];
 						*d++ = b[1];
 						Processed += 2;
 						break;
 					}
 					default:
 					{
 						if (Count - Processed >= 3)
 						{
 							*d++ = b[0];
 							*d++ = b[1];
 							*d++ = b[2];
 							Processed += 3;
 						}
 						break;
 					}
 				}
 			}
 			
 			if (Processed != Count)
 			{
 				printf("%s:%i - uuencode line error, processed %i of %i\n",
 					_FL,
 					Processed, Count);
 			}
 
 			Status = Out->Write(Buf, d-Buf) > 0;
 
 			DeleteArray(Buf);
 		}
 	}
 	return Status;
 }
 
 bool DecodeUuencodedAttachment(LDataStoreI *Store, LArray<LDataI*> &Files, LStreamI *Out, const char *In)
 {
 	if (Store && In)
 	{
 		// const char Ws[] = " \t\r\n";
 		LStringPipe FileName;
 		LAutoPtr<LStringPipe> FileData;
 		const char *e;
 		const char *Last = In;
 		int Line = 1;
 
 		for (const char *s = In; s && *s; s = *e?e+1:e)
 		{
 			// Find the end of the line...
 			e = s;
 			while (*e && *e != '\n')
 				e++;
 
 			if (FileData)
 			{
 				if (_strnicmp(s, "end", 3) == 0)
 				{
 					// Write attachment
 					LDataI *Attachment = Store->Create(MAGIC_ATTACHMENT);
 					if (Attachment)
 					{
 						LAutoString Name(FileName.NewStr());
 						if (Name)
 						{
 							char *e = Name + strlen(Name);
 							while (e > Name.Get() && strchr(" \t\r\n", e[-1]))
 								*--e = 0;
 							Attachment->SetStr(FIELD_NAME, Name);
 						}
 						
 						LAutoStreamI fd(FileData.Release());
 						Attachment->SetStream(fd);
 						Files.Add(Attachment);
 					}
 					
 					FileData.Reset();
 				}
 				else if (!DecodeUuencodedLine(FileData, s, e - s))
 				{
 					/*
 					printf("%s:%i - DecodeUuencodedLine failed on line %i:\n\t%s\n",
 						_FL, Line, s);
 					*/
 				}
 			}
 			// Is it the start of a file
 			else if (_strnicmp(s, "begin ", 6) == 0)
 			{
 				if (Last)
 				{
 					Out->Write(Last, s - Last);
 					Last = 0;
 				}
 
 				auto Header = LString(s, e - s).SplitDelimit(" ", -1, true);
 				if (Header.Length() >= 3)
 				{
 					LMemQueue File;
 					for (int n=2; Header[n]; n++)
 					{
 						FileName.Print("%s%s", n==2?"":" ", Header[n].Get());
 					}
 				}
 
 				FileData.Reset(new LStringPipe(256));
 			}
 			else if (!Last)
 			{
 				Last = s;
 			}
 
 			Line++;
 		}
 
 		if (Files.Length() && Last)
 		{
 			Out->Write(Last, strlen(Last));
 		}
 	}
 
 	return Files.Length() > 0;
 }
 
 char *MakeFileName(const char *ContentUtf, const char *Ext)
 {
 	if (!ContentUtf)
 	{
 		LAssert(!"Invalid parameter.");
 		return 0;
 	}
 
 	char *Content = 0;
 	if (LIsUtf8(ContentUtf))
 	{
 		// Valid UTF-8
 		Content = NewStr(ContentUtf);
 	}
 	else
 	{
 		// Garbage, so just ignore the input data.
 		char n[256];
 		sprintf_s(n, sizeof(n), "_%i", LRand(1000000));
 		Content = NewStr(n);
 	}
 
 	if (!Content)
 	{
 		LAssert(!"No content to make filename from.");
 		return 0;
 	}
 
 	char File[MAX_PATH_LEN];
 
 	char *e = Content;
 	for (int i=0; i<64 && *e; i++)
 	{
 		char *before = e;
 		e = LSeekUtf8(e, 1);
 		if (e == before)
 		{
 			LAssert(!"LSeekUtf8 failed to more pointer forward.");
 			break;
 		}
 	}
 	*e = 0;
 
 	if (strlen(Content) > 0)
 	{
 		if (Ext)
 			sprintf_s(File, sizeof(File), "%s.%s", Content, Ext);
 		else
 			sprintf_s(File, sizeof(File), "%s", Content);
 	}
 	else
 	{
 		LAssert(!"No content for file name?");
 		strcpy_s(File, sizeof(File), "file");
 	}
 	
 	// Strip out invalid characters...
 	char *Out = File;
 	for (char *In = File; *In; In++)
 	{
 		if (!strchr("\\/?*:\"<>|\r\n", *In))
 		{
 			*Out++ = *In;
 		}
 	}
 	*Out++ = 0;
 
 	LAssert(strlen(File) > 0);
 
 	char Temp[MAX_PATH_LEN];
 	LMakePath(Temp, sizeof(Temp), ScribeTempPath(), File);
 	
 	if (LFileExists(Temp))
 	{
 		char *Dot = strrchr(Temp, '.');
 		for (int i=2; LFileExists(Temp); i++)
 		{
 			ssize_t Len = Dot - Temp;
 			sprintf_s(Dot, sizeof(Temp)-Len, "%i.%s", i, Ext);
 		}
 	}
 
 	DeleteArray(Content);
 
 	return NewStr(Temp);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 Store3Progress::Store3Progress(LView *parent, bool interact) : LProgressDlg(parent)
 {
 	Interact = interact;
 	NewFormat = -1;
 }
 
 const char *Store3Progress::GetStr(int id)
 {
 	switch (id)
 	{
 	case Store3UiError:
 		return Err;
 	case Store3UiStatus:
 		return (Cache = ItemAt(0)->GetDescription());
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 Store3Status Store3Progress::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 	case Store3UiError:
 		Err = str;
 		// Fall through
 	case Store3UiStatus:
 		ItemAt(0)->SetDescription(str);
 		return Store3Success;
 	}
 
 	LAssert(0);
 	return Store3Error;
 }
 
 int64 Store3Progress::GetInt(int id)
 {
 	switch (id)
 	{
 	case Store3UiCurrentPos:
 		return ItemAt(0)->Value();
 	case Store3UiInteractive:
 		return Interact;
 	case Store3UiCancel:
 		return IsCancelled();
 	case Store3UiNewFormat:
 		return NewFormat;
 	}
 
 	LAssert(0);
 	return -1;
 }
 
 Store3Status Store3Progress::SetInt(int id, int64 i)
 {
 	switch (id)
 	{
 	case Store3UiCancel:
 		return Store3Error;
 	case Store3UiCurrentPos:
 		ItemAt(0)->Value(i);
 		break;
 	case Store3UiMaxPos:
 		ItemAt(0)->SetRange(i);
 		break;				
 	case Store3UiNewFormat:
 		NewFormat = (int)i;
 		break;
 	default:
 		LAssert(0);
 		return Store3Error;
 	}
 	
 	return Store3Success;
 }
 
 
 ///////////////////////////////////////////////////////////////////////
 class BufferedTrace
 {
 	List<char> Traces;
 
 public:
 	~BufferedTrace()
 	{
 		for (auto s: Traces)
 		{
 			LgiTrace(s);
 			DeleteArray(s);
 		}
 	}
 
 	void Trace(char *s)
 	{
 		if (s)
 		{
 			Traces.Insert(NewStr(s));
 		}
 	}
 } ;
 
 static BufferedTrace Bt;
 
 void TraceTime(char *s)
 {
 	static int64 Last = 0;
 	if (s)
 	{
 		int64 Now = LCurrentTime();
 		int64 Diff = 0;
 		if (Last)
 		{
 			Diff = Now - Last;
 		}
 		else
 		{
 			Diff = 0;
 		}
 		Last = Now;
 
 		char m[256];
 		sprintf_s(m, sizeof(m), "%s (+%i)", s, (int)Diff);
 		Bt.Trace(m);
 	}
 	else
 	{
 		Last = 0;
 	}
 }
 
 /////////////////////////////////////////////////////////////////////////////
 Counter::~Counter()
 {
 	for (auto c: *this)
 	{
 		DeleteObj(c);
 	}
 }
 
 CountItem *Counter::FindType(int Type)
 {
 	for (auto c: *this)
 	{
 		if (Type == c->Type)
 		{
 			return c;
 		}
 	}
 
 	CountItem *c = new CountItem;
 	if (c)
 	{
 		c->Type = Type;
 		Insert(c);
 	}
 
 	return c;
 }
 
 void Counter::Inc(int Type)
 {
 	CountItem *c = FindType(Type);
 	if (c)
 	{
 		c->Count++;
 	}
 }
 
 void Counter::Dec(int Type)
 {
 	CountItem *c = FindType(Type);
 	if (c)
 	{
 		c->Count--;
 	}
 }
 
 void Counter::Add(int Type, int64 n)
 {
 	CountItem *c = FindType(Type);
 	if (c)
 	{
 		c->Count += n;
 	}
 }
 
 void Counter::Sub(int Type, int64 n)
 {
 	CountItem *c = FindType(Type);
 	if (c)
 	{
 		c->Count -= n;
 	}
 }
 
 int64 Counter::GetTypeCount(int Type)
 {
 	CountItem *c = FindType(Type);
 	if (c)
 	{
 		return c->Count;
 	}
 	return 0;
 }
 
 //////////////////////////////////////////////////////////
 ItemFieldDef *ScribeGetFieldDefs(int Type)
 {
 	switch ((uint32_t)Type)
 	{
 		case MAGIC_MAIL:
 		{
 			return MailFieldDefs;
 		}
 		case MAGIC_CONTACT:
 		{
 			return ContactFieldDefs;
 		}
 		case MAGIC_CALENDAR:
 		{
 			return CalendarFields;
 		}
 	}
 
 	return 0;
 }
 
 Contact *IsContact(LListItem *Item)
 {
 	return dynamic_cast<Contact*>(Item);
 }
 
 Mail *IsMail(LListItem *Item)
 {
 	return dynamic_cast<Mail*>(Item);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 char sMimeVCard[] = "text/x-vcard";
 char sMimeVCalendar[] = "text/calendar";
 char sMimeICalendar[] = "application/ics";
 char sMimeMbox[] = "text/mbox";
 char sMimeLgiResource[] = "application/x-lgi-resource";
 char sMimeMessage[] = "message/rfc822";
 char sMimeXml[] = "text/xml";
 
 LString ScribeGetFileMimeType(const char *File)
 {
 	LString Ret;
 	if (File)
 	{
 		char *Ext = LGetExtension((char*)File);
 		if (Ext)
 		{
 			if (_stricmp(Ext, "lr8") == 0)
 			{
 				Ret = sMimeLgiResource;
 			}
 			else if (_stricmp(Ext, "ici") == 0)
 			{
 				Ret = "application/x-ici";
 			}
 			else if (_stricmp(Ext, "vcf") == 0)
 			{
 				Ret = sMimeVCard;
 			}
 			else if (_stricmp(Ext, "vcs") == 0 ||
 					 _stricmp(Ext, "ics") == 0)
 			{
 				Ret = sMimeVCalendar;
 			}
 			else if (_stricmp(Ext, "eml") == 0)
 			{
 				Ret = sMimeMessage;
 			}
 			#if defined WIN32
 			// Hard code extensions (because windows doesn't get it right)
 			else if (_stricmp(Ext, "mbx") == 0 ||
 					 _stricmp(Ext, "mbox") == 0)
 			{
 				Ret = sMimeMbox;
 			}
 			#endif
 		}
 
 		if (!Ret)
 		{
 			// Do normal lookup
 			Ret = LGetFileMimeType(File);
 		}
 	}
 
 	return Ret;
 }
 
 /////////////////////////////////////////////////////////////////////
 Mailto::Mailto(ScribeWnd *app, const char *s)
 {
 	App = app;
 	Subject = NULL;
 	Body = NULL;
 
 	if (!s)
 		return;
 
 	// Do some detection of what type of string this is...
 	//
 	// Could be in various formats:
 	//	1. user@isp.com
 	//	2. user@isp.com, user2@isp.com, user3@isp.com
 	//  3. "First Last" <user@isp.com>
 	//  4. "First Last" <user@isp.com>, "First2 Last2" <user2@isp.com>
 	//  5. mailto:user@isp.com
 	//  6. mailto:user@isp.com?subject=xxxxxx&body=xxxxxxxx
 
 	// Skip whitespace
 	while (*s && strchr(" \t\r\n", *s)) s++;
 
 	// Check for mailto prefix
 	if (_strnicmp(s, "mailto:", 7) == 0)
 	{
 		// Parse mailto URI
 		char *e = NewStr(s + 7);
 
 		char *In, *Out = e;
 		for (In = e; *In; )
 		{
 			if (In[0] == '%' &&
 				In[1] &&
 				In[2])
 			{
 				char h[3] = { In[1], In[2], 0 };
 				*Out++ = htoi(h);
 				In += 3;
 			}
 			else
 			{
 				*Out++ = *In++;
 			}
 		}
 		*Out++ = 0;
 
 		// Process mailto syntax
 		char *Question = strchr(e, '?');
 		if (Question)
 		{
 			*Question++ = 0;
 
 			// Split all the headers up
 			auto Headers = LString(Question).SplitDelimit("&");
 			for (unsigned h=0; h<Headers.Length(); h++)
 			{
 				char *Header = Headers[h];
 				if (Header)
 				{
 					// Split the header into name, value pairs
 					char *Value = strchr(Header, '=');
 					if (Value)
 					{
 						*Value++ = 0;
 
 						if (ValidStr(Header) && ValidStr(Value))
 						{
 							// Both parts of the header are sane
 							if (_stricmp(Header, "Subject") == 0)
 							{
 								// Subject
 								Subject = LDecodeUri(Value);
 							}
 							else if (_stricmp(Header, "Body") == 0)
 							{
 								// Body
 								Body = LDecodeUri(Value);
 							}
 							else if (_stricmp(Header, "To") == 0)
 							{
 								char *s = LDecodeUri(Value);
 								if (s)
 								{
 									// SetRecipients(m->Text, m->To, 0);
 									ListAddr *la = new ListAddr(App);
 									if (la)
 									{
 										la->sAddr = s;
 										To.Insert(la);
 									}
 									DeleteArray(s);
 								}
 							}
 							// else unknown header???
 						}
 					}
 				}
 			}
 		}
 
 		// Anything left over in 'Str' is a recipient
 		if (ValidStr(e))
 		{
 			// add recipients
 			ListAddr *la = new ListAddr(App);
 			if (la)
 			{
 				la->sAddr = e;
 				To.Insert(la);
 			}
 		}
 
 		DeleteArray(e);
 	}
 	else
 	{
 		// Not a mailto, apply normal email recipient parsing
 		char White[] = " \t\r\n";
 		#define SkipWhite(s) while (*s && strchr(White, *s)) s++;
 
 		const char *Addr = s;
 		for (const char *c = s; true;)
 		{
 			SkipWhite(c);
 			if (*c == '\'' || *c == '\"')
 			{
 				char Delim = *c++;
 				char *e = strchr((char*)c, Delim);
 				if (e) c = e + 1;
 				else c += strlen(c);
 			}
 			else if (*c == '<')
 			{
 				char *e = strchr((char*)c, '>');
 				if (e) c = e + 1;
 				else c++;
 			}
 			else if (*c == ',' || *c == 0)
 			{
 				char *a = NewStr(Addr, c - Addr);
 				if (a)
 				{
 					LAutoString Name, Addr;
 					DecodeAddrName(a, Name, Addr, 0);
 					if (Name || Addr)
 					{
 						ListAddr *la = new ListAddr(App);
 						if (la)
 						{
 							if (Name && Addr)
 							{
 								la->sName = Name.Get();
 								la->sAddr = Addr.Get();
 							}
 							else
 							{
 								la->sAddr = Name ? Name.Get() : Addr.Get();
 							}
 							To.Insert(la);
 						}
 					}
 
 					DeleteArray(a);
 				}
 
 				if (!*c)
 					break;
 				else
 				{
 					c++;
 					SkipWhite(c);
 					Addr = c;
 				}
 			}
 			else c++;
 		}
 	}
 }
 
 Mailto::~Mailto()
 {
 	To.DeleteObjects();
 	DeleteArray(Subject);
 	DeleteArray(Body);
 }
 
 void Mailto::Apply(Mail *m)
 {
 	if (m)
 	{
 		bool Dirty = false;
 
 		if (Subject)
 		{
 			m->SetSubject(Subject);
 			Dirty = true;
 		}
 
 		if (Body)
 		{
 			LVariant HtmlEdit;
 			m->App->GetOptions()->GetValue(OPT_EditControl, HtmlEdit);
 
 			auto Email = m->GetFromStr(FIELD_EMAIL);
 			ScribeAccount *Acc = m->App->GetAccountByEmail(Email);
 			if (!Acc)
 				Acc = m->App->GetCurrentAccount();
 			LVariant Sig;
 			LString Content;
 			if (Acc)
 			{
 				if (HtmlEdit.CastInt32())
 				{
 					Sig = Acc->Identity.HtmlSig();
 					if (Sig.Str())
 					{
 						char *s = Sig.Str();
 						char *e = stristr(s, "<body>");
 						if (e)
 							Content.Printf("%.*s\n%s\n%s", e - s, s, Body, e + 6);
 						else
 							Content.Printf("%s\n%s", Body, s);
 					}
 					else
 						Content = Body;
 				}
 				else
 				{
 					Sig = Acc->Identity.TextSig();
 					Content.Printf("%s\n%s", Body, Sig.Str());
 				}
 			}
 
 			if (HtmlEdit.CastInt32())
 				m->SetHtml(Content);
 			else
 				m->SetBody(Content);
 			
 			Dirty = true;
 		}
 
 		for (auto t: To)
 		{
 			LDataIt To = m->GetObject()->GetList(FIELD_TO);
 			if (To)
 			{
 				LDataPropI *Addr = To->Create(m->GetObject()->GetStore());
 				if (Addr)
 				{
 					LDataPropI *p = dynamic_cast<LDataPropI*>(t);
 					if (p)
 					{
 						Addr->CopyProps(*p);
 						To->Insert(Addr);
 					}
 					else
 					{
 						LAssert(!"Not the right object.");
 						DeleteObj(Addr);
 					}
 				}
 
 				if (m->GetUI())
 				{
 					m->GetUI()->AddRecipient(new ListAddr(App, t));
 				}
 				Dirty = true;
 			}
 		}
 
 		if (Dirty)
 			m->SetDirty();
 	}
 }
 
 ScribeDom::ScribeDom(ScribeWnd *a)
 {
 	App = a;
 	Email = NULL;
 	Con = NULL;
 	Cal = NULL;
 	Fil = NULL;
 	Grp = NULL;
 }
 
 bool ScribeDom::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdScribe: // Type: ScribeWnd
 		{
 			Value = (LDom*)App;
 			break;
 		}
 		case SdMail: // Type: Mail
 		{
 			Value = Email;
 			break;
 		}
 		case SdContact: // Type: Contact
 		{
 			Value = Con;
 			break;
 		}
 		case SdContactGroup: // Type: ContactGroup
 		{
 			Value = Grp;
 			break;
 		}
 		case SdCalendar: // Type: Calendar
 		{
 			Value = Cal;
 			break;
 		}
 		case SdFilter: // Type: Filter
 		{
 			Value = Fil;
 			break;
 		}
 		case SdNow: // Type: String
 		{
 			char n[256];
 			LDateTime Now;
 			Now.SetNow();
 			Now.Get(n, sizeof(n));
 			Value = n;
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 #include "lgi/common/Html.h"
 #include "lgi/common/Button.h"
 
 class HtmlMsg : public LDialog, public LDefaultDocumentEnv
 {
 	LTableLayout *Tbl = NULL;
 	Html1::LHtml *Html2 = NULL;
 
 public:
 	HtmlMsg(LViewI *Parent, const char *Html, const char *Title, int Type)
 	{
 		LPoint Size(300, 300);
 		SetParent(Parent);
 		Name(Title?Title:"Message");
 		
 		AddView(Tbl = new LTableLayout(2222));
 		auto c = Tbl->GetCell(0, 0);
 		if (c->Add(Html2 = new Html1::LHtml(100, 0, 0,
 									  (int)(GdcD->X() * 0.5),
 									  (int)(GdcD->Y() * 0.75),
 									  this)))
 		{
 			Html2->SetCharset("utf-8");
 			Html2->Name(Html);
 
 			/*
 			Size = Html2->Layout();
 			LRect r(0, 0, Size.x, Size.y);
 			Html2->SetPos(r);
 			*/
 		}
 
 		LArray<LButton*> Btns;
 		switch (Type & 0xf)
 		{
 			case MB_OK:
 				Btns.Add(new LButton(IDOK, 0, 0, -1, -1, "Ok"));
 				break;
 			case MB_OKCANCEL:
 				Btns.Add(new LButton(IDOK, 0, 0, -1, -1, "Ok"));
 				Btns.Add(new LButton(IDCANCEL, 0, 0, -1, -1, "Cancel"));
 				break;
 			case MB_YESNO:
 				Btns.Add(new LButton(IDYES, 0, 0, -1, -1, "Yes"));
 				Btns.Add(new LButton(IDNO, 0, 0, -1, -1, "No"));
 				break;
 			case MB_YESNOCANCEL:
 				Btns.Add(new LButton(IDYES, 0, 0, -1, -1, "Yes"));
 				Btns.Add(new LButton(IDNO, 0, 0, -1, -1, "No"));
 				Btns.Add(new LButton(IDCANCEL, 0, 0, -1, -1, "Cancel"));
 				break;
 		}
 
 		c = Tbl->GetCell(0, 1);
 		c->TextAlign(LCss::AlignCenter);
 
 		for (auto b: Btns)
 			c->Add(b);
 		
 		LRect r(0, 0,
 				Size.x + 20 + LAppInst->GetMetric(LGI_MET_DECOR_X),
 				Size.y + 20 + LSysFont->GetHeight() + LAppInst->GetMetric(LGI_MET_DECOR_CAPTION) + LAppInst->GetMetric(LGI_MET_DECOR_Y));
 		SetPos(r);
 		MoveSameScreen(Parent);
 	}
 
 	void OnPosChange()
 	{
 		if (Tbl)
 			Tbl->SetPos(GetClient());
 	}
 	
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case IDOK:
 			case IDCANCEL:
 			case IDYES:
 			case IDNO:
 				EndModal(Ctrl->GetId());
 				break;
 		}
 		
 		return LDialog::OnNotify(Ctrl, n);
 	}
 };
 
 void LHtmlMsg(std::function<void(int)> Callback, LViewI *Parent, const char *Html, const char *Title, int Type, ...)
 {
 	va_list Arg;
 	va_start(Arg, Type);
 	#undef vsnprintf
 	int length = vsnprintf(NULL, 0, Html, Arg);
 	LAutoString Msg(new char[++length]);
 	vsprintf_s(Msg, length, Html, Arg);
 	va_end(Arg);
 
 	auto Dlg = new HtmlMsg(Parent, Msg, Title, Type);
 	Dlg->DoModal([Callback](auto dlg, auto id)
 	{
 		if (Callback)
 			Callback(id);
 		delete dlg;
 	});
 }
 
 /////////////////////////////////////////////////////////////////////////////
 void TabDialog::OnCreate()
 {
 	LTabView *Tab;
 	if (GetViewById(TabCtrlId, Tab))
 	{
 		Tab->SetPourChildren(true);
 		LRect r(0, 0, 100, 100);
 		Tab->SetPos(r);
 	}
 	
 	OnPosChange();
 }
 
 void TabDialog::IdealSize(LButton *b)
 {
 	LViewLayoutInfo Inf;
 	if (b->OnLayout(Inf))
 	{
 		b->OnLayout(Inf);
 	}
 	else if (b->GetWindow())
 	{
 		auto s = b->GetWindow()->GetDpiScale();
 		LDisplayString ds(b->GetFont(), b->Name());
 		Inf.Width.Max = (int32)(ds.X() + (s.x * LButton::Overhead.x));
 		Inf.Height.Max = (int32)(ds.Y() + (s.y * LButton::Overhead.y));
 	}
 	else
 	{
 		LAssert(!"No way to set ideal size.");
 		return;
 	}
 	
 	LRect p = b->GetPos();
 	p.SetSize(Inf.Width.Max, Inf.Height.Max);
 	b->SetPos(p);
 }
 
 void TabDialog::OnPosChange()
 {
 	LButton *Ok = 0, *Cancel = 0, *Help = 0;
 	LViewI *Tab = 0;
 
 	if (GetViewById(TabCtrlId, Tab) &&
 		GetViewById(IDOK, Ok) &&
 		GetViewById(IDCANCEL, Cancel))
 	{
 		GetViewById(HelpBtnId, Help);
 
 		LRect r = GetClient();
 		r.Inset(LTableLayout::CellSpacing, LTableLayout::CellSpacing);
 		
 		IdealSize(Ok);
 		IdealSize(Cancel);
 
 		LRect t = r;
 		t.y2 -= LTableLayout::CellSpacing + Ok->Y();
 		Tab->SetPos(t);
 		
 		if (Help)
 		{
 			IdealSize(Help);
 
 			LRect h = Help->GetPos();
 			h.Offset(r.x1 - h.x1, r.y2 - h.Y() + 1 - h.y1);
 			Help->SetPos(h);
 		}
 
 		LRect c = Cancel->GetPos();
 		c.Offset(r.x2 - c.X() + 1 - c.x1, r.y2 - c.Y() + 1 - c.y1);
 		Cancel->SetPos(c);
 
 		LRect o = Ok->GetPos();
 		o.Offset(c.x1 - LTableLayout::CellSpacing - o.X() + 1 - o.x1, r.y2 - o.Y() + 1 - o.y1);
 		Ok->SetPos(o);
 	}
 }
 
 LAutoString ConvertThreadIndex(char *ThreadIndex, int TruncateChars)
 {
 	LAutoString a;
 
 	if (ThreadIndex)
 	{
 		uchar InBuf[256];
 		ssize_t In = ConvertBase64ToBinary(InBuf, sizeof(InBuf), ThreadIndex, strlen(ThreadIndex));
 		LAssert(In >= 22);
 		
 		LStringPipe OutBuf(256);
 		for (int i=0; i<In-TruncateChars; i++)
 		{
 			OutBuf.Print("%2.2x", InBuf[i]);
 		}
 		
 		a.Reset(OutBuf.NewStr());
 	}
 	
 	return a;
 }
 
 ScribeProtocol ProtocolStrToEnum(const char *str)
 {
 	if (!str)
 		return ProtocolNone;
 
 	if (!_stricmp(str, PROTOCOL_POP3))
 		return ProtocolPop3;
 	if (!_stricmp(str, PROTOCOL_IMAP4_FETCH))
 		return ProtocolImapFetch;
 	if (!_stricmp(str, PROTOCOL_IMAP4))
 		return ProtocolImapFull;
 	if (!_stricmp(str, PROTOCOL_CALENDAR))
 		return ProtocolCalender;
 	if (!_stricmp(str, PROTOCOL_POP_OVER_HTTP))
 		return ProtocolPopOverHttp;
 	if (!_stricmp(str, PROTOCOL_MAPI))
 		return ProtocolMapi;
 	if (!_stricmp(str, PROTOCOL_SMTP))
 		return ProtocolSmtp;
 	
 	LAssert(!"Invalid protocol");
 	return ProtocolNone;
 }
 
 /////////////////////////////////////////////////////////////////
 static LHashTbl<ConstStrKey<char,false>, ScribeDomType> Scribe_StrToDom(0, SdNone);
 static LHashTbl<IntKey<int,SdNone>, const char *> Scribe_DomToStr;
 
 void InitStrToDom()
 {
 	if (Scribe_StrToDom.Length() == 0)
 	{
 		// If this asserts it's likely you have a duplicate value in Code/DomTypeValues.h
 		#undef _
 		#define _(name) LAssert(Scribe_StrToDom.Find(#name) == SdNone); \
 						Scribe_StrToDom.Add(#name, Sd##name); \
 						LAssert(Scribe_StrToDom.Find(#name) == Sd##name); \
 						\
 						LAssert(Scribe_DomToStr.Find(Sd##name) == NULL); \
 						Scribe_DomToStr.Add(Sd##name, #name); \
 						LAssert(Scribe_DomToStr.Find(Sd##name) != NULL);
 		#include "DomTypeValues.h"
 		#undef _
 	}
 }
 
 ScribeDomType StrToDom(const char *s)
 {
 	ScribeDomType d = Scribe_StrToDom.Find(s);
 	return d;
 }
 
 const char *DomToStr(ScribeDomType d)
 {
 	const char *s = Scribe_DomToStr.Find(d);
 	return s;
 }
 
 void PatternBox(LSurface *pDC, const LRect &r)
 {
 	int All = r.X() + r.Y() - 1;
 	int MinEdge = MIN(r.X(), r.Y());
 	bool Wider = r.X() > r.Y();
 	
 	for (int i=0; i<All; i++)
 	{
 		LPoint pt(r.x1 + i, r.y1);
 		int Draw = ((pt.x + pt.y) >> 2) % 2;
 		
 		/*
 		if (i <= 4)
 			LgiTrace("pt=%i,%i draw=%i\n", pt.x, pt.y, Draw);
 		*/		
 		if (!Draw)
 			continue;
 		
 		if (i < MinEdge)
 		{
 			pDC->Line(r.x1, r.y1 + i, r.x1 + i, r.y1);
 		}
 		else if (Wider)
 		{
 			if (i < r.X())
 			{
 				int yy = r.Y() - 1;
 				pDC->Line(pt.x, pt.y, pt.x - yy, pt.y + yy);
 			}
 			else
 			{
 				int yy = r.Y() - (i - r.X() + 1) - 1;
 				pDC->Line(r.x2, r.y2-yy, r.x2-yy, r.y2);
 			}
 		}
 		else // Tall
 		{
 			if (i < r.Y())
 			{
 				int xx = r.X() - 1;
 				pDC->Line(r.x1, r.y1 + i, r.x1 + xx, r.y1 + i - xx);
 			}
 			else
 			{
 				int xx = r.X() - (i - r.Y() + 1) - 1;
 				pDC->Line(r.x2-xx, r.y2, r.x2, r.y2-xx);
 			}
 		}
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////
 ContactGroup *LookupContactGroup(ScribeWnd *App, const char *Name)
 {
 	auto Srcs = App->GetThingSources(MAGIC_GROUP);
 	if (!Srcs.Length() || !Name)
 		return NULL;
 
 	for (auto s: Srcs)
 	{
 		s->LoadThings();
 		
 		for (auto t: s->Items)
 		{
 			ContactGroup *g = t->IsGroup();
 			if (!g)
 				continue;
 
 			LVariant Nm;
 			if (g->GetVariant("Name", Nm) &&
 				Nm.Str() &&
 				_stricmp(Nm.Str(), Name) == 0)
 			{
 				return g;
 			}
 		}
 	}
 	
 	return NULL;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 LOAuth2::Params GetOAuth2Params(const char *Host, Store3ItemTypes Context)
 {
 	LOAuth2::Params	p;
 
 	// FYI: None of this works due to issues at the providers end. It did sometime in the
 	// past. And is only here in case someone wants to try and get it working again.
 
 	if (stristr(Host, "google.") ||
 		stristr(Host, "gmail."))
 	{
 		if (Context == MAGIC_MAIL)
 		{
 			p.AuthUri = "https://accounts.google.com/o/oauth2/auth";
 			p.ApiUri = "https://www.googleapis.com/oauth2/v3/token";
 			
 			#if 1
 			// Old scope:
 			p.Scope = "https://mail.google.com/";
 			#else
 			// New scope: (doesn't work)
 			p.Scope = "https://www.googleapis.com/auth/gmail.modify";
 			#endif
 			
 			// p.RevokeUri = "https://accounts.google.com/o/oauth2/revoke";
 		}
 		/*
 		else if (Context == MAGIC_CALENDAR)
 		{
 			p.AuthUri = "https://accounts.google.com/o/oauth2/v2/auth";
 			p.ApiUri = "https://apidata.googleusercontent.com/caldav/v2/%s/user";
 			p.Scope = "https://www.googleapis.com/auth/calendar";
 		}
 		*/
 		else return p;
 					
 		p.Provider = LOAuth2::Params::OAuthGoogle;
 					
 		p.ClientID = "<add yours here>";
 		p.ClientSecret = "<add yours here>";
 		p.RedirURIs = "urn:ietf:wg:oauth:2.0:oob\nhttp://localhost";
 	}
 	else if (stristr(Host, "outlook.") &&
 			!stristr(Host, "office365."))
 	{
 		if (Context == MAGIC_MAIL)
 		{
 			p.RedirURIs = "urn:ietf:wg:oauth:2.0:oob\nhttp://localhost";
 			p.AuthUri = "https://login.microsoftonline.com/common/oauth2/v2.0/authorize";
 			p.ApiUri = "https://login.microsoftonline.com/common/oauth2/v2.0/token";
 		}
 		else return p;
 
 		p.Provider = LOAuth2::Params::OAuthMicrosoft;
 					
 		p.ClientID = "<add yours here>";
 		p.ClientSecret = "<add yours here>";
 					
 		p.Scope = "https://outlook.office.com/mail.readwrite%20https://outlook.office.com/mail.send";
 	}
 
 	return p;
 }
 
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 class ScribeHtmLParser : public LHtmlParser
 {
 	LScriptEngine Eng;
 
 public:
 	struct HtmlElem : public LHtmlElement
 	{
 		LHashTbl<ConstStrKey<char, false>, LString> Attr;
 
 		HtmlElem(LHtmlElement *e) : LHtmlElement(e)
 		{
 		}
 
 		bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL)
 		{
 			if (!Stricmp(Name, "element"))
 			{
 				Value = Tag.Get();
 				return true;
 			}
 			else if (!Stricmp(Name, "content"))
 			{
 				Value.OwnStr(WideToUtf8(Txt.Get()));
 				return true;
 			}
 			else if (!Stricmp(Name, "attr"))
 			{
 				if (Array)
 				{
 					char *s = Attr.Find(Array);
 					if (s)
 					{
 						Value = s;
 						return true;
 					}
 				}
 			}
 
 			return false;
 		}
 
 		bool Get(const char *attr, const char *&val)
 		{
 			auto s = Attr.Find(attr);
 			if (!s)
 				return false;
 			val = s.Get();
 			return true;
 		}
 
 		void Set(const char *attr, const char *val)
 		{
 			Attr.Add(attr, val);
 		}
 	};
 
 	ScribeHtmLParser() : LHtmlParser(NULL),
 		Eng(NULL, NULL, NULL)
 	{
 	}
 
 	LHtmlElement *CreateElement(LHtmlElement *Parent)
 	{
 		return new HtmlElem(Parent);
 	}
 
 	void Evaluate(LArray<HtmlElem*> &Out, LString Search, HtmlElem *Elem)
 	{
 		LVariant Result;
 		if (Eng.EvaluateExpression(&Result, Elem, Search))
 		{
 			if (Result.CastInt32())
 				Out.Add(Elem);
 		}
 
 		for (auto e: Elem->Children)
 			Evaluate(Out, Search, dynamic_cast<HtmlElem*>(e));
 	}
 };
 
 bool SearchHtml(LVariant *ReturnValue, const char *Html, const char *SearchExp, const char *ResultExp)
 {
 	ScribeHtmLParser Parser;
 	ScribeHtmLParser::HtmlElem Root(NULL);
 	if (!Parser.Parse(&Root, Html))
 	{
 		LgiTrace("%s:%i - HTML parsing failed.\n", _FL);
 		*ReturnValue = false;
 		return false;
 	}
 
 	LArray<ScribeHtmLParser::HtmlElem*> Matches;
 	Parser.Evaluate(Matches, SearchExp, &Root);
 
 	if (!ReturnValue->SetList())
 		return false;
 
 	LScriptEngine Eng(NULL, NULL, NULL);
 	for (auto e: Matches)
 	{
 		LVariant *Result = new LVariant;
 		Eng.EvaluateExpression(Result, e, ResultExp);
 		ReturnValue->Add(Result);
 	}
 
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 ScriptDownloadContentThread::ScriptDownloadContentThread(ScribeWnd *app, LString uri, LString callbackName, LVariant *userData) :
 	LThread("ScriptDownloadContentThread", (App = app)->AddDispatch())
 {
 	Uri = uri;
 	CallbackName = callbackName;
 	if (userData)
 		UserData = *userData;
 
 	DeleteOnExit = true;
 	Run();
 }
 
 int ScriptDownloadContentThread::Main()
 {
 	Result = LgiGetUri(this, &Out, &Err, Uri);
 	return false;
 }
 
 void ScriptDownloadContentThread::OnComplete()
 {
 	auto Cb = App->GetCallback(CallbackName);
 	if (!Cb.Func)
 		return;
 
 	LVirtualMachine Vm;
 	LScriptArguments Args(&Vm);
 
 	LVariant vApp((LDom*)App);
 	Args.Add(&vApp);
 
 	LVariant vUri = Uri.Get();
 	Args.Add(&vUri);
 
 	LVariant vResult = Result;
 	Args.Add(&vResult);
 
 	LVariant vData;
 	if (Result)
 		vData.OwnStr(Out.NewStr());
 	else
 		vData = Err.Get();
 	Args.Add(&vData);
 
 	Args.Add(&UserData);
 		
 	App->ExecuteScriptCallback(Cb, Args);
 }
diff --git a/src/Scripting.cpp b/src/Scripting.cpp
--- a/src/Scripting.cpp
+++ b/src/Scripting.cpp
@@ -1,1136 +1,1136 @@
 #include "Scribe.h"
 #include "ScribePrivate.h"
 #include "lgi/common/Scripting.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/ThreadEvent.h"
 #include "lgi/common/LgiRes.h"
 
 #include "resdefs.h"
 #include "../src/common/Coding/ScriptingPriv.h"
 
 extern LHostFunc Methods[];
 LStringPipe ScribeInitTraceStore;
 
 #ifdef _MSC_VER
 #define __func__ __FUNCTION__
 #endif
 
 #define ARG_CHECK(op, num) \
 	if (Args.Length() op num) \
 	{ \
 		Args.Throw(_FL, "%s: Wrong number of args: %i (expecting %i)\n", __func__, Args.Length(), num); \
 		*Args.GetReturn() = false; \
 		return true; \
 	}
 
 LScribeScript *LScribeScript::Inst = 0;
 
 LView *CastLView(LVariant *v)
 {
 	if (v)
 	{
 		if (v->Type == GV_DOM)
 			return dynamic_cast<LView*>(v->Value.Dom);
 		else if (v->Type == GV_GVIEW)
 			return v->Value.View;
 	}
 	return 0;
 }
 
 ScribeFolder *CastFolder(LVariant *v)
 {
 	if (v && v->Type == GV_DOM)	
 		return dynamic_cast<ScribeFolder*>(v->Value.Dom);
 	return NULL;
 }
 
 void LScribeScriptPriv_ConsoleClosingCallback(LScriptConsole *Console, void *UserData);
 
 struct LScribeScriptPriv : public LStream, public LThread
 {
 	ScribeWnd *App;	
 	bool Loop = true;
 	LThreadEvent Event;
 	
 	// Incoming buffer
 	LMutex InputLock; // Covers Used and Buffer
 	ssize_t Used;
 	LArray<char> Buffer;
 	
 	// Outputs
 	LMutex OutputLock; // Covers LogFile, LogMem and Console
 	LString LogFile;
 	LArray<char> LogMem;
 	ssize_t LogMemUsed = 0;
 	LScriptConsole *Console = NULL;
 	
 	LScribeScriptPriv(ScribeWnd *app) :
 		LThread("LScribeScriptPriv.Thread"),
 		App(app),
 		InputLock("LScribeScriptPriv.Input"),
 		OutputLock("LScribeScriptPriv.Output")
 	{
 		LogMem.Length(64 << 10);
 
 		// Get the log path
 		if (!(LogFile = LgiTraceGetFilePath()))
 		{
 			LAssert(0);
 		}
 		
 		// Setup our buffer first
 		Used = 0;
 		Buffer.Length(64 << 10);
 
 		// Now register to get trace messages...
 		// ScribeInitTraceStore has all the trace logs before this point
 		LgiTraceSetStream(this);
 
 		auto TraceContent = ScribeInitTraceStore.NewLStr();
 		Write(TraceContent.Get(), TraceContent.Length());
 		
 		// Start thread
 		Run();
 	}
 	
 	~LScribeScriptPriv()
 	{
 		Loop = false;
 		
 		LgiTraceSetStream(NULL);
 		DeleteObj(Console);
 		
 		Event.Signal();
 		while (!IsExited())
 			LSleep(true);
 	}
 	
 	/// This method can't block at all, and must accept data from any
 	/// thread.
 	ssize_t Write(const void *Data, ssize_t Size, int Flags = 0)
 	{
 		ssize_t Status = 0;
 		
 		LAssert(Size < (16 << 10));
 		
 		if (Data && InputLock.LockWithTimeout(500, _FL))
 		{
 			// Put all data into a buffer as quickly as possible
 			ssize_t Remaining = (ssize_t)Buffer.Length() - Used;
 			ssize_t Common = MIN(Remaining, Size);
 			char *Ptr = &Buffer[Used];
 			if (Ptr)
 			{
 				memcpy(Ptr, Data, Common);
 				Status = Common;
 				Used += Common;
 			}
 			
 			InputLock.Unlock();
 			
 			if (Status > 0)
 				Event.Signal();
 		}
 		
 		return Status;
 	}
 	
 	void ShowScriptingWindow(bool Show)
 	{
 		LMutex::Auto Lock(&OutputLock, _FL);
 		
 		if (Show)
 		{
 			if (!Console)
 			{
 				Console = new LScriptConsole(App, LScribeScriptPriv_ConsoleClosingCallback, this);
 				if (Console)
 					Console->Write(&LogMem[0], LogMemUsed);
 			}
 		}
 		else
 		{
 			DeleteObj(Console);
 		}
 	}
 
 	int Main()
 	{
 		while (Loop)
 		{
 			Event.Wait();
 
 			if (!Loop) // Shutting down?
 				break;
 
 			// Check for input data
 			LArray<char> Input;
 			if (InputLock.LockWithTimeout(500, _FL))
 			{
 				if (Used > 0)
 				{
 					if (Input.Length(Used))
 						memcpy(&Input[0], &Buffer[0], Used);
 					Used = 0;
 				}
 				
 				InputLock.Unlock();
 			}
 			
 			if (Input.Length())
 			{
 				// We have some input... send to outputs
 				if (OutputLock.LockWithTimeout(500, _FL))
 				{
 					// Write to our log file...
 					LFile f;
 					if (LogFile && f.Open(LogFile, O_WRITE))
 					{
 						f.SetPos(f.GetSize());
 						f.Write(&Input[0], Input.Length());
 						f.Close();
 					}
 
 					if (LogMemUsed + Input.Length() > LogMem.Length())
 					{
 						// Move data down to make space... by deleting a 1/4 of the data
 						// and shifting down the rest.
 						auto i = LogMemUsed >> 2;
 						
 						// Seek to the end of a line
 						for (; i < LogMemUsed; i++)
 						{
 							if (LogMem[i] == '\n')
 							{
 								i++;
 								break;
 							}
 						}
 						
 						// Shift the memory down, and update the used variable
 						memmove(&LogMem[0], &LogMem[i], LogMemUsed-i);
 						LogMemUsed -= i;
 						
 						// Check there is enough space now...?
 						if (LogMemUsed + Input.Length() > LogMem.Length())
 							// Nope... make it bigger then
 							LogMem.Length(LogMemUsed + Input.Length());
 					}
 
 					if (LogMemUsed + Input.Length() < LogMem.Length())
 					{
 						memcpy(&LogMem[LogMemUsed], &Input[0], Input.Length());
 						LogMemUsed += Input.Length();
 					}
 
 					if (Console)
 					{
 						Console->Write((const char*)&Input[0], Input.Length());
 					}
 
 					OutputLock.Unlock();
 					
 					// Tell the UI about the new messages...
 					#if LGI_VIEW_HANDLE
 					if (App->Handle())
 					#endif
 						App->PostEvent(M_NEW_CONSOLE_MSG);
 				}
 			}
 		}
 		
 		return 0;
 	}	
 };
 
 void LScribeScriptPriv_ConsoleClosingCallback(LScriptConsole *Console, void *UserData)
 {
 	((LScribeScriptPriv*)UserData)->Console = NULL;
 }
 
 LScribeScript::LScribeScript(ScribeWnd *app)
 {
 	d = new LScribeScriptPriv(app);
 	App = app;
 	Eng = 0;
 }
 
 LScribeScript::~LScribeScript()
 {
 	DeleteObj(d);
 }
 
 void LScribeScript::ShowScriptingWindow(bool show)
 {
 	d->ShowScriptingWindow(show);
 }
 
 LStream *LScribeScript::GetLog()
 {
 	return d;
 }
 
 LAutoString LScribeScript::GetDataFolder()
 {
 	return App->GetDataFolder();
 }
 
 LString LScribeScript::GetIncludeFile(const char *FileName)
 {
 	LString Path;
 	const char *Search[] = {
 		"./scripts",
 		"../scripts",
 		"../../scripts",
 		NULL
 	};
 	LFile::Path p(ScribeResourcePath());
 	p += FileName;
 	
 	for (int i=0; Search[i] && !p.Exists(); i++)
 	{
 		p = ScribeResourcePath();
 		p += Search[i];
 		p += FileName;
 	}
 	
 	if (p.Exists())
 		Path = p.GetFull();
 	else
 		Path = LFindFile(FileName);
 	
 	if (!Path)
 	{
 		LgiTrace("%s:%i - GetIncludeFile(%s) failed.\n", _FL, FileName);
 		return LString();
 	}
 
 	LFile f(Path);
 	if (!f)
 	{
 		LgiTrace("%s:%i - GetIncludeFile(%s) couldn't open '%s' for reading.\n", _FL, FileName, Path.Get());
 		return LString();
 	}
 
 	return f.Read();
 }
 
 LHostFunc *LScribeScript::GetCommands()
 {
 	return Methods;
 }
 
 void LScribeScript::SetEngine(LScriptEngine *eng)
 {
 }
 
 bool LScribeScript::GetFolder(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 1);
 
 	Args.GetReturn()->Empty();
 	if (Args[0]->Type == GV_INT32)
 	{
 		ScribeFolder *f = App->GetFolder(Args[0]->Value.Int);
 		if (f)
 		{
 			*Args.GetReturn() = (LDom*)f;
 			return true;
 		}
 	}
 
 	char *f = Args[0]->Str();
 	if (f)
 	{
 		*Args.GetReturn() = (LDom*)App->GetFolder(f);
 	}
 
 	return true;
 }
 
 bool LScribeScript::GetSourceFolders(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 1);
 
 	LArray<ScribeFolder*> Folders;
 	auto FolderType = Args[0]->CastInt32();
 	Store3ItemTypes ItemType = MAGIC_NONE;
 	switch (FolderType)
 	{
 		case FOLDER_INBOX:
 		case FOLDER_OUTBOX:
 		case FOLDER_SENT:
 		case FOLDER_TRASH:
 		case FOLDER_TEMPLATES:
 		case FOLDER_SPAM:
 			Folders.Add(App->GetFolder(FolderType));
 			break;
 		case FOLDER_CONTACTS:
 			ItemType = MAGIC_CONTACT;
 			break;
 		case FOLDER_FILTERS:
 			ItemType = MAGIC_FILTER;
 			break;
 		case FOLDER_CALENDAR:
 			ItemType = MAGIC_CALENDAR;
 			break;
 		case FOLDER_GROUPS:
 			ItemType = MAGIC_GROUP;
 			break;
 	}
 
 	if (ItemType != MAGIC_NONE)
 		Folders = App->GetThingSources(ItemType);
 
 	auto r = Args.GetReturn();
 	if (!r->SetList())
 		return false;
 
 	auto Lst = r->Value.Lst;
 	for (auto f: Folders)
 		Lst->Add(new LVariant((LDom*)f));
 	return true;
 }
 
 bool LScribeScript::BrowseFolder(LScriptArguments &Args)
 {
 	ARG_CHECK(<, 4);
 
 	LView *Parent = CastLView(Args[0]);
 	LString MessageTxt = Args[1]->Str();
 	LString DefaultFolderName = Args[2]->Str();
 	LString CallbackName = Args[3]->Str();
 
 	if (!CallbackName)
 	{
 		*Args.GetReturn() = false;
 		return true;
 	}
 
 	*Args.GetReturn() = true;
 
 	auto d = new FolderDlg(	Parent,
 							App,
 							MAGIC_ANY, // limit to
 							0, // root
 							0, // init sel
 							true,
 							DefaultFolderName,
 							MessageTxt);
 	d->DoModal([this, d, CallbackName](auto dlg, auto id)
 	{
 		if (id)
 		{
 			auto FolderPath = d->Get();
 			auto cb = App->GetCallback(CallbackName);
 			if (cb.Func)
 			{
 				LVirtualMachine Vm;
 				LScriptArguments Args(&Vm);
 				LVariant vFolderPath = FolderPath;
 				Args.Add(&vFolderPath);		
 				App->ExecuteScriptCallback(cb, Args);
 			}
 			else LgiTrace("%s:%i - No callback called '%s'\n", _FL, CallbackName.Get());
 		}
 		delete dlg;
 	});
 
 	return true;
 }
 
 bool LScribeScript::CreateSubFolder(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 3);
 
 	*Args.GetReturn() = false;
 	ScribeFolder *Parent = CastFolder(Args[0]);
 	if (!Parent)
 		return true;
 
 	char *ChildName = Args[1]->Str();
 	if (!ChildName)
 		return true;
 
 	for (ScribeFolder *c = Parent->GetChildFolder(); c; c = c->GetNextFolder())
 	{
 		auto n = c->GetName(true);
 		if (n.Equals(ChildName))
 		{
 			*Args.GetReturn() = c;
 			return true;
 		}
 	}
 
 	char *TypeStr = Args[2]->Str();
 	if (!TypeStr)
 		return true;
 
 	int Type = MAGIC_NONE;
 
 	if (_stricmp(TypeStr, "Mail") == 0)
 		Type = MAGIC_MAIL;
 	else if (_stricmp(TypeStr, "Contact") == 0)
 		Type = MAGIC_CONTACT;
 	else if (_stricmp(TypeStr, "Filter") == 0)
 		Type = MAGIC_FILTER;
 	else if (_stricmp(TypeStr, "Calendar") == 0)
 		Type = MAGIC_CALENDAR;
 	else if (_stricmp(TypeStr, "Group") == 0)
 		Type = MAGIC_GROUP;							
 
 	if (Type >= MAGIC_BASE)
 	{
-		ScribeFolder *Child = Parent->CreateSubDirectory(ChildName, Type);
+		ScribeFolder *Child = Parent->CreateSubFolder(ChildName, Type);
 		if (Child)
 		{
 			*Args.GetReturn() = Child;
 			return true;
 		}
 	}
 
 	return true;
 }
 
 bool LScribeScript::SaveThing(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 2);
 
 	ScribeFolder *Folder = dynamic_cast<ScribeFolder*>(Args[0]->CastDom());
 	Thing *T = dynamic_cast<Thing*>(Args[1]->CastDom());
 	*Args.GetReturn() = Folder && T ? T->Save(Folder) : false;
 
 	return true;
 }
 
 bool LScribeScript::CreateThing(LScriptArguments &Args)
 {
 	ARG_CHECK(<, 1);
 
 	Thing *t;
 	uint32_t Type = Args[0]->CastInt32();
 	ScribeFolder *Folder = Args.Length() > 1 ? dynamic_cast<ScribeFolder*>(Args[1]->CastDom()) : NULL;
 	t = App->CreateItem(Type, Folder, false);
 	*Args.GetReturn() = dynamic_cast<LDom*>(t);
 
 	return true;
 }
 
 bool LScribeScript::MoveThing(LScriptArguments &Args)
 {
 	ScribeFolder *To = NULL;
 	Thing *t = NULL;
 	LArray<Thing*> Items;
 
 	ARG_CHECK(!=, 2);
 
 	// Resolve the thing...
 	t = dynamic_cast<Thing*>(Args[1]->CastDom());
 	if (!t)
 	{
 		LgiTrace("%s:%i - MoveThing error: Arg 1 not a DOM object.\n", _FL);
 		goto MoveThingErr;
 	}
 
 	// Resolve the folder...
 	if (Args[0]->Type == GV_DOM)
 	{
 		To = dynamic_cast<ScribeFolder*>(Args[0]->CastDom());
 		if (!To)
 			LgiTrace("%s:%i - MoveThing error: Arg 0 (object ptr) not a Folder.\n", _FL);
 	}
 	else if (Args[0]->Type == GV_STRING)
 	{
 		char *Path = Args[0]->CastString();
 		To = t->App->GetFolder(Path);
 		if (!To)
 			LgiTrace("%s:%i - MoveThing error: Arg 0 ('%s') not a valid path to a folder.\n", _FL, Path);
 	}
 	if (!To)
 		goto MoveThingErr;
 
 	// Move the thing to the folder...
 	Items.Add(t);
 	To->MoveTo(Items, false);
 	*Args.GetReturn() = true;
 	return true;
 
 MoveThingErr:
 	*Args.GetReturn() = false;
 	return true;
 }
 
 bool LScribeScript::LoadFolder(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 1);
 
 	*Args.GetReturn() = false;
 	
 	if (Args[0]->Type == GV_DOM)
 	{
 		ScribeFolder *Folder = dynamic_cast<ScribeFolder*>(Args[0]->Value.Dom);
 		if (Folder)
 			*Args.GetReturn() = Folder->LoadThings();
 	}
 
 	return true;
 }
 
 bool LScribeScript::LookupContact(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 1);
 	auto Email = Args[0]->CastString();
 	*Args.GetReturn() = (LDom*) Contact::LookupEmail(Email);
 	return true;
 }
 
 bool LScribeScript::MsgBox(LScriptArguments &Args)
 {
 	LViewI *Parent = CastLView(Args[0]);
 	LgiMsg(Parent, "The 'MsgBox' function is deprecated. Please use 'MessageDlg' (it has the same arguments).", AppName);
 	*Args.GetReturn() = 0;
 	return true;
 }
 
 bool LScribeScript::GetSystemPath(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 1);
 
 	Args.GetReturn()->Empty();
 	LSystemPath sp = LSP_TEMP;
 	const char *Name; 
 	if (Args[0]->IsInt())
 		sp = (LSystemPath) Args[0]->CastInt32();
 	else if ((Name = Args[0]->CastString()))
 	{
 		#undef _
 		#define _(path) if (!_stricmp(Name, #path)) sp = path;
 		_(LSP_ROOT) _(LSP_OS) _(LSP_OS_LIB) _(LSP_TEMP) _(LSP_COMMON_APP_DATA)
 		_(LSP_USER_APP_DATA) _(LSP_LOCAL_APP_DATA) _(LSP_DESKTOP) _(LSP_HOME)
 		_(LSP_USER_APPS) _(LSP_EXE) _(LSP_TRASH) _(LSP_APP_INSTALL)
 		_(LSP_APP_ROOT) _(LSP_USER_DOCUMENTS) _(LSP_USER_MUSIC) _(LSP_USER_VIDEO)
 		_(LSP_USER_DOWNLOADS) _(LSP_USER_LINKS)
 	}
 	else return true;
 
 	LFile::Path p(sp);
 	*Args.GetReturn() = p.GetFull();
 
 	return true;
 }
 
 bool LScribeScript::GetScribeTempPath(LScriptArguments &Args)
 {
 	*Args.GetReturn() = ScribeTempPath();
 	return true;
 }
 
 bool LScribeScript::JoinPath(LScriptArguments &Args)
 {
 	char p[MAX_PATH_LEN] = "";
 	if (Args.Length() > 0)
 	{
 		bool First = true;
 		for (unsigned i=0; i<Args.Length(); i++)
 		{
 			char *s = Args[i]->CastString();
 			if (s)
 			{
 				if (First)
 					strcpy_s(p, sizeof(p), s);
 				else
 					LMakePath(p, sizeof(p), p, s);
 				First = false;
 			}
 		}
 	}
 
 	*Args.GetReturn() = p;
 	return true;
 }
 
 bool LScribeScript::DeleteThing(LScriptArguments &Args)
 {
 	*Args.GetReturn() = false;
 
 	LArray<Thing*> a;
 	int Ok = 0, Error = 0;
 	LDom *dom;
 	bool ToTrash = false;
 
 	for (auto Arg: Args)
 	{
 		if (Arg->Type == GV_DOM)
 		{
 			if (!(dom = Arg->CastDom())) continue;
 			Attachment *attachment = dynamic_cast<Attachment*>(dom);
 			if (attachment)
 			{
 				Mail *m = attachment->GetOwner();
 				if (m)
 				{
 					if (m->DeleteAttachment(attachment)) Ok++;
 					else Error++;
 				}
 				else LAssert(!"No owner?");
 			}
 			else
 			{
 				auto t = dynamic_cast<Thing*>(dom);
 				if (t) a.Add(t);
 			}
 		}
 		else if (Arg->Type == GV_LIST)
 		{
 			auto l = Arg->Value.Lst;
 			if (!l) continue;
 			for (auto i: *l)
 			{
 				if (!(dom = i->CastDom())) continue;
 				auto t = dynamic_cast<Thing*>(dom);
 				if (t) a.Add(t);
 			}
 		}
 		else if (Arg->Type == GV_STRING)
 		{
 			if (Stristr(Arg->Str(), "trash"))
 				ToTrash = true;
 		}
 	}
 
 	while (a.Length() > 0)
 	{
 		auto t = a[0];
 		auto Store = t->GetObject()->GetStore();
 		LArray<LDataI*> Del;
 		for (auto it = a.begin(); it != a.end(); )
 		{
 			t = *it;
 			if (t->GetObject()->GetStore() == Store)
 			{
 				Del.Add(t->GetObject());
 				a.Delete(it);
 			}
 			else it++;
 		}
 		if (Store->Delete(Del, ToTrash) > Store3Error) Ok++;
 		else Error++;
 	}
 
 	*Args.GetReturn() = Error == 0;
 	return true;
 }
 
 bool LScribeScript::ShowThingWindow(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 1);
 
 	*Args.GetReturn() = false;
 
 	if (Args[0]->Type == GV_DOM)
 	{
 		Thing *t = dynamic_cast<Thing*>(Args[0]->CastDom());
 		if (t)
 			*Args.GetReturn() = t->DoUI();
 	}
 
 	return true;
 }
 
 bool LScribeScript::AddToolsMenuItem(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 2);
 
 	*Args.GetReturn() = App->RegisterCallback(LToolsMenu, Args);
 
 	return true;
 }
 
 bool LScribeScript::AddCallback(LScriptArguments &Args)
 {
 	ARG_CHECK(<, 2);
 
 	auto Str = Args[0]->CastString();
 	ScribeDomType Type = StrToDom(Str);
 	switch (Type)
 	{
 		#define HandleCallbackType(DomField, CbType) \
 			case DomField: \
 				*Args.GetReturn() = App->RegisterCallback(CbType, Args); \
 				break
 
 		HandleCallbackType(SdOnBeforeMailSend, LMailOnBeforeSend);
 		HandleCallbackType(SdOnAfterMailReceive, LMailOnAfterReceive);
 		HandleCallbackType(SdOnThingContextMenu, LThingContextMenu);
 		HandleCallbackType(SdOnFolderContextMenu, LFolderContextMenu);
 		HandleCallbackType(SdOnThingToolbar, LThingUiToolbar);
 		HandleCallbackType(SdOnApplicationToolbar, LApplicationToolbar);
 		HandleCallbackType(SdOnBeforeInstallBar,LBeforeInstallBar);
 		HandleCallbackType(SdOnInstallComponent, LInstallComponent);
 		HandleCallbackType(SdOnTimer, LOnTimer);
 		HandleCallbackType(SdOnRenderMail, LRenderMail);
 		HandleCallbackType(SdOnLoad, LOnLoad);
 		default:
 			Args.Throw(_FL, "No callback named '%s'", Str);
 			*Args.GetReturn() = false;
 			break;
 	}
 
 	return true;
 }
 
 // MenuAddItem(SubMenu, IconIndex/File, LabelText, Position, CallbackMethod, CallbackId)
 bool LScribeScript::MenuAddItem(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 6);
 
 	*Args.GetReturn() = false;
 	LDom *Dom = Args[0]->CastDom();
 	LScriptUi *Menu = dynamic_cast<LScriptUi*>(Dom);
 	char *IconFile = 0;
 	int IconIdx = -1;
 	
 	if (Args[1]->Type == GV_INT32)
 		IconIdx = Args[1]->CastInt32();
 	else if (Args[1]->Type == GV_STRING)
 		IconFile = Args[1]->Str();
 	
 	char *LabelTxt = Args[2]->Str();
 	int Position = Args[3]->CastInt32();
 	char *CallbackMethodName = Args[4]->Str();
 	int CallbackId = Args[5]->CastInt32();
 	
 	if (!Menu || !Menu->Sub)
 		return Args.Throw(NULL, -1, "No menu to append to.");
 
 	if (CallbackId < 0)
 	{
 		Menu->Sub->AppendSeparator(Position);
 		*Args.GetReturn() = true;
 		return true;
 	}
 
 	if (!LabelTxt)
 		return Args.Throw(NULL, -1, "No label text.");
 	if (!CallbackMethodName)
 		return Args.Throw(NULL, -1, "No label callback method name.");
 
 	LScriptCallback Cb = App->GetCallback(CallbackMethodName);
 	if (!Cb.Func)
 	{
 		Args.Throw(NULL, -1, "Callback not defined.");
 		return true;
 	}
 
 	auto Top = Menu->Sub;
 	while (Top->GetParent() &&
 			Top->GetParent()->GetParent())
 		Top = Top->GetParent()->GetParent();
 	auto Existing = Top->FindItem(CallbackId);
 	if (Existing)
 		return Args.Throw(NULL, -1, "Item ID '%i' already exists.", CallbackId);
 
 	Cb.Param = CallbackId;
 	Menu->Sub->AppendItem(LabelTxt, CallbackId, true, Position);
 
 	// The callbacks are always in a flat list in the top most LScriptCallback,
 	// where the caller can easily see them.
 	LScriptUi *Root = Menu;
 	while (Root->Parent)
 		Root = Root->Parent;
 	Root->Callbacks.New() = Cb;
 
 	*Args.GetReturn() = true;
 	return true;
 }
 
 bool LScribeScript::MenuAddSubmenu(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 3);
 	
 	Args.GetReturn()->Empty();
 	LScriptUi *Menu = dynamic_cast<LScriptUi*>(Args[0]->CastDom());
 	char *SubmenuTxt = Args[1]->Str();
 	int Position = Args[2]->CastInt32();
 	if (Menu && Menu->Sub && SubmenuTxt)
 	{
 		LScriptUi *s = new LScriptUi(Menu->Sub->AppendSub(SubmenuTxt, Position));
 		if (s)
 		{
 			s->Parent = Menu;
 			Menu->Subs.Add(s);
 			*Args.GetReturn() = s;
 		}
 	}
 
 	return true;
 }
 
 bool LScribeScript::ToolbarAddItem(LScriptArguments &Args)
 {
 	ARG_CHECK(<, 6);
 	
 	LScriptUi *Tb = dynamic_cast<LScriptUi*>(Args[0]->CastDom());
 	int Icon = Args[1]->CastInt32();
 	char *Label = Args[2]->Str();
 	// int Pos = Args[3]->CastInt32();
 	char *CallbackMethodName = Args[4]->Str();
 	int CallbackId = Args[5]->CastInt32();
 	if (Tb && Tb->Toolbar && CallbackMethodName)
 	{
 		if (CallbackId < 0)
 		{
 			Tb->Toolbar->AppendSeparator();
 			*Args.GetReturn() = true;
 		}
 		else
 		{
 			LScriptCallback Cb = App->GetCallback(CallbackMethodName);
 			if (Cb.Func)
 			{
 				Cb.Param = CallbackId;
 				Tb->Toolbar->AppendButton(Label, CallbackId, TBT_PUSH, true, Icon);
 
 				LScriptUi *Root = Tb;
 				while (Root->Parent)
 					Root = Root->Parent;
 				Root->Callbacks.New() = Cb;
 
 				*Args.GetReturn() = true;
 			}
 			else *Args.GetReturn() = false;
 		}
 	}
 	else
 		*Args.GetReturn() = false;
 
 	return true;
 }
 
 bool LScribeScript::FilterDoActions(LScriptArguments &Args)
 {
 	ARG_CHECK(!=, 2);
 
 	Filter *f = dynamic_cast<Filter*>(Args[0]->CastDom());
 	Mail *m = dynamic_cast<Mail*>(Args[1]->CastDom());
 	if (f && m)
 	{
 		bool Stop = false;
 		f->DoActions(m, Stop);
 		*Args.GetReturn() = true;
 	}
 	else
 		*Args.GetReturn() = false;
 	
 	return true;
 }
 
 
 #define DefFn(Name) \
 	LHostFunc(#Name, 0, (ScriptCmd)&LScribeScript::Name)
 
 LHostFunc Methods[] =
 {
 	DefFn(MsgBox),
 
 	DefFn(GetSystemPath),
 	DefFn(GetScribeTempPath),
 	DefFn(JoinPath),
 
 	DefFn(GetFolder),
 	DefFn(GetSourceFolders),
 	DefFn(LoadFolder),
 	DefFn(CreateSubFolder),
 	DefFn(BrowseFolder),
 
 	DefFn(CreateThing),
 	DefFn(MoveThing),
 	DefFn(SaveThing),
 	DefFn(DeleteThing),
 	DefFn(ShowThingWindow),
 	DefFn(FilterDoActions),
 	DefFn(LookupContact),
 
 	DefFn(AddToolsMenuItem),
 	DefFn(AddCallback),
 
 	DefFn(MenuAddItem),
 	DefFn(MenuAddSubmenu),
 	DefFn(ToolbarAddItem),
 
 	LHostFunc(0, 0, 0),
 };
 
 LScriptConsole::LScriptConsole(ScribeWnd *app, ConsoleClosingCallback callback, void *callback_data)
 {
 	Txt = NULL;
 	Callback = callback;
 	CallbackData = callback_data;
 	App = app;
 	LRect r(0, 0, 600, 500);
 	SetPos(r);
 	if (App)
 		MoveSameScreen(App);
 	else
 		MoveToCenter();
 	Name(LLoadString(IDS_CONSOLE, "Console"));
 
 	if (Attach(0))
 	{
 		Children.Insert(Txt = new LTextLog(100));
 		if (Txt)
 		{
 			Txt->SetPourLargest(true);
 		}
 		AttachChildren();
 		Visible(true);
 		RegisterHook(this, LKeyEvents);
 	}
 }
 
 LScriptConsole::~LScriptConsole()
 {
 	printf("%p::~LScriptConsole() %p\n", this, Callback);
 	if (Callback)
 		Callback(this, CallbackData);
 }
 
 bool LScriptConsole::OnViewKey(LView *v, LKey &k)
 {
 	if (k.CtrlCmd() && ToLower(k.c16) == 'w')
 	{
 		if (k.Down())
 			Quit();
 		return true;
 	}
 
 	return false;
 }
 
 bool LScriptConsole::OnRequestClose(bool OsShuttingDown)
 {
 	LVariant v;
 	App->GetOptions()->SetValue(OPT_ShowScriptConsole, v = 0);
 	auto Item = App->GetMenu()->FindItem(IDM_SCRIPTING_CONSOLE);
 	if (Item) Item->Checked(false);
 	if (Callback)
 	{
 		Callback(this, CallbackData);
 		Callback = NULL;
 	}
 
 	return true;
 }
 
 void LScriptConsole::Write(const char *s, int64 Len)
 {
 	if (Txt)
 		Txt->Write(s, (int)Len);
 }
 
 bool OnFilterScript(Filter *f, Mail *m, const char *Script)
 {
 	if (!Script || !f || !m || !LScribeScript::Inst)
 		return false;
 
 	LScriptEngine *e = m->App->GetScriptEngine();
 	LAutoPtr<LCompiledCode> obj(new LCompiledCode);
 	if (!obj)
 	{
 		return false;
 	}
 	
 	// Setup the various pre-defined variables
 	LVariant v;
 	obj->Set("App", v = dynamic_cast<LDom*>(f->App));
 	obj->Set("Mail", v = dynamic_cast<LDom*>(m));
 	obj->Set("Filter", v = dynamic_cast<LDom*>(f));
 
 	// Compile...
 	LString ScriptName;
 	ScriptName.Printf("%s.filter", f->GetName());
 	if (!e->Compile(obj, NULL, Script, ScriptName))
 	{
 		f->App->OnScriptCompileError(NULL, f);
 		return false;
 	}
 	
 	// And run...
 	LExecutionStatus Result = e->Run(obj, NULL, ScribeTempPath());
 	return Result != ScriptError;
 }
 
 bool OnToolScript(ScribeWnd *App, const char *File)
 {
 	bool Status = false;
 
 	if (App && File && LScribeScript::Inst)
 	{
 		LAutoString Script(LReadTextFile(File));
 		if (Script)
 		{
 			LScriptEngine *e = App->GetScriptEngine();
 			if (e)
 			{
 				LAutoPtr<LCompiledCode> Obj(new LCompiledCode);
 
 				if (e->Compile(Obj, NULL, Script, File))
 				{
 					LScriptArguments Args(NULL);
 					Args.Add(new LVariant((LDom*)App));
 					Status = e->CallMethod(Obj, "Main", Args);
 					Args.DeleteObjects();
 				}
 				else
 				{
 					App->OnScriptCompileError(File, NULL);
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
 bool LScriptUi::SetupCallbacks(ScribeWnd *App, ThingUi *Parent, Thing *t, LScriptCallbackType Type)
 {
 	if (!App)
 		return false;
 
 	LArray<LScriptCallback*> Callbacks;
 	if (!App->GetScriptCallbacks(Type, Callbacks))
 		return false;
 
 	LScriptArguments Args(NULL);
 	int a = 0;
 	Args[a++] = new LVariant(App);
 	Args[a++] = new LVariant(this);
 	Args[a++] = new LVariant(t);
 
 	for (unsigned i=0; i<Callbacks.Length(); i++)
 		App->ExecuteScriptCallback(*Callbacks[i], Args);
 
 	return true;
 }
 
 bool LScriptUi::ExecuteCallbacks(ScribeWnd *App, ThingUi *Parent, Thing *t, int Cmd)
 {
 	if (!App)
 		return false;
 
 	LScriptArguments Args(NULL);
 	Args[0] = new LVariant(App);	// App
 	Args[1] = new LVariant(Parent); // Window
 	Args[2] = new LVariant(t);		// Thing
 	Args[3] = new LVariant(Cmd);	// CallbackId
 
 	for (auto &c: Callbacks)
 	{
 		if (c.Param == Cmd)
 			App->ExecuteScriptCallback(c, Args);
 	}
 
 	return false;
 }
diff --git a/src/Store3Common.cpp b/src/Store3Common.cpp
--- a/src/Store3Common.cpp
+++ b/src/Store3Common.cpp
@@ -1,539 +1,539 @@
 #include <time.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Mail.h"
 
 #include "Store3Common.h"
 #include "ScribeInc.h"
 #include "DomType.h"
 
 LHashTbl<IntKey<int>,LDataStoreI*> LDataStoreI::Map;
 
 //////////////////////////////////////////////////////////////////////////////////////
 const char *Store3ItemTypeToMime(Store3ItemTypes type)
 {
 	switch (type)
 	{
 		case MAGIC_MAIL:       return "message/rfc822";
 		case MAGIC_CONTACT:    return "text/vcard";
 		case MAGIC_ATTACHMENT: return "application/octet-stream";
 		case MAGIC_CALENDAR:   return "text/vcalendar";
 		case MAGIC_FILTER:     return "text/x-email-filter";
 		default:
 			LAssert(!"Unknown type");
 			break;
 	}
 	
 	return NULL;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 LDataUserI::LDataUserI()
 {
 	Object = NULL;
 }
 
 LDataUserI::~LDataUserI()
 {
 	if (Object)
 		Object->UserData = NULL;
 }
 
 LDataI *LDataUserI::GetObject()
 {
 	return Object;
 }
 
 bool LDataUserI::SetObject(LDataI *o, bool InDestuctor, const char *File, int Line)
 {
 	if (o == Object)
 		return true;
 
 	if (Object)
 	{
 		Object->UserData = NULL;
 		if (!InDestuctor && Object->IsOrphan())
 			delete Object;
 		Object = NULL;
 	}
 
 	Object = o;
 	if (File)
 		SetterRef.Printf("%s:%i", File, Line);
 	else
 		SetterRef.Empty();
 
 	if (Object)
 		Object->UserData = this;
 
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 Store3Addr::Store3Addr(LDataStoreI *store, LDataPropI *i)
 {
 	LAssert(store != NULL);
 	Store = store;
 	CC = 0;
 	if (i)
 		CopyProps(*i);
 }
 
 Store3Addr::~Store3Addr()
 {
 }
 
 size_t Store3Addr::Sizeof()
 {
 	size_t s = sizeof(*this);
 	if (Addr) s += strlen(Addr);
 	if (Name) s += strlen(Name);
 	return s;
 }
 
 void Store3Addr::SetStore(LDataStoreI *s)
 {
 	Store = s;
 	LAssert(Store != NULL);
 }
 
 void Store3Addr::Empty()
 {
 	Name.Empty();
 	Addr.Empty();
 	CC = 0;
 }
 
 Store3CopyImpl(Store3Addr)
 {
 	Empty();
 	Name = p.GetStr(FIELD_NAME);
 	Addr = p.GetStr(FIELD_EMAIL);
 	CC = (int)p.GetInt(FIELD_CC);
 	return true;
 }
 
 const char *Store3Addr::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_NAME:
 			return Name;
 		case FIELD_EMAIL:
 			return Addr;
 	}
 
 	return 0;
 }
 
 Store3Status Store3Addr::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_NAME:
 		{
 			Name = str;
 			break;
 		}
 		case FIELD_EMAIL:
 		{
 			Addr = str;
 			break;
 		}
 		default:
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 bool Store3Addr::GetVariant(const char *n, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(n);
 	switch (Fld)
 	{
 		case SdName: // Type: String
 		{
 			Value = Name;
 			break;
 		}
 		case SdEmail: // Type: String
 		{
 			Value = Addr;
 			break;
 		}
 		case SdDomain: // Type: String
 		{
 			char *At = Addr ? strchr(Addr, '@') : NULL;
 			if (At)
 				Value = At + 1;
 			else
 				Value.Empty();
 			break;
 		}
 		case SdText: // Type: String
 		{
 			char s[512];
 			LString EscName;
 			if (Name)
 				EscName = LString::Escape(Name, -1, "\'");
 			
 			if (Name && Addr)
 				sprintf_s(s, sizeof(s), "\"%s\" <%s>", EscName.Get(), (char*)Addr);
 			else if (Name)
 				sprintf_s(s, sizeof(s), "\"%s\"", EscName.Get());
 			else if (Addr)
 				sprintf_s(s, sizeof(s), "<%s>", (char*)Addr);
 			else
 				return false;
 
 			s[sizeof(s)-1] = 0;
 			Value = s;
 			break;
 		}
 		case SdContact: // Type: Contact
 		{
 			LDataEventsI *e = Store->GetEvents();
 			if (!e)
 				return false;
 
 			LArray<LDom*> Matches;
 			if (!e->Match(Store, this, MAGIC_CONTACT, Matches))
 				return false;
 
 			Value = Matches[0];
 			break;
 		}
 		case SdGroups: // Type: String[]
 		{
 			LDataEventsI *e = Store->GetEvents();
 			if (!e)
 				return false;
 
 			LArray<LDom*> Matches;
 			if (e->Match(Store, this, MAGIC_GROUP, Matches))
 			{				
 				Value.SetList();
 				for (unsigned i=0; i<Matches.Length(); i++)
 				{
 					LAutoPtr<LVariant> v(new LVariant);
 					if (Matches[i]->GetValue("Name", *v))
 						Value.Value.Lst->Insert(v.Release());
 				}
 			}
 			else
 				Value.Empty();
 			break;
 		}
 		default:
 		{
 			LAssert(!"Not a supported field.");
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool Store3Addr::SetVariant(const char *n, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(n);
 	switch (Fld)
 	{
 		case SdName: // Type: String
 		{
 			Name = Value.Str();
 			break;
 		}
 		case SdEmail: // Type: String
 		{
 			Addr = Value.Str();
 			break;
 		}
 		case SdText: // Type: String
 		{
 			DecodeAddrName(Value.Str(), [this](LString name, LString addr){
 				Name = LString::UnEscape(name);
 				Addr = addr;
 			}, NULL);
 			break;
 		}
 		default:
 		{
 			LAssert(!"Not a valid field");
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 int64 Store3Addr::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_CC:
 			return CC;
 	}
 	return -1;
 }
 
 Store3Status Store3Addr::SetInt(int id, int64 i)
 {
 	switch (id)
 	{
 		case FIELD_CC:
 			CC = (int)i;
 			break;
 		default:
 			return Store3Error;
 	}
 	return Store3Success;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
 Store3Field::Store3Field(LDataStoreI *Store, int id, int width)
 {
 	Id = id;
 	Width = width;
 }
 
 const char *Store3Field::GetStr(int id)
 {
 	return 0;
 }
 
 int64 Store3Field::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_ID:
 			return Id;
 		case FIELD_WIDTH:
 			return Width;
 	}
 
 	return -1;
 }
 
 Store3Status Store3Field::SetInt(int id, int64 i)
 {
 	switch (id)
 	{
 		case FIELD_ID:
 			Id = (int)i;
 			break;
 		case FIELD_WIDTH:
 			Width = (int)i;
 			break;
 		default:
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Mime conversion
 bool Store3ToLMime(LMime *Out, LDataPropI *InInterface)
 {
-	LDataI *In = dynamic_cast<LDataI*>(InInterface);
+	auto In = dynamic_cast<LDataI*>(InInterface);
 	if (!Out || !In)
 	{
 		LAssert(0);
 		return false;
 	}
 	
-	int Type = In->Type();
+	auto Type = In->Type();
 	if (Type == MAGIC_MAIL)
 	{
-		LDataIt Sub = In->GetList(FIELD_MIME_SEG);
-		LDataPropI *Child = Sub->First();
+		auto Sub = In->GetList(FIELD_MIME_SEG);
+		auto Child = Sub->First();
 		if (Child)
 		{
 			if (!Store3ToLMime(Out, Child))
 				return false;
 		}
 		else LAssert(0);
 	}
 	else if (Type == MAGIC_ATTACHMENT)
 	{
 		auto Hdrs = In->GetStr(FIELD_INTERNET_HEADER);
 		if (Hdrs)
 		{
 			if (!Out->SetHeaders(Hdrs))
 			{
 				LAssert(0);
 				return false;
 			}
 		}
 		else
 		{
 			// No headers???
 		}
 
 		auto Charset = In->GetStr(FIELD_CHARSET);
 		if (Charset)
 			Out->SetCharset(Charset);
 		
 		auto Data = In->GetStream(_FL);
 		if (Data)
 		{
 			if (!Out->SetData(true, Data.Release()))
 			{
 				LAssert(0);
 				return false;
 			}
 		}
 
 		LDataIt Sub = In->GetList(FIELD_MIME_SEG);
 		for (LDataPropI *Child = Sub->First(); Child; Child = Sub->Next())
 		{
 			LMime *NewSeg = Out->NewChild();
 			if (NewSeg)
 			{
 				if (Store3ToLMime(NewSeg, Child))
 					Out->Insert(NewSeg);
 				else
 					return false;
 			}
 			else
 			{
 				LAssert(0);
 				return false;
 			}
 		}
 	}
 	else
 	{
 		LAssert(!"Incorrect object type.");
 		return false;
 	}
 		
 	return true;
 }
 
 bool GMimeToStore3(LDataPropI *Out, LMime *In, bool InMemOnly)
 {
 	LDataI *DataOut = dynamic_cast<LDataI*>(Out);
 	if (!DataOut || !In)
 	{
 		LAssert(0);
 		return false;
 	}
 	
 	if (!Out->SetStr(FIELD_INTERNET_HEADER, In->GetHeaders()))
 	{
 		LAssert(0);
 		return false;
 	}
 	
 	if (In->GetLength() > 0)
 	{
 		LAutoStreamI Data(new LMemStream(In->GetData(), -1, -1));
 		if (!Data)
 		{
 			LAssert(0);
 			return false;
 		}			
 		if (!DataOut)
 		{
 			LAssert(0);
 			return false;
 		}
 		DataOut->SetStream(Data);
 	}
 
 	for (int i=0; i<In->Length(); i++)
 	{
 		LDataI *cOut = DataOut->GetStore()->Create(MAGIC_ATTACHMENT);
 		if (!cOut)
 			return false;
 		
 		LMime *cIn = (*In)[i];
 		if (!GMimeToStore3(cOut, cIn))
 			return false;
 		
 		Store3Status s = cOut->Save(DataOut);
 		if (s == Store3Error)
 		{
 			LAssert(0);
 			return false;
 		}
 	}
 
 	return true;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////
 LString HeadersFromStream(LStreamI *Msg)
 {
 	LString s;
 	int Block = 1024;
 	
 	Msg->SetPos(0);
 	for (ssize_t Pos = 0; Pos < (512 << 10); )
 	{
 		if (!s.Length(Pos + Block))
 			break;
 		
 		ssize_t Rd = Msg->Read(s.Get() + Pos, s.Length() - Pos);
 		if (Rd <= 0)
 		{
 			s.Empty();
 			break;
 		}
 		
 		Pos += Rd;
 		s.Length(Pos);
 
 		ptrdiff_t EndOfHeader = s.Find("\r\n\r\n");
 		if (EndOfHeader > 0)
 		{
 			s.Length(EndOfHeader);
 			break;
 		}
 	}
 	
 	return s;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 LString CreateMboxHeader(LDataI *Object)
 {
 	LString s;
 	LDataPropI *From;
 	if (!Object ||
 		!(From = Object->GetObj(FIELD_FROM)))
 	{
 		LAssert(0);
 		return s;
 	}
 
 	// generate from header
 	s.Printf("From %s ", From->GetStr(FIELD_EMAIL));
 	
 	struct tm Ft;	
 	ZeroObj(Ft);
 	LDateTime Rec = *Object->GetDate(FIELD_DATE_RECEIVED);
 	if (!Rec.Year())
 		Rec.SetNow();
 		
 	Ft.tm_sec = Rec.Seconds();			/* seconds after the minute - [0,59] */
 	Ft.tm_min = Rec.Minutes();			/* minutes after the hour - [0,59] */
 	Ft.tm_hour = Rec.Hours();			/* hours since midnight - [0,23] */
 	Ft.tm_mday = Rec.Day();			/* day of the month - [1,31] */
 	Ft.tm_mon = Rec.Month() - 1;		/* months since January - [0,11] */
 	Ft.tm_year = Rec.Year() - 1900;    /* years since 1900 */
 	Ft.tm_wday = Rec.DayOfWeek();
 
 	char Temp[64];
 	strftime(Temp, sizeof(Temp), "%a %b %d %H:%M:%S %Y", &Ft);
 	s += Temp;
 	s += "\r\n";
 	
 	return s;
 }
 
diff --git a/src/Store3Common.h b/src/Store3Common.h
--- a/src/Store3Common.h
+++ b/src/Store3Common.h
@@ -1,286 +1,291 @@
 #ifndef _STORE3_COMMON_H_
 #define _STORE3_COMMON_H_
 
 #include "lgi/common/Store3.h"
 #include "lgi/common/Mime.h"
 
 #include "ScribeDefs.h"
 
 class Store3MimeType
 {
 	LAutoString Mt;
 
 public:
 	Store3MimeType(const char *mt)
 	{
 		Mt.Reset(NewStr(mt));
 	}
 
 	#undef IsText
 
 	operator char*() { return Mt; }
 	Store3MimeType &operator =(const char *s) { Mt.Reset(NewStr(s)); return *this; }
 	bool Is(const char *Type)	{ return Mt && _stricmp(Mt, Type) == 0; }
 	bool IsMultipart()			{ return Mt && _strnicmp(Mt, "multipart/", 10) == 0; }
 	bool IsText()				{ return Mt && _strnicmp(Mt, "text/", 5) == 0; }
 	bool IsPlainText()			{ return Is(sTextPlain); }
 	bool IsHtml()				{ return Is(sTextHtml); }
 	bool IsMixed()				{ return Is(sMultipartMixed); }
 	bool IsAlternative()		{ return Is(sMultipartAlternative); }
 	bool IsRelated()			{ return Is(sMultipartRelated); }
 };
 
 class Store3Addr : public LDataPropI
 {
 	LDataStoreI *Store;
 
 public:
 	LString Name, Addr;
 	int CC;
 
 	Store3Addr(LDataStoreI *store, LDataPropI *i = NULL);	
 	~Store3Addr();
 
 	Store3CopyDecl;
 
 	void SetStore(LDataStoreI *s);
 	void Empty();
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 	size_t Sizeof();
 
 	bool GetVariant(const char *n, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *n, LVariant &Value, const char *Array = NULL) override;
 };
 
 class Store3Field : public LDataPropI
 {
 public:
 	int32 Id, Width;
 
 	Store3Field(LDataStoreI *Store, int id = 0, int width = 100);
 
 	LDataPropI &operator =(LDataPropI &p) { LAssert(0); return *this; }
 
 	const char *GetStr(int id);
 	int64 GetInt(int id);
 	Store3Status SetInt(int id, int64 i);
 };
 
 template<class TStore, class TMail, class TAttach>
 class Store3Attachment : public LDataI
 {
 protected:
 	TStore *Kit = NULL;
 	TMail *Mail = NULL;
 	TAttach *Parent = NULL;
 	DIterator<LDataPropI, TAttach, TStore> Children;
 	bool Dirty = true;
 	LAutoPtr<LStreamI> Import;
 
 	void _Delete()
 	{
 		if (Parent)
 		{
 			#ifdef _DEBUG
 			TAttach *This = dynamic_cast<TAttach*>(this);
 			#endif
 			LAssert(This && Parent->Children.IndexOf(This) >= 0);
 			Parent->Children.Delete(this);
 			Parent = NULL;
 		}
 		else if (Mail)
 		{
 			Mail->Seg = NULL;
 		}
 		Mail = NULL;
 
 		TAttach *c;
 		while (Children.Length())
 		{
 			c = Children.a[0];
 			LAssert(c->Parent == this);
 			DeleteObj(c);
 		}
 	}
 
 public:
 	Store3Attachment(TStore *store)
 	{
 		Kit = store;
 		Children.State = Store3Loaded;
 	}
 	
 	~Store3Attachment()
 	{
 		// If this assert fires, you didn't call 
 		// _Delete() in your destructor.
 		LAssert(Parent == NULL && Mail == NULL);
 	}
 
+	bool GetDirty()
+	{
+		return Dirty;
+	}
+
 	void Detach()
 	{
 		if (Parent)
 		{
 			TAttach *This = dynamic_cast<TAttach*>(this);
 			LAssert(This!=NULL);
 			LAssert(Parent->Children.a.HasItem(This));
 			Parent->Children.a.Delete(This);
 			Parent = NULL;
 			Dirty = true;
 		}
 		else if (Mail)
 		{
 			if (Mail->Seg == this)
 			{
 				Mail->Seg = NULL;
 			}
 			Dirty = true;
 		}
 		
 		Mail = NULL;
 	}
 	
 	void AttachTo(TAttach *Obj)
 	{
 		Detach();
 
 		if (Obj)
 		{
 			TAttach *This = dynamic_cast<TAttach*>(this);
 			
 			bool HasChild = Obj->Children.a.HasItem(This);
 			bool HasParent = false;
 			for (TAttach *p = This; p; p = p->GetParent())
 			{
 				if (p == Obj)
 				{
 					HasParent = true;
 					break;
 				}
 			}
 
 			if (This &&
 				!HasChild &&
 				!HasParent)
 			{
 				Obj->Children.a.Add(This);
 				Parent = Obj;
 				SetMail(Obj->Mail);
 			}
 			else
 			{
 				LAssert(0);
 			}
 		}
 	}
 	
 	void AttachTo(TMail *Obj)
 	{
 		Detach();
 
 		if (Obj)
 		{
 			if (Obj->Seg != NULL &&
 				Obj->Seg != this)
 			{
 				auto s = Obj->Seg;
 				Obj->Seg->Detach();
 				delete s;
 			}
 			
 			Obj->Seg = dynamic_cast<TAttach*>(this);
 			SetMail(Obj);
 		}
 	}
 
 	void SetMail(TMail *m)
 	{
 		Mail = m;
 		if (m)
 			Kit = m->Store; // If the mail's store changes, we should update here
 
 		// TAttach *This = dynamic_cast<TAttach*>(this);
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			auto c = Children.a[i];
 			bool Ok = true;
 			for (auto p = GetParent(); p; p = p->GetParent())
 			{
 				if (p == c)
 				{
 					Ok = false;
 					break;
 				}
 			}
 			if (Ok)
 				Children.a[i]->SetMail(m);
 		}
 	}
 	
 	TAttach *GetParent()
 	{
 		return Parent;
 	}
 	
 	bool FindSegs(const char *SearchMimeType, LArray<TAttach*> &Results)
 	{
 		const char *Mt = GetStr(FIELD_MIME_TYPE);
 		if (!Mt)
 			Mt = sTextPlain;
 
 		if (!_stricmp(SearchMimeType, Mt))
 		{
 			Results.Add(dynamic_cast<TAttach*>(this));
 		}
 
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			Children.a[i]->FindSegs(SearchMimeType, Results);
 		}
 
 		return Results.Length() > 0;
 	}
 
 	LDataIt GetList(int id)
 	{
 		if (id == FIELD_MIME_SEG)
 			return &Children;
 
 		return 0;
 	}
 
 	TAttach *FindChildByMimeType(const char *MimeType)
 	{
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			TAttach *a = dynamic_cast<TAttach*>(Children[i]);
 			if (a)
 			{
 				if (a->Is(MimeType))
 					return a;
 			}
 		}
 		return NULL;
 	}
 	
 	bool Is(const char *Type)	{ const char *Mt = GetStr(FIELD_MIME_TYPE); return Mt && _stricmp(Mt, Type) == 0; }
 	bool IsMultipart()			{ const char *Mt = GetStr(FIELD_MIME_TYPE); return Mt && _strnicmp(Mt, "multipart/", 10) == 0; }
 	bool IsPlainText()			{ return Is(sTextPlain); }
 	bool IsHtml()				{ return Is(sTextHtml); }
 	bool IsMixed()				{ return Is(sMultipartMixed); }
 	bool IsAlternative()		{ return Is(sMultipartAlternative); }
 	bool IsRelated()			{ return Is(sMultipartRelated); }
 
 	virtual void OnSave() = 0;
 	LDataStoreI *GetStore() { return Kit; }
 };
 
 extern bool Store3ToLMime(LMime *Out, LDataPropI *In);
 extern bool GMimeToStore3(LDataPropI *Out, LMime *In, bool InMemOnly = false);
 extern LString HeadersFromStream(LStreamI *Msg);
 extern LString CreateMboxHeader(LDataI *Object);
 
 #endif
diff --git a/src/Store3Mail3/Mail3.h b/src/Store3Mail3/Mail3.h
--- a/src/Store3Mail3/Mail3.h
+++ b/src/Store3Mail3/Mail3.h
@@ -1,779 +1,780 @@
 #ifndef _MAIL3_H_
 #define _MAIL3_H_
 
 #include "lgi/common/Lgi.h"
 #include "Store3Common.h"
 #include "v3.41.2/sqlite3.h"
 
 // Debugging stuff
 #define MAIL3_TRACK_OBJS		0
 
 #define MAIL3_DB_FILE			"Database.sqlite"
 #define MAIL3_TBL_FOLDER		"Folder"
 #define MAIL3_TBL_FOLDER_FLDS	"FolderFields"
 #define MAIL3_TBL_MAIL			"Mail"
 #define MAIL3_TBL_MAILSEGS		"MailSegs"
 #define MAIL3_TBL_CONTACT		"Contact"
 #define MAIL3_TBL_GROUP			"ContactGroup"
 #define MAIL3_TBL_FILTER		"Filter"
 #define MAIL3_TBL_CALENDAR		"Calendar"
 
 class LMail3Store;
 class LMail3Mail;
 
 enum Mail3SubFormat
 {
 	Mail3v1, // All the mail and segs in a single tables.
 	Mail3v2, // All the mail and segs in per folders tables.
 };
 
 struct LMail3Def
 {
 	const char *Name;
 	const char *Type;
 };
 
 struct GMail3Idx
 {
 	const char *IdxName;
 	const char *Table;
 	const char *Column;
 };
 
 class Mail3BlobStream : public LStream
 {
 	LMail3Store *Store;
 	sqlite3_blob *b;
 	int64 Pos, Size;
 	int SegId;
 	bool WriteAccess;
 	
 	bool OpenBlob();
 	bool CloseBlob();
 
 public:
 	const char *File;
 	int Line;
 
 	Mail3BlobStream(LMail3Store *Store, int segId, int size, const char *file, int line, bool Write = false);
 	~Mail3BlobStream();
 	
 	int64 GetPos();
 	int64 SetPos(int64 p);
 	int64 GetSize();
 	int64 SetSize(int64 sz);
 	
 	ssize_t Read(void *Buf, ssize_t Len, int Flags = 0);
 	ssize_t Write(const void *Buf, ssize_t Len, int Flags = 0);
 };
 
 
 extern LMail3Def TblFolder[];
 extern LMail3Def TblFolderFlds[];
 extern LMail3Def TblMail[];
 extern LMail3Def TblMailSegs[];
 extern LMail3Def TblContact[];
 extern LMail3Def TblFilter[];
 extern LMail3Def TblGroup[];
 extern LMail3Def TblCalendar[];
 
 #define SERIALIZE_STR(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetStr(Col, Var.Str())) \
 			return false; \
 	} \
 	else \
 		Var = s.GetStr(Col);
 
 #define SERIALIZE_DATE(Var, Col) \
 	if (Write) \
 	{ \
 		if (Var.IsValid()) Var.ToUtc(); \
 		if (!s.SetDate(Col, Var)) \
 			return false; \
 	} \
 	else \
 	{ \
 		int Fmt = Var.GetFormat(); \
 		Var.SetFormat(GDTF_YEAR_MONTH_DAY|GDTF_24HOUR); \
 		Var.Set(s.GetStr(Col)); \
 		Var.SetFormat(Fmt); \
 		Var.SetTimeZone(0, false); \
 	}
 
 #define SERIALIZE_BOOL(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetBool(Col);
 
 #define SERIALIZE_INT(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetInt(Col);
 
 
 #define SERIALIZE_INT64(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt64(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetInt64(Col);
 
 #define SERIALIZE_COLOUR(Colour, Col) \
 	if (Write) \
 	{ \
 		int64_t c = Colour.IsValid() ? Colour.c32() : 0; \
 		if (!s.SetInt64(Col, c)) \
 			return false; \
 	} \
 	else \
 	{ \
 		int64_t c = s.GetInt64(Col); \
 		if (c > 0) Colour.c32((uint32_t)c); \
 		else Colour.Empty(); \
 	}
 
 #define SERIALIZE_AUTOSTR(var, Col) \
 	{ \
 		if (Write) \
 		{ \
 			if (!s.SetStr(Col, var)) \
 				return false; \
 		} \
 		else \
 		{ \
 			var.Reset(NewStr(s.GetStr(Col))); \
 		} \
 	}
 
 #define SERIALIZE_LSTR(var, Col) \
 	{ \
 		if (Write) \
 		{ \
 			if (!s.SetStr(Col, var)) \
 				return false; \
 		} \
 		else \
 		{ \
 			var = s.GetStr(Col); \
 		} \
 	}
 	
 struct LMail3StoreMsg
 {
 	enum Type
 	{
 		MsgNone,
 		MsgCompactComplete,
 		MsgRepairComplete,
 	}	Msg;
 
 	int64_t Int;
 	LString Str;
 
 	LMail3StoreMsg(Type type)
 	{
 		Msg = type;
 	}
 };
 
 class LMail3Store : public LDataStoreI
 {
 	friend class LMail3Obj;
 	friend class LMail3Mail;
 	friend class Mail3Trans;
 	friend class CompactThread;
 
 	LDataEventsI *Callback;
 	sqlite3 *Db;
 	LString Folder;
 	LString DbFile;
 	class LMail3Folder *Root;
 	LHashTbl<ConstStrKey<char,false>, LMail3Def*> Fields;
 	LHashTbl<StrKey<char,false>, GMail3Idx*> Indexes;
 	Store3Status OpenStatus;
 	LHashTbl<ConstStrKey<char,true>, Store3Status> TableStatus;
 	LString ErrorMsg;
 	LString StatusMsg;
 	LString TempPath;
 
 	std::function<void(bool)> CompactOnStatus;
 	std::function<void(bool)> RepairOnStatus;
 
 	struct TableDefn : LArray<LMail3Def>
 	{
 		LString::Array t;
 	};
 
 	bool ParseTableFormat(const char *Name, TableDefn &Defs);
 	Store3Status CheckTable(const char *Name, LMail3Def *Flds);
 	bool UpdateTable(const char *Name, LMail3Def *Flds, Store3Status Check);
 	bool DeleteMailById(int64 Id);
 	bool OpenDb();
 	bool CloseDb();
 	LMail3Folder *GetSystemFolder(int Type);
 
 public:
 	Mail3SubFormat Format;
 
 	class LStatement
 	{
 		struct PostBlob
 		{
 			int64 Size;
 			LVariant ColName;
 			LStreamI *Data;
 		};
 
 		LArray<PostBlob> Post;
 
 	protected:
 		LMail3Store *Store;
 		sqlite3_stmt *s;
 		LVariant Table;
 		LAutoString TempSql;
 		
 	public:
 		LStatement(LMail3Store *store, const char *sql = NULL);
 		virtual ~LStatement();
 
 		operator sqlite3_stmt *() { return s; }
 
 		bool IsOk()
 		{
 			return
 				#ifndef __llvm__
 				this != 0 &&
 				#endif
 				Store != 0 &&
 				s != 0;
 		}
 		bool Prepare(const char *Sql);
 		bool Row();
 		bool Exec();
 		bool Reset();
 		bool Finalize();
 		int64 LastInsertId();
 		
 		int GetSize(int Col);
 
 		bool GetBool(int Col);
 		int GetInt(int Col);
 		bool SetInt(int Col, int n);
 		int64 GetInt64(int Col);
 		bool SetInt64(int Col, int64 n);
 		char *GetStr(int Col);
 		bool GetBinary(int Col, LVariant *v);
 
 		bool SetStr(int Col, const char *s);
 		bool SetDate(int Col, LDateTime &d);
 		bool SetStream(int Col, const char *ColName, LStreamI *s);
 		bool SetBinary(int Col, const char *ColName, LVariant *v);
 
 		virtual int64 GetRowId() { LAssert(0); return -1; }
 	};
 
 	class LInsert : public LStatement
 	{
 	public:
 		LInsert(LMail3Store *store, const char *Tbl);
 
 		int64 GetRowId() { return LastInsertId(); }
 	};
 
 	class LUpdate : public LStatement
 	{
 		int64 RowId;
 
 	public:
 		LUpdate(LMail3Store *store, const char *Tbl, int64 rowId, char *ExcludeField = 0);
 
 		int64 GetRowId() { return RowId; }
 	};
 
 	class LTransaction
 	{
 		LMail3Store *Store;
 		bool Open;
 
 	public:
 		LTransaction(LMail3Store *store);
 		~LTransaction();
 		
 		bool RollBack();
 	};
 
 	#if MAIL3_TRACK_OBJS
 	struct SqliteObjs
 	{
 		LStatement *Stat;
 		Mail3BlobStream *Stream;
 		SqliteObjs()
 		{
 			Stat = 0;
 			Stream = 0;
 		}
 	};
 	LArray<SqliteObjs> All;
 	template<typename T>
 	bool RemoveFromAll(T *p)
 	{
 		for (int i=0; i<All.Length(); i++)
 		{
 			SqliteObjs &d = All[i];
 			if ((d.Stream && (void*)d.Stream == (void*)p)
 				||
 				(d.Stat && (void*)d.Stat == (void*)p))
 			{
 				All.DeleteAt(i);
 				return true;
 			}
 		}
 		LAssert(0);
 		return false;
 	}
 	#endif
 
 	LMail3Store(const char *Mail3Folder, LDataEventsI *Callback, bool Create);
 	~LMail3Store();
 
 	int64 GetFolderId(char *Path);
 	LDataEventsI *GetEvents() { return Callback; }
 	bool OnIdle() { return false; }
 	sqlite3 *GetDb() { return Db; }
 	bool IsOk();
 	int64 GetInt(int id);
 	Store3Status SetInt(int id, int64 i);
 	const char *GetStr(int id);
 	Store3Status SetStr(int id, const char *s);
 	LDataPropI *GetObj(int id);
 	uint64 Size();
 	LDataI *Create(int Type);
 	LDataFolderI *GetRoot(bool create = false);
 	Store3Status Move(LDataFolderI *NewFolder, LArray<LDataI*> &Items);
 	Store3Status Delete(LArray<LDataI*> &Items, bool ToTrash);
 	Store3Status Change(LArray<LDataI*> &Items, int PropId, LVariant &Value, LOperator Operator);
 	void Compact(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	void Upgrade(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	void Repair(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	bool SetFormat(LViewI *Parent, LDataPropI *Props);
 	void PostStore(LMail3StoreMsg *m) { Callback->Post(this, m); }
 	void OnEvent(void *Param);
 	bool Check(int Code, const char *Sql);
 	LMail3Def *GetFields(const char *t) { return Fields.Find(t); }
 
 	StoreTrans StartTransaction();
 
 	// LDataEventsI wrappers
 	void OnNew(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new);
 	bool OnMove(const char *File, int Line, LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items);
 	bool OnChange(const char *File, int Line, LArray<LDataI*> &items, int FieldHint);
 	bool OnDelete(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &items);
 
 private:
 	class Mail3Trans : public LDataStoreI::LDsTransaction
 	{
 		Mail3Trans **Ptr;
 		LTransaction Trans;
 
 	public:
 		Mail3Trans(LMail3Store *s, Mail3Trans **ptr);
 		~Mail3Trans();
 	} *Transaction;
 };
 
 class LMail3Obj
 {
 protected:
 	bool Check(int r, char *sql);
 
 public:
 	LMail3Store *Store;
 	int64 Id;
 	int64 ParentId;
 
 	LMail3Obj(LMail3Store *store)
 	{
 		Id = ParentId = -1;
 		Store = store;
 	}
 
 	bool Write(const char *Table, bool Insert);
 
 	virtual const char *GetClass() { return "LMail3Obj"; }
 	virtual bool Serialize(LMail3Store::LStatement &s, bool Write) = 0;
 	virtual void SetStore(LMail3Store *s) { Store = s; }
 };
 
 class LMail3Thing : public LDataI, public LMail3Obj 
 {
 	friend class LMail3Store;
 	LMail3Thing &operator =(LMail3Thing &p) = delete;
 
 protected:
     bool NewMail = false;
 
 	virtual const char *GetTable() { LAssert(0); return  0; }
 	virtual void OnSave() {};
 
 public:
 	LMail3Folder *Parent = NULL;
 
 	LMail3Thing(LMail3Store *store) : LMail3Obj(store)
 	{
 	}
 
 	~LMail3Thing();
 
 	const char *GetClass() { return "LMail3Thing"; }
 	bool IsOnDisk() { return Id > 0; }
 	bool IsOrphan() { return Store == NULL || Parent == NULL; }
 	uint64 Size() { return sizeof(*this); }
 	uint32_t Type() { LAssert(0); return 0; }
 	Store3Status Delete(bool ToTrash);
 	LDataStoreI *GetStore() { return Store; }
 	LAutoStreamI GetStream(const char *file, int line) { LAssert(0); return LAutoStreamI(0); }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) { LAssert(0); return false; }
 
 	Store3Status Save(LDataI *Folder = 0);
 	virtual bool DbDelete() { LAssert(0); return false; }
 };
 
 class LMail3Folder : public LDataFolderI, public LMail3Obj
 {
 public:
 	LVariant Name;
 	int Unread;
 	int Open;
 	int ItemType;
 	int Sort; // Which field to sort contents on
 	int Threaded;
 	int SiblingIndex; // The index of this folder when sorting amongst other sibling folders
 	union {
 		int AccessPerms;
 		struct {
 			int16_t ReadPerm;
 			int16_t WritePerm;
 		};
 	};
 	Store3SystemFolder System;
 
 	LMail3Folder *Parent;
 	DIterator<LDataFolderI, LMail3Folder, LMail3Store> Sub;
 	DIterator<LDataI, LMail3Thing, LMail3Store> Items;
 	DIterator<LDataPropI, Store3Field, LMail3Store> Flds;
 
 	LMail3Folder(LMail3Store *store);
 	~LMail3Folder();
 
 	Store3CopyDecl;
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	const char *GetClass() override { return "LMail3Folder"; }
 
 	uint32_t Type() override;
 	bool IsOnDisk() override;
 	bool IsOrphan() override;
 	uint64 Size() override;
 	Store3Status Save(LDataI *Folder) override;
 	Store3Status Delete(bool ToTrash) override;
 	LDataStoreI *GetStore() override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI stream) override;
 	LDataIterator<LDataFolderI*> &SubFolders() override;
 	LDataIterator<LDataI*> &Children() override;
 	LDataIterator<LDataPropI*> &Fields() override;
 	Store3Status DeleteAllChildren() override;
 	Store3Status FreeChildren() override;
 	LMail3Folder *FindSub(char *Name);
 	bool DbDelete();
 	bool GenSizes();
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 };
 
 class LMail3Attachment : public Store3Attachment<LMail3Store, LMail3Mail, LMail3Attachment>
 {
 	int64 SegId;
 	int64 BlobSize;
 
 	LAutoString Headers;
 
 	LString Name;
 	LString MimeType;
 	LString ContentId;
 	LString Charset;
 	
 	/// This is set when the segment is not to be stored on disk.
 	/// When signed and/or encrypted messages are stored, the original
 	/// rfc822 image is maintained by not MIME decoding into separate
 	/// segments but leaving it MIME encoded in one seg (headers and body).
 	/// At runtime the segment is loaded and parsed into a temporary tree
 	/// of LMail3Attachment objects. This flag is set for those temporary
 	/// nodes.
 	bool InMemoryOnly;
 
 public:
 	LMail3Attachment(LMail3Store *store);
 	~LMail3Attachment();
 
 	void SetInMemoryOnly(bool b);
 	int64 GetId() { return SegId; }
 	LMail3Attachment *Find(int64 Id);
 	bool Load(LMail3Store::LStatement &s, int64 &ParentId);
 	bool ParseHeaders() override;
 	char *GetHeaders();
 	bool HasHeaders() { return ValidStr(Headers); }
 
 	Store3CopyDecl;
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 	Store3Status Delete(bool ToTrash = false) override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI stream) override;
 
 	uint32_t Type() override { return MAGIC_ATTACHMENT; }
 	bool IsOnDisk() override { return SegId > 0; }
 	bool IsOrphan() override { return false; }
 	uint64 Size() override;
 	uint64 SizeChildren();
 	Store3Status Save(LDataI *Folder = 0) override;
 	void OnSave() override;
 };
 
 class LMail3Mail : public LMail3Thing
 {
 	LAutoString TextCache;
 	LAutoString HtmlCache;
 	LString IdCache;
 	LAutoPtr<uint64> SizeCache;
 	LString InferredCharset;
+	LString ErrMsg;
 
 	void LoadSegs();
 	void OnSave() override;
 
 	const char *GetTable() override { return MAIL3_TBL_MAIL; }
 	void ParseAddresses(char *Str, int CC);
 	const char *InferCharset();
 	bool Utf8Check(LVariant &v);
 	bool Utf8Check(LAutoString &v);
 
 public:
 	int Priority = MAIL_PRIORITY_NORMAL;
 	int Flags = 0;
 	int AccountId = 0;
 	int64 MailSize = 0;
 	uint32_t MarkColour = Rgba32(0, 0, 0, 0); // FIELD_MARK_COLOUR, 32bit rgba colour
 
 	LVariant Subject;
 	DIterator<LDataPropI, Store3Addr, LMail3Store> To;
 	LMail3Attachment *Seg = NULL;
 	Store3Addr From;
 	Store3Addr Reply;
 	LVariant Label;
 	LVariant MessageID;
 	LVariant References;
 	LVariant FwdMsgId;
 	LVariant BounceMsgId;
 	LVariant ServerUid;
 
 	LDateTime DateReceived;
 	LDateTime DateSent;
 
 	LMail3Mail(LMail3Store *store);
 	~LMail3Mail();
 
 	Store3CopyDecl;
 	void SetStore(LMail3Store *s) override;
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	const char *GetClass() override { return "LMail3Mail"; }
 	LMail3Attachment *GetAttachment(int64 Id);
 	bool FindSegs(const char *MimeType, LArray<LMail3Attachment*> &Segs, bool Create = false);
 	int GetAttachments(LArray<LMail3Attachment*> *Lst = 0);
     bool ParseHeaders() override;
     void ResetCaches();
 
 	uint32_t Type() override;
 	uint64 Size() override;
 	bool DbDelete() override;
 	LDataStoreI *GetStore() override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI  stream) override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *t) override;
 	LDataPropI *GetObj(int id) override;
 	Store3Status SetObj(int id, LDataPropI *i) override;
 	LDataIt GetList(int id) override;
 	Store3Status SetRfc822(LStreamI *m) override;
 };
 
 class LMail3Contact : public LMail3Thing
 {
 	const char *GetTable() override { return MAIL3_TBL_CONTACT; }
 	LHashTbl<IntKey<int64>, LString*> f;
 
 public:
 	LVariant Image;
 	LDateTime DateMod;
 
 	LMail3Contact(LMail3Store *store);
 	~LMail3Contact();
 
 	uint32_t Type() override { return MAGIC_CONTACT; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Contact"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 
 	int64 GetInt(int id) override { return -1; }
 
 	LVariant *GetVar(int id) override;
 	Store3Status SetVar(int id, LVariant *i) override;
 
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Group : public LMail3Thing
 {
 	const char *GetTable() override { return MAIL3_TBL_GROUP; }
 
 	LString Name;
 	LString Group;
 	LDateTime DateMod;
 
 public:
 	LMail3Group(LMail3Store *store);
 	~LMail3Group();
 
 	uint32_t Type() override { return MAGIC_GROUP; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Group"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 
 	int64 GetInt(int id) override { return -1; }
 
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Filter : public LMail3Thing
 {
 	int Index;
 	int StopFiltering;
 	int Direction;
 	LString Name;
 	LString ConditionsXml;
 	LString ActionsXml;
 	LString Script;
 	LDateTime Modified;
 
 	const char *GetTable() override { return MAIL3_TBL_FILTER; }
 
 public:
 	LMail3Filter(LMail3Store *store);
 	~LMail3Filter();
 
 	uint32_t Type() override { return MAGIC_FILTER; }
 	LDataStoreI *GetStore() override { return Store; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Filter"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;	
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int Col, int64 n) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Calendar : public LMail3Thing
 {
 	LString ToCache;
 
 private:
 	int CalType = 0; // FIELD_CAL_TYPE
 	LString To; // FIELD_TO
 	CalendarPrivacyType CalPriv = CalDefaultPriv; // FIELD_CAL_PRIVACY
 	int Completed = 0; // FIELD_CAL_COMPLETED
 	LDateTime Start; // FIELD_CAL_START_UTC
 	LDateTime  End; // FIELD_CAL_END_UTC
 	LString TimeZone; // FIELD_CAL_TIMEZONE
 	LString Subject; // FIELD_CAL_SUBJECT
 	LString Location; // FIELD_CAL_LOCATION
 	LString Uid; // FIELD_UID
 	bool AllDay = false; // FIELD_CAL_ALL_DAY
 	int64 StoreStatus = Store3Success; // FIELD_STATUS - ie the current Store3Status
 	LString EventStatus; // FIELD_CAL_STATUS
 	LDateTime Modified; // FIELD_DATE_MODIFIED
 
 	LString Reminders; // FIELD_CAL_REMINDERS
 	LDateTime LastCheck; // FIELD_CAL_LAST_CHECK
 	int ShowTimeAs = 0; // FIELD_CAL_SHOW_TIME_AS
 
 	int Recur = 0; // FIELD_CAL_RECUR
 	int RecurFreq = 0; // FIELD_CAL_RECUR_FREQ
 	int RecurInterval = 0; // FIELD_CAL_RECUR_INTERVAL
 	LDateTime RecurEnd; // FIELD_CAL_RECUR_END_DATE
 	int RecurCount = 0; // FIELD_CAL_RECUR_END_COUNT
 	int RecurEndType = 0; // FIELD_CAL_RECUR_END_TYPE
 	LString RecurPos; // FIELD_CAL_RECUR_FILTER_POS
 	
 	int FilterDays = 0; // FIELD_CAL_RECUR_FILTER_DAYS
 	int FilterMonths = 0; // FIELD_CAL_RECUR_FILTER_MONTHS
 	LString FilterYears; // FIELD_CAL_RECUR_FILTER_YEARS
 	LString Notes; // FIELD_CAL_NOTES
 	
 	LColour Colour;
 
 	const char *GetTable() override { return MAIL3_TBL_CALENDAR; }
 
 public:
 	LMail3Calendar(LMail3Store *store);
 	~LMail3Calendar();
 
 	uint32_t Type() override { return MAGIC_CALENDAR; }
 	LDataStoreI *GetStore() override { return Store; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Filter"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int Col, int64 n) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *t) override;
 };
 
 #endif
diff --git a/src/Store3Mail3/Mail3Attachment.cpp b/src/Store3Mail3/Mail3Attachment.cpp
--- a/src/Store3Mail3/Mail3Attachment.cpp
+++ b/src/Store3Mail3/Mail3Attachment.cpp
@@ -1,568 +1,581 @@
 #include "Mail3.h"
 #include "lgi/common/TextConvert.h"
 
 Mail3BlobStream::Mail3BlobStream(LMail3Store *store, int segid, int size, const char *file, int line, bool Write)
 {
 	Store = store;
 	File = file;
 	Line = line;
 	b = 0;
 	Pos = 0;
 	Size = size;
 	SegId = segid;
 	WriteAccess = Write;
 	
 	#if MAIL3_TRACK_OBJS
 	LMail3Store::SqliteObjs &_d = Store->All.New();
 	_d.Stream = this;
 	#endif
 
 	OpenBlob();
 }
 
 Mail3BlobStream::~Mail3BlobStream()
 {
 	CloseBlob();
 	#if MAIL3_TRACK_OBJS
 	Store->RemoveFromAll(this);
 	#endif
 }
 
 bool Mail3BlobStream::OpenBlob()
 {
 	bool Res = Store->Check(sqlite3_blob_open(Store->GetDb(),
 											NULL, // Database
 											"MailSegs",
 											"Data",
 											SegId,
 											WriteAccess,
 											&b), 0);
 	// if (b) LgiTrace("%s:%i - open blob %p\n", _FL, b);
 	return Res;
 }
 
 bool Mail3BlobStream::CloseBlob()
 {
 	if (!b)
 		return true;
 
 	// LgiTrace("%s:%i - close blob %p\n", _FL, b);
 	int Res = sqlite3_blob_close(b);
 	b = NULL;
 	return Store->Check(Res, 0);
 }
 
 int64 Mail3BlobStream::GetPos()
 {
 	return Pos;
 }
 
 int64 Mail3BlobStream::SetPos(int64 p)
 {
 	if (p < 0)
 		p = 0;
 	if (p > Size)
 		p = Size;
 	return Pos = p;
 }
 
 int64 Mail3BlobStream::GetSize()
 {
 	return Size;
 }
 
 int64 Mail3BlobStream::SetSize(int64 sz)
 {
 	LAssert(!"You can't set the size of a blob.");
 	return Size;
 }
 
 
 
 ssize_t Mail3BlobStream::Read(void *Buf, ssize_t Len, int Flags)
 {
 	if (!b)
 		return 0;
 
 	int64 Remain = Size - Pos;
 	int64 Copy = MIN(Remain, Len);
 	auto Res = sqlite3_blob_read(b, Buf, (int)Copy, (int)Pos);
 	if (Res == SQLITE_ABORT)
 	{
 		if (!CloseBlob())
 			return 0;	
 		if (!OpenBlob())
 			return 0;	
 		Res = sqlite3_blob_read(b, Buf, (int)Copy, (int)Pos);
 	}
 	
 	if (!Store->Check(Res, 0))
 		return 0;
 
 	Pos += Copy;
 	return (ssize_t) Copy;
 }
 
 ssize_t Mail3BlobStream::Write(const void *Buf, ssize_t Len, int Flags)
 {
 	if (!b)
 		return 0;
 
 	auto Res = sqlite3_blob_write(b, Buf, (int)Len, (int)Pos);
 	if (Res == SQLITE_ABORT)
 	{
 		if (!CloseBlob())
 			return 0;	
 		if (!OpenBlob())
 			return 0;	
 		Res = sqlite3_blob_write(b, Buf, (int)Len, (int)Pos);
 	}
 
 	if (!Store->Check(Res, 0))
 		return 0;
 	
 	Pos += Len;
 	return Len;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////
 LMail3Attachment::LMail3Attachment(LMail3Store *store) :
 	Store3Attachment<LMail3Store, LMail3Mail, LMail3Attachment>(store)
 {
 	SegId = -1;
 	BlobSize = 0;
 	InMemoryOnly = false;
 }
 
 LMail3Attachment::~LMail3Attachment()
 {
 	_Delete();
 }
 
 void LMail3Attachment::SetInMemoryOnly(bool b)
 {
 	InMemoryOnly = b;
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		Children.a[i]->SetInMemoryOnly(b);
 	}
 }
 
 uint64 LMail3Attachment::Size()
 {
 	int64 HeaderSz = Headers ? strlen(Headers) : 0;
 	int64 NameSz = Name.Length();
 	int64 MimeSz = MimeType.Length();
 	int64 ContentIdSz = ContentId.Length();
 	int64 CharsetSz = Charset.Length();
 	int64 ImportSz = Import ? Import->GetSize() : 0;
 	
 	return	HeaderSz +
 			NameSz +
 			MimeSz +
 			ContentIdSz +
 			CharsetSz +
 			BlobSize +
 			sizeof(BlobSize) + 
 			sizeof(SegId) +
 			ImportSz;
 }
 
 uint64 LMail3Attachment::SizeChildren()
 {
 	uint64 s = 0;
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LMail3Attachment *c = Children.a[i];
 		s += c->Size();
 		s += c->SizeChildren();
 	}
 	return s;	
 }
 
 LMail3Attachment *LMail3Attachment::Find(int64 Id)
 {
 	if (SegId == Id)
 		return this;
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LMail3Attachment *r = Children.a[i]->Find(Id);
 		if (r)
 			return r;
 	}
 
 	return 0;
 }
 
 Store3CopyImpl(LMail3Attachment)
 {
 	Headers.Reset(NewStr(p.GetStr(FIELD_INTERNET_HEADER)));
 	if (Headers)
 	{
 		// Source supports headers...
 		ParseHeaders();
 	}
 	else
 	{
 		// Copy over whatever fields we can...
 		Name = p.GetStr(FIELD_NAME);
 		MimeType = p.GetStr(FIELD_MIME_TYPE);
 		ContentId = p.GetStr(FIELD_CONTENT_ID);
 		Charset = p.GetStr(FIELD_CHARSET);
 	}
 	
 	LDataI *Data = dynamic_cast<LDataI*>(&p);
 	if (Data)
 	{
 		LAutoStreamI tmp = Data->GetStream(_FL);
 		SetStream(tmp);
 	}
 	return true;
 }
 
 char *LMail3Attachment::GetHeaders()
 {
 	if (!Headers)
 	{
 		LStringPipe p;
 		if (!MimeType)
 		{
 			LAssert(!"MimeType is required.");
 			return NULL;
 		}
 		p.Print("Content-Type: %s", MimeType?MimeType.Get():(char*)"text/plain");
 		if (Charset)
 			p.Print("; charset=%s", Charset.Get());
 		if (Name)
 			p.Print("; name=\"%s\"", Name.Get());
 		p.Print("\r\n");
 		if (ContentId)
 		{
 			p.Print("Content-Id: <%s>\r\n", ContentId.Strip("<>").Get());
 			if (Name)
 				p.Print("Content-Disposition: inline; filename=\"%s\"\r\n", Name.Get());
 		}
 		Headers.Reset(p.NewStr());		
 	}
 
 	return Headers;
 }
 
 bool LMail3Attachment::ParseHeaders()
 {
 	LAutoString Ct(InetGetHeaderField(Headers, "Content-Type"));
 	char *Colon = Ct ? strchr(Ct, ';') : 0;
 	if (Colon)
 	{
 		while (Colon > Ct.Get() && strchr(" \t\r\n", Colon[-1])) Colon--;
 
 		LAutoString Cs(InetGetSubField(Colon, "charset"));
 		if (Cs)
 		{
 			Charset = Cs.Get();
 			LAssert(!strchr(Charset, '>'));
 		}
 		
 		*Colon = 0;
 	}
 
 	MimeType = Ct;
 	
 	return true;
 }
 
 bool LMail3Attachment::Load(LMail3Store::LStatement &s, int64 &ParentId)
 {
 	SegId = s.GetInt64(0);
 	ParentId = s.GetInt64(2);
 	
 	Headers.Reset(NewStr(s.GetStr(3)));
 	ParseHeaders();
 	
 	BlobSize = s.GetSize(4);
 	Dirty = false;
 
+	#ifdef _DEBUG
+	// This was a hack to fix a dumb bug in a dev build... so so dumb.
+	if (Headers)
+	{
+		auto cdcd = Strstr(Headers.Get(), "\xcd\xcd");
+		if (cdcd)
+		{
+			*cdcd = 0;
+			Dirty = true;
+		}
+	}	
+	#endif
+
 	LAssert(!Mail || Kit == Mail->Store);
 
 	return true;
 }
 
 Store3Status LMail3Attachment::Save(LDataI *NewParent)
 {
 	if (NewParent)
 	{
 		// Check hierarchy
 		LMail3Attachment *NewSeg = dynamic_cast<LMail3Attachment*>(NewParent);
 		if (NewSeg)
 		{
 			// This propagates the in mem only setting down the tree of nodes
 			InMemoryOnly = NewSeg->InMemoryOnly;
 			if (NewSeg != Parent)
 				AttachTo(NewSeg);
 		}
 		else
 		{
 			LMail3Mail *NewMail = dynamic_cast<LMail3Mail*>(NewParent);
 			if (NewMail)
 			{
 				if (NewMail != Mail)
 					AttachTo(NewMail);
 			}
 		}
 	}
 
 	if (Mail)
 	{
 		// Mark the mail size dirty.
 		Mail->MailSize = -1;
 
 		LAssert(Kit == Mail->Store);
 	}
 
 	if (!InMemoryOnly)
 	{
 		if (Mail && Mail->Id > 0)
 		{
 			if (SegId <= 0)
 			{
 				LMail3Attachment *Parent = GetParent();
 
 				LMail3Store::LInsert Ins(Kit, MAIL3_TBL_MAILSEGS);
 				Ins.SetInt64(1, Mail->Id);
 				Ins.SetInt64(2, Parent ? Parent->SegId : -1);
 				Ins.SetStr(3, GetHeaders());
 				if (Import)
 					Ins.SetStream(4, "Data", Import);
 				if (!Ins.Exec())
 					return Store3Error;
 
 				SegId = Ins.LastInsertId();
 			}
 			else if (Dirty)
 			{
 				LMail3Attachment *Parent = GetParent();
 
 				LMail3Store::LUpdate Up(Kit, MAIL3_TBL_MAILSEGS, SegId, Import ? 0 : (char*)"Data");
 				Up.SetInt64(0, SegId);
 				Up.SetInt64(1, Mail->Id);
 				Up.SetInt64(2, Parent ? Parent->SegId : -1);
 				Up.SetStr(3, GetHeaders());
 				if (Import)
 					Up.SetStream(4, "Data", Import);
 				if (!Up.Exec())
 					return Store3Error;
 
 			}
 
  			Import.Reset();
 			Dirty = false;
 		}
 		else
 		{
 			Dirty = true;
 		}
 	}
 
 	return Store3Success;
 }
 
 void LMail3Attachment::OnSave()
 {
 	if (!Mail)
 	{
 		LAssert(!"Segment is not attached to a mail!");
 		return;
 	}
 
 	if (Dirty || SegId <= 0)
 	{
 		Save();
 	}
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		Children.a[i]->OnSave();
 	}
 }
 
 const char *LMail3Attachment::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_CHARSET:
 		{
 		    if (!Charset)
 		    {
 			    // Maybe a parent segment has a charset?
 			    for (LMail3Attachment *p = GetParent(); p; p = p->GetParent())
 			    {
 			        auto Cs = p->GetStr(FIELD_CHARSET);
 			        if (Cs)
 			            return Cs;
 			    }
 			}
 
 			return Charset;
 		}
 		case FIELD_NAME:
 		{
 			if (!Name)
 			{
 				LAutoString t(InetGetHeaderField(Headers, "Content-Disposition"));
 				
 				LAutoString n(DecodeRfc2047(InetGetSubField(t, "filename")));
 				if (n)
 					Name = n.Get();
 				else
 				{
 					LAutoString ct(InetGetHeaderField(Headers, "Content-Type"));
 					if (ct)
 					{
 						if (n.Reset(DecodeRfc2047(InetGetSubField(ct, "name"))))
 							Name = n.Get();
 					}
 				}
 			}
 
 			return Name;
 			break;
 		}
 		case FIELD_MIME_TYPE:
 		{
 			if (!MimeType)
 			{
 				LAutoString t(InetGetHeaderField(Headers, "Content-Type"));
 				if (t)
 				{
 					char *c = strchr(t, ';');
 					if (c)
 					{
 						while (strchr(" \t\r\n", c[-1])) c--;
 						MimeType.Set(t, c ? c - t : -1);
 					}
 				}
 			}
 
 			return MimeType;
 			break;
 		}
 		case FIELD_CONTENT_ID:
 		{
 			if (!ContentId)
 			{
 				LAutoString Id(InetGetHeaderField(Headers, "Content-Id"));
 				ContentId = LString(Id.Get()).Strip("<>");
 			}
 
 			return ContentId;
 			break;
 		}
 		case FIELD_INTERNET_HEADER:
 			return Headers;
 	}
 
 	LAssert(!"Unknown id.");
 	return NULL;
 }
 
 Store3Status LMail3Attachment::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_INTERNET_HEADER:
         	Headers.Reset(NewStr(str));
 			ParseHeaders();
 			break;
 		case FIELD_NAME:
 			Name = str;
 			Headers.Reset();
 			break;
 		case FIELD_MIME_TYPE:
 			MimeType = str;
 
 			// FIXME: If we have headers from an incoming mail, this is an error to delete them here.
 			LAssert(Headers.Get() == NULL);
 
 			Headers.Reset();
 			break;
 		case FIELD_CONTENT_ID:
 			ContentId = LString(str).Strip("<>");
 			Headers.Reset();
 			break;
 		case FIELD_CHARSET:
 			Charset = str;
 			if (Charset.Find(">") >= 0)
 				LAssert(!"Invalid char");
 			
 			Headers.Reset();
 			break;
 		default:
 			LAssert(!"Unknown id.");
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 int64 LMail3Attachment::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_STORE_TYPE:
 			return Store3Sqlite;
 		case FIELD_SIZE:
 			return BlobSize;
 	}
 
 	LAssert(!"Unknown id.");
 	return false;
 }
 
 Store3Status LMail3Attachment::SetInt(int id, int64 i)
 {
 	LAssert(!"Unknown id.");
 	return Store3Error;
 }
 
 Store3Status LMail3Attachment::Delete(bool ToTrash)
 {
 	if (InMemoryOnly)
 		return Store3Success;
 
 	if (SegId <= 0)
 		return Store3Error;
 
 	LString Sql;
 	Sql.Printf("delete from " MAIL3_TBL_MAILSEGS " where Id=" LPrintfInt64, SegId);
 	LMail3Store::LStatement s(Kit, Sql);
 	if (!s.Exec())
 		return Store3Error;
 
 	SegId = -1;
 	return Store3Success;
 }
 
 LAutoStreamI LMail3Attachment::GetStream(const char *file, int line)
 {
 	LAutoStreamI Ret;
 
 	if (Import)
 		Ret.Reset(new LProxyStream(Import));
 	else if (SegId > 0 && BlobSize > 0)
 		Ret.Reset(new Mail3BlobStream(Kit, (int)SegId, (int)BlobSize, file, line));
 
 	return Ret;
 }
 
 bool LMail3Attachment::SetStream(LAutoStreamI s)
 {
 	Import = s;
 	Dirty = true;
 	BlobSize = Import ? Import->GetSize() : 0;
 	
 	if (Mail)
 		Mail->ResetCaches();
 	
 	return true;
 }
diff --git a/src/Store3Mail3/Mail3Mail.cpp b/src/Store3Mail3/Mail3Mail.cpp
--- a/src/Store3Mail3/Mail3Mail.cpp
+++ b/src/Store3Mail3/Mail3Mail.cpp
@@ -1,1622 +1,1646 @@
 #include "Mail3.h"
 #include "lgi/common/Mail.h"
 #include "lgi/common/Store3MimeTree.h"
 #include "lgi/common/StreamConcat.h"
 #include "lgi/common/TextConvert.h"
 #include "ScribeUtils.h"
 
 LMail3Def TblMail[] =
 {
 	{"Id",				"INTEGER PRIMARY KEY AUTOINCREMENT"},
 	{"ParentId",		"INTEGER"},
 
 	// Integers
 		{"Priority",		"INTEGER"},
 		{"Flags",			"INTEGER"},
 		{"AccountId",		"INTEGER"},
 		{"MarkColour",		"INTEGER"},
 
 	// Strings
 		{"Subject",			"TEXT"},
 		{"ToAddr",			"TEXT"},
 		{"FromAddr",		"TEXT"},
 		{"Reply",			"TEXT"},
 		{"Label",			"TEXT"},
 		{"InternetHeader",	"TEXT"},
 		{"MessageID",		"TEXT"},
 		{"Ref",				"TEXT"},
 		{"FwdMsgId",		"TEXT"},
 		{"BounceMsgId",		"TEXT"},
 		{"ServerUid",		"TEXT"},
 
 	// Date/times
 		{"DateReceived",	"TEXT"},
 		{"DateSent",		"TEXT"},
 
     // Other meta data
 		{"Size",    		"INTEGER"},
 
 	{0, 0}
 };
 
 LMail3Def TblMailSegs[] =
 {
 	{"Id",				"INTEGER PRIMARY KEY AUTOINCREMENT"},
 	{"MailId",			"INTEGER"},
 	{"ParentId",		"INTEGER"},
 	{"Headers",			"TEXT"},
 	{"Data",			"BLOB"},
 	
 	{0,					0},
 };
 
 bool Mail3_InsertSeg(LMail3Store::LInsert &Ins, LMime *m, int64 ParentId, int64 ParentSeg, int64 &MailSize)
 {
 	Ins.SetInt64(1, ParentId);
 	Ins.SetInt64(2, ParentSeg);
 	Ins.SetStr(3, m->GetHeaders());
 
 	LStreamI *MimeData = m->GetData();
 	int64 Sz = MimeData ? MimeData->GetSize() : 0;
 	if (Sz > 0)
 		MailSize += Sz;
 	
 	Ins.SetStream(4, "Data", MimeData);
 
 	if (!Ins.Exec())
 		return false;
 
 	ParentSeg = Ins.LastInsertId();
 	Ins.Reset();
 
 	for (int i=0; i<m->Length(); i++)
 	{
 		LMime *c = (*m)[i];
 		if (!Mail3_InsertSeg(Ins, c, ParentId, ParentSeg, MailSize))
 			return false;
 	}
 
 	return true;
 }
 
 bool Mail3_CopySegs(LMail3Mail *m, LMail3Attachment *parent, LDataI *in)
 {
 	const char *Mt = in->GetStr(FIELD_MIME_TYPE);
 	if (!Mt)
 	{
 		return false;
 	}
 	
 	LMail3Attachment *out = new LMail3Attachment(m->Store);
 	if (!out)
 		return false;
 
 	out->CopyProps(*in);
 	if (parent)
 		out->AttachTo(parent);
 	else
 		out->AttachTo(m);
 
 	LDataIt It = in->GetList(FIELD_MIME_SEG);
 	for (LDataPropI *c = It->First(); c; c = It->Next())
 	{
 		LDataI *child = dynamic_cast<LDataI*>(c);
 		if (child && !Mail3_CopySegs(m, out, child))
 			return false;
 	}
 
 	return true;
 }
 
 LMail3Mail::LMail3Mail(LMail3Store *store) :
 	LMail3Thing(store),
 	From(store),
 	Reply(store)
 {
 	To.State = Store3Loaded;
 }
 
 LMail3Mail::~LMail3Mail()
 {
 	To.DeleteObjects();
 	DeleteObj(Seg);
 }
 
 #define DEBUG_COPY_PROPS		0
 
 Store3CopyImpl(LMail3Mail)
 {
 #if DEBUG_COPY_PROPS
 LProfile Prof("Store3CopyProps");
 #endif
 	Priority = (int)p.GetInt(FIELD_PRIORITY);
 	Flags = (int)p.GetInt(FIELD_FLAGS);
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 
 	SetStr(FIELD_INTERNET_HEADER, p.GetStr(FIELD_INTERNET_HEADER));
 	MessageID = p.GetStr(FIELD_MESSAGE_ID);
 	Subject = p.GetStr(FIELD_SUBJECT);
 	MarkColour = (int)p.GetInt(FIELD_COLOUR);
 	AccountId = (int)p.GetInt(FIELD_ACCOUNT_ID);
 	SetStr(FIELD_LABEL, p.GetStr(FIELD_LABEL));
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	LDataPropI *i = p.GetObj(FIELD_FROM);
 	if (i) From.CopyProps(*i);
 	i = p.GetObj(FIELD_REPLY);
 	if (i) Reply.CopyProps(*i);
 	
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	const LDateTime *d = p.GetDate(FIELD_DATE_RECEIVED);
 	if (d) DateReceived = *d;
 	d = p.GetDate(FIELD_DATE_SENT);
 	if (d) DateSent = *d;
 	
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	To.DeleteObjects();
 	LDataIt pTo = p.GetList(FIELD_TO);
 	for (unsigned n=0; n<pTo->Length(); n++)
 	{
 		To.Insert(new Store3Addr(GetStore(), (*pTo)[n]), -1, true);
 	}
 	To.State = Store3Loaded;
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	LDataI *Root = dynamic_cast<LDataI*>(p.GetObj(FIELD_MIME_SEG));
 	if (Root)
 	{
 		// Must commit ourselves now and get an Id if needed
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 		if (Id > 0 || Write(MAIL3_TBL_MAIL, true))
 		{
 		    // Clear existing segment if present...
 		    LAssert(!Seg || Seg->GetId() < 0);
 			DeleteObj(Seg);
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 			// Save all the segments out
 			Mail3_CopySegs(this, NULL, Root);
 			
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 			OnSave();
 		}
 	}
 
 	return true;
 }
 
 void LMail3Mail::SetStore(LMail3Store *s)
 {
 	if (Id < 0)
 	{
 		LMail3Thing::SetStore(s);
 		From.SetStore(s);
 		Reply.SetStore(s);
 		if (Seg)
 			Seg->SetMail(this);
 	}
 	else LAssert(!"Object is already commited to another store.");
 }
 
 bool SafeAddrTokenize(const char *In, List<char> &Out, bool Debug = false)
 {
 	if (!In)
 		return false;
 	
 	// Find all the characters of interest...
 	LArray<const char*> a;
 	for (const char *c = In; *c; c++)
 	{
 		if (strchr("\':,<@>", *c))
 			a.Add(c);
 	}
 	
 	// Now do pattern matching. We may encounter weird numbers of single
 	// quotes due to recipient names having un-escaped single quotes.
 	const char *Last = In;
 	LAutoString Str;
 	for (ssize_t i=0; i<(ssize_t)a.Length(); i++)
 	{
 		// Check for '<' '@', '>' pattern
 		if (i < (ssize_t)a.Length() - 4 &&
 			*a[i] == '<' &&
 			*a[i+1] == '@' &&
 			*a[i+2] == '>' &&
 			*a[i+3] == ':' &&
 			*a[i+4] == ',')
 		{
 			const char *e = a[i+4];
 			Str.Reset(NewStr(Last, e-Last));
 			Last = e + 1;
 		}
 		else if (i < (ssize_t)a.Length() - 3 &&
 			*a[i] == '<' &&
 			*a[i+1] == '@' &&
 			*a[i+2] == '>' &&
 			*a[i+3] == ':')
 		{
 			const char *e = a[i+3];
 			while (*e) e++;
 			Str.Reset(NewStr(Last, e-Last));
 			Last = e;
 		}
 		else if (i < (ssize_t)a.Length() - 2 &&
 			*a[i] == '<' &&
 			*a[i+1] == '>' &&
 			*a[i+2] == ':')
 		{
 			// This case handles a group name without a '@' in it...
 			const char *e = a[i+2];
 			while (*e) e++;
 			Str.Reset(NewStr(Last, e-Last));
 			Last = e;
 		}
 		else break;
 		
 		if (Str)
 		{
 			Out.Insert(Str.Release());
 		}
 	}
 	
 	return true;
 }
 
 #if 1
 #define DEBUG_SERIALIZE(...)	 if (Debug) LgiTrace(__VA_ARGS__)
 #else
 #define DEBUG_SERIALIZE(...)
 #endif
 
 bool LMail3Mail::Serialize(LMail3Store::LStatement &s, bool Write)
 {
 	static LVariant vTo, vFrom, vReply;
 	bool Debug = false;
 	
 	// Save the objects to strings
 	if (Write)
 	{
 		if (MailSize < 0 && Seg)
 		{
 			MailSize = (uint32_t) (Seg->Size() + Seg->SizeChildren());
 		}
 		
 		if (!From.GetValue("Text", vFrom))
 			vFrom.Empty();
 		if (!Reply.GetValue("Text", vReply))
 			vReply.Empty();
 
 		LStringPipe p;
 		int Done = 0;
 		for (unsigned i=0; i<To.Length(); i++)
 		{
 			LVariant v;
 			Store3Addr *a = To.a[i];
 			if (a->GetValue("Text", v) && v.Str())
 			{
 			    const char *Comma = Done ? ", " : "";
 				DEBUG_SERIALIZE("ToText='%s'\n", v.Str());
 				p.Print("%s%s:%i", Comma, v.Str(), a->CC);
 				Done++;
 			}
 		}
 		vTo.OwnStr(p.NewStr());
 		DEBUG_SERIALIZE("vTo='%s'\n", vTo.Str());
 	}
 
 	int i = 0;
 	LVariant NullInternetHeader; // The internet header is now stored
 								// In the first segment ONLY. But it
 								// wasn't worth removing the field in
 								// the DB.
 
 	SERIALIZE_INT64(Id, i++);
 	SERIALIZE_INT64(ParentId, i++);
 
 	SERIALIZE_INT(Priority, i++);
 	SERIALIZE_INT(Flags, i++);
 	SERIALIZE_INT(AccountId, i++);
 	SERIALIZE_INT(MarkColour, i++);
 
 	SERIALIZE_STR(Subject, i++);
 	SERIALIZE_STR(vTo, i++);
 	SERIALIZE_STR(vFrom, i++);
 	SERIALIZE_STR(vReply, i++);
 	SERIALIZE_STR(Label, i++);
 	SERIALIZE_STR(NullInternetHeader, i++);
 	SERIALIZE_STR(MessageID, i++);
 	SERIALIZE_STR(References, i++);
 	SERIALIZE_STR(FwdMsgId, i++);
 	SERIALIZE_STR(BounceMsgId, i++);
 	SERIALIZE_STR(ServerUid, i++);
 
 	SERIALIZE_DATE(DateReceived, i++);
 	SERIALIZE_DATE(DateSent, i++);
 
 	SERIALIZE_INT64(MailSize, i++);
 
 	// Load the objects from the strings
 	if (!Write)
 	{
 		From.SetValue("Text", vFrom);
 		Reply.SetValue("Text", vReply);
 
 		To.DeleteObjects();
 		List<char> Addr;
 		char *ToStr = vTo.Str();
 		//DEBUG_SERIALIZE("ReadTo='%s'\n", ToStr);
 		int Colons = 0;
 		int Commas = 0;
 		for (char *c = ToStr; c && *c; c++)
 		{
 			if (*c == ':')
 				Colons++;
 			else if (*c == ',')
 				Commas++;
 		}
 		if (Commas == 1 && Colons > 1)
 		{
 			// Broken data
 			char *c = ToStr;
 			while (*c)
 			{
 				while (*c && (strchr(WhiteSpace, *c) || *c == ','))
 					c++;
 					
 				char *e = strchr(c, '>');
 				if (!e)
 					break;
 				e++;
 				if (*e == ':')
 					e++;
 				while (IsDigit(*e))
 					e++;
 				
 				char *a = NewStr(c, e - c);
 				if (!a)
 					break;
 					
 				Addr.Insert(a);
 				c = e;
 			}
 		}
 		else
 		{
 			// Correct data? Hopefully...
 			#if 1
 			SafeAddrTokenize(vTo.Str(), Addr);
 			#else
 			TokeniseStrList(vTo.Str(), Addr, ",");
 			#endif
 		}
 		
 		for (auto r: Addr)
 		{
 			Store3Addr *a = new Store3Addr(GetStore());
 			if (a)
 			{
 				char *CcType = strrchr(r, ':');
 				if (CcType)
 					*CcType++ = 0;
 
 				LAutoString Name, Addr;
 				DecodeAddrName(r, Name, Addr, 0);
 				
 				a->SetStr(FIELD_NAME, Name);
 				a->SetStr(FIELD_EMAIL, Addr);
 				a->CC = CcType ? atoi(CcType) : 0;
 				
 				To.Insert(a, -1, true);
 			}
 		}
 		Addr.DeleteArrays();
 		To.State = Store3Loaded;
 	}
 
 	return true;
 }
 
 uint32_t LMail3Mail::Type()
 {
 	return MAGIC_MAIL;
 }
 
 size_t Sizeof(LVariant &v)
 {
 	int s = 0;
 	switch (v.Type)
 	{
 		default:
 			break;
 		case GV_STRING:
 			return (int)strlen(v.Str());
 		case GV_WSTRING:
 			return StrlenW(v.WStr()) * sizeof(char16);
 	}
 	return s + sizeof(v);
 }
 
 size_t Sizeof(DIterator<LDataPropI, Store3Addr, LMail3Store> &i)
 {
 	size_t s = sizeof(i);
 	for (unsigned n=0; n<i.Length(); n++)
 		s += i.a[n]->Sizeof();
 
 	return s;
 }
 
 uint64 LMail3Mail::Size()
 {
 	if (MailSize < 0 && Seg)
 	{
 		MailSize = (uint32_t) (Seg->Size() + Seg->SizeChildren());
 	}
 
 	return	MailSize + // Size of mime segments...
 			sizeof(Priority) +
 			sizeof(Flags) +
 			sizeof(AccountId) +
 			Sizeof(Subject) +
 			Sizeof(To) +
 			From.Sizeof() +
 			Reply.Sizeof() +
 			Sizeof(Label) +
 			// Sizeof(InternetHeader) +
 			Sizeof(MessageID) +
 			Sizeof(References) +
 			Sizeof(FwdMsgId) +
 			Sizeof(BounceMsgId) +
 			Sizeof(ServerUid) +
 			sizeof(DateReceived) +
 			sizeof(DateSent);
 }
 
 bool LMail3Mail::DbDelete()
 {
 	return Store->DeleteMailById(Id);
 }
 
 LDataStoreI *LMail3Mail::GetStore()
 {
 	return Store;
 }
 
 LAutoStreamI LMail3Mail::GetStream(const char *file, int line)
 {
 	LAutoStreamI Ret;
 	const char *TmpPath = Store->GetStr(FIELD_TEMP_PATH);
 	
 	if (Flags & MAIL_STORED_FLAT)
 	{
 		// Construct from the single segment...
 		LString Sql;
 		Sql.Printf("select * from '%s' where MailId=" LPrintfInt64, MAIL3_TBL_MAILSEGS, Id);
 		LMail3Store::LStatement s(Store, Sql);
 		if (s.Row())
 		{
 			LStreamConcat *Sc;
 			int64 SegId = s.GetInt64(0);
 			char *Hdr	= s.GetStr(3);
 			
 			if (Hdr && Ret.Reset(Sc = new LStreamConcat))
 			{
 				size_t HdrLen	= strlen(Hdr);
 				int BlobSize	= s.GetSize(4);
 
 				Sc->Add(new LMemStream(Hdr, HdrLen));
 				Sc->Add(new LMemStream("\r\n\r\n", 4));
 				Sc->Add(new Mail3BlobStream(Store, (int)SegId, BlobSize, file, line));
 				
 				LFile f;
 				if (f.Open("c:\\temp\\email.eml", O_WRITE))
 				{
 					LCopyStreamer Cp(64<<10);
 					Cp.Copy(Sc, &f);
 					f.Close();
 					
 					Sc->SetPos(0);
 				}
 			}
 		}
 	}
 	else if (Ret.Reset(new LTempStream(TmpPath)))
 	{
 		// Encode from multiple segments...
 		LoadSegs();
 		if (Seg)
 		{
 			LMime Mime(TmpPath);
 			if (Store3ToLMime(&Mime, Seg))
 			{
 				if (!Mime.Text.Encode.Push(Ret))
 				{
 					LgiTrace("%s:%i - Mime encode failed.\n", _FL);
 					Ret.Reset();					
 				}
 			}
 			else
 			{
 				LgiTrace("%s:%i - Store3ToGMime failed.\n", _FL);
 				Ret.Reset();
 			}
 		}
 		else
 		{
 			LgiTrace("%s:%i - No segment to encode.\n", _FL);
 			Ret.Reset();
 		}
 	}
 	
 	return Ret;
 }
 
 bool LMail3Mail::SetStream(LAutoStreamI stream)
 {
 	if (!stream)
 		return false;
 
 	DeleteObj(Seg);
 
 	// MIME parse the stream and store it to segments.
 	LMime Mime;
 	if (Mime.Text.Decode.Pull(stream))
 	{
 		Seg = new LMail3Attachment(Store);
 		if (Seg)
 		{
 			// This stops the objects being written to disk.
 			// Which would mean we have multiple copies of the same
 			// data on disk. This setting also propagates down the
 			// tree automatically as GMimeToStore3 saves new child
 			// notes to their parents.
 			Seg->SetInMemoryOnly(true);
 			Seg->AttachTo(this);
 			
 			GMimeToStore3(Seg, &Mime);
 		}
 	}
 
 	return false;
 }
 
 bool LMail3Mail::FindSegs(const char *MimeType, LArray<LMail3Attachment*> &Results, bool Create)
 {
 	LoadSegs();
 	
 	if ((!Seg || !Seg->FindSegs(MimeType, Results)) && Create)
 	{
 		LMail3Attachment *a = new LMail3Attachment(Store);
 		if (!a)
 			return false;
 		a->SetStr(FIELD_MIME_TYPE, MimeType);
 
 		Store3MimeTree<LMail3Store, LMail3Mail, LMail3Attachment> Tree(this, Seg);
 		Tree.Add(a);
 		if (!Tree.Build())
 			return false;
 		
 		Results.Add(a);
 	}
 	
 	/* 
 	for (unsigned i=0; i<Results.Length(); i++)
 	{
 		LMail3Attachment *a = Results[i];
 		if (!a->GetStr(FIELD_MIME_TYPE))
 		{
 			// Ugh, a bug has caused a bunch of NULL mime-types..
 			a->SetStr(FIELD_MIME_TYPE, MimeType);
 		}
 	}
 	*/
 
 	return Results.Length() > 0;
 }
 
 LMail3Attachment *LMail3Mail::GetAttachment(int64 Id)
 {
 	return Seg ? Seg->Find(Id) : 0;
 }
 
 struct Pair
 {
 	int64 Parent;
 	LMail3Attachment *Seg;
 };
 
 int LMail3Mail::GetAttachments(LArray<LMail3Attachment*> *Lst)
 {
 	if (!Seg)
 		return -1;
 
 	int Count = 0;
 	if (Seg->IsMultipart())
 	{
 		LDataIt It = Seg->GetList(FIELD_MIME_SEG);
 		if (It)
 		{
 			for (LDataPropI *i=It->First(); i; i=It->Next())
 			{
 				const char *Mt = i->GetStr(FIELD_MIME_TYPE);
 				const char *Name = i->GetStr(FIELD_NAME);
 				if
 				(
 					(
 						Mt &&
 						_stricmp("text/plain", Mt) &&
 						_stricmp("text/html", Mt)
 					)
 					||
 					ValidStr(Name)
 				)
 				{
 					Count++;
 					if (Lst)
 					{
 						LMail3Attachment *a = dynamic_cast<LMail3Attachment*>(i);
 						if (a)
 							Lst->Add(a);
 					}
 				}
 			}
 		}
 	}
 
 	return Count;
 }
 
 void LMail3Mail::LoadSegs()
 {
 	if (Id > 0 && !Seg)
 	{
 		if (Flags & MAIL_STORED_FLAT)
 		{
 			// Decompression flat MIME storage to tree
 			
 			// GetStream will do the hard work of joining the message back
 			// into RFC822 format.
 			LAutoStreamI Rfc822 = GetStream(_FL);
 			if (!Rfc822)
 				return;
 
 			// Then we MIME parse it and store it to segments.
 			SetStream(Rfc822);
 		}
 		else
 		{
 			LArray<Pair> Others;
 
 			char Sql[256];
 			sprintf_s(Sql, sizeof(Sql), "select * from '%s' where MailId=" LPrintfInt64, MAIL3_TBL_MAILSEGS, Id);
 			LMail3Store::LStatement s(Store, Sql);
 			while (s.Row())
 			{
 				Pair p;
 				p.Seg = new LMail3Attachment(Store);
 				if (p.Seg->Load(s, p.Parent))
 				{
 					if (p.Parent <= 0)
 					{
 						if (Seg)
 						{
 							// hmmm, this shouldn't happen
 							p.Seg->AttachTo(Seg);
 						}
 						else
 						{
 							p.Seg->AttachTo(this);
 						}
+
+						#ifdef _DEBUG
+						// This was a hack to fix a dumb bug in a dev build... so so dumb.
+						if (p.Seg->GetDirty())
+						{
+							LArray<LDataI*> items{this};
+							Store->OnChange(_FL, items, FIELD_MIME_SEG);
+						}
+						#endif
 					}
 					else
 					{
 						Others.Add(p);
 					}
 				}
 			}
 
 			while (Seg && Others.Length())
 			{
 				ssize_t StartSize = Others.Length();
 
 				for (unsigned i=0; i<Others.Length(); i++)
 				{
 					LMail3Attachment *p = Seg->Find(Others[i].Parent);
 					if (p)
 					{
 						Others[i].Seg->AttachTo(p);
 						Others.DeleteAt(i--);
 					}
 				}
 
 				if (StartSize == Others.Length())
 				{
 					// No segments could be attached? Must have borked up parent id's
 					while (Others.Length())
 					{
 						// Just attach them somewhere... anywhere...!
 						if (Seg)
 							Others[0].Seg->AttachTo(Seg);
 						else
 							Others[0].Seg->AttachTo(this);
 						Others.DeleteAt(0);
 					}
 				}
 			}
 
 			if (Seg)
 			{
 				int Attached = GetAttachments();
 				int NewFlags;
 				if (Attached > 0)
 					NewFlags = Flags | MAIL_ATTACHMENTS;
 				else
 					NewFlags = Flags & ~MAIL_ATTACHMENTS;
 				if (NewFlags != Flags)
 				{
 					Flags = NewFlags;
 					Save();
 				}
 			}
 		}
 	}
 }
 
 static auto DefaultCharset = "windows-1252";
 			
 const char *LMail3Mail::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_DEBUG:
 		{
 			static char s[64];
 			sprintf_s(s, sizeof(s), "Mail3.Id=" LPrintfInt64, Id);
 			return s;
 		}
 		case FIELD_SUBJECT:
 		{
 			if (!LIsUtf8(Subject.Str()))
 			{
 				auto cs = DetectCharset(Subject.Str());
 				LAutoString conv;
 				if (conv.Reset((char*)LNewConvertCp("utf-8", Subject.Str(), cs ? cs.Get() : DefaultCharset)))
 					Subject = conv;
 			}
 
 			#if 0
 			int32 ch;
 			LgiTrace("Subj:");
 			for (LUtf8Ptr p(Subject.Str()); ch = p; p++)
 				LgiTrace(" u+%x", ch);
 			LgiTrace("\n");
 			#endif
 
 			return Subject.Str();
 		}
 		case FIELD_CHARSET:
 		{
 			return "utf-8";
 		}
 		case FIELD_TEXT:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (!TextCache && FindSegs("text/plain", Results))
 			{
 				LStringPipe p;
 				for (auto seg: Results)
 				{
 					if (seg->GetStr(FIELD_NAME))
 						continue;
 
 					auto s = seg->GetStream(_FL);
 					if (!s)
 						continue;
 
 					LString Charset = seg->GetStr(FIELD_CHARSET);
 
 					LAutoString Buf;
 					auto Size = s->GetSize();
 					if (Size <= 0)
 						continue;
 
 					Buf.Reset(new char[Size+1]);
 					s->Read(&Buf[0], Size);
 					Buf[Size] = 0;
 
 					if (!Charset)
 						Charset = DetectCharset(Buf.Get());
 					if (!Charset)
 						Charset = DefaultCharset;
 
 					LAutoString Utf8;
 					if (!Stricmp(Charset.Get(), "utf-8") && LIsUtf8(Buf))
 						Utf8 = Buf;
 					else
 						Utf8.Reset((char*)LNewConvertCp("utf-8", Buf, Charset, Size));
 
 					if (Results.Length() > 1)
 					{
 						if (p.GetSize())
 							p.Print("\n---------------------------------------------\n");
 						p.Push(Utf8);
 					}
 					else
 					{
 						TextCache = Utf8;
 						return TextCache;
 					}
 				}
 
 				TextCache.Reset(p.NewStr());
 			}
 			return TextCache;
 		}
 		case FIELD_HTML_CHARSET:
 		{
 			return "utf-8";
 		}
 		case FIELD_ALTERNATE_HTML:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (!HtmlCache && FindSegs("text/html", Results))
 			{
 				LMemQueue Blocks(1024);
 				int64 Total = 0;
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						LAutoStreamI s = Results[i]->GetStream(_FL);
 						if (s)
 						{
 							int64 Size = s->GetSize();
 							if (Size > 0)
 							{
 								auto Charset = Results[i]->GetStr(FIELD_CHARSET);
 							
 								char *Buf = new char[(size_t)Size+1];
 								ssize_t Rd = s->Read(Buf, (int)Size);
 								if (Rd > 0)
 								{
 									Buf[Rd] = 0;
 									
 									if (Charset && _stricmp("utf-8", Charset) != 0)
 									{
 										char *Tmp = (char*)LNewConvertCp("utf-8", Buf, Charset, (int)Size);
 										if (Tmp)
 										{
 											DeleteArray(Buf);
 											Buf = Tmp;
 											Size = strlen(Tmp);
 										}
 									}
 									
 									Blocks.Write(Buf, (int)Size);
 									Total += Size;
 									DeleteArray(Buf);
 								}
 							}
 						}
 					}
 				}
 				
 				HtmlCache.Reset((char*)Blocks.New(1));				
 			}
 			return HtmlCache;
 		}
 
 		case FIELD_LABEL:
 			return Label.Str();
 		case FIELD_INTERNET_HEADER:
 		{
 			auto Root = GetObj(FIELD_MIME_SEG);
 			if (Root)
 				return Root->GetStr(id);
 			else
 				return NULL;
 		}
 		case FIELD_REFERENCES:
 			return References.Str();
 		case FIELD_FWD_MSG_ID:
 			return FwdMsgId.Str();
 		case FIELD_BOUNCE_MSG_ID:
 			return BounceMsgId.Str();
 		case FIELD_SERVER_UID:
 			return ServerUid.Str();
 		case FIELD_MESSAGE_ID:
 		{
 			if (!MessageID.Str())
 			{
 				LAutoString Header(InetGetHeaderField(GetStr(FIELD_INTERNET_HEADER), "Message-ID"));
 				if (Header)
 				{
 					auto Ids = ParseIdList(Header);
 					MessageID = Ids[0];
 				}
 			}
 			return MessageID.Str();
 		}
 		case FIELD_UID:
 		{
 			IdCache.Printf(LPrintfInt64, Id);
 			return IdCache;
 		}
+		case FIELD_ERROR:
+			return ErrMsg;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 void LMail3Mail::OnSave()
 {
 	if (Seg)
 	{
 		LDataStoreI::StoreTrans Trans = Store->StartTransaction();
 		Seg->OnSave();
 	}
 }
 
 void LMail3Mail::ParseAddresses(char *Str, int CC)
 {
 	List<char> Addr;
 	TokeniseStrList(Str, Addr, ",");
 	
 	for (auto RawAddr: Addr)
 	{
 		LAutoPtr<LDataPropI> a(To.Create(Store));
 		if (a)
 		{
 			Store3Addr *sa = dynamic_cast<Store3Addr*>(a.Get());
 			LAssert(sa != NULL);
 			if (sa)
 			{
 				DecodeAddrName(RawAddr, sa->Name, sa->Addr, 0);
 				sa->CC = CC;
 				To.Insert(a.Release());
 			}
 		}
 	}
 	Addr.DeleteArrays();
 }
 
 void LMail3Mail::ResetCaches()
 {
 	TextCache.Reset();
 	HtmlCache.Reset();
 	SizeCache.Reset();
 }
 
 const char *LMail3Mail::InferCharset()
 {
 	if (!InferredCharset)
 	{
 		// Sometimes mailers don't follow the rules... *cough*outlook*cough*
 		// So lets play the "guess the charset" game...
 	
 		// Maybe one of the segments has a charset?
 		InferredCharset = Seg->GetStr(FIELD_CHARSET);		
 		if (!InferredCharset)
 		{
 			// What about 'Content-Language'?
 			auto InetHdrs = GetStr(FIELD_INTERNET_HEADER);
 			if (InetHdrs)
 			{
 				LAutoString ContentLang(InetGetHeaderField(InetHdrs, "Content-Language"));
 				if (ContentLang)
 				{
 					LLanguage *Lang = LFindLang(ContentLang);
 					if (Lang)
 						InferredCharset = Lang->Charset;
 				}
 			}
 		}
 	}
 		
 	return InferredCharset;
 }
 
 bool LMail3Mail::Utf8Check(LAutoString &v)
 {
 	if (!LIsUtf8(v.Get()))
 	{
 		const char *Cs = InferCharset();
 		if (Cs)
 		{
 			LAutoString Value((char*) LNewConvertCp("utf-8", v, Cs, -1));
 			if (Value)
 			{
 				v = Value;
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 bool LMail3Mail::Utf8Check(LVariant &v)
 {
 	if (!LIsUtf8(v.Str()))
 	{
 		const char *Cs = InferCharset();
 		if (Cs)
 		{
 			LAutoString Value((char*) LNewConvertCp("utf-8", v.Str(), Cs, -1));
 			if (Value)
 			{
 				v.OwnStr(Value.Release());
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 bool LMail3Mail::ParseHeaders()
 {
 	// Reload from headers...
 	auto InetHdrs = GetStr(FIELD_INTERNET_HEADER);
 	Subject.OwnStr(DecodeRfc2047(InetGetHeaderField(InetHdrs, "subject")));
 	Utf8Check(Subject);
 
 	// From
 	LAutoString s(DecodeRfc2047(InetGetHeaderField(InetHdrs, "from")));
 	Utf8Check(s);
 	From.Empty();
 	DecodeAddrName(s, From.Name, From.Addr, NULL);
 
 	s.Reset(DecodeRfc2047(InetGetHeaderField(InetHdrs, "reply-to")));
 	Utf8Check(s);
 	Reply.Empty();
 	DecodeAddrName(s, Reply.Name, Reply.Addr, NULL);
 
 	// Parse To and CC headers.
 	To.DeleteObjects();
 	if (s.Reset(DecodeRfc2047(InetGetHeaderField(InetHdrs, "to"))))
 	{
 		Utf8Check(s);
 		ParseAddresses(s, MAIL_ADDR_TO);
 	}
 	if (s.Reset(DecodeRfc2047(InetGetHeaderField(InetHdrs, "cc"))))
 	{
 		Utf8Check(s);
 		ParseAddresses(s, MAIL_ADDR_CC);
 	}
 
 	// Data
 	if (s.Reset(InetGetHeaderField(InetHdrs, "date")))
 	{
 	    DateSent.Decode(s);
 		DateSent.ToUtc();
 	}
 				
 	DeleteObj(Seg);
 	ResetCaches();
 	
 	return true;
 }
 
 Store3Status LMail3Mail::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_SUBJECT:
 			Subject = str;
 			break;
 
 		case FIELD_TEXT:
 		{
 			TextCache.Reset();
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/plain", Results, str != 0))
 			{
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 					    LAutoStreamI s(str ? new LMemStream((char*)str, strlen(str)) : 0);
 						Results[i]->SetStream(s);
 						break;
 					}
 				}
 			}
 			break;
 		}
 		case FIELD_CHARSET:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/plain", Results, str != 0))
 			{
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						Results[i]->SetStr(FIELD_CHARSET, str);
 						break;
 					}
 				}
 			}
 			break;
 		}
 		case FIELD_ALTERNATE_HTML:
 		{
 			HtmlCache.Reset();
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/html", Results, str != 0))
 			{
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						if (str)
 						{
 							LAutoStreamI tmp(new LMemStream((char*)str, strlen(str)));
 							Results[i]->SetStream(tmp);
 						}
 						else
 						{
 							auto s = Results[i];
 							s->Delete();
 							delete s;
 						}
 						break;
 					}
 				}
 			}
 			break;
 		}
 		case FIELD_HTML_CHARSET:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/html", Results, str != 0))
 			{
 				const char *Charset = str && *str == '>' ? str + 1 : str;
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						if (Results[i]->SetStr(FIELD_CHARSET, Charset))
 							return Store3Success;
 						break;
 					}
 				}
 			}
 
 			return Store3Error;
 		}
 
 		case FIELD_LABEL:
 			Label = str;
 			break;
 		case FIELD_INTERNET_HEADER:
 		{
 			LoadSegs();
 			
 			if (!ValidStr(str))
 				// There is no point continuing as it will just attach an empty
 				// attachment which eventually asserts in the save code.
 				//		e.g. LMail3Attachment::GetHeaders()
 				break;
 
 			if (!Seg)
 			{
 				// This happens when the user re-sends an email and it creates
 				// a new empty email to copy the old sent email into.
 				LMail3Attachment *a = new LMail3Attachment(Store);
 				if (!a)
 				{
 					LAssert(0);
 					return Store3Error;
 				}
 				
 				a->AttachTo(this);
 			}
 			
 			Seg->SetStr(id, str);
 			break;
 		}
 		case FIELD_MESSAGE_ID:
 			MessageID = str;
 			break;
 		case FIELD_REFERENCES:
 			References = str;
 			break;
 		case FIELD_FWD_MSG_ID:
 			FwdMsgId = str;
 			break;
 		case FIELD_BOUNCE_MSG_ID:
 			BounceMsgId = str;
 			break;
 		case FIELD_SERVER_UID:
 			ServerUid = str;
 			break;
 
 		default:
 			LAssert(0);
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 int64 LMail3Mail::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_STORE_TYPE:
 			return Store3Sqlite;
 		case FIELD_SIZE:
 			return Size();
 		case FIELD_LOADED:
 			return Store3Loaded;
 		case FIELD_PRIORITY:
 			return Priority;
 		case FIELD_FLAGS:
 			return Flags;
 		case FIELD_DONT_SHOW_PREVIEW:
 			return false;
 		case FIELD_ACCOUNT_ID:
 			return AccountId;
 		case FIELD_COLOUR:
 			return (uint64_t)MarkColour;
 		case FIELD_SERVER_UID:
 			return -1;
 	}
 
 	LAssert(0);
 	return -1;
 }
 
 Store3Status LMail3Mail::SetInt(int id, int64 i)
 {
 	switch (id)
 	{
 		case FIELD_LOADED:
 			return Store3Success;
 		case FIELD_PRIORITY:
 			Priority = (int)i;
 			return Store3Success;
 		case FIELD_FLAGS:
 			Flags = (int)i;
 			return Store3Success;
 		case FIELD_ACCOUNT_ID:
 			AccountId = (int)i;
 			return Store3Success;
 		case FIELD_COLOUR:
 			if (i < 0)
 				MarkColour = Rgba32(0, 0, 0, 0); // transparent
 			else
 				MarkColour = (uint32_t)i;
 			return Store3Success;
 	}
 
 	LAssert(0);
 	return Store3NotImpl;
 }
 
 const LDateTime *LMail3Mail::GetDate(int id)
 {
 	switch (id)
 	{
 		case FIELD_DATE_RECEIVED:
 			return &DateReceived;
 		case FIELD_DATE_SENT:
 			return &DateSent;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 Store3Status LMail3Mail::SetDate(int id, const LDateTime *t)
 {
 	switch (id)
 	{
 		case FIELD_DATE_RECEIVED:
 			if (t)
 				DateReceived = *t;
 			else
 				DateReceived.Year(0);
 			return Store3Success;
 		case FIELD_DATE_SENT:
 			if (t)
 				DateSent = *t;
 			else
 				DateSent.Year(0);
 			return Store3Success;
 	}
 
 	LAssert(0);
 	return Store3NotImpl;
 }
 
 LDataPropI *LMail3Mail::GetObj(int id)
 {
 	switch (id)
 	{
 		case FIELD_FROM:
 			return &From;
 		case FIELD_REPLY:
 			return &Reply;
 		case FIELD_MIME_SEG:
 		{
 			LoadSegs();
 
 			/* This causes replies to have the wrong format for "text/plain"
 			if (!Seg)
 			{
 				LMail3Attachment *a = new LMail3Attachment(Store);
 				if (a)
 				{
 					a->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 					a->AttachTo(this);
 				}
 			}
 			*/
 
 			return Seg;
 		}
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 Store3Status LMail3Mail::SetObj(int id, LDataPropI *i)
 {
 	switch (id)
 	{
 		case FIELD_MIME_SEG:
 		{
 			if (Seg)
 			{
 				Seg->SetMail(NULL);
 				Seg = NULL;
 			}
 			
 			LMail3Attachment *a = dynamic_cast<LMail3Attachment*>(i);
 			if (!a)
 			{
 				LAssert(!"Incorrect object...");
 				return Store3Error;
 			}
 			
 			Seg = a;
 			Seg->SetMail(this);
 			break;
 		}
 		case FIELD_HTML_RELATED:
 		{
 			LMail3Attachment *a = i ? dynamic_cast<LMail3Attachment*>(i) : NULL;
 			
 			LoadSegs();
 			if (Seg)
 			{
 				Store3MimeTree<LMail3Store, LMail3Mail, LMail3Attachment> Tree(this, Seg);
 				
 				if (a)
 					Tree.MsgHtmlRelated.Add(a);
 				else
 					Tree.MsgHtmlRelated.Empty();
 				
 				if (!Tree.Build())
 					return Store3Error;
 					
 				MailSize = -1;
 				Seg->Save(this);
 			}
 			break;
 		}
 		default:
 			LAssert(0);
 			return Store3NotImpl;
 	}
 	
 	return Store3Success;
 }
 
 LDataIt LMail3Mail::GetList(int id)
 {
 	switch (id)
 	{
 		case FIELD_TO:
 			return &To;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 class LSubStream : public LStreamI
 {
 	// The source stream to read from
 	LStreamI *s;
 	
 	// The start position in the source stream
 	int64 Start;
 	
 	// The length of the sub-stream
 	int64 Len;
 	
 	// The current position in the sub-stream
 	// (relative to the start of the sub-stream, not the parent stream)
 	int64 Pos;
 
 public:
 	LSubStream(LStreamI *stream, int64 start = 0, int64 len = -1)
 	{
 		s = stream;
 		Pos = 0;
 		Start = MAX(0, start);
 		
 		int64 MaxLen = s->GetSize() - Start;
 		if (MaxLen < 0)
 			MaxLen = 0;
 		Len = len < 0 && s ? MaxLen : MIN(MaxLen, len); 
 	}
 
 	bool IsOpen() { return true; }
 	int Close()
 	{
 		s = NULL;
 		Start = Len = Pos = 0;
 		return true;
 	}
 	
 	int64 GetSize()
 	{
 		return s ? Len : -1;
 	}
 	
 	int64 SetSize(int64 Size)
 	{
 		// Can't set size
 		return GetSize();
 	}
 
 	int64 GetPos()
 	{
 		return s ? Pos : -1;
 	}
 	
 	int64 SetPos(int64 p)
 	{
 		if (p < 0) p = 0;
 		if (p >= Len) p = Len;
 		return Pos = p;
 	}
 	
 	ssize_t Read(void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		ssize_t r = 0;
 		if (s && Buffer)
 		{
 			int64 Remaining = Len - Pos;
 			ssize_t Common = MIN(Size, (int)Remaining);
 			
 			int64 SrcPos = Start + Pos;
 			int64 ActualPos = s->SetPos(SrcPos);
 			if (ActualPos == SrcPos)
 			{			
 				r = s->Read(Buffer, Common, Flags);
 				if (r > 0)
 				{
 					Pos += r;
 				}
 			}
 			else LAssert(0);
 		}
 		return r;
 	}
 	
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		LAssert(!"Not implemented.");
 		return 0;
 	}
 	
 	LStreamI *Clone() { return new LSubStream(s, Start, Len); }
 };
 
 Store3Status LMail3Mail::SetRfc822(LStreamI *m)
 {
 	Store3Status Status = Store3Error;
 
-	if (m)
+	if (!m)
 	{
-		// Save all the segments out
-		LDataStoreI::StoreTrans Trans = Store->StartTransaction();
+		ErrMsg = "No input stream.";
+		return Status;
+	}
 
-		if (Id < 0)
-		{
-			// Must commit ourselves now and get an Id
-			if (!Write(MAIL3_TBL_MAIL, true))
-				return Store3Error;
-		}
-		else
+	// Save all the segments out
+	LDataStoreI::StoreTrans Trans = Store->StartTransaction();
+
+	if (Id < 0)
+	{
+		// Must commit ourselves now and get an Id
+		if (!Write(MAIL3_TBL_MAIL, true))
 		{
-			char s[256];
-			sprintf_s(s, sizeof(s), "delete from %s where MailId=" LPrintfInt64, MAIL3_TBL_MAILSEGS, Id);
-			LMail3Store::LStatement Del(Store, s);
-			if (!Del.Exec())
-				return Store3Error;
+			ErrMsg = "Write to MAIL3_TBL_MAIL failed.";
+			return Store3Error;
 		}
-
-		DeleteObj(Seg);
+	}
+	else
+	{
+		char s[256];
+		sprintf_s(s, sizeof(s), "delete from %s where MailId=" LPrintfInt64, MAIL3_TBL_MAILSEGS, Id);
+		LMail3Store::LStatement Del(Store, s);
+		if (!Del.Exec())
+		{
+			ErrMsg = "Delete query failed.";
+			return Store3Error;
+		}
+	}
 
-		/*
-		Normally the message is parsed into MIME segments and stored parsed and decoded into 
-		the MailSegs table. If the message is encrypted or signed that could the client can't
-		verify the message later because the specifics of MIME encoding varies between clients.
-		
-		So if the message is:
-		
-			Signed and/or Encrypted:	There is only one MAILSEG record with all the headers of the 
-										root MIME segment, and the body stream has all the data of
-										the RFC822 image.
-			
-			Otherwise:					Normal MIME parsing is done, storing the message in different
-										MAILSEG records. Which was the previous behaviour.
+	DeleteObj(Seg);
 
-		First the headers of the root MIME node are read to see what the Content-Type is.
-		Then a decision about how to store the node is made.
-		*/
-		LString Hdrs = HeadersFromStream(m);
-		LAutoString Type(InetGetHeaderField(Hdrs, "Content-Type"));
+	/*
+	Normally the message is parsed into MIME segments and stored parsed and decoded into 
+	the MailSegs table. If the message is encrypted or signed that could the client can't
+	verify the message later because the specifics of MIME encoding varies between clients.
+		
+	So if the message is:
+		
+		Signed and/or Encrypted:	There is only one MAILSEG record with all the headers of the 
+									root MIME segment, and the body stream has all the data of
+									the RFC822 image.
+			
+		Otherwise:					Normal MIME parsing is done, storing the message in different
+									MAILSEG records. Which was the previous behaviour.
 
-		Flags &= ~MAIL_STORED_FLAT;
-		if (Type)
+	First the headers of the root MIME node are read to see what the Content-Type is.
+	Then a decision about how to store the node is made.
+	*/
+	LString Hdrs = HeadersFromStream(m);
+	LAutoString Type(InetGetHeaderField(Hdrs, "Content-Type"));
+
+	Flags &= ~MAIL_STORED_FLAT;
+	if (Type)
+	{
+		LString s = Type.Get();
+		ptrdiff_t Colon = s.Find(";");
+		if (Colon > 0)
+			s.Length((uint32_t)Colon);
+		s = s.Strip().Lower();
+		if (s == sMultipartEncrypted ||
+			s == sMultipartSigned)
 		{
-			LString s = Type.Get();
-			ptrdiff_t Colon = s.Find(";");
-			if (Colon > 0)
-				s.Length((uint32_t)Colon);
-			s = s.Strip().Lower();
-			if (s == sMultipartEncrypted ||
-				s == sMultipartSigned)
-			{
-				Flags |= MAIL_STORED_FLAT;
-			}
+			Flags |= MAIL_STORED_FLAT;
 		}
+	}
 
-		LMail3Store::LInsert Ins(Store, MAIL3_TBL_MAILSEGS);
-		MailSize = 0;
+	LMail3Store::LInsert Ins(Store, MAIL3_TBL_MAILSEGS);
+	MailSize = 0;
 
-		LMime Mime;
-		if (Flags & MAIL_STORED_FLAT)
-		{
-			// Don't parse MIME into a tree.
-			Mime.SetHeaders(Hdrs);
-			Mime.SetData(true, new LSubStream(m, Hdrs.Length()+4));
-			if (Mail3_InsertSeg(Ins, &Mime, Id, -1, MailSize))
-				Status = Store3Success;
-		}
+	LMime Mime;
+	if (Flags & MAIL_STORED_FLAT)
+	{
+		// Don't parse MIME into a tree.
+		Mime.SetHeaders(Hdrs);
+		Mime.SetData(true, new LSubStream(m, Hdrs.Length()+4));
+		if (Mail3_InsertSeg(Ins, &Mime, Id, -1, MailSize))
+			Status = Store3Success;
 		else
-		{
-			// Do normal parsing in to MIME tree.
-			if (Mime.Text.Decode.Pull(m) &&
-				Mail3_InsertSeg(Ins, &Mime, Id, -1, MailSize))
-				Status = Store3Success;
-		}
+			ErrMsg = "Flat insert query failed.";
+	}
+	else
+	{
+		// Do normal parsing in to MIME tree.
+		if (Mime.Text.Decode.Pull(m) &&
+			Mail3_InsertSeg(Ins, &Mime, Id, -1, MailSize))
+			Status = Store3Success;
+		else
+			ErrMsg = "Regular insert query failed.";
 	}
 
 	return Status;
 }
diff --git a/src/Store3Mail3/Mail3Store.cpp b/src/Store3Mail3/Mail3Store.cpp
--- a/src/Store3Mail3/Mail3Store.cpp
+++ b/src/Store3Mail3/Mail3Store.cpp
@@ -1,2231 +1,2231 @@
 #include "Mail3.h"
 #include "resdefs.h"
 #include "lgi/common/SubProcess.h"
 #include <wchar.h>
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Thread.h"
 #include "lgi/common/Store3MimeTree.h"
 
 #define SanityCheck() if (!IsOk()) return NULL;
 
 ///////////////////////////////////////////////////////////////////////////////////
 LMail3Thing::~LMail3Thing()
 {
 	if (Parent)
 		Parent->Items.a.Delete(this);
 }
 
 Store3Status LMail3Thing::Delete(bool ToTrash)
 {
 	LArray<LDataI*> Del;
 	Del.Add(this);
 	return Store->Delete(Del, ToTrash);
 }
 
 Store3Status LMail3Thing::Save(LDataI *Folder)
 {
 	LMail3Folder *Fld = dynamic_cast<LMail3Folder*>(Folder);
 	if (Folder && !Fld)
 	{
 		LAssert(!"Not the right folder type");
 		LgiTrace("%s:%i - Not the right folder type.\n", _FL);
 		return Store3Error;
 	}
 	
 	if (Fld && Fld->Store != Store)
 	{
 		SetStore(Fld->Store);
 	}
 	
 	const char *Table = GetTable();
 	bool Create = false;
 	bool IsNewMail = Type() == MAGIC_MAIL && TestFlag(GetInt(FIELD_FLAGS), MAIL_NEW);
 	LArray<LDataI*> NewItems;
 
 	if (Id < 0)
 	{
 		if (Fld)
 		{
 			// Make sure the folder is loaded...
 			Fld->Children();
 
 			Parent = Fld;
 			ParentId = Fld->Id;
 			LAssert(Parent->Items.IndexOf(this, true) < 0);
 			
 			// LgiTrace("%s:%i - Saving %i to %s (%i items)\n", _FL, (int)Id, Parent->GetStr(FIELD_FOLDER_NAME), Parent->Items.Length());
 			Parent->Items.Insert(this, -1, true);
 			
 			Create = true;
 
 			NewItems.Add(this);
 
 			if (IsNewMail)
 				SetInt(FIELD_FLAGS, GetInt(FIELD_FLAGS) & ~MAIL_NEW);
 		}
 		else
 		{
 			LAssert(!"No parent to save to.");
 			LgiTrace("%s:%i - No parent to save to.\n", _FL);
 			return Store3Error;
 		}
 	}
 	else if (Fld)
 	{
 		// Make sure the folder is loaded...
 		Fld->Children();
 
 		ParentId = Fld->Id;
 		if (Parent != Fld)
 		{
 			LDataFolderI *Old = Parent;
 			if (Parent)
 			{
 				// Remove this item from the current parent folder...
 				LAssert(Parent->Items.IndexOf(this) >= 0);
 				Parent->Items.Delete(this);
 			}
 			
 			// Add it to the new one...
 			Parent = Fld;
 			LAssert(Parent->Items.IndexOf(this, true) < 0);
 
 // LgiTrace("%s:%i - Saving %i to %s (%i items)\n", _FL, (int)Id, Parent->GetStr(FIELD_FOLDER_NAME), Parent->Items.Length());
 			Parent->Items.Insert(this, -1, true);
 
 			LArray<LDataI*> a;
 			a.Add(this);
 			if (Old)
 				Store->OnMove(_FL, Parent, Old, a);
 			else
 				NewItems.Add(this);
 
 			if (IsNewMail)
 				SetInt(FIELD_FLAGS, GetInt(FIELD_FLAGS) & ~MAIL_NEW);
 		}
 	}
 	
 	bool Status = Write(Table, Create);
 	if (Status)
 	{
 		OnSave();
 		if (NewItems.Length())
 			Store->OnNew(_FL, Parent, NewItems, -1, IsNewMail);
 	}
 	else
 	{
 		LgiTrace("%s:%i - Write failed.\n", _FL);
 	}
 
 	return Status ? Store3Success : Store3Error;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
 GMail3Idx Mail3Indexes[] =
 {
 	{"MailFolderIdx", MAIL3_TBL_MAIL, "ParentId"},
 	{"MailSegMailIdx", MAIL3_TBL_MAILSEGS, "MailId"},
 	{"MailSegParentIdx", MAIL3_TBL_MAILSEGS, "ParentId"},
 };
 
 LMail3Store::LMail3Store(const char *Mail3Folder, LDataEventsI *callback, bool Create) :
 	TableStatus(0, Store3Error)
 {
 	Format = Mail3v1;
 	Folder = Mail3Folder;
 	Callback = callback;
 	Db = 0;
 	Transaction = 0;
 	Root = 0;
 	OpenStatus = Store3Success;
 	Fields.Add(MAIL3_TBL_FOLDER, TblFolder);
 	Fields.Add(MAIL3_TBL_FOLDER_FLDS, TblFolderFlds);
 	Fields.Add(MAIL3_TBL_MAIL, TblMail);
 	Fields.Add(MAIL3_TBL_MAILSEGS, TblMailSegs);
 	Fields.Add(MAIL3_TBL_CONTACT, TblContact);
 	Fields.Add(MAIL3_TBL_GROUP, TblGroup);
 	Fields.Add(MAIL3_TBL_FILTER, TblFilter);
 	Fields.Add(MAIL3_TBL_CALENDAR, TblCalendar);
 
 	bool Exist = LDirExists(Mail3Folder);
 	if (!Create && !Exist)
 	{
 		ErrorMsg.Printf(LLoadString(IDS_ERROR_FILE_DOESNT_EXIST), Mail3Folder);
 	}
 	else if (!Exist && !FileDev->CreateFolder(Mail3Folder))
 	{
 		ErrorMsg.Printf(LLoadString(IDS_ERROR_CANT_CREATE_FOLDER), Mail3Folder);
 	}
 	else
 	{
 		OpenDb();
 	}
 
 	#if _DEBUG
 	LMail3Mail m(this);
 	Store3MimeTree<LMail3Store, LMail3Mail, LMail3Attachment> Tree(&m, m.Seg);
 	if (!Tree.UnitTests(this, &m))
 	{
 		LgiTrace("%s:%i - Error: Store3MimeTree unit tests failed\n", _FL);
 		LAssert(!"Store3MimeTree unit tests failed.\n");
 	}
 	#endif
 }
 
 LMail3Store::~LMail3Store()
 {
 	CloseDb();
 	DeleteObj(Root);
 }
 
 LMail3Folder *LMail3Store::GetSystemFolder(int Type)
 {
 	if (!Callback || !Root)
 		return NULL;
 
 	LVariant Path;
 	if (Callback->GetSystemPath(FOLDER_INBOX, Path))
 	{
 		auto p = LString(Path.Str()).Split("/");
 		for (auto f: Root->Sub.a)
 		{
 			auto Nm = f->GetStr(FIELD_FOLDER_NAME);
 			if (p.Last().Equals(Nm))
 			{
 				return f;
 			}
 		}
 	}
 	
 	return NULL;
 }
 
 LDataPropI *LMail3Store::GetObj(int id)
 {
 	switch (id)
 	{
 		case FIELD_INBOX:
 			return GetSystemFolder(FOLDER_INBOX);
 		case FIELD_OUTBOX:
 			return GetSystemFolder(FOLDER_OUTBOX);
 		case FIELD_SENT:
 			return GetSystemFolder(FOLDER_SENT);
 		case FIELD_TRASH:
 			return GetSystemFolder(FOLDER_TRASH);
 	}
 	
 	return NULL;
 }
 
 bool LMail3Store::OpenDb()
 {
 	char f[MAX_PATH_LEN];
 	
 	StatusMsg.Empty();
 	
 	LMakePath(f, sizeof(f), Folder, MAIL3_DB_FILE);
 	DbFile = f;
 	if (!Check(sqlite3_open(f, &Db), 0))
 	{
 		ErrorMsg.Printf(LLoadString(IDS_ERROR_CANT_CREATE_DB), f);
 		return false;
 	}
 	else
 	{
 		// const char *Tbl;
 		// for (LMail3Def *Flds=Fields.First(&Tbl); Flds; Flds=Fields.Next(&Tbl))
 		for (auto it : Fields)
 		{
 			Store3Status s = CheckTable(it.key, it.value);
 			if (s == Store3Missing &&
 				UpdateTable(it.key, it.value, s))
 			{
 				s = Store3Success;
 			}
 
 			TableStatus.Add(it.key, s);
 			if (s == Store3Error ||
 				(s == Store3UpgradeRequired && OpenStatus != Store3Error))
 				OpenStatus = s;
 		}
 		
 		LArray<LAutoString> DelNames;
 		{
 			LStatement Tables(	this,
 								"SELECT name FROM sqlite_master "
 								"WHERE type='table' "
 								"ORDER BY name;");
 			while (Tables.Row())
 			{
 				char *Name = Tables.GetStr(0);
 				if (Name && strchr(Name, '_') && !stristr(Name, "sqlite"))
 					DelNames.New().Reset(NewStr(Name));
 			}
 		}
 		for (unsigned i=0; i<DelNames.Length(); i++)
 		{
 			char Sql[256];
 			sprintf_s(Sql, sizeof(Sql), "drop table %s", DelNames[i].Get());
 			LStatement Del(this, Sql);
 			if (!Del.Exec())
 			{
 				LAssert(!"Drop table failed.");
 				return false;
 			}
 		}
 
 		LDataStoreI::StoreTrans Trn = StartTransaction();
 		for (int i=0; i<CountOf(Mail3Indexes); i++)
 		{
 			sprintf_s(f, sizeof(f),
 					"create index if not exists %s on %s(%s)",
 					Mail3Indexes[i].IdxName,
 					Mail3Indexes[i].Table,
 					Mail3Indexes[i].Column);
 			LStatement s(this, f);
 			s.Exec();
 		}
 	}
 	
 	return true;
 }
 
 bool LMail3Store::CloseDb()
 {
 	DeleteObj(Transaction);
 	if (Db)
 	{
 		int r = sqlite3_close(Db);
 		if (r == SQLITE_BUSY)
 		{
 			sqlite3_stmt *n;
 			while ((n = sqlite3_next_stmt(Db, 0)))
 			{
 				LgiTrace("close n=%p\n", n);
 				sqlite3_finalize(n);
 			}
 			LAssert(!"Unfinalized statements");
 			Db = NULL;
 			return false;
 		}
 		else Check(r, 0);
 
 		Db = NULL;
 	}
 	
 	return true;
 }
 
 LMail3Store::Mail3Trans::Mail3Trans(LMail3Store *s, LMail3Store::Mail3Trans **ptr)
 	: LDataStoreI::LDsTransaction(s), Trans(s)
 {
 	Ptr = ptr;
 	*Ptr = this;
 }
 
 LMail3Store::Mail3Trans::~Mail3Trans()
 {
 	*Ptr = 0;
 }
 
 LDataStoreI::StoreTrans LMail3Store::StartTransaction()
 {
 	StoreTrans t;
 	if (!Transaction)
 	{
 		t.Reset(new Mail3Trans(this, &Transaction));
 	}
 	return t;
 }
 
 void LMail3Store::OnNew(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new)
 {
 	if (!Callback)
 		return;
 	Callback->SetContext(File, Line);
 	Callback->OnNew(parent, new_items, pos, is_new);
 }
 
 bool LMail3Store::OnChange(const char *File, int Line, LArray<LDataI*> &items, int FieldHint)
 {
 	if (!Callback)
 		return false;
 	Callback->SetContext(File, Line);
 	return Callback->OnChange(items, FieldHint);
 }
 
 bool LMail3Store::OnMove(const char *File, int Line, LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items)
 {
 	if (!Callback)
 		return false;
 	Callback->SetContext(File, Line);
 	return Callback->OnMove(new_parent, old_parent, items);
 }
 
 bool LMail3Store::OnDelete(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &items)
 {
 	if (!Callback)
 		return false;
 	Callback->SetContext(File, Line);
 	return Callback->OnDelete(parent, items);
 }
 
 const char *LMail3Store::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_NAME:
 			return DbFile;
 		case FIELD_ERROR:
 			return ErrorMsg;
 		case FIELD_STATUS:
 			return StatusMsg;
 		case FIELD_TEMP_PATH:
 			return TempPath;
 		case FIELD_STORE_TYPE:
 			return "LMail3Store";
 	}
 	
 	return NULL;
 }
 
 Store3Status LMail3Store::SetStr(int id, const char *s)
 {
 	switch (id)
 	{
 		case FIELD_ERROR:
 			ErrorMsg = s;
 			break;
 		case FIELD_STATUS:
 			StatusMsg = s;
 			break;
 		case FIELD_TEMP_PATH:
 			TempPath = s;
 			break;
 		default:
 			LAssert(0);
 			return Store3Error;
 	}
 	
 	return Store3Success;
 }
 
 int64 LMail3Store::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_STATUS:
 		{
 			if (OpenStatus != Store3Success)
 				return OpenStatus;
 
 			return IsOk() ? Store3Success : Store3Error;
 		}
 		case FIELD_READONLY:
 			return false;
 		case FIELD_VERSION:
 			return 3;
 		case FIELD_FORMAT:
 			return Format;
 		case FIELD_STORE_TYPE:
 			return Store3Sqlite;
 	}
 
 	return -1;
 }
 
 Store3Status LMail3Store::SetInt(int id, int64 i)
 {
 	switch (id)
 	{
 		case FIELD_FORMAT:
 			break;
 	}
 
 	return Store3Error;
 }
 
 bool LMail3Store::Check(int Code, const char *Sql)
 {
 	if (Code == SQLITE_OK ||
 		Code == SQLITE_DONE)
 		return true;
 
 	const char *Err = sqlite3_errmsg(Db);
 	LgiTrace("%s:%i - Sqlite error %i: %s\n%s",
 		_FL,
 		Code, Err,
 		Sql?Sql:(char*)"",
 		Sql?"\n":"");
 	LAssert(!"Db Error");
 
 	#if MAIL3_TRACK_OBJS
 	for (int i=0; i<All.Length(); i++)
 	{
 		SqliteObjs &s = All[i];
 		if (s.Stat)
 		{
 			int asd=0;
 		}
 		else if (s.Stream)
 		{
 			int asd=0;
 		}
 	}
 	#endif
 
 	return false;
 }
 
 uint64 LMail3Store::Size()
 {
 	return LFileSize(DbFile);
 }
 
 LDataI *LMail3Store::Create(int Type)
 {
 	switch ((uint32_t)Type)
 	{
 		case MAGIC_FOLDER:
 			return new LMail3Folder(this);
 		case MAGIC_MAIL:
 			return new LMail3Mail(this);
 		case MAGIC_FILTER:
 			return new LMail3Filter(this);
 		case MAGIC_CALENDAR:
 			return new LMail3Calendar(this);
 		case MAGIC_ATTACHMENT:
 			return new LMail3Attachment(this);
 
 		case MAGIC_CONTACT:
 			return new LMail3Contact(this);
 		case MAGIC_GROUP:
 			return new LMail3Group(this);
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 LDataFolderI *LMail3Store::GetRoot(bool create)
 {
 	SanityCheck()
 
 	if (!Root)
 	{
 		LStatement s(this, "select * from '" MAIL3_TBL_FOLDER "' where ParentId is null");
 		if (s.IsOk())
 		{
 			if (s.Row())
 			{
 				// Load existing root folder...
 				if ((Root = new LMail3Folder(this)))
 				{
 					Root->Items.State = Store3Loaded;
 					Root->Serialize(s, false);
 				}
 			}
 			else
 			{
 				// Create new root folder...
 				if ((Root = new LMail3Folder(this)))
 				{
 					Root->Items.State = Store3Loaded;
 					Root->Write(MAIL3_TBL_FOLDER, true);
 				}
 			}
 		}
 	}
 
 	return Root;
 }
 
 #define PROFILE_MOVE		0
 #if PROFILE_MOVE
 	#define PROF_MOVE(...)	prof.Add(__VA_ARGS__)
 #else
 	#define PROF_MOVE(...)
 #endif
 
 Store3Status LMail3Store::Move(LDataFolderI *NewFolder, LArray<LDataI*> &Items)
 {
 	Store3Status Status = Store3Error;
 
 	LMail3Folder *To = dynamic_cast<LMail3Folder*>(NewFolder);
 	if (!To)
 		return Status;
 	if (Items.Length() == 0)
 		return Store3Success;
 
 #if PROFILE_MOVE
 LProfile prof("LMail3Store::Move");
 #endif
 	LDataFolderI *OldParent = NULL;
 	LArray<LDataI*> Moved;
 	StoreTrans Tr = StartTransaction();
 
 	for (unsigned n=0; n<Items.Length(); n++)
 	{
 		LMail3Thing *Thing = 0;
 		LMail3Folder *Fld = dynamic_cast<LMail3Folder*>(Items[n]);
 		if (Fld)
 		{
 PROF_MOVE("0");
 			if (Fld->ParentId == To->Id)
 				Status = Store3Success;
 			else
 			{
 				char s[256];
 				sprintf_s(s, sizeof(s), "update " MAIL3_TBL_FOLDER " set ParentId=" LPrintfInt64 " where Id=" LPrintfInt64, To->Id, Fld->Id);
 PROF_MOVE("1");
 				LStatement Stmt(this, s);
 				if (Stmt.Exec())
 				{
 PROF_MOVE("2");
 					Status = Store3Success;
 					LAssert(Fld->Parent->Sub.IndexOf(Fld) >= 0);
 
 					Fld->Parent->Sub.Delete(Fld);
 					LDataFolderI *From = Fld->Parent;
 					Fld->Parent = To;
 					Fld->ParentId = Fld->Parent->Id;
 					To->Sub.Insert(Fld);
 
 					if (!OldParent) OldParent = From;
 					if (Callback && OldParent && Moved.Length() && OldParent != From)
 					{
 PROF_MOVE("3");
 						Callback->OnMove(To, OldParent, Moved);
 PROF_MOVE("4");
 						Moved.Length(0);
 						OldParent = From;
 					}							
 					Moved.Add(Fld);
 				}
 			}
 		}
 		else if ((Thing = dynamic_cast<LMail3Thing*>(Items[n])))
 		{
 PROF_MOVE("5");
 			if (Thing->ParentId == To->Id)
 				Status = Store3Success;
 			else if (To->ItemType != MAGIC_ANY &&
 						Thing->Type() != To->ItemType)
 			{
 				LgiTrace("%s:%i - Can't move item (type=%x) to folder containing type %x.\n", _FL, Thing->Type(), To->ItemType);
 				Status = Store3Error;
 			}
 			else
 			{
 				// This needs to be before the SQL update so that duplicate Mail 
 				// objects don't get created when moving to an unloaded folder.
 				if (To->Items.GetState() != Store3Loaded)
 					To->Children();
 					
 PROF_MOVE("6");
 				char s[256];
 				sprintf_s(s, sizeof(s), "update %s set ParentId=" LPrintfInt64 " where Id=" LPrintfInt64, Thing->GetTable(), To->Id, Thing->Id);
 				LStatement Stmt(this, s);
 				if (Stmt.Exec())
 				{
 PROF_MOVE("6");
 					Status = Store3Success;
 					LDataFolderI *From = Thing->Parent;
 					if (Thing->Parent)
 					{
 						LAssert(Thing->Parent->Items.IndexOf(Thing) >= 0);
 						Thing->Parent->Items.Delete(Thing);
 					}
 
 					Thing->Parent = To;
 					Thing->ParentId = To->Id;
 						
 					LAssert(To->Items.IndexOf(Thing) < 0);
 						
 					#ifdef _DEBUG
 					if (To->System != Store3SystemTrash)
 					{
 						// Check there is no duplicate ID..
 						for (unsigned k=0; k<To->Items.a.Length(); k++)
 						{
 							if (To->Items.a[k]->Id == Thing->Id)
 							{
 								LAssert(!"Can't have duplicate IDs in the same folder.");
 							}
 						}
 					}
 					#endif						
 						
 // LgiTrace("%s:%i - Saving %p:%i to %s (%i items)\n", _FL, Thing, (int)Thing->Id, To->GetStr(FIELD_FOLDER_NAME), To->Items.Length());
 					To->Items.Insert(Thing);
 
 					if (!OldParent) OldParent = From;
 					if (Callback && OldParent && Moved.Length() && OldParent != From)
 					{
 PROF_MOVE("7");
 						Callback->OnMove(To, OldParent, Moved);
 PROF_MOVE("8");
 						Moved.Length(0);
 						OldParent = From;
 					}							
 					Moved.Add(Thing);
 				}
 			}
 		}
 	}
 
 	if (Callback && Moved.Length())
 		Callback->OnMove(To, OldParent, Moved);
 
 	return Status;
 }
 
 Store3Status LMail3Store::Delete(LArray<LDataI*> &Items, bool ToTrash)
 {
 	if (Items.Length() == 0)
 		return Store3Error;
 
 	LVariant FolderName;
 	LMail3Folder *Trash = 0;
 	if (ToTrash && Callback->GetSystemPath(FOLDER_TRASH, FolderName))
 	{
 		auto t = LString(FolderName.Str()).SplitDelimit("/");
 		if (t.Length() == 1)
 			Trash = Root->FindSub(t[0]);
 	}
 
 	if (Trash)
 	{
 		LArray<LDataI*> MoveItems;
 		for (unsigned i=0; i<Items.Length(); i++)
 		{
 			LDataI *di = Items[i];
 			
 			LMail3Thing *t = dynamic_cast<LMail3Thing*>(di);
 			if (t && t->Parent != Trash)
 			{
 				// Move the item to the trash instead...
 				MoveItems.Add(di);
 				Items.DeleteAt(i--, true);
 			}
 			else
 			{			
 				LMail3Folder *f = dynamic_cast<LMail3Folder*>(di);
 				if (f && f->Parent != Trash)
 				{
 					// Move the folder to the trash instead...
 					MoveItems.Add(di);
 					Items.DeleteAt(i--, true);
 				}
 			}
 		}
 		
 		if (MoveItems.Length() > 0)
 		{
 			Store3Status s = Move(Trash, MoveItems);
 			
 			if (s != Store3Success)
 				return s;
 		}
 		
 		if (Items.Length() == 0)
 			return Store3Success;
 	}
 
 	Store3Status s = Store3Success;
 	LDataI *Item = Items[0];
 	switch ((uint32_t)Item->Type())
 	{
 		default:
 		{
 			LMail3Thing *t = dynamic_cast<LMail3Thing*>(Item);
 			if (!t)
 			{
 				LAssert(!"What are you trying to do?");
 				s = Store3Error;
 			}
 			else if (Callback && !Callback->OnDelete(t->Parent, Items))
 			{
 				s = Store3Error;
 			}
 			else
 			{
 				for (unsigned i=0; i<Items.Length(); i++)
 				{
 					if ((t = dynamic_cast<LMail3Thing*>(Items[i])))
 					{
 						if (t->DbDelete())
 						{
 							if (t->Parent)
 								t->Parent->Items.Delete(t);
 							else
 								LAssert(0);
 							DeleteObj(t);
 						}
 						else s = Store3Error;
 					}
 				}
 			}
 			break;
 		}
 		case MAGIC_ATTACHMENT:
 		{
 			for (auto i: Items)
 			{
 				LMail3Attachment *a = dynamic_cast<LMail3Attachment*>(i);
 				if (a)
 				{
 					a->Delete(ToTrash);
 					a->Detach();
 					delete a;
 				}
 			}
 			break;
 		}
 		case MAGIC_FOLDER:
 		{
 			LMail3Folder *f = dynamic_cast<LMail3Folder*>(Item);
 			if (!f)
 				s = Store3Error;
 			else if (Callback && !Callback->OnDelete(f->Parent, Items))
 				s = Store3Error;
 			else
 			{
 				for (unsigned i=0; i<Items.Length(); i++)
 				{
 					if ((f = dynamic_cast<LMail3Folder*>(Items[i])))
 					{
 						if (f->DbDelete())
 						{
 							if (f->Parent)
 								f->Parent->Sub.Delete(f);
 							else
 								LAssert(0);
 							DeleteObj(f);
 						}
 						else s = Store3Error;
 					}
 				}
 			}
 			break;
 		}
 	}
 
 	return s;
 }
 
 Store3Status LMail3Store::Change(LArray<LDataI*> &Items, int PropId, LVariant &Value, LOperator Operator)
 {
 	if (Items.Length() == 0)
 		return Store3Success;
 
 	if (PropId != FIELD_FLAGS)
 	{
 		LAssert(!"Not impl.");
 		return Store3NotImpl;
 	}
 
 	int32 Val = Value.CastInt32();
 	if (!Val)
 	{
 		LAssert(!"One flag must be set");
 		return Store3Error;
 	}
 
 	if (Operator != OpPlusEquals &&
 		Operator != OpMinusEquals)
 	{
 		LAssert(!"Operator not supported.");
 		return Store3Error;
 	}
 
 	StoreTrans Tr = StartTransaction();
 
 	// Set/unset flag
 	for (unsigned i=0; i<Items.Length();)
 	{
 		LStringPipe p;
 		p.Print("update " MAIL3_TBL_MAIL " set ");
 
 		if (Operator == OpMinusEquals)
 			// Unset flag
 			p.Print("Flags=Flags&%i where ", ~Val);
 		else
 			// Set flag
 			p.Print("Flags=Flags|%i where ", Val);
 
 		LArray<LDataI*> Chunk;
 		for (unsigned n=0; n<100 && i<Items.Length(); n++, i++)
 		{
 			auto m = dynamic_cast<LMail3Mail*>(Items[i]);
 			if (!m)
 			{
 				LAssert(!"Invalid object.");
 				continue;
 			}
 			if
 			(
 				(Operator == OpMinusEquals && (m->Flags & Val))
 				||
 				(Operator == OpPlusEquals && !(m->Flags & Val))
 			)
 			{
 				p.Print("%sId=" LPrintfInt64, Chunk.Length()?" or ":"", m->Id);
 				Chunk.Add(m);
 			}
 		}
 
 		if (Chunk.Length())
 		{
 			auto Sql = p.NewLStr();
 			LStatement s(this, Sql);
 			if (!s.Exec())
 				return Store3Error;
 
 			for (unsigned n=0; n<Chunk.Length(); n++)
 			{
 				LMail3Mail *m = dynamic_cast<LMail3Mail*>(Chunk[n]);
 				if (m)
 				{
 					if (Operator == OpMinusEquals)
 						m->Flags &= ~Val;
 					else
 						m->Flags |= Val;
 				}
 			}
 
 			OnChange(_FL, Chunk, PropId);
 		}
 	}
 
 	return Store3Success;
 }
 
 bool LMail3Store::SetFormat(LViewI *Parent, LDataPropI *Props)
 {
 	if (!Parent || !Props)
 		return false;
 
 	Mail3SubFormat NewFormat = (Mail3SubFormat)Props->GetInt(Store3UiNewFormat);
 	if (NewFormat == Format)
 		return true;
 	
 	bool Error = false;
 	LStatement Folders(this, "select * from " MAIL3_TBL_FOLDER);
 	char Sql[256];
 
 	LStatement Count(this, "select Count(*) as c from " MAIL3_TBL_FOLDER);
 	if (Count.Row())
 	{
 		char *c = Count.GetStr(0);
 		if (c)
 			Props->SetInt(Store3UiMaxPos, atoi(c));
 	}
 
 	if (NewFormat == Mail3v1)
 	{
 		// Change format to single table for all email
 		
 		// Create the mail table
 		Store3Status s = CheckTable(MAIL3_TBL_MAIL, TblMail);
 		if (!UpdateTable(MAIL3_TBL_MAIL, TblMail, s))
 			Error = true;
 		else
 		{
 			// Copy all the sub-folder mail into that one table...
 			while (Folders.Row())
 			{
 				int64 Id = Folders.GetInt64(0);
 
 				char TblName[128];
 				sprintf_s(TblName, sizeof(TblName), "Mail_" LPrintfInt64, Id);
 
 				// Set the parent ID on all mail rows in the sub-folder table (just to be sure)
 				sprintf_s(Sql, sizeof(Sql), "update %s set ParentId=" LPrintfInt64, TblName, Id);
 				LStatement SetId(this, Sql);
 				if (!SetId.Exec())
 				{
 					Error = true;
 					break;
 				}
 
 				// Now copy all the rows into the main Mail table
 				sprintf_s(Sql, sizeof(Sql), "insert into " MAIL3_TBL_MAIL " select * from %s", TblName);
 				LStatement Copy(this, Sql);
 				if (!Copy.Exec())
 				{
 					Error = true;
 					break;
 				}
 
 				// And drop the sub-folder table..				
 				sprintf_s(Sql, sizeof(Sql), "drop table if exists %s", TblName);
 				LStatement Del(this, Sql);
 				if (!Del.Exec())
 				{
 					Error = true;
 					break;
 				}
 			}
 		}
 	}
 	else if (NewFormat == Mail3v2)
 	{
 		// Change format to a table per folder of email
 		{
 			LTransaction Trans(this);
 			int Pos = 0;
 			while (Folders.Row())
 			{
 				int64 Id = Folders.GetInt64(0);
 				
 				char TblName[128];
 				sprintf_s(TblName, sizeof(TblName), "Mail_" LPrintfInt64, Id);
 				
 				sprintf_s(Sql, sizeof(Sql), "create table if not exists %s as select * from Mail where ParentId=" LPrintfInt64, TblName, Id);
 				LStatement Convert(this, Sql);
 				if (!Convert.Exec())
 				{
 					Error = true;
 					Trans.RollBack();
 					break;
 				}
 
 				Props->SetInt(Store3UiCurrentPos, ++Pos);
 			}
 		}
 
 		sprintf_s(Sql, sizeof(Sql), "drop table if exists " MAIL3_TBL_FOLDER);
 		LStatement Del(this, Sql);
 		if (!Del.Exec())
 			Error = true;
 	}
 
 	if (!Error)
 		Format = NewFormat;
 	
 	return !Error;
 }
 
 void LMail3Store::Upgrade(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus)
 {
 	bool Status = true;
 
 	LStringPipe p;
 
 	for (auto it : Fields)
 	{
 		Store3Status s = TableStatus.Find(it.key);
 		if (s == Store3UpgradeRequired)
 		{
 			if (!UpdateTable(it.key, it.value, s))
 			{
 				p.Print("Failed to upgrade %s\n", it.key);
 				Status = false;
 			}
 		}
 	}
 
 	if (Props && !Status)
 	{
 		LAutoString a(p.NewStr());
 		Props->SetStr(Store3UiError, a);
 	}
 
 	if (OnStatus)
 		OnStatus(Status);
 }
 
 class SqliteRepairThread : public LThread
 {
 	LMail3Store *Store;
 	LString Exe;
 	LString Db;
 	LString RepairSql;
 	LString OldDb;
 	
 	LViewI *Parent = NULL;
 	LDataPropI *Props = NULL;
 	LAutoPtr<LSubProcess> Shell;
 	ssize_t Ch = 0;
 	char Line[512] = {};
 
 public:
 	bool Status = false;
 
 	SqliteRepairThread(LMail3Store *store, LString exe, LString db, LViewI *parent, LDataPropI *props) :
 		Store(store),
 		LThread("SqliteRepairThread")
 	{
 		Exe = exe;
 		Db = db;
 		Parent = parent;
 		Props = props;
 		
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), Db, "..\\Repair.sql");
 		for (char *c = p; *c; c++)
 		{
 			if (*c == '\\')
 				*c = '/';
 		}
 		RepairSql = p;
 		
 		LString s;
 		LDateTime dt;
 		dt.SetNow();
 		char sNow[64];
 		dt.Get(sNow, sizeof(sNow));
 		for (char *c = sNow; *c; c++)
 		{
 			if (*c == ':' || *c == '/')
 				*c = '-';
 		}
 		
 		s.Printf("..\\Database %s.sqlite", sNow);
 		LMakePath(p, sizeof(p), Db, s);
 		OldDb = p;
 		
 		LgiTrace("Sqlite Repair paths:\n"
 				"Exe: '%s'\n"
 				"Db: '%s'\n"
 				"Old: '%s'\n"
 				"Sql: '%s'\n",
 				Exe.Get(),
 				Db.Get(),
 				OldDb.Get(),
 				RepairSql.Get());
 		
 		Run();
 	}
 	
 	char *Read()
 	{
 		Ch = Shell->Read(Line, sizeof(Line)-1);
 		if (Ch < 0)
 			return NULL;
 		Line[Ch] = 0;
 		return Line;
 	}
 	
 	bool GetPrompt()
 	{
 		char *l;
 		while ((l = Read()))
 		{
 			if (stristr(l, "sqlite>"))
 				return true;
 		}
 
 		if (Props)
 			Props->SetStr(Store3UiError, "Failed to get prompt...");
 		return false;
 	}
 	
 	void StatusMsg(const char *msg)
 	{
 		if (Props)
 		{
 			int64 p = Props->GetInt(Store3UiCurrentPos);
 			Props->SetInt(Store3UiCurrentPos, p + 1);
 			Props->SetStr(Store3UiStatus, msg);
 		}
 	}
 
 	int OnStatus(int s)
 	{
 		// Send status event back to the store...
 		auto msg = new LMail3StoreMsg(LMail3StoreMsg::MsgRepairComplete);
 		msg->Int = s;
 		Store->PostStore(msg);
 
 		return s;
 	}
 	
 	int Main()
 	{
 		if (Props)
 		{
 			Props->SetInt(Store3UiMaxPos, 7);
 			Props->SetStr(Store3UiStatus, "Starting sqlite...");
 		}
 
 		// Open the shell and start the export process
 		LString Args;
 		Args.Printf("-interactive %s", Db.Get());
 		if (!Shell.Reset(new LSubProcess(Exe, Args)))
 			return OnStatus(-1);
 		
 		if (!Shell->Start(true, true))
 		{
 			if (Props)
 				Props->SetStr(Store3UiError, "Couldn't execute sqlite3 shell.");
 			return OnStatus(-2);
 		}		
 
 		// http://froebe.net/blog/2015/05/27/error-sqlite-database-is-malformed-solved/
 		//
 		// Run through the commands:
 		// pragma integrity_check;
 		// .mode insert
 		// .output mydb_export.sql
 		// .dump
 		// .exit
 		if (!GetPrompt())
 			return OnStatus(-3);
 		StatusMsg("Setting mode...");
 			
 		LString Cmd;
 		Cmd.Printf(".mode insert\r\n");
 		Shell->Write(Cmd, Cmd.Length());
 		
 		if (!GetPrompt())
 			return OnStatus(-4);
 		StatusMsg("Setting output file...");
 		
 		Cmd.Printf(".output \"%s\"\r\n", RepairSql.Get());
 		Shell->Write(Cmd, Cmd.Length());
 
 		if (!GetPrompt())
 			return OnStatus(-5);
 		StatusMsg("Dumping SQL...");
 
 		Cmd.Printf(".dump\r\n");
 		Shell->Write(Cmd, Cmd.Length());
 
 		if (!GetPrompt())
 			return OnStatus(-6);
 
 		Cmd.Printf(".exit\r\n");
 		Shell->Write(Cmd, Cmd.Length());
 		Shell->Wait();
 		
 		StatusMsg("Renaming database...");
 		
 		if (!FileDev->Move(Db, OldDb))
 		{
 			LString s;
 			s.Printf("Can't move '%s' to '%s'", Db.Get(), OldDb.Get());
 			Props->SetStr(Store3UiError, s);
 			return -6;
 		}
 		
 		StatusMsg("Importing SQL...");
 
 		char *r = RepairSql;
 		for (char *c = r; *c; c++)
 		{
 			if (*c == '/' || *c == '\\')
 				*c = DIR_CHAR;
 		}
 
 		#ifdef WINDOWS
 		wchar_t wd[MAX_PATH_LEN];
 		_wgetcwd(wd, MAX_PATH_LEN);
 		#else
 		char wd[MAX_PATH_LEN];
 		#ifdef __GTK_H__
 		// Gtk::
 		#endif
 		getcwd(wd, MAX_PATH_LEN);
 		#endif
 		
 		char base[MAX_PATH_LEN];
 		LMakePath(base, sizeof(base), Db, "..");
 		#ifdef WINDOWS
 		LAutoWString baseW(Utf8ToWide(base));
 		_wchdir(baseW);
 		#else
 		#ifdef __GTK_H__
 		// Gtk::
 		#endif
 		chdir(base);
 		#endif
 		char *exe_leaf = strrchr(Exe, DIR_CHAR);
 		
 		Args.Printf("%s \"%s\" < \"%s\"", exe_leaf ? exe_leaf + 1 : Exe.Get(), Db.Get(), RepairSql.Get());
 		int Result = system(Args);
 		LgiTrace("Import result = %i\n", Result);
 		
 		#ifdef WINDOWS
 		_wchdir(wd);
 		#else
 		#ifdef __GTK_H__
 		// Gtk::
 		#endif
 		chdir(wd);
 		#endif
 
 		StatusMsg("Deleting temporary files...");
 		FileDev->Delete(RepairSql, false);
 
 		return OnStatus(0);
 	}
 };
 
 bool CheckPathForFile(const char *File, char *Exe, int ExeSize)
 {
     LString Path; 
     #ifdef WINDOWS
     char *buffer = NULL;
     size_t sz = 0;
     errno_t err = _dupenv_s(&buffer, &sz, "PATH");
     if (err)
     {
 		LgiTrace("%s:%i - _dupenv_s failed with %i.\n", _FL, err);
 		return false;
     }
     if (sz == 0) // PATH not found
 		return false;
 	Path = buffer;
 	free(buffer);		
     #else
     Path = getenv("PATH");
     if (!Path)
 		return false;
     #endif
     
     LString::Array p = Path.Split(LGI_PATH_SEPARATOR);
     for (unsigned i=0; i<p.Length(); i++)
     {
         char s[MAX_PATH_LEN];
         LMakePath(s, sizeof(s), p[i], File);
         if (LFileExists(s))
         {
             strcpy_s(Exe, ExeSize, s);
             return true;
         }
     }    
     
     return false;
 }
 
 void LMail3Store::Repair(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus)
 {
 	// Is the sqlite3 shell binary available?
 	char base[MAX_PATH_LEN];
 	char exe[MAX_PATH_LEN] = "";
 	LMakePath(base, sizeof(base), DbFile, "..");
 	
 	#ifdef WINDOWS
 		const char *SqliteBin = "sqlite3.exe";
 		LMakePath(exe, sizeof(exe), base, SqliteBin);
 	#else
 		const char *SqliteBin = "sqlite3";
 		CheckPathForFile(SqliteBin, exe, sizeof(exe));
 	#endif		    
 	if (!LFileExists(exe))
 	{
 		LString DownloadUrl = "https://www.sqlite.org/download.html";
 		LViewI *p = dynamic_cast<LViewI*>(Props);
 		LString Msg;
 		Msg.Printf("Error: sqlite shell binary missing (%s). "
 		            #ifdef WINDOWS
 		            "Download from:\n"
 					"\n"
 					"    %s\n"
 					#else
 					"Install using your package manager:\n"
 					"\n"
 					"   e.g. sudo apt-get install sqlite3\n"
 					#endif
 					"\n"
 					"Download the shell binary and extract to this folder:\n"
 					"\n"
 					"    %s\n"
 					"\n"
 					"Then try the Repair command again.\n",
 					SqliteBin,
 					DownloadUrl.Get(),
 					base);
 		auto Dlg = new LAlert(p?p:Parent,
 							"LMail3Store::Repair",
 							Msg,
 							"Browse Download Site & Local Folder",
 							"Cancel");
 		Dlg->DoModal([this, Dlg, DownloadUrl, base](auto dlg, auto ctrlId)
 		{
 			if (ctrlId == 1)
 			{
 				LExecute(DownloadUrl);
 				LExecute(base);
 			}
 			delete dlg;
 		});
 	
 		if (OnStatus)
 			OnStatus(true);
 		return;
 	}
 	
 	// Close our database...
 	CloseDb();	
 	
 	// Do the repair in a thread
 	RepairOnStatus = OnStatus;
 	new SqliteRepairThread(this, exe, DbFile, Parent, Props);
 }
 
 int64 LMail3Store::GetFolderId(char *Path)
 {
 	auto Parts = LString(Path).SplitDelimit("/");
 	LMail3Folder *Root = dynamic_cast<LMail3Folder*>(GetRoot());
 	if (!Root)
 		return 0;
 
 	uint64 Id = Root->Id;
 	for (unsigned i=0; i<Parts.Length(); i++)
 	{
 		char *p = Parts[i];
 		char Sql[256];
 		sprintf_s(Sql, sizeof(Sql), "select * from " MAIL3_TBL_FOLDER " where Name=\"%s\" and ParentId=" LPrintfInt64, p, Id);
 		LStatement s(this, Sql);
 		if (s.Row())
 		{
 			Id = s.GetInt64(0);
 		}
 		else return 0;
 	}
 	
 	return Id;
 }
 
 bool LMail3Store::DeleteMailById(int64 Id)
 {
 	LDataStoreI::StoreTrans Trans = StartTransaction();
 	char s[256];
 
 	// Delete all the segments...
 	sprintf_s(s, sizeof(s), "delete from " MAIL3_TBL_MAILSEGS " where MailId=" LPrintfInt64, Id);
 	LMail3Store::LStatement Del(this, s);
 	if (!Del.Exec())
 		return false;
 
 	// Delete the mail itself
 	sprintf_s(s, sizeof(s), "delete from " MAIL3_TBL_MAIL " where Id=" LPrintfInt64, Id);
 	LMail3Store::LStatement Del2(this, s);
 	if (!Del2.Exec())
 		return false;
 
 	return true;
 }
 
 /*
 	while
 	(
 		!Props->GetInt(Store3UiCancel)
 		&&            
 		(Thread.Return < 0 || !Thread.IsExited())
 	)
 	{
 		LSleep(100);
 				
 		if (Thread.Lock(_FL))
 		{
 			if (Thread.Status)
 			{
 				Props->SetStr(Store3UiStatus, Thread.Status);
 				Thread.Status.Empty();
 			}
 			if (Thread.Error)
 			{
 				
 				Thread.Error.Empty();
 			}
 			if (Thread.Max > 0)
 			{
 				Props->SetInt(Store3UiMaxPos, Thread.Max);
 				Thread.Max = -1;
 			}
 			if (Thread.Value >= 0)
 			{
 				Props->SetInt(Store3UiCurrentPos, Thread.Value);
 				Thread.Value = -1;
 			}
 			Thread.Unlock();
 		}
 				
 		LYield();
 	}
 			
 	Status = Thread.Return > 0;
 */
 
 class CompactThread : public LThread, public LCancel
 {
 	int64 InboxId = 0;
 	LMail3Store *Store = NULL;
 	LDataPropI *Props = NULL;
 	int64 Value = -1;
 	int64 Max = -1;
 
 public:
 	CompactThread(LMail3Store *store, int64 inboxId, LDataPropI *props) :
 		LThread("CompactThread")
 	{
 		Store = store;
 		InboxId = inboxId;
 		Props = props;
 
 		Run();
 	}
 	
 	~CompactThread()
 	{
 		Cancel();
 		WaitForExit();
 	}
 
 	void SetError(const char *s)
 	{
 		Props->SetStr(Store3UiError, s);
 	}
 	
 	void SetStatus(const char *s)
 	{
 		Props->SetStr(Store3UiStatus, s);
 	}
 
 	void OnStatus(bool s)
 	{
 		// Send status event back to the store...
 		auto msg = new LMail3StoreMsg(LMail3StoreMsg::MsgCompactComplete);
 		msg->Int = s;
 		Store->PostStore(msg);
 	}
 	
 	int Main()
 	{
 		// Clean up orphaned mail segments.
 		{
 			SetStatus("Cleaning up orphaned Mail segments...");
 			LMail3Store::LStatement s(Store,
 				"delete from " MAIL3_TBL_MAILSEGS " where MailId not in (select Id from " MAIL3_TBL_MAIL ")");
 			if (!s.Exec())
 			{
 				SetError("Failed to delete orphaned segments.");
 				OnStatus(false);
 				return -1;
 			}
 		}
 
 		// Clean up orphaned mail.
 		if (!IsCancelled())
 		{
 			SetStatus("Cleaning up orphaned Mail...");
 
 			LMail3Store::LStatement count(Store, "select COUNT(*) from " MAIL3_TBL_MAIL " where ParentId not in (select Id from " MAIL3_TBL_FOLDER ")");
 			if (count.Row())
 			{
 				int64 Rows = count.GetInt64(0);
 				Max = Rows;
 			}
 
 			LDataStoreI::StoreTrans Trn = Store->StartTransaction();
 			LMail3Store::LStatement s(Store, "select Id from " MAIL3_TBL_MAIL " where ParentId not in (select Id from " MAIL3_TBL_FOLDER ")");
 			int64 RowPos = 0;
 			while (!IsCancelled() && s.Row())
 			{
 				int64 Id = s.GetInt64(0);
 				Store->DeleteMailById(Id);
 				Value = ++RowPos;
 			}
 			
 			Max = 1;
 			Value = 0;
 		}
 
 		// Vacuum
 		if (!IsCancelled())
 		{
 			SetStatus("Vacuum unused space...");
 
 			LMail3Store::LStatement s(Store, "vacuum;");
 			if (!s.Exec())
 			{
 				SetError("Reclaiming space failed.");
 				OnStatus(false);
 				return -1;
 			}
 		}
 		
 		OnStatus(true);
 		return 0;
 	}
 };
 
 void LMail3Store::Compact(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus)
 {
 	if (!Props || !Callback)
 		return;
 
 	bool Status = false;
 	LVariant InboxPath;
 	if (!Callback->GetSystemPath(FOLDER_INBOX, InboxPath))
 		Props->SetStr(Store3UiError, "Couldn't get path to Inbox.");
 	else
 	{
 		int64 InboxId = GetFolderId(InboxPath.Str());
 		if (!InboxId)
 			Props->SetStr(Store3UiError, "Couldn't get Inbox ID.");
 		{
 			// Save this locally, because the thread isn't suitable for calling it.
 			// Instead it will send us a message, and then the store can call it from
 			// the GUI thread. This way any client implementing the callback can talk
 			// to or delete UI elements.
 			CompactOnStatus = OnStatus;
 
 			new CompactThread(this, InboxId, Props);
 			return; // without calling OnStatus, the CompactThread will do it.
 		}
 	}
 	
 	OnStatus(Status);
 }
 
 void LMail3Store::OnEvent(void *Param)
 {
 	auto msg = (LMail3StoreMsg*)Param;
 	switch (msg->Msg)
 	{
 		case LMail3StoreMsg::MsgCompactComplete:
 		{
 			if (CompactOnStatus)
 			{
 				CompactOnStatus(msg->Int);
 				CompactOnStatus = NULL;
 			}
 			else LgiTrace("%s:%i - No CompactOnStatus to call on MsgCompactComplete.\n", _FL);
 			break;
 		}
 		case LMail3StoreMsg::MsgRepairComplete:
 		{
 			OpenDb();
 	
 			if (RepairOnStatus)
 			{
 				RepairOnStatus(msg->Int >= 0);
 				RepairOnStatus = NULL;
 			}
 			break;
 		}
 		default:
 		{
 			LgiTrace("%s:%i - Unhandled mail3store event.\n", _FL);
 			break;
 		}
 	}
 }
 
 bool LMail3Store::IsOk()
 {
 	return
 		#ifndef __llvm__
 		this != 0 &&
 		#endif
 		Db != 0;
 }
 
 bool LMail3Store::ParseTableFormat(const char *Name, TableDefn &Defs)
 {
 	char Sql[256];
 	sprintf_s(Sql, sizeof(Sql), "SELECT * FROM sqlite_master WHERE type='table' and name='%s'", Name);
 
 	LStatement st(this, Sql);
 	if (!st.IsOk())
 		return false;
 
 	if (!st.Row())
 		return false;
 
 	char *Fmt = st.GetStr(4);
 	char *s = Fmt ? strchr(Fmt, '(') + 1 : 0;
 	char *e = Fmt ? strrchr(Fmt, ')') : 0;
 	if (!s || !e)
 		return false;
 
 	LString f(s, e - s);
 	Defs.t = f.SplitDelimit(",");
 
 	for (unsigned i=0; i<Defs.t.Length(); i++)
 	{
 		char *Fld = Defs.t[i];
 		while (*Fld && strchr(" \t\r\n", *Fld)) Fld++;
 		char *Sp = strchr(Fld, ' ');
 		if (Sp)
 		{
 			*Sp++ = 0;
 
 			LMail3Def &d = Defs.New();
 			d.Name = Fld;
 			d.Type = Sp;
 		}
 		else return false;
 	}
 
 	return true;
 }
 
 Store3Status LMail3Store::CheckTable(const char *Name, LMail3Def *Flds)
 {
 	Store3Status Status = Store3Success;
 
 	if (!IsOk())
 		return Store3Error;
 
 	TableDefn Defs;
 	LString::Array t;
 	unsigned FieldCount = 0;
 	for (FieldCount=0; Flds[FieldCount].Name; FieldCount++)
 		;
 
 	if (ParseTableFormat(Name, Defs))
 	{
 		size_t MaxFields = MAX(Defs.Length(), FieldCount);
 		for (unsigned i=0; i<MaxFields; i++)
 		{
 			if (i >= Defs.Length())
 			{
 				LString Msg;
 				Msg.Printf("\nTable '%s' is missing the schema field: '%s %s'", Name, Flds[i].Type, Flds[i].Name);
 				StatusMsg += Msg;
 				break;
 			}
 
 			LMail3Def &Def = Defs[i];
 			if (i >= FieldCount) // Schema field count is less than existing table
 			{
 				LString Msg;
 				Msg.Printf("\nTable '%s' has an extra field: '%s %s'\n", Name, Def.Type, Def.Name);
 				StatusMsg += Msg;
 				break;
 			}
 			
 			if (!Flds[i].Name ||
 				!Flds[i].Type ||
 				!Def.Name ||
 				!Def.Type)
 			{
 				Status = Store3Error;
 				break;
 			}
 
 			if (_stricmp(Flds[i].Name, Def.Name) != 0 ||
 				_stricmp(Flds[i].Type, Def.Type) != 0)
 			{
 				LString Msg;
 				Msg.Printf("\nTable '%s' has a field '%s %s' which is to the schema: '%s %s'\n",
 							Name,
 							Def.Type, Def.Name,
 							Flds[i].Type, Flds[i].Name);
 				StatusMsg += Msg;
 
 				Status = Store3UpgradeRequired;
 				break;
 			}
 		}
 		if (Defs.Length() != FieldCount)
 		{
 			LString Msg;
 			Msg.Printf("\nTable '%s' has %i fields (should have %i)\n", Name, Defs.Length(), FieldCount);
 			StatusMsg += Msg;
 			Status = Store3UpgradeRequired;
 		}
 	}
 	else Status = Store3Missing;
 	
 	return Status;
 }
 
 bool LMail3Store::UpdateTable(const char *Name, LMail3Def *Flds, Store3Status Check)
 {
 	LStatement st(this);
 	LAutoString TempTable;
 	TableDefn Defs;
 
 	if (Check == Store3UpgradeRequired)
 	{
 		// Get the old table format so we can copy over field by field later...
 		if (!ParseTableFormat(Name, Defs))
 		{
 			return false;
 		}
 
 		char Tmp[256];
 		sprintf_s(Tmp, sizeof(Tmp), "%s_tmp", Name);
 		TempTable.Reset(NewStr(Tmp));
 
 		char AlterSql[256];
 		sprintf_s(AlterSql, sizeof(AlterSql), "alter table %s rename to %s", Name, Tmp);
 
 		LStatement Alter(this, AlterSql);
 		if (!Alter.Exec())
 		{
 			LAssert(!"Can't rename table.");
 			return false;
 		}
 	}
 
 	// Create table?
 	LStringPipe p;
 	LHashTbl<ConstStrKey<char,false>, bool> AllFlds;
 	p.Print("create table %s (", Name);
 	for (int i=0; Flds[i].Name; i++)
 	{
 		AllFlds.Add(Flds[i].Name, true);
 		if (i) p.Print(", ");
 		p.Print("%s %s", Flds[i].Name, Flds[i].Type);
 	}
 	p.Print(")");
 	LAutoString s(p.NewStr());
 	if (s)
 	{
 		if (st.Prepare(s))
 			st.Exec();
 		else
 		{
 			LgiTrace("Sql='%s'\n", s.Get());
 			return false;
 		}
 	}
 
 	// Copy over data from the old table
 	if (TempTable)
 	{
 		LStringPipe p;
 		p.Print("insert into %s (", Name);
 
 		int Count = 0;
 		for (unsigned i=0; i<Defs.Length(); i++) // For all common fields between the 2 tables
 		{
 			LMail3Def &Def = Defs[i];
 			if (AllFlds.Find(Def.Name))
 			{
 				p.Print("%s%s", Count ? (char*)", " : "", Def.Name);
 				Count++;
 			}
 		}
 
 		p.Print(") select ");
 		Count = 0;
 		for (unsigned i=0; i<Defs.Length(); i++)
 		{
 			LMail3Def &Def = Defs[i];
 			if (AllFlds.Find(Def.Name))
 			{
 				p.Print("%s%s", Count ? (char*)", " : "", Def.Name);
 				Count++;
 			}
 		}
 		p.Print(" from %s", TempTable.Get());
 
 		// Run the copy
 		LAutoString InsSql(p.NewStr());
 		if (!st.Prepare(InsSql))
 		{
 			LAssert(!"Can't insert old data");
 			return false;
 		}
 
 		if (!st.Exec())
 		{
 			LAssert(!"Can't copy data from old table.");
 			return false;
 		}
 
 		// Delete the temporary table...
 		char Sql[256];
 		sprintf_s(Sql, sizeof(Sql), "drop table %s", TempTable.Get());
 		if (!st.Prepare(Sql) ||
 			!st.Exec())
 		{
 			LAssert(!"Drop table failed.");
 			return false;
 		}
 	}
 
 	return true;
 }
 
 LMail3Store::LInsert::LInsert(LMail3Store *store, const char *Tbl) : LStatement(store)
 {
 	Store = store;
 	Table = Tbl;
 
 	LMail3Def *f = Store->GetFields(Tbl);
 	if (f)
 	{
 		LVariant v;
 		LStringPipe p;
 		p.Print("insert into '%s' values (", Tbl);
 		for (int i=0; f[i].Name; i++)
 		{
 			if (i) p.Print(",");
 			p.Print("?");
 		}
 		p.Print(")");
 		v.OwnStr(p.NewStr());
 
 		Prepare(v.Str());
 	}
 }
 
 LMail3Store::LUpdate::LUpdate(LMail3Store *store, const char *Tbl, int64 rowid, char *ExcludeField) : LStatement(store)
 {
 	RowId = rowid;
 	Store = store;
 	Table = Tbl;
 
 	LAssert(Store != 0 && Tbl != 0 && RowId > 0);
 
 	LMail3Def *f = Store->GetFields(Tbl);
 	if (f)
 	{
 		LVariant v;
 		LStringPipe p;
 		p.Print("update %s set ", Tbl);
 		for (int i=1; f[i].Name; i++)
 		{
 			if (ExcludeField && !_stricmp(f[i].Name, ExcludeField))
 				continue;
 
 			if (i>1) p.Print(", ");
 			p.Print("%s=?%i", f[i].Name, i + 1);
 		}
 		p.Print(" where %s=?1", f[0].Name);
 		v.OwnStr(p.NewStr());
 
 		Prepare(v.Str());
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////
 bool LMail3Obj::Check(int r, char *sql)
 {
 	return Store->Check(r, sql);
 }
 
 #define DEBUG_MAIL3_WRITE				0
+#if DEBUG_MAIL3_WRITE
+#define PROFILE(msg)					Prof.Add(msg)
+#else
+#define PROFILE(msg)
+#endif
 
 bool LMail3Obj::Write(const char *Table, bool Insert)
 {
 #if DEBUG_MAIL3_WRITE
 LProfile Prof("LMail3Obj::Write");
 #endif
 	LAutoPtr<LMail3Store::LStatement> s;
 
-#if DEBUG_MAIL3_WRITE
-Prof.Add(_FL);
-#endif
+	PROFILE("0");
 	if (Insert)
 		s.Reset(new LMail3Store::LInsert(Store, Table));
 	else
 		s.Reset(new LMail3Store::LUpdate(Store, Table, Id));
-#if DEBUG_MAIL3_WRITE
-Prof.Add(_FL);
-#endif
+
+	PROFILE("1");
 	if (s)
 	{
 		Serialize(*s, true);
-#if DEBUG_MAIL3_WRITE
-Prof.Add(_FL);
-#endif
+
+		PROFILE("2");
+
 		if (s->Exec())
 		{
-#if DEBUG_MAIL3_WRITE
-Prof.Add(_FL);
-#endif
+			PROFILE("3");
 			if (Insert)
 			{
 				Id = s->LastInsertId();
 				if (Id < 0)			
 				{
 					LAssert(!"No ID returned.");
 					LgiTrace("%s:%i - No ID from statement.\n", _FL);
 				}
 			}
 		}
 		else
 		{
 			LgiTrace("%s:%i - Exec failed.\n", _FL);
 		}
 	}
 	else LAssert(!"No statement");
 
 	return Id >= 0;
 }
 
 //////////////////////////////////////////////////////////////////////////
 LMail3Store::LStatement::LStatement(LMail3Store *store, const char *sql)
 {
 	Store = store;
 	s = 0;
 
 	#if MAIL3_TRACK_OBJS
 	LMail3Store::SqliteObjs &_d = Store->All.New();
 	_d.Stat = this;
 	#endif
 
 	if (sql)
 		Prepare(sql);
 }
 
 LMail3Store::LStatement::~LStatement()
 {
 	Finalize();
 
 	#if MAIL3_TRACK_OBJS
 	Store->RemoveFromAll(this);
 	#endif
 }
 
 int64 LMail3Store::LStatement::LastInsertId()
 {
 	return sqlite3_last_insert_rowid(Store->GetDb());
 }
 
 bool LMail3Store::LStatement::Prepare(const char *Sql)
 {
 	Finalize();
 	
 	TempSql.Reset(NewStr(Sql));
 	Store->Check(sqlite3_prepare_v2(Store->GetDb(), Sql, -1, &s, 0), Sql);
 
 	return s != 0;
 }
 
 bool LMail3Store::LStatement::Finalize()
 {
 	if (!s)
 		return false;
 
 	bool Status = Store->Check(sqlite3_finalize(s), 0);
 
 	s = 0;
 
 	return Status;
 }
 
 bool LMail3Store::LStatement::Row()
 {
 	if (!IsOk()) return false;
 	int r = sqlite3_step(s);
 	return r == SQLITE_ROW;
 }
 
 bool LMail3Store::LStatement::Exec()
 {
 	if (!IsOk()) return false;
 
 	if (!Store->Check(sqlite3_step(s), TempSql))
 		return false;
 
 	bool Status = true;
 	if (Post.Length())
 	{
 		int64 Id = GetRowId();
 		LAssert(Id > 0);
 
 		for (unsigned i=0; i<Post.Length(); i++)
 		{
 			PostBlob &b = Post[i];
 			sqlite3_blob *Blob = 0;
 
 			if (Store->Check(sqlite3_blob_open(	Store->GetDb(),
 												0,
 												Table.Str(),
 												b.ColName.Str(),
 												Id,
 												true,
 												&Blob), 0))
 			{
 				LArray<char> Buf;
 				if (Buf.Length(32<<10))
 				{
 					ssize_t r, Pos = 0;
 					
 					b.Data->SetPos(0);
 
 					while ((r = b.Data->Read(&Buf[0], Buf.Length())) > 0)
 					{
 						if (!Store->Check(sqlite3_blob_write(Blob, &Buf[0], (int)r, (int)Pos), 0))
 						{
 							Status = false;
 							break;
 						}
 
 						Pos += r;
 					}
 				}
 				else Status = false;
 
 				Store->Check(sqlite3_blob_close(Blob), 0);
 			}
 		}
 
 		Post.Length(0);
 	}
 
 	return Status;
 }
 
 bool LMail3Store::LStatement::Reset()
 {
 	if (!IsOk()) return false;
 	return	Store->Check(sqlite3_reset(s), 0) &&
 			Store->Check(sqlite3_clear_bindings(s), 0);
 }
 
 /* All the getter functions use 'Col' as the first column is '0' */
 int LMail3Store::LStatement::GetSize(int Col)
 {
 	return IsOk() ? sqlite3_column_bytes(s, Col) : 0;
 }
 
 bool LMail3Store::LStatement::GetBool(int Col)
 {
 	if (!IsOk() || sqlite3_column_type(s, Col) == SQLITE_NULL)
 		return false;
 	return sqlite3_column_int(s, Col) != 0;
 }
 
 int LMail3Store::LStatement::GetInt(int Col)
 {
 	if (!IsOk() || sqlite3_column_type(s, Col) == SQLITE_NULL)
 		return -1;
 	return sqlite3_column_int(s, Col);
 }
 
 int64 LMail3Store::LStatement::GetInt64(int Col)
 {
 	if (!IsOk() || sqlite3_column_type(s, Col) == SQLITE_NULL)
 		return -1;
 	return sqlite3_column_int64(s, Col);
 }
 
 bool LMail3Store::LStatement::SetInt64(int Col, int64 n)
 {
 	if (!IsOk()) return false;
 	if (n == -1)
 		return Store->Check(sqlite3_bind_null(s, Col+1), 0);
 	else
 		return Store->Check(sqlite3_bind_int64(s, Col+1, n), 0);
 }
 
 char *LMail3Store::LStatement::GetStr(int Col)
 {
 	if (!IsOk())
 		return NULL;
 	auto txt = (char*)sqlite3_column_text(s, Col);
 	return txt;
 }
 
 bool LMail3Store::LStatement::GetBinary(int Col, LVariant *v)
 {
 	if (!v)
 		return false;
 	
 	const void *Ptr = sqlite3_column_blob(s, Col);
 	if (!Ptr)
 		return false;
 	
 	int Bytes = sqlite3_column_bytes(s, Col);	
 	return v->SetBinary(Bytes, (void*)Ptr);
 }
 
 /* All the setter functions use 'Col+1' as the first column is '1' */
 bool LMail3Store::LStatement::SetInt(int Col, int n)
 {
 	if (!IsOk()) return false;
 	if (n == -1)
 		return Store->Check(sqlite3_bind_null(s, Col+1), 0);
 	else
 		return Store->Check(sqlite3_bind_int(s, Col+1, n), 0);
 }
 
 bool LMail3Store::LStatement::SetStr(int Col, const char *Str)
 {
 	if (!IsOk())
 		return false;
 	
 	if (Str)
 		return Store->Check(sqlite3_bind_text(s, Col+1, Str, -1, SQLITE_STATIC), 0);
 	else
 		return Store->Check(sqlite3_bind_null(s, Col+1), 0);
 }
 
 bool LMail3Store::LStatement::SetDate(int Col, LDateTime &Var)
 {
 	if (!Var.Year())
 		return Store->Check(sqlite3_bind_null(s, Col+1), 0);
 
 	char c[64];
 	sprintf_s(c, sizeof(c), "%4.4i-%2.2i-%2.2i %2.2i:%2.2i:%2.2i", Var.Year(), Var.Month(), Var.Day(), Var.Hours(), Var.Minutes(), Var.Seconds());
 	return Store->Check(sqlite3_bind_text(s, Col+1, (const char*)c, -1, SQLITE_TRANSIENT), 0);
 };
 
 bool LMail3Store::LStatement::SetStream(int Col, const char *ColName, LStreamI *Data)
 {
 	if (!IsOk() || !Data)
 		return false;
 
 	PostBlob &p = Post.New();
 	p.ColName = ColName;
 	p.Data = Data;
 	p.Size = Data->GetSize();
 
 	LAssert((p.Size & 0xffffffff00000000) == 0);
 	return Store->Check(sqlite3_bind_zeroblob(s, Col+1, (int)p.Size), 0);
 }
 
 bool LMail3Store::LStatement::SetBinary(int Col, const char *ColName, LVariant *v)
 {
 	if (!v || v->Type != GV_BINARY)
 	{
 		LAssert(!"Invalid binary type.");
 		return false;
 	}
 	
 	if (!Store->Check(sqlite3_bind_blob(s, Col+1, v->Value.Binary.Data, (int)v->Value.Binary.Length, SQLITE_TRANSIENT), NULL))
 		return false;
 		
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////
 LMail3Store::LTransaction::LTransaction(LMail3Store *store)
 {
 	Store = store;
 	
 	const char *Sql = "begin;";
 	Open = Store ? Store->Check(sqlite3_exec(Store->GetDb(), Sql, 0, 0, 0), Sql) : false;
 }
 
 LMail3Store::LTransaction::~LTransaction()
 {
 	if (Open)
 	{
 		const char *Sql = "end;";
 		Store->Check(sqlite3_exec(Store->GetDb(), Sql, 0, 0, 0), Sql);
 	}
 }
 
 bool LMail3Store::LTransaction::RollBack()
 {
 	bool Status = false;
 
 	if (Open)
 	{
 		const char *Sql = "rollback;";
 		Status = Store->Check(sqlite3_exec(Store->GetDb(), Sql, 0, 0, 0), Sql);
 		Open = false;
 	}
 
 	return Status;
 }
 
 /////////////////////////////////////////////////////////////////////////
 LDataStoreI *OpenMail3(const char *Mail3Folder, LDataEventsI *Callback, bool Create)
 {
 	return new LMail3Store(Mail3Folder, Callback, Create);
 }
diff --git a/win/Scribe_vs2019.vcxproj b/win/Scribe_vs2019.vcxproj
--- a/win/Scribe_vs2019.vcxproj
+++ b/win/Scribe_vs2019.vcxproj
@@ -1,733 +1,734 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Debug|x64">
       <Configuration>Debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="ReleaseNoOptimize|Win32">
       <Configuration>ReleaseNoOptimize</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="ReleaseNoOptimize|x64">
       <Configuration>ReleaseNoOptimize</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|Win32">
       <Configuration>Release</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|x64">
       <Configuration>Release</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectName>Scribe</ProjectName>
     <ProjectGuid>{540DDE64-0927-4E67-B927-2E3BE7ECB029}</ProjectGuid>
     <RootNamespace>Scribe_vc8</RootNamespace>
     <Keyword>Win32Proj</Keyword>
     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
     <_ProjectFileVersion>12.0.30501.0</_ProjectFileVersion>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <PreLinkEventUseInBuild>false</PreLinkEventUseInBuild>
     <LinkIncremental>true</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;C:\Office 2010 Developer Resources\include;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\src;..\Resources;..\src\Sqlite;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\include;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\private\common;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\libpng\build32;..\..\..\..\CodeLib\libpng\build32\zlib_dir;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;..\..\libs\mapi;..\..\libs\libchardet\src;..\..\libs\libchardet\include;c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\mapi;c:\Program Files (x86)\OpenSSL\include;%(AdditionalIncludeDirectories);Utils\Tables</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN32;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <PrecompiledHeader />
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <ShowIncludes>false</ShowIncludes>
     </ClCompile>
     <PreLinkEvent>
       <Message>Update version</Message>
       <Command>cd Code\Py
 "C:\Program Files\Python36\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat"
 rc Resource.rc
 cd ..
 copy Code\Resource.res $(OutDir)
 </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet14x32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x32;..\..\..\Lgi\trunk\lib;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX86</TargetMachine>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\src;..\src\Sqlite;..\Resources;..\Utils\Tables;..\..\libs\mapi;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\build-x64\libiconv-1.17\include;..\..\libs\build-x64\libpng\zlib_dir;..\..\libs\build-x64\libpng;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\private\common;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\include;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;c:\Program Files\OpenSSL\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN64;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <SupportJustMyCode>true</SupportJustMyCode>
     </ClCompile>
     <PreLinkEvent>
       <Command>
       </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet19x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x64;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;..\..\..\Lgi\trunk\lib;..\..\..\CodeLib\protobuf-3.9.1\cmake\build\solution\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX64</TargetMachine>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
       <VerboseOutput>true</VerboseOutput>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\src;..\Resources;..\src\Sqlite;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\include;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\private\common;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\libpng\build32;..\..\..\..\CodeLib\libpng\build32\zlib_dir;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;..\..\libs\mapi;c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\mapi;c:\Program Files (x86)\OpenSSL\include;%(AdditionalIncludeDirectories);Utils\Tables;..\crashpad-release-x86-64-stable\include;..\crashpad-release-x86-64-stable\include\mini_chromium</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN32;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader />
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <PreLinkEvent>
       <Command>cd Code\Py
 "C:\Python37\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat"
 rc Resource.rc
 cd ..
 copy Code\Resource.res $(OutDir)
 </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet14x32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x32;..\..\..\Lgi\trunk\lib;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX86</TargetMachine>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <AdditionalIncludeDirectories>..\src;..\src\Sqlite;..\Resources;..\Utils\Tables;..\..\libs\mapi;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\build-x64\libiconv-1.17\include;..\..\libs\build-x64\libpng\zlib_dir;..\..\libs\build-x64\libpng;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\private\common;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\include;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;c:\Program Files\OpenSSL\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN64;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level1</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <Optimization>MinSpace</Optimization>
       <SupportJustMyCode>true</SupportJustMyCode>
     </ClCompile>
     <PreLinkEvent>
       <Command>cd ..\src\Py
 "C:\Program Files\Python39\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"
 rc Resource.rc
 copy Resource.res ..\win\$(OutDir)</Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet19x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x64;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;..\..\..\Lgi\trunk\lib;..\..\..\CodeLib\protobuf-3.9.1\cmake\build\solution\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX64</TargetMachine>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\src;..\Resources;..\src\Sqlite;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\include;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\private\common;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\libpng\build32;..\..\..\..\CodeLib\libpng\build32\zlib_dir;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;..\..\libs\mapi;c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\mapi;c:\Program Files (x86)\OpenSSL\include;%(AdditionalIncludeDirectories);Utils\Tables;..\crashpad-release-x86-64-stable\include;..\crashpad-release-x86-64-stable\include\mini_chromium</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN32;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader />
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <PreLinkEvent>
       <Message>Update Version</Message>
       <Command>cd Code\Py
 "C:\Python37\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat"
 rc Resource.rc
 cd ..
 copy Code\Resource.res $(OutDir)
 </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet14x32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x32;..\..\..\Lgi\trunk\lib;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX86</TargetMachine>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <AdditionalIncludeDirectories>..\src;..\src\Sqlite;..\Resources;..\Utils\Tables;..\..\libs\mapi;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\build-x64\libiconv-1.17\include;..\..\libs\build-x64\libpng\zlib_dir;..\..\libs\build-x64\libpng;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\private\common;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\include;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;c:\Program Files\OpenSSL\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN64;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level1</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <Optimization>MinSpace</Optimization>
       <SupportJustMyCode>true</SupportJustMyCode>
     </ClCompile>
     <PreLinkEvent>
       <Command>cd ..\src\Py
 "C:\Program Files\Python39\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"
 rc Resource.rc
 copy Resource.res ..\win\$(OutDir)</Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet19x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x64;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;..\..\..\Lgi\trunk\lib;..\..\..\CodeLib\protobuf-3.9.1\cmake\build\solution\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX64</TargetMachine>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\LexCpp.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptCompiler.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptLibrary.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptVM.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\Db-Csv.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\DbTable.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Gif.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Jpeg.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Lzw.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Png.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Tiff.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Font\EmojiFont.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\DrawListSurface.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Tools\GdcTools.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SegmentTree.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SharedMemory.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SoftwareUpdate.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\TimeZone.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\Tnef.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mime.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\HttpTools.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Ftp.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Http.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OAuth2.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\WebDav.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mail.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailHttp.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailImap.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OpenSSLSocket.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\Browser.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\LgiMain.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Storage\3\Store3.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiMap.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiTools.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\Homoglyphs.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\HomoglyphsTable.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Html.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlCommon.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlParser.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\SpellCheckAspell.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\XmlTreeUi.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\RtfHtml.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\TextConvert.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\vCard-vCal.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\BlockCursor.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEdit.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\HorzRuleBlock.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\ImageBlock.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\TextBlock.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ColourSelect.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ControlTree.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\DatePopup.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\FilterUi.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Graph.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\TimePopup.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ZoomView.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\MonthView.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\YearView.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\win\Lgi\SpellCheckWindows.cpp" />
     <ClCompile Include="..\..\libs\Btree\btree.c" />
     <ClCompile Include="..\..\libs\Btree\btree_delete.c" />
     <ClCompile Include="..\..\libs\Btree\btree_header.c" />
     <ClCompile Include="..\..\libs\Btree\btree_insert.c" />
     <ClCompile Include="..\..\libs\Btree\btree_lock.c" />
     <ClCompile Include="..\..\libs\Btree\btree_node.c" />
     <ClCompile Include="..\..\libs\Btree\btree_search.c" />
     <ClCompile Include="..\..\libs\Btree\btree_traverse.c" />
     <ClCompile Include="..\..\libs\Btree\config.c" />
     <ClCompile Include="..\..\libs\Btree\db.c" />
     <ClCompile Include="..\..\libs\Btree\db_blocklist.c" />
     <ClCompile Include="..\..\libs\Btree\db_blocks.c" />
     <ClCompile Include="..\..\libs\Btree\db_cache.c" />
     <ClCompile Include="..\..\libs\Btree\db_header.c" />
     <ClCompile Include="..\..\libs\Btree\db_lock.c" />
     <ClCompile Include="..\..\libs\Btree\db_utils.c" />
     <ClCompile Include="..\..\libs\Btree\gbtree.cpp" />
     <ClCompile Include="..\..\libs\Btree\hashtable.c" />
     <ClCompile Include="..\..\libs\Btree\offsetlist.c" />
     <ClCompile Include="..\src\AddressSelect.cpp" />
     <ClCompile Include="..\src\BayesDlg.cpp" />
     <ClCompile Include="..\src\BayesianFilter.cpp" />
     <ClCompile Include="..\src\Calendar.cpp" />
     <ClCompile Include="..\src\CalendarView.cpp" />
     <ClCompile Include="..\src\Components.cpp" />
     <ClCompile Include="..\src\Encryption\GnuPG.cpp" />
     <ClCompile Include="..\src\Exp_Scribe.cpp" />
     <ClCompile Include="..\src\FolderCalendarSource.cpp" />
     <ClCompile Include="..\src\GBTreeWordStore.cpp" />
     <ClCompile Include="..\src\NewMailDlg.cpp" />
     <ClCompile Include="..\src\RemoteCalendarSource.cpp" />
     <ClCompile Include="..\src\SearchView.cpp" />
     <ClCompile Include="..\src\HtmlToText.cpp" />
     <ClCompile Include="..\src\ImpExp_Mbox.cpp" />
     <ClCompile Include="..\src\ImpExp_Outlook.cpp" />
     <ClCompile Include="..\src\Imp_CsvContacts.cpp" />
     <ClCompile Include="..\src\Imp_Eml.cpp" />
     <ClCompile Include="..\src\Imp_Eudora.cpp" />
     <ClCompile Include="..\src\Imp_Mozilla.cpp" />
     <ClCompile Include="..\src\Imp_NetscapeContacts.cpp" />
     <ClCompile Include="..\src\Imp_OutlookExpress.cpp" />
     <ClCompile Include="..\src\ManageMailStores.cpp" />
     <ClCompile Include="..\src\MContainer.cpp" />
     <ClCompile Include="..\src\ObjectInspector.cpp" />
     <ClCompile Include="..\src\OptionsDlg.cpp" />
     <ClCompile Include="..\src\PreviewPanel.cpp" />
     <ClCompile Include="..\src\PrintContext.cpp" />
     <ClCompile Include="..\src\PrintPreview.cpp" />
     <ClCompile Include="..\src\ReplicateDlg.cpp" />
     <ClCompile Include="..\src\ScribeAbout.cpp" />
     <ClCompile Include="..\src\ScribeAccount.cpp" />
     <ClCompile Include="..\src\ScribeAccountPreview.cpp" />
     <ClCompile Include="..\src\ScribeAccountUI.cpp" />
     <ClCompile Include="..\src\ScribeApp.cpp" />
     <ClCompile Include="..\src\ScribeAttachment.cpp" />
     <ClCompile Include="..\src\ScribeContact.cpp" />
     <ClCompile Include="..\src\ScribeFilter.cpp" />
     <ClCompile Include="..\src\ScribeFinder.cpp" />
     <ClCompile Include="..\src\ScribeFolder.cpp" />
     <ClCompile Include="..\src\ScribeFolderDlg.cpp" />
     <ClCompile Include="..\src\ScribeFolderProp.cpp" />
     <ClCompile Include="..\src\ScribeFolderSelect.cpp" />
     <ClCompile Include="..\src\ScribeFolderTree.cpp" />
     <ClCompile Include="..\src\ScribeGroup.cpp" />
     <ClCompile Include="..\src\ScribeItemList.cpp" />
     <ClCompile Include="..\src\ScribeLangDlg.cpp" />
     <ClCompile Include="..\src\ScribeListAddr.cpp" />
     <ClCompile Include="..\src\ScribeMail.cpp" />
     <ClCompile Include="..\src\ScribeMain.cpp" />
     <ClCompile Include="..\src\ScribePageSetup.cpp" />
     <ClCompile Include="..\src\ScribePassword.cpp" />
     <ClCompile Include="..\src\ScribeSendReceive.cpp" />
     <ClCompile Include="..\src\ScribeSockets.cpp" />
     <ClCompile Include="..\src\ScribeStatusPanel.cpp" />
     <ClCompile Include="..\src\ScribeThing.cpp" />
     <ClCompile Include="..\src\ScribeUi.cpp" />
     <ClCompile Include="..\src\ScribeUtils.cpp" />
     <ClCompile Include="..\src\Scripting.cpp" />
     <ClCompile Include="..\src\SecurityDlg.cpp" />
     <ClCompile Include="..\src\Sqlite\v3.41.2\sqlite3.c" />
     <ClCompile Include="..\src\Store3Common.cpp" />
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Attachment.cpp" />
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Folder.cpp" />
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Mail.cpp" />
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Store.cpp" />
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Thread.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Attachment.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Calendar.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Contact.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Filter.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Folder.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Group.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Mail.cpp" />
     <ClCompile Include="..\src\Store3Mail3\Mail3Store.cpp" />
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Attachment.cpp" />
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Calendar.cpp" />
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Contact.cpp" />
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Folder.cpp" />
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Mail.cpp" />
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Store.cpp" />
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Thing.cpp" />
     <ClCompile Include="..\src\Store3Webdav\WebdavCalendar.cpp" />
     <ClCompile Include="..\src\Store3Webdav\WebdavContact.cpp" />
     <ClCompile Include="..\src\Store3Webdav\WebdavFolder.cpp" />
     <ClCompile Include="..\src\Store3Webdav\WebdavStore.cpp" />
     <ClCompile Include="..\src\Store3Webdav\WebdavThread.cpp" />
     <ClCompile Include="..\src\TitlePage.cpp" />
     <ClCompile Include="..\Utils\Tables\MailFlags.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LDbTable.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LWebDav.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\OpenSSLSocket.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\ZlibWrapper.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Browser.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ColourSelect.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ControlTree.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DateTimeCtrls.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Db.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DrawListSurface.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Emoji.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\EmojiFont.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\FilterUi.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Ftp.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\GdcTools.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Graph.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Homoglyphs.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Html.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlCommon.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlParser.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Http.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HttpTools.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mail.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mime.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OAuth2.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OpenSSLSocket.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\RichTextEdit.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Scripting.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SegmentTree.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SharedMemory.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SoftwareUpdate.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SpellCheck.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3Defs.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3MimeTree.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\StoreCommon.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\TextConvert.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Tnef.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\WebDav.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\XmlTreeUi.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ZoomView.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\Instructions.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptingPriv.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.h" />
     <ClInclude Include="..\..\libs\Btree\btree.h" />
     <ClInclude Include="..\..\libs\Btree\btree_header.h" />
     <ClInclude Include="..\..\libs\Btree\btree_lock.h" />
     <ClInclude Include="..\..\libs\Btree\btree_node.h" />
     <ClInclude Include="..\..\libs\Btree\config.h" />
     <ClInclude Include="..\..\libs\Btree\db.h" />
     <ClInclude Include="..\..\libs\Btree\db_blocklist.h" />
     <ClInclude Include="..\..\libs\Btree\db_blocks.h" />
     <ClInclude Include="..\..\libs\Btree\db_cache.h" />
     <ClInclude Include="..\..\libs\Btree\db_header.h" />
     <ClInclude Include="..\..\libs\Btree\db_internal.h" />
     <ClInclude Include="..\..\libs\Btree\db_lock.h" />
     <ClInclude Include="..\..\libs\Btree\db_types.h" />
     <ClInclude Include="..\..\libs\Btree\db_utils.h" />
     <ClInclude Include="..\..\libs\Btree\gbtree.h" />
     <ClInclude Include="..\..\libs\Btree\hashtable.h" />
     <ClInclude Include="..\..\libs\Btree\offsetlist.h" />
     <ClInclude Include="..\src\BayesianFilter.h" />
     <ClInclude Include="..\src\Calendar.h" />
     <ClInclude Include="..\src\CalendarView.h" />
     <ClInclude Include="..\src\Components.h" />
     <ClInclude Include="..\src\DomFields.h" />
     <ClInclude Include="..\src\DomType.h" />
     <ClInclude Include="..\src\DomTypeValues.h" />
     <ClInclude Include="..\src\Encryption\GnuPG.h" />
+    <ClInclude Include="..\src\FolderTask.h" />
     <ClInclude Include="..\src\Imp_Outlook.h" />
     <ClInclude Include="..\src\ManageMailStores.h" />
     <ClInclude Include="..\src\ObjectInspector.h" />
     <ClInclude Include="..\src\PreviewPanel.h" />
     <ClInclude Include="..\src\PrintContext.h" />
     <ClInclude Include="..\src\PrintPreview.h" />
     <ClInclude Include="..\src\ReplicateDlg.h" />
     <ClInclude Include="..\src\Scribe.h" />
     <ClInclude Include="..\src\ScribeAccountPreview.h" />
     <ClInclude Include="..\src\ScribeAccountUI.h" />
     <ClInclude Include="..\src\ScribeDefs.h" />
     <ClInclude Include="..\src\ScribeFolderDlg.h" />
     <ClInclude Include="..\src\ScribeFolderSelect.h" />
     <ClInclude Include="..\src\ScribeInc.h" />
     <ClInclude Include="..\src\ScribeListAddr.h" />
     <ClInclude Include="..\src\ScribePageSetup.h" />
     <ClInclude Include="..\src\ScribePrivate.h" />
     <ClInclude Include="..\src\ScribeStatusPanel.h" />
     <ClInclude Include="..\src\ScribeUtils.h" />
     <ClInclude Include="..\src\Sqlite\v3.41.2\sqlite3.h" />
     <ClInclude Include="..\src\Sqlite\v3.41.2\sqlite3ext.h" />
     <ClInclude Include="..\src\Store3Imap\include\Scribe.pb.h" />
     <ClInclude Include="..\src\Store3Imap\ScribeImap.h" />
     <ClInclude Include="..\src\Store3Mail3\Mail3.h" />
     <ClInclude Include="..\src\Store3Mapi\ScribeMapi.h" />
     <ClInclude Include="..\src\Store3Webdav\WebdavStore.h" />
     <ClInclude Include="..\src\Store3Webdav\WebdavStorePriv.h" />
     <ClInclude Include="..\Scripts\ScribeScripts.h" />
     <ClInclude Include="..\Utils\Tables\Tables.h" />
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="..\..\..\Lgi\trunk\src\common\Coding\ExternCall.asm">
       <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">cd $(IntDir)
 "c:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\ml64.exe" %(FullPath) /c</Command>
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(IntDir)%(Filename).obj;%(Outputs)</Outputs>
       <Command Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">cd $(IntDir)
 "c:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\ml64.exe" %(FullPath) /c</Command>
       <Outputs Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">$(IntDir)%(Filename).obj;%(Outputs)</Outputs>
       <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">cd $(IntDir)
 "c:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64\ml64.exe" %(FullPath) /c</Command>
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(IntDir)%(Filename).obj;%(Outputs)</Outputs>
     </CustomBuild>
     <None Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\gen.py" />
     <None Include="..\..\libs\build.py" />
     <None Include="..\src\Encryption\Examples\encrypted+attach.eml" />
     <None Include="..\src\Encryption\Examples\encrypted+html+attach+key.eml" />
     <None Include="..\src\Encryption\Examples\encrypted.eml" />
     <None Include="..\src\Encryption\Examples\signed+attach.eml" />
     <None Include="..\src\Encryption\Examples\signed+encrypted.eml" />
     <None Include="..\src\Encryption\Examples\signed+HTML+attach+key.eml" />
     <None Include="..\src\Encryption\Examples\signed+html.eml" />
     <None Include="..\src\Encryption\Examples\signed.eml" />
     <None Include="..\src\Py\DomScan.py" />
     <None Include="..\src\Py\win32_pre_build_step.py" />
     <None Include="..\src\Store3Imap\Scribe.proto" />
     <None Include="..\Help\calendar.html" />
     <None Include="..\Help\contacts.html" />
     <None Include="..\Help\email.html" />
     <None Include="..\Help\features.html" />
     <None Include="..\Help\filters.html" />
     <None Include="..\Help\help.css" />
     <None Include="..\Help\import.html" />
     <None Include="..\Help\index.html" />
     <None Include="..\Help\install.html" />
     <None Include="..\Help\intro.html" />
     <None Include="..\Help\menu.html" />
     <None Include="..\Help\plugins.html" />
     <None Include="..\Help\print.html" />
     <None Include="..\Help\scripting.html" />
     <None Include="..\Help\ui.html" />
     <None Include="..\Resources\About.html" />
     <None Include="..\Resources\PreviewContact.html" />
     <None Include="..\Resources\PreviewGroup.html" />
     <None Include="..\Resources\PreviewMail.html" />
     <None Include="..\Resources\Themes\Dark\colours.json" />
     <None Include="..\Resources\Themes\Dark\styles.css" />
     <None Include="..\Resources\Title.html" />
     <None Include="..\Scripts\Add Senders To Contacts.script" />
     <None Include="..\Scripts\CovieRender.script" />
     <None Include="..\Scripts\DecrementAll.script" />
     <None Include="..\Scripts\Delete Attachments.script" />
     <None Include="..\Scripts\Delete Duplicate Messages.script" />
     <None Include="..\Scripts\LdapPlugin.script" />
     <None Include="..\Scripts\Mail Filters Menu.script" />
     <None Include="..\Utils\Store\check-build.py" />
     <None Include="..\Utils\Store\store.py" />
     <None Include="Installer-64bit.nsi" />
     <None Include="Installer-64bit.nsi.in" />
   </ItemGroup>
   <ItemGroup>
     <Image Include="..\Resources\Icons\app.ico" />
     <Image Include="..\Resources\Icons\Blank.ico" />
     <Image Include="..\Resources\Icons\calender.ico" />
     <Image Include="..\Resources\Icons\contact.ico" />
     <Image Include="..\Resources\Icons\error.ico" />
     <Image Include="..\Resources\Icons\event.ico" />
     <Image Include="..\Resources\Icons\filter.ico" />
     <Image Include="..\Resources\Icons\Mail.ico" />
     <Image Include="..\Resources\Icons\Small.ico" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="..\src\Resource.rc" />
   </ItemGroup>
   <ItemGroup>
     <Manifest Include="..\Resources\ScribeWindows.manifest" />
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\Utils\Tables\MailFlags.txt" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\Lgi\trunk\win\Lgi_vs2019.vcxproj">
       <Project>{95df9ca4-6d37-4a85-a648-80c2712e0da1}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\..\lgi\trunk\src\common\Net\libntlm-0.4.2\build-win32\libntlm_vs2019.vcxproj">
       <Project>{f97aaaca-bf41-46b8-b534-a1639589a1a3}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\..\Lgi\trunk\utils\Updater\Updater_vs2019.vcxproj">
       <Project>{11e9238b-921e-44e5-a3d2-61c5bfa7cc6c}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\libs\aspell-0.60.6.1\win32\dist\aspell-dist-0.60-vs2019.vcxproj">
       <Project>{1509fe6d-0b3a-422a-99d1-e26a26ce8da5}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\libs\bzip2-1.0.6\windows\bzip2-1.0.6-vs2019.vcxproj">
       <Project>{e5575141-c1a2-4997-badb-7584cf546e1f}</Project>
     </ProjectReference>
     <ProjectReference Include="..\mapi\ScribeMapi_vs2019.vcxproj">
       <Project>{148574ce-4da6-4b8a-9ec6-ff68adc2a046}</Project>
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/win/Scribe_vs2019.vcxproj.filters b/win/Scribe_vs2019.vcxproj.filters
--- a/win/Scribe_vs2019.vcxproj.filters
+++ b/win/Scribe_vs2019.vcxproj.filters
@@ -1,1083 +1,1086 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <ClCompile Include="..\..\libs\Btree\btree_traverse.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_delete.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_header.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_insert.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_lock.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_node.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_search.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_blocklist.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_blocks.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_cache.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_header.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_lock.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_utils.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\gbtree.cpp">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiMap.cpp">
       <Filter>Emoji</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiTools.cpp">
       <Filter>Emoji</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Font\EmojiFont.cpp">
       <Filter>Emoji</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\BlockCursor.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ColourSelect.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ControlTree.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\DatePopup.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\DrawListSurface.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\FilterUi.cpp">
       <Filter>Filtering</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Ftp.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Tools\GdcTools.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Gif.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Graph.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\hashtable.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\HorzRuleBlock.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mime.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\LexCpp.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\offsetlist.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\ImageBlock.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\LgiMain.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OpenSSLSocket.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailHttp.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailImap.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OAuth2.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Png.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEdit.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Storage\3\Store3.cpp">
       <Filter>Store3</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Jpeg.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Lzw.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\config.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\Db-Csv.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\DbTable.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\Homoglyphs.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\HomoglyphsTable.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mail.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\Utils\Tables\MailFlags.c">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\RtfHtml.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptCompiler.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptLibrary.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptVM.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SegmentTree.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SharedMemory.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SoftwareUpdate.cpp">
       <Filter>Install</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\win\Lgi\SpellCheckWindows.cpp">
       <Filter>SpellCheck</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\TextBlock.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\TextConvert.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Tiff.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\Tnef.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\TimePopup.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ZoomView.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\XmlTreeUi.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\WebDav.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\vCard-vCal.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\TimeZone.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\YearView.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\MonthView.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Html.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlCommon.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlParser.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\Browser.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\HttpTools.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Http.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\SpellCheckAspell.cpp">
       <Filter>SpellCheck</Filter>
     </ClCompile>
     <ClCompile Include="..\src\AddressSelect.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\src\BayesDlg.cpp">
       <Filter>Filtering</Filter>
     </ClCompile>
     <ClCompile Include="..\src\BayesianFilter.cpp">
       <Filter>Filtering</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Calendar.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\src\CalendarView.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Components.cpp">
       <Filter>Install</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Exp_Scribe.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\FolderCalendarSource.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\src\GBTreeWordStore.cpp">
       <Filter>Filtering</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Encryption\GnuPG.cpp">
       <Filter>Encryption</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Imp_CsvContacts.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Imp_Eml.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Imp_Eudora.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Imp_Mozilla.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Imp_NetscapeContacts.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Imp_OutlookExpress.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ImpExp_Mbox.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ImpExp_Outlook.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Attachment.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Calendar.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Contact.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Filter.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Folder.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Group.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Mail.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mail3\Mail3Store.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ManageMailStores.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\MContainer.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\src\NewMailDlg.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ObjectInspector.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\OptionsDlg.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\PreviewPanel.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\PrintContext.cpp">
       <Filter>Printing</Filter>
     </ClCompile>
     <ClCompile Include="..\src\PrintPreview.cpp">
       <Filter>Printing</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ReplicateDlg.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeAccount.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeApp.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\RemoteCalendarSource.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeAccountUI.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeFolderProp.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeFolderSelect.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeFolderTree.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Attachment.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Folder.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Mail.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Store.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Imap\ScribeImap_Thread.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeAbout.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeAccountPreview.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeItemList.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeContact.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeAttachment.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeFilter.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeFinder.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeFolder.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeFolderDlg.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeGroup.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeLangDlg.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Attachment.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Calendar.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Contact.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Folder.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Mail.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Store.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Mapi\ScribeMapi_Thing.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeUi.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeThing.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeListAddr.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Sqlite\v3.41.2\sqlite3.c">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Common.cpp">
       <Filter>Store3</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeStatusPanel.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Scripting.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeMail.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Webdav\WebdavCalendar.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Webdav\WebdavContact.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Webdav\WebdavFolder.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Webdav\WebdavStore.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\src\Store3Webdav\WebdavThread.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\src\SecurityDlg.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\TitlePage.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\SearchView.cpp">
       <Filter>User Interface</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribePageSetup.cpp">
       <Filter>Printing</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeMain.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeSendReceive.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeSockets.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribePassword.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\ScribeUtils.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\src\HtmlToText.cpp">
       <Filter>Application</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\libs\Btree\btree.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\btree_header.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\btree_lock.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\btree_node.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_utils.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Db.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_blocklist.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_blocks.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_cache.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_header.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_internal.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_lock.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_types.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\gbtree.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\EmojiFont.h">
       <Filter>Emoji</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Emoji.h">
       <Filter>Emoji</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ColourSelect.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ControlTree.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DateTimeCtrls.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DrawListSurface.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\FilterUi.h">
       <Filter>Filtering</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Ftp.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\GdcTools.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Graph.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\hashtable.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mime.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LDbTable.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\offsetlist.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\OpenSSLSocket.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OpenSSLSocket.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OAuth2.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\RichTextEdit.h">
       <Filter>RichTextEdit</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.h">
       <Filter>RichTextEdit</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Scripting.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\StoreCommon.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3MimeTree.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3Defs.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LWebDav.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\config.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Homoglyphs.h">
       <Filter>Mail</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mail.h">
       <Filter>Mail</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\Instructions.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\Scripts\ScribeScripts.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptingPriv.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SegmentTree.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SharedMemory.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SoftwareUpdate.h">
       <Filter>Install</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SpellCheck.h">
       <Filter>SpellCheck</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\TextConvert.h">
       <Filter>Mail</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Tnef.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\WebDav.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ZoomView.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\XmlTreeUi.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\Utils\Tables\Tables.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\ZlibWrapper.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Html.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlCommon.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlParser.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Browser.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HttpTools.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Http.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\src\BayesianFilter.h">
       <Filter>Filtering</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Calendar.h">
       <Filter>Calendar</Filter>
     </ClInclude>
     <ClInclude Include="..\src\CalendarView.h">
       <Filter>Calendar</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Components.h">
       <Filter>Install</Filter>
     </ClInclude>
     <ClInclude Include="..\src\DomFields.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\DomType.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\DomTypeValues.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Encryption\GnuPG.h">
       <Filter>Encryption</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Imp_Outlook.h">
       <Filter>Import/Export</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Store3Mail3\Mail3.h">
       <Filter>Store3\Mail3</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ManageMailStores.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ObjectInspector.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\PreviewPanel.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\PrintContext.h">
       <Filter>Printing</Filter>
     </ClInclude>
     <ClInclude Include="..\src\PrintPreview.h">
       <Filter>Printing</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ReplicateDlg.h">
       <Filter>Import/Export</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Scribe.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Store3Imap\include\Scribe.pb.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeAccountUI.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeFolderSelect.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Store3Imap\ScribeImap.h">
       <Filter>Store3\Imap</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeAccountPreview.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeDefs.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeFolderDlg.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeInc.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Store3Mapi\ScribeMapi.h">
       <Filter>Store3\Mapi</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeListAddr.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Sqlite\v3.41.2\sqlite3.h">
       <Filter>Store3\Mail3</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Sqlite\v3.41.2\sqlite3ext.h">
       <Filter>Store3\Mail3</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeStatusPanel.h">
       <Filter>User Interface</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Store3Webdav\WebdavStore.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\src\Store3Webdav\WebdavStorePriv.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribePageSetup.h">
       <Filter>Printing</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribePrivate.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\src\ScribeUtils.h">
       <Filter>Application</Filter>
     </ClInclude>
+    <ClInclude Include="..\src\FolderTask.h">
+      <Filter>Application</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Image Include="..\Resources\Icons\app.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\Blank.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\event.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\error.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\Small.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\calender.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\contact.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\filter.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\Mail.ico">
       <Filter>Resources</Filter>
     </Image>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\Resources\About.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\email.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\features.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\filters.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\intro.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\install.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\index.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\import.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\calendar.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\contacts.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\ui.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Resources\Themes\Dark\styles.css">
       <Filter>Help</Filter>
     </None>
     <None Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\gen.py">
       <Filter>Scripting</Filter>
     </None>
     <None Include="..\Resources\Themes\Dark\colours.json">
       <Filter>Resources</Filter>
     </None>
     <None Include="..\Help\menu.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\plugins.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\help.css">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\print.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\scripting.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Resources\Title.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Utils\Store\check-build.py">
       <Filter>Install</Filter>
     </None>
     <None Include="..\Utils\Store\store.py">
       <Filter>Install</Filter>
     </None>
     <None Include="..\..\libs\build.py">
       <Filter>Install</Filter>
     </None>
     <None Include="Installer-64bit.nsi">
       <Filter>Install</Filter>
     </None>
     <None Include="..\Scripts\Add Senders To Contacts.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\CovieRender.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\Delete Attachments.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\DecrementAll.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\Delete Duplicate Messages.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\LdapPlugin.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\Mail Filters Menu.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="Installer-64bit.nsi.in">
       <Filter>Install</Filter>
     </None>
     <None Include="..\Resources\PreviewContact.html">
       <Filter>Controls/UI\PreviewPanel</Filter>
     </None>
     <None Include="..\Resources\PreviewMail.html">
       <Filter>Controls/UI\PreviewPanel</Filter>
     </None>
     <None Include="..\Resources\PreviewGroup.html">
       <Filter>Controls/UI\PreviewPanel</Filter>
     </None>
     <None Include="..\src\Py\DomScan.py">
       <Filter>Install</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\encrypted.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\encrypted+html+attach+key.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\encrypted+attach.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Store3Imap\Scribe.proto">
       <Filter>Application</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\signed.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\signed+attach.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\signed+encrypted.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\signed+html.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Encryption\Examples\signed+HTML+attach+key.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\src\Py\win32_pre_build_step.py">
       <Filter>Application</Filter>
     </None>
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\Utils\Tables\MailFlags.txt">
       <Filter>Scripting</Filter>
     </Text>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="BTree">
       <UniqueIdentifier>{28943112-0c58-468a-b315-7696092c8778}</UniqueIdentifier>
     </Filter>
     <Filter Include="Help">
       <UniqueIdentifier>{f16baf81-af69-4eb1-9faf-6f448a36a13b}</UniqueIdentifier>
     </Filter>
     <Filter Include="Scripting">
       <UniqueIdentifier>{ffd46a02-1aed-411d-a961-754cfaf46299}</UniqueIdentifier>
     </Filter>
     <Filter Include="Resources">
       <UniqueIdentifier>{cac512da-cfa7-4bbe-b5be-14a1d31848fb}</UniqueIdentifier>
     </Filter>
     <Filter Include="Calendar">
       <UniqueIdentifier>{15bf5500-86f7-4217-ad50-dfc441b2fb89}</UniqueIdentifier>
     </Filter>
     <Filter Include="TestCases">
       <UniqueIdentifier>{c8868eeb-fe8d-42a2-a647-9df3bff160c4}</UniqueIdentifier>
     </Filter>
     <Filter Include="Emoji">
       <UniqueIdentifier>{111097d8-3c3a-4fb4-a418-548f08670ade}</UniqueIdentifier>
     </Filter>
     <Filter Include="Lgi">
       <UniqueIdentifier>{3347deb8-7d16-4010-9dff-676bafee8413}</UniqueIdentifier>
     </Filter>
     <Filter Include="Controls/UI">
       <UniqueIdentifier>{84e29f91-6e12-481b-8d4c-18e499c9a501}</UniqueIdentifier>
     </Filter>
     <Filter Include="Filtering">
       <UniqueIdentifier>{1d79521d-1efc-4656-bec1-13973241c432}</UniqueIdentifier>
     </Filter>
     <Filter Include="RichTextEdit">
       <UniqueIdentifier>{90145701-794d-4956-af76-5cc116600a6e}</UniqueIdentifier>
     </Filter>
     <Filter Include="Import/Export">
       <UniqueIdentifier>{963cf563-311f-4292-8aef-947945b63c15}</UniqueIdentifier>
     </Filter>
     <Filter Include="Encryption">
       <UniqueIdentifier>{762f00ae-b360-4e54-b181-857af25a6490}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3">
       <UniqueIdentifier>{98c796a3-d418-4adb-b8f8-1a51e8349d96}</UniqueIdentifier>
     </Filter>
     <Filter Include="Network">
       <UniqueIdentifier>{9f3b229f-b2f8-4bbb-897c-f048d35571d4}</UniqueIdentifier>
     </Filter>
     <Filter Include="Graphics">
       <UniqueIdentifier>{2c79f6d5-53c2-454d-b897-0a6779024c02}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\Mail3">
       <UniqueIdentifier>{8139c7b4-9593-48c3-98af-a0db78c410aa}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\Imap">
       <UniqueIdentifier>{d7ace5ac-018a-4ae6-882e-652cf33d3f50}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\Mapi">
       <UniqueIdentifier>{2431021b-92a9-444c-9796-2b1e7d81bd5a}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\WebDav">
       <UniqueIdentifier>{b63a6ed6-bb9e-4538-95f8-2f7782e199eb}</UniqueIdentifier>
     </Filter>
     <Filter Include="Install">
       <UniqueIdentifier>{7b5dbea7-b971-4a65-a5f5-e12726480450}</UniqueIdentifier>
     </Filter>
     <Filter Include="Mail">
       <UniqueIdentifier>{432fd674-ec47-4cfc-afdf-d60b633feb48}</UniqueIdentifier>
     </Filter>
     <Filter Include="Application">
       <UniqueIdentifier>{dbfbd2a8-e411-4b43-a188-bde8cd1ac292}</UniqueIdentifier>
     </Filter>
     <Filter Include="SpellCheck">
       <UniqueIdentifier>{cc8997f1-f092-4b82-a5e5-a3bcc92846ce}</UniqueIdentifier>
     </Filter>
     <Filter Include="Controls/UI\Html">
       <UniqueIdentifier>{6fbe15c0-133a-4ae9-a441-03a9dcafe050}</UniqueIdentifier>
     </Filter>
     <Filter Include="Scripting\Scripts">
       <UniqueIdentifier>{4fd600f1-77c6-4b58-b9a8-85d436233d52}</UniqueIdentifier>
     </Filter>
     <Filter Include="Controls/UI\PreviewPanel">
       <UniqueIdentifier>{22d7ec0d-a127-4b05-b6f0-937c3255224a}</UniqueIdentifier>
     </Filter>
     <Filter Include="User Interface">
       <UniqueIdentifier>{8fc43a66-4c8f-4df4-a79b-195ac2b933f6}</UniqueIdentifier>
     </Filter>
     <Filter Include="Printing">
       <UniqueIdentifier>{0bbd47dc-9bff-40f0-9d61-182a4dc33ff7}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="..\..\..\Lgi\trunk\src\common\Coding\ExternCall.asm">
       <Filter>Scripting</Filter>
     </CustomBuild>
   </ItemGroup>
   <ItemGroup>
     <Manifest Include="..\Resources\ScribeWindows.manifest">
       <Filter>Scripting</Filter>
     </Manifest>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="..\src\Resource.rc">
       <Filter>Resources</Filter>
     </ResourceCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file