diff --git a/Code/Exp_Scribe.cpp b/Code/Exp_Scribe.cpp
--- a/Code/Exp_Scribe.cpp
+++ b/Code/Exp_Scribe.cpp
@@ -1,954 +1,779 @@
 
 #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 "../Resources/resdefs.h"
 #include "FolderTask.h"
 
-/*
-
-	int CountItems(ScribeFolder *f, bool Children)
-	{
-		int Status = 0;
-
-		if (f && f->Store)
-		{
-			for (StorageItem *i = f->Store->GetChild(); i; i = i->GetNext())
-			{
-				if (i->GetType() == MAGIC_MAIL ||
-					i->GetType() == MAGIC_CONTACT)
-				{
-					Status++;
-				}
-			}
-
-			if (Children)
-			{
-				for (ScribeFolder *c = f->GetChildFolder(); c; c = c->GetNextFolder())
-				{
-					if ((!Spam || c != Spam) &&
-						(!Trash || c != Trash))
-					{
-						Status += CountItems(c, Children);
-					}
-				}
-			}
-		}
-
-		return Status;
-	}
-
-*/
+#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)
 	{
-		int asd=0;
 	}
 
 	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();
 	}
 
-	ScribeFolder *GetFolder(LString Path, Store3ItemTypes CreateItemType = MAGIC_NONE)
+	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)
-		{
-			LAssert(!"No root loaded.");
-			return NULL;
-		}
-
-		auto parts = Path.SplitDelimit("/");
-		ScribeFolder *f = Root;
-		for (auto p: parts)
-		{
-			auto c = f->GetSubFolder(p);
-			if (!c)
-			{
-				if (CreateItemType != MAGIC_NONE)
-				{
-					c = f->CreateSubDirectory(p, CreateItemType);
-					if (!c)
-						return NULL;
-				}
-				else return NULL;
-			}
-
-			f = c;
-		}
-
-		return f;
+			return false;
+		return CheckDirty(Root);
 	}
 };
 
 struct ScribeExportTask : public FolderTask
 {
 	int FolderLoadErrors = 0;
 
-	int MailCreated = 0;
-	int MailSkipped = 0;
-	int MailErrors = 0;
-
-	int ContactCreated = 0;
-	int ContactSkipped = 0;
-	int ContactErrors = 0;
-
-	int ObjectCreated = 0;
-	int ObjectErrors = 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*> DstMsgIds;
 
 	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;
+		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);
+					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()
 	{
-		LgiMsg(	this,
-				"Mail export complete.\n"
-				"\n"
-				"    Email: %i created, %i already exist, %i errors\n"
-				"    Contacts: %i created, %i already exist, %i errors",
-				"Export",
-				MB_OK,
-				MailCreated,
-				MailSkipped,
-				MailErrors,
-				ContactCreated,
-				ContactSkipped,
-				ContactErrors);
+		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>Object <th>Created <th>Errors <th>Skipped </tr>\n");
+		for (int i=0; i<CountOf(types); i++)
+		{
+			auto type    = types[i];
+			auto name    = Store3ItemTypeName(type);
+			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, created, errStyle, errors, skipped);
+		}
+
+		html.Print("</table></body>\n");
+
+		LHtmlMsg(NULL, this, html.NewGStr(), "Export", MB_OK);
 	}
 };
 
 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; }
 
-/*
-void ScribeExportTask::ExportFolder(LString ToPath,
-									LString FromPath,
-									bool Children,
-									LProgressDlg *Prog,
-									std::function<void(bool)> onStatus)
-{
-	if (!ToPath || !FromPath)
-		ExportFolderStatus(false);
-
-	ScribeFolder *From = App->GetFolder(FromPath);
-	if (!From)
-		ExportFolderStatus(false);
-
-	if (!((!Spam  || From != Spam) &&
-		(!Trash || From != Trash)))
-		ExportFolderStatus(false);
-
-	ScribeFolder *To = GetFolder(ToPath, From);
-	if (!To)
-		ExportFolderStatus(false);
-
-	bool FromLoaded = From->IsLoaded();
-	bool ToLoaded = From->IsLoaded();
-
-	auto ProcessItem = [this, To, Prog, FromPath, From, FromLoaded, ToLoaded, Children, ToPath, onStatus]()
-	{
-		bool Status = true;
-
-
-		if (!FromLoaded)
-		{
-			From->UnloadThings();
-		}
-		if (!ToLoaded)
-		{
-			To->UnloadThings();
-		}
-
-		if (Children)
-		{
-			char t[256];
-			char f[256];
-			LString n;
-
-			for (ScribeFolder *c = From->GetChildFolder(); c && (!Prog || !Prog->IsCancelled()); c = c->GetNextFolder())
-			{
-				n = c->GetName(true);
-				if (n)
-				{
-					strcpy_s(t, sizeof(t), ToPath);
-					char *e = t + strlen(t) - 1;
-					if (*e++ != '/') *e++ = '/';
-					strcpy_s(e, sizeof(t)-(e-t), n);
-
-					strcpy_s(f, sizeof(f), FromPath);
-					e = f + strlen(f) - 1;
-					if (*e++ != '/') *e++ = '/';
-					strcpy_s(e, sizeof(f)-(e-f), n);
-									
-					ExportFolder(t, f, true, Prog, [](auto ok){});
-				}
-			}
-		}
-	};
-
-	To->LoadThings(NULL, [From, ProcessItem](auto status)
-	{
-		From->LoadThings(NULL, [ProcessItem](auto status)
-		{
-			ProcessItem();
-		});
-	});
-}
-
-bool ScribeExportTask::ExportThing()
-{
-	switch ((uint32_t)SrcFolder->GetItemType())
-	{
-		case MAGIC_MAIL:
-		{
-			int InitMailErrors = MailErrors;
-								
-			for (auto t: From->Items)
-			{
-				if (Prog && Prog->IsCancelled())
-					break;
-									
-				Mail *m = t->IsMail();
-				if (m)
-				{
-					auto Id = m->GetMessageId(true);
-					if (Id)
-					{
-						if (!ToMsgs.Find(Id))
-						{
-							// Create new mail...
-							Mail *n = new Mail(App);
-							if (n)
-							{
-								*n = (Thing&)*m;
-								n->SetParentFolder(To);
-								n->SetObject(To->GetObject()->GetStore()->Create(MAGIC_MAIL), false, _FL);
-								if (n->GetObject())
-								{
-									MailCreated++;
-
-									// Now create all the attachments
-									List<Attachment> Att;
-									if (m->GetAttachments(&Att))
-									{
-										for (auto OldAttachment: Att)
-										{
-											Attachment *NewAttachment = new Attachment(m->App, OldAttachment);
-											if (NewAttachment)
-											{
-												n->AttachFile(NewAttachment);
-												NewAttachment->SetObject(n->GetObject()->GetStore()->Create(MAGIC_ATTACHMENT), false, _FL);
-											}
-										}
-									}
-								}
-								else MailErrors++;
-
-							}
-							else MailErrors++;
-						}
-						else MailSkipped++;
-					}
-					else MailErrors++;
-				}
-
-				if (Prog)
-					Prog->Value(Prog->Value() + 1);
-			}
-
-			Status |= MailErrors == InitMailErrors;
-			break;
-		}
-		case MAGIC_CONTACT:
-		{
-			LHashTbl<StrKey<char>,Contact*> ToContacts;
-			for (auto t: To->Items)
-			{
-				Contact *c = t->IsContact();
-				if (c)
-				{
-					auto k = ContactKey(c);
-					if (k)
-						ToContacts.Add(k, c);
-				}
-			}
-
-			int InitContactErrors = ContactErrors;
-			uint64 Last = LCurrentTime();
-			for (auto t: From->Items)
-			{
-				if (Prog && Prog->IsCancelled())
-					break;
-										
-				Contact *c = t->IsContact();
-				if (c)
-				{
-					auto k = ContactKey(c);
-					if (k)
-					{
-						if (!ToContacts.Find(k))
-						{
-							Contact *n = new Contact(App);
-							if (n)
-							{
-								*n = (Thing&)*c;
-								n->SetParentFolder(To);
-							}
-							else ContactErrors++;
-						}
-						else ContactSkipped++;
-					}
-					else ContactErrors++;
-				}
-
-				if (Prog)
-					Prog->Value(Prog->Value() + 1);
-			}
-
-			Status |= ContactErrors == InitContactErrors;
-			break;
-		}
-}
-*/
-
 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;
 			}
 
+			auto Path = SrcFolder->GetPath();
+			if (Stristr(Path.Get(), "/Inbox"))
+			{
+				int asd=0;
+			}
+
 			DstStore = NULL;
-			DstFolder = Dst.GetFolder(dst, SrcFolder->GetItemType());
+			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(DstFolder->GetPath());
+							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?");
 
 							DstMsgIds.Empty();
 							if (DstFolder->GetItemType() == MAGIC_MAIL)
 							{
 								// Make a map of destination folder message IDs
 								if (DstObj)
 								{
 									auto &c = DstObj->Children();
 									for (auto t = c.First(); t; t = c.Next())
 									{
 										if (t->Type() != MAGIC_MAIL)
 											continue;
 
 										auto Id = t->GetStr(FIELD_MESSAGE_ID);
 										if (Id)
 											DstMsgIds.Add(Id, t);
 									}
 								}
 							}
 						}
 						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 = in->GetStr(FIELD_MESSAGE_ID);
 						if (!Id)
-						{
-							MailErrors++;
-							break;
-						}
+							OnError("%s:%i - Email has no MsgId\n", _FL)
 
 						if (DstMsgIds.Find(Id))
-						{
-							MailSkipped++;
-							break;
-						}
+							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)
-								MailErrors++;
+								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)
-									MailErrors++;
+									OnError("%s:%i - Failed to attach seg to mail.\n", _FL)
 								else
 								{
 									LString err;
 									if (!CopyAttachments(outMail, outSeg, inSeg, err))
-										MailErrors++;
+										OnError("%s:%i - CopyAttachments failed\n", _FL)
 									else
-										MailCreated++;
+										OnCreate()
 								}
 							}
 						}
-						else MailCreated++;
+						else
+							OnCreate()
 
 						outMail->Save(DstFolder->GetObject());
 						break;
 					}
 					default:
 					{
 						auto outObj = DstStore->Create(in->Type());
 						if (!outObj)
 						{
-							ObjectErrors++;
-							LgiTrace("%s:%i - %s failed to create %s\n", _FL,
+							OnError("%s:%i - %s failed to create %s\n", _FL,
 								DstStore->GetStr(FIELD_STORE_TYPE),
-								Store3ItemTypeName((Store3ItemTypes)in->Type()));
-							break;
+								Store3ItemTypeName((Store3ItemTypes)in->Type()))
 						}
 
 						if (!outObj->CopyProps(*in))
-						{
-							ObjectErrors++;
-							break;
-						}
+							OnError("%s:%i - CopyProps failed.\n", _FL)
 
 						if (outObj->Save(DstFolder->GetObject()) < Store3Delayed)
-						{
-							ObjectErrors++;
-							break;
-						}
+							OnError("%s:%i - Save failed\n", _FL)
 
-						ObjectCreated++;
+						OnCreate();
 						break;
 					}
 				}
 
 				Processed++;
 			}
 
 			if (SrcItems.Length() == 0)
 			{
 				SrcFolder = NULL;
 				DstFolder = NULL;
 				DstStore = NULL;
 				State = ExpGetNext;
 				(*this)++; // move progress...
 			}
 
-			LgiTrace("Processed: %i\n", Processed);
+			// 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;
 		}
 	}
 
 	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/Code/Scribe.h b/Code/Scribe.h
--- a/Code/Scribe.h
+++ b/Code/Scribe.h
@@ -1,2563 +1,2563 @@
 /*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();
 	LStream *GetLog();
 	GHostFunc *GetCommands();	
 	char *GetIncludeFile(char *FileName);
 
 	// 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 ChooseFolderDlg : public LDialog
 {
     ScribeWnd *App;
 	LEdit *Folder;
 	int Type;
 	bool Export;
 	LList *Lst;
 
 	void InsertFile(const char *f);
 
 public:
 	LString DestFolder;
 	LString::Array SrcFiles;
 
 	ChooseFolderDlg
 	(
 		ScribeWnd *parent,
 		bool IsExport,
 		const char *Title,
 		const char *Msg,
 		char *DefFolder = NULL,
 		int FolderType = MAGIC_MAIL,
 		LString::Array *Files = NULL
 	);
 
 	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 GetDirty() { return Dirty; }
-
 	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:
 	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.
 		//		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;
 		}
 	};
 	
 	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) {}
 
 	// 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 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 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);
 	int Sizeof();
 	bool Serialize(LFile &f, bool Write);
 	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
 	size_t SizeofField(const char *Name);
 	size_t Sizeof();
 	bool Serialize(LFile &f, bool Write);
 	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 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
 	List<char> 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);
 
 ////////////////////////////////////////////////////////////
 // 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(List<char> &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();
 
 	// 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;
 
 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);
 
 	// 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);
 	bool MoveTo(LArray<Thing*> &Items, bool CopyOnly = false, LArray<Store3Status> *Status = 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();
 	
 	// Virtuals:
 		/// 
 		/// 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.
 		virtual Store3Status LoadThings(LViewI *Parent = NULL,	std::function<void(Store3Status)> Callback = NULL);
 		virtual Store3Status WriteThing(Thing *t,				std::function<void(Store3Status)> Callback = NULL);
 		virtual Store3Status DeleteThing(Thing *t,				std::function<void(Store3Status)> Callback = NULL);
 		virtual Store3Status DeleteAllThings(					std::function<void(Store3Status)> Callback = NULL);
 		virtual bool LoadFolders();
 		virtual bool UnloadThings();
 		virtual bool IsWriteable() { return true; }
 		virtual bool IsPublicFolders() { return false; }
 
 		virtual void OnProperties(int Tab = -1) override;
 		virtual ScribeFolder *CreateSubDirectory(const char *Name, int Type);
 		virtual void OnRename(char *NewName);
 		virtual void OnDelete();
 		virtual LString GetPath();
 		virtual ScribeFolder *GetSubFolder(const char *Path);
 		virtual void Populate(ThingList *List);
 		virtual bool CanHaveSubFolders(Store3ItemTypes Type = MAGIC_MAIL) { return GetItemType() != MAGIC_ANY; }
 		virtual void OnRethread();
 
 	// Name
 	void SetName(const char *Name, bool Encode);
 	LString GetName(bool Decode);
 
 	// Serialization
 	int Sizeof();
 	bool Serialize(LFile &f, bool Write);
 
 	// 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;
 	LAutoString 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(GPassword *p);
 	void SetPassword(GPassword *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;
 	}
 
 	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);
 	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;
 
 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);
 	bool			LoadMailStores();
 	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();
 
 	static bool IsUnitTest;
 	const char *GetClass() override { return "ScribeWnd"; }
 	void DoDebug(char *s);
 	void Validate(LMailStore *s);
 
 	// 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 LVmDebuggerCallback *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/Code/ScribeThing.cpp b/Code/ScribeThing.cpp
--- a/Code/ScribeThing.cpp
+++ b/Code/ScribeThing.cpp
@@ -1,882 +1,890 @@
 #include "lgi/common/Lgi.h"
 #include "Scribe.h"
 #include "../Resources/resdefs.h"
 #include "Store3Imap/ScribeImap.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 
 /////////////////////////////////////////////////////////////////////////////////
 ThingType::ThingType()
 {
 }
 
 ThingType::~ThingType()
 {
+	if (Dirty)
+	{
+		if (DirtyThings.HasItem(this))
+		{
+			LAssert(!"Should not be deleting something in the dirty list...?");
+			DirtyThings.Delete(this);
+		}
+	}
 }
 
 void ThingType::WhenLoaded(const char *file, int line, std::function<void()> Callback, int index)
 {
 	if (!Callback)
 	{
 		LAssert(!"No callback.");
 		return;
 	}
 
 	if (!Loaded && GetObject())
 	{
 		// Lets just check the state of the object first...
 		auto i = GetObject()->GetInt(FIELD_LOADED);
 		if (i == Store3Loaded)
 		{
 			// This is the default for mail3 for instance...
 			Loaded = true;
 		}
 	}
 
 	if (Loaded)
 	{
 		Callback();
 	}
 	else
 	{
 		ThingEventInfo *cb = new ThingEventInfo;
 		cb->File = file;
 		cb->Line = line;
 		cb->Callback = Callback;
 
 		if (index < 0)
 			OnLoadCallbacks.Add(cb);
 		else
 			OnLoadCallbacks.AddAt(index, cb);
 	}
 }
 
 bool ThingType::IsLoaded(int Set)
 {
 	if (Set >= 0)
 	{
 		if (!Loaded && Set > 0)
 		{
 			Loaded = true;
 
 			for (auto cb: OnLoadCallbacks)
 			{
 				// LgiTrace("OnLoadCallbacks %s:%i\n", cb.File, cb.Line);
 				cb->Callback();
 			}
 			OnLoadCallbacks.DeleteObjects();
 		}
 
 		Loaded = Set > 0;
 	}
 
 	return Loaded;
 }
 
 bool ThingType::SetDirty(bool b)
 {
 	bool Status = false;
 
 	if (WillDirty)
 	{
 		Thing *t = dynamic_cast<Thing*>(this);
 		if (t &&
 			t->GetObject() &&
 			t->GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 		{
 			// IMAP email need to be explicitly saved when the message
 			// is fully constructed.
 			return true;
 		}
 
 		if (Dirty == b)
 		{
 		    if (Dirty)
 		        LAssert(Thing::DirtyThings.HasItem(this));
 		    else
 		        LAssert(!Thing::DirtyThings.HasItem(this));
 		}
 		else
 		{
 		    if (b)
 		    {
 		        Dirty = true;
 				if (!Thing::DirtyThings.HasItem(this))
 				    Thing::DirtyThings.Add(this);
 		    }
 		    else
 		    {
 		        Dirty = false;
 			    Thing::DirtyThings.Delete(this);
 			}
 		}
 	}
 
 	return Status;
 }
 
 /////////////////////////////////////////////////////////////////////////////////
 LArray<ThingType*> ThingType::DirtyThings;
 
 Thing::Thing(ScribeWnd *app, LDataI *object)
 {
 	_UserPtr = this;
 	App = app;
 	IncRef(); // Someone always starts with owning this object.
 	SetObject(object, false, _FL);
 }
 
 Thing::~Thing()
 {
 	if (GetUI())
 	{
 		LAssert(!"Really, should we still be linked to a UI here?");
 	}
 
 	DirtyThings.Delete(this);
 	DeleteObj(Data);
 
 	SetParentFolder(NULL);
 
 	auto o = GetObject();
 	if (o)
 	{
 		SetObject(NULL, true, _FL);
 		DeleteObj(o);
 	}
 }
 
 LDataI *Thing::DefaultObject(LDataI *arg)
 {
 	LAssert(App != NULL);
 
 	if (arg)
 	{
 		SetObject(arg, false, _FL);
 	}
 	else if (!GetObject() &&
 			App &&
 			App->GetDefaultMailStore())
 	{
 		LMailStore *Ms = App->GetDefaultMailStore();
 		if (Ms)
 			SetObject(Ms->Store->Create(Type()), false, _FL);
 	}
 
 	return GetObject();
 }
 
 bool Thing::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 = GetList();
 			DoContextMenu(m);
 		}
 		return true;
 	}
 	#endif
 	
 	return false;
 }
 
 void Thing::SetParentFolder(ScribeFolder *f)
 {
 	if (GetFolder() == f)
 		return;
 	
 	if (_ParentFolder)
 	{
 		if (!_ParentFolder->Items.HasItem(this))
 		{
 			LAssert(!"_ParentFolder->Items incorrect.");
 		}
 		_ParentFolder->Items.Delete(this);
 	}
 
 	_ParentFolder = f;
 
 	if (_ParentFolder)
 	{
 		LAssert(!_ParentFolder->Items.HasItem(this));
 		_ParentFolder->Items.Insert(this);
 	}
 }
 
 Store3Status Thing::SetFolder(ScribeFolder *New, int Param)
 {
 	Store3Status Moved = Store3Error;
 
 	if (New)
 	{
 		ScribeFolder *Old = GetFolder();
 		if (Old)
 		{
 			if (Old->GetObject() &&
 				New->GetObject() &&
 				Old->GetObject()->GetStore() != 0 &&
 				Old->GetObject()->GetStore() == New->GetObject()->GetStore())
 			{
 				// Both source and dest are local folders...
 				// This is really an optimization to reduce the overhead of moving objects
 				// between folders, a function which is provided by the storage sub-system
 				// does all the work for us.
 				LArray<LDataI*> Mv;
 				Mv.Add(GetObject());
 
 				Moved = Old->GetObject()->GetStore()->Move(New->GetFldObj(), Mv);
 				if (Moved == Store3Success)
 				{
 					LAssert(!Old->Items.HasItem(this));
 					LAssert(GetFolder() == New);
 					LAssert(New->Items.HasItem(this));
 				}
 			}
 			else
 			{
 				if (IsPlaceHolder())
 				{
 				}
 				else if (New->GetObject() && GetObject() && New->GetObject()->GetStore())
 				{
 					// Source OR Dest are remote...
 					LDataI *NewObject = New->GetObject()->GetStore()->Create(Type());
 					if (NewObject)
 					{
 						LDataI *OldObject = GetObject();
 
 						// Copy the current data into the new object
 						NewObject->CopyProps(*GetObject());
 						SetObject(NewObject, false, _FL);
 
 						// Try writing it to the store...
 						// bool InOld = Old->Items.HasItem(this);
 						Store3Status WrStatus = New->WriteThing(this);
 						switch (WrStatus)
 						{
 							default:
 							case Store3Error:
 							{
 								// It failed, delete the new object...
 								SetObject(OldObject, false, _FL);
 								DeleteObj(NewObject);
 								break;
 							}
 							case Store3Success:
 							{
 								// Ok, immediate save, set new object
 								// delete old object
 								Moved = OldObject->Delete(false);
 								if (Moved == Store3Error)
 								{
 									SetObject(OldObject, false, _FL);
 									DeleteObj(NewObject);
 								}
 								else if (Moved == Store3Success)
 								{
 									// Remove the Thing from the old folder.
 									Old->Items.Delete(this);
 									LAssert(New->Items.HasItem(this));
 									
 									if (GetList())
 										GetList()->Remove(this);
 								}
 								else // Delayed
 								{
 									// Because the list item is the Mail object itself we can't leave a 
 									// place holder in the LList until the delayed delete happens. The 
 									// mail object is need to appear in the destination folder, as it's
 									// now associated with 'NewObject'.
 									Old->Items.Delete(this);
 									if (GetList())
 										GetList()->Remove(this);
 								}
 								break;
 							}
 							case Store3Delayed:
 							{
 								// We have to wait for the object to be written.
 								// There will be a ScribeWnd::OnNew(...) call back 
 								// when that happens.
 								// 
 								// If is succeeds:
 								// - we need to swap the objects over... complete
 								// the updating of the UI.
 								//
 								// If it fails:
 								// - do nothing...
 								//
 								// In the meantime change the object back to the old
 								// one. But leave the UserData pointing to us. This
 								// is so the OnNew handler can finish the move for
 								// us later, and still know whats going on.
 								LAssert(Old->Items.HasItem(this));	// The old folder needs to have 
 																		// a pointer to us until "OnNew".
 								SetObject(OldObject, false, _FL);
 
 								// Setup a new Thing for the new Object...
 								Thing *t = App->CreateThingOfType(Type(), NewObject);
 								if (t)
 								{
 									// Add it to the new folder...
 									New->Items.Add(t);
 
 									// Setup a delete operation to be executed when the object arrives
 									// back at the app with an OnNew events.
 									t->DeleteOnAdd.Path = Old->GetPath();
 									t->DeleteOnAdd.Obj = this;
 								}
 
 								Moved = WrStatus;
 								break;
 							}
 						}
 					}
 				}
 			}
 		}
 		else
 		{
 			Moved = New->WriteThing(this);
 		}
 	}
 
 	return Moved;
 }
 
 void Thing::OnCreate()
 {
 }
 
 bool Thing::OnDelete()
 {
 	if (!App)
 		return false;
 
 	if (IsPlaceHolder())
 	{
 		DecRef();
 		return true;
 	}
 
 	Mail *m = IsMail();
 	if (m)
 	{
 		List<Mail> Lst;
 		Lst.Insert(m);
 		App->OnNewMail(&Lst, false);
 	}
 
 	if (GetObject() && GetObject()->GetStore())
 	{
 		LArray<LDataI*> Del;
 		Del.Add(GetObject());
 		if (GetObject()->GetStore()->Delete(Del, true))
 		{
 			return true;
 		}
 	}
 
 	ScribeFolder *Trash = App->GetFolder(FOLDER_TRASH);
 	if (!Trash)
 		return false;
 
 	LArray<Thing*> Items;
 	Items.Add(this);
 	return Trash->MoveTo(Items);
 }
 
 void Thing::OnMove()
 {
 	/*
 	if (LListItem::Parent)
 	{
 		int MyIndex = LListItem::Parent->IndexOf(this);
 		LListItem::Parent->Remove(this);
 
 		if (Parent && Parent->Length() < 1)
 		{
 			Window->OnSelect();
 		}
 		else if (LListItem::Parent && MyIndex >= 0)
 		{
 			LListItem::Parent->Value(MyIndex);
 		}
 	}
 	*/
 }
 
 bool Thing::OnBeginDrag(LMouse &m)
 {
 	int Ico = -1;
 	switch (Type())
 	{
 		case MAGIC_MAIL:
 			Ico = ICON_UNREAD_MAIL;
 			break;
 		case MAGIC_CONTACT:
 			Ico = ICON_CONTACT;
 			break;
 		case MAGIC_FILTER:
 			Ico = ICON_FILTER;
 			break;
 		case MAGIC_CALENDAR:
 			Ico = ICON_CALENDAR;
 		default:
 			break;
 	}
 
 	if (Ico >= 0)
 	{
 		LImageList *s = App->GetIconImgList();
 		if (s)
 		{
 			LRect r;
 			r.ZOff(s->TileX()-1, s->TileY()-1);
 			r.Offset(s->TileX() * Ico, 0);
 			SetIcon(s, &r);
 		}
 	}
 
 	Drag(App, m.Event, DROPEFFECT_MOVE | DROPEFFECT_COPY);
 
 	SetIcon(NULL);
 	return true;
 }
 
 bool Thing::GetFormats(LDragFormats &Formats)
 {
 	Formats.Supports(ScribeThingList);
 	
 	#if !defined(LGI_COCOA)
 	Formats.Supports(LGI_FileDropFormat);
 	#else
 	Formats.Supports(LGI_StreamDropFormat);
 	#endif
 
 	return Formats.Length() > 0;
 }
 
 void Thing::ExportAll(	LViewI *Parent,
 						const char *ExportMimeType,
 						std::function<void(bool)> Callback)
 {
 	List<Thing> Sel;
 	if (GetList())
 		GetList()->GetSelection(Sel);
 	else
 		Sel.Insert(this);
 	
 	auto Process = [&](LFileSelect *Select)
 	{
 		int Exported = 0;
 		int Errors = 0;
 		for (auto m: Sel)
 		{
 			const char *Out;
 			char Buf[MAX_PATH_LEN];
 			if (Sel.Length() == 1)
 			{
 				Out = Select->Name();
 			}
 			else
 			{
 				char *Leaf = LGetLeaf(m->GetDropFileName());
 				if (!Leaf)
 				{
 					Errors++;
 					continue;
 				}
 				
 				// Make a unique name...
 				for (int Index = 1; Index < 1000; Index++)
 				{
 					LString Nm = Leaf;
 					if (Index > 1)
 					{
 						LString::Array a = Nm.RSplit(".", 1);
 						if (a.Length() == 2)
 							Nm.Printf("%s %i.%s", a[0].Get(), Index, a[1].Get());
 						else
 							Nm.Printf("%s %i", a[0].Get(), Index);
 					}				
 					if (!LMakePath(Buf, sizeof(Buf), Select->Name(), Nm))
 					{
 						Errors++;
 						break;
 					}
 					
 					if (!LFileExists(Buf))
 						break;
 				}
 				
 				Out = Buf;
 			}					
 		
 			LAutoPtr<LFile> f(new LFile);
 			if (!f->Open(Out, O_WRITE))
 			{
 				LgiTrace("%s:%i - Couldn't open '%s' for writing.", _FL, Select->Name());
 				Errors++;
 			}
 			else
 			{
 				f->SetSize(0);
 				if (m->Export(m->AutoCast(f), ExportMimeType))
 					Exported++;
 				else
 					Errors++;
 			}
 		}
 
 		if (Errors > 0)
 			LgiMsg(Parent, "Export failed: %i exported, %i errors.", AppName, MB_OK, Exported, Errors);
 			
 		if (Callback)
 			Callback(Errors == 0);
 	};
 	
 	auto Select = new LFileSelect(Parent);
 	if (Sel.Length() == 1)
 		Select->Name(LGetLeaf(GetDropFileName()));
 	Select->Type("Email", "*.eml");
 
 	if (Sel.Length() > 1)
 	{
 		Select->OpenFolder([&](auto dlg, auto status)
 		{
 			if (status)
 				Process(dlg);
 			delete dlg;
 		});
 	}
 	else
 	{
 		Select->Save([&](auto dlg, auto status)
 		{
 			if (status)
 				Process(dlg);
 			delete dlg;
 		});
 	}
 }
 
 bool Thing::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType Fld = StrToDom(MethodName);
 	switch (Fld)
 	{
 		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 status = Import(AutoCast(f), Args[1]->Str());
 					*ReturnValue = status.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 status = Export(AutoCast(f), Args[1]->Str());
 					*ReturnValue = status.status;
 				}
 				else
 					LgiTrace("%s:%i - Error: Can't open '%s' for writing.\n", _FL, FileName);
 			}
 			break;
 		}
 		default:
 			return false;
 	}
 
 	return true;
 }
 
 bool Thing::GetData(LArray<LDragData> &Data)
 {
 	bool Status = false;
 
 	LArray<Thing*> Objs;
 	LList *ParentList = LListItem::Parent;
 	if (ParentList)
 		ParentList->GetSelection(Objs);
 
 	for (unsigned idx = 0; idx < Data.Length(); idx++)
 	{
 		LDragData &dd = Data[idx];
 		if (!dd.Format)
 			continue;
 		
 		if (dd.IsFormat(LGI_FileDropFormat))
 		{
 			LMouse m;
 			App->GetMouse(m, true);
 
 			LString::Array Files;
 			for (auto t: Objs)
 				Status |= t->GetDropFiles(Files);
 
 			if (Status && CreateFileDrop(&dd, m, Files))
 				Status = true;
 		}
 		else if (dd.IsFormat(LGI_StreamDropFormat))
 		{
 			for (auto t: Objs)
 			{
 				if (t->GetObject())
 				{
 					LAutoStreamI s = t->GetObject()->GetStream(_FL);
 					if (s)
 					{
 						s->SetPos(0);
 						
 						auto Fn = t->GetDropFileName();
 						auto MimeType = Store3ItemTypeToMime(t->Type());
 						dd.AddFileStream(LGetLeaf(Fn), MimeType, s);
 					}
 				}
 			}
 			
 			Status = dd.Data.Length() > 0;
 		}
 		else if (dd.IsFormat(ScribeThingList))
 		{
 			ScribeClipboardFmt *Fmt = ScribeClipboardFmt::Alloc(Objs);
 			if (Fmt)
 			{
 				Status |= dd.Data[0].SetBinary(Fmt->Sizeof(), Fmt);
 				free(Fmt);
 			}
 		}
 	}
 
 	return Status;
 }
 
 ////////////////////////////////////////
 bool Thing::SetField(int Field, int n)
 {
 	return GetObject() ? GetObject()->SetInt(Field, n) != 0 : false;
 }
 
 bool Thing::SetField(int Field, double n)
 {
 	LAssert(!"Not implemented");
 	return false;
 }
 
 bool Thing::SetField(int Field, char *n)
 {
 	return GetObject() ? GetObject()->SetStr(Field, n) != 0 : false;
 }
 
 bool Thing::SetField(int Field, LDateTime &n)
 {
 	return GetObject() ? GetObject()->SetDate(Field, &n) != 0 : false;
 }
 
 bool Thing::GetField(int Field, int &n)
 {
 	n = GetObject() ? (int)GetObject()->GetInt(Field) : 0;
 	return true;
 }
 
 bool Thing::GetField(int Field, double &n)
 {
 	LAssert(!"Not implemented");
 	return false;
 }
 
 bool Thing::GetField(int Field, const char *&n)
 {
 	n = GetObject() ? GetObject()->GetStr(Field) : 0;
 	return n != 0;
 }
 
 bool Thing::GetField(int Field, LDateTime &n)
 {
 	const LDateTime *t = GetObject() ? GetObject()->GetDate(Field) : 0;
 	if (t)
 	{
 		n = *t;
 		return n.IsValid();
 	}
 
 	return false;
 }
 
 bool Thing::DeleteField(int Field)
 {
 	LAssert(!"Not implemented");
 	return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 LArray<ThingUi*> ThingUi::All;
 
 ThingUi::ThingUi(Thing *item, const char *name)
 {	
 	_Dirty = false;
 	_Running = false;
 	_Name = NewStr(name);
 	_Item = item;
 	App = item ? item->App : NULL;
 	LAssert(App != NULL);
 
 	SetQuitOnClose(false);
 	SetSnapToEdge(true);
 	Name(_Name);
 
 	All.Add(this);
 }
 
 ThingUi::~ThingUi()
 {
 	LAssert(InThread());
 	LAssert(All.HasItem(this));
 	All.Delete(this);
 
 	_Running = false;
 	_Dirty = false;
 	DeleteArray(_Name);
 }
 
 bool ThingUi::OnViewKey(LView *v, LKey &k)
 {
 	bool IsPopup = false;
 	#ifdef __GTK_H__
 	OsView Hnd = GtkCast(GetWindow()->WindowHandle(), gtk_widget, GtkWidget);
 	#else
 	OsView Hnd = Handle();
 	#endif
 	for (LViewI *p = v; p; p = p->GetParent())
 	{
 		if (dynamic_cast<LPopup*>(p))
 		{
 			IsPopup = true;
 			break;
 		}
 	}	
 
 	bool Status = LWindow::OnViewKey(v, k);
 
 	// The 'this' pointer may not be valid from here on.
 	if (IsPopup)
 	{
 		return Status;
 	}
 
 	if (!Status &&
 		k.Down() &&
 		k.vkey == LK_ESCAPE)
 	{
 		LPostEvent(Hnd, M_CLOSE);
 		return false;
 	}
 
 	return Status;
 }
 
 bool ThingUi::SetDirty(bool d, bool ui)
 {
 	bool Status = true;
 
 	if (d ^ _Dirty)
 	{
 		if (d)
 		{
 			if (_Item && dynamic_cast<ImapMail*>(_Item->GetObject()))
 			{
 				LAssert(!"Should imap mail become dirty?");
 			}
 			
 			_Dirty = true;
 			OnDirty(_Dirty);
 		}
 		else
 		{
 			int Result = ui ? LgiMsg(this, LLoadString(IDS_SAVE_ITEM), AppName, MB_YESNOCANCEL) : IDYES;
 			if (Result == IDYES)
 			{
 				OnSave();
 				_Dirty = false;
 				OnDirty(_Dirty);
 			}
 			else if (Result == IDCANCEL)
 			{
 				Status = false;
 			}
 			else
 			{
 				// Result == IDNO
 				_Dirty = false;
 				OnDirty(_Dirty);
 			}
 		}
 
 		if (Status)
 		{
 			char s[256];
 			if (_Dirty)
 			{
 				sprintf_s(s, sizeof(s), "%s (%s)", _Name, LLoadString(IDS_CHANGED));
 			}
 			else
 			{
 				strcpy_s(s, sizeof(s), _Name);
 			}
 			Name(s);
 		}
 	}
 
 	return Status;
 }
 
 bool ThingUi::OnRequestClose(bool OsShuttingDown)
 {
 	static bool Processing = false;
 	bool Status = false;
 
 	if (!Processing)
 	{
 		Processing = true;
 
 		bool Cleaned = SetDirty(false);
 		if (Cleaned)
 		{
 			Status = LWindow::OnRequestClose(OsShuttingDown);
 		}
 
 		Processing = false;
 	}
 
 	return Status;
 }
 
diff --git a/Code/ScribeUtils.cpp b/Code/ScribeUtils.cpp
--- a/Code/ScribeUtils.cpp
+++ b/Code/ScribeUtils.cpp
@@ -1,2123 +1,2130 @@
 #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 NULL;
 
 	LString cs;
 	if (detect_r(s.Get(), s.Length(), &obj) == CHARDET_SUCCESS)
 		cs = obj->encoding;
 
 	// obj->encoding, obj->confidence, obj->bom
 	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;
 				}
 
 				LToken Header(s, " ", true, e - s);
 				if (Header.Length() >= 3)
 				{
 					LMemQueue File;
 					for (int n=2; Header[n]; n++)
 					{
 						FileName.Print("%s%s", n==2?"":" ", Header[n]);
 					}
 				}
 
 				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
 			LToken Headers(Question, "&");
 			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;
-	Html1::LHtml *Html2;
+	LTableLayout *Tbl = NULL;
+	Html1::LHtml *Html2 = NULL;
 
 public:
 	HtmlMsg(LViewI *Parent, const char *Html, const char *Title, int Type)
 	{
-		LPoint Size(200, 200);
-		Tbl = NULL;
+		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)
 	{
 		#undef _
 		#define _(name) Scribe_StrToDom.Add(#name, Sd##name); \
 						LAssert(Scribe_StrToDom.Find(#name) == Sd##name); \
 						Scribe_DomToStr.Add(Sd##name, #name);
 		#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);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////
 // This converts an async call to sync, because the GetVariant / CallMethod API
 // can't be changed to include a callback. It's a hack until such time as there
 // is proper support for callbacks in the DOM api.
 void WaitForVariant(LVariant &var)
 {
 	auto StartTs = LCurrentTime();
 	while (var.Type == GV_NULL)
 	{
 		LSleep(10);
 		LYield();
 		if (LCurrentTime() - StartTs > 20000)
 		{
 			LgiTrace("%s:%i - WaitForVariant waiting for: %is", _FL, (int)(LCurrentTime()-StartTs));
 			StartTs = LCurrentTime();
 		}
 	}
 }
 
 void WaitForString(LString &var)
 {
 	auto StartTs = LCurrentTime();
 	while (var.Get() == NULL)
 	{
 		LSleep(10);
 		LYield();
 		if (LCurrentTime() - StartTs > 20000)
 		{
 			LgiTrace("%s:%i - WaitForString waiting for: %is", _FL, (int)(LCurrentTime()-StartTs));
 			StartTs = LCurrentTime();
 		}
 	}
 }