diff --git a/src/PreviewPanel.cpp b/src/PreviewPanel.cpp
--- a/src/PreviewPanel.cpp
+++ b/src/PreviewPanel.cpp
@@ -1,975 +1,977 @@
 /*
 **	FILE:			ScribePreview.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			31/8/99
 **	DESCRIPTION:	Scribe Mail Preview UI
 **
 **	Copyright (C) 1999, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/Html.h"
 #include "lgi/common/Scripting.h"
 
 #include "Scribe.h"
 #include "PreviewPanel.h"
 #include "resdefs.h"
 #include "ScribeListAddr.h"
 #include "Calendar.h"
 #include "Components.h"
 
 #include "../src/common/Text/HtmlPriv.h"
 
 #define OPT_PreviewSize					"LPreviewPanel::OpenSize"
 #define OPT_PreviewOpen					"LPreviewPanel::IsOpen"
 
 #if defined(WIN32) && defined(_DEBUG)
 #define DEBUG_FOCUS						1
 #else
 #define DEBUG_FOCUS						0
 #endif
 
 #ifdef MAC
 #define HEADER_POS						1
 #else
 #define HEADER_POS						0
 #endif
 
 class LPreviewPanelPrivate : public LDocumentEnv, public LScriptContext
 {
 public:
 	LPreviewPanel *Panel;
 	ScribeWnd *App;
 	LDocView *TextCtrl;
 	Thing *Item;
 	Thing *Pulse;
 	LRect TxtPos;
 	int Time;
 	LCapabilityTarget::CapsHash MissingCaps;
 	MissingCapsBar *Bar;
 	bool IgnoreShowImgNotify;
 	Contact *CtxMenuContact;
 
 	// Dynamic header content
 	Html1::LHtml *Header;
 	int HeaderY;
 	ScribeDom *HeaderDom;
 	LString HeaderMailFile;
 	LString HeaderMailTemplate;
 	LString HeaderContactFile;
 	LString HeaderContactTemplate;
 	LString HeaderGroupFile;
 	LString HeaderGroupTemplate;
 	
 	// Scripting
 	LAutoPtr<LCompiledCode> ScriptObj;
 
 	// Methods
 	LPreviewPanelPrivate(LPreviewPanel *p) : Panel(p)
 	{
 		HeaderY = 88;
 		Header = 0;
 		HeaderDom = 0;
 		Bar = 0;
 		IgnoreShowImgNotify = false;
 		CtxMenuContact = NULL;
 
 		Item = 0;
 		Pulse = 0;
 		TextCtrl = 0;
 		Time = -1;
 		TxtPos.ZOff(-1, -1);
 	}
 
 	~LPreviewPanelPrivate()
 	{
 		DeleteObj(Bar);
 	}
 
 	LString GetIncludeFile(const char *FileName) override
 	{
 		return NULL;
 	}
 
 	bool AppendItems(LSubMenu *Menu, const char *Param, int Base) override
 	{
 		if (!Menu)
 			return false;
 
 		Mailto mt(App, Param);
 		CtxMenuContact = mt.To.Length() > 0 ? Contact::LookupEmail(mt.To[0]->sAddr) : NULL;
 
 		if (CtxMenuContact)
 			Menu->AppendItem(LLoadString(IDS_OPEN_CONTACT), IDM_OPEN, true);
 		else
 			Menu->AppendItem(LLoadString(IDS_ADD_CONTACTS), IDM_NEW_CONTACT, true);
 
 		return true;
 	}
 
 	bool OnMenu(LDocView *View, int Id, void *Context) override
 	{
 		if (Id == IDM_NEW_CONTACT)
 		{
 			if (Context)
 			{
 				Html1::LTag *a = (Html1::LTag*) Context;
 				char *Name = WideToUtf8(a->Text());
 				const char *Email = 0;
 				a->Get("href", Email);
 
 				ListAddr *La = new ListAddr(App, Email, Name);
 				if (La)
 				{
 					La->AddToContacts(true);
 					DeleteObj(La);
 				}
 			}
 		}
 		else if (Id == IDM_OPEN && CtxMenuContact)
 		{
 			CtxMenuContact->DoUI();
 			CtxMenuContact = NULL;
 		}
 		else return false;
 
 		return true;
 	}
 
 	bool OnNavigate(LDocView *Parent, const char *Uri) override
 	{
 		Mailto m(App, Uri);
 		if (m.To[0])
 		{
 			Mail *email = App->CreateMail();
 			if (email)
 			{
 				m.Apply(email);
 				email->DoUI();
 				return true;
 			}
 		}
 		return false;
 	}
 
 	LDocumentEnv::LoadType GetContent(LoadJob *&j) override
 	{
 		LUri i;
 
 		if (!j)
 			goto GetContentError;
 		if (_strnicmp(j->Uri, "LC_", 3) == 0)
 			goto GetContentError;
 
 		i.Set(j->Uri);
 		if (!i.sProtocol || !i.sPath)
 			goto GetContentError;
 
 		if (_stricmp(i.sProtocol, "file") == 0)
 		{
 			char p[MAX_PATH_LEN];
 			strcpy_s(p, sizeof(p), i.sPath);
 			#ifdef WIN32
 			char *c;
 			while (c = strchr(p, '/')) *c = '\\';
 			#endif
 
 			if (LFileExists(p))
 			{
 				j->pDC.Reset(GdcD->Load(p));
 
 				return LoadImmediate;
 			}
 		}
 		else if
 		(
 			!_stricmp(i.sProtocol, "http") ||
 			!_stricmp(i.sProtocol, "https") ||
 			!_stricmp(i.sProtocol, "ftp")
 		)
 		{
 			// We don't check OPT_HtmlLoadImages here because it's done elsewhere:
 			// - ScribeWnd::CreateTextControl calls LHtml::SetLoadImages with the value from OPT_HtmlLoadImages
 			// - LTag::LoadImage checks LHtml::GetLoadImages
 			//
 			// If there is a remote job here, it's because it's probably whitelisted.			
 			Worker = App->GetImageLoader();
 			if (Worker)
 			{
 				Worker->AddJob(j);
 				j = 0;
 
 				return LoadDeferred;
 			}
 		}
 
 	GetContentError:
 		return LoadError;
 	}
 
 	bool trace(LScriptArguments &Args)
 	{
 		LgiTrace("Script: ");
 		for (unsigned i=0; i<Args.Length(); i++)
 		{
 			LgiTrace("%s%s", i ? ", " : "", Args[i]->CastString());
 		}
 		LgiTrace("\n");
 
 		return true;
 	}
 
 	bool encodeURI(LScriptArguments &Args)
 	{
 		if (Args.Length() == 1)
 		{
 			LUri u;
 			*Args.GetReturn() = u.EncodeStr(Args[0]->CastString());
 			return true;
 		}
 
 		return false;
 	}
 
 	bool getElementById(LScriptArguments &Args)
 	{
 		if (Args.Length() == 1 && Header)
 		{
 			LDom *e = Header->getElementById(Args[0]->CastString());
 			if (e)
 			{
 				*Args.GetReturn() = e;
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	// Convert dynamic fields into string values...
 	LString OnDynamicContent(LDocView *Parent, const char *Code) override
 	{
 		if (!HeaderDom)
 			return NULL;
 
 		LVariant v;
 		if (!HeaderDom->GetValue(Code, v))
 			return NULL;
 
 		return v.CastString();
 	}
 
 	void SetEngine(LScriptEngine *Eng) {}
 	LHostFunc *GetCommands() override;
 
 	void SetGlobals(LCompiledCode *obj)
 	{
 		if (!obj)
 			return;
 		
 		// Set global 'Thing' variable to the current object.
 		LVariant v = (LDom*)Item;
 		obj->Set("Thing", v);
 
 		// Set 'document' variable to the document viewer object.
 		if (TextCtrl)
 		{
 			v = (LDom*)TextCtrl;
 			obj->Set("document", v);
 		}
 	}
 
 	bool OnCompileScript(LDocView *Parent, char *Script, const char *Language, const char *MimeType) override
 	{
 		LScriptEngine *Engine = App->GetScriptEngine();
 		if (!Engine || !Script)
 			return false;
 
 		if (!ScriptObj)
 		{
 			if (ScriptObj.Reset(new LCompiledCode))
 				SetGlobals(ScriptObj);
 		}
 			
 		if (!ScriptObj)
 			return false;
 
 		SetLog(LScribeScript::Inst->GetLog());
 
 		const char *FileName = "script.html";
 		if (Item->Type() == MAGIC_MAIL)
 			FileName = HeaderMailFile;
 		else if (Item->Type() == MAGIC_CONTACT)
 			FileName = HeaderContactFile;
 
 		return Engine->Compile(ScriptObj, this, Script, FileName);
 	}
 
 	bool OnExecuteScript(LDocView *Parent, char *Script) override
 	{
 		LScriptEngine *Engine = App->GetScriptEngine();
 		if (Engine && Script)
 		{
 			if (!ScriptObj)
 			{
 				if (ScriptObj.Reset(new LCompiledCode))
 					SetGlobals(ScriptObj);
 			}
 
 			// Run the fragment of code.
 			if (Engine->RunTemporary(ScriptObj, Script))
 			{
 				return true;
 			}
 		}
 
 		return false;
 	}
 };
 
 LHostFunc Cmds[] =
 {
 	LHostFunc("getElementById", "", (ScriptCmd)&LPreviewPanelPrivate::getElementById),
 	LHostFunc("encodeURI", "", (ScriptCmd)&LPreviewPanelPrivate::encodeURI),
 	LHostFunc("trace", "", (ScriptCmd)&LPreviewPanelPrivate::trace),
 	LHostFunc(0, 0, 0)
 };
 
 LHostFunc *LPreviewPanelPrivate::GetCommands()
 {
 	return Cmds;
 }
 
 LPreviewPanel::LPreviewPanel(ScribeWnd *app)
 {
 	d = new LPreviewPanelPrivate(this);
 	d->App = app;
 	
     // This allows us to hook iconv conversion events
     LFontSystem::Inst()->Register(this);
     
     // This allows us to hook missing image library events
     GdcD->Register(this);
 }
 
 LPreviewPanel::~LPreviewPanel()
 {
 	DeleteObj(d);
 }
 
 LMessage::Param LPreviewPanel::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_NEEDS_CAP:
 		{
 			LAutoString c((char*)Msg->A());
 			NeedsCapability(c);
 			return 0;
 		}
 		case M_UPDATE:
 		{
 			OnPosChange();
 			break;
 		}
 	}
     
     return LLayout::OnEvent(Msg);
 }
 
 void LPreviewPanel::OnCloseInstaller()
 {
 	d->Bar = NULL;
 }
 
 void LPreviewPanel::OnInstall(CapsHash *Caps, bool Status)
 {
 	if (Caps && Status)
 	{
 	    LDataI *Obj;
 		if (d->Item &&
 			(Obj = d->Item->GetObject()) &&
 			Obj->Type() == MAGIC_MAIL)
 		{
 			LFontSystem::Inst()->ResetLibCheck();
 			d->Item->Reparse();
 		}
 
 		OnThing(d->Item, true);
 	}
 	else
 	{
 		// Install failed...
 	}
 }
 
 bool LPreviewPanel::NeedsCapability(const char *Name, const char *Param)
 {
     if (!InThread())
     {
         PostEvent(M_NEEDS_CAP, (LMessage::Param)NewStr(Name));
     }
     else
     {
         if (!Name)
             return false;
             
         if (d->MissingCaps.Find(Name))
             return true;
 
         d->MissingCaps.Add(Name, true);
 
 	    char msg[256];
 		LArray<const char *> Actions;
 		LAutoPtr<LColour> Back;
 	    
 	    if (!_stricmp(Name, "RemoteContent"))
 	    {
 			Actions.Add(LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT));
 			Actions.Add(LLoadString(IDS_SHOW_REMOTE_CONTENT));
 
 			Back.Reset(new LColour(L_LOW));
 			strcpy_s(msg, sizeof(msg),
 					LLoadString
 					(
 						IDS_REMOTE_CONTENT_MSG,
 						"To protect your privacy Scribe has blocked the remote content in this message."
 					));
 	    }
 	    else
 	    {
 			Actions.Add(LLoadString(IDS_INSTALL));
 			int ch = 0;
 			for (auto k : d->MissingCaps)
 				ch += sprintf_s(msg+ch, sizeof(msg)-ch, "%s%s", ch?", ":"", k.key);
 			ch += sprintf_s(msg+ch, sizeof(msg)-ch, " is required to display this content.");
 		}
     		
         if (!d->Bar)
         {
             d->Bar = new MissingCapsBar(this, &d->MissingCaps, msg, d->App, Actions, Back);
             d->Bar->Attach(this);
             OnPosChange();
         }
         else
         {
 		    d->Bar->SetMsg(msg);
         }
     }
 
     return true;
 }
 
 LDocView *LPreviewPanel::GetDoc(const char *MimeType)
 {
     return d->TextCtrl;
 }
 
 bool LPreviewPanel::SetDoc(LDocView *v, const char *MimeType)
 {
     if (v != d->TextCtrl)
     {
         DeleteObj(d->TextCtrl);
         if ((d->TextCtrl = v))
         {
 			LCapabilityClient *cc = dynamic_cast<LCapabilityClient*>(d->TextCtrl);
 			if (cc)
 				cc->Register(this);
 
 			if (IsAttached())
 				return v->Attach(this);				
         }
     }
     return true;
 }
 
 void LPreviewPanel::OnPaint(LSurface *pDC)
 {
 	pDC->Colour(L_MED);
 	pDC->Rectangle();
 	
 	#ifdef MAC
 	if (d->Header)
 	{
 		LRect r = d->Header->GetPos();
 		pDC->Colour(Rgb24(0xB0, 0xB0, 0xB0), 24);
 		pDC->Line(r.x1-1, r.y1-1, r.x2, r.y1-1);
 		pDC->Line(r.x1-1, r.y1-1, r.x1-1, r.y2);
 	}
 	#endif
 }
 
 void LPreviewPanel::OnPosChange()
 {
 	int y = 0;
 	LRect c = GetClient();
 
 	if (d->Header)
 	{
 		LRect r(HEADER_POS, HEADER_POS, c.X()-(HEADER_POS<<1), c.Y()-(HEADER_POS<<1));
 		d->Header->SetPos(r);
 		LPoint Size = d->Header->Layout(true);
 		if (Size.y > 0)
 		{
 			/*	This size limit is now implemented as CSS in the HTML itself. */
 			d->HeaderY = Size.y;
 			if (d->HeaderY != r.Y())
 			{
 				r.Set(HEADER_POS, HEADER_POS, c.X()-(HEADER_POS<<1), HEADER_POS+d->HeaderY-1);
 				d->Header->SetPos(r);
 			}
 		}
 
 		y += r.Y();
 	}
 	
 	if (d->Bar)
 	{
 		LRect r(0, y, c.X()-1, y + d->Bar->Y() - 1);
 		d->Bar->SetPos(r);
 		y += d->Bar->Y();
 	}
 
 	if (d->TextCtrl)
 	{
 		LRect r(0, y, c.X()-1, c.Y()-1);
 		d->TextCtrl->SetPos(r);
 		d->TextCtrl->Visible(true);
 	}
 }
 
 bool AttachViewToPanel(LDocView *v, void *p)
 {
 	LPreviewPanel *pp = (LPreviewPanel*)p;
 
 	return v->Attach(pp);
 }
 
 Thing *LPreviewPanel::GetCurrent()
 {
 	return d->Item;
 }
 
 bool LPreviewPanel::CallMethod(const char *Name, LVariant *Dst, LArray<LVariant*> &Arg)
 {
 	ScribeDomType Method = StrToDom(Name);
 
 	*Dst = false;
 	switch (Method)
 	{
 		case SdShowRemoteContent:
 			if (d->TextCtrl)
 			{
 				bool Always = Arg.Length() > 0 ? Arg[0]->CastBool() : false;
 				if (Always)
 				{
 					auto m = d->Item->IsMail();
 					if (m)
 					{
 						auto From = m->GetFrom();
 						if (From)
 							d->App->RemoteContent_AddSender(From->GetStr(FIELD_EMAIL), true);
 						else
 							LgiTrace("%s:%i - No from address.\n", _FL);
 					}
 					else LgiTrace("%s:%i - Not an email.\n", _FL);
 				}
 
 				d->IgnoreShowImgNotify = true;
 				d->TextCtrl->SetLoadImages(true);
 				d->IgnoreShowImgNotify = false;
 				PostEvent(M_UPDATE);
 				*Dst = true;
 			}
 			break;
 		case SdSetHtml:
 			if (d->TextCtrl && Arg.Length() > 0)
 			{
 				d->TextCtrl->Name(Arg[0]->Str());
 				*Dst = true;
 			}
 			break;
 		default:
 			return false;
 	}
 	
 	return true;	
 }
 
 void LPreviewPanel::OnThing(Thing *item, bool ChangeEvent)
 {
 	if (d->Item == item && !ChangeEvent)
 		return;
 
     d->MissingCaps.Empty();
     DeleteObj(d->Bar);
     
 	if (d->Item &&
 		d->TextCtrl &&
 		d->TextCtrl->IsDirty() &&
 		!dynamic_cast<Html1::LHtml*>(d->TextCtrl))
 	{
 		Mail *m = d->Item->IsMail();
 		if (m)
 		{
 			MailUi *Ui = dynamic_cast<MailUi*>(m->GetUI());
 			bool AlreadyDirty = Ui ? Ui->IsDirty() : false;
 			if (AlreadyDirty)
 			{
 				LgiMsg(	this,
 						"Email already open and edited.\n"
 						"Preview changes lost.",
 						AppName);
 			}
 			else
 			{
 				m->SetBody(d->TextCtrl->Name());
 				m->SetDirty();
 
 				if (Ui)
 					Ui->OnLoad();
 			}
 		}
 	}
+
 	d->Item = item;
 
-	char *Mem = 0;
-
 	if (!d->Item || d->Item->Type() != MAGIC_MAIL)
 	{
 		DeleteObj(d->Header);
 		DeleteObj(d->HeaderDom);
 	}
 	
-	if (d->Item)
+	if (!d->Item)
+	{
+		DeleteObj(d->TextCtrl);
+	}
+	else
 	{
 		d->ScriptObj.Reset();
 
 		if (d->TextCtrl &&
 			d->TextCtrl->IsAttached())
 		{
 			d->TxtPos = d->TextCtrl->GetPos();
 		}
 
 		switch ((uint32_t)d->Item->Type())
 		{
 			case MAGIC_MAIL:
 			{
-				Mail *m = d->Item->IsMail();
-				if (m)
+				auto m = d->Item->IsMail();
+				if (!m)
+					break;
+
+				if (!d->Header)
 				{
-					if (!d->Header)
+					if (!d->HeaderMailTemplate)
 					{
-						if (!d->HeaderMailTemplate)
-						{
-							char Base[] = "PreviewMail.html";
-							
-							d->HeaderMailFile = LFindFile("PreviewMailCustom.html");
+						char Base[] = "PreviewMail.html";
 							
-							if (d->HeaderMailFile || (d->HeaderMailFile = LFindFile(Base)))
-								d->HeaderMailTemplate = LFile(d->HeaderMailFile).Read();
-							else
-								d->HeaderMailTemplate.Printf("Failed to find '%s'", Base);
-						}
-
-						if (d->HeaderMailTemplate)
-						{
-							d->Header = new Html1::LHtml(100, HEADER_POS, HEADER_POS, GetPos().X()-1, d->HeaderY);
-							if (d->Header)
-							{
-								d->HeaderDom = new ScribeDom(d->App);
-								d->Header->SetEnv(d);
-								d->Header->Attach(this);
-								Invalidate();
-							}
-						}
+						d->HeaderMailFile = LFindFile("PreviewMailCustom.html");
+							
+						if (d->HeaderMailFile || (d->HeaderMailFile = LFindFile(Base)))
+							d->HeaderMailTemplate = LFile(d->HeaderMailFile).Read();
+						else
+							d->HeaderMailTemplate.Printf("Failed to find '%s'", Base);
 					}
 
-					if (!TestFlag(m->GetFlags(), MAIL_READ) && !ChangeEvent)
+					if (d->HeaderMailTemplate)
 					{
-						LVariant MarkReadAfterPreview;
-						d->App->GetOptions()->GetValue(OPT_MarkReadAfterPreview, MarkReadAfterPreview);
-						if (MarkReadAfterPreview.CastInt32())
+						d->Header = new Html1::LHtml(100, HEADER_POS, HEADER_POS, GetPos().X()-1, d->HeaderY);
+						if (d->Header)
 						{
-							d->Pulse = d->Item;
-							
-							LVariant Secs = 5;
-							d->App->GetOptions()->GetValue(OPT_MarkReadAfterSeconds, Secs);
-							if (Secs.CastInt32())
-							{
-								d->Time = Secs.CastInt32();
-							}
-							else
-							{
-								m->SetFlags(m->GetFlags() | MAIL_READ);
-							}
+							d->HeaderDom = new ScribeDom(d->App);
+							d->Header->SetEnv(d);
+							d->Header->Attach(this);
+							Invalidate();
 						}
 					}
-
-					if (!m->CreateView(this, (const char*)NULL, false, 512<<10, true))
-					{
-						DeleteObj(d->TextCtrl);
-					}
+				}
 
-					if (d->Header && d->HeaderMailTemplate)
+				if (!TestFlag(m->GetFlags(), MAIL_READ) && !ChangeEvent)
+				{
+					LVariant MarkReadAfterPreview;
+					d->App->GetOptions()->GetValue(OPT_MarkReadAfterPreview, MarkReadAfterPreview);
+					if (MarkReadAfterPreview.CastInt32())
 					{
-						if (d->HeaderDom)
-							d->HeaderDom->Email = m;
+						d->Pulse = d->Item;
+							
+						LVariant Secs = 5;
+						d->App->GetOptions()->GetValue(OPT_MarkReadAfterSeconds, Secs);
+						if (Secs.CastInt32())
+						{
+							d->Time = Secs.CastInt32();
+						}
+						else
+						{
+							m->SetFlags(m->GetFlags() | MAIL_READ);
+						}
+					}
+				}
+
+				if (!m->CreateView(this, LString()/*mimetype*/, false, 512<<10, true))
+				{
+					DeleteObj(d->TextCtrl);
+				}
+
+				if (d->Header && d->HeaderMailTemplate)
+				{
+					if (d->HeaderDom)
+						d->HeaderDom->Email = m;
 						
-						d->Header->Name(d->HeaderMailTemplate);
-					}
+					d->Header->Name(d->HeaderMailTemplate);
 				}
 				break;
 			}
 			case MAGIC_CONTACT:
 			{
-				Contact *c = d->Item->IsContact();
-				if (c)
+				auto c = d->Item->IsContact();
+				if (!c)
+					break;
+
+				if (!d->Header)
 				{
-					if (!d->Header)
+					if (!d->HeaderContactTemplate)
 					{
-						if (!d->HeaderContactTemplate)
+						char Base[] = "PreviewContact.html";
+						if ((d->HeaderContactFile = LFindFile(Base)))
+							d->HeaderContactTemplate = LFile(d->HeaderContactFile).Read();
+						else
+							d->HeaderContactTemplate.Printf("Failed to find '%s'", Base);
+					}
+
+					if (d->HeaderContactTemplate)
+					{
+						d->Header = new Html1::LHtml(100, HEADER_POS, HEADER_POS, GetPos().X()-1, d->HeaderY);
+						if (d->Header)
 						{
-							char Base[] = "PreviewContact.html";
-							if ((d->HeaderContactFile = LFindFile(Base)))
-								d->HeaderContactTemplate = LFile(d->HeaderContactFile).Read();
-							else
-								d->HeaderContactTemplate.Printf("Failed to find '%s'", Base);
-						}
-
-						if (d->HeaderContactTemplate)
-						{
-							d->Header = new Html1::LHtml(100, HEADER_POS, HEADER_POS, GetPos().X()-1, d->HeaderY);
-							if (d->Header)
-							{
-								d->HeaderDom = new ScribeDom(d->App);
-								d->Header->SetEnv(d);
-								d->Header->Attach(this);
-								Invalidate();
-							}
+							d->HeaderDom = new ScribeDom(d->App);
+							d->Header->SetEnv(d);
+							d->Header->Attach(this);
+							Invalidate();
 						}
 					}
+				}
 
-					if (d->Header && d->HeaderContactTemplate)
+				if (d->Header && d->HeaderContactTemplate)
+				{
+					if (d->HeaderDom)
 					{
-						if (d->HeaderDom)
-						{
-							d->HeaderDom->Con = c;
-						}
-						d->Header->Name(d->HeaderContactTemplate);
-					}					
-				}
+						d->HeaderDom->Con = c;
+					}
+					d->Header->Name(d->HeaderContactTemplate);
+				}					
 				break;
 			}
 			case MAGIC_GROUP:
 			{
-				ContactGroup *g = d->Item->IsGroup();
-				if (g)
+				auto g = d->Item->IsGroup();
+				if (!g)
+					break;
+
+				if (!d->Header)
 				{
-					if (!d->Header)
+					if (!d->HeaderGroupTemplate)
 					{
-						if (!d->HeaderGroupTemplate)
+						char Base[] = "PreviewGroup.html";
+						if ((d->HeaderGroupFile = LFindFile(Base)))
+							d->HeaderGroupTemplate = LFile(d->HeaderGroupFile).Read();
+						else
+							d->HeaderGroupTemplate.Printf("Failed to find '%s'", Base);
+					}
+
+					if (d->HeaderGroupTemplate)
+					{
+						d->Header = new Html1::LHtml(100, HEADER_POS, HEADER_POS, GetPos().X()-1, d->HeaderY);
+						if (d->Header)
 						{
-							char Base[] = "PreviewGroup.html";
-							if ((d->HeaderGroupFile = LFindFile(Base)))
-								d->HeaderGroupTemplate = LFile(d->HeaderGroupFile).Read();
-							else
-								d->HeaderGroupTemplate.Printf("Failed to find '%s'", Base);
-						}
-
-						if (d->HeaderGroupTemplate)
-						{
-							d->Header = new Html1::LHtml(100, HEADER_POS, HEADER_POS, GetPos().X()-1, d->HeaderY);
-							if (d->Header)
-							{
-								d->HeaderDom = new ScribeDom(d->App);
-								d->Header->SetEnv(d);
-								d->Header->Attach(this);
-								Invalidate();
-							}
+							d->HeaderDom = new ScribeDom(d->App);
+							d->Header->SetEnv(d);
+							d->Header->Attach(this);
+							Invalidate();
 						}
 					}
+				}
 
-					if (d->Header && d->HeaderGroupTemplate)
+				if (d->Header && d->HeaderGroupTemplate)
+				{
+					if (d->HeaderDom)
 					{
-						if (d->HeaderDom)
-						{
-							d->HeaderDom->Grp = g;
-						}
-						d->Header->Name(d->HeaderGroupTemplate);
-					}					
+						d->HeaderDom->Grp = g;
+					}
+					d->Header->Name(d->HeaderGroupTemplate);
 				}
 				break;
 			}
 			case MAGIC_CALENDAR:
 			{
-				Calendar *c = d->Item->IsCalendar();
-				if (c)
+				auto c = d->Item->IsCalendar();
+				if (!c)
+					break;
+
+				LStringPipe p;
+				LDateTime Start, End;
+				uint64 StartTs, EndTs;
+				char s[256];
+				if (c->GetField(FIELD_CAL_START_UTC, Start))
 				{
-					LStringPipe p;
-					LDateTime Start, End;
-					uint64 StartTs, EndTs;
-					char s[256];
-					if (c->GetField(FIELD_CAL_START_UTC, Start))
+					Start.Get(s, sizeof(s));
+					Start.Get(StartTs);
+					p.Print("Start: %s\n", s);
+
+					if (c->GetField(FIELD_CAL_END_UTC, End))
 					{
-					    Start.Get(s, sizeof(s));
-					    Start.Get(StartTs);
-					    p.Print("Start: %s\n", s);
-
-					    if (c->GetField(FIELD_CAL_END_UTC, End))
-					    {
-					        End.Get(s, sizeof(s));
-    					    End.Get(EndTs);
+					    End.Get(s, sizeof(s));
+    					End.Get(EndTs);
     					    
-                            int Min = (int) ((EndTs - StartTs) / LDateTime::Second64Bit / 60);
-                            if (Min >= 24 * 60)
-                            {
-                                double Days = (double)Min / 24.0 / 60.0;
-    					        p.Print("End: %s (%.1f day%s)\n", s, Days, Days == 1.0 ? "" : "s");
-                            }
-                            else
-                            {
-                                int Hrs = Min / 60;
-                                int Mins = Min % 60;
-    					        p.Print("End: %s (%i:%02i)\n", s, Hrs, Mins);
-                            }
-					    }
+                        int Min = (int) ((EndTs - StartTs) / LDateTime::Second64Bit / 60);
+                        if (Min >= 24 * 60)
+                        {
+                            double Days = (double)Min / 24.0 / 60.0;
+    					    p.Print("End: %s (%.1f day%s)\n", s, Days, Days == 1.0 ? "" : "s");
+                        }
+                        else
+                        {
+                            int Hrs = Min / 60;
+                            int Mins = Min % 60;
+    					    p.Print("End: %s (%i:%02i)\n", s, Hrs, Mins);
+                        }
 					}
+				}
 					    
-					const char *Str = 0;
-					if (c->GetField(FIELD_CAL_SUBJECT, Str))
-					    p.Print("Subject: %s\n", Str);
-					if (c->GetField(FIELD_CAL_LOCATION, Str))
-					    p.Print("Location: %s\n", Str);
-					if (c->GetField(FIELD_CAL_NOTES, Str))
-					    p.Print("Notes: %s\n", Str);
+				const char *Str = 0;
+				if (c->GetField(FIELD_CAL_SUBJECT, Str))
+					p.Print("Subject: %s\n", Str);
+				if (c->GetField(FIELD_CAL_LOCATION, Str))
+					p.Print("Location: %s\n", Str);
+				if (c->GetField(FIELD_CAL_NOTES, Str))
+					p.Print("Notes: %s\n", Str);
 					
-					LAutoString Txt(p.NewStr());
-					if (!dynamic_cast<LTextView3*>(d->TextCtrl))
-						DeleteObj(d->TextCtrl);
-					if (!d->TextCtrl)
-					{
-						d->TextCtrl = d->App->CreateTextControl(100, "text/plain", false);
-						if (d->TextCtrl)
-						{
-							d->TextCtrl->Visible(false);
-							d->TextCtrl->Sunken(false);
-							d->TextCtrl->Attach(this);
-						}
-					}
+				LAutoString Txt(p.NewStr());
+				if (!dynamic_cast<LTextView3*>(d->TextCtrl))
+					DeleteObj(d->TextCtrl);
+				
+				if (!d->TextCtrl)
+				{
+					d->TextCtrl = d->App->CreateTextControl(100, "text/plain", false);
 					if (d->TextCtrl)
 					{
-						d->TextCtrl->SetReadOnly(true);
-						d->TextCtrl->Name(Txt);
-					}						
+						d->TextCtrl->Visible(false);
+						d->TextCtrl->Sunken(false);
+						d->TextCtrl->Attach(this);
+					}
+				}
+
+				if (d->TextCtrl)
+				{
+					d->TextCtrl->SetReadOnly(true);
+					d->TextCtrl->Name(Txt);
 				}
 				break;
 			}
 			case MAGIC_FILTER:
 			{
 				if (!dynamic_cast<Html1::LHtml*>(d->TextCtrl))
 					DeleteObj(d->TextCtrl);
+				
 				if (!d->TextCtrl)
 				{
 					LRect c = GetClient();
 					d->TextCtrl = new Html1::LHtml(100, 0, 0, c.X(), c.Y(), d);
 					if (d->TextCtrl)
 					{
 						d->TextCtrl->Visible(false);
 						d->TextCtrl->Sunken(false);
 						d->TextCtrl->Attach(this);
 					}
 				}
+				
 				if (d->TextCtrl)
 				{
 					Filter *f = d->Item->IsFilter();
 					if (f)
 					{
 						LAutoString Desc = f->DescribeHtml();
 						if (Desc)
 						{
 							d->TextCtrl->Name(Desc);
 							d->TextCtrl->Visible(true);	
 						}
 					}
 				}						
 				break;
 			}
 		}
 	}
-	else
-	{
-		DeleteObj(d->TextCtrl);
-	}
 
 	if (d->TextCtrl)
 	{
 		d->TextCtrl->SetCaret(0, false);
 		d->TextCtrl->UnSelectAll();
 	}
 
 	OnPosChange();
-	DeleteArray(Mem);
 }
 
 void LPreviewPanel::OnPulse()
 {
 	if (d->Time > 0)
 	{
 		d->Time--;
 	}
 	else if (d->Time == 0)
 	{
 		if (d->Item == d->Pulse)
 		{
 			Mail *m = d->Item->IsMail();
 			if (m)
 			{
 				m->SetFlags(m->GetFlags() | MAIL_READ);
 			}
 		}
 
 		d->Pulse = 0;
 		d->Time = -1;
 	}
 }
 
 int LPreviewPanel::OnNotify(LViewI *v, LNotification n)
 {
 	switch (v->GetId())
 	{
 		case IDC_TEXT:
 		{
 			if (d->Item && d->TextCtrl)
 			{
 				if (n.Type == LNotifyShowImagesChanged &&
 					!d->IgnoreShowImgNotify)
 				{
 					bool LdImg = d->TextCtrl->GetLoadImages();
 					if (LdImg == true)
 					{
 						DeleteObj(d->Bar);
 						OnPosChange();
 					}
 				}
 
 				Mail *m = d->Item->IsMail();
 				if (m)
 				{
 					m->OnNotify(v, n);
 				}
 			}
 			break;
 		}
 	}
 
 	return 0;
 }
 
diff --git a/src/ScribeApp.cpp b/src/ScribeApp.cpp
--- a/src/ScribeApp.cpp
+++ b/src/ScribeApp.cpp
@@ -1,13258 +1,13260 @@
 /*
 **	FILE:			ScribeApp.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			22/10/1998
 **	DESCRIPTION:	Scribe email application
 **
 **	Copyright (C) 1998, Matthew Allen
 **		fret@memecode.com
 */
 
 // Debug defines
 // #define PRINT_OUT_STORAGE_TREE
 // #define TEST_OBJECT_SIZE
 
 #define USE_SPELLCHECKER			1
 #define USE_INTERNAL_BROWSER		1		// for help
 #define RUN_STARTUP_SCRIPTS			1
 #define PROFILE_ON_PULSE			0
 #define TRAY_CONTACT_BASE			1000
 #define TRAY_MAIL_BASE				10000
 
 // Includes
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 #include <memory>
 
 #include "Scribe.h"
 
 #include "lgi/common/StoreConvert1To2.h"
 #include "lgi/common/NetTools.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/OpenSSLSocket.h"
 #include "lgi/common/SoftwareUpdate.h"
 #include "lgi/common/Html.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/RichTextEdit.h"
 #include "lgi/common/Browser.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/Store3.h"
 #include "lgi/common/Growl.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/SpellCheck.h"
 #include "lgi/common/SubProcess.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/Map.h"
 #include "lgi/common/Charset.h"
 #include "lgi/common/RefCount.h"
 
 #include "ScribePrivate.h"
 #include "PreviewPanel.h"
 #include "ScribeStatusPanel.h"
 #include "ScribeFolderDlg.h"
 #include "ScribePageSetup.h"
 #include "Calendar.h"
 #include "CalendarView.h"
 #include "ScribeSpellCheck.h"
 #include "Store3Common.h"
 #include "PrintContext.h"
 #include "resource.h"
 #include "ManageMailStores.h"
 #include "ReplicateDlg.h"
 #include "ScribeAccountPreview.h"
 #include "Encryption/GnuPG.h"
 #include "Store3Webdav/WebdavStore.h"
 #include "resdefs.h"
 #include "../unittests/UnitTest.h"
 #include "../src/common/Coding/ScriptingPriv.h"
 
 #define DEBUG_STORE_EVENTS			0
 #if DEBUG_STORE_EVENTS
 #define LOG_STORE(...)				LgiTrace(__VA_ARGS__)
 #else
 #define LOG_STORE(...)
 #endif
 
 #define IDM_LOAD_MSG				2000
 #define RAISED_LOOK					0
 #define SUNKEN_LOOK					false
 #ifdef MAC
 #define SUNKEN_CTRL					false
 #else
 #define SUNKEN_CTRL					true
 #endif
 
 #if LGI_CARBON
 
 #define TRAY_ICON_NONE				-1
 #define TRAY_ICON_NORMAL			-1
 #define TRAY_ICON_MAIL				0
 #define TRAY_ICON_ERROR				1
 
 #elif defined(WIN32)
 
 #define TRAY_ICON_NORMAL			0
 #define TRAY_ICON_ERROR				1
 #define TRAY_ICON_MAIL				2
 #define TRAY_ICON_NONE				3
 
 #else
 
 #define TRAY_ICON_NONE				-1
 #define TRAY_ICON_NORMAL			0
 #define TRAY_ICON_ERROR				1
 #define TRAY_ICON_MAIL				2
 
 #endif
 
 char ScribeThingList[] = "com.memecode.ThingList";
 
 ScribeClipboardFmt *ScribeClipboardFmt::Alloc(bool ForFolders, size_t Size)
 {
 	ScribeClipboardFmt *obj = (ScribeClipboardFmt*) calloc(sizeof(ScribeClipboardFmt)+((Size-1)*sizeof(Thing*)), 1);
 	if (obj)
 	{
 		memcpy(obj->Magic, ForFolders ? ScribeFolderMagic : ScribeThingMagic, sizeof(obj->Magic));
 		obj->ProcessId = LAppInst->GetProcessId();
 		obj->Len = (uint32_t)Size;
 	}
 	return obj;
 }
 
 ScribeClipboardFmt *ScribeClipboardFmt::Alloc(List<Thing> &Lst)
 {
 	ScribeClipboardFmt *Fmt = Alloc(false, Lst.Length());
 	for (unsigned i=0; i<Lst.Length() && Fmt; i++)
 		Fmt->ThingAt(i, Lst[i]);
 	return Fmt;
 }
 
 ScribeClipboardFmt *ScribeClipboardFmt::Alloc(LArray<Thing*> &Arr)
 {
 	ScribeClipboardFmt *Fmt = Alloc(false, Arr.Length());
 	for (unsigned i=0; i<Arr.Length() && Fmt; i++)
 		Fmt->ThingAt(i, Arr[i]);
 	return Fmt;
 }
 
 bool ScribeClipboardFmt::Is(const char *Type, void *Ptr, size_t Bytes)
 {
 	// Do we have the minimum bytes for the structure?
 	if (Bytes >= sizeof(ScribeClipboardFmt) &&
 		Ptr != NULL)
 	{
 		ScribeClipboardFmt *This = (ScribeClipboardFmt*)Ptr;
 
 		// Check the magic is the right value
 		if (memcmp(This->Magic, Type, 4) != 0)
 			return false;
 
 		// Check it's from this process
 		if (This->ProcessId != LAppInst->GetProcessId())
 			return false;
 		
 		return true;
 	}
 
 	return false;
 }
 
 Thing *ScribeClipboardFmt::ThingAt(size_t Idx, Thing *Set)
 {
 	if (memcmp(Magic, ScribeThingMagic, 4))
 		return NULL;
 	if (Idx >= Len)
 		return NULL;
 	if (Set)
 		Things[Idx] = Set;
 	return Things[Idx];
 }
 
 ScribeFolder *ScribeClipboardFmt::FolderAt(size_t Idx, ScribeFolder *Set)
 {
 	if (memcmp(Magic, ScribeFolderMagic, 4))
 		return NULL;
 	if (Idx >= Len)
 		return NULL;
 	if (Set)
 		Folders[Idx] = Set;
 	return Folders[Idx];
 }
 
 size_t ScribeClipboardFmt::Sizeof()
 {
 	return sizeof(*this) + ((Len - 1) * sizeof(Thing*));
 }
 
 bool OptionSizeInKiB = false;
 bool ShowRelativeDates = false;
 const char *MailAddressDelimiters = "\t\r\n;,";
 
 char16 SpellDelim[] =
 {
 	' ', '\t', '\r', '\n', ',', ',', '.', ':', ';',
 	'{', '}', '[', ']', '!', '@', '#', '$', '%', '^', '&', '*',
 	'(', ')', '_', '-', '+', '=', '|', '\\', '/', '?', '\"',
 	0
 };
 
 const char *DefaultRfXml = 
 	"---------- %s ----------\n"
 	"%s: <mail.to[0].name> (<mail.to[0].email>)\n"
 	"%s: <mail.from.name> (<mail.from.email>)\n"
 	"%s: <mail.subject>\n"
 	"%s: <mail.datesent>\n"
 	"\n"
 	"<mail.bodyastext quote=scribe.quote>\n"
 	"<cursor>\n"
 	"<mail.sig>\n";
 
 uchar DateTimeFormats[] = 
 {
 	GDTF_DEFAULT,
 	
 	GDTF_DAY_MONTH_YEAR | GDTF_12HOUR,
 	GDTF_MONTH_DAY_YEAR | GDTF_12HOUR,
 	GDTF_YEAR_MONTH_DAY | GDTF_12HOUR,
 
 	GDTF_DAY_MONTH_YEAR | GDTF_24HOUR,
 	GDTF_MONTH_DAY_YEAR | GDTF_24HOUR,
 	GDTF_YEAR_MONTH_DAY | GDTF_24HOUR
 };
 
 SystemFolderInfo SystemFolders[] =
 {
 	{FOLDER_INBOX,		OPT_Inbox,		NULL},
 	{FOLDER_OUTBOX,		OPT_Outbox,		NULL},
 	{FOLDER_SENT,		OPT_Sent,		NULL},
 	{FOLDER_CONTACTS,	OPT_Contacts,	NULL},
 	{FOLDER_TRASH,		OPT_Trash,		NULL},
 	{FOLDER_CALENDAR,	OPT_Calendar,	OPT_HasCalendar},
 	{FOLDER_TEMPLATES,	OPT_Templates,	OPT_HasTemplates},
 	{FOLDER_FILTERS,	OPT_Filters,	OPT_HasFilters},
 	{FOLDER_GROUPS,		OPT_Groups,		OPT_HasGroups},
 	{FOLDER_SPAM,		OPT_SpamFolder,	OPT_HasSpam},
 	{-1, 0, 0}
 };
 
 ScribeBehaviour *ScribeBehaviour::New(ScribeWnd *app)
 {
 	return 0;
 }
 
 void ScribeOptionsDefaults(LOptionsFile *f)
 {
 	if (!f)
 		return;
 
 	f->CreateTag("Accounts");
 	f->CreateTag("CalendarUI");
 	f->CreateTag("CalendarUI.Sources");
 	f->CreateTag("MailUI");
 	f->CreateTag("ScribeUI");
 	f->CreateTag("Plugins");
 	f->CreateTag("Print");
 
 	#define DefaultIntOption(opt, def) { LVariant v; if (!f->GetValue(opt, v)) \
 											f->SetValue(opt, v = (int)def); }
 	#define DefaultStrOption(opt, def) { LVariant v; if (!f->GetValue(opt, v)) \
 											f->SetValue(opt, v = def); }
 	DefaultIntOption(OPT_DefaultAlternative, 1);
 	DefaultIntOption(OPT_BoldUnread, 1);
 	DefaultIntOption(OPT_PreviewLines, 1);
 	DefaultIntOption(OPT_AutoDeleteExe, 1);
 	DefaultIntOption(OPT_DefaultReplyAllSetting, MAIL_ADDR_BCC);
 	DefaultIntOption(OPT_BlinkNewMail, 1);
 	DefaultIntOption(OPT_MarkReadAfterSeconds, 5);
 	DefaultStrOption(OPT_BayesThreshold, "0.9");
 	DefaultIntOption(OPT_SoftwareUpdate, 1);
 	DefaultIntOption(OPT_ResizeImgAttachments, false);
 	DefaultIntOption(OPT_ResizeJpegQual, 80);
 	DefaultIntOption(OPT_ResizeMaxPx, 1024);
 	DefaultIntOption(OPT_ResizeMaxKb, 200);
 	DefaultIntOption(OPT_RegisterWindowsClient, 1);
 	DefaultIntOption(OPT_HasTemplates, 0);
 	DefaultIntOption(OPT_HasCalendar, 1);
 	DefaultIntOption(OPT_HasGroups, 1);
 	DefaultIntOption(OPT_HasFilters, 1);
 	DefaultIntOption(OPT_HasSpam, 0);
 }
 
 const char *Store3ItemTypeName(Store3ItemTypes t)
 {
 	switch (t)
 	{
 		case MAGIC_NONE:		return "MAGIC_NONE";
 		case MAGIC_BASE:		return "MAGIC_BASE";
 		case MAGIC_MAIL:		return "MAGIC_MAIL";
 		case MAGIC_CONTACT:		return "MAGIC_CONTACT";
 		// case MAGIC_FOLDER:		return "MAGIC_FOLDER";
 		case MAGIC_MAILBOX:		return "MAGIC_MAILBOX";
 		case MAGIC_ATTACHMENT:	return "MAGIC_ATTACHMENT";
 		case MAGIC_ANY:			return "MAGIC_ANY";
 		case MAGIC_FILTER:		return "MAGIC_FILTER";
 		case MAGIC_FOLDER:		return "MAGIC_FOLDER";
 		case MAGIC_CONDITION:	return "MAGIC_CONDITION";
 		case MAGIC_ACTION:		return "MAGIC_ACTION";
 		case MAGIC_CALENDAR:	return "MAGIC_CALENDAR";
 		case MAGIC_ATTENDEE:	return "MAGIC_ATTENDEE";
 		case MAGIC_GROUP:		return "MAGIC_GROUP";
 		default:
 			LAssert(0);
 			break;
 	}
 	
 	return "(error)";
 }
 
 void SetRecipients(ScribeWnd *App, char *Start, LDataIt l, EmailAddressType CC)
 {
 	while (Start && *Start)
 	{
 		LString Str;
 		char *End = strchr(Start, ',');
 		if (End)
 		{
 			Str.Set(Start, End-Start);
 			Start = End + 1;
 		}
 		else
 		{
 			Str = Start;
 			Start = 0;
 		}
 
 		if (Str)
 		{
 			ListAddr *a = new ListAddr(App);
 			if (a)
 			{
 				a->CC = CC;
 				
 				if (_strnicmp(Str, "mailto:", 7) == 0)
 					a->sAddr = Str(7,-1);
 				else
 					a->sAddr = Str;
 				
 				l->Insert(a);
 			}
 		}
 	}
 }
 
 static char SoftwareUpdateUri[] = "http://www.memecode.com/update.php";
 
 enum SoftwareStatus
 {
 	SwError,
 	SwCancel,
 	SwOutOfDate,
 	SwUpToDate
 };
 
 static LString ExtractVer(const char *s)
 {
 	char Buf[256], *Out = Buf;
 	for (const char *In = s; *In && Out < Buf + sizeof(Buf) - 1; In++)
 	{
 		if (*In == ' ')
 			break;
 		if (IsDigit(*In) || *In == '.')
 			*Out++ = *In;
 	}
 	*Out++ = 0;
 	return LString(Buf);
 }
 
 void IsSoftwareUpToDate(ScribeWnd *Parent, bool WithUI, bool IncBetas, std::function<void(SoftwareStatus, LSoftwareUpdate::UpdateInfo*)> callback)
 {
 	// LSoftwareUpdate::UpdateInfo Info
 	// Software update?
 	auto Proxy  = Parent->GetHttpProxy();
 	auto Update = new LSoftwareUpdate(AppName, SoftwareUpdateUri, Proxy);
 
 	Update->CheckForUpdate(
 		[WithUI, Parent, callback, Update](auto Info, auto errorMsg)
 		{
 			if (Info)
 			{
 				auto LocalVer = LString(ScribeVer).SplitDelimit(".");
 				LString BuildVer = ExtractVer(Info->Build);
 				auto OnlineVer = BuildVer.SplitDelimit(".");
 				if (OnlineVer.Length() != LocalVer.Length())
 				{
 					LgiTrace("%s:%i - Invalid online version number \"%s\"\n", _FL, Info->Version.Get());
 					if(callback)
 						callback(SwError, Info);
 					return;
 				}
 
 				unsigned i;
 				for(i = 0; i < OnlineVer.Length(); i++)
 				{
 					auto l = Atoi(LocalVer[i].Get());
 					auto o = Atoi(OnlineVer[i].Get());
 					if(l < o)
 					{
 						if(callback)
 							callback(SwOutOfDate, Info);
 						return;
 					}
 					if(l > o)
 					{
 						if(callback)
 							callback(SwUpToDate, Info);
 						return;
 					}
 				}
 
 				LDateTime Compile;
 				auto Date = LString(__DATE__).SplitDelimit(" ");
 				Compile.Month(LDateTime::MonthFromName(Date[0]));
 				Compile.Day(atoi(Date[1]));
 				Compile.Year(atoi(Date[2]));
 				Compile.SetTime(__TIME__);
 
 				bool DateGreaterThenCompile = Info->Date > Compile;
 				if (callback)
 					callback(DateGreaterThenCompile ? SwOutOfDate : SwUpToDate, Info);
 				return;
 			}
 			else if (WithUI)
 			{
 				if (callback)
 					callback(SwCancel, NULL);
 				LgiMsg(Parent, LLoadString(IDS_ERROR_SOFTWARE_UPDATE), AppName, MB_OK, errorMsg);
 			}
 
 			if (callback)
 				callback(SwError, NULL);
 		},
 		WithUI ? Parent : NULL,
 		IncBetas);
 }
 
 bool UpgradeSoftware(const LSoftwareUpdate::UpdateInfo *Info, ScribeWnd *Parent, bool WithUI)
 {
 	bool DownloadUpdate = true;
 
 	if (WithUI)
 	{
 		char Ds[64];
 		Info->Date.Get(Ds, sizeof(Ds));
 
 		DownloadUpdate = LgiMsg(Parent,
 								LLoadString(IDS_SOFTWARE_UPDATE_DOWNLOAD),
 								AppName,
 								MB_YESNO,
 								Info->Build.Get(),
 								Info->Uri.Get(),
 								Ds)
 							==
 								IDYES;
 	}
 
 	if (!DownloadUpdate)
 		return false;
 
 	LAutoString Proxy = Parent->GetHttpProxy();
 	LSoftwareUpdate Update(AppName, SoftwareUpdateUri, Proxy, ScribeTempPath());
 	// FIXME:
 	return false; // Update.ApplyUpdate(Info, false, Parent);
 }
 
 void SoftwareUpdate(ScribeWnd *Parent, bool WithUI, bool IncBetas, std::function<void(bool goingToUpdate)> callback)
 {
 	// Software update?
 	IsSoftwareUpToDate(Parent, WithUI, IncBetas, [WithUI, Parent, callback](auto s, auto Info)
 	{
 		if (s == SwUpToDate)
 		{
 			if (WithUI)
 				LgiMsg(Parent, LLoadString(IDS_SOFTWARE_CURRENT), AppName, MB_OK);
 			if (callback)
 				callback(false); // we're up to date
 		}
 		else if (s == SwOutOfDate)
 		{
 			auto status = UpgradeSoftware(Info, Parent, WithUI);
 			if (callback)
 				callback(status); // update is going to happen
 		}
 	});
 }
 
 const char *AppName = "Scribe";
 char HelpFile[] = "index.html";
 
 const char OptionsFileName[] = "ScribeOptions";
 
 const char AuthorEmailAddr[] = "fret@memecode.com";
 const char AuthorHomepage[] = "http://www.memecode.com";
 const char ApplicationHomepage[] = "http://www.memecode.com/scribe.php";
 const char CommercialHomepage[] = "http://www.memecode.com/inscribe.php";
 const char FaqHomepage[] = "http://www.memecode.com/scribe/faq.php";
 
 const char *DefaultFolderNames[16];
 Store3ItemTypes DefaultFolderTypes[] = {
 	MAGIC_MAIL,		// Inbox
 	MAGIC_MAIL,		// Outbox
 	MAGIC_MAIL,		// Sent
 	MAGIC_ANY,		// Trash
 	MAGIC_CONTACT,	// Contacts
 	MAGIC_MAIL,		// Templates
 	MAGIC_FILTER,	// Filters
 	MAGIC_CALENDAR,	// Calendar Events
 	MAGIC_GROUP,	// Groups
 	MAGIC_MAIL,		// Spam
 	MAGIC_NONE,
 	MAGIC_NONE,
 	MAGIC_NONE,
 	MAGIC_NONE
 };
 
 extern void Log(char *File, char *Str, ...);
 
 //////////////////////////////////////////////////////////////////////////////
 void LogMsg(char *str, ...)
 {
 	#ifdef _DEBUG
 	char f[256];
 	LMakePath(f, sizeof(f), LGetExePath(), "log.txt");
 
 	if (str)
 	{
 		char buffer[256];
 		va_list arg;
 		va_start(arg ,str);
 		vsprintf_s(buffer, sizeof(buffer), str, arg);
 		va_end(arg);
 
 		LFile File;
 		while (!File.Open(f, O_WRITE))
 		{
 			LSleep(5);
 		}
 
 		File.Seek(File.GetSize(), SEEK_SET);
 		File.Write(buffer, strlen(buffer));
 	}
 	else
 	{
 		FileDev->Delete(f, false);
 	}
 	#endif
 }
 
 LString GetFullAppName(bool Platform)
 {
 	LString Ret = AppName;
 	if (Platform)
 	{
 		LString s;
 		const char *Build = 
 			#ifndef _DEBUG
 			"Release";
 			#else
 			"Debug";
 			#endif
 		
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		const char *OsName = LGetOsName();
 		if (Os == LGI_OS_WIN9X)
 		{
 			switch (Ver[1])
 			{
 				case 0:
 					OsName = "Win95";
 					break;
 				case 10:
 					OsName = "Win98";
 					break;
 				case 90:
 					OsName = "WinME";
 					break;
 			}
 		}
 		else if (Os == LGI_OS_WIN32 ||
 				 Os == LGI_OS_WIN64)
 		{
 			if (Ver[0] < 5)
 			{
 				OsName = "WinNT";
 			}
 			else if (Ver[0] == 5)
 			{
 				if (Ver[1] == 0)
 					OsName = "Win2k";
 				else
 					OsName = "WinXP";
 			}
 			else if (Ver[0] == 6)
 			{
 				if (Ver[1] == 0)
 					OsName = "Vista";
 				else if (Ver[1] == 1)
 					OsName = "Win7";
 				else if (Ver[1] == 2)
 					OsName = "Win8";
 				else if (Ver[1] == 3)
 					OsName = "Win8.1";
 			}
 			else if (Ver[0] == 10)
 			{
 				OsName = "Win10";
 			}
 			else if (Ver[0] == 11)
 			{
 				// What's the chances eh?
 				OsName = "Win11";
 			}
 		}
 
 		s.Printf(" v%s (%s v", ScribeVer, OsName);
 		Ret += s;
 		
 		for (unsigned i=0; i<Ver.Length(); i++)
 		{
 			s.Printf("%s%i", i?".":"", Ver[i]);
 			Ret += s;
 		}
 		
 		s.Printf(", %s", Build);
 		Ret += s;
 	
 		#ifdef LINUX
 		char *Wm = 0;
 		switch (LGetWindowManager())
 		{
 			case WM_Gnome:
 				Wm = "Gnome";
 				break;
 			case WM_Kde:
 				Wm = "Kde";
 				break;
 		}
 		if (Wm)
 		{
 			s.Printf(", %s", Wm);
 			Ret += s;
 		}
 		#endif
 		
 		LLanguage *CurLang = LGetLanguageId();
 		if (CurLang)
 		{
 			s.Printf(", %s", CurLang->Id);
 			Ret += s;
 		}
 		
 		s.Printf(")");
 		Ret += s;
 	}
 	
 	return Ret;
 }
 
 bool MatchWord(char *Str, char *Word)
 {
 	bool Status = false;
 	
 	if (Str && Word)
 	{
 		#define IsWord(c)	( IsDigit(c) || IsAlpha(c) )
 		for (char *s=stristr(Str, Word); s; s=stristr(s+1, Word))
 		{
 			char *e = s + strlen(Word);
 			if (	(s<=Str || !IsWord(s[-1]) )	&&
 					(e[0] == 0 || !IsWord(e[0]))	)
 			{
 				return true;
 			}
 		}
 	}
 
 	return Status;
 }
 
 
 
 //////////////////////////////////////////////////////////////////////////////
 ScribePanel::ScribePanel(ScribeWnd *app, const char *name, int size, bool open) :
 	LPanel(name, size, open)
 {
 	App = app;
 }
 
 bool ScribePanel::Pour(LRegion &r)
 {
 	if (App)
 	{
 		SetClosedSize(App->GetToolbarHeight());
 	}
 
 	return LPanel::Pour(r);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 class NoContactType : public Contact
 {
 	LString NoFace80Path;
 	LString NoFace160Path;
 
 public:
 	NoContactType(ScribeWnd *wnd) : Contact(wnd)
 	{
 	}
 
 	Thing &operator =(Thing &c) override
 	{
 		return *this;
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array) override
 	{
 		ScribeDomType Fld = StrToDom(Name);
 		int Px = Array ? atoi(Array) : 80;
 		LString &Str = Px == 160 ? NoFace160Path : NoFace80Path;
 
 		if (!Str)
 		{
 			LString f;
 			f.Printf("NoFace%i.png", Px);
 			Str = LFindFile(f);
 			LAssert(Str != NULL); // This should always resolve.
 		}
 
 		if (!Str)
 			return false;
 
 		if (Fld == SdImageHtml)
 		{
 			LString html;
 			html.Printf("<img src='file://%s'>\n", Str.Get());
 			Value = html;
 			return true;
 		}
 		else if (Fld == SdImage)
 		{
 			Value = Str;
 			return true;
 		}
 
 		return false;
 	}
 };
 
 class ScribeWndPrivate :
 	public LBrowser::LBrowserEvents,
 	public LVmCallback,
 	public LHtmlStaticInst
 {
 	LOptionsFile::PortableType InstallMode = LOptionsFile::UnknownMode;
 
 public:
 	ScribeWnd		*App;
 	
 	uint64          LastTs = 0;
 	int				ClipboardFormat = 0;
 	LFont			*PreviewFont = NULL;
 	int				PrintMaxPages = -1;
 	int				NewMailTimeout = -1;
 	bool			SendAfterReceive = false;
 	bool			IngoreOnClose = false;
 	LAutoString		UiTags;
 	LAutoPtr<LGrowl> Growl;
 	LArray<Contact*> TrayMenuContacts;
 	bool            ExitAfterSend = false;
 	LToolButton		*ShowConsoleBtn = NULL;
 	LString			MulPassword;
 	LString			CalendarSummary;
 	LBox			*SubSplit = NULL, *SearchSplit = NULL;
 	LArray<ScribeFolder*> ThingSources;
 	int				LastLayout = 0;
 	LMenuItem		*DisableUserFilters = NULL;
 	LAutoPtr<LOptionsFile> Options;
 	HttpImageThread	*ImageLoader = NULL;
 	int				LastMinute = -1, LastHour = -1;
 	LArray<LDataEventsI*> Store3EventCallbacks;
 	LAutoPtr<LPrinter> PrintOptions;
 	LHashTbl<IntKey<SribeResourceType,ResNone>, LString> ResFiles;
 
 	// These are for the LDataEventsI callbacks to store source context
 	// Mainly for debugging where various events came from.
 	const char		*CtxFile = NULL;
 	int				CtxLine = 0;
 
 	// Contact no face images
 	LAutoRefPtr<NoContactType> NoContact;
 	
 	// Remote content white/blacklists
 	bool RemoteContent_Init = false;
 	LString::Array RemoteWhiteLst, RemoteBlackLst;
 
 	// Spell checking
 	int AppWndHnd;
 	LAutoPtr<LSpellCheck> SpellerThread;
 
 	// Missing caps
 	LCapabilityTarget::CapsHash MissingCaps;
 	MissingCapsBar *Bar = NULL;
 	LString ErrSource; // Script file that has an error.
 	Filter *ErrFilter = NULL; // Filter that has scripting error.
 
 	// Load state
 	bool			FoldersLoaded = false;	
 
 	// Bayesian filter
 	LStringPipe BayesLog;
 
 	// Thread item processing
 	LArray<MailTransferEvent*> Transfers;
 
 	// Scripting...
 	LAutoPtr<LScriptEngine> Engine;
 	LArray<LScript*> Scripts;
 	LArray<LScript*> CurrentScripts;
 	LScript *CurrentScript() { return CurrentScripts.Length() ? CurrentScripts.Last() : NULL; }
 	int NextToolMenuId = IDM_TOOL_SCRIPT_BASE;
 	LAutoPtr<LScriptUi> ScriptToolbar;
 	LArray<LScriptCallback*> OnSecondTimerCallbacks;
 
 	// Encryption
 	LAutoPtr<GpgConnector> GpgInst; 
 
 	// Unit tests
 	LAutoPtr<LUnitTestServer> UnitTestServer;
 
 	class ScribeTextControlFactory : public LViewFactory
 	{
 		ScribeWnd *Wnd;
 
 		LView *NewView(const char *Class, LRect *Pos, const char *Text)
 		{
 			if (!_stricmp(Class, "ScribeTextView"))
 				return Wnd->CreateTextControl(-1, 0, true);
 			return NULL;
 		}
 
 	public:
 		ScribeTextControlFactory(ScribeWnd *wnd)
 		{
 			Wnd = wnd;
 		}
 	} TextControlFactory;
 
 	ScribeWndPrivate(ScribeWnd *app) :
 		App(app),
 		TextControlFactory(app)
 	{
 		NoContact = new NoContactType(app);
 		NoContact->DecRef(); // 2->1
 		AppWndHnd = LEventSinkMap::Dispatch.AddSink(App);
 
 		#ifdef WIN32
 		ClipboardFormat = RegisterClipboardFormat(
 			#ifdef UNICODE
 			L"Scribe.Item"
 			#else
 			"Scribe.Item"
 			#endif
 			);
 		#endif
 
 		LScribeScript::Inst = new LScribeScript(App);
 		if (Engine.Reset(new LScriptEngine(App, LScribeScript::Inst, this)))
 			Engine->SetConsole(LScribeScript::Inst->GetLog());
 	}
 
 	~ScribeWndPrivate()
 	{
 		// Why do we need this? ~LView will take care of it?
 		// LEventSinkMap::Dispatch.RemoveSink(App);
 		Options.Reset();
 		Scripts.DeleteObjects();
 		DeleteObj(ImageLoader);
 		Engine.Reset();
 		DeleteObj(LScribeScript::Inst);
 	}
 
 	LGrowl *GetGrowl()
 	{
 		if (!Growl &&
 			Growl.Reset(new LGrowl))
 		{
 			LAutoPtr<LGrowl::LRegister> r(new LGrowl::LRegister);
 			r->App = "Scribe";
 			r->IconUrl = "http://memecode.com/images/scribe/growl-app.png";
 			
 			LGrowl::LNotifyType &NewMail = r->Types.New();
 			NewMail.Name = "new-mail";
 			NewMail.IconUrl = "http://memecode.com/images/scribe/growl-new-mail.png";
 			NewMail.Enabled = true;
 
 			LGrowl::LNotifyType &Cal = r->Types.New();
 			Cal.Name = "calendar";
 			Cal.IconUrl = "http://memecode.com/images/scribe/growl-calendar.png";
 			Cal.Enabled = true;
 
 			LGrowl::LNotifyType &Debug = r->Types.New();
 			Debug.Name = "debug";
 			Debug.IconUrl = "http://memecode.com/images/scribe/growl-bug.png";
 			Debug.Enabled = false;
 
 			LGrowl::LNotifyType &Info = r->Types.New();
 			Info.IconUrl = "http://memecode.com/images/scribe/growl-note.png";
 			Info.Name = "info";
 			Info.Enabled = true;
 
 			Growl->Register(r);
 		}
 		
 		return Growl;
 	}
 
 	LVmDebugger *AttachVm(LVirtualMachine *Vm, LCompiledCode *Code, const char *Assembly)
 	{
 		LVariant v;
 		if (Options)
 			Options->GetValue(OPT_ScriptDebugger, v);
 		if (v.CastInt32())
 			return new LVmDebuggerWnd(App, this, Vm, Code, NULL);
 		
 		return NULL;
 	}
 
 	bool CallCallback(LVirtualMachine &Vm, LString CallbackName, LScriptArguments &Args)
 	{
 		for (auto s: Scripts)
 		{
 			if (!s->Code)
 				continue;
 
 			auto Method = s->Code->GetMethod(CallbackName);
 			if (!Method)
 				continue;
 
 			auto Status = Vm.ExecuteFunction(s->Code, Method, Args);
 			return Status > ScriptError;
 		}
 
 		Vm.SetDebuggerEnabled(true); // Lets show the UI when we throw the callback not found error.
 		Args.Throw(_FL, "There is no function '%s' for callback.", CallbackName.Get());
 		return false;
 	}
 
 	bool CompileScript(LAutoPtr<LCompiledCode> &Output, const char *FileName, const char *Source)
 	{
 		LCompiler c;
 		return c.Compile(Output, Engine->GetSystemContext(), LScribeScript::Inst, FileName, Source, NULL);
 	}
 
 	bool OnSearch(LBrowser *br, const char *txt)
 	{
 		char Path[256];
 		if (!App->GetHelpFilesPath(Path, sizeof(Path)))
 			return false;
 
 		auto Terms = LString(txt).SplitDelimit(", ");
 
 		LStringPipe p;
 		p.Print("<html>\n<body><h1>Search Results</h1>\n<ul>\n");
 		LDirectory Dir;
 		for (int b = Dir.First(Path, "*.html"); b; b = Dir.Next())
 		{
 			if (!Dir.IsDir())
 			{
 				char Path[256];
 				Dir.Path(Path, sizeof(Path));
 				LFile f;
 				if (f.Open(Path, O_READ))
 				{
 					LXmlTree t(GXT_NO_DOM);
 					LXmlTag r;
 					if (t.Read(&r, &f))
 					{
 						char *PrevName = 0;
 						char PrevUri[256] = "";
 						for (auto c: r.Children)
 						{
 							if (c->IsTag("a"))
 							{
 								char *Name = c->GetAttr("name");
 								if (Name)
 								{
 									PrevName = Name;
 								}
 							}
 							else if (c->GetContent())
 							{
 								bool Hit = false;
 								for (unsigned i=0; !Hit && i<Terms.Length(); i++)
 								{
 									Hit = stristr(c->GetContent(), Terms[i]) != 0;
 								}
 								if (Hit)
 								{
 									LStringPipe Uri(256);
 									char *Leaf = strrchr(Path, DIR_CHAR);
 									Leaf = Leaf ? Leaf + 1 : Path;
 									
 									Uri.Print("file://%s", Path);
 									if (PrevName)
 										Uri.Print("#%s", PrevName);
 									
 									LAutoString UriStr(Uri.NewStr());
 									
 									if (_stricmp(UriStr, PrevUri))
 									{
 										p.Print("<li> <a href='%s'>%s",
 												UriStr.Get(),
 												Leaf);
 										if (PrevName)
 											p.Print("#%s", PrevName);
 										p.Print("</a>\n");
 										
 										strcpy_s(PrevUri, sizeof(PrevUri), UriStr);
 									}
 								}
 							}
 						}
 					}
 				}
 			}
 		}
 
 		p.Print("</ul>\n</body>\n</html>\n");
 		LAutoString Html(p.NewStr());
 		br->SetHtml(Html);
 		return true;
 	}
 
 	void AskUserForInstallMode(std::function<void(LOptionsFile::PortableType)> callback)
 	{
 		auto Dlg = new LAlert(App,
 							AppName,
 							LLoadString(IDS_PORTABLE_Q),
 							LLoadString(IDS_HELP),
 							LLoadString(IDS_DESKTOP),
 							LLoadString(IDS_PORTABLE));
 		
 		Dlg->SetButtonCallback(1, [this](auto idx)
 		{
 			App->LaunchHelp("install.html");
 		});
 
 		Dlg->DoModal([callback](auto dlg, auto Btn)
 		{
 			if (Btn == 1)
 			{
 				// Help
 				LAssert(!"Help btn should use callback.");
 			}
 			else if (Btn == 2)
 			{
 				// Desktop
 				if (callback)
 					callback(LOptionsFile::DesktopMode);
 			}
 			else if (Btn == 3)
 			{
 				// Portable
 				if (callback)
 					callback(LOptionsFile::PortableMode);
 			}
 			else
 			{
 				delete dlg;
 				LAppInst->Exit(1);
 			}
 
 			delete dlg;
 		});
 	}
 
 	LOptionsFile::PortableType GetInstallMode()
 	{
 		if (InstallMode == LOptionsFile::UnknownMode)
 		{
 			if (LAppInst->GetOption("portable"))
 			{
 				InstallMode = LOptionsFile::PortableMode;
 				LgiTrace("Selecting portable mode based on -portable switch.\n");
 			}
 			else if (LAppInst->GetOption("desktop"))
 			{
 				InstallMode = LOptionsFile::DesktopMode;
 				LgiTrace("Selecting portable mode based on -desktop switch.\n");
 			}
 		}
 
 		if (InstallMode == LOptionsFile::UnknownMode)
 		{
 			bool PortableIsPossible = true;
 			
 			char Inst[MAX_PATH_LEN] = "";
 			LGetSystemPath(LSP_APP_INSTALL, Inst, sizeof(Inst));
 			
 			// Do write check
 			char Wr[MAX_PATH_LEN];
 			LMakePath(Wr, sizeof(Wr), Inst, "_write_test.txt");
 			LFile f;
 			if (f.Open(Wr, O_WRITE))
 			{
 				// Clean up
 				f.Close();
 				FileDev->Delete(Wr, false);
 			}
 			else
 			{
 				// No write perms
 				PortableIsPossible = false;
 			}
 			
 			if (PortableIsPossible && LAppInst->IsElevated())
 			{
 				// Check if the install is in some read only location:
 				// e.g. c:\Program Files
 				char Pm[MAX_PATH_LEN];
 				if (LGetSystemPath(LSP_USER_APPS, Pm, sizeof(Pm)))
 				{
 					size_t n = strlen(Pm);
 					PortableIsPossible = _strnicmp(Pm, Inst, n) != 0;
 					// LgiMsg(App, "%i\n%s\n%s", AppName, MB_OK, PortableIsPossible, Pm, Inst);
 				}
 				else LgiTrace("%s:%i - Failed to get paths.", _FL);
 			}
 
 			if (PortableIsPossible)
 			{
 				// Basically "ask the user" here...
 				return LOptionsFile::UnknownMode;
 			}
 			else
 			{
 				InstallMode = LOptionsFile::DesktopMode;
 				LgiTrace("Selecting Desktop based on lack of write permissions to install folder.\n");
 			}
 		}
 
 		return InstallMode;
 	}
 
 	void SetInstallMode(LOptionsFile::PortableType t)
 	{
 		InstallMode = t;
 	}
 
 	void DeleteCallbacks(LArray<LScriptCallback> &Callbacks)
 	{
 		for (unsigned i=0; i<Callbacks.Length(); i++)
 		{
 			if (Callbacks[i].Type == LToolsMenu &&
 				Callbacks[i].Param)
 			{
 				auto it = App->GetMenu()->FindItem(Callbacks[i].Param);
 				if (it)
 				{
 					it->Remove();
 					DeleteObj(it);
 				}
 			}
 		}
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 void UpgradeRfOption(ScribeWnd *App, const char *New, const char *Old, const char *Default)
 {
 	LVariant v;
 
 	/*
 	App->GetOptions()->GetValue(New, v);
 	if (v.Str())
 	{
 		ScribePath *Path = new ScribePath(App, Old);
 		if (Path)
 		{
 			char *Xml = LReadTextFile(*Path);
 			if (Xml)
 			{
 				App->GetOptions()->SetValue(New, v = Xml);
 				DeleteArray(Xml);
 			}
 			App->GetOptions()->DeleteValue(Old);
 			DeleteObj(Path);
 		}
 	}
 	*/
 
 	if (Default && !App->GetOptions()->GetValue(New, v))
 	{
 		App->GetOptions()->SetValue(New, v = Default);
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////
 ScribeWnd::AppState ScribeWnd::ScribeState = ScribeConstructing;
 
 
 /*
  * This constructor is a little convoluted, but the basic idea is this:
  * 
  * - Do some basic init.
  * - Attempt to load the options (could make portable/desktop mode clear)
  * - If the portable/desktop mode is unclear ask the user.
  * - Call AppConstruct1.
  * - If the UI language is not known, ask the user.
  * - Call AppConstruct2.
  * 
  * Each time a dialog is needed the rest of the code needs to be in a callable function.
  * 
  * It's important to note that the ScribeWnd::OnCreate method needs to be called after
  * the system Handle() is created, and after any dialogs in the ScribeWnd::ScribeWnd
  * constructor have finished.
  */
 ScribeWnd::ScribeWnd() :
 	BayesianFilter(this),
 	CapabilityInstaller("Scribe",
 						ScribeVer,
 						"http://memecode.com/components/lookup.php",
 						ScribeTempPath()),
 	TrayIcon(this)
 {
 	if (_Lock)
 		_Lock->SetName("ScribeWnd");
 
 	// init some variables
 	LApp::ObjInstance()->AppWnd = this;
 	LCharsetSystem::Inst()->DetectCharset = ::DetectCharset;
 	d = new ScribeWndPrivate(this);
 	ScribeIpc = new LSharedMemory("Scribe", SCRIBE_INSTANCE_MAX * sizeof(ScribeIpcInstance));
 	if (ScribeIpc && ScribeIpc->GetPtr())
 	{
 		ScribeIpcInstance *InstLst = (ScribeIpcInstance*) ScribeIpc->GetPtr();
 		for (int i=0; i<SCRIBE_INSTANCE_MAX; i++)
 		{
 			if (InstLst[i].Valid())
 			{
 				if (!LIsProcess(InstLst[i].Pid))
 				{
 					LgiTrace("Crashed instance %i\n", InstLst[i].Pid);
 					InstLst[i].Clear();
 				}
 			}
 			else if (!ThisInst)
 			{
 				ThisInst = InstLst + i;
 				memset(ThisInst, 0, sizeof(ScribeIpcInstance));
 				ThisInst->Magic = SCRIBE_INSTANCE_MAGIC;
 				ThisInst->Pid = LProcessId();
 				
 				// LgiTrace("Install Scribe pid=%i to pos=%i\n", LProcessId(), i);
 			}
 		}
 	}
 	else DeleteObj(ScribeIpc);
 
 	#ifndef WIN32
 	printf("%s\n", GetFullAppName(true).Get());
 	#endif
 
 	auto Type = d->GetInstallMode();
 
 	if (Type == LOptionsFile::UnknownMode)
 	{
 		 // This may make the mode more clear...
 		if (LoadOptions())
 			Type = d->GetInstallMode();
 	}
 
 	if (Type == LOptionsFile::UnknownMode)
 	{
 		d->AskUserForInstallMode([this](auto selectedMode)
 		{
 			d->SetInstallMode(selectedMode);
 
 			if (!d->Options)
 				d->Options.Reset(new LOptionsFile(selectedMode, OptionsFileName));
 
 			Construct1();
 		});
 	}
 	else Construct1();
 }
 
 void ScribeWnd::Construct1()
 {
 	if (!d->Options && !LoadOptions())
 	{
 		ScribeState = ScribeExiting;
 		return;
 	}
 	ScribeOptionsDefaults(d->Options);
 
 	LVariant GlyphSub;
 	if (GetOptions()->GetValue(OPT_GlyphSub, GlyphSub))
 	{
 		bool UseGlyphSub = GlyphSub.CastInt32() != 0;
 		LSysFont->SubGlyphs(UseGlyphSub);
 		LSysBold->SubGlyphs(UseGlyphSub);
 		LFontSystem::Inst()->SetDefaultGlyphSub(UseGlyphSub);
 	}
 	else
 	{
 		GetOptions()->SetValue(OPT_GlyphSub, GlyphSub = LFontSystem::Inst()->GetDefaultGlyphSub());
 	}
 
 	{
 		// Limit the size of the 'Scribe.txt' log file
 		char p[MAX_PATH_LEN];
 		if (LgiTraceGetFilePath(p, sizeof(p)))
 		{
 			int64 Sz = LFileSize(p);
 			#define MiB * 1024 * 1024
 			if (Sz > (3 MiB))
 				FileDev->Delete(p);
 		}
 	}
 
 	// Process pre-UI options
 	LVariant SizeAdj;
 	int SzAdj = SizeAdj.CastInt32();
 	if (GetOptions()->GetValue(OPT_UiFontSize, SizeAdj) &&
 		(SzAdj = SizeAdj.CastInt32()) >= 0 &&
 		SzAdj < 5)
 	{
 		SzAdj -= 2;
 		if (SzAdj)
 		{
 			int Pt = LSysFont->PointSize();
 		
 			LSysFont->PointSize(Pt + SzAdj);
 			LSysFont->Create();
 
 			LSysBold->PointSize(Pt + SzAdj);
 			LSysBold->Create();
 		
 			LFont *m = LMenu::GetFont();
 			if (m)
 			{
 				m->PointSize(m->PointSize() + SzAdj);
 				m->Create();
 			}
 		}
 	}
 	else
 	{
 		GetOptions()->SetValue(OPT_UiFontSize, SizeAdj = 2);
 	}
 
 	// Resources and languages
 	SetLanguage();
 
 	// If no language set...
 	LVariant LangId;
 	if (!GetOptions()->GetValue(OPT_UiLanguage, LangId))
 	{
 		// Ask the user...
 		auto Dlg = new LanguageDlg(this);
 		if (!Dlg->Ok)
 		{
 			delete Dlg;
 			LgiMsg(this, "Failed to create language selection dialog.", "Scribe Error");
 			ScribeState = ScribeExiting;
 			LCloseApp();
 		}
 		else
 		{
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 				{
 					// Set the language in the options file
 					LVariant v;
 					GetOptions()->SetValue(OPT_UiLanguage, v = Dlg->Lang.Get());
 		
 					// Reload the resource file... to get the new lang.
 					LResources *Cur = LgiGetResObj(false);
 					DeleteObj(Cur);
 
 					SetLanguage();
 					Construct2();
 				}
 				else // User canceled
 				{
 					ScribeState = ScribeExiting;
 					LCloseApp();
 				}
 				delete dlg;
 			});
 		}
 	}
 	else Construct2();
 }
 
 void ScribeWnd::Construct2()
 {
 	#if 1
 	auto CurRes = LgiGetResObj(false);
 	LVariant Theme;
 	if (CurRes && GetOptions()->GetValue(OPT_Theme, Theme))
 	{
 		auto Paths = ScribeThemePaths();
 		auto NoTheme = LLoadString(IDS_DEFAULT);
 		if (Theme.Str() &&
 			Stricmp(NoTheme, Theme.Str()))
 		{
 			for (auto p: Paths)
 			{
 				LFile::Path Inst(p);
 				Inst += Theme.Str();
 				if (Inst.Exists())
 				{
 					CurRes->SetThemeFolder(Inst);
 					d->Static->OnSystemColourChange();
 					break;
 				}
 			}
 		}
 	}
 	#endif
 
 	LoadCalendarStringTable();
 
 	ZeroObj(DefaultFolderNames);
 	DefaultFolderNames[FOLDER_INBOX]     = LLoadString(IDS_FOLDER_INBOX, "Inbox");
 	DefaultFolderNames[FOLDER_OUTBOX]    = LLoadString(IDS_FOLDER_OUTBOX, "Outbox");
 	DefaultFolderNames[FOLDER_SENT]      = LLoadString(IDS_FOLDER_SENT, "Sent");
 	DefaultFolderNames[FOLDER_TRASH]     = LLoadString(IDS_FOLDER_TRASH, "Trash");
 	DefaultFolderNames[FOLDER_CONTACTS]  = LLoadString(IDS_FOLDER_CONTACTS, "Contacts");
 	DefaultFolderNames[FOLDER_TEMPLATES] = LLoadString(IDS_FOLDER_TEMPLATES, "Templates");
 	DefaultFolderNames[FOLDER_FILTERS]   = LLoadString(IDS_FOLDER_FILTERS, "Filters");
 	DefaultFolderNames[FOLDER_CALENDAR]  = LLoadString(IDS_FOLDER_CALENDAR, "Calendar");
 	DefaultFolderNames[FOLDER_GROUPS]    = LLoadString(IDS_FOLDER_GROUPS, "Groups");
 	DefaultFolderNames[FOLDER_SPAM]      = LLoadString(IDS_SPAM, "Spam");
 
 	LStringPipe RfXml;
 	RfXml.Print(DefaultRfXml,
 				LLoadString(IDS_ORIGINAL_MESSAGE),
 				LLoadString(FIELD_TO),
 				LLoadString(FIELD_FROM),
 				LLoadString(FIELD_SUBJECT),
 				LLoadString(IDS_DATE));
 	{
 		LAutoString Xml(RfXml.NewStr());
 		UpgradeRfOption(this, OPT_TextReplyFormat, "ReplyXml", Xml);
 		UpgradeRfOption(this, OPT_TextForwardFormat, "ForwardXml", Xml);
 	}
 
 	LFontType t;
 	if (t.GetSystemFont("small"))
 	{
 		d->PreviewFont = t.Create();
 		if (d->PreviewFont)
 		{
 			#if defined WIN32
 			d->PreviewFont->PointSize(8);
 			#endif
 		}
 	}
 
 	MoveOnScreen();
 
 	// Load global graphics
 	LoadImageResources();
 
 	// Load time threads
 	// Window name
 	Name(AppName);
 	SetSnapToEdge(true);
 	ClearTempPath();
 
 	#if WINNATIVE
 	SetStyle(GetStyle() & ~WS_VISIBLE);
 	SetExStyle(GetExStyle() & ~WS_EX_ACCEPTFILES);
 	CreateClassW32(AppName, LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_APP)));
 	#endif
 
 	#if defined LINUX
 	SetIcon("About64px.png");
 	LFinishXWindowsStartup(this);
 	#endif
 
 	ScribeState = ScribeConstructed;
 	OnCreate();
 }
 
 void ScribeWnd::Construct3()
 {
 	if (ScribeState == ScribeConstructing)
 	{
 		// Constructor is still running, probably showing some UI.
 		// Don't complete setup at this point.
 		return;
 	}
 
 	// Load the styles
 	LResources::StyleElement(this);
 
 	// Main menu
 	Menu = new LMenu(AppName);
 	if (Menu)
 	{
 		Menu->Attach(this);
 		if (Menu->Load(this, "ID_MENU", GetUiTags()))
 		{
 			LAssert(ImageList != NULL);
 			Menu->SetImageList(ImageList, false);
 
 			auto IdentityItem = Menu->FindItem(IDM_NO_IDENTITIES);
 			if (IdentityItem)
 			{
 				IdentityMenu = IdentityItem->GetParent();
 			}
 
 			CmdSend.MenuItem = Menu->FindItem(IDM_SEND_MAIL);
 			auto NewMailMenu = Menu->FindItem(IDM_NEW_EMAIL);
 			if (NewMailMenu)
 			{
 				MailMenu = NewMailMenu->GetParent();
 			}
 
 			LVariant v;
 			WorkOffline = Menu->FindItem(IDM_WORK_OFFLINE);
 			if (WorkOffline && GetOptions()->GetValue(OPT_WorkOffline, v))
 			{
 				WorkOffline->Checked(v.CastInt32() != 0);
 			}
 
 			if ((d->DisableUserFilters = Menu->FindItem(IDM_FILTERS_DISABLE)))
 			{
 				if (GetOptions()->GetValue(OPT_DisableUserFilters, v))
 				{
 					d->DisableUserFilters->Checked(v.CastInt32() != 0);
 				}
 			}
 
 			#if RUN_STARTUP_SCRIPTS
 			// Run scripts in './Scripts' folder
 			char s[MAX_PATH_LEN];
 			LMakePath(s, sizeof(s), ScribeResourcePath(),
 				"scripts");
 			if (!LDirExists(s))
 				LMakePath(s, sizeof(s), LGetSystemPath(LSP_APP_INSTALL),
 					#if defined(LINUX) || defined(WINDOWS)
 					"..\\"
 					#endif
 					"scripts");
 			if (!LDirExists(s))
 				LgiTrace("%s:%i - Error: the scripts folder '%s' doesn't exist.\n", _FL, s);
 			else
 			{
 				bool ErrorDsp = false;
 				LDirectory Dir;
 				for (int b = Dir.First(s); b; b = Dir.Next())
 				{
 					if (Dir.IsDir())
 						continue;
 
 					char *Ext = LGetExtension(Dir.GetName());
 					if (!Ext || _stricmp(Ext, "script") != 0)
 						continue;
 
 					Dir.Path(s, sizeof(s));
 
 					LStringPipe Log;
 					char *Source = LReadTextFile(s);
 					if (Source)
 					{
 						LScript *Cur = new LScript;
 						if (Cur)
 						{
 							char Msg[256];
 							d->CurrentScripts.Add(Cur);
 							LScribeScript::Inst->GetLog()->Write(Msg,
 								sprintf_s(Msg, sizeof(Msg), "Compiling '%s'...\n", Dir.GetName()));
 
 							LCompiler c;
 							if (c.Compile(	Cur->Code,
 											d->Engine->GetSystemContext(),
 											LScribeScript::Inst,
 											s,
 											Source,
 											NULL))
 							{
 								LFunctionInfo *Main = Cur->Code->GetMethod("Main");
 								if (Main)
 								{
 									LVirtualMachine Vm(d);
 									
 									LScriptArguments Args(&Vm);
 									Args.New() = new LVariant((LDom*)this);
 									d->Scripts.Add(Cur);
 									if (Vm.ExecuteFunction(	Cur->Code,
 															Main,
 															Args,
 															LScribeScript::Inst->GetLog()) &&
 										Args.GetReturn()->CastInt32())
 									{
 										d->CurrentScripts.Delete(Cur, true);
 										Cur = NULL;
 									}
 									else
 									{
 										LgiTrace("Error: Script's main failed (%s)\n", Cur->Code->GetFileName());
 										if (Cur->Callbacks.Length())
 											d->DeleteCallbacks(Cur->Callbacks);
 										d->Scripts.Delete(Cur);
 									}
 
 									Args.DeleteObjects();
 								}
 							}
 							else if (!ErrorDsp)
 							{
 								ErrorDsp = true;
 								OnScriptCompileError(Source, NULL);
 							}
 
 							if (Cur)
 							{
 								d->CurrentScripts.Delete(Cur, true);
 								DeleteObj(Cur);
 							}
 						}
 
 						DeleteArray(Source);
 					}
 				}
 
 			}
 			#endif
 
 			#define EnableItem(id, en) { auto i = Menu->FindItem(id); if (i) i->Enabled(en); }
 			#define SetMenuIcon(id, ico) { auto i = Menu->FindItem(id); if (i) i->Icon(ico); }
 			
 			EnableItem(IDM_IMPORT_OUTLOOK_ITEMS, true);
 			
 			// SetMenuIcon(IDM_OPEN_FOLDERS, ICON_OPEN_FOLDER);
 			SetMenuIcon(IDM_OPTIONS, ICON_OPTIONS);
 			SetMenuIcon(IDM_SECURITY, ICON_LOCK);
 
 			SetMenuIcon(IDM_CUT, ICON_CUT);
 			SetMenuIcon(IDM_COPY, ICON_COPY);
 			SetMenuIcon(IDM_PASTE, ICON_PASTE);
 
 			SetMenuIcon(IDM_LAYOUT1, ICON_LAYOUT1);
 			SetMenuIcon(IDM_LAYOUT2, ICON_LAYOUT2);
 			SetMenuIcon(IDM_LAYOUT3, ICON_LAYOUT3);
 			SetMenuIcon(IDM_LAYOUT4, ICON_LAYOUT4);
 			SetMenuIcon(IDM_NEW_EMAIL, ICON_UNSENT_MAIL);
 			SetMenuIcon(IDM_SET_READ, ICON_READ_MAIL);
 			SetMenuIcon(IDM_SET_UNREAD, ICON_UNREAD_MAIL);
 			SetMenuIcon(IDM_NEW_CONTACT, ICON_CONTACT);
 			SetMenuIcon(IDM_NEW_GROUP, ICON_CONTACT_GROUP);
 			SetMenuIcon(IDM_REPLY, ICON_FLAGS_REPLY);
 			SetMenuIcon(IDM_REPLY_ALL, ICON_FLAGS_REPLY);
 			SetMenuIcon(IDM_FORWARD, ICON_FLAGS_FORWARD);
 			SetMenuIcon(IDM_BOUNCE, ICON_FLAGS_BOUNCE);
 			SetMenuIcon(IDM_NEW_FILTER, ICON_FILTER);
 			SetMenuIcon(IDM_FILTER_CURRENT_FOLDER, ICON_FOLDER_FILTERS);
 			SetMenuIcon(IDM_MEMECODE, ICON_LINK);
 			SetMenuIcon(IDM_HOMEPAGE, ICON_LINK);
 			SetMenuIcon(IDM_SCRIBE_FAQ, ICON_LINK);
 			SetMenuIcon(IDM_INSCRIBE_LINK, ICON_LINK);
 			SetMenuIcon(IDM_VERSION_HISTORY, ICON_LINK);
 			SetMenuIcon(IDM_DEBUG_INFO, ICON_LINK);
 			SetMenuIcon(IDM_TUTORIALS, ICON_LINK);
 			SetMenuIcon(IDM_FEEDBACK, ICON_UNREAD_MAIL);
 			SetMenuIcon(IDM_HELP, ICON_HELP);
 
 			LMenuItem *mi;
 			if
 			(
 				GetOptions()->GetValue(OPT_EditControl, v) &&
 				(mi = Menu->FindItem(IDM_HTML_EDITOR))
 			)
 				mi->Checked(v.CastInt32() != 0);
 
 			Menu->SetPrefAndAboutItems(IDM_OPTIONS, IDM_ABOUT);
 		}
 	}
 
 	// Initialize user interface
 	SetupUi();
 
 	// Get some of the base submenu pointers. These are needed
 	// for SetupAccounts to work correctly, e.g. populate the
 	// send/receive/preview submenus. Folders need to be loaded
 	// before this for the templates folder
 	BuildDynMenus();
 
 	// Load accounts
 	SetupAccounts();
 
 	// Recursively load folder tree
 	LoadFolders([this](auto status)
 	{
 		// Redo it for the templates... now that load folders has completed.
 		BuildDynMenus();
 
 		if (ScribeState == ScribeExiting)
 			return;
 
 		// Process command line
 		OnCommandLine();
 
 		// Update the templates sub-menu now that the folders are loaded
 		BuildDynMenus();
 
 		// Check registry settings
 		SetDefaultHandler();
 
 		// Run on load scripts...
 		LArray<LScriptCallback*> OnLoadCallbacks;
 		if (GetScriptCallbacks(LOnLoad, OnLoadCallbacks))
 		{
 			for (auto r: OnLoadCallbacks)
 			{
 				LVirtualMachine Vm;
 				LScriptArguments Args(&Vm);
 				Args.New() = new LVariant(this);
 				ExecuteScriptCallback(*r, Args);
 				Args.DeleteObjects();
 			}
 		}
 	
 		ScribeState = ScribeRunning;
 	});
 }
 
 void ScribeWnd::SetLanguage()
 {
 	LVariant LangId;
 	if (GetOptions()->GetValue(OPT_UiLanguage, LangId))
 	{
 		// Set the language to load...
 		LAppInst->SetConfig("Language", LangId.Str());
 	}
 	LResources::SetLoadStyles(true);
 
 	// Load the resources (with the current lang)
 	if (!LgiGetResObj(true, "Scribe"))
 	{
 		LgiMsg(NULL, "The resource file 'Scribe.lr8' is missing.", AppName);
 		ScribeState = ScribeExiting;
 		LCloseApp();
 	}
 }
 
 ScribeWnd::~ScribeWnd()
 {
 	LAppInst->AppWnd = 0;
 	SearchView = NULL;
 	ScribeState = ScribeExiting;
 	LScribeScript::Inst->ShowScriptingWindow(false);
 
 	// Other cleanup...
 	ClearTempPath();
 	ShutdownIpc();
 	SetPulse();
 
 	// Save anything thats still dirty in the folders...
 	// just in case we crash during the shutdown phase.
 	ScribeFolder *Cur = GetCurrentFolder();
 	if (Cur)
 		Cur->SerializeFieldWidths();
 	SaveDirtyObjects(5000);
 
 	// Tell the UI not to reference anything in the folders
 	if (PreviewPanel)
 	{
 		PreviewPanel->OnThing(0, false);
 	}
 	Mail::NewMailLst.Empty();
 
 	// ~AccountStatusItem references the account list... must be before we
 	// delete the accounts.
 	DeleteObj(StatusPanel);
 
 	// ~Accountlet needs to reference the root container... so
 	// it has to go before unloading of folders.
 	Accounts.DeleteObjects();
 
 	UnLoadFolders();
 
 	DeleteObj(PreviewPanel);
 	SaveOptions();
 	DeleteObj(Commands);
 	DeleteObj(d->PreviewFont);
 	DeleteObj(d->SubSplit);
 	DeleteObj(Splitter);
 	MailList = NULL;
 
 	CmdSend.ToolButton = NULL;
 	CmdReceive.ToolButton = NULL;
 	CmdPreview.ToolButton = NULL;
 	CmdSend.MenuItem = NULL;
 	CmdReceive.MenuItem = NULL;
 	CmdPreview.MenuItem = NULL;
 
 	// This could be using the OpenSSL library for HTTPS connections. So
 	// close it before calling EndSSL.
 	DeleteObj(d->ImageLoader);
 	
 	// This has to be after we close all the accounts... otherwise
 	// they might still be using SSL functions, e.g. an IMAP/SSL connect.
 	EndSSL();
 
 	DeleteObj(d);
 }
 
 LString ScribeWnd::GetResourceFile(SribeResourceType Type)
 {
 	auto File = d->ResFiles.Find(Type);
 	if (!File)
 		LgiTrace("%s:%i - No file for resource type %i\n", _FL, Type);
 	return File;
 }
 
 void ScribeWnd::LoadImageResources()
 {
 	auto Res = LgiGetResObj();
 	LString::Array Folders;
 	if (Res)
 	{
 		auto p = Res->GetThemeFolder();
 		if (p)
 			Folders.Add(p);
 	}
 	Folders.Add(ScribeResourcePath());
 
 	for (auto p: Folders)
 	{
 		LDirectory Dir;
 
 		LgiTrace("%s:%i - Loading resource folder '%s'\n", _FL, p.Get());
 		for (auto b = Dir.First(p); b; b = Dir.Next())
 		{
 			if (Dir.IsDir())
 				continue;
 
 			auto Name = Dir.GetName();
 			if (MatchStr("Toolbar-*.png", Name))
 			{
 				if (!d->ResFiles.Find(ResToolbarFile))
 					d->ResFiles.Add(ResToolbarFile, Dir.FullPath());
 			}
 			else if (MatchStr("xgate-icons-*.png", Name))
 				d->ResFiles.Add(ResToolbarFile, Dir.FullPath());
 			else if (MatchStr("Icons-*.png", Name))
 				d->ResFiles.Add(ResIconsFile, Dir.FullPath());
 		}
 	}
 
 	ToolbarImgs.Reset(LLoadImageList(GetResourceFile(ResToolbarFile)));
 	ImageList.Reset(LLoadImageList(GetResourceFile(ResIconsFile)));
 	if (!ImageList)
 		LgiTrace("%s:%i - Failed to load toolbar image ('xgate-icons-32.png' or 'Toolbar-24.png')\n", _FL);
 }
 
 int ScribeWnd::GetEventHandle()
 {
 	return d->AppWndHnd;
 }
 
 void ScribeWnd::OnCloseInstaller()
 {
 	d->Bar = NULL;
 	if (InThread())
 	{
 		PourAll();
 	}
 	else LAssert(0);
 }
 
 void ScribeWnd::OnInstall(CapsHash *Caps, bool Status)
 {
 }
 
 bool ScribeWnd::NeedsCapability(const char *Name, const char *Param)
 {
 	#if DEBUG_CAPABILITIES
 	LgiTrace("ScribeWnd::NeedsCapability(%s, %s)\n", Name, Param);
 	#endif
 	
 	if (!InThread())
 	{
 		#if DEBUG_CAPABILITIES
 		LgiTrace("%s:%i - Posting M_NEEDS_CAP\n", _FL);
 		#endif
 		PostEvent(M_NEEDS_CAP, (LMessage::Param)NewStr(Name), (LMessage::Param)NewStr(Param));
 	}
 	else
 	{
 		if (!Name)
 			return false;
 			
 		if (d->MissingCaps.Find(Name))
 		{
 			#if DEBUG_CAPABILITIES
 			LgiTrace("%s:%i - Already in MissingCaps\n", _FL);
 			#endif
 			return true;
 		}
 
 		d->MissingCaps.Add(Name, true);
 
 		LStringPipe MsgBuf(256);
 		int i = 0;
 		// const char *k;
 		// for (bool b=d->MissingCaps.First(&k); b; b=d->MissingCaps.Next(&k), i++)
 		for (auto k : d->MissingCaps)
 		{
 			MsgBuf.Print("%s%s", i?", ":"", k.key);
 		}
 		
 		LVariant Actions;
 		if (stristr(Name, "OpenSSL"))
 		{
 			MsgBuf.Print(LLoadString(IDS_ERROR_SERVER_CONNECT));
 			if (Param)
 				MsgBuf.Print("\n%s", Param);
 			Actions.Add(new LVariant(LLoadString(IDS_INSTALL)));
 		}
 		else if (stristr(Name, "Registry"))
 		{
 			MsgBuf.Print(LLoadString(IDS_ERROR_REG_WRITE));
 			Actions.Add(new LVariant(LLoadString(IDS_DONT_SHOW_AGAIN)));
 		}
 		else if (stristr(Name, "SpellingDictionary"))
 		{
 			MsgBuf.Print(LLoadString(IDS_ERROR_NEED_INSTALL), Param);
 			Actions.Add(new LVariant(LLoadString(IDS_DOWNLOAD)));
 		}
 		Actions.Add(new LVariant(LLoadString(IDS_OK)));
 		
 		#if DEBUG_CAPABILITIES
 		LgiTrace("%s:%i - Actions.Length()=%i, Bar=%p\n", _FL, Actions.Length(), d->Bar);
 		#endif
 		if (Actions.Length())
 		{
 			LAutoString Msg(MsgBuf.NewStr());
 
 			// Check the script hook here...
 			bool ShowInstallBar = true;
 			LArray<LScriptCallback*> Callbacks;
 			if (GetScriptCallbacks(LBeforeInstallBar, Callbacks))
 			{
 				for (unsigned i=0; i<Callbacks.Length(); i++)
 				{
 					LScriptCallback &c = *Callbacks[i];
 					if (!c.Func)
 						continue;
 
 					LVirtualMachine Vm;
 					LScriptArguments Args(&Vm);
 					LVariant This((LDom*)this);
 					LVariant TheMsg(Msg.Get());					
 					
 					Args.Add(&This);
 					Args.Add(&TheMsg);
 					Args.Add(&Actions);
 					
 					if (ExecuteScriptCallback(c, Args, true))
 					{
 						if (!Args.GetReturn()->CastInt32())
 							ShowInstallBar = false;
 						else
 							Msg.Reset(TheMsg.ReleaseStr());
 					}
 				}
 			}
 			
 			// Now create the capability install bar...
 			if (!d->Bar && ShowInstallBar && Actions.Type == GV_LIST)
 			{
 				// FYI Capabilities are handled in ScribeWnd::StartAction.
 				LArray<const char *> Act;
 				for (auto v : *Actions.Value.Lst)
 					Act.Add(v->Str());
 				
 				d->Bar = new MissingCapsBar(this, &d->MissingCaps, Msg, this, Act);
 				AddView(d->Bar, 2);
 				AttachChildren();
 				OnPosChange();
 			}
 		}
 	}
 
 	return true;
 }
 
 LAutoString ScribeWnd::GetDataFolder()
 {
 	LVariant v;
 	GetOptions()->GetValue(OPT_IsPortableInstall, v);
 	
 	char p[MAX_PATH_LEN];
 	if (LGetSystemPath(v.CastInt32() ? LSP_APP_INSTALL : LSP_APP_ROOT, p, sizeof(p)))
 	{
 		if (!LDirExists(p))
 			FileDev->CreateFolder(p);
 
 		return LAutoString(NewStr(p));
 	}
 	else LgiTrace("%s:%i - LgiGetSystemPath failed (portable=%i).\n", _FL, v.CastInt32());
 	
 	return LAutoString();
 }
 
 LScriptEngine *ScribeWnd::GetScriptEngine()
 {
 	return d->Engine;
 }
 
 LScriptCallback ScribeWnd::GetCallback(const char *CallbackMethodName)
 {
 	LScriptCallback Cb;
 	
 	auto Cur = d->CurrentScript();
 	if (Cur && Cur->Code)
 	{
 		Cb.Script = Cur;
 		Cb.Func = Cur->Code->GetMethod(CallbackMethodName);
 	}
 
 	if (!Cb.Func)
 	{
 		for (auto s: d->Scripts)
 		{
 			Cb.Script = s;
 			if ((Cb.Func = s->Code->GetMethod(CallbackMethodName)))
 				break;
 		}
 	}
 
 	return Cb;
 }
 
 bool ScribeWnd::RegisterCallback(LScriptCallbackType Type, LScriptArguments &Args)
 {
 	if (!d->CurrentScript())
 	{
 		LgiTrace("%s:%i - No current script.\n", _FL);
 		return false;
 	}
 
 	char *Fn = Args[1]->Str();
 	LScriptCallback Cb = GetCallback(Fn);
 	if (!Cb.Func)
 	{
 		LgiTrace("%s:%i - No callback '%s'.\n", _FL, Fn);
 		return false;
 	}
 
 	switch (Type)
 	{
 		case LToolsMenu:
 		{
 			char *Menu = Args[0]->Str();
 			auto Cur = d->CurrentScript();
 			if (!Menu || !Fn || !Cur)
 			{
 				LgiTrace("%s:%i - menu=%s, fn=%s.\n", _FL, Menu, Fn);
 				return false;
 			}
 
 			LScriptCallback &c = Cur->Callbacks.New();
 			c = Cb;
 			c.Type = Type;
 			c.Param = d->NextToolMenuId;
 
 			LMenuItem *Tools = GetMenu()->FindItem(IDM_TOOLS_MENU);
 			auto ToolSub = Tools ? Tools->Sub() : 0;
 			if (ToolSub)
 			{
 				if (d->NextToolMenuId == IDM_TOOL_SCRIPT_BASE)
 				{
 					ToolSub->AppendSeparator();
 				}
 
 				ToolSub->AppendItem(Menu, c.Param, true);			
 				d->NextToolMenuId++;
 			}
 			break;
 		}
 		case LThingContextMenu:
 		case LFolderContextMenu:
 		case LThingUiToolbar:
 		case LMailOnBeforeSend:
 		case LMailOnAfterReceive:
 		case LApplicationToolbar:
 		case LBeforeInstallBar:
 		case LInstallComponent:
 		case LOnTimer:
 		case LRenderMail:
 		case LOnLoad:
 		{
 			auto Cur = d->CurrentScript();
 			LAssert(d->Scripts.HasItem(Cur));
 
 			LScriptCallback &c = Cur->Callbacks.New();
 			c = Cb;
 			c.Type = Type;
 			if (Args.Length() > 2)
 				c.Data = *Args[2];
 			break;
 		}
 		default:
 		{
 			LAssert(!"Not a known callback type");
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool ScribeWnd::GetScriptCallbacks(LScriptCallbackType Type, LArray<LScriptCallback*> &Callbacks)
 {
 	for (auto s: d->Scripts)
 	{
 		for (auto &c: s->Callbacks)
 		{
 			if (c.Type == Type)
 				Callbacks.Add(&c);
 		}
 	}
 
 	return Callbacks.Length() > 0;
 }
 
 bool ScribeWnd::ExecuteScriptCallback(LScriptCallback &c, LScriptArguments &Args, bool ReturnArgs)
 {
 	if (!c.Func || !c.Script)
 		return false;
 
 	// Setup
 	LVirtualMachine Vm(d);
 	d->CurrentScripts.Add(c.Script);
 	
 	// Call the method
 	bool Status = Vm.ExecuteFunction(	c.Script->Code,
 										c.Func,
 										Args,
 										LScribeScript::Inst->GetLog(),
 										ReturnArgs ? &Args : NULL) != ScriptError;
 
 	// Cleanup
 	d->CurrentScripts.PopLast();
 	return Status;
 }
 
 LStream *ScribeWnd::ShowScriptingConsole()
 {
 	auto Item = Menu->FindItem(IDM_SCRIPTING_CONSOLE);
 	if (Item)
 	{
 		Item->Checked(!Item->Checked());
 		LScribeScript::Inst->ShowScriptingWindow(Item->Checked());
 		
 		LVariant v;
 		GetOptions()->SetValue(OPT_ShowScriptConsole, v = Item->Checked());
 	}
 	
 	return LScribeScript::Inst->GetLog();
 }
 
 LOptionsFile::PortableType ScribeWnd::GetPortableType()
 {
 	return d->GetInstallMode();
 }
 
 void ScribeWnd::RemoteContent_AddSender(const char *Addr, bool WhiteList)
 {
 	if (!Addr)
 		return;
 
 	auto Opt = WhiteList ? OPT_RemoteContentWhiteList : OPT_RemoteContentBlackList;
 	LVariant v;
 	GetOptions()->GetValue(Opt, v); // Not an error if not there...
 
 	auto existing = LString(v.Str()).SplitDelimit(" ,\r\n");
 	for (auto p: existing)
 	{
 		if (MatchStr(p, Addr))
 		{
 			LgiTrace("%s:%i - '%s' is already in '%s'\n", _FL, Addr, Opt);
 			return; // Already in list...
 		}
 	}
 
 	existing.SetFixedLength(false);
 	existing.Add(Addr);
 	auto updated = LString("\n").Join(existing);
 	GetOptions()->SetValue(Opt, v = updated.Get());
 	LgiTrace("%s:%i - Added '%s' to '%s'\n", _FL, Addr, Opt);
 	d->RemoteContent_Init = false;
 }
 
 ScribeRemoteContent ScribeWnd::RemoteContent_GetSenderStatus(const char *Addr)
 {
 	if (!d->RemoteContent_Init)
 	{
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_RemoteContentWhiteList, v))
 			d->RemoteWhiteLst = LString(v.Str()).SplitDelimit(" ,\r\n");
 		if (GetOptions()->GetValue(OPT_RemoteContentBlackList, v))
 			d->RemoteBlackLst = LString(v.Str()).SplitDelimit(" ,\r\n");
 		d->RemoteContent_Init = true;
 	}
 
 	for (auto p: d->RemoteWhiteLst)
 		if (MatchStr(p, Addr))
 			return RemoteAlwaysLoad;
 
 	for (auto p: d->RemoteBlackLst)
 		if (MatchStr(p, Addr))
 			return RemoteNeverLoad;
 
 	return RemoteDefault;
 }
 
 void ScribeWnd::RemoteContent_ClearCache()
 {
 	d->RemoteWhiteLst.Empty();
 	d->RemoteBlackLst.Empty();
 	d->RemoteContent_Init = false;
 }
 
 void ScribeWnd::OnSpellerSettingChange()
 {
 	// Kill the current thread
 	d->SpellerThread.Reset();
 	
 	// Setup the new thread
 	LSpellCheck *t = GetSpellThread();
 	if (t)
 	{
 		// Trigger an install if needed
 		t->Check(d->AppWndHnd, "thisisamispeltword", 0, 18);
 	}
 }
 
 bool ScribeWnd::SetSpellThreadParams(LSpellCheck *Thread)
 {
 	if (!Thread)
 		return false;
 	
 	LVariant Lang, Dict;
 	GetOptions()->GetValue(OPT_SpellCheckLanguage, Lang);
 	GetOptions()->GetValue(OPT_SpellCheckDictionary, Dict);
 
 	LAutoPtr<LSpellCheck::Params> Params(new LSpellCheck::Params);
 	if (!Params)
 		return false;
 
 	Params->IsPortable = GetPortableType();
 	Params->OptionsPath = GetOptions()->GetFile();
 	Params->Lang = Lang.Str();
 	Params->Dict = Dict.Str();
 	Params->CapTarget = this;
 	
 	Thread->SetParams(Params);
 	return true;
 }
 
 LSpellCheck *ScribeWnd::CreateSpellObject()
 {
 	LVariant PrefAspell;
 	GetOptions()->GetValue(OPT_PreferAspell, PrefAspell);
 
 	LAutoPtr<LSpellCheck> Obj;
 
 	if (PrefAspell.CastInt32())
 		Obj = CreateAspellObject();
 
 	#if defined(MAC)
 
 		if (!Obj)
 			Obj = CreateAppleSpellCheck();
 
 	#elif defined(WINDOWS)
 
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		if
 		(
 			!Obj &&
 			(Os == LGI_OS_WIN32 || Os == LGI_OS_WIN64)
 			&&
 			(
 				Ver.Length() > 1 &&
 				(
 					Ver[0] > 6
 					||
 					(Ver[0] == 6 && Ver[1] > 1)
 				)
 			)
 		)
 			Obj = CreateWindowsSpellCheck();
 				
 	#endif
 
 	if (!Obj)
 		Obj = CreateAspellObject();
 
 	SetSpellThreadParams(Obj);
 	return Obj.Release();
 }
 
 LSpellCheck *ScribeWnd::GetSpellThread(bool OverrideOpt)
 {
 	LVariant Use;
 	if (OverrideOpt)
 		Use = true;
 	else
 		GetOptions()->GetValue(OPT_SpellCheck, Use);
 
 	#if USE_SPELLCHECKER
 	if ((Use.CastInt32() != 0) ^ (d->SpellerThread.Get() != 0))
 		d->SpellerThread.Reset(Use.CastInt32() ? CreateSpellObject() : NULL);
 	#endif
 
 	return d->SpellerThread;
 }
 
 LAutoString ScribeWnd::GetHttpProxy()
 {
 	LAutoString Proxy;
 	
 	LVariant v;
 	if (GetOptions()->GetValue(OPT_HttpProxy, v) && ValidStr(v.Str()))
 	{
 		Proxy.Reset(v.ReleaseStr());
 	}
 	else
 	{
 		LProxyUri p;
 		if (p.sHost)
 			Proxy.Reset(NewStr(p.ToString()));
 	}
 	
 	return Proxy;
 }
 
 InstallProgress *ScribeWnd::StartAction(MissingCapsBar *Bar, LCapabilityTarget::CapsHash *Components, const char *ActionParam)
 {
 	if (!ActionParam)
 	{
 		LgiTrace("%s:%i - No action supplied.\n", _FL);
 		return NULL;
 	}
 
 	LArray<LScriptCallback*> Callbacks;
 	LVariant Action(ActionParam);
 	if (GetScriptCallbacks(LInstallComponent, Callbacks))
 	{
 		bool StartInstall = true;
 
 		for (unsigned i=0; i<Callbacks.Length(); i++)
 		{
 			LScriptCallback &c = *Callbacks[i];
 			if (!c.Func)
 				continue;
 
 			LVirtualMachine Vm;
 			LScriptArguments Args(&Vm);
 			LVariant This((LDom*)this);
 			
 			Args.Add(&This);
 			Args.Add(&Action);
 			
 			if (ExecuteScriptCallback(c, Args))
 			{
 				if (!Args.GetReturn()->CastInt32())
 					StartInstall = false;
 			}
 		}
 		
 		if (!Action.Str())
 		{
 			LgiTrace("%s:%i - GInstallComponent removed action name.\n", _FL);
 			return NULL;
 		}
 
 		if (!StartInstall)
 		{
 			LgiTrace("%s:%i - GInstallComponent script canceled install of '%s'.\n", _FL, ActionParam);
 			return NULL;
 		}
 	}
 
 	if (!_stricmp(Action.Str(), LLoadString(IDS_OK)))
 	{
 		// Do nothing
 		d->MissingCaps.Empty();
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_DONT_SHOW_AGAIN)))
 	{
 		// Turn off registering as a client.
 		LVariant No(false);
 		GetOptions()->SetValue(OPT_RegisterWindowsClient, No);
 		GetOptions()->SetValue(OPT_CheckDefaultEmail, No);
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_INSTALL)))
 	{
 		#ifdef WINDOWS
 		bool IsSsl = false;
 		for (auto c: *Components)
 		{
 			if (!_stricmp(c.key, "openssl"))
 			{
 				IsSsl = true;
 				break;
 			}
 		}
 		if (IsSsl)
 		{
 			LString s;
 			s.Printf(LLoadString(IDS_WINDOWS_SSL_INSTALL), LGetOsName());
 			
 			auto q = new LAlert(this, AppName, s, "Open Website", LLoadString(IDS_CANCEL));
 			q->DoModal([this, q](auto dlg, auto id)
 			{
 				switch (id)
 				{
 					case 1:
 						LExecute("https://slproweb.com/products/Win32OpenSSL.html");
 						break;
 					default:
 						break;
 				}
 				delete dlg;
 			});
 			return NULL;
 		}
 		#endif
 
 		return CapabilityInstaller::StartAction(Bar, Components, Action.Str());
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_SHOW_CONSOLE)))
 	{
 		ShowScriptingConsole();
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_OPEN_SOURCE)))
 	{
 		if (d->ErrSource)
 			LExecute(d->ErrSource);
 		else if (d->ErrFilter)
 			d->ErrFilter->DoUI();
 		
 		d->ErrSource.Empty();
 		d->ErrFilter = NULL;
 	}
 	else if (	!Stricmp(Action.Str(), LLoadString(IDS_SHOW_REMOTE_CONTENT)) ||
 				!Stricmp(Action.Str(), LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT)))
 	{
 		auto c = Components->begin();
 		LWindow *w = Bar->GetWindow();
 		if ((*c).key &&
 			!Stricmp((*c).key, "RemoteContent") &&
 			w)
 		{
 			LVariant Ret, Always(!Stricmp(Action.Str(), LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT)));
 			LArray<LVariant*> Args;
 			Args[0] = &Always;
 			w->CallMethod(DomToStr(SdShowRemoteContent), &Ret, Args);
 		}
 	}
 	else if (!_stricmp(Action.Str(), LLoadString(IDS_DOWNLOAD)))
 	{
 		auto t = GetSpellThread();
 		if (t)
 			t->InstallDictionary();
 		else
 			LgiTrace("%s:%i - No spell thread.\n", _FL);
 	}
 	else LAssert(!"Unknown action.");
 	
 	return NULL;
 }
 
 HttpImageThread *ScribeWnd::GetImageLoader()
 {
 	if (!d->ImageLoader)
 	{
 		LAutoString Proxy = GetHttpProxy();
 		d->ImageLoader = new HttpImageThread(this, Proxy, 0);
 	}
 
 	return d->ImageLoader;
 }
 
 char *ScribeWnd::GetUiTags()
 {
 	if (!d->UiTags)
 	{
 		char UiTags[256] =
 			"inscribe"
 			#if defined WIN32
 			" win32"
 			#elif defined LINUX
 			" linux"
 			#elif defined MAC
 			" mac"
 			#endif
 			;
 	
 		LVariant Tags;
 		if (!GetOptions())
 		{
 			LAssert(!"Where is the options?");
 		}
 		else if (GetOptions()->GetValue("tags", Tags))
 		{
 			size_t Len = strlen(UiTags);
 			sprintf_s(UiTags+Len, sizeof(UiTags)-Len, " %s", Tags.Str());
 		}
 
 		d->UiTags.Reset(NewStr(UiTags));
 	}
 
 	return d->UiTags;
 }
 
 void ScribeWnd::OnCreate()
 {
 	// LgiTrace("ScribeWnd::OnCreate. ScribeState=%i\n", ScribeState);
 	if (IsAttached() && ScribeState == ScribeConstructed)
 	{
 		ScribeState = ScribeInitializing;
 		Construct3();
 	}
 }
 
 ScribeAccount *ScribeWnd::GetAccountByEmail(const char *Email)
 {
 	if (!Email)
 		return NULL;
 
 	for (auto a : *GetAccounts())
 	{
 		LVariant e = a->Identity.Email();
 		if (e.Str() &&
 			!_stricmp(e.Str(), Email))
 		{
 			return a;
 		}
 	}
 	
 	return 0;
 }
 
 ScribeAccount *ScribeWnd::GetAccountById(int Id)
 {
 	for (auto a : *GetAccounts())
 	{
 		if (a->Receive.Id() == Id)
 		{
 			return a;
 		}
 	}
 	
 	return 0;
 }
 
 const char *ScribeWnd::EditCtrlMimeType()
 {
 	LVariant Html;
 	GetOptions()->GetValue(OPT_EditControl, Html);
 	return Html.CastInt32() ? sTextHtml : sTextPlain;
 }
 
 LAutoString ScribeWnd::GetReplyXml(const char *MimeType)
 {
 	bool IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 
 	LVariant s;
 	GetOptions()->GetValue(IsHtml ? OPT_HtmlReplyFormat : OPT_TextReplyFormat, s);
 	return LAutoString(s.ReleaseStr());
 }
 
 LAutoString ScribeWnd::GetForwardXml(const char *MimeType)
 {
 	bool IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 
 	LVariant s;
 	GetOptions()->GetValue(IsHtml ? OPT_HtmlForwardFormat : OPT_TextForwardFormat, s);
 	return LAutoString(s.ReleaseStr());
 }
 
 LVmCallback *ScribeWnd::GetDebuggerCallback()
 {
 	return d;
 }
 
 GpgConnector *ScribeWnd::GetGpgConnector()
 {
 	if (!d->GpgInst)
 	{
 		if (!GpgConnector::IsInstalled())
 			return NULL;
 		
 		d->GpgInst.Reset(new GpgConnector());
 	}
 	
 	return d->GpgInst;
 }
 
 LFont *ScribeWnd::GetPreviewFont()
 {
 	return d->PreviewFont;
 }
 
 bool ScribeWnd::IsValid()
 {
 	#if 0
 	try
 	{
 		for (ScribeAccount *a = Accounts.First(); a; a = Accounts.Next())
 		{
 		}
 	}
 	catch(...)
 	{
 		return false;
 	}
 	#endif
 
 	return true;
 }
 
 bool ScribeWnd::ShutdownIpc()
 {
 	// Remove our instance from the shared memory
 	if (ScribeIpc && ScribeIpc->GetPtr())
 	{
 		ScribeIpcInstance *InstLst = (ScribeIpcInstance*) ScribeIpc->GetPtr();
 
 		if (ThisInst)
 			memset(ThisInst, 0, sizeof(*ThisInst));
 
 		int c = 0;
 		for (int i=0; i<SCRIBE_INSTANCE_MAX; i++)
 		{
 			if (InstLst[i].Valid())
 				c++;
 		}
 
 		if (!c)
 			ScribeIpc->Destroy();
 	}	
 	
 	ThisInst = 0;
 	DeleteObj(ScribeIpc);
 
 	return true;
 }
 
 bool ScribeWnd::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdQuote: // Type: String
 		{
 			return GetOptions()->GetValue(OPT_QuoteReplyStr, Value);
 		}
 		case SdName: // Type: String
 		{
 			Value = AppName;
 			break;
 		}
 		case SdHome: // Type: String
 		{
 			Value = LGetExePath().Get();
 			break;
 		}
 		case SdNow: // Type: String
 		{
 			LDateTime Now;
 			Now.SetNow();
 			char s[64];
 			Now.Get(s, sizeof(s));
 			Value = s;
 			break;
 		}
 		case SdFolder:	// Type: ScribeFolder[]
 						// Pass system folder index or string as array parameter.
 		{
 			ScribeFolder *f = 0;
 			if (!Array)
 				return false;
 
 			if (IsDigit(*Array))
 			{
 				f = GetFolder(atoi(Array));
 			}
 			else
 			{
 				f = GetFolder(Array);
 			}
 
 			if (!f)
 				return false;
 
 			Value = (LDom*)f;
 			break;
 		}
 		case SdAppName: // Type: String
 		{
 			Value = AppName;
 			break;
 		}
 		case SdCalendarToday: // Type: String
 		{
 			Calendar::SummaryOfToday(this, [this](auto s)
 			{
 				d->CalendarSummary = s;
 			});
 
 			return d->CalendarSummary;
 		}
 		case SdInboxSummary:
 		{
 			LStringPipe p;
 			
 			// Iterate through the mail stores
 			for (auto m: Folders)
 			{
 				if (!m.Store)
 					continue;
 				auto Inbox = m.Store->GetObj(FIELD_INBOX);
 				if (!Inbox)
 					continue;
 
 				auto Unread = Inbox->GetInt(FIELD_UNREAD);
 				auto Name = Inbox->GetStr(FIELD_FOLDER_NAME);
 				LString Path;
 				Path.Printf("/%s/%s", m.Name.Get(), Name);
 					
 				if (Unread)
 					p.Print("%s: <a href='folder://%s'>%i unread</a><br>", m.Name.Get(), Path.Get(), Unread);
 				else
 					p.Print("%s: 0 unread<br>", m.Name.Get());
 			}
 			
 			// And also the IMAP full folders
 			for (auto a: Accounts)
 			{
 				ScribeProtocol Protocol = a->Receive.ProtocolType();
 				if (Protocol == ProtocolImapFull)
 				{
 					LDataStoreI *Store = a->Receive.GetDataStore();
 					if (Store)
 					{
 						auto Inbox = Store->GetObj(FIELD_INBOX);
 						if (Inbox)
 						{
 							auto Unread = Inbox->GetInt(FIELD_UNREAD);
 							auto Name = Inbox->GetStr(FIELD_FOLDER_NAME);
 							auto m = a->Receive.Name();
 							if (m.Str())
 							{
 								LString Path;
 								Path.Printf("/%s/%s", m.Str(), Name);
 								
 								if (Unread)
 									p.Print("%s: <a href='folder://%s'>%i unread</a><br>", m.Str(), Path.Get(), Unread);
 								else
 									p.Print("%s: 0 unread<br>", m.Str());
 							}
 						}
 					}
 				}
 			}
 			
 			Value = p.NewLStr().Get();
 			break;
 		}
 		case SdExecute: // Type: String
 		{
 			if (!Array)
 				return false;
 
 			const char *s = Array;
 			char *Exe = LTokStr(s);
 			if (!Exe)
 				return false;
 
 			while (*s && *s == ' ') s++;
 			
 			LStringPipe Out;
 			LSubProcess p(Exe, (char*)s);
 			if (p.Start())
 			{
 				p.Communicate(&Out);
 				LAutoString o(Out.NewStr());
 				LAutoString t(TrimStr(o));
 				Value = t;
 			}
 			
 			DeleteArray(Exe);
 			break;
 		}
 		case SdBuildType: // Type: String
 		{
 			#ifdef _DEBUG
 			Value = "<font color=#ff0000>Debug</font>";
 			#else
 			Value = "Release";
 			#endif
 			break;
 		}
 		case SdPlatform: // Type: String
 		{
 			LArray<int> Ver;
 			LGetOs(&Ver);
 			
 			LString::Array Va;
 			for (auto i: Ver)
 				Va.New().Printf("%i", i);
 			
 			#if defined __GTK_H__
 				auto Api = "GTK3";
 			#elif LGI_SDL
 				auto Api = "SDL";
 			#elif LGI_COCOA
 				auto Api = "Cocoa";
 			#elif LGI_CARBON
 				auto Api = "Carbon";
 			#elif defined WIN32
 				auto Api = "WinApi";
 			#else
 				#error "Impl me."
 				auto Api = "#err";
 			#endif
 			
 			LString s;
 			s.Printf("%s, v%s, %s", LGetOsName(), LString(".").Join(Va).Get(), Api);
 			Value = s.Get();
 			break;
 		}
 		case SdVersion: // Type: String
 		{
 			char Ver[32];
 			sprintf_s(Ver, sizeof(Ver), "v%s", ScribeVer);
 			Value = Ver;
 			break;
 		}
 		case SdBuild: // Type: String
 		{
 			char s[128];
 			sprintf_s(s, sizeof(s), "%s, %s, %ibit", __DATE__, __TIME__, (int)(sizeof(NativeInt)*8));
 			Value = s;
 			break;
 		}
 		case SdLanguage: // Type: String
 		{
 			LLanguage *l = LGetLanguageId();
 			if (!l)
 				return false;
 
 			char s[256];
 			sprintf_s(s, sizeof(s), "%s \"%s\"", l->Name, l->Id);
 			Value = s;
 			break;
 		}
 		case SdString: // Type: String
 		{
 			if (!Array)
 			{
 				LAssert(!"Missing string ID");
 				return false;
 			}
 
 			int Id = atoi(Array);
 			Value = LLoadString(Id);
 			break;
 		}
 		case SdCurrentFolder: // Type: ScribeFolder
 		{
 			Value = (LDom*) GetCurrentFolder();
 			break;
 		}
 		case SdView: // Type: LView
 		{
 			Value = (LView*)this;
 			break;
 		}
 		case SdNoContact: // Type: Contact
 		{
 			Value = (NoContactType*)d->NoContact;
 			break;
 		}
 		case SdAccounts:
 		{
 			if (Array)
 			{
 				if (IsDigit(*Array))
 				{
 					auto i = atoi(Array);
 					if (i >= 0 && i < (ssize_t)Accounts.Length())
 					{
 						Value = (LDom*)Accounts[i];
 					}
 					else return false;
 				}
 				else
 				{
 					for (auto a : Accounts)
 					{
 						LVariant nm = a->Send.Name();
 						if (nm.Str() && !_stricmp(nm.Str(), Array))
 						{
 							Value = (LDom*)a;
 							break;
 						}
 					}
 				}
 			}
 			else
 			{
 				Value = (int32)Accounts.Length();
 			}
 			break;
 		}
 		case SdOptions:
 		{
 			Value = GetOptions();
 			break;
 		}
 		case SdMailStorePaths:
 		{
 			if (!Value.SetList())
 				return false;
 			for (auto Ms : Folders)
 				Value.Add(new LVariant(Ms.Path));
 			break;
 		}
 		case SdRootFolders:
 		{
 			if (!Value.SetList() || !Tree)
 				return false;
 
 			for (auto *i = Tree->GetChild(); i; i = i->GetNext())
 			{
 				ScribeFolder *c = dynamic_cast<ScribeFolder*>(i);
 				if (c)
 				{
 					auto p = c->GetPath();
 					Value.Add(new LVariant(p));
 				}
 			}
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool ScribeWnd::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType m = StrToDom(MethodName);
 	switch (m)
 	{
 		case SdGrowlOnMail: // Type: (Mail Obj)
 		{
 			if (Args.Length() != 1)
 			{
 				LgiTrace("%s:%i - Wrong arg count: %i.\n", _FL, (int)Args.Length());
 				return false;
 			}
 			
 			Mail *m = dynamic_cast<Mail*>(Args[0]->CastDom());
 			if (!m)
 			{
 				LgiTrace("%s:%i - Invalid object.\n", _FL);
 				return false;
 			}
 			
 			GrowlOnMail(m);
 			break;
 		}
 		case SdGrowlInfo:
 		{
 			auto Title = Args.Length() > 0 ? Args[0] : NULL;
 			auto Text = Args.Length() > 1 ? Args[1] : NULL;
 			GrowlInfo(Title ? Title->Str() : NULL, Text ? Text->Str() : NULL);
 			break;
 		}
 		case SdGetClipboardText: // Type: ()
 		{
 			LClipBoard c(this);
 			*ReturnValue = c.Text();
 			break;
 		}
 		case SdSetClipboardText: // Type: (String Text)
 		{
 			if (Args.Length() != 1)
 			{
 				LgiTrace("%s:%i - Wrong arg count: %i.\n", _FL, (int)Args.Length());
 				return false;
 			}
 
 			char *Str = Args[0]->CastString();
 			LClipBoard c(this);
 
 			if (ValidStr(Str))
 				*ReturnValue = c.Text(Str);
 			else
 				*ReturnValue = c.Empty();
 			break;
 		}
 		case SdLookupContactGroup: // Type: (String GroupName)
 		{
 			if (Args.Length() != 1)
 			{
 				LgiTrace("%s:%i - Wrong arg count: %i.\n", _FL, (int)Args.Length());
 				return false;
 			}
 			
 			ContactGroup *Grp = LookupContactGroup(this, Args[0]->Str());
 			*ReturnValue = dynamic_cast<LDom*>(Grp);
 			break;
 		}
 		case SdAskUserString: // Type: (LView ParentView, String Callback, String PromptMessage[, Bool ObsurePassword[, String DefaultValue]])
 		{
 			LVirtualMachine::Context Ctx;
 			// Ctx = Args.GetVm()->SaveContext()
 
 			if (!Ctx || Args.Length() < 3)
 			{
 				*ReturnValue = true;
 				return true;
 			}
 
 			LView *View       = Args[0]->CastView();
 			auto CallbackName = Args[1]->Str();
 			auto Prompt       = Args[2]->CastString();
 			bool IsPassword   = Args.Length() > 3 ? Args[3]->CastInt32() != 0 : false;
 			auto Default      = Args.Length() > 4 ? Args[4]->Str() : NULL;
 
 			auto i = new LInput(View ? View : this, Default, Prompt, AppName, IsPassword);
 			i->DoModal([Ctx, i, CallbackName=LString(CallbackName)](auto dlg, auto id)
 			{
 				if (id)
 				{
 					LScriptArguments Args(NULL);
 					Args.Add(new LVariant(i->GetStr()));
 					Ctx.Call(CallbackName, Args);
 					Args.DeleteObjects();
 				}
 				delete dlg;
 			});
 
 			*ReturnValue = true;
 			break;
 		}
 		case SdCreateAccount: // Type: ()
 		{
 			ScribeAccount *a = new ScribeAccount(this, (int)Accounts.Length());
 			if (a)
 			{
 				if (ReturnValue)
 					*ReturnValue = (LDom*)a;
 				Accounts.Insert(a);
 				a->Create();
 			}
 			else return false;
 			break;
 		}
 		case SdDeleteAccount: // Type: (ScribeAccount AccountToDelete)
 		{
 			if (Args.Length() != 1)
 				return false;
 			
 			ScribeAccount *a = dynamic_cast<ScribeAccount*>(Args[0]->CastDom());
 			if (!a)
 			{
 				if (ReturnValue)
 					*ReturnValue = false;
 			}
 			else
 			{
 				int Idx = (int)Accounts.IndexOf(a);
 				if (Idx < 0 || a->IsOnline())
 				{
 					if (ReturnValue)
 						*ReturnValue = false;
 				}
 				else
 				{
 					Accounts.Delete(a);
 					a->Delete();
 					delete a; // delete actual account object
 
 					// Reindex remaining items so their are no gaps
 					int i=0;
 					auto it = Accounts.begin();
 					for (a = *it; a; a = *++it, i++)
 					{
 						a->ReIndex(i);
 					}
 				}
 			}
 			break;
 		}
 		case SdShowRemoteContent:
 		{
 			if (PreviewPanel)
 				return PreviewPanel->CallMethod(MethodName, ReturnValue, Args);
 			else
 				return false;
 			break;
 		}
 		case SdSearchHtml: // Type(Html, SearchExp, ResultExp)
 		{
 			if (Args.Length() != 3)
 			{
 				LgiTrace("%s:%i - SearchHtml requires 3 arguments.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto Html = Args[0]->Str();
 			auto SearchExp = Args[1]->Str();
 			auto ResultExp = Args[2]->Str();
 			if (!Html || !SearchExp || !ResultExp)
 			{
 				LgiTrace("%s:%i - SearchHtml got non-string argument.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			SearchHtml(ReturnValue, Html, SearchExp, ResultExp);
 			return true;
 		}
 		case SdGetUri: // Type(UriToDownload, CallbackName)
 		{
 			if (Args.Length() < 2)
 			{
 				LgiTrace("%s:%i - GetUri requires at least 2 arguments.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto Uri = Args[0]->Str();
 			auto Callback = Args[1]->Str();
 			LVariant *UserData = Args.Length() > 2 ? Args[2] : NULL;
 			new ScriptDownloadContentThread(this, Uri, Callback, UserData);
 			*ReturnValue = true;
 			return true;
 		}
 		default:
 		{
 			LAssert(!"Unsupported method.");
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 LOptionsFile *ScribeWnd::GetOptions(bool Create)
 {
 	if (!d->Options && Create)
 	{
 		LAssert(!"Not here... do it in LoadOptions.");
 		return NULL;
 	}
 
 	return d->Options;
 }
 
 int OptionsFileCmp(OptionsInfo *a, OptionsInfo *b)
 {
 	int64 Diff = b->Mod - a->Mod;
 	return Diff < 0 ? -1 : (Diff > 0 ? 1 : 0);
 }
 
 OptionsInfo::OptionsInfo()
 {
 	Score = 0;
 	Mod = 0;
 	Leaf = NULL;
 	Usual = false;
 }
 	
 OptionsInfo &OptionsInfo::operator =(char *p)
 {
 	File = p;
 	Leaf = LGetLeaf(File);
 		
 	if (Leaf)
 	{
 		char n[64];
 		sprintf_s(n, sizeof(n), "%s.xml", OptionsFileName);
 		Usual = !_stricmp(n, Leaf);
 	}
 		
 	return *this;
 }
 	
 LAutoPtr<LOptionsFile> OptionsInfo::Load()
 {
 	// Read the file...
 	size_t Count = 0;
 	LXmlTag *Stores = NULL;
 	LXmlTag *Acc = NULL;
 	LAutoPtr<LOptionsFile> Of(new LOptionsFile(File));
 	if (!Of)
 		return Of;
 	if (!Of->SerializeFile(false))
 		goto OnError;
 		
 	// Sanity check the options...
 	Acc = Of->LockTag(OPT_Accounts, _FL);
 	if (!Acc)
 		goto OnError;
 	Of->Unlock();
 		
 	Stores = Of->LockTag(OPT_MailStores, _FL);
 	if (!Stores)
 		goto OnError;
 
 	Count = Stores->Children.Length();
 	Of->Unlock();
 	if (Count == 0)
 		goto OnError;
 		
 	return Of;
 
 OnError:
 	Of.Reset();
 	return Of;
 }
 
 #define DEBUG_OPTS_SCAN		0
 bool ScribeWnd::ScanForOptionsFiles(LArray<OptionsInfo> &Files, LSystemPath PathType)
 {
 	LString Root = LGetSystemPath(PathType);
 	LDirectory Dir;
 	char p[MAX_PATH_LEN];
 
 	if (IsUnitTest)
 		Root += ".unittest";
 
 	#if DEBUG_OPTS_SCAN
 	LgiTrace("%s:%i - Root='%s'\n", _FL, Root.Get());
 	#endif
 
 	for (int b = Dir.First(Root); b; b = Dir.Next())
 	{
 		if
 		(
 			!Dir.IsDir()
 			&&
 			Dir.Path(p, sizeof(p))
 		)
 		{
 			LResolveShortcut(p, p, sizeof(p));
 			char *Ext = LGetExtension(Dir.GetName());
 			if (stristr(Dir.GetName(), OptionsFileName) != NULL &&
 				Ext &&				
 				(!_stricmp(Ext, "xml") || !_stricmp(Ext, "bak")))
 			{
 				OptionsInfo &i = Files.New();
 				i = p;
 				i.Mod = Dir.GetLastWriteTime();
 
 				#if DEBUG_OPTS_SCAN
 				LgiTrace("%s:%i - File='%s'\n", _FL, p);
 				#endif
 			}
 		}
 	}
 	
 	Files.Sort(OptionsFileCmp);
 	
 	// Scan through the results and pick out the normal file
 	for (unsigned i=0; i<Files.Length() && !d->Options; i++)
 	{
 		if (Files[i].Usual)
 		{
 			d->Options = Files[i].Load();
 
 			#if DEBUG_OPTS_SCAN
 			LgiTrace("%s:%i - Attempt '%s' = %p\n", _FL, Files[i].File.Get(), d->Options);
 			#endif
 		}
 	}
 
 	if (!d->Options)
 	{
 		// Scan through the alternative files and look for something 
 		// we can use.
 		#if DEBUG_OPTS_SCAN
 		LgiTrace("%s:%i - Scanning backups\n", _FL);
 		#endif
 		for (unsigned i=0; i<Files.Length() && !d->Options; i++)
 		{
 			if (!Files[i].Usual)
 			{
 				d->Options = Files[i].Load();
 				if (d->Options)
 				{
 					// Lets rename this baby back to the real filename
 					LString Xml = OptionsFileName;
 					Xml += ".xml";
 					LFile::Path Normal(Root, Xml);
 					if (LFileExists(Normal))
 						FileDev->Delete(Normal);
 					
 					d->Options->SetFile(Normal);
 					d->Options->SerializeFile(true); // sets to clean after changing filename.
 				}
 			}
 		}
 	}
 
 	if (d->Options)
 	{
 		// Load OK: Clear out any old options files...
 		#if DEBUG_OPTS_SCAN
 		LgiTrace("%s:%i - Files.len=" LPrintfSizeT "\n", _FL, Files.Length());
 		#endif
 		while (Files.Length() > 6)
 		{
 			auto Idx = Files.Length() - 1;
 			auto &f = Files[Idx];
 			#if DEBUG_OPTS_SCAN
 			LgiTrace("%s:%i - Delete '%s'\n", _FL, f.File.Get());
 			#endif
 			FileDev->Delete(f.File);
 			Files.DeleteAt(Idx);
 		}
 	}
 
 	return d->Options != NULL;
 }
 
 bool ScribeWnd::IsUnitTest = false;
 
 bool ScribeWnd::LoadOptions()
 {
 	bool Load = false;
 	
 	// Check if we are running unit tests...
 	if ((IsUnitTest = LAppInst->GetOption("unittest")))
 	{
 		d->UnitTestServer.Reset(new LUnitTestServer(this));
 	}
 
 	// Look in the XGate folder
 	#if WINNATIVE && !defined(_DEBUG)
 	LRegKey xgate(false, "HKEY_CURRENT_USER\\Software\\XGate");
 	if (xgate.IsOk())
 	{
 		char *Spool = xgate.GetStr("SpoolDir");
 		if (LDirExists(Spool))
 		{
 			char File[MAX_PATH_LEN];
 			LMakePath(File, sizeof(File), Spool, "spool");
 			LMakePath(File, sizeof(File), File, OptionsFileName);
 			strcat_s(File, sizeof(File), ".xml");
 			if (LFileExists(File))
 			{
 				d->SetInstallMode(LOptionsFile::DesktopMode);
 				LgiTrace("Selecting xgate mode based on options file path.\n");
 				d->Options.Reset(new LOptionsFile(File));
 			}
 		}
 	}
 	#endif
 
 	// Now look in the application install folder
 	LArray<OptionsInfo> Files;
 	if (!d->Options &&
 		ScanForOptionsFiles(Files, LSP_APP_INSTALL))
 	{
 		// File is in the install folder...
 		d->SetInstallMode(LOptionsFile::PortableMode);
 		LgiTrace("Selecting portable mode based on options file path.\n");
 	}
 	
 	// Look in the app root
 	if
 	(
 		!d->Options &&
 		ScanForOptionsFiles(Files, LSP_APP_ROOT)
 	)
 	{
 		// Desktop mode
 		d->SetInstallMode(LOptionsFile::DesktopMode);
 		LgiTrace("Selecting desktop mode based on options file path.\n");
 	}
 	
 	// Do multi-instance stuff
 	if (d->Options && d->Options->GetFile())
 	{
 		// Search for other instances of Scribe
 		if (ScribeIpc)
 		{
 			int i;
 			ScribeIpcInstance *InstLst = (ScribeIpcInstance*) ScribeIpc->GetPtr();
 			ScribeIpcInstance *Mul = 0;
 
 			for (i=0; i<SCRIBE_INSTANCE_MAX; i++)
 			{
 				if (InstLst[i].IsMul())
 				{
 					Mul = InstLst + i;
 					d->MulPassword = Mul->Password;
 					break;
 				}
 			}
 
 			for (i=0; i<SCRIBE_INSTANCE_MAX; i++, InstLst++)
 			{
 				// LgiTrace("[%i] %i, magic=%x, pid=%i\n", i, InstLst->IsScribe(), InstLst->Magic, InstLst->Pid);
 				if (InstLst->IsScribe() && InstLst != ThisInst)
 				{
 					// LgiTrace("%s, %s\n", InstLst->OptionsPath, d->Options->GetFile());
 					if (Mul || _stricmp(InstLst->OptionsPath, d->Options->GetFile()) == 0)
 					{
 						int Pid = InstLst->Pid;
 						OsAppArguments *Args = LAppInst->GetAppArgs();
 						
 						if (!LIsProcess(Pid))
 						{
 							continue;
 						}
 						
 						char *Utf8 = 0;
 						#if WINNATIVE
 						Utf8 = WideToUtf8(Args->lpCmdLine);
 						#else
 						LStringPipe p;
 						for (int i=1; i<Args->Args; i++)
 						{
 							if (i > 1) p.Push(" ");
 							char *Sp = strchr(Args->Arg[i], ' ');
 							if (Sp) p.Push("\"");
 							p.Push(Args->Arg[i]);
 							if (Sp) p.Push("\"");
 						}
 						Utf8 = p.NewStr();
 						#endif
 						if (Utf8)
 						{
 							size_t Len = strlen(Utf8);
 							if (Len > 255)
 							{
 								InstLst->Flags |= SCRIBE_IPC_LONG_ARGS;
 								InstLst->Flags &= ~SCRIBE_IPC_CONTINUE_ARGS;
 								for (char *u = Utf8; Len > 0; u += 255)
 								{
 									ssize_t Part = MIN(sizeof(InstLst->Args)-1, Len);
 									
 									memcpy(InstLst->Args, u, Part);
 									Len -= Part;
 
 									int64 Start = LCurrentTime();
 									while (LCurrentTime() - Start < 60000)
 									{
 										if (TestFlag(InstLst->Flags, SCRIBE_IPC_CONTINUE_ARGS) &&
 											InstLst->Args[0] == 0)
 										{
 											Start = 0;
 											break;
 										}
 										LSleep(10);
 									}
 									if (Start)
 									{
 										LgiTrace("%s:%i - SendLA timed out.\n", _FL);
 										break;
 									}
 								}
 
 								InstLst->Flags &= ~(SCRIBE_IPC_CONTINUE_ARGS | SCRIBE_IPC_LONG_ARGS);
 							}
 							else
 							{
 								strcpy_s(InstLst->Args, sizeof(InstLst->Args), Utf8);
 							}
 							DeleteArray(Utf8);
 							
 							ShutdownIpc();
 							
 							LgiTrace("Passed args to the other running instance of Scribe (pid=%i)\n", Pid);
 							LCloseApp();
 							return false;
 						}
 						else LgiTrace("%s:%i - No arguments to pass.\n", _FL);
 					}
 				}
 			}
 			
 			if (Mul && LFileExists(Mul->OptionsPath))
 			{
 				// No instance of Scribe is running, but MUL may be keeping
 				// the previously run instance around. So we should run that
 				// by using the options file and password from MUL's instance
 				// record.
 				d->Options.Reset(new LOptionsFile(Mul->OptionsPath));
 			}
 		}
 		
 		// Insert ourselves into the instance list
 		if (ThisInst)
 		{
 			strcpy_s(ThisInst->OptionsPath, sizeof(ThisInst->OptionsPath), d->Options->GetFile());
 		}
 	}
 
 	// Open file and load..
 	if (!Load && d->Options)
 	{
 		LOptionsFile *Opts = GetOptions();
 		Load = Opts->SerializeFile(false);
 		if (Load)
 		{
 			LVariant v = d->GetInstallMode() == LOptionsFile::PortableMode;
 			GetOptions()->SetValue(OPT_IsPortableInstall, v);
 		}
 		else
 		{
             auto err = GetOptions()->GetError();
 			LgiMsg(	this,
 					LLoadString(IDS_ERROR_LR8_FAILURE),
 					AppName,
 					MB_OK,
 					err);
 		}
 	}
 
 	if (!d->Options)
 	{
 		// d->Options = new LOptionsFile(d->GetInstallMode(), OptionsFileName);
 		return false;
 	}
 
 	if (d->Options)
 	{
 		LVariant v;
 
 		if (!d->Options->GetValue(OPT_IsPortableInstall, v) &&
 			d->GetInstallMode() != LOptionsFile::UnknownMode)
 		{
 			v = d->GetInstallMode() == LOptionsFile::PortableMode;
 			d->Options->SetValue(OPT_IsPortableInstall, v);
 		}
 
 		ScribeOptionsDefaults(d->Options);
 
 		if (Load)
 		{
 			if (GetOptions()->GetValue(OPT_PrintSettings, v))
 			{
 				auto *p = GetPrinter();
 				if (p)
 				{
 					LString s = v.Str();
 					p->Serialize(s, false);
 				}
 			}
 		}
 
 		if (d->Options->GetValue(OPT_PreviewLines, v))
 		{
 			Mail::PreviewLines = v.CastInt32() != 0;
 		}
 
 		// upgrade smtp password
 		const char *Pw = "SmtpPsw";
 		if (!GetOptions()->GetValue(OPT_EncryptedSmtpPassword, v))
 		{
 			// no encrypted password, look for unencrypted password
 			if (GetOptions()->GetValue(Pw, v))
 			{
 				LPassword p;
 				p.Set(v.Str());
 				p.Serialize(GetOptions(), OPT_EncryptedSmtpPassword, true);
 			}
 		}
 
 		// if old un-encrypted password exists...
 		// delete the key, we are now storing an encrypted 
 		// password
 		if (GetOptions()->GetValue(Pw, v))
 			GetOptions()->DeleteValue(Pw);
 		
 		if (GetOptions()->GetValue(OPT_AdjustDateTz, v))
 			Mail::AdjustDateTz = !v.CastInt32();
 
 		if (!GetOptions()->GetValue(OPT_ConfirmDelete, v))
 			GetOptions()->SetValue(OPT_ConfirmDelete, v = true);
 
 		if (!GetOptions()->GetValue(OPT_DelDirection, v))
 			GetOptions()->SetValue(OPT_DelDirection, v = DeleteActionPrev);
 
 		if (GetOptions()->GetValue(OPT_SizeInKiB, v))
 			OptionSizeInKiB = v.CastInt32() != 0;	
 		if (GetOptions()->GetValue(OPT_RelativeDates, v))
 			ShowRelativeDates = v.CastInt32() != 0;	
 
 		// date format
 		if (GetOptions()->GetValue(OPT_DateFormat, v))
 		{
 			int Idx = v.CastInt32();
 			if (Idx >= 0 && Idx < CountOf(DateTimeFormats))
 				LDateTime::SetDefaultFormat(DateTimeFormats[Idx]);
 		}
 		
 		// SSL debug logging
 		if (GetOptions()->GetValue(OPT_DebugSSL, v))
 			SslSocket::DebugLogging = v.CastInt32() != 0;
 
 		// Growl
 		if (GetOptions()->GetValue(OPT_GrowlEnabled, v) &&
 			v.CastInt32())
 		{
 			LVariant Ver, Bld;
 			GetVariant(DomToStr(SdVersion), Ver);
 			GetVariant("Build", Bld);
 			LString n;
 			n.Printf("%s\n%s", Ver.Str(), Bld.Str());
 			GrowlInfo("Scribe has started up...", n);
 		}
 	}
 
 	#if LGI_EXCEPTIONS
 	try
 	{
 	#endif
 		// Default the font settings to the system font
 		// if they don't already exist
 		const char *OptFont[] = { OPT_EditorFont, OPT_PrintFont, OPT_HtmlFont, 0 };
 		int Index = 0;
 		for (const char **Opt=OptFont; *Opt; Opt++, Index++)
 		{
 			LVariant v;
 			if (!GetOptions()->GetValue(*Opt, v))
 			{
 				LFontType Type;
 				if (Type.GetSystemFont("System"))
 				{
 					if (Index == 2)
 					{
 						int Pt = Type.GetPointSize();
 						Type.SetPointSize(Pt+3);
 					}
 					Type.Serialize(GetOptions(), *Opt, true);
 				}
 			}
 		}
 	#if LGI_EXCEPTIONS
 	}
 	catch (...)
 	{
 		LgiMsg(	this,
 				LLoadString(IDS_ERROR_FONT_SETTINGS),
 				AppName,
 				MB_OK);
 	}
 	#endif
 
 	return true;
 }
 
 bool ScribeWnd::SaveOptions()
 {
 	LStringPipe Log(256);
 	bool Status = false;
 	bool WriteFailed = false;
 	bool WndStateSet = false;
 	
 	RestartSave:
 	if (d->Options && !d->Options->GetFile())
 	{
 		bool PortableOk = true;
 		char Path[MAX_PATH_LEN];
 		char Leaf[32];
 
 		sprintf_s(Leaf, sizeof(Leaf), "%s.xml", OptionsFileName);
 		Log.Print("No current path for '%s', creating...\n", Leaf);
 
 		LVariant v;
 		GetOptions()->GetValue(OPT_IsPortableInstall, v);
 		if (v.CastInt32())
 		{
 			if (!LGetSystemPath(LSP_APP_INSTALL, Path, sizeof(Path)))
 			{
 				PortableOk = false;
 				Log.Print("Error: LgiGetSystemPath(LSP_APP_INSTALL) failed.\n");
 			}
 			else
 			{
 				LMakePath(Path, sizeof(Path), Path, Leaf);
 				
 				// Do write test to confirm we are good to go
 				LFile f;
 				if (f.Open(Path, O_WRITE))
 				{
 					f.Close();
 					FileDev->Delete(Path, false);
 					d->Options->SetFile(Path);
 				}
 				else
 				{
 					PortableOk = false;
 					Log.Print("Warning: '%s' is not writable.\n", Path);
 				}
 			}
 		}
 		
 		if (!v.CastInt32() || !PortableOk)
 		{
 			// Desktop mode then.
 			if (v.CastInt32())
 			{
 				const char *Msg = "Switching to desktop mode because the install folder is not writable.";
 				Log.Print("%s\n", Msg);
 				LgiMsg(this, Msg, AppName, MB_OK);
 				GetOptions()->SetValue(OPT_IsPortableInstall, v = false);
 			}
 
 			if (!LGetSystemPath(LSP_APP_ROOT, Path, sizeof(Path)))
 			{
 				Log.Print("Error: LgiGetSystemPath(LSP_APP_ROOT) failed.\n");
 			}
 			else
 			{
 				LMakePath(Path, sizeof(Path), Path, LAppInst->LBase::Name());
 				if (!LDirExists(Path))
 				{
 					if (!FileDev->CreateFolder(Path))
 					{
 						Log.Print("Error: CreateFolder('%s') failed.\n", Path);
 					}
 				}
 
 				LMakePath(Path, sizeof(Path), Path, Leaf);
 				
 				// Do write test to confirm we are good to go
 				LFile f;
 				if (f.Open(Path, O_WRITE))
 				{
 					f.Close();
 					FileDev->Delete(Path, false);
 					d->Options->SetFile(Path);
 				}
 				else
 				{
 					Log.Print("Error: '%s' is not writable.\n", Path);
 				}
 			}
 		}
 	}
 
 	if (d->Options && d->Options->GetFile() && d->Options->IsValid())
 	{
 		// Backup options file
 		char Backup[MAX_PATH_LEN];
 		strcpy_s(Backup, sizeof(Backup), d->Options->GetFile());
 		char *Ext = LGetExtension(Backup);
 		if (Ext)
 		{
 			*--Ext = 0;
 
 			LString s;
 			for (int i=1; i<100; i++)
 			{
 				s.Printf("%s_%i.bak", Backup, i);
 				if (!LFileExists(s))
 					break;
 			}
 
 			if (!LFileExists(s))
 				FileDev->Move(d->Options->GetFile(), s);
 		}
 
 		// Update some settings...
 		#if LGI_VIEW_HANDLE
 		if (Handle())
 		#endif
 			WndStateSet = SerializeState(GetOptions(), OPT_ScribeWndPos, false);
 
 		LVariant v;
 		if (Splitter)
 			GetOptions()->SetValue(OPT_SplitterPos, v = (int)Splitter->Value());
 		if (d->SubSplit)
 		{
 			auto First = d->SubSplit->GetViewAt(0);
 			if (First == (LViewI*)SearchView)
 			{
 				auto Lst = (SearchView) ? d->SubSplit->GetViewAt(1) : NULL;
 				if (Lst)
 					GetOptions()->SetValue(OPT_SubSplitPos, v = (int)Lst->GetPos().Y());
 			}
 			else
 				GetOptions()->SetValue(OPT_SubSplitPos, v = (int)d->SubSplit->Value());
 		}
 
 		// Write them...
 		if (GetOptions()->SerializeFile(true))
 		{
 			Status = true;
 		}
 		else
 		{
 			// We probably don't have write permissions to the install folder...
 			Log.Print("Error: Options.Serialize failed.\n");
 			
 			if (!WriteFailed)
 			{
 				// This blocks any possibility of an infinite loop
 				WriteFailed = true;
 				d->Options->SetFile(NULL);
 				
 				// Set desktop mode explicitly
 				LVariant v;
 				GetOptions()->GetValue(OPT_IsPortableInstall, v = false);
 				
 				Log.Print("Restarting save after setting desktop mode...\n");
 				goto RestartSave;
 			}
 		}
 	}
 	
 	if (!Status)
 	{
 		LString a = Log.NewLStr();
 		LgiMsg(this, "Saving options failed:\n%s", AppName, MB_OK, a.Get());
 	}
 	
 	if (!WndStateSet)
 	{
 		LRect r(10, 10, 790, 590);
 		SetPos(r);
 		MoveToCenter();
 	}
 	
 	return Status;
 }
 
 //
 // Command Line Options:
 //
 //	-m, -t				: To recipient(s)
 //	-f					: The filename of the attachment
 //	-b					: Attach as a binary
 //	-c					: CC'd recipient(s)
 //	-s					: Subject for the email
 //	-n					: Send now... else UI is shown
 //	-p					: Print the file
 //  -upgrade_folders	: trigger a folder upgrade
 //  -o                  : Load the following options file
 //  -u                  : Load the following URL/file
 //
 void ScribeWnd::OnCommandLine()
 {
 	// check command line args
 	LString Str, File;
 	bool CreateMail = false;
 	CreateMail = LAppInst->GetOption("m", Str);
 	if (!CreateMail) CreateMail = LAppInst->GetOption("t", Str);
 	bool HasFile = LAppInst->GetOption("f", File);
 	if (!CreateMail) CreateMail = HasFile;
 
 	LString OpenArg;
 	if (LAppInst->GetOption("u", OpenArg))
 	{
 		LUri u(OpenArg);
 		if (u.sProtocol)
 		{
 			OnUrl(OpenArg);
 		}
 		else if (LFileExists(OpenArg))
 		{
 			LArray<const char*> Files;
 			Files.Add(OpenArg);
 			OnReceiveFiles(Files);
 		}
 	}
 
 	Mail *NewEmail = 0;
 	if (CreateMail && Str)
 	{
 		// strip off quotes if needed
 		char *In = Str, *Out = Str;
 		for (; In && *In; In++)
 		{
 			if (!strchr("\'\"", *In))
 			{
 				*Out++ = *In;
 			}
 		}
 		*Out++ = 0;
 
 		// create object
 		NewEmail = dynamic_cast<Mail*>(CreateItem(MAGIC_MAIL, NULL, false));
 		if (NewEmail)
 		{
 			Mailto mt(this, Str);
 			mt.Apply(NewEmail);
 
 			// cc's?
 			if (LAppInst->GetOption("c", Str))
 			{
 				SetRecipients(this, Str, NewEmail->GetObject()->GetList(FIELD_TO), MAIL_ADDR_CC);
 			}
 
 			// attach a file?
 			if (File)
 			{
 				if (LAppInst->GetOption("b"))
 				{
 					// attach as a binary file
 					NewEmail->AttachFile(this, &File[0]);
 				}
 				else
 				{
 					// insert as the body
 					LAutoString b(LReadTextFile(&File[0]));
 					if (b)
 					{
 						NewEmail->SetBody(b);
 					}
 				}
 			}
 
 			// subject?
 			if (LAppInst->GetOption("s", Str))
 			{
 				NewEmail->SetSubject(Str);
 			}
 
 			// Send now or later?
 			if (LAppInst->GetOption("n"))
 			{
 				// Check for exit after send option
 				d->ExitAfterSend = LAppInst->GetOption("exit");
 				
 				// now
 				NewEmail->SetFlags(MAIL_CREATED | MAIL_READY_TO_SEND | NewEmail->GetFlags());
 				NewEmail->Save();
 				OnCommand(IDM_SEND_MAIL, 0,
 					#ifndef __GTK_H__
 					Handle()
 					#else
 					NULL
 					#endif
 					);
 			}
 			else
 			{
 				// later
 				NewEmail->DoUI();
 			}
 		}
 	} 
 
 	// Pop3 on startup option
 	LVariant n;
 	if (GetOptions()->GetValue(OPT_Pop3OnStart, n) && n.CastInt32())
 	{
 		OnCommand(IDM_RECEIVE_MAIL, 0, NULL);
 	}
 }
 
 void ScribeWnd::SetCurrentIdentity(int i)
 {
 	LVariant v = i;
 	GetOptions()->SetValue(OPT_CurrentIdentity, v);
 	
 	if (DefaultIdentityItem) DefaultIdentityItem->Checked(i < 0);
 	for (auto a: Accounts)
 	{
 		a->SetCheck(i == a->GetIndex());
 	}
 }
 
 ScribeAccount *ScribeWnd::GetCurrentAccount()
 {
 	auto Idx = GetCurrentIdentity();
 	ScribeAccount *a = (Idx >= 0 && Idx < (ssize_t)Accounts.Length()) ? Accounts.ItemAt(Idx) : NULL;
 	bool ValidId = a != NULL && a->IsValid();
 	if (!ValidId)
 	{
 		LAssert(!"No current identity?");
 		
 		// Find a valid account to be the identity...
 		for (auto a : Accounts)
 		{
 			if (!a->Send.Disabled() &&
 				a->Identity.IsValid())
 			{
 				break;
 			}
 		}
 	}
 	return a;
 }
 
 int ScribeWnd::GetCurrentIdentity()
 {
 	LVariant i;
 	if (GetOptions()->GetValue(OPT_CurrentIdentity, i))
 		return i.CastInt32();
 	else if (ScribeState != ScribeInitializing)
 		LgiTrace("%s:%i - No OPT_CurrentIdentity set.\n", _FL);
 
 	return -1;
 }
 
 void ScribeWnd::SetupAccounts()
 {
 	int i, CurrentIdentity = GetCurrentIdentity();
 
 	if (StatusPanel)
 	{
 		StatusPanel->Empty();
 	}
 
 	#if !defined(COCOA) // FIXME
 	LAssert(ReceiveMenu && PreviewMenu);
 	#endif
 
 	if (SendMenu) SendMenu->Empty();
 	if (ReceiveMenu) ReceiveMenu->Empty();
 	if (PreviewMenu) PreviewMenu->Empty();
 	if (IdentityMenu)
 	{
 		IdentityMenu->Empty();
 	}
 
 	static bool Startup = true;
 
 	bool ResetDefault = false;
 	LArray<ScribeAccount*> Enabled;
 	for (i=0; true; i++)
 	{
 		// char *s = 0;
 
 		ScribeAccount *a = Startup ? new ScribeAccount(this, i) : Accounts[i];
 		if (a)
 		{
 			if (i == 0)
 			{
 				a->Create();
 			}
 			
 			a->Register(this);
 
 			LVariant ReceiveName = a->Receive.Name();
 			LVariant ReceiveServer = a->Receive.Server();
 			LVariant SendServer = a->Send.Server();
 
 			if (i == 0 ||
 				ValidStr(ReceiveName.Str()) ||
 				ValidStr(ReceiveServer.Str()) ||
 				ValidStr(SendServer.Str()) )
 			{
 				a->Send.SendItem = SendItem;
 				a->Receive.ReceiveItem = ReceiveItem;
 				a->Receive.PreviewItem = PreviewItem;
 
 				if (!Accounts.HasItem(a))
 				{
 					Accounts.Insert(a);
 				}
 				
 				if (i) a->Create();				
 				a->InitMenus();
 
 				// Identity Menu Item
 				LVariant IdEmail = a->Identity.Email();
 				LVariant IdName = a->Identity.Name();
 				if (IdentityMenu &&
 					ValidStr(IdEmail.Str()))
 				{
 					char s[256];
 					if (IdName.Str())
 						sprintf_s(s, sizeof(s), "%s <%s>", IdName.Str(), IdEmail.Str());
 					else
 						sprintf_s(s, sizeof(s), "<%s>", IdEmail.Str());
 
 					a->SetMenuItem(IdentityMenu->AppendItem(s, IDM_IDENTITY_BASE+i+1, !a->Send.Disabled()));
 					if (a->Send.Disabled())
 					{
 						a->SetCheck(false);
 						if (i == CurrentIdentity)
 							ResetDefault = true;
 					}
 					else
 					{
 						a->SetCheck(i == CurrentIdentity);
 						Enabled[i] = a;
 					}
 				}
 			}
 			else
 			{
 				Accounts.Delete(a);
 				DeleteObj(a);
 			}
 		}
 
 		if (!a)
 			break;
 	}
 
 	if ((ResetDefault || CurrentIdentity < 0) && Enabled.Length())
 	{
 		for (unsigned i=0; i<Enabled.Length(); i++)
 		{
 			if (Enabled[i])
 			{
 				Enabled[i]->SetCheck(true);
 				
 				LVariant v;
 				GetOptions()->SetValue(OPT_CurrentIdentity, v = (int)i);
 				break;					
 			}
 		}
 	}
 
 	Startup = false;
 
 	if (ReceiveMenu &&
 		i == 0)
 	{
 		ReceiveMenu->AppendItem(LLoadString(IDS_NO_ITEMS), 0, false);
 	}
 
 	if (StatusPanel)
 	{
 		StatusPanel->OnAccountListChange();
 	}
 
 	SetPulse(100);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 class LShutdown : public LDialog
 {
 	LTextLabel *Msg;
 	LButton *KillBtn;
 	LButton *CancelBtn;
 	bool Disconnected;
 	
 public:
 	ScribeAccount *Wait;
 	List<ScribeAccount> *Accounts;
 
 	LShutdown(List<ScribeAccount> *accounts)
 	{
 		Wait = 0;
 		Disconnected = false;
 		Accounts = accounts;
 		LRect r(	0,
 					0,
 					320 + LAppInst->GetMetric(LGI_MET_DECOR_X),
 					70 + LAppInst->GetMetric(LGI_MET_DECOR_Y));
 		SetPos(r);
 		MoveToCenter();
 
 		char Str[256];
 		sprintf_s(Str, sizeof(Str), "%s exiting...", AppName);
 		LView::Name(Str);
 
 		AddView(Msg = new LTextLabel(-1, 10, 10, 300, -1, "None"));
 		AddView(KillBtn = new LButton(IDC_KILL, 70, 35, 60, 20, "Kill"));
 		AddView(CancelBtn = new LButton(IDCANCEL, 140, 35, 60, 20, "Cancel"));
 
 		if (KillBtn)
 		{
 			KillBtn->Enabled(false);
 		}
 	}
 
 	void OnCreate()
 	{
 		SetPulse(100);
 	}
 
 	void OnPulse()
 	{
 		if (Accounts)
 		{
 			if (!Wait)
 			{
 				Wait = (*Accounts)[0];
 				if (Wait)
 				{
 					Disconnected = false;
 					
 					char s[256];
 					LVariant v = Wait->Receive.Name();
 					sprintf_s(s, sizeof(s), "Waiting for '%s'", v.Str() ? v.Str() : (char*)"Untitled...");
 					Msg->Name(s);
 
 					Accounts->Delete(Wait);					
 					Wait->Stop();
 
 					KillBtn->Enabled(true);
 				}
 				else
 				{
 					SetPulse();
 					EndModal(true);
 				}
 			}
 
 			if (Wait && !Wait->IsOnline())
 			{
 				Wait = 0;
 				Msg->Name("None");
 				KillBtn->Enabled(false);
 			}
 		}
 		else
 		{
 			SetPulse();
 			EndModal(false);
 		}
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case IDC_KILL:
 			{
 				if (Wait)
 				{
 					if (!Disconnected)
 					{
 						Disconnected = true;
 						Wait->Disconnect();
 					}
 					else
 					{
 						Wait->Kill();
 					}
 				}
 				break;
 			}
 			case IDCANCEL:
 			{
 				EndModal(false);
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 bool ScribeWnd::OnRequestClose(bool OsShuttingDown)
 {
 	if (FolderTasks.Length() > 0)
 	{
 		LgiTrace("%s:%i - %i folder tasks still busy...\n", _FL, FolderTasks.Length());
 		return false;
 	}
 
 	LString OnClose = LAppInst->GetConfig("Scribe.OnClose");
 	if (!d->IngoreOnClose &&
 		!OsShuttingDown &&
 		!Stricmp(OnClose.Get(), "minimize"))
 	{
 		SetZoom(LZoomMin);
 		return false;
 	}
 
 	Visible(false);
 
 	if (ScribeState != ScribeRunning)
 	{
 		// Inside a folder load/unload or initialization
 		// Tell the loader to quit out...
 		ScribeState = ScribeExiting;
 
 		// Leave now, we can exit when we're ready
 		return false;
 	}
 	else if (IsSending() ||
 			 GetActiveThreads() > 0)
 	{
 		// whack up a shutdown window
 		List<ScribeAccount> Online;
 
 		for (auto i: Accounts)
 		{
 			i->OnEndSession();
 			if (i->IsOnline())
 			{
 				Online.Insert(i);
 			}
 		}
 
 		auto Dlg = new LShutdown(&Online);
 		Dlg->DoModal([this, Dlg](auto dlg, auto id)
 		{
 			if (id)
 			{
 				ScribeState = ScribeExiting;
 				LCloseApp();
 			}
 			else
 			{
 				ScribeState = ScribeRunning;
 				Visible(true);
 			}
 		});
 		return false; // At the very minimum the app has to wait for the user to respond.
 	}
 	else
 	{
 		// End all sessions if any...
 		for (auto i: Accounts)
 		{
 			i->OnEndSession();
 		}
 	}
 
 	// close all the other top level windows
 	while (ThingUi::All.Length() > 0)
 	{
 		ThingUi *Ui = ThingUi::All.First();
 		if (!Ui->OnRequestClose(OsShuttingDown))
 		{
 			ScribeState = ScribeRunning;
 			Visible(true);
 			return false;
 		}
 
 		size_t Start = ThingUi::All.Length();
 		Ui->Quit();
 		if (ThingUi::All.Length() >= Start)
 		{
 			LAssert(0);
 			break;
 		}
 	}
 
 	SerializeState(GetOptions(), OPT_ScribeWndPos, false);
 	LCloseApp();
 
 	return LWindow::OnRequestClose(OsShuttingDown);
 }
 
 void ScribeWnd::DoOnTimer(LScriptCallback *c)
 {
 	if (!c)
 		return;
 
 	auto Now = LCurrentTime();
 	if (c->PrevTs)
 	{
 		auto Since = Now - c->PrevTs; 
 		double Sec = (double)Since / 1000.0;
 		if (Sec >= c->fParam)
 		{
 			// Call the function
 			c->PrevTs = Now;
 
 			LVirtualMachine Vm;
 			LScriptArguments Args(&Vm);
 			LVariant This((LDom*)this);
 			Args.Add(&This);
 			ExecuteScriptCallback(*c, Args);
 		}
 	}
 	else
 	{
 		c->PrevTs = Now;
 	}
 }
 
 void ScribeWnd::OnMinute()
 {
 	if (Folders.Length() == 0)
 		return;
 
 	// Check for calendar event alarms...
 	Calendar::CheckReminders();
 
 	// Check for any outgoing email that should be re-attempted...
 	ScribeFolder *Outbox = GetFolder(FOLDER_OUTBOX);
 	if (Outbox)
 	{
 		bool Resend = false;
 
 		for (auto t : Outbox->Items)
 		{
 			Mail *m = t->IsMail();
 			if (m &&
 				!TestFlag(m->GetFlags(), MAIL_SENT) &&
 				TestFlag(m->GetFlags(), MAIL_READY_TO_SEND) &&
 				m->SendAttempts > 0)
 			{
 				Resend = true;
 				break;
 			}			
 		}
 
 		if (Resend)
 			Send();
 	}
 
 	LArray<LScriptCallback*> Cb;
 	if (GetScriptCallbacks(LOnTimer, Cb))
 	{
 		for (auto c: Cb)
 		{
 			if (!c->Func)
 				continue;
 
 			if (c->fParam == 0.0)
 			{
 				// Work out the period from 'Data'
 				char *s = c->Data.Str();
 				while (*s && IsWhiteSpace(*s)) s++;
 				char *u = s;
 				while (*u && !IsAlpha(*u)) u++;
 				double v = atof(s);
 
 				switch (*u)
 				{
 					case 's': case 'S': // seconds
 						c->fParam = v;
 						break;
 					case 'm': case 'M': // mins
 						c->fParam = v * LDateTime::MinuteLength;
 						break;
 					case 'h': case 'H': // hours
 						c->fParam = v * LDateTime::HourLength;
 						break;
 					case 'd': case 'D': // days
 						c->fParam = v * LDateTime::DayLength;
 						break;
 					default:
 					{
 						LgiTrace("%s:%i - Couldn't understand period '%s'\n", _FL, c->Data.Str());
 						c->Data.Empty();
 						break;
 					}
 				}
 
 				if ((c->OnSecond = c->fParam < 60.0))
 				{
 					d->OnSecondTimerCallbacks.Add(c);
 				}
 			}
 
 			if (!c->OnSecond)
 				DoOnTimer(c);
 		}
 	}
 }
 
 void ScribeWnd::OnHour()
 {
 	// Force time zone update in case of daylight savings change.
 	LDateTime::SystemTimeZone(true);
 
 	// Check if we need should be doing a software update check
 	static bool InSoftwareCheck = false;
 	if (!InSoftwareCheck)
 	{
 		char s[64];
 
 		InSoftwareCheck = true;
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_SoftwareUpdate, v) &&
 			v.CastInt32())
 		{
 			LDateTime Now, Last;
 
 			Now.SetFormat(GDTF_YEAR_MONTH_DAY);
 			Last.SetFormat(Now.GetFormat());
 
 			Now.SetNow();
 					
 			if (!GetOptions()->GetValue(OPT_SoftwareUpdateLast, v) ||
 				!Last.Set(v.Str()))
 			{
 				// Record now as the last check point
 				Now.Get(s, sizeof(s));
 				GetOptions()->SetValue(OPT_SoftwareUpdateLast, v = s);
 			}
 			else if (GetOptions()->GetValue(OPT_SoftwareUpdateTime, v))
 			{
 				// Valid last check date/time.
 				switch (v.CastInt32())
 				{
 					case 0: // Week
 						Last.AddDays(7);
 						break;
 					case 1: // Month
 						Last.AddMonths(1);
 						break;
 					case 2: // Year
 						Last.AddMonths(12);
 						break;
 					default:
 						LgiTrace("%s:%i - The option '%s' is not valid\n", _FL, OPT_SoftwareUpdateTime);
 						return;
 				}
 
 				if (Last < Now)
 				{
 					// Save the last date for next time...
 					Now.Get(s, sizeof(s));
 					GetOptions()->SetValue(OPT_SoftwareUpdateLast, v = s);
 
 					// Check for update now...
 					GetOptions()->GetValue(OPT_SoftwareUpdateIncBeta, v);
 					IsSoftwareUpToDate(	this,
 										false,
 										v.CastInt32() != 0,
 										[this](auto s, auto Info)
 										{
 											if (s == SwOutOfDate)
 												if (UpgradeSoftware(Info, this, true))
 													LCloseApp();
 										});
 				}
 			}
 		}
 		InSoftwareCheck = false;
 	}
 }
 
 bool ScribeWnd::SaveDirtyObjects(int TimeLimitMs)
 {
 	bool Status = false;
 	if (Thing::DirtyThings.Length() > 0)
 	{
 		static bool SavingObjects = false;
 
 		if (!SavingObjects)
 		{
 			SavingObjects = true;
 
 			LArray<int> WriteTimes;
 			// ssize_t StartDirty = Thing::DirtyThings.Length();
 			uint64 Start = LCurrentTime();
 			for (unsigned i=0;
 				i<ThingType::DirtyThings.Length() && LCurrentTime() - Start < TimeLimitMs;
 				i++)
 			{
 				ThingType *t = ThingType::DirtyThings[i];
 				if (t)
 				{
 					static int FailedWrites = 0;
 
 					uint64 WriteStart = LCurrentTime();
 					if (t->Save(NULL))
 					{
 						WriteTimes.Add((int) (LCurrentTime() - WriteStart));
 						
 						LAssert(!ThingType::DirtyThings.HasItem(t));
 						Status = true;
 					}
 					else
 					{
 						LgiTrace("Failed to save thing type 0x%x\n", t->Type());
 
 						FailedWrites++;
 						if (FailedWrites > 2)
 						{
 							while (ThingType::DirtyThings.Length())
 								ThingType::DirtyThings[0]->SetDirty(false);
 							FailedWrites = 0;
 						}
 					}
 				}
 			}
 
 			SavingObjects = false;
 			
 			/*
 			if (Status)
 			{
 				LStringPipe p;
 				p.Print("WriteTimes: ");
 				for (unsigned i=0; i<WriteTimes.Length(); i++)
 					p.Print("%i, ", WriteTimes[i]);
 				LAutoString a(p.NewStr());
 				#ifdef WINDOWS
 				OutputDebugStringA(a);
 				#else
 				printf("%s", a.Get());
 				#endif
 			}
 			*/
 		}
 	}
 
 	return Status;
 }
 
 void ScribeWnd::OnPulse()
 {
 	if (ScribeState == ScribeRunning)
 	{
 		OnIdle();
 		
 		uint64 Now = LCurrentTime();
 		if (Now - d->LastTs >= 1000)
 		{
 			d->LastTs = Now;
 			OnPulseSecond();
 		}
 	}
 }
 
 void ScribeWnd::OnPulseSecond()
 {
 	#if PROFILE_ON_PULSE
 	LProfile Prof("NewMailLst handling");
 	Prof.HideResultsIfBelow(50);
 	#endif
 	
 	if (Mail::NewMailLst.Length() > 0)
 	{
 		LVariant Blink;
 		if (GetOptions()->GetValue(OPT_BlinkNewMail, Blink) && Blink.CastInt32())
 		{
 			TrayIcon.Value((TrayIcon.Value() == TRAY_ICON_MAIL) ? TRAY_ICON_NONE : TRAY_ICON_MAIL);
 		}
 	}
 	else
 	{
 		bool Err = false;
 		for (auto a: Accounts)
 		{
 			if (!a->Receive.GetStatus() ||
 				!a->Send.GetStatus())
 			{
 				Err = true;
 			}
 		}
 		
 		TrayIcon.Value(Err ? TRAY_ICON_ERROR : TRAY_ICON_NORMAL);
 	}
 	
 	#if PROFILE_ON_PULSE
 	Prof.Add("StatusPanel handling");
 	#endif
 
 	if (StatusPanel)
 	{
 		StatusPanel->OnPulse();
 	}
 
 	#if PROFILE_ON_PULSE
 	Prof.Add("OnXXXX handling");
 	#endif
 	
 	LDateTime Now;
 	Now.SetNow();
 	if (d->LastMinute != Now.Minutes()) // Check every minute...
 	{
 		d->LastMinute = Now.Minutes();
 		OnMinute();
 	}
 	if (d->LastHour != Now.Hours()) // Check every hour...
 	{
 		d->LastHour = Now.Hours();
 		OnHour();
 	}
 	{
 		// These timers need to be checked every second...
 		for (auto c: d->OnSecondTimerCallbacks)
 			DoOnTimer(c);
 	}
 
 	#if PROFILE_ON_PULSE
 	Prof.Add("Instance handling");
 	#endif
 
 	if (ThisInst && ValidStr(ThisInst->Args))
 	{
 		LStringPipe p;
 		p.Push(ThisInst->Args);
 		if (ThisInst->Flags & SCRIBE_IPC_LONG_ARGS)
 		{
 			ThisInst->Flags |= SCRIBE_IPC_CONTINUE_ARGS;
 
 			int64 Start = LCurrentTime();
 			while (	TestFlag(ThisInst->Flags, SCRIBE_IPC_LONG_ARGS) &&
 					LCurrentTime() - Start < 60000)
 			{
 				ZeroObj(ThisInst->Args);
 				while (	TestFlag(ThisInst->Flags, SCRIBE_IPC_LONG_ARGS) &&
 						!ThisInst->Args[0] &&
 						LCurrentTime() - Start < 60000)
 				{
 					LSleep(10);
 				}
 				p.Push(ThisInst->Args);
 			}
 		}
 		ZeroObj(ThisInst->Args);
 
 		LAutoString Arg(p.NewStr());
 		if (Arg)
 		{
 			OsAppArguments AppArgs(0, 0);
 			
 			LgiTrace("Received cmd line: %s\n", Arg.Get());
 			AppArgs.Set(Arg);
 
 			LAppInst->SetAppArgs(AppArgs);
 
 			if (LAppInst->GetOption("m") &&
 				LAppInst->GetOption("f"))
 				;
 			else
 				LAppInst->OnCommandLine();
 			
 			OnCommandLine();
 
 			if (GetZoom() == LZoomMin)
 				SetZoom(LZoomNormal);
 			Visible(true);
 		}
 	}
 
 	#if PROFILE_ON_PULSE
 	Prof.Add("PreviewPanel handling");
 	#endif
 
 	if (PreviewPanel)
 	{
 		PreviewPanel->OnPulse();
 	}
 }
 
 void ScribeWnd::AddFolderToMru(char *FileName)
 {
 	if (FileName)
 	{
 		// read MRU
 		List<char> Files;
 		int i;
 		for (i=0; i<10; i++)
 		{
 			char Key[32];
 			LVariant f;
 			sprintf_s(Key, sizeof(Key), "FolderMru.%i", i);
 			if (GetOptions()->GetValue(Key, f))
 			{
 				Files.Insert(NewStr(f.Str()));
 				GetOptions()->DeleteValue(Key);
 			}
 		}
 
 		// remove FileName if present
 		for (auto f: Files)
 		{
 			if (_stricmp(f, FileName) == 0)
 			{
 				Files.Delete(f);
 				DeleteArray(f);
 				break;
 			}
 		}
 
 		// insert FileName at the start of the list
 		Files.Insert(NewStr(FileName));
 
 		// write MRU
 		for (i=0; i<10; i++)
 		{
 			char *n = Files.ItemAt(i);
 			if (n)
 			{
 				char Key[32];
 				sprintf_s(Key, sizeof(Key), "FolderMru.%i", i);
 				LVariant f;
 				GetOptions()->SetValue(Key, f = n);
 			}
 			else break;
 		}
 
 		// Clean up
 		Files.DeleteArrays();
 	}
 }
 
 bool ScribeWnd::CleanFolders(ScribeFolder *f)
 {
 	if (!f)
 		return false;
 
 	if (f->Select())
 	{
 		f->SerializeFieldWidths();
 	}
 
 	for (ScribeFolder *c = f->GetChildFolder(); c; c = c->GetNextFolder())
 	{
 		CleanFolders(c);
 	}
 
 	return true;
 }
 
 void ScribeWnd::OnFolderChanged(LDataFolderI *folder)
 {
 }
 
 bool ScribeWnd::OnFolderTask(LEventTargetI *Ptr, bool Add)
 {
 	if (Add)
 	{
 		if (FolderTasks.HasItem(Ptr))
 		{
 			LAssert(!"Can't add task twice.");
 			return false;
 		}
 		FolderTasks.Add(Ptr);
 		return true;
 	}
 	else
 	{
 		if (!FolderTasks.HasItem(Ptr))
 		{
 			LAssert(!"Item not part of task list.");
 			return false;
 		}
 		FolderTasks.Delete(Ptr);
 		return true;
 	}
 }
 
 LMailStore *ScribeWnd::GetDefaultMailStore()
 {
 	LMailStore *Def = 0;
 
 	for (unsigned i=0; i<Folders.Length(); i++)
 	{
 		if (Folders[i].IsOk())
 		{
 			if (Folders[i].Default || !Def)
 			{
 				Def = &Folders[i];
 			}
 			else if (Def)
 			{
 				if (Folders[i].Priority() > Def->Priority())
 				{
 					Def = &Folders[i];
 				}
 			}
 		}
 	}
 
 	return Def;
 }
 
 bool HasMailStore(LXmlTag *MailStores, char *Name)
 {
 	for (auto t : MailStores->Children)
 	{
 		char *StoreName = t->GetAttr(OPT_MailStoreName);
 		if (StoreName && Name && !_stricmp(StoreName, Name))
 			return true;
 	}
 	return false;
 }
 
 LDataStoreI *ScribeWnd::CreateDataStore(const char *_Full, bool CreateIfMissing)
 {
 	LString Full(_Full);
 	auto Ext = LGetExtension(Full);
 	if (Ext)
 	{
 		if (!_stricmp(Ext, "mail2"))
 		{
 			LgiMsg(this, LLoadString(IDS_MAIL2_DEPRECATED), AppName, MB_OK, Full.Get());
 		}
 		else if (!_stricmp(Ext, "mail3"))
 		{
 			return OpenMail3(Full, this, CreateIfMissing);
 		}
 		else if (!_stricmp(Ext, "sqlite"))
 		{
 			LTrimDir(Full);
 			return OpenMail3(Full, this, CreateIfMissing);
 		}
 		else
 		{
 			LgiTrace("%s:%i - Not a valid mail store extension: %s\n", _FL, Full.Get());
 			LAssert(!"Not a valid mail store extension.");
 		}
 	}
 	else LgiTrace("%s:%i - No extension for CreateDataStore: %s\n", _FL, Full.Get());
 
 	return NULL;
 }
 
 class MailStoreUpgrade :
 	public LProgressDlg,
 	public LDataPropI
 {
 public:
 	ScribeWnd *App = NULL;
 	LDataStoreI *Ds = NULL;
 	int Status = -1;
 	LString Error;
 
 	MailStoreUpgrade(ScribeWnd *app, LDataStoreI *ds) :
 		LProgressDlg(app, -1)
 	{
 		SetParent(App = app);
 		Ds = ds;
 		SetCanCancel(false);
 		SetDescription("Upgrading mail store...");
 		SetPulse(1000);
 
 		Ds->Upgrade(this, this, [this](auto status)
 		{
 			Status = status;
 		});
 	}
 
 	~MailStoreUpgrade()
 	{
 	}
 
 	void OnPulse() override
 	{
 		if (Status >= 0)
 		{
 			EndModal(0);
 			return;
 		}
 
 		return LProgressDlg::OnPulse();
 	}
 
 	LDataPropI &operator =(LDataPropI &p)
 	{
 		LAssert(0);
 		return *this;
 	}
 
 	Store3Status SetStr(int id, const char *str) override
 	{
 		switch (id)
 		{
 			case Store3UiError:
 				Error = str;
 				break;
 			default:
 				LAssert(!"Impl me.");
 				return Store3Error;
 				break;
 		}
 		
 		return Store3Success;
 	}
 };
 
 bool ScribeWnd::ProcessFolder(LDataStoreI *&Store, int StoreIdx, char *StoreName)
 {
 	if (Store->GetInt(FIELD_VERSION) == 0)
 	{
 		// version error
 		LgiMsg(this, LLoadString(IDS_ERROR_FOLDERS_VERSION), AppName, MB_OK, 0, Store->GetInt(FIELD_VERSION));
 		return false;
 	}
 
 	if (Store->GetInt(FIELD_READONLY))
 	{
 		LgiMsg(this, LLoadString(IDS_ERROR_READONLY_FOLDERS), AppName);
 	}
 
 	// get root item
 	LDataFolderI *Root = Store->GetRoot();
 	if (!Root)
 		return false;
 
 	ScribeFolder *&Mailbox = Folders[StoreIdx].Root;
 	Mailbox = new ScribeFolder;
 	if (Mailbox)
 	{
 		Mailbox->App = this;
 		Mailbox->SetObject(Root, false, _FL);
 
 		Root->SetStr(FIELD_FOLDER_NAME, StoreName);
 		Root->SetInt(FIELD_FOLDER_TYPE, MAGIC_NONE);
 	}
 
 	#ifdef TEST_OBJECT_SIZE
 	// debug/repair code
 	if (Root->StoreSize != Root->Sizeof())
 	{
 		SizeErrors[0]++;
 		Root->StoreSize = Root->Sizeof();
 		if (Root->Object)
 		{
 			Root->Object->StoreDirty = true;
 		}
 	}
 	#endif
 
 	// Insert the root object and then...
 	Tree->Insert(Mailbox);
 
 	// Recursively load the rest of the tree
 	{
 		// LProfile p("Loadfolders");
 		Mailbox->LoadFolders();
 	}
 				
 	// This forces a re-pour to re-order the folders according to their
 	// sort settings.
 	Tree->UpdateAllItems();
 
 	if (ScribeState != ScribeExiting)
 	{
 		// Show the tree
 		Mailbox->Expanded(Folders[StoreIdx].Expanded);
 
 		// Checks the folders for a number of required objects
 		// and creates them if required
 		auto StoreType = Store->GetInt(FIELD_STORE_TYPE);
 		if (StoreType == Store3Sqlite)
 			Validate(&Folders[StoreIdx]);
 		else if (StoreType < 0)
 			LAssert(!"Make sure you impl the FIELD_STORE_TYPE field in the store.");
 
 					
 		// FIXME
 		// AddFolderToMru(Full);
 	}
 
 	return true;
 }
 
 struct LoadMailStoreState : public LView::ViewEventTarget
 {
 	typedef std::function<void(bool)> BoolCb;
 	typedef std::function<void(int)>  IntCb;
 
 	ScribeWnd *App;
 	BoolCb Callback; // Final cb for entire LoadMailStoreState execution
 	LOptionsFile *Options = NULL;
 	LXmlTag *MailStores = NULL;
 	LArray<LXmlTag*> Que;
 	int StoreIdx = 0;
 	bool OptionsDirty = false;
 	bool Status = false;
 	std::function<bool(bool)> ReturnWithEvent;
 	std::function<bool(bool)> ReturnOnDialog;
 	std::function<void(const char *folderPath,const char *details,IntCb callback)> AskStoreUpgrade;
 
 	LoadMailStoreState(ScribeWnd *app, std::function<void(bool)> callback) :
 		ViewEventTarget(app, M_LOAD_NEXT_MAIL_STORE),
 		App(app),
 		Callback(callback)
 	{
 		Options = App->GetOptions();
 
 		ReturnWithEvent = [this](bool s)
 		{
 			PostEvent(M_LOAD_NEXT_MAIL_STORE);
 			return s;
 		};
 
 		ReturnOnDialog = [this](bool s)
 		{
 			return s;
 		};
 
 		AskStoreUpgrade = [this](auto FolderPath, auto Details, auto cb)
 		{
 			auto result = LgiMsg(App,
 								LLoadString(IDS_MAILSTORE_UPGRADE_Q),
 								AppName,
 								MB_YESNO,
 								FolderPath,
 								ValidStr(Details) ? Details : "n/a");
 			cb(result);
 		};
 
 		MailStores = Options->LockTag(OPT_MailStores, _FL);
 
 		// Load up some work in the queue and start the iteration...
 		if (MailStores)
 			Que = MailStores->Children;
 	}
 
 	void Start()
 	{
 		PostEvent(M_LOAD_NEXT_MAIL_STORE);
 	}
 
 	bool OnStatus(bool b)
 	{
 		if (MailStores)
 			Options->Unlock();
 
 		if (OptionsDirty)
 			App->SaveOptions();
 
 		if (Callback)
 			Callback(b);
 		
 		delete this;
 		
 		return b;
 	}
 
 	LMessage::Result OnEvent(LMessage *Msg) override
 	{
 		if (Msg->Msg() == M_LOAD_NEXT_MAIL_STORE)
 		{
 			if (!MailStores)
 				OnStatus(false);
 			else
 				Iterate();
 		}
 
 		return 0;
 	}
 
 	// This will process one item off the Que,
 	// Or if no work is available call PostIterate to 
 	// finish the process.
 	//
 	// In most cases this function should complete with
 	// ReturnWithEvent to trigger the next iteration...
 	bool Iterate()
 	{
 		// No more work, so do the completion step:
 		if (Que.Length() == 0)
 			return PostIterate();
 
 		// There are 2 exits modes for this function:
 		//
 		// 1) Normal exit where we should post a M_LOAD_NEXT_MAIL_STORE to ourselves to
 		// start the next iteration by calling ReturnWithEvent.
 		//
 		// 2) A dialog was launched and we should NOT post a M_LOAD_NEXT_MAIL_STORE event
 		// by calling ReturnOnDialog. The dialog's callback will do that later.
 
 		// Get the next Xml tag off the queue:
 		auto MailStore = Que[0];
 		Que.DeleteAt(0, true);
 
 		if (!MailStore->IsTag(OPT_MailStore))
 			return ReturnWithEvent(false);
 
 		// Read the folders..
 		auto Path       = MailStore->GetAttr(OPT_MailStoreLocation);
 		auto ContactUrl = MailStore->GetAttr(OPT_MailStoreContactUrl);
 		auto CalUrl     = MailStore->GetAttr(OPT_MailStoreCalendarUrl);
 		if (!Path && !ContactUrl && !CalUrl)
 		{
 			LgiTrace("%s:%i - No mail store path (%i).\n", _FL, StoreIdx);
 			return ReturnWithEvent(false);
 		}
 
 		// If disabled, skip:
 		if (MailStore->GetAsInt(OPT_MailStoreDisable) > 0)
 			return ReturnWithEvent(false);
 
 		// Check and validate the folder name:
 		auto StoreName = MailStore->GetAttr(OPT_MailStoreName);
 		if (!StoreName)
 		{
 			char Tmp[256];
 			for (int i=1; true; i++)
 			{
 				sprintf_s(Tmp, sizeof(Tmp), "Folders%i", i);
 				if (!HasMailStore(MailStores, Tmp))
 					break;
 			}
 
 			MailStore->SetAttr(OPT_MailStoreName, Tmp);
 			StoreName = MailStore->GetAttr(OPT_MailStoreName);
 			OptionsDirty = true;
 		}
 
 		// Build a LMailStore entry in App->Folders:
 		auto &Folder = App->Folders[StoreIdx];
 		Folder.Name = StoreName;
 
 		if (Path)
 		{
 			// Mail3 folders on disk...
 			LFile::Path p;
 			if (LIsRelativePath(Path))
 			{
 				p = Options->GetFile();
 				p--;
 				p += Path;
 			}
 			else p = Path;
 			auto Full = p.GetFull();
 
 			LVariant CreateFoldersIfMissing;
 			Options->GetValue(OPT_CreateFoldersIfMissing, CreateFoldersIfMissing);
 
 			// Sniff type...
 			auto Ext = LGetExtension(Full);
 			if (!Ext)
 				return ReturnWithEvent(false);
 
 			if (!Folder.Store)
 				Folder.Store = App->CreateDataStore(Full, CreateFoldersIfMissing.CastInt32() != 0);
 			if (!Folder.Store)
 			{
 				LgiTrace("%s:%i - Failed to create data store for '%s'\n", _FL, Full.Get());
 				return ReturnWithEvent(false);
 			}
 
 			Folder.Path = Full;
 		}
 		else if (ContactUrl || CalUrl)
 		{
 			// Remove Webdav folders...
 			Folder.Store = new WebdavStore(App, App, StoreName);
 		}
 		else
 		{
 			return ReturnWithEvent(false);
 		}
 
 		LDataStoreI *&Store = Folder.Store;
 		auto ex = MailStore->GetAsInt(OPT_MailStoreExpanded);
 		if (ex >= 0)
 			Folder.Expanded = ex != 0;
 		
 		// Check if the mail store requires upgrading...
 		auto MsState = (Store3Status)Store->GetInt(FIELD_STATUS);
 		if (MsState == Store3UpgradeRequired)
 		{
 			LgiTrace("%s:%i - this=%p\n", _FL, this);
 			auto Details = Store->GetStr(FIELD_STATUS);
 			AskStoreUpgrade(Folder.Path.Get(),
 							ValidStr(Details) ? Details : "n/a",
 							[this, Store, MailStore](auto result)
 							{
 								if (result == IDYES)
 								{
 									auto Prog = new MailStoreUpgrade(App, Store);
 									Prog->DoModal([this, MailStore](auto dlg, auto code)
 									{
 										// Upgrade complete, finish the iteration..
 										Iterate2(MailStore);
 
 										delete dlg;
 									});
 									return;
 								}
 
 								// Upgrade not allowed, so do next iteration...			
 								ReturnWithEvent(false);
 							});
 
 			return ReturnOnDialog(true);
 		}
 		else if (MsState == Store3Error)
 		{
 			auto ErrMsg = Store->GetStr(FIELD_ERROR);
 			auto a = new LAlert(App,
 								AppName, ErrMsg ? ErrMsg : LLoadString(IDS_ERROR_FOLDERS_STATUS),
 								LLoadString(IDS_EDIT_MAIL_STORES),
 								LLoadString(IDS_OK));			
 			a->DoModal([this](auto dlg, auto code)
 			{
 				delete dlg;
 
 				if (code == 1)
 				{
 					App->PostEvent(M_COMMAND, IDM_MANAGE_MAIL_STORES);
 					
 					// This fails the whole LoadMailStores process, because the user
 					// is going to edit the mail store list via the dialog;
 					OnStatus(false);
 				}
 				else
 				{
 					// We can't load this mail store, so do the next iteration...
 					ReturnWithEvent(true);
 				}
 			});
 
 			return ReturnOnDialog(false);
 		}
 
 		// No upgrade or error, just keep going.
 		return Iterate2(MailStore);
 	}
 
 	// This also should complete by calling ReturnWithEvent/ReturnOnDialog.
 	bool Iterate2(LXmlTag *MailStore)
 	{
 		auto &Folder = App->Folders[StoreIdx];
 		auto StoreName = MailStore->GetAttr(OPT_MailStoreName);
 
 		// check password
 		LString FolderPsw;
 		if ((FolderPsw = Folder.Store->GetStr(FIELD_STORE_PASSWORD)))
 		{
 			bool Verified = false;
 
 			if (ValidStr(App->d->MulPassword))
 			{
 				Verified = App->d->MulPassword.Equals(FolderPsw, false);
 				App->d->MulPassword.Empty();
 			}
 
 			if (!Verified)
 			{
 				auto Dlg = new LInput(App, "", LLoadString(IDS_ASK_FOLDER_PASS), AppName, true);
 				Dlg->DoModal([this, Dlg, FolderPsw, StoreName](auto dlg, auto id)
 				{
 					auto psw = Dlg->GetStr();
 					delete dlg;
 
 					if (id == IDOK)
 					{
 						auto &Folder = App->Folders[StoreIdx];
 						if (psw == FolderPsw)
 						{
 							Status |= App->ProcessFolder(Folder.Store, StoreIdx, StoreName);
 						}
 						else
 						{
 							// Clear the folder and don't increment the StoreIdx...
 							Folder.Empty();
 							App->Folders.PopLast();
 							ReturnWithEvent(false);
 							return;
 						}
 					}
 
 					Iterate3();
 				});
 
 				return ReturnOnDialog(true);
 			}
 		}
 		else
 		{
 			Status |= App->ProcessFolder(Folder.Store, StoreIdx, StoreName);
 		}
 
 		return Iterate3();
 	}
 
 	bool Iterate3()
 	{
 		StoreIdx++;
 		return ReturnWithEvent(true);
 	}
 
 	bool PostIterate()
 	{
 		if (Status)
 		{
 			// Force load some folders...
 			ScribeFolder *Folder = App->GetFolder(FOLDER_CALENDAR);
 			if (Folder)
 				Folder->LoadThings();
 			Folder = App->GetFolder(FOLDER_FILTERS);
 			if (Folder)
 				Folder->LoadThings();
 			for (auto ms: App->Folders)
 			{
 				if (!ms.Root)
 					continue;
 				for (auto c = ms.Root->GetChildFolder(); c; c = c->GetNextFolder())
 				{
 					if (c->GetItemType() == MAGIC_CONTACT ||
 						c->GetItemType() == MAGIC_FILTER)
 						c->LoadThings();
 				}
 			}
 
 			List<Contact> c;
 			App->GetContacts(c);
 
 			// Set selected folder to Inbox by default
 			// if the user hasn't selected a folder already
 			if (App->ScribeState != ScribeWnd::ScribeExiting && App->Tree && !App->Tree->Selection())
 			{
 				LVariant StartInFolder;
 				Options->GetValue(OPT_StartInFolder, StartInFolder);
 
 				ScribeFolder *Start = NULL;
 				if (ValidStr(StartInFolder.Str()))
 				{
 					Start = App->GetFolder(StartInFolder.Str());
 				}
 				if (!Start)
 				{
 					Start = App->GetFolder(FOLDER_INBOX);
 				}
 				if (Start && App->Tree)
 				{
 					App->Tree->Select(Start);
 				}
 			}
 		}
 
 		Options->DeleteValue(OPT_CreateFoldersIfMissing);
 
 		// Set system folders
 		ScribeFolder *f = App->GetFolder(FOLDER_INBOX);
 		if (f) f->SetSystemFolderType(Store3SystemInbox);
 		f = App->GetFolder(FOLDER_OUTBOX);
 		if (f) f->SetSystemFolderType(Store3SystemOutbox);
 		f = App->GetFolder(FOLDER_SENT);
 		if (f) f->SetSystemFolderType(Store3SystemSent);
 		f = App->GetFolder(FOLDER_SPAM);
 		if (f) f->SetSystemFolderType(Store3SystemSpam);
 
 		return OnStatus(Status);
 	}
 };
 
 void ScribeWnd::LoadMailStores(std::function<void(bool)> Callback)
 {
 	if (auto s = new LoadMailStoreState(this, Callback))
 		s->Start();
 }
 
 void ScribeWnd::LoadFolders(std::function<void(bool)> Callback)
 {
 	AppState PrevState = ScribeState;
 	ScribeState = ScribeLoadingFolders;
 
 	// Setup Mailstores tag
 	{
 		LXmlTag *MailStores = GetOptions()->LockTag(OPT_MailStores, _FL);
 		if (!MailStores)
 		{
 			// Check if we can upgrade the old folder tag
 			char n[32];
 			sprintf_s(n, sizeof(n), "%s-Folders", LGetOsName());
 			LVariant OldFolders;
 			GetOptions()->GetValue(n, OldFolders);
 
 			// Create mail store element..
 			GetOptions()->CreateTag(OPT_MailStores);
 			if ((MailStores = GetOptions()->LockTag(OPT_MailStores, _FL)))
 			{
 				if (OldFolders.Str())
 				{
 					LXmlTag *Store = MailStores->CreateTag(OPT_MailStore);
 					if (Store)
 					{
 						char Opts[MAX_PATH_LEN];
 						LMakePath(Opts, sizeof(Opts), GetOptions()->GetFile(), "..");
 						auto Rel = LMakeRelativePath(Opts, OldFolders.Str());
 
 						Store->SetAttr(OPT_MailStoreLocation, Rel ? Rel.Get() : OldFolders.Str());
 
 						// No need to ask the user for a store name, it'll be
 						// asked later in this method anyway...
 
 						// Leave the old folder tag in the xml in case the user
 						// downgrades to v1.xx
 					}
 				}
 			}
 		}
 
 		GetOptions()->Unlock();
 		if (!MailStores)
 		{
 			if (Callback)
 				Callback(false);
 			return;
 		}
 	}
 
 	// Set loading flags
 	CmdSend.Enabled(false);
 	CmdReceive.Enabled(false);
 	CmdPreview.Enabled(false);
 
 	LoadMailStores([this, PrevState, Callback](auto Status)
 	{
 		if (Tree)
 		{
 			for (auto a: Accounts)
 			{
 				if (!a->Receive.Disabled() && a->Receive.IsPersistant())
 					a->Receive.Connect(0, false);
 			}
 		}
 
 		using BoolFn = std::function<void(bool)>;
 		auto FinishLoad = new BoolFn
 		(
 			[this, PrevState, Callback](bool Status)
 			{
 				if (ScribeState == ScribeExiting)
 				{
 					LCloseApp();
 				}
 				else
 				{
 					d->FoldersLoaded = true;
 					PostEvent(M_SCRIBE_LOADED);
 				}
 
 				if (ScribeState == ScribeExiting)
 					LCloseApp();
 				ScribeState = PrevState;
 
 				if (Callback)
 					Callback(Status);
 			}
 		);
 
 		if (Folders.Length() == 0)
 		{
 			auto Dlg = new ScribeFolderDlg(this);
 			Dlg->DoModal([this, Dlg, FinishLoad, Callback, &Status](auto dlg, auto id)
 			{
 				if (id == IDOK)
 				{
 					bool CreateMailStore = false;
 
 					if (Dlg->Create)
 					{
 						// create folders
 						if (LFileExists(Dlg->FolderFile))
 						{
 							if (LgiMsg(this, LLoadString(IDS_ERROR_FOLDERS_ALREADY_EXIST), AppName, MB_YESNO) == IDYES)
 								CreateMailStore = true;
 							else
 								LgiMsg(this, LLoadString(IDS_ERROR_WONT_OVERWRITE_FOLDERS), AppName);
 						}
 						else if ((Status = CreateFolders(Dlg->FolderFile)))
 							CreateMailStore = true;
 					}
 					else
 						CreateMailStore = true;
 
 					if (CreateMailStore)
 					{
 						LXmlTag *MailStores = GetOptions()->LockTag(OPT_MailStores, _FL);
 						if (MailStores)
 						{
 							LXmlTag *Store = MailStores->CreateTag(OPT_MailStore);
 							if (Store)
 							{
 								char p[MAX_PATH_LEN];
 								LMakePath(p, sizeof(p), GetOptions()->GetFile(), "..");
 								auto RelPath = LMakeRelativePath(p, Dlg->FolderFile);
 								Store->SetAttr(OPT_MailStoreLocation, RelPath ? RelPath.Get() : Dlg->FolderFile.Get());
 							}
 							GetOptions()->Unlock();
 
 							LoadMailStores(NULL);
 						}
 					}
 				}
 
 				if (id)
 					(*FinishLoad)(Status);
 				else if (Callback)
 					Callback(false);
 				delete FinishLoad;
 				delete dlg;
 			});
 		}
 		else
 		{
 			(*FinishLoad)(Status);
 			delete FinishLoad;
 		}
 	});
 }
 
 bool ScribeWnd::UnLoadFolders()
 {
 	if (FolderTasks.Length() > 0 ||
 		ScribeState == ScribeLoadingFolders)
 	{
 		// Um, we can't unload folders right now 
 		// something is already happening...
 		return false;
 	}
 
 	AppState PrevState = ScribeState;
 	ScribeState = ScribeUnloadingFolders;
 
 	OnSelect();
 
 	if (MailList)
 	{
 		ScribeFolder *Container = MailList->GetContainer();
 		if (Container)
 		{
 			// save folder settings
 			Container->SerializeFieldWidths();
 		}
 
 		MailList->SetContainer(NULL);
 		MailList->RemoveAll();
 	}
 
 	int Error = 0;
 	while (Thing::DirtyThings.Length() > 0)
 	{
 		if (!SaveDirtyObjects())
 		{	
 			Error++;
 			LgiTrace("%s:%i - SaveDirtyObjects failed.\n", _FL);
 
 			if (Error > 100)
 			{
 				// I think we're stuck...
 				return false;
 			}
 		}
 	}
 
 	// Unload IMAP folders...
 	for (auto a: Accounts)
 	{
 		if (!a->Receive.Disabled() &&
 			a->Receive.IsPersistant())
 		{
 			a->Receive.Disconnect();
 		}
 	}
 
 	if (GetOptions())
 	{
 		// Unload local folders...
 		LXmlTag *MailStores = GetOptions()->LockTag(OPT_MailStores, _FL);
 
 		for (size_t i=0; i<Folders.Length(); i++)
 		{
 			// Save the expanded state...
 			if (Folders[i].Root)
 			{
 				bool Expanded = Folders[i].Root->Expanded();
 
 				for (auto ms: MailStores->Children)
 				{
 					char *StoreName = ms->GetAttr(OPT_MailStoreName);
 					if (Folders[i].Name.Equals(StoreName))
 					{
 						ms->SetAttr(OPT_MailStoreExpanded, Expanded);
 						break;
 					}
 				}
 			}
 
 			DeleteObj(Folders[i].Root);
 			DeleteObj(Folders[i].Store);
 		}
 
 		if (MailStores)
 		{
 			GetOptions()->Unlock();
 			MailStores = NULL;
 		}
 	}
 
 	Folders.Length(0);
 	d->FoldersLoaded = false;
 
 	if (ScribeState == ScribeExiting)
 		LCloseApp();
 	ScribeState = PrevState;
 
 	return true;
 }
 
 void ScribeWnd::BuildDynMenus()
 {
 	if (MailMenu)
 	{
 		LString SendMail = LLoadString(IDS_SEND_MAIL);
 		LString ReceiveMail = LLoadString(IDS_RECEIVE_MAIL);
 		LString PreviewMail = LLoadString(IDS_PREVIEW_ON_SERVER);
 		auto ReceiveAll = LLoadString(IDS_RECEIVE_ALL_ACCOUNTS);
 
 		if (!CmdReceive.MenuItem && ReceiveAll)
 			CmdReceive.MenuItem = MailMenu->AppendItem(ReceiveAll, IDM_RECEIVE_ALL, true);
 
 		if (!SendMenu && SendMail)
 		{
 			auto s = SendMail.SplitDelimit("\t");
 			SendMenu = MailMenu->AppendSub(s[0]);
 		}
 
 		if (!ReceiveMenu && ReceiveMail)
 		{
 			auto s = ReceiveMail.SplitDelimit("\t");
 			ReceiveMenu = MailMenu->AppendSub(s[0]);
 		}
 
 		if (!PreviewMenu && PreviewMail)
 		{
 			auto s = PreviewMail.SplitDelimit("\t");
 			PreviewMenu = MailMenu->AppendSub(s[0]);
 		}
 	}
 
 	if (!NewTemplateMenu)
 	{
 		auto i = Menu->FindItem(IDM_NO_TEMPLATES);
 		if (i)
 		{
 			NewTemplateMenu = i->GetParent();
 		}
 	}
 	if (NewTemplateMenu)
 	{
 		NewTemplateMenu->Empty();
 
 		int d = 0;
 		ScribeFolder *Templates = GetFolder(FOLDER_TEMPLATES, NULL, true);
 		if (Templates)
 		{
 			Templates->LoadThings();
 
 			for (auto i: Templates->Items)
 			{
 				Mail *m = i->IsMail();
 				if (m)
 				{
 					NewTemplateMenu->AppendItem(m->GetSubject()
 													?
 													m->GetSubject()
 													:
 													(char*)"(no subject)",
 												IDM_NEW_FROM_TEMPLATE + d,
 												true);
 					d++;
 				}
 			}
 
 			if (d == 0)
 			{
 				NewTemplateMenu->AppendItem(LLoadString(IDS_NO_ITEMS_IN_FOLDER), -1, false);
 			}
 		}
 		else
 		{
 			NewTemplateMenu->AppendItem(LLoadString(IDS_NO_TEMPLATES), -1, false);
 		}
 	}
 }
 
 int ScribeWnd::GetToolbarHeight()
 {
 	return (Commands) ? MAX(Commands->Y()-1, 20) : 20;
 }
 
 LToolBar *ScribeWnd::LoadToolbar(LViewI *Parent, const char *File, LAutoPtr<LImageList> &Img)
 {
 	if (!Img)
 		Img.Reset(LLoadImageList(File));
 	if (!Img)
 	{
 		LAssert(!"Missing image resource.");
 		return NULL;
 	}
 
 	LToolBar *Tools = NULL;
 	if (Img)
 	{
 		Tools = new LToolBar;
 		if (Tools)
 			Tools->SetImageList(Img, Img->TileX(), Img->TileY(), false);
 	}
 	else
 	{
 		Tools = LgiLoadToolbar(Parent, File);
 	}
 
 	if (Tools)
 	{
 		LVariant SizeAdj;
 		LFont *f = Tools->GetFont();
 		if (f)
 		{
 			if (GetOptions()->GetValue(OPT_UiFontSize, SizeAdj))
 			{
 				SizeAdj.Cast(GV_INT32);
 				SizeAdj.Value.Int -= 2;
 				f->PointSize(f->PointSize()+SizeAdj.Value.Int);
 			}
 		}
 
 		Tools->GetCss(true)->BorderSpacing(LCss::Len(LCss::LenPx, SCRIBE_TOOLBAR_BORDER_SPACING_PX));
 		Tools->TextLabels(ShowToolbarText());
 	}
 
 	return Tools;
 }
 
 void ScribeWnd::SetListPane(LView *v)
 {
 	ThingList *ThingLst = dynamic_cast<ThingList*>(v);
 	DynamicHtml *Html = dynamic_cast<DynamicHtml*>(v);
 	if (!ThingLst)
 	{
 		DeleteObj(SearchView);
 		if (MailList)
 			MailList->RemoveAll();
 	}
 
 	v->Sunken(SUNKEN_CTRL);
 	if ((MailList = ThingLst))
 	{
 		DeleteObj(TitlePage);
 		if (GetCtrlValue(IDM_ITEM_FILTER))
 		{
 			OnCommand(IDM_ITEM_FILTER, 0, NULL);
 		}
 	}
 	else
 	{
 		TitlePage = Html;
 	}
 	
 	SetLayout();
 }
 
 bool ScribeWnd::SetItemPreview(LView *v)
 {
 	v->Sunken(SUNKEN_CTRL);
 	if (d->SubSplit->IsAttached())
 	{
 		if (d->LastLayout == 2)
 		{
 			Splitter->SetViewAt(1, v);
 		}
 		else
 		{
 			d->SubSplit->SetViewAt(1, v);
 		}
 
 		return true;
 	}
 
 	return false;
 }
 
 ScribeWnd::LayoutMode ScribeWnd::GetEffectiveLayoutMode()
 {
 	LVariant Mode;
 	GetOptions()->GetValue(OPT_LayoutMode, Mode);
 	ScribeFolder *Cur = GetCurrentFolder();
 	
 	if (Cur && Cur->IsRoot())
 	{
 		Mode = FoldersAndList;
 	}
 
 	if (Mode.CastInt32() == 0)
 	{
 		Mode = FoldersListAndPreview;
 	}	
 	
 	return (LayoutMode) Mode.CastInt32();
 }
 
 void ScribeWnd::SetLayout(LayoutMode Mode)
 {
 	// int TreeWidth = Tree ? Tree->X() : 200;
 	// int PreviewHt = PreviewPanel ? PreviewPanel->Y() : 200;
 
 	if (Mode > 0)
 	{
 		LVariant v;
 		GetOptions()->SetValue(OPT_LayoutMode, v = (int)Mode);
 	}
 
 	Mode = GetEffectiveLayoutMode();
 
 	if (!Splitter)
 		return;
 
 	bool JustPreviewPane =	(Mode == FoldersAndList && d->LastLayout == FoldersListAndPreview) ||
 							(Mode == FoldersListAndPreview && d->LastLayout == FoldersAndList);
 
 	LView *Content = NULL;
 	if (TitlePage)
 		Content = TitlePage;
 	else if (MailList)
 		Content = MailList;
 
 	if (JustPreviewPane)
 	{
 		// Optimized path for hide/show the preview pane that doesn't destroy the tree
 		// control and cause it to lose focus... otherwise we can't set it's focus due
 		// to some weird windows interaction.
 		switch (Mode)
 		{
 			default:
 			case FoldersListAndPreview:
 			{
 				if (Content)
 					Content->Sunken(SUNKEN_CTRL);
 				if (PreviewPanel)
 					PreviewPanel->Sunken(SUNKEN_CTRL);
 
 				Splitter->SetViewAt(1, d->SubSplit);
 				d->SubSplit->SetVertical(true);
 				
 				int Idx = 0;
 				if (SearchView)
 					d->SubSplit->SetViewAt(Idx++, SearchView);				
 				d->SubSplit->SetViewAt(Idx++, Content);
 				d->SubSplit->SetViewAt(Idx++, PreviewPanel);
 				break;
 			}
 			case FoldersAndList:
 			{
 				if (Content)
 					Content->Sunken(SUNKEN_CTRL);
 				
 				if (SearchView)
 				{
 					#if LGI_VIEW_HANDLE
 					if (!d->SubSplit->Handle())
 						Splitter->SetViewAt(1, d->SubSplit);
 					#endif
 					d->SubSplit->SetVertical(true);
 					Splitter->SetViewAt(1, d->SubSplit);
 
 					int Idx = 0;
 					if (SearchView)
 						d->SubSplit->SetViewAt(Idx++, SearchView);				
 					d->SubSplit->SetViewAt(Idx++, Content);
 				}
 				else
 				{
 					d->SubSplit->Detach();
 					Splitter->SetViewAt(1, Content);
 				}
 				break;
 			}
 		}
 	}
 	else
 	{		
 		if (Tree)
 			Tree->Sunken(SUNKEN_CTRL);
 		if (Content)
 			Content->Sunken(SUNKEN_CTRL);
 		if (PreviewPanel)
 			PreviewPanel->Sunken(SUNKEN_CTRL);
 		switch (Mode)
 		{
 			default:
 			case FoldersListAndPreview:
 			{
 				Splitter->SetVertical(false);
 				d->SubSplit->SetVertical(true);
 				Splitter->SetViewAt(0, Tree);
 				Splitter->SetViewAt(1, d->SubSplit);
 
 				int Idx = 0;
 				if (SearchView)
 					d->SubSplit->SetViewAt(Idx++, SearchView);
 				d->SubSplit->SetViewAt(Idx++, Content);
 				d->SubSplit->SetViewAt(Idx++, PreviewPanel);
 
 				DeleteObj(d->SearchSplit);
 				break;
 			}
 			case PreviewOnBottom:
 			{
 				Splitter->SetVertical(true);
 				d->SubSplit->SetVertical(false);
 				Splitter->SetViewAt(0, d->SubSplit);
 				Splitter->SetViewAt(1, PreviewPanel);
 
 				d->SubSplit->SetViewAt(0, Tree);
 				if (SearchView)
 				{
 					if (!d->SearchSplit)
 						d->SearchSplit = new LBox;
 					d->SubSplit->SetViewAt(1, d->SearchSplit);
 					d->SearchSplit->SetVertical(true);
 					d->SearchSplit->SetViewAt(0, SearchView);
 					d->SearchSplit->SetViewAt(1, Content);
 				}
 				else
 				{
 					d->SubSplit->SetViewAt(1, Content);
 					DeleteObj(d->SearchSplit);
 				}
 				break;
 			}
 			case FoldersAndList:
 			{
 				Splitter->SetVertical(false);
 				Splitter->SetViewAt(0, Tree);
 				
 				if (SearchView)
 				{
 					d->SubSplit->SetVertical(true);
 					Splitter->SetViewAt(1, d->SubSplit);
 					d->SubSplit->SetViewAt(0, SearchView);
 					d->SubSplit->SetViewAt(1, Content);
 				}
 				else
 				{
 					d->SubSplit->Detach();
 					Splitter->SetViewAt(1, Content);
 				}
 				DeleteObj(d->SearchSplit);
 				break;
 			}
 			case ThreeColumn:
 			{
 				Splitter->SetVertical(false);
 				Splitter->SetViewAt(0, Tree);
 				
 				if (SearchView)
 				{
 					d->SubSplit->SetVertical(true);
 					Splitter->SetViewAt(1, d->SubSplit);
 					d->SubSplit->SetViewAt(0, SearchView);
 					d->SubSplit->SetViewAt(1, Content);
 				}
 				else
 				{
 					d->SubSplit->Detach();
 					Splitter->SetViewAt(1, Content);
 				}
 				
 				Splitter->SetViewAt(2, PreviewPanel);
 				DeleteObj(d->SearchSplit);
 				break;
 			}
 		}
 	}
 
 	if (!SearchView)
 	{
 		LVariant Pos = 200;
 		GetOptions()->GetValue(OPT_SplitterPos, Pos);
 		if (Pos.CastInt32() < 10)
 			Pos = 200;
 		Splitter->Value(Pos.CastInt32());
 
 		LRect r = Splitter->GetPos();
 		r.x2++;
 		Splitter->SetPos(r);
 
 		if (d->SubSplit->IsAttached())
 		{
 			Pos = 200;
 			GetOptions()->GetValue(OPT_SubSplitPos, Pos);
 			if (Pos.CastInt32() < 10)
 				Pos = 200;
 			d->SubSplit->Value(Pos.CastInt32());
 		}
 	}
 	
 	PourAll();
 	#ifdef LINUX
 	LYield();
 	#endif
 
 	d->LastLayout = Mode;
 }
 
 void ScribeWnd::SetupUi()
 {
 	// Show the window
 	if (!SerializeState(GetOptions(), OPT_ScribeWndPos, true))
 	{
 		LRect r(0, 0, 1023, 767);
 		SetPos(r);
 		MoveToCenter();
 	}
 
 	Visible(true);
 
 	// Main toolbar
 	Commands = LoadToolbar(this, GetResourceFile(ResToolbarFile), ToolbarImgs);
 	if (Commands)
 	{
 		Commands->Attach(this);
 		#ifdef MAC
 		Commands->Raised(false);
 		#else
 		Commands->Raised(RAISED_LOOK);
 		#endif
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_NEW_EMAIL)), IDM_NEW_EMAIL, TBT_PUSH, true, IMG_NEW_MAIL);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_NEW_CONTACT)), IDM_NEW_CONTACT, TBT_PUSH, true, IMG_NEW_CONTACT);
 		Commands->AppendSeparator();
 
 		CmdSend.ToolButton = Commands->AppendButton(RemoveAmp(LLoadString(IDS_SEND)), IDM_SEND_MAIL, TBT_PUSH, true, IMG_SEND);
 		Commands->AppendButton("+", IDM_RECEIVE_AND_SEND, TBT_PUSH, true, -2);
 		CmdReceive.ToolButton = Commands->AppendButton(RemoveAmp(LLoadString(IDS_RECEIVE)), IDM_RECEIVE_MAIL, TBT_PUSH, true, IMG_RECEIVE);
 		CmdPreview.ToolButton = Commands->AppendButton(RemoveAmp(LLoadString(IDS_PREVIEW)), IDM_PREVIEW_POP3, TBT_PUSH, true, IMG_PREVIEW);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_DELETE)), IDM_DELETE, TBT_PUSH, true, IMG_TRASH);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_SPAM)), IDM_DELETE_AS_SPAM, TBT_PUSH, true, IMG_DELETE_SPAM);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_REPLY)), IDM_REPLY, TBT_PUSH, true, IMG_REPLY);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_REPLYALL)), IDM_REPLY_ALL, TBT_PUSH, true, IMG_REPLY_ALL);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_FORWARD)), IDM_FORWARD, TBT_PUSH, true, IMG_FORWARD);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_BOUNCE)), IDM_BOUNCE, TBT_PUSH, true, IMG_BOUNCE);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_PRINT)), IDM_PRINT, TBT_PUSH, true, IMG_PRINT);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_CALENDAR)), IDM_CALENDAR, TBT_PUSH, true, IMG_CALENDAR);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_ITEM_FILTER)), IDM_ITEM_FILTER, TBT_TOGGLE, true, IMG_SEARCH);
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_THREAD)), IDM_THREAD, TBT_TOGGLE, true, IMG_THREADS);
 		d->ShowConsoleBtn = Commands->AppendButton(RemoveAmp(LLoadString(IDS_SHOW_CONSOLE)), IDM_SHOW_CONSOLE, TBT_PUSH, true, IMG_CONSOLE_NOMSG);
 		Commands->AppendSeparator();
 
 		Commands->AppendButton(RemoveAmp(LLoadString(IDS_HELP)), IDM_HELP, TBT_PUSH, true, IMG_HELP);
 
 		Commands->Customizable(GetOptions(), OPT_ScribeWndToolbar);
 		if (d->ScriptToolbar.Reset(new LScriptUi(Commands)))
 			d->ScriptToolbar->SetupCallbacks(this, 0, 0, LApplicationToolbar);
 		PourAll();
 	}
 
 	CmdSend.Enabled(false);
 	CmdReceive.Enabled(false);
 
 	// Preview and status windows
 	PreviewPanel = new LPreviewPanel(this);
 	StatusPanel = new AccountStatusPanel(this, ImageList);
 	if (PreviewPanel &&
 		StatusPanel)
 	{
 		#ifdef MAC
 		StatusPanel->Raised(false);
 		#else
 		StatusPanel->Raised(RAISED_LOOK);
 		#endif
 		StatusPanel->Attach(this);
 
 		PourAll();
 	}
 
 	// Splitter window, for folders and item list
 	Tree = new MailTree(this);
 	if (ImageList)
 	{
 		Tree->AskImage(true);
 		Tree->SetImageList(ImageList, false);
 	}
 
 	d->SubSplit = new LBox;
 	
 	Splitter = new LBox;
 	if (Splitter)
 	{
 		Splitter->Attach(this);
 		#ifdef MAC
 		Splitter->Raised(false);
 		#else
 		Splitter->Raised(RAISED_LOOK);
 		#endif
 
 		SetLayout();
 	}
 
 
 	#if WINNATIVE
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_SMALL));
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_ERR));
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_MAIL));
 	TrayIcon.Load(MAKEINTRESOURCE(IDI_BLANK));
 	#else
 	TrayIcon.Load(_T("tray_small.png"));
 	TrayIcon.Load(_T("tray_error.png"));
 	TrayIcon.Load(_T("tray_mail.png"));
 	#endif
 	
 	LStringPipe s(256);
 	LVariant UserName;
 	
 	s.Print("%s", AppName);
 	if (GetOptions()->GetValue(OPT_UserName, UserName))
 	{
 		s.Print(" [%s]", UserName.Str());
 	}
 	auto AppTitle = s.NewLStr();
 	TrayIcon.Name(AppTitle);
 	Name(AppTitle);
 
 	TrayIcon.Value(TRAY_ICON_NORMAL);
 	TrayIcon.Visible(true);
 
 	auto Item = Menu->FindItem(IDM_SCRIPTING_CONSOLE);
 	if (Item)
 	{
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_ShowScriptConsole, v))
 		{
 			Item->Checked(v.CastInt32() != 0);
 			LScribeScript::Inst->ShowScriptingWindow(Item->Checked());
 		}
 	}
 
 	if (Tree)
 	{
 		Tree->Focus(true);
 	}
 }
 
 Thing *ScribeWnd::CreateItem(int Type, ScribeFolder *Folder, bool Ui)
 {
 	auto FolderStore = Folder && Folder->GetObject() ? Folder->GetObject()->GetStore() : NULL;
 	auto DefaultStore = GetDefaultMailStore();
 	auto Store = FolderStore ? FolderStore : (DefaultStore ? DefaultStore->Store : NULL);
 	if (!Store)
 	{
 		LAssert(!"no store");
 		LgiTrace("%s:%i - No store for creating calendar object.\n", _FL);
 		return NULL;
 	}
 
 	auto Obj = Store->Create(Type);
 	if (!Obj)
 	{
 		LAssert(!"create failed");
 		LgiTrace("%s:%i - store failed to create object.\n", _FL);
 		return NULL;
 	}
 
 	#define HANDLE_CREATE_ITEM(Magic, Type)					\
 		case Magic:											\
 		{													\
 			auto o = new Type(this, Obj);					\
 			if (!o)											\
 			{												\
 				LgiTrace("%s:%i - Alloc failed.\n", _FL);	\
 				break;										\
 			}												\
 			if (Folder) o->SetParentFolder(Folder);			\
 			if (Ui) o->DoUI();								\
 			return o;										\
 		}
 
 
 	switch ((uint32_t)Type)
 	{
 		case MAGIC_MAIL:
 		{
 			// create a new mail message
 			Mail *m = new Mail(this, Obj);
 			if (!m)
 			{
 				LgiTrace("%s:%i - Alloc failed.\n", _FL);
 				break;
 			}
 
 			if (!m->GetObject())
 			{
 				m->DecRef();
 				return 0;
 			}
 
 			m->OnCreate();
 
 			if (Folder)
 				m->SetParentFolder(Folder);
 
 			if (Ui)
 				m->DoUI();
 
 			return m;
 		}
 		HANDLE_CREATE_ITEM(MAGIC_CONTACT, Contact)
 		HANDLE_CREATE_ITEM(MAGIC_CALENDAR, Calendar)
 		HANDLE_CREATE_ITEM(MAGIC_FILTER, Filter)
 		HANDLE_CREATE_ITEM(MAGIC_GROUP, ContactGroup)
 		default:
 			LAssert(!"Unhandled object type.");
 			break;
 	}
 
 	return NULL;
 }
 
 void ScribeWnd::OnPaint(LSurface *pDC)
 {
 	#if 0
 	pDC->Colour(LColour::Red);
 	pDC->Rectangle();
 	#else
 	LCssTools Tools(this);
 	auto c = GetClient();
 	// c.Offset(0, -26);
 	Tools.PaintContent(pDC, c);
 	#endif
 }
 
 int CompareContacts(Contact **a, Contact **b)
 {
 	if (a && b)
 	{
 		auto A = (*a)->GetFirst();
 		auto B = (*b)->GetFirst();
 		if (A && B)
 			return _stricmp(A, B);
 	}
 
 	return 0;
 }
 
 bool ScribeWnd::OpenAMail(ScribeFolder *Folder)
 {
 	if (Folder &&
 		Tree)
 	{
 		Folder->LoadThings();
 
 		for (auto i: Folder->Items)
 		{
 			Mail *m = i->IsMail();
 			if (m && !(m->GetFlags() & MAIL_READ))
 			{
 				Tree->Select(Folder);
 				m->DoUI();
 				return true;
 			}
 		}
 
 		for (auto *t=Folder->GetChild(); t; t=t->GetNext())
 		{
 			ScribeFolder *f = dynamic_cast<ScribeFolder*>(t);
 			if (OpenAMail(f))
 			{
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 void AddContactToMenu(LSubMenu *Menu, Contact *c, ssize_t Index)
 {
 	if (!c || Index < 0)
 		return;
 
 	auto Email = c->GetEmail();
 	if (!Email)
 		return;
 
 	// has an email, list it
 	auto First = c->GetFirst();
 	auto Last = c->GetLast();
 	if (First || Last)
 	{
 		char Buf[256];
 		sprintf_s(Buf, sizeof(Buf), "%s %s", (First)?First:"", (Last)?Last:"");
 		auto Item = Menu->AppendItem(Buf, TRAY_CONTACT_BASE + (int)Index, true);
 		if (Item) Item->Icon(ICON_CONTACT);
 	}
 }
 
 void ScribeWnd::AddContactsToMenu(LSubMenu *Menu)
 {
 	if (!Menu)
 		return;
 
 	d->TrayMenuContacts.Sort(CompareContacts);
 	if (((ssize_t)d->TrayMenuContacts.Length() << 4) > GdcD->Y() - 200)
 	{
 		// Group contacts by starting letter
 		LArray<Contact*> Alpha[26];
 		LArray<Contact*> Other;
 		for (auto c: d->TrayMenuContacts)
 		{
 			auto First = c->GetFirst();
 			auto Last = c->GetLast();
 			auto Email = c->GetEmail();
 			if (Email)
 			{
 				// has an email, list it
 				if (First || Last)
 				{
 					auto Name = First?First:Last;
 					if
 					(
 						(*Name >= 'a' && *Name <= 'z')
 						||
 						(*Name >= 'A' && *Name <= 'Z')
 					)
 					{
 						int Ind = tolower(*Name) - 'a';
 						if (Ind >= 0 && Ind < CountOf(Alpha))
 							Alpha[Ind].Add(c);
 						else
 							Other.Add(c);
 					}
 					else
 						Other.Add(c);
 				}
 			}
 		}
 
 		for (int i=0; i<CountOf(Alpha); i++)
 		{
 			if (Alpha[i].Length() > 0)
 			{
 				char Group[64];
 				sprintf_s(Group, sizeof(Group), "%c...", 'a' + i);
 				auto Sub = Menu->AppendSub(Group);
 				if (Sub)
 				{
 					for (auto c: Alpha[i])
 						AddContactToMenu(Sub, c, d->TrayMenuContacts.IndexOf(c));
 				}
 			}
 		}
 
 		if (Other.Length())
 		{
 			auto Sub = Menu->AppendSub("Other...");
 			if (Sub)
 			{
 				for (auto c: Other)
 					AddContactToMenu(Sub, c, d->TrayMenuContacts.IndexOf(c));
 			}
 		}
 	}
 	else
 	{
 		// Display all...
 		for (size_t i=0; i<d->TrayMenuContacts.Length(); i++)
 		{
 			AddContactToMenu(Menu, d->TrayMenuContacts[i], i);
 		}
 	}
 }
 
 void ScribeWnd::OnUrl(const char *Url)
 {
 	LUri u(Url);
 	if (u.sProtocol && !_stricmp(u.sProtocol, "mailto"))
 	{
 		CreateMail(0, Url, 0);
 	}
 }
 
 void ScribeWnd::OnReceiveFiles(LArray<const char*> &Files)
 {
 	int UnknownFormats = 0;
 	int64 Period = LCurrentTime() - LastDrop;
 
 	if (Period > 500) // Lock out drops within 500ms of an LGI drop
 	{
 		LString sSend, sPages;
 		bool HasSend = LAppInst->GetOption("send", sSend);
 		bool HasPrint = LAppInst->GetOption("p", sPages);
 		LArray<Mail*> NewMail;
 
 		for (unsigned i=0; i<Files.Length(); i++)
 		{
 			auto f = Files[i];
 			LString MimeType = ScribeGetFileMimeType(f);
 
 			if (MimeType)
 			{
 				Thing *t = NULL;
 				
 				if (!_stricmp(MimeType, sMimeVCard))
 				{
 					t = CreateItem(MAGIC_CONTACT, NULL, false);
 				}
 				else if (!_stricmp(MimeType, sMimeVCalendar))
 				{
 					t = CreateItem(MAGIC_CALENDAR, NULL, false);
 				}
 				else if (!_stricmp(MimeType, sMimeMessage))
 				{
 					t = CreateItem(MAGIC_MAIL, NULL, false);
 				}
 				else if (!_stricmp(MimeType, sMimeMbox))
 				{
 					// What should I do here?
 				}
 				else UnknownFormats++;
 
 				if (t)
 				{
 					LAutoPtr<LFile> str(new LFile);
 					if (str->Open(f, O_READ))
 					{
 						if (t->Import(t->AutoCast(str), MimeType))
 						{
 							if (HasSend)
 							{
 								Mail *m = t->IsMail();
 								if (m)
 								{
 									NewMail.Add(m);
 									m->SetFlags(m->GetFlags() | MAIL_CREATED | MAIL_READ);
 								}
 							}
 							else
 							{
 								t->DoUI();
 							}
 						}
 					}
 				}
 			}
 			else UnknownFormats++;
 		}
 
 		bool SendNow = sSend ? atoi(sSend) != 0 : false;
 		for (unsigned i=0; i<NewMail.Length(); i++)
 		{
 			Mail *m = NewMail[i];
 			if (SendNow)
 			{
 				m->SetFlags(m->GetFlags() | MAIL_READY_TO_SEND);
 				m->Save();
 			}
 			else if (HasPrint)
 			{
 				ThingPrint(NULL, m, GetPrinter(), 0, sPages ? atoi(sPages) : 0);
 			}
 			else
 			{
 				m->DoUI();
 			}
 		}
 		if (SendNow)
 			Send();
 	}
 }
 
 void ScribeWnd::OnTrayClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		#ifndef MAC
 		// No support for different mouse button info so the default
 		// action is to show the sub-menu of contacts and actions.
 		if (m.IsContextMenu())
 		#endif
 		{
 			LWindow::OnTrayClick(m);
 		}
 		#ifndef MAC
 		else if (m.Left())
 		{
 			if (m.Double())
 			{
 				if (Mail::NewMailLst.Length() > 0)
 				{
 					ScribeFolder *InBox = GetFolder(FOLDER_INBOX);
 					OpenAMail(InBox);
 				}
 			}
 			else
 			{
 				if (GetZoom() == LZoomMin)
 				{
 					SetZoom(LZoomNormal);
 				}
 				else
 				{
 					if (Obscured())
 						SetZoom(LZoomNormal);  // Bounce in front, first.
 					else
 						SetZoom(LZoomMin);
 				}
 				Visible(true);
 
 				MoveOnScreen();
 				Raise();
 
 				if (MailList)
 				{
 					MailList->Focus(true);
 				}
 			}
 		}
 		else if (m.Middle())
 		{
 			Mail::NewMailLst.Empty();
 		}
 		#endif
 	}
 }
 
 void ScribeWnd::OnTrayMenu(LSubMenu &m)
 {
 	m.SetImageList(ImageList, false);
 	d->TrayMenuContacts.Length(0);
 
 	#ifdef MAC
 	m.AppendItem(LLoadString(IDS_OPEN), IDM_OPEN);
 	m.AppendSeparator();
 	#endif
 
 	LHashTbl<ConstStrKey<char,false>,Contact*> Added;
 	LArray<ScribeFolder*> Srcs = GetThingSources(MAGIC_CONTACT);
 	for (auto c: Srcs)
 	{
 		c->LoadThings();
 		for (auto i: c->Items)
 		{
 			Contact *c = i->IsContact();
 			if (!c) continue;
 
 			bool IsAdded = false;
 			auto Emails = c->GetEmails();
 			for (auto e: Emails)
 			{
 				if (Added.Find(e))
 					IsAdded = true;
 			}
 
 			if (Emails.Length() && !IsAdded)
 			{
 				for (auto e: Emails)
 					Added.Add(e, c);
 				d->TrayMenuContacts.Add(c);
 			}
 		}
 	}
 	AddContactsToMenu(&m);
 
 	m.AppendSeparator();
 
 	if (Mail::NewMailLst.Length() > 0)
 	{
 		int i=0;
 		for (auto ml: Mail::NewMailLst)
 		{
 			LStringPipe p;
 			
 			// This code figures out how many UTF characters to print. We
 			// can't split a UTF character because downstream conversions
 			// will fail.
 			const char *Subj = ml->GetSubject();
 			if (!Subj)
 				Subj = "(No Subject)";
 			LUtf8Ptr u((uint8_t*)Subj);
 			while ((int32)u && u.GetPtr() - (uchar*)Subj < 64)
 				u++;
 			ssize_t Bytes = u.GetPtr() - (uchar*)Subj;
 			
 			p.Print("%.*s, %s <%s>",
 					Bytes,
 					Subj?Subj:(char*)"(No Subject)",
 					ml->GetFromStr(FIELD_NAME),
 					ml->GetFromStr(FIELD_EMAIL));
 			LAutoString a(p.NewStr());
 			
 			LAssert(LIsUtf8(a));
 			
 			auto Item = m.AppendItem(a, TRAY_MAIL_BASE+i++, true);
 			if (Item)
 			{
 				Item->Icon(ICON_UNREAD_MAIL);
 			}
 		}
 		m.AppendSeparator();
 	}
 
 	if (GetZoom() == LZoomMin)
 	{
 		m.AppendItem(LLoadString(IDS_OPEN), IDM_OPEN, true);
 	}
 
 	auto NewMail = m.AppendItem(LLoadString(IDS_NEW_EMAIL), IDM_NEW_EMAIL);
 	if (NewMail) NewMail->Icon(ICON_UNSENT_MAIL);
 	m.AppendItem(LLoadString(IDS_EXIT), IDM_EXIT);
 }
 
 void ScribeWnd::OnTrayMenuResult(int MenuId)
 {
 	switch (MenuId)
 	{
 		case IDM_OPEN:
 		{
 			if (GetZoom() == LZoomMin)
 			{
 				SetZoom(LZoomNormal);
 			}
 
 			Visible(true);
 			Raise();
 			
 			if (MailList)
 			{
 				MailList->Focus(true);
 			}
 			break;
 		}
 		case IDM_NEW_EMAIL:
 		{
 			CreateMail();
 			break;
 		}
 		case IDM_EXIT:
 		{
 			d->IngoreOnClose = true;
 			PostEvent(M_CLOSE);
 			break;
 		}
 		default:
 		{
 			auto i = MenuId - TRAY_CONTACT_BASE;
 			Contact *c = d->TrayMenuContacts.IdxCheck(i) ? d->TrayMenuContacts[i] : NULL;
 			if (c)
 			{
 				CreateMail(c);
 			}
 
 			Mail *m = Mail::NewMailLst[MenuId - TRAY_MAIL_BASE];
 			if (m)
 			{
 				Mail::NewMailLst.Delete(m);
 				m->DoUI();
 			}
 			break;
 		}
 	}
 }
 
 void ScribeWnd::OnZoom(LWindowZoom Action)
 {
 	if (Action == LZoomMin)
 	{
 		LVariant i;
 		if (GetOptions()->GetValue(OPT_MinimizeToTray, i) && i.CastInt32())
 		{
 			Visible(false);
 		}
 	}
 }
 
 struct UserInput
 {
 	std::function<void(LString)> Callback;
 	LView *Parent;
 	LString Msg;
 	bool Password;
 
 	UserInput()
 	{
 		Password = false;
 	}
 };
 
 void ScribeWnd::GetUserInput(LView *Parent, LString Msg, bool Password, std::function<void(LString)> Callback)
 {
 	if (InThread())
 	{
 		auto Inp = new LInput(Parent ? Parent : this, "", Msg, AppName, Password);
 		Inp->DoModal([this, Inp, Callback](auto dlg, auto id)
 		{
 			if (Callback)
 				Callback(id ? Inp->GetStr() : NULL);
 			delete dlg;
 		});
 	}
 
 	auto i = new UserInput;
 	i->Parent = Parent;
 	i->Msg = Msg;
 	i->Password = Password;
 	i->Callback = Callback;
 	if (!PostEvent(M_GET_USER_INPUT, (LMessage::Param)i))
 	{
 		LAssert(!"PostEvent failed.");
 		if (Callback)
 			Callback(NULL);
 	}
 }
 
 LMessage::Result ScribeWnd::OnEvent(LMessage *Msg)
 {
 	TrayIcon.OnEvent(Msg);
 	BayesianFilter::OnEvent(Msg);
 	
 	switch (Msg->Msg())
 	{
 		case M_UNIT_TEST:
 		{
 			LAutoPtr<LJson> j((LJson*)Msg->A());
 			if (!j) break;
 
 			auto cmd = j->Get("cmd");
 			if (!cmd) break;
 
 			if (cmd.Equals("somecmd"))
 			{
 				
 			}
 			break;
 		}
 		case M_CALENDAR_SOURCE_EVENT:
 		{
 			CalendarSource *cs = (CalendarSource*)Msg->A();
 			LAutoPtr<LMessage> m((LMessage*)Msg->B());
 			if (cs && m)
 				cs->OnEvent(m);
 			break;
 		}
 		case M_GET_USER_INPUT:
 		{
 			LAutoPtr<UserInput> i((UserInput*)Msg->A());
 			LAssert(i);
 			LAssert(InThread()); // Least we get stuck in an infinite loop
 			
 			GetUserInput(i->Parent, i->Msg, i->Password, i->Callback);
 			break;
 		}
 		case M_SET_HTML:
 		{
 			LAutoPtr<LString> Html((LString*)Msg->A());
 			if (PreviewPanel && Html)
 			{
 				LVariant Ret;
 				LArray<LVariant*> Arg;
 				Arg.Add(new LVariant(Html->Get()));
 				PreviewPanel->CallMethod(DomToStr(SdSetHtml), &Ret, Arg);
 				Arg.DeleteObjects();
 			}
 			break;
 		}
 		case M_NEW_CONSOLE_MSG:
 		{
 			if (d->ShowConsoleBtn)
 				d->ShowConsoleBtn->Image(IDM_CONSOLE_MSGS);
 			break;
 		}
 		case M_NEEDS_CAP:
 		{
 			LAutoString c((char*)Msg->A());
 			LAutoString param((char*)Msg->B());
 			NeedsCapability(c, param);
 			return 0;
 			break;
 		}
 		case M_STORAGE_EVENT:
 		{
 			LDataStoreI *Store = LDataStoreI::Map.Find((int)Msg->A());
 			if (Store)
 				Store->OnEvent((void*)Msg->B());
 			break;
 		}
 		case M_SCRIBE_SET_MSG_FLAG:
 		{
 			LAutoString p((char*)Msg->A());
 			if (p)
 			{
 				char *d = strrchr(p, '/');
 				if (d)
 				{
 					*d++ = 0;
 					ScribeFolder *f = GetFolder(p);
 					if (f)
 					{
 						LUri u;
 						LString a = u.DecodeStr(d);
 						f->GetMessageById(a, [this, NewFlag=(int)Msg->B()](auto r)
 						{
 							if (r)
 							{
 								int ExistingFlags = r->GetFlags();
 								r->SetFlags(ExistingFlags | NewFlag);
 							}
 						});
 					}
 				}
 			}
 			break;
 		}
 		case M_SCRIBE_DEL_THING:
 		{
 			Thing *t = (Thing*)Msg->A();
 			DeleteObj(t);
 			break;
 		}
 		case M_SCRIBE_LOADED:
 		{
 			if (d->FoldersLoaded)
 			{
 				// Ok let the user in
 				CmdSend.Enabled(true);
 				CmdReceive.Enabled(true);
 				CmdPreview.Enabled(true);
 			}
 			break;
 		}
 		case M_SCRIBE_THREAD_DONE:
 		{
 			// Finialize connection
 			AccountThread *Thread = (AccountThread*) Msg->A();
 			Accountlet *Acc = (Accountlet*) Msg->B();
 			if (Thread && Acc)
 			{
 				OnAfterConnect(Acc->GetAccount(), Acc->IsReceive());
 
 				d->NewMailTimeout = 2;
 				Acc->OnThreadDone();
 			}
 			else
 			{
 				LAssert(0);
 			}
 			break;
 		}
 		case M_SCRIBE_MSG:
 		{
 			char *m = (char*)Msg->A();
 			if (m)
 			{
 				if (Msg->B())
 				{
 					if (LgiMsg(this, m, AppName, MB_YESNO) == IDYES)
 					{
 						PostEvent(M_COMMAND, IDM_OPTIONS, 0);						
 					}
 				}
 				else
 				{
 					LgiMsg(this, "%s", AppName, MB_OK, m);
 				}
 
 				DeleteArray(m);
 			}
 			break;
 		}
 		/*
 		case M_SCRIBE_LOG_MSG:
 		{
 			List<LogEntry> *Log = (List<LogEntry>*)Msg->A();
 			LAutoPtr<LogEntry> Entry((LogEntry*)Msg->B());
 
 			if (ScribeState != ScribeExiting &&
 				Log &&
 				Entry)
 			{
 				Log->Insert(Entry.Release());
 
 				// Trim long list...
 				while (Log->Length() > 1024)
 				{
 					LogEntry *e = Log->First();
 					Log->Delete(e);
 					DeleteObj(e);
 				}
 			}
 			break;
 		}
 		*/
 		case M_SCRIBE_NEW_MAIL:
 		{
 			if (Lock(_FL))
 			{
 				if (NewMailDlg)
 				{
 					NewMailDlg->AddThings(&Mail::NewMailLst);
 				}
 				Unlock();
 			}
 			break;
 		}
 		case M_SCRIBE_OPEN_THING:
 		{
 			Thing *t = (Thing*) Msg->A();
 			if (t)
 			{
 				t->DoUI();
 			}
 			break;
 		}
 		case M_SCRIBE_ITEM_SELECT:
 		{
 			if (!MailList || !IsAttached())
 				break;
 
 			List<Thing> Things;
 			MailList->GetSelection(Things);
 			OnSelect(&Things);
 			break;
 		}
 		case M_URL:
 		{
 			LAutoPtr<LString> Url((LString*)Msg->A());
 			if (Url)
 			{
 				LUri u(*Url);
 				if (u.sProtocol && !_stricmp(u.sProtocol, "mailto"))
 				{
 					Mailto mt(this, *Url);
 					if (mt.To.Length() > 0)
 					{
 						Thing *t = CreateItem(MAGIC_MAIL, NULL, false);
 						if (t)
 						{
 							Mail *m = t->IsMail();
 							if (m)
 							{
 								mt.Apply(m);
 								m->DoUI();
 							}
 							else DeleteObj(t);
 						}
 					}
 				}
 			}
 			break;
 		}
 	}
 
 	return LWindow::OnEvent(Msg);
 }
 
 bool ScribeWnd::IsMyEmail(const char *Email)
 {
 	if (Email)
 	{
 		LVariant e;
 		for (auto a : *GetAccounts())
 		{
 			LVariant e = a->Identity.Email();
 			if (e.Str() && _stricmp(Email, e.Str()) == 0)
 			{
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 int ScribeWnd::GetMaxPages()
 {
 	return d->PrintMaxPages;
 }
 
 void ScribeWnd::ThingPrint(std::function<void(bool)> Callback, ThingType *m, LPrinter *Printer, LView *Parent, int MaxPages)
 {
 	d->PrintMaxPages = MaxPages;
 	
 	if (!Printer)
 		Printer = GetPrinter();
 	if (!Printer)
 	{
 		if (Callback) Callback(false);
 		return;
 	}
 	Thing *t = dynamic_cast<Thing*>(m);
 	if (!t)
 	{
 		if (Callback) Callback(false);
 		return;
 	}
 		
 	auto Events = new ScribePrintContext(this, t);
 	Printer->Print(	Events,
 					[this, Events, Parent, Printer, Callback](auto pages)
 					{
 						if (pages == Events->OnBeginPrintError)
 						{
 							LgiMsg(Parent, "Printing failed: %s", AppName, MB_OK, Printer->GetErrorMsg().Get());
 							if (Callback)
 								Callback(false);
 						}
 						else if (Callback)
 						{
 							Callback(true);
 						}
 
 						delete Events;
 					},
 					AppName,
 					-1,
 					Parent ? Parent : this);
 }
 
 bool ScribeWnd::MailReplyTo(Mail *m, bool All)
 {
 	bool Status = false;
 
 	if (m)
 	{
 		LDataStoreI *Store = m->GetObject() ? m->GetObject()->GetStore() : NULL;
 		LDataI *NewMailObj = Store && Store->GetInt(FIELD_STORE_TYPE) == Store3Sqlite ? Store->Create(MAGIC_MAIL) : NULL;
 		
 		Mail *NewMail = new Mail(this, NewMailObj);
 		if (NewMail)
 		{
 			if (NewMail->GetObject())
 			{
 				NewMail->OnReply(m, All, true);
 
 				LView *w = NewMail->DoUI();
 				if (w)
 				{
 					LViewI *t = w->FindControl(IDC_TEXT);
 					if (t)
 					{
 						t->Focus(true);
 					}
 				}
 
 				Status = true;
 			}
 			else DeleteObj(NewMail);
 		}
 	}
 
 	return Status;
 }
 
 bool ScribeWnd::MailForward(Mail *m)
 {
 	bool Status = false;
 
 	if (m)
 	{
 		Mail *NewMail = new Mail(this);
 		if (NewMail)
 		{
 			if (NewMail->OnForward(m, true))
 			{
 				NewMail->DoUI();
 				Status = true;
 			}
 			else
 			{
 				NewMail->DecRef();
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool ScribeWnd::MailBounce(Mail *m)
 {
 	bool Status = false;
 
 	if (m)
 	{
 		Mail *NewMail = new Mail(this);
 		if (NewMail)
 		{
 			if (NewMail->OnBounce(m, true))
 			{
 				NewMail->DoUI();
 				Status = true;
 			}
 			else
 			{
 				DeleteObj(NewMail);
 			}
 		}
 	}
 
 	return Status;
 }
 
 Mail *ScribeWnd::CreateMail(Contact *c, const char *Email, const char *Name)
 {
 	Mail *m = dynamic_cast<Mail*>(CreateItem(MAGIC_MAIL, NULL, false));
 	if (m)
 	{
 		bool IsMailTo = false;
 		if (Email)
 		{
 			IsMailTo = _strnicmp(Email, "mailto:", 7) == 0;
 			if (IsMailTo)
 			{
 				Mailto mt(this, Email);
 				mt.Apply(m);
 			}
 		}
 
 		MailUi *UI = dynamic_cast<MailUi*>(m->DoUI());
 		if (UI)
 		{
 			if (c)
 			{
 				UI->AddRecipient(c);
 			}
 
 			if (Email && !IsMailTo)
 			{
 				UI->AddRecipient(Email, Name);
 			}
 		}
 	}
 
 	return m;
 }
 
 Mail *ScribeWnd::LookupMailRef(const char *MsgRef, bool TraceAllUids)
 {
 	if (!MsgRef)
 		return 0;
 	
 	LAutoString p(NewStr(MsgRef));
 	char *RawUid = strrchr(p, '/');
 	if (RawUid)
 	{
 		*RawUid++ = 0;
 		LUri u;
 		LString Uid = u.DecodeStr(RawUid);
 		
 		// Try the mail message map first...
 		Mail *m = Mail::GetMailFromId(Uid);
 		if (m)
 			return m;
 
 		// Ok, not found, so look in last known folder...
 		ScribeFolder *f = GetFolder(p);
 		if (f)
 		{
 			for (auto t : f->Items)
 			{
 				Mail *m = t->IsMail();
 				if (m)
 				{
 					auto s = m->GetMessageId();
 					if (s && !strcmp(s, Uid))
 					{
 						return m;
 					}
 					
 					if (TraceAllUids)
 						LgiTrace("\t%s\n", s);
 				}
 			}
 		}
 	}
 
 	return 0;
 }
 
 void ScribeWnd::OnBayesAnalyse(const char *Msg, const char *WhiteListEmail)
 {
 	LString s, q;
 	s.Printf("<html><body style='background:L_MED;'><pre>%s</pre>", Msg);
 	if (WhiteListEmail)
 	{
 		q.Printf(LLoadString(IDS_REMOVE_WHITELIST), WhiteListEmail);
 		s += LString("<br>") + q;
 	}
 	s += "</body></html>";
 	LHtmlMsg([this, WhiteListEmail=LString(WhiteListEmail)](auto result)
 			{
 				if (result == IDYES)
 					RemoveFromWhitelist(WhiteListEmail);
 			},
 			this,
 			s,
 			AppName,
 			WhiteListEmail ? MB_YESNO : MB_OK);
 }
 
 bool ScribeWnd::OnBayesResult(const char *MailRef, double Rating)
 {
 	Mail *m = LookupMailRef(MailRef);
 	if (m)
 		return OnBayesResult(m, Rating);
 	#ifdef _DEBUG
 	else
 	{
 		LgiTrace("%s:%i - error finding mail ref: %s\n", _FL, MailRef);
 		LookupMailRef(MailRef, true);
 		LAssert(!"We should always be able to resolve the reference, unless m is completely deleted");
 	}
 	#endif
 	
 	return false;
 }
 
 bool ScribeWnd::OnBayesResult(Mail *m, double Rating)
 {
 	if (!m)
 		return false;
 
 	LVariant v;
 	GetOptions()->GetValue(OPT_BayesThreshold, v);
 	double BayesThresh = v.CastDouble();
 	if (BayesThresh < 0.1) BayesThresh = 0.1;
 	if (BayesThresh > 1.0) BayesThresh = 1.0;
 
 	if (Rating < BayesThresh)
 	{
 		// Not spam, so we continue new mail processing
 		if (m->NewEmail == Mail::NewEmailBayes)
 		{
 			List<Mail> Nm;
 			Nm.Insert(m);
 			m->NewEmail = Mail::NewEmailGrowl;
 			OnNewMail(&Nm, true);
 		}
 		return false;
 	}
 
 	// Spam is pink!
 	m->SetMarkColour(Rgb32(255, 0, 0));
 	m->SetFlags(m->GetFlags() | MAIL_BAYES_SPAM);
 
 	ScribeBayesianFilterMode FilterMode = BayesOff;
 	if (GetOptions()->GetValue(OPT_BayesFilterMode, v))
 		FilterMode = (ScribeBayesianFilterMode)v.CastInt32();
 		
 	if (FilterMode == BayesTrain)
 	{
 		// Move to folder
 		LVariant MoveToPath;
 		if (!GetOptions()->GetValue(OPT_BayesMoveTo, MoveToPath))
 		{
 			MoveToPath = "/Spam/Probably";
 		}
 		ScribeFolder *f = GetFolder(MoveToPath.Str());
 		if (f)
 		{
 			LArray<Thing*> Items;
 			Items.Add(m);
 			f->MoveTo(Items, false, [this, m](auto result, auto status)
 			{			
 				List<Mail> obj;
 				obj.Insert(m);
 				OnNewMail(&obj, false);
 			});
 		}
 	}
 	else
 	{
 		m->DeleteAsSpam(this);
 	}
 
 	return true;
 }
 
 static int AccountCmp(ScribeAccount *a, ScribeAccount *b, int Data)
 {
 	return a->Identity.Sort() - b->Identity.Sort();
 }
 
 class ScribePasteState : public LProgressDlg
 {
 	ScribeWnd *App = NULL;
 	ScribeFolder *Folder = NULL;
 	LAutoPtr<uint8_t, true> Data;
 	ssize_t Size = 0;
 	LDataStoreI::StoreTrans Trans;
 	LProgressPane *LoadPane = NULL, *SavePane = NULL;
 	ScribeClipboardFmt *tl = NULL;
 	uint32_t Errors = 0;
 	ssize_t Idx = 0;
 
 	enum PasteState
 	{
 		LoadingThings,
 		SavingThings,
 	}	State = LoadingThings;
 
 public:
 	ScribePasteState(ScribeWnd *app, ScribeFolder *folder, LAutoPtr<uint8_t, true> data, ssize_t size) :
 		LProgressDlg(app),
 		App(app),
 		Folder(folder),
 		Data(data),
 		Size(size)
 	{
 		// Paste 'ScribeThingList'
 		tl = (ScribeClipboardFmt*)Data.Get();
 
 		Trans = Folder->GetObject()->GetStore()->StartTransaction();
 
 		LoadPane = ItemAt(0);
 		LoadPane->SetDescription("Loading objects...");
 		LoadPane->SetRange(tl->Length());
 
 		SavePane = Push();
 		SavePane->SetRange(tl->Length());
 		SavePane->SetDescription("Saving: No errors...");
 
 		// LProgressDlg will do a SetPulse in it's OnCreate
 	}
 
 	void OnPulse()
 	{
 		auto Start = LCurrentTime();
 		static int TimeSlice = 300; //ms
 
 		if (State == LoadingThings)
 		{
 			while (	Idx < tl->Length() &&
 					!IsCancelled() &&
 					LCurrentTime() - Start < TimeSlice)
 			{
 				Thing *t = tl->ThingAt(Idx++);
 				if (!t)
 					continue;
 
 				auto Obj = t->GetObject();
 				if (Obj->GetInt(FIELD_LOADED) < Store3Loaded)
 					Obj->SetInt(FIELD_LOADED, Store3Loaded);
 			}
 
 			Value(Idx);
 			if (Idx >= tl->Length())
 			{
 				State = SavingThings;
 				Idx = 0;
 			}
 		}
 		else if (State == SavingThings)
 		{
 			while (	Idx < tl->Length() &&
 					!IsCancelled() &&
 					LCurrentTime() - Start < TimeSlice)
 			{
 				Thing *t = tl->ThingAt(Idx++);
 				if (!t)
 					continue;
 
 				auto Obj = t->GetObject();
 				LAssert(Obj->GetInt(FIELD_LOADED) == Store3Loaded); // Load loop should have done this already
 
 				Thing *Dst = App->CreateItem(Obj->Type(), Folder, false);
 				if (Dst)
 				{
 					*Dst = *t;
 					Dst->Update();
 					if (!Dst->Save(Folder))
 					{
 						LString s;
 						s.Printf("Saving: " LPrintfSSizeT " error(s)", ++Errors);
 						SetDescription(s);
 					}
 				}
 				else Errors++;
 			}
 
 			SavePane->Value(Idx);
 			if (Idx >= tl->Length())
 			{
 				if (Errors > 0)
 					LgiMsg(this, "Failed to save %i of %i objects.", AppName, MB_OK, Errors, tl->Length());
 				Quit();
 				return;
 			}
 		}
 
 		LProgressDlg::OnPulse();
 	}
 };
 
 int ScribeWnd::OnCommand(int Cmd, int Event, OsView WndHandle)
 {
 	// Send mail multi-menu
 	if (Cmd >= IDM_SEND_FROM &&
 		Cmd <= IDM_SEND_FROM + (ssize_t)Accounts.Length())
 	{
 		Send(Cmd - IDM_SEND_FROM);
 		return 0;
 	}
 
 	// Receive mail multi-menu
 	if (Cmd >= IDM_RECEIVE_FROM &&
 		Cmd < IDM_RECEIVE_FROM + (ssize_t)Accounts.Length())
 	{
 		Receive(Cmd - IDM_RECEIVE_FROM);
 		return 0;
 	}
 
 	// Preview mail multi-menu
 	if (Cmd >= IDM_PREVIEW_FROM &&
 		Cmd < IDM_PREVIEW_FROM + (ssize_t)Accounts.Length())
 	{
 		Preview(Cmd - IDM_PREVIEW_FROM);
 		return 0;
 	}
 
 	// Identity multi-menu
 	if (Cmd >= IDM_IDENTITY_BASE &&
 		Cmd <= IDM_IDENTITY_BASE + (ssize_t)Accounts.Length())
 	{
 		SetCurrentIdentity(Cmd - IDM_IDENTITY_BASE - 1);
 		return 0;
 	}
 
 	// Is this a script tool?
 	if (LScribeScript::Inst &&
 		Cmd >= IDM_TOOL_SCRIPT_BASE &&
 		Cmd < IDM_TOOL_SCRIPT_BASE + (int)d->Scripts.Length())
 	{
 		// Do tools menu callback... find the right callback....
 		LArray<LScriptCallback*> c;
 		if (GetScriptCallbacks(LToolsMenu, c))
 		{
 			for (unsigned i=0; i<c.Length(); i++)
 			{
 				if (c[i]->Func &&
 					c[i]->Param == Cmd)
 				{
 					// Call the callback
 					char Msg[MAX_PATH_LEN];
 					LScribeScript::Inst->GetLog()->Write
 						(
 							Msg,
 							sprintf_s(Msg, sizeof(Msg), "\n\nRunning tool script '%s'...\n", c[i]->Script->Code->GetFileName())
 						);
 
 					// Setup the arguments...
 					LScriptArguments Args(NULL);
 					Args.New() = new LVariant((LDom*)this);
 					Args.New() = new LVariant(Cmd);
 
 					// Call the method
 					ExecuteScriptCallback(*c[i], Args);
 
 					// Cleanup
 					Args.DeleteObjects();
 					break;
 				}
 			}
 		}
 		return 0;
 	}
 
 	// New from template multi-menu
 	if (Cmd >= IDM_NEW_FROM_TEMPLATE &&
 		Cmd < IDM_NEW_FROM_TEMPLATE + 100)
 	{
 		int Index = Cmd - IDM_NEW_FROM_TEMPLATE;
 		ScribeFolder *Templates = GetFolder(FOLDER_TEMPLATES);
 		if (Templates)
 		{
 			Templates->LoadThings();
 
 			for (auto i: Templates->Items)
 			{
 				Mail *m = i->IsMail();
 				if (m)
 				{
 					if (Index == 0)
 					{
 						Thing *t = CreateItem(MAGIC_MAIL, 0, false); // GetFolder(FOLDER_OUTBOX)
 						Mail *NewMail = IsMail(t);
 						if (NewMail)
 						{
 							*NewMail = (Thing&)*m;
 							NewMail->DoUI();
 							break;
 						}
 					}
 					Index--;
 				}
 			}
 		}
 		return 0;
 	}
 
 	switch (Cmd)
 	{
 		// File menu
 		case IDM_MANAGE_MAIL_STORES:
 		{
 			auto Dlg = new ManageMailStores(this);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				LAutoPtr<LDialog> mem(dlg);
 				if (id)
 				{
 					SaveOptions();
 
 					if (!UnLoadFolders())
 						return;
 
 					LXmlTag *Ms = GetOptions()->LockTag(OPT_MailStores, _FL);
 					if (Ms)
 					{
 						while (Ms->Children.Length())
 							delete Ms->Children[0];
 					
 						LXmlTag *t = Dlg->Options.GetChildTag(OPT_MailStores);
 						if (t)
 						{
 							for (auto c: t->Children)
 							{
 								LXmlTag *n = new LXmlTag;
 								n->Copy(*c, true);
 								Ms->InsertTag(n);
 							}
 						}
 
 						GetOptions()->Unlock();
 					}
 
 					LVariant v;
 					GetOptions()->SetValue(OPT_CreateFoldersIfMissing, v = true);
 
 					if (!Dlg->Options.GetValue(OPT_StartInFolder, v))
 						v.Empty();
 					GetOptions()->SetValue(OPT_StartInFolder, v);
 
 					LoadFolders(NULL);
 				}
 			});
 			break;
 		}
 		case IDM_REPLICATE:
 		{
 			auto Dlg = new ReplicateDlg(this);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 				{
 					UnLoadFolders();
 					Dlg->StartProcess();
 					// Don't delete dialog... let it run
 				}
 				else delete dlg;
 			});
 			break;
 		}
 		case IDM_SECURITY:
 		{
 			// Check for user perm password...
 			// No point allow any old one to edit the security settings.
 			auto ShowDialog = [this]()
 			{
 				auto Dlg = new SecurityDlg(this);
 				Dlg->DoModal(NULL);
 			};
 
 			LPassword p;
 			if (p.Serialize(GetOptions(), OPT_UserPermPassword, false))
 			{
 				GetAccessLevel(this, PermRequireUser, "Security Settings", [ShowDialog](bool Allow)
 				{
 					if (Allow)
 						ShowDialog();
 				});
 			}
 			else
 			{
 				ShowDialog();
 			}
 			break;
 		}
 		case IDM_OPTIONS:
 		{
 			LVariant ShowTotals;
 			GetOptions()->GetValue(OPT_ShowFolderTotals, ShowTotals);
 
 			// do the dialog
 			auto Dlg = new OptionsDlg(this);
 			Dlg->DoModal([this, Dlg, ShowTotals](auto dlg, auto id)
 			{
 				if (id)
 				{
 					// set up the POP3 accounts
 					SetupAccounts();
 					SaveOptions();
 
 					// close any IMAP accounts that are now disabled.
 					for (auto a : Accounts)
 					{
 						if (a->Receive.IsConfigured() &&
 							a->Receive.IsPersistant())
 						{
 							if (a->Receive.Disabled())
 								a->Receive.Disconnect();
 							else
 								Receive(a->GetIndex());
 						}
 					}
 
 					// List/Tree view options update
 					LVariant i;
 					if (GetOptions()->GetValue(OPT_ShowFolderTotals, i) &&
 						i.CastInt32() != ShowTotals.CastInt32())
 					{
 						Tree->UpdateAllItems();
 					}
 					if (GetOptions()->GetValue(OPT_PreviewLines, i))
 					{
 						Mail::PreviewLines = i.CastInt32() != 0;
 					}
 					if (MailList)
 					{
 						if (GetOptions()->GetValue(OPT_GridLines, i))
 						{
 							MailList->DrawGridLines(i.CastInt32() != 0);
 						}
 						MailList->Invalidate();
 					}
 
 					// date formats
 					if (GetOptions()->GetValue(OPT_DateFormat, i))
 					{
 						int Idx = i.CastInt32();
 						if (Idx >= 0 && Idx < CountOf(DateTimeFormats))
 						{
 							LDateTime::SetDefaultFormat(DateTimeFormats[Idx]);
 						}
 					}
 					if (GetOptions()->GetValue(OPT_AdjustDateTz, i))
 						Mail::AdjustDateTz = i.CastInt32() == 0;
 
 					// SSL debug logging
 					if (GetOptions()->GetValue(OPT_DebugSSL, i))
 						SslSocket::DebugLogging = i.CastInt32() != 0;
 
 					// Html edit menu
 					if (GetOptions()->GetValue(OPT_EditControl, i))
 					{
 						auto mi = Menu->FindItem(IDM_HTML_EDITOR);
 						if (mi) mi->Checked(i.CastInt32() != 0);
 					}
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_WORK_OFFLINE:
 		{
 			if (WorkOffline)
 			{
 				WorkOffline->Checked(!WorkOffline->Checked());
 				LVariant v;
 				GetOptions()->SetValue(OPT_WorkOffline, v = WorkOffline->Checked());
 
 				if (!WorkOffline->Checked())
 				{
 					// Offline -> Online transition.
 
 					// Check if any pending messages are in the Outbox
 					ScribeFolder *Outbox = GetFolder(FOLDER_OUTBOX);
 					if (Outbox)
 					{
 						bool HasMailToSend = false;
 
 						for (auto t: Outbox->Items)
 						{
 							Mail *m = t->IsMail();
 							if (m)
 							{
 								if (TestFlag(m->GetFlags(), MAIL_READY_TO_SEND))
 								{
 									HasMailToSend = true;
 									break;
 								}
 							}
 						}
 
 						if (HasMailToSend)
 						{
 							PostEvent(M_COMMAND, IDM_SEND_MAIL,
 								#ifndef __GTK_H__
 								(LMessage::Param)Handle()
 								#else
 								0
 								#endif
 								);
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDM_ITEM_FILTER:
 		{
 			if (GetCtrlValue(IDM_ITEM_FILTER))
 			{
 				if ((SearchView = new LSearchView(this)))
 				{
 					SearchView->Focus(true);
 					SetLayout();
 				}
 			}
 			else
 			{
 				DeleteObj(SearchView);
 			}
 
 			ScribeFolder *Folder = GetCurrentFolder();
 			if (Folder)
 			{
 				Folder->Populate(MailList);
 			}
 			break;
 		}
 		case IDM_PRINT:
 		{
 			if (MailList)
 			{
 				List<LListItem> Sel;
 				if (MailList->LList::GetSelection(Sel))
 				{
 					for (auto i: Sel)
 					{
 						ThingType *t = dynamic_cast<ThingType*>(i);
 						ThingPrint(NULL, t);
 					}
 				}
 			}
 			break;
 		}
 		case IDM_PRINTSETUP:
 		{
 			auto *p = GetPrinter();
 			if (p && p->Browse(this))
 			{
 				LString Str;
 				if (p->Serialize(Str, true))
 				{
 					LVariant v;
 					GetOptions()->SetValue(OPT_PrintSettings, v = Str);
 				}
 			}
 			break;
 		}
 		case IDM_PAGE_SETUP:
 		{
 			auto Dlg = new ScribePageSetup(this, GetOptions());
 			Dlg->DoModal(NULL);
 			break;
 		}
 		case IDM_EXIT:
 		{
 			LMouse m;
 			GetMouse(m);
 			d->IngoreOnClose = m.Ctrl();
 			LCloseApp();
 			break;
 		}
 
 		// Edit menu
 		case IDM_FIND:
 		{
 			auto v = GetFocus();
 			LDocView *doc = dynamic_cast<LDocView*>(v);
 			if (doc)
 			{
 				doc->DoFind(NULL);
 			}
 			else
 			{
 				ScribeFolder *Folder = GetCurrentFolder();
 				OpenFinder(this, Folder);
 			}
 			break;
 		}
 		case IDM_COPY:
 		{
 			if (MailList && MailList->Focus())
 			{
 				List<Thing> Lst;
 				if (!MailList->GetSelection(Lst))
 					break;
 
 				// Copy 'ScribeThingList'
 				ScribeClipboardFmt *tl = ScribeClipboardFmt::Alloc(Lst);
 				if (!tl)
 					break;
 
 				LClipBoard Clip(this);
 				if (Clip.IsOpen())
 				{
 					if (!Clip.Binary(d->ClipboardFormat, (uchar*)tl, tl->Sizeof(), true))
 					{
 						LgiMsg(this, "Couldn't set the clipboard data.", AppName, MB_OK);
 					}
 				}
 				else
 				{
 					LgiMsg(this, "Couldn't open the clipboard.", AppName, MB_OK);
 				}
 
 				free(tl);
 			}
 			else
 			{
 				LViewI *v = LAppInst->GetFocus();
 				if (v)
 					v->PostEvent(M_COPY);
 			}
 			break;
 		}
 		case IDM_PASTE:
 		{
 			LViewI *v = LAppInst->GetFocus();
 			if (v && v->GetWindow() != (LWindow*)this)
 			{
 				v->PostEvent(M_PASTE);
 				break;
 			}
 			
 			if (!MailList->Focus() && !Tree->Focus())
 			{
 				LgiTrace("%s:%i - List/Tree doesn't have focus.\n");
 				break;
 			}
 
 			ScribeFolder *Folder = dynamic_cast<ScribeFolder*>(Tree->Selection());
 			if (!Folder || !Folder->GetObject())
 			{
 				LgiMsg(this, "No current folder.", AppName, MB_OK);
 				break;
 			}
 
 			LClipBoard Clip(this);
 			if (!Clip.IsOpen())
 			{
 				LgiMsg(this, "Couldn't open the clipboard.", AppName, MB_OK);
 				break;
 			}
 
 			LAutoPtr<uint8_t, true> Data;
 			ssize_t Size = 0;
 			if (!Clip.Binary(d->ClipboardFormat, Data, &Size))
 			{
 				LgiMsg(this, "Couldn't get the clipboard data.", AppName, MB_OK);
 				break;
 			}
 
 			if (ScribeClipboardFmt::IsThing(Data.Get(), Size))
 			{
 				new ScribePasteState(this, Folder, Data, Size);
 			}
 			break;
 		}
 		case IDM_DELETE:
 		{
 			LViewI *f = LAppInst->GetFocus();
 			LEdit *e = dynamic_cast<LEdit*>(f);
 			if (e)
 			{
 				// This handles the case where on a mac the menu eats the delete key, even
 				// when the edit control needs it
 				LKey k(LK_DELETE, 0);
 				k.Down(true);
 				f->OnKey(k);
 				k.Down(false);
 				f->OnKey(k);
 			}
 			else
 			{
 				OnDelete();
 			}
 			break;
 		}
 		case IDM_DELETE_AS_SPAM:
 		{
 			if (MailList)
 			{
 				List<LListItem> Sel;
 				MailList->GetSelection(Sel);
 				int Index = -1;
 
 				for (auto i: Sel)
 				{
 					Mail *m = IsMail(i);
 					if (m)
 					{
 						if (Index < 0)
 						{
 							Index = MailList->IndexOf(i);
 						}
 						m->DeleteAsSpam(this);
 					}
 				}
 
 				if (Index >= 0)
 				{
 					LListItem *i = MailList->ItemAt(Index);
 					if (!i)
 						i = MailList->ItemAt(MailList->Length()-1);
 					if (i)
 						i->Select(true);
 				}
 			}
 			break;
 		}
 		case IDM_REFRESH:
 		{
 			ScribeFolder *f = GetCurrentFolder();
 			if (!f)
 				break;
 			
 			const char *s = DomToStr(SdRefresh);
 			f->GetFldObj()->OnCommand(s);
 			break;
 		}
 
 		// Mail menu
 		case IDM_NEW_EMAIL:
 		{
 			CreateMail();
 			break;
 		}
 		case IDM_SET_READ:
 		case IDM_SET_UNREAD:
 		{
 			ScribeFolder *f = GetCurrentFolder();
 			if (!f)
 				break;
 
 			bool SetRead = Cmd == IDM_SET_READ;
 			f->LoadThings();
 
 			LArray<LDataI*> Change;
 			for (auto t: f->Items)
 			{
 				Mail *m = t->IsMail();
 				if (m && m->Select())
 					Change.Add(m->GetObject());
 			}
 
 			LVariant v = MAIL_READ;
 			LDataStoreI *Store = f->GetObject()->GetStore();
 			if (Store->Change(Change, FIELD_FLAGS, v, SetRead ? OpPlusEquals : OpMinusEquals) == Store3Error)
 			{
 				for (auto t : f->Items)
 				{
 					Mail *m = t->IsMail();
 					if (!m)
 						continue;
 
 					if (!m->Select())
 						continue;
 
 					if (SetRead)
 						m->SetFlags(m->GetFlags() | MAIL_READ);
 					else
 						m->SetFlags(m->GetFlags() & ~MAIL_READ);
 				}
 			}
 			break;
 		}
 		case IDM_REPLY:
 		case IDM_REPLY_ALL:
 		{
 			if (MailList)
 				MailReplyTo(IsMail(MailList->GetSelected()), (Cmd == IDM_REPLY_ALL));
 			break;
 		}
 		case IDM_FORWARD:
 		{
 			if (MailList)
 				MailForward(IsMail(MailList->GetSelected()));
 			break;
 		}
 		case IDM_BOUNCE:
 		{
 			if (MailList)
 				MailBounce(IsMail(MailList->GetSelected()));
 			break;
 		}
 		case IDM_SEND_MAIL:
 		{
 			Send();
 			break;
 		}
 		case IDM_RECEIVE_AND_SEND:
 		{
 			d->SendAfterReceive = true;
 			PostEvent(M_COMMAND, IDM_RECEIVE_MAIL, (LMessage::Param)FindControl(IDM_RECEIVE_MAIL));
 			break;
 		}
 		case IDM_THREAD:
 		{
 			if (MailList)
 			{
 				ScribeFolder *f = GetCurrentFolder();
 				if (f)
 				{
 					f->SetThreaded(!f->GetThreaded());
 					f->Populate(MailList);
 				}
 			}
 			break;
 		}
 		case IDM_RECEIVE_ALL:
 		{
 			#define LOG_RECEIVE_ALL		0
 			int i = 0;
 			
 			Accounts.Sort(AccountCmp);
 			
 			for (auto a : Accounts)
 			{
 				#if LOG_RECEIVE_ALL
 				auto name = a->Identity.Name();
 				auto email = a->Identity.Email();
 				LString desc;
 				desc.Printf("%s/%s", name.Str(), email.Str());
 				#endif
 				
 				if (!a->Receive.IsConfigured())
 				{
 					#if LOG_RECEIVE_ALL
 					LgiTrace("%s:%i - %i/%s not configured.\n", _FL, a->GetIndex(), desc.Get());
 					#endif
 				}
 				else if (a->Receive.Disabled() > 0)
 				{
 					#if LOG_RECEIVE_ALL
 					LgiTrace("%s:%i - %i/%s is disabled.\n", _FL, a->GetIndex(), desc.Get());
 					#endif
 				}
 				else
 				{
 					#if LOG_RECEIVE_ALL				
 					LgiTrace("%s:%i - %i/%s will connect.\n", _FL, a->GetIndex(), desc.Get());
 					#endif
 					Receive(a->GetIndex());
 				}
 				i++;
 			}
 			break;
 		}
 		case IDM_RECEIVE_MAIL:
 		{
 			LVariant Def;
 			if (GetOptions()->GetValue(OPT_Pop3DefAction, Def) && Def.CastInt32() == 0)
 				return OnCommand(IDM_RECEIVE_ALL, 0, NULL);
 
 			Receive(0);
 			break;
 		}
 		case IDM_PREVIEW_POP3:
 		{
 			LArray<ScribeAccount*> Account;
 
 			Accounts.Sort(AccountCmp);
 
 			for (auto a: Accounts)
 			{
 				if (!a->Receive.IsConfigured())
 					continue;
 				
 				auto Protocol = ProtocolStrToEnum(a->Receive.Protocol().Str());
 				if (Protocol == ProtocolPop3)
 				{
 					Account.Add(a);
 					break;
 				}
 			}
 			
 			if (Account.Length() == 1)
 				OpenPopView(this, Account);
 
 			break;
 		}
 
 		case IDM_CALENDAR:
 		{
 			extern void OpenCalender(ScribeFolder *folder);
 
 			ScribeFolder *Folder = GetFolder(FOLDER_CALENDAR);
 			if (Folder)
 			{
 				OpenCalender(Folder);
 			}
 			break;
 		}
 
 		// Contact menu
 		case IDM_NEW_CONTACT:
 		{
 			CreateItem(MAGIC_CONTACT, NULL);
 			break;
 		}
 		case IDM_NEW_GROUP:
 		{
 			CreateItem(MAGIC_GROUP, NULL);
 			break;
 		}
 
 		// Filter menu
 		case IDM_NEW_FILTER:
 		{
 			Thing *t = CreateItem(MAGIC_FILTER, NULL, false);
 			if (t)
 			{
 				t->IsFilter()->SetIncoming(true);
 				t->DoUI();
 			}
 			break;
 		}
 		case IDM_FILTER_CURRENT_FOLDER:
 		{
 			ScribeFolder *Folder = GetCurrentFolder();
 			if (Folder)
 			{
 				List<Filter> Filters;
 				GetFilters(Filters, false, false, true);
 
 				List<Mail> Src;
 				for (auto i: Folder->Items)
 				{
 					if (i->IsMail())
 					{
 						Src.Insert(i->IsMail());
 					}
 				}
 
 				if (!Src[0])
 				{
 					LgiMsg(this, LLoadString(IDS_NO_MAIL_TO_FILTER), AppName);
 				}
 				else
 				{
 					Filter::ApplyFilters(this, Filters, Src);
 				}
 			}
 			break;
 		}
 		case IDM_FILTER_SELECTION:
 		{
 			ScribeFolder *Folder = GetCurrentFolder();
 			if (Folder)
 			{
 				List<Filter> Filters;
 				GetFilters(Filters, false, false, true);
 
 				List<Mail> Src;
 				for (auto i: Folder->Items)
 				{
 					if (i->IsMail() && i->Select())
 					{
 						Src.Insert(i->IsMail());
 					}
 				}
 
 				if (Src.Length())
 				{
 					Filter::ApplyFilters(this, Filters, Src);
 				}
 			}
 			break;
 		}
 		case IDM_DEBUG_FILTERS:
 		{
 			auto i = Menu->FindItem(IDM_DEBUG_FILTERS);
 			if (i)
 			{
 				i->Checked(!i->Checked());
 			}
 			break;
 		}
 		case IDM_HTML_EDITOR:
 		{
 			auto i = Menu->FindItem(IDM_HTML_EDITOR);
 			if (i)
 			{
 				i->Checked(!i->Checked());
 				
 				LVariant v;
 				GetOptions()->SetValue(OPT_EditControl, v = i->Checked() ? 1 : 0);
 			}
 			break;
 		}
 		case IDM_FILTERS_DISABLE:
 		{
 			if (d->DisableUserFilters)
 			{
 				d->DisableUserFilters->Checked(!d->DisableUserFilters->Checked());
 
 				LVariant v;
 				GetOptions()->SetValue(OPT_DisableUserFilters, v = d->DisableUserFilters->Checked());
 			}			
 			break;
 		}
 		case IDM_BUILD_BAYES_DB:
 		{
 			BuildSpamDb();
 			break;
 		}
 		case IDM_BAYES_STATS:
 		{
 			BuildStats();
 			break;
 		}
 		case IDM_BAYES_SETTINGS:
 		{
 			auto Dlg = new BayesDlg(this);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 				{
 					LVariant i;
 					if (GetOptions()->GetValue(OPT_BayesFilterMode, i))
 					{
 						ScribeBayesianFilterMode m = ((ScribeBayesianFilterMode)i.CastInt32());
 						if (m != BayesOff)
 						{
 							LVariant SpamPath, ProbablyPath;
 							GetOptions()->GetValue(OPT_SpamFolder, SpamPath);
 							GetOptions()->GetValue(OPT_BayesMoveTo, ProbablyPath);
 											
 							if (m == BayesFilter)
 							{
 								ScribeFolder *Spam = GetFolder(SpamPath.Str());
 								if (!Spam)
 								{
 							
 									LMailStore *RelevantStore = GetMailStoreForPath(SpamPath.Str());
 									if (RelevantStore)
 									{
 										LString p = SpamPath.Str();
 										LString::Array a = p.SplitDelimit("/");
 									
 										Spam = RelevantStore->Root;
 										for (unsigned i=1; i<a.Length(); i++)
 										{
 											ScribeFolder *c = Spam->GetSubFolder(a[i]);
 											if (!c)
 												c = Spam->CreateSubDirectory(a[i], MAGIC_MAIL);
 											Spam = c;
 										}
 									}
 								}
 							
 								if (Spam)
 								{
 									LVariant v;
 									GetOptions()->SetValue(OPT_HasSpam, v = 1);
 								}
 							}
 							else if (m == BayesTrain)
 							{
 								ScribeFolder *Probably = GetFolder(ProbablyPath.Str());
 								if (!Probably)
 								{
 									LgiMsg(this, "Couldn't find the folder '%s'", AppName, MB_OK, ProbablyPath.Str());
 								}
 							}
 						}
 					}
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_BAYES_CHECK:
 		{
 			List<LListItem> Sel;
 			if (MailList) MailList->GetSelection(Sel);
 
 			for (auto i: Sel)
 			{
 				Thing *t = dynamic_cast<Thing*>(i);
 				if (t)
 				{
 					Mail *m = t->IsMail();
 					if (m)
 					{
 						d->BayesLog.Empty();
 						
 						double SpamRating = 0.0;
 						IsSpam(SpamRating, m, true);
 						break;
 					}
 				}
 			}
 			break;
 		}
 
 		// Tools menu
 		case IDM_SCRIPTING_CONSOLE:
 		case IDM_SHOW_CONSOLE:
 		{
 			ShowScriptingConsole();
 
 			if (d->ShowConsoleBtn)
 				d->ShowConsoleBtn->Image(IMG_CONSOLE_NOMSG);
 			break;
 		}
 		case IDM_EXPORT_TEXT_MBOX:
 		{
 			Export_UnixMBox(this);
 			break;
 		}
 		case IDM_IMPORT_CSV:
 		{
 			ImportCsv(this);
 			break;
 		}
 		case IDM_EXPORT_CSV:
 		{
 			ExportCsv(this);
 			break;
 		}
 		case IDM_IMPORT_EML:
 		{
 			ImportEml(this);
 			break;
 		}
 		case IDM_EXPORT_SCRIBE:
 		{
 			ExportScribe(this, NULL/* default mail store */);
 			break;
 		}
 		case IDM_IMPORT_TEXT_MBOX:
 		{
 			Import_UnixMBox(this);
 			break;
 		}
 		case IDM_IMP_EUDORA_ADDR:
 		{
 			Import_EudoraAddressBook(this);
 			break;
 		}
 		case IDM_IMP_MOZILLA_ADDR:
 		{
 			Import_MozillaAddressBook(this);
 			break;
 		}
 		case IDM_IMP_MOZILLA_MAIL:
 		{
 			Import_MozillaMail(this);
 			break;
 		}
 		#if WINNATIVE
 		case IDM_IMPORT_OUTLOOK_PAB:
 		{
 			Import_OutlookContacts(this);
 			break;
 		}
 		case IDM_IMPORT_OUTLOOK_ITEMS:
 		{
 			Import_Outlook(this, IMP_OUTLOOK);
 			break;
 		}
 		case IDM_EXPORT_OUTLOOK_ITEMS:
 		{
 			Export_Outlook(this);
 			break;
 		}
 		#endif
 		case IDM_IMP_MBX_EMAIL:
 		{
 			Import_OutlookExpress(this, false); // v4
 			break;
 		}
 		case IDM_IMP_DBX_EMAIL:
 		{
 			Import_OutlookExpress(this); // v5
 			break;
 		}
 		case IDM_IMPORT_NS_CONTACTS:
 		{
 			Import_NetscapeContacts(this);
 			break;
 		}
 		case IDM_CHECK_UPDATE:
 		{
 			LVariant v;
 			GetOptions()->GetValue(OPT_SoftwareUpdateIncBeta, v);
 			SoftwareUpdate(this, true, v.CastInt32() != 0, [](auto goingToUpdate)
 			{
 				if (goingToUpdate)
 					LCloseApp();
 			});
 			break;
 		}
 		case IDM_LOGOUT:
 		{
 			CurrentAuthLevel = PermRequireNone; 
 			auto i = Menu->FindItem(IDM_LOGOUT);
 			if (i)
 				i->Enabled(false);
 			break;
 		}
 		case IDM_LAYOUT1:
 		{
 			LVariant v;
 			int TwoThirds = GetClient().Y() >> 1;
 			GetOptions()->SetValue(OPT_SplitterPos, v = 200);
 			GetOptions()->SetValue(OPT_SubSplitPos, v = TwoThirds);
 			SetLayout(FoldersListAndPreview);
 			break;
 		}
 		case IDM_LAYOUT2:
 		{
 			LVariant v;
 			int TwoThirds = GetClient().Y() >> 1;
 			GetOptions()->SetValue(OPT_SplitterPos, v = TwoThirds);
 			GetOptions()->SetValue(OPT_SubSplitPos, v = 200);
 			SetLayout(PreviewOnBottom);
 			break;
 		}
 		case IDM_LAYOUT3:
 		{
 			LVariant v;
 			GetOptions()->SetValue(OPT_SplitterPos, v = 200);
 			SetLayout(FoldersAndList);
 			break;
 		}
 		case IDM_LAYOUT4:
 		{
 			LVariant v;
 			GetOptions()->SetValue(OPT_SplitterPos, v = 200);
 			GetOptions()->SetValue(OPT_SubSplitPos, v);
 			SetLayout(ThreeColumn);
 			break;
 		}
 		case IDM_CRASH:
 		{
 			int *Crash = 0;
 			*Crash = true;
 			break;
 		}
 		case IDM_DUMP_MEM:
 		{
 			LDumpMemoryStats(0);
 			break;
 		}
 		case IDM_SCRIPT_DEBUG:
 		{
 			LVariant v;
 			if (GetOptions())
 				GetOptions()->SetValue(OPT_ScriptDebugger, v = true);
 
 			LVirtualMachine *vm = new LVirtualMachine(d);
 			if (!vm)
 				break;
 
 			LVmDebugger *dbg = vm->OpenDebugger();
 			if (!dbg)
 				break;
 
 			dbg->OwnVm(true);
 			break;
 		}
 		case IDM_SCRIPT_BREAK_ON_WARN:
 		{
 			auto mi = GetMenu()->FindItem(IDM_SCRIPT_BREAK_ON_WARN);
 			if (!mi)
 				break;
 			LVirtualMachine::BreakOnWarning = !mi->Checked();
 			mi->Checked(LVirtualMachine::BreakOnWarning);
 			break;
 		}
 		case IDM_UNIT_TESTS:
 		{
 			#ifdef _DEBUG
 			UnitTests([this](auto ok)
 			{
 				LgiMsg(this, "UnitTest status: %i", AppName, MB_OK, ok);
 			});
 			#endif
 			break;
 		}
 
 		// Help menu
 		case IDM_HELP:
 		{
 			LaunchHelp("index.html");
 			// LgiMsg(this, LLoadString(IDS_ERROR_NO_HELP), AppName, MB_OK);
 			break;
 		}
 		case IDM_FEEDBACK:
 		{
 			LVariant e;
 			if (GetOptions()->GetValue("author", e))
 				CreateMail(0, e.Str());
 			else
 				CreateMail(0, AuthorEmailAddr);
 			break;
 		}
 		case IDM_MEMECODE:
 		{
 			LExecute(AuthorHomepage);
 			break;
 		}
 		case IDM_HOMEPAGE:
 		{
 			LVariant hp;
 			if (GetOptions()->GetValue("homepage", hp))
 				LExecute(hp.Str());
 			else
 				LExecute(ApplicationHomepage);
 			break;
 		}
 		case IDM_VERSION_HISTORY:
 		{
 			LExecute("http://www.memecode.com/site/ver.php?id=445");
 			break;
 		}
 		case IDM_DEBUG_INFO:
 		{
 			char s[256];
 			sprintf_s(s, sizeof(s), "%s#debug", ApplicationHomepage);
 			LExecute(s);
 			break;
 		}
 		case IDM_TUTORIALS:
 		{
 			LExecute("http://www.memecode.com/scribe/tutorials");
 			break;
 		}
 		case IDM_INSCRIBE_LINK:
 		{
 			LExecute(CommercialHomepage);
 			break;
 		}
 		case IDM_SCRIBE_FAQ:
 		{
 			LExecute(FaqHomepage);
 			break;
 		}
 		case IDM_ABOUT:
 		{
 			extern void ScribeAbout(ScribeWnd *Parent);
 			ScribeAbout(this);
 			break;
 		}
 		default:
 		{			
 			if (d->ScriptToolbar)
 				d->ScriptToolbar->ExecuteCallbacks(this, 0, 0, Cmd);
 			break;
 		}
 	}
 
 	return 0;
 }
 
 void ScribeWnd::OnDelete()
 {
 	LVariant ConfirmDelete;
 	GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 	if (!ConfirmDelete.CastInt32() ||
 		LgiMsg(this, LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 	{
 		LArray<LDataI*> Del;
 		
 		if (Tree && Tree->Focus())
 		{
 			ScribeFolder *Item = dynamic_cast<ScribeFolder*>(Tree->Selection());
 			if (Item)
 			{
 				Tree->OnDelete(Item, false);
 			}
 		}
 		else if (MailList
 			#ifdef MAC
 			&& MailList->Focus()
 			#endif
 			)
 		{
 			List<LListItem> Sel;
 			MailList->GetSelection(Sel);
 
 			for (auto i: Sel)
 			{
 				Thing *t = dynamic_cast<Thing*>(i);
 				if (t)
 					Del.Add(t->GetObject());
 			}
 
 			if (Del.Length())
 			{
 				auto Store = Del[0]->GetStore();
 				Store->Delete(Del, true);
 			}
 			else LgiTrace("%s:%i - Nothing to delete\n", _FL);
 
 			#ifndef MAC
 			MailList->Focus(true);
 			#endif
 		}
 	}
 }
 
 int ScribeWnd::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_THING_LIST:
 		{
 			if (n.Type == LNotifyReturnKey)
 			{
 				LListItem *i = MailList ? MailList->GetSelected() : 0;
 				Thing *t = dynamic_cast<Thing*>(i);
 				if (t)
 				{
 					t->DoUI();
 				}
 			}
 			else if (n.Type == LNotifyDeleteKey)
 			{
 				/* This is now handled by the menu
 				OnDelete();
 				return true;
 				*/
 			}
 			
 			if (SearchView &&
 				MailList)
 			{
 				SearchView->OnNotify(Ctrl, n);
 			}
 			break;
 		}
 		case IDC_TEXT:
 		{
 			if (PreviewPanel)
 			{
 				PreviewPanel->OnNotify(Ctrl, n);
 			}
 			break;
 		}
 	}
 
 	return 0;
 }
 
 void ScribeWnd::AddThingSrc(ScribeFolder *src)
 {
 	if (!d->ThingSources.HasItem(src))
 		d->ThingSources.Add(src);
 }
 
 void ScribeWnd::RemoveThingSrc(ScribeFolder *src)
 {
 	d->ThingSources.Delete(src);
 }
 
 LArray<ScribeFolder*> ScribeWnd::GetThingSources(Store3ItemTypes Type)
 {
 	LArray<ScribeFolder*> a;
 	for (auto f: d->ThingSources)
 	{
 		if (f->GetItemType() == Type &&
 			!f->IsInTrash())
 		{
 			a.Add(f);
 		}
 	}
 	return a;
 }
 
 bool ScribeWnd::LogFilterActivity()
 {
 	auto i = Menu->FindItem(IDM_DEBUG_FILTERS);
 	return i ? i->Checked() : false;
 }
 
 bool ScribeWnd::CreateFolders(LAutoString &FileName)
 {
 	bool Status = false;
 
 	if (FileName)
 	{
 		char *Ext = LGetExtension(FileName);
 		if (!Ext)
 		{
 			char File[300];
 			strcpy_s(File, sizeof(File), FileName);
 			strcat(File, ".mail3");
 			FileName.Reset(NewStr(File));
 		}
 
 		// Create objects, and then close the file.. it'll be reloaded later
 		LAutoPtr<LDataStoreI> m(CreateDataStore(FileName, true));
 		if (m)
 		{
 			m->GetRoot(true);
 			Status = true;
 		}
 		else LgiTrace("%s:%i - CreateDataStore failed.\n", _FL);
 	}
 	else LgiTrace("%s:%i - No file name for CreateFolder.\n", _FL);
 
 	return Status;
 }
 
 bool ScribeWnd::CompactFolders(LMailStore &Store, bool Interactive)
 {
 	if (!Store.Store)
 		return false;
 
 	auto Dlg = new Store3Progress(this, Interactive);
 
 	Dlg->SetDescription(LLoadString(IDS_CHECKING_OBJECTS));
 
 	bool Offline = false;
 	if (WorkOffline)
 	{
 		Offline = WorkOffline->Checked();
 		WorkOffline->Checked(true);
 	}
 
 	Store.Store->Compact(this, Dlg, [this, Offline, Dlg](auto status)
 	{
 		LAssert(InThread());
 
 		if (WorkOffline)
 			WorkOffline->Checked(Offline);
 
 		delete Dlg;
 	});
 
 	return true;
 }
 
 CalendarSource *CalendarSource::Create(ScribeWnd *App, const char *ObjName, const char *Id)
 {
 	if (!Stricmp(ObjName, "RemoteCalendarSource"))
 		return new RemoteCalendarSource(App, Id);
 	return new FolderCalendarSource(App, Id);
 }
 
 int ScribeWnd::GetCalendarSources(LArray<CalendarSource*> &Out)
 {
 	static bool Loaded = false;
 
 	if (!Loaded)
 	{
 		Loaded = true;
 		CalendarSource::SetCreateIn(NULL);
 
 		LVariant Create;
 		GetOptions()->GetValue(OPT_CalendarCreateIn, Create);
 
 		// This should be a list of all calendar folders in ANY mail store...
 		auto CalFlds = GetThingSources(MAGIC_CALENDAR);
 
 		LXmlTag *t = GetOptions()->LockTag(OPT_CalendarSources, _FL);
 		if (t)
 		{
 			bool AutoPopulate = t->Children.Length() == 0;
 
 			for (auto c: t->Children)
 			{
 				auto s = CalendarSource::Create(this,
 												c->GetAttr(CalendarSource::OptObject),
 												c->GetTag());
 				if (s && s->Read())
 				{
 					// Add known source...
 					if (!Stricmp(Create.Str(), c->GetTag()))
 					{
 						CalendarSource::SetCreateIn(s);							
 					}
 
 					// Remove from CalFlds
 					FolderCalendarSource *Fcs = dynamic_cast<FolderCalendarSource*>(c);
 					if (Fcs)
 					{
 						auto Path = Fcs->GetPath();
 						for (auto c: CalFlds)
 						{
 							if (c->GetPath().Equals(Path))
 							{
 								CalFlds.Delete(c);
 								break;
 							}
 						}
 					}
 				}
 			}
 
 			if (AutoPopulate)
 			{
 				// Now CalFlds should be a list of all calendar folders NOT in the source XML tag
 				for (auto c: CalFlds)
 				{
 					FolderCalendarSource *s = new FolderCalendarSource(this);
 					if (s)
 					{
 						// So add an entry to track it...
 						auto Path = c->GetPath();
 						s->SetPath(Path);
 						s->SetDisplay(true);
 						s->SetColour(CalendarSource::FindUnusedColour());
 						s->Write();
 					}
 				}
 			}
 		
 			GetOptions()->Unlock();
 		}
 
 		if (!CalendarSource::GetCreateIn() &&
 			CalendarSource::GetSources().Length())
 		{
 			CalendarSource::SetCreateIn(CalendarSource::GetSources().ItemAt(0));
 		}
 	}
 
 	for (unsigned i=0; i<CalendarSource::GetSources().Length(); i++)
 		Out.Add(CalendarSource::GetSources().ItemAt(i));
 	return (int)Out.Length();
 }
 
 int ScribeWnd::GetFolderType(ScribeFolder *f)
 {
 	if (!f)
 		return -1;
 
 	for (SystemFolderInfo *fi = SystemFolders; fi->PathOption; fi++)
 	{
 		bool Check = true;
 		if (fi->HasOption)
 		{
 			LVariant v;
 			if (GetOptions()->GetValue(fi->HasOption, v))
 				Check = v.CastInt32() != 0;
 		}
 		if (Check)
 		{		
 			ScribeFolder *c = GetFolder(fi->Id);
 			if (c == f)
 				return fi->Id;
 		}
 	}
 
 	return -1;
 }
 
 ScribeFolder *ScribeWnd::GetCurrentFolder()
 {
 	if (Tree)
 	{
 		auto *Item = Tree->Selection();
 		if (Item)
 		{
 			return dynamic_cast<ScribeFolder*>(Item);
 		}
 	}
 
 	return 0;
 }
 
 bool ScribeWnd::GetSystemPath(int Folder, LVariant &Path)
 {
 	char KeyName[64];
 	sprintf_s(KeyName, sizeof(KeyName), "Folder-%i", Folder);
 	return GetOptions()->GetValue(KeyName, Path);
 }
 
 LMailStore *ScribeWnd::GetMailStoreForIdentity(const char *IdEmail)
 {
 	LVariant Tmp;
 	if (!IdEmail)
 	{
 		// Get current identity
 		ScribeAccount *Cur = GetCurrentAccount();
 		if (Cur)
 		{
 			Tmp = Cur->Identity.Email();
 			IdEmail = Tmp.Str();
 		}
 	}
 	
 	if (!IdEmail)
 		return NULL;
 	
 	ScribeAccount *a = NULL;
 	for (auto Acc : Accounts)
 	{
 		LVariant e = Acc->Identity.Email();
 		if (e.Str() && !_stricmp(e.Str(), IdEmail))
 		{
 			a = Acc;
 			break;
 		}
 	}
 	if (!a)
 		return NULL;
 
 	LVariant DestPath = a->Receive.DestinationFolder();
 	if (!DestPath.Str())
 		return NULL;
 	
 	return GetMailStoreForPath(DestPath.Str());
 }
 
 ScribeFolder *ScribeWnd::GetFolder(int Id, LDataI *s)
 {
 	if (s)
 	{
 		for (auto &f: Folders)
 			if (s->GetStore() == f.Store)
 				return GetFolder(Id, &f);
 	}
 
 	return GetFolder(Id);
 }
 
 ScribeFolder *ScribeWnd::GetFolder(int Id, LMailStore *Store, bool Quiet)
 {
 	char KeyName[64];
 	sprintf_s(KeyName, sizeof(KeyName), "Folder-%i", Id);
 	LVariant FolderName;
 	bool NoOption = false;
 
 	if (GetOptions()->GetValue(KeyName, FolderName))
 	{
 		if (ValidStr(FolderName.Str()) &&
 			strlen(FolderName.Str()) > 0)
 		{
 			ScribeFolder *c = GetFolder(FolderName.Str(), Store);
 			if (c)
 			{
 				return c;
 			}
 			else if (!Quiet)
 			{
 				LgiTrace("%s:%i - '%s' doesn't exist.\n",
 					_FL, FolderName.Str());
 			}
 		}
 	}
 	else if (!Quiet)
 	{
 		// LgiTrace("%s:%i - No option '%s'\n", _FL, KeyName);
 		NoOption = true;
 	}
 
 	switch (Id)
 	{
 		case FOLDER_INBOX:
 		case FOLDER_OUTBOX:
 		case FOLDER_SENT:
 		case FOLDER_TRASH:
 		case FOLDER_CONTACTS:
 		case FOLDER_TEMPLATES:
 		case FOLDER_FILTERS:
 		case FOLDER_CALENDAR:
 		case FOLDER_GROUPS:
 		case FOLDER_SPAM:
 		{
 			ScribeFolder *c = GetFolder(DefaultFolderNames[Id], Store);
 			if (!c)
 			{
 				// if (!Quiet)
 				// LgiTrace("%s:%i - Default folder '%s' doesn't exist.\n", _FL, DefaultFolderNames[Id]);
 			}
 			else if (NoOption)
 			{
 				auto p = c->GetPath();
 				GetOptions()->SetValue(KeyName, FolderName = p.Get());
 			}
 			return c;
 		}
 	}
 
 	return NULL;
 }
 
 bool ScribeWnd::OnMailStore(LMailStore **MailStore, bool Add)
 {
 	if (!MailStore)
 	{
 		LAssert(!"No mail store pointer?");
 		return false;
 	}
 	
 	if (Add)
 	{
 		*MailStore = &Folders.New();
 		if (*MailStore)
 			return true;
 	}
 	else
 	{
 		ssize_t Idx = *MailStore - &Folders[0];
 		if (Idx >= 0 && Idx < (ssize_t)Folders.Length())
 		{
 			Folders.DeleteAt(Idx, true);
 			*MailStore = NULL;
 			return true;
 		}
 		else
 		{
 			LAssert(!"Index out of range.");
 		}
 	}
 	
 	return false;
 }
 
 LMailStore *ScribeWnd::GetMailStoreForPath(const char *Path)
 {
 	if (!Path)
 		return NULL;
 
 	auto t = LString(Path).SplitDelimit("/");
 	if (t.Length() > 0)
 	{
 		const char *First = t[0];
 		
 		// Find the mail store that that t[0] refers to
 		for (unsigned i=0; i<Folders.Length(); i++)
 		{
 			if (Folders[i].IsOk())
 			{
 				const char *RootStr = Folders[i].Root->GetText();
 				if (RootStr && !_stricmp(RootStr, First))
 				{
 					return &Folders[i];
 				}
 			}
 		}
 	}
 	
 	return NULL;
 }
 
 ScribeFolder *ScribeWnd::GetFolder(const char *Name, LMailStore *s)
 {
 	ScribeFolder *Folder = 0;
 
 	if (ValidStr(Name))
 	{
 		LString Sep("/");
 		auto t = LString(Name).Split(Sep);
 		LMailStore tmp;
 		LString TmpName;
 
 		if (t.Length() > 0)
 		{
 			if (!s)
 			{
 				s = GetMailStoreForPath(Name);
 				if (!s)
 				{
 					// IMAP folders?
 					for (auto a: Accounts)
 					{
 						ScribeProtocol Proto = a->Receive.ProtocolType();
 						if (Proto == ProtocolImapFull)
 						{
 							ScribeFolder *Root = a->Receive.GetRootFolder();
 							if (Root)
 							{
 								const char *RootStr = Root->GetText();
 								if (RootStr &&
 									a->Receive.GetDataStore() &&
 									!_stricmp(RootStr, t[0]))
 								{
 									tmp.Root = Root;
 									tmp.Store = a->Receive.GetDataStore();
 									s = &tmp;
 									break;
 								}
 							}
 						}
 					}
 				}
 				if (s)
 				{
 					if (*Name == '/') Name++;
 					Name = strchr(Name, '/');
 					if (!Name)
 						Name = "/";
 				}
 			}
 			else if (s->Root)
 			{
 				// Check if the store name is on the start of the folder
 				auto RootName = s->Root->GetName(true);
 				if (RootName.Equals(t[0]))
 				{
 					LString::Array a;
 					for (unsigned i=1; i<t.Length(); i++)
 					{
 						a.New() = t[i];
 					}
 					TmpName = Sep.Join(a);
 					Name = TmpName;
 				}
 			}
 		}
 
 		if (!s)
 		{
 			s = GetDefaultMailStore();
 		}
 
 		if (s && Name)
 		{
 			if (_stricmp(Name, "/") == 0)
 				return s->Root;
 		
 			Folder = s->Root ? s->Root->GetSubFolder(Name) : 0;
 		}
 	}
 
 	return Folder;
 }
 
 void ScribeWnd::Update(int What)
 {
 	if (What & UPDATE_TREE)
 	{
 		Tree->Invalidate();
 		return;
 	}
 
 	if (What & UPDATE_LIST)
 	{
 		if (MailList) MailList->Invalidate();
 		return;
 	}
 }
 
 void ScribeWnd::DoDebug(char *s)
 {
 }
 
 Thing *ScribeWnd::CreateThingOfType(Store3ItemTypes Type, LDataI *obj)
 {
 	Thing *t = NULL;
 	switch (Type)
 	{
 		case MAGIC_CONTACT:
 		{
 			t = new Contact(this, obj);
 			break;
 		}
 		case MAGIC_MAIL:
 		{
 			t = new Mail(this, obj);
 			break;
 		}
 		case MAGIC_ATTACHMENT:
 		{
 			t = new Attachment(this, obj);
 			break;
 		}
 		case MAGIC_FILTER:
 		{
 			t = new Filter(this, obj);
 			break;
 		}
 		case MAGIC_CALENDAR:
 		{
 			t = new Calendar(this, obj);
 			break;
 		}
 		case MAGIC_GROUP:
 		{
 			t = new ContactGroup(this, obj);
 			break;
 		}
 		default:
 			break;
 	}
 
 	if (t)
 	{
 		t->App = this;
 	}
 
 	return t;
 }
 
 void ScribeWnd::GetFilters(List<Filter> &Filters, bool JustIn, bool JustOut, bool JustInternal)
 {
 	auto Srcs = GetThingSources(MAGIC_FILTER);
 	for (auto f: Srcs)
 	{
 		for (auto t: f->Items)
 		{
 			Filter *Ftr = t->IsFilter();
 			if (Ftr)
 			{
 				if (JustIn && !Ftr->GetIncoming())
 					continue;
 
 				if (JustOut && !Ftr->GetOutgoing())
 					continue;
 				
 				if (JustInternal && !Ftr->GetInternal())
 					continue;
 
 				Filters.Insert(Ftr);
 			}
 		}
 	}
 
 	extern int FilterCompare(Filter *a, Filter *b, NativeInt Data);
 	Filters.Sort(FilterCompare);
 }
 
 bool ScribeWnd::ShowToolbarText()
 {
 	LVariant i;
 	if (GetOptions()->GetValue(OPT_ToolbarText, i))
 	{
 		return i.CastInt32() != 0;
 	}
 
 	GetOptions()->SetValue(OPT_ToolbarText, i = true);
 	return true;
 }
 
 void ScribeWnd::HashContacts(LHashTbl<StrKey<char,false>,Contact*> &Contacts, ScribeFolder *Folder, bool Deep)
 {
 	if (!Folder)
 	{
 		// Default item is the contacts folder
 		Folder = GetFolder(FOLDER_CONTACTS);
 
 		// Also look at all the contact sources...
 		auto Srcs = GetThingSources(MAGIC_CONTACT);
 		for (auto Src: Srcs)
 		{
 			for (auto t: Src->Items)
 			{
 				Contact *c = t->IsContact();
 				if (!c)
 					continue;
 
 				auto emails = c->GetEmails();
 				for (auto e: emails)
 				{
 					if (!Contacts.Find(e))
 						Contacts.Add(e, c);
 				}
 			}
 		}
 	}
 
 	// recurse through each folder and make a list
 	// of every contact object we find.
 	if (Folder)
 	{
 		Folder->LoadThings();
 
 		for (auto t: Folder->Items)
 		{
 			Contact *c = t->IsContact();
 			if (c)
 			{
 				auto Emails = c->GetEmails();
 				for (auto e: Emails)
 					if (e && !Contacts.Find(e))
 						Contacts.Add(e, c);
 			}
 		}
 
 		for (auto f = Folder->GetChildFolder(); Deep && f; f = f->GetNextFolder())
 		{
 			HashContacts(Contacts, f, Deep);
 		}
 	}
 }
 
 List<Contact> *ScribeWnd::GetEveryone()
 {
 	return &Contact::Everyone;
 }
 
 bool ScribeWnd::GetContacts(List<Contact> &Contacts, ScribeFolder *Folder, bool Deep)
 {
 	LArray<ScribeFolder*> Folders;
 
 	if (!Folder)
 	{
 		Folders = GetThingSources(MAGIC_CONTACT);
 		auto f = GetFolder(FOLDER_CONTACTS);
 		if (f && !Folders.HasItem(f))
 			Folders.Add(f);
 	}
 	else
 		Folders.Add(Folder);
 
 	if (!Folders.Length())
 		return false;
 
 	for (auto f: Folders)
 	{
 		// recurse through each folder and make a list
 		// of every contact object we find.
 		ScribePerm Perm = f->GetFolderPerms(ScribeReadAccess);
 		bool Safe = CurrentAuthLevel >= Perm;
 		if (Safe)
 		{
 			f->LoadThings();
 	
 			for (auto t: f->Items)
 			{
 				Contact *c = t->IsContact();
 				if (c)
 					Contacts.Insert(c);
 			}
 
 			for (ScribeFolder *c = f->GetChildFolder(); Deep && c; c = c->GetNextFolder())
 				GetContacts(Contacts, c, Deep);
 		}
 	}
 	
 	return true;
 }
 
 /*
 	This function goes through the database and checks for some
 	basic requirements and fixes things up if they aren't ok.
 */
 bool ScribeWnd::ValidateFolder(LMailStore *s, int Id)
 {
 	char OptName[32];
 	sprintf_s(OptName, sizeof(OptName), "Folder-%i", Id);
 	
 	LVariant Path;
 	if (!GetOptions()->GetValue(OptName, Path))
 	{
 		char Opt[256];
 		sprintf_s(Opt, sizeof(Opt), "/%s", DefaultFolderNames[Id]);
 		GetOptions()->SetValue(OptName, Path = Opt);
 	}
 	
 	// If the path name has the store name at the start, strip that off...
 	LString Sep("/");
 	LString::Array Parts = LString(Path.Str()).Split(Sep);
 	if (Parts.Length() > 1)
 	{
 		if (Parts[0].Equals(s->Name))
 		{
 			Parts.DeleteAt(0, true);
 			Path = Sep.Join(Parts);
 		}
 		else
 		{
 			LMailStore *ms = GetMailStoreForPath(Path.Str());
 			if (ms)
 			{
 				s = ms;
 			}
 			else
 			{
 				// Most likely the user has renamed something and broken the
 				// path. Lets just error out instead of creating the wrong folder
 				return false;
 			}			
 		}
 	}
 	
 	// Now resolve the path...
 	ScribeFolder *Folder = GetFolder(Path.Str(), s);
 	if (!Folder)
 	{
 		char *p = Path.Str();
 		if (_strnicmp(p, "/IMAP ", 6) != 0)
 		{
 			LAssert(DefaultFolderTypes[Id] != MAGIC_NONE);
 			Folder = s->Root->CreateSubDirectory(*p=='/'?p+1:p, DefaultFolderTypes[Id]);
 		}
 	}
 	
 	if (!Folder)
 		return false;
 
 	Folder->SetDefaultFields();
 	return true;
 }
 
 void ScribeWnd::Validate(LMailStore *s)
 {
 	// Check for all the basic folders
 
 	int Errors = 0;	
 	for (SystemFolderInfo *fi = SystemFolders; fi->PathOption; fi++)
 	{
 		bool Check = true;
 		if (fi->HasOption)
 		{
 			LVariant v;
 			if (GetOptions()->GetValue(fi->HasOption, v))
 				Check = v.CastInt32() != 0;
 		}
 		if (Check)
 		{
 			if (!ValidateFolder(s, fi->Id))
 				Errors++;
 		}
 	}
 
 	if (Errors &&
 		LgiMsg(this,
 				"There were errors validating the system folders."
 				"Would you like to review the mail store's system folder paths?",
 				AppName,
 				MB_YESNO) == IDYES)
 	{
 		PostEvent(M_COMMAND, IDM_MANAGE_MAIL_STORES);
 	}
 }
 
 ThingFilter *ScribeWnd::GetThingFilter()
 {
 	return SearchView;
 }
 
 ScribeAccount *ScribeWnd::GetSendAccount()
 {
 	LVariant DefSendAcc = 0;
 
 	if (!GetOptions()->GetValue(OPT_DefaultSendAccount, DefSendAcc))
 	{
 		for (auto a : Accounts)
 			if (a->Send.Server().Str())
 				return a;
 	}
 
 	ScribeAccount *i = Accounts.ItemAt(DefSendAcc.CastInt32());
 	if (i && i->Send.Server().Str())
 		return i;
 
 	return NULL;
 }
 
 LPrinter *ScribeWnd::GetPrinter()
 {
 	if (!d->PrintOptions)
 		d->PrintOptions.Reset(new LPrinter);
 	return d->PrintOptions;
 }
 
 int ScribeWnd::GetActiveThreads()
 {
 	int Status = 0;
 	for (auto i: Accounts)
 	{
 		if (i->IsOnline())
 		{
 			Status++;
 		}
 	}
 	return Status;
 }
 
 class DefaultClientDlg : public LDialog
 {
 public:
 	bool DontWarn;
 	DefaultClientDlg(LView *parent)
 	{
 		DontWarn = false;
 		SetParent(parent);
 		LoadFromResource(IDD_WARN_DEFAULT);
 		MoveToCenter();
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case ID_YES:
 			case ID_NO:
 			{
 				LCheckBox *DW;
 				if (GetViewById(IDC_DONT_WARN, DW))
 				{
 					DontWarn = DW->Value() != 0;
 				}
 				EndModal(Ctrl->GetId() == ID_YES);
 				break;
 			}
 		}
 		return 0;
 	}
 
 };
 
 #if WINNATIVE
 struct DefaultClient
 {
 	char DefIcon[MAX_PATH_LEN];
 	char CmdLine[MAX_PATH_LEN];
 	char DllPath[MAX_PATH_LEN];
 
 	DefaultClient()
 	{
 		auto Exe = LGetExeFile();
 		sprintf_s(DefIcon, sizeof(DefIcon), "%s,1", Exe.Get());
 		sprintf_s(CmdLine, sizeof(CmdLine), "\"%s\" /m \"%%1\"", Exe.Get());
 		LMakePath(DllPath, sizeof(DllPath), Exe, "../ScribeMapi.dll");
 	}
 	
 	bool IsWindowsXp()
 	{
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		if
 		(
 			(
 				Os == LGI_OS_WIN32
 				||
 				Os == LGI_OS_WIN64
 			)
 			&&
 			Ver.Length() > 1
 			&&
 			Ver[0] == 5
 			&&
 			Ver[1] == 1
 		)
 			return true;
 		
 		return false;
 	}
 	
 	bool InstallMailto(bool Write)
 	{
 		LAutoPtr<LRegKey> mailto = CheckKey(Write, "HKCR\\mailto");
 		if (!mailto)
 			return false;
 		if (!CheckString(Write, mailto, NULL, "URL:MailTo Protocol"))
 			return false;
 		
 		LAutoPtr<LRegKey> deficon = CheckKey(Write, "HKCR\\mailto\\DefaultIcon");
 		if (!deficon)
 			return false;
 		if (!CheckString(Write, deficon, NULL, DefIcon))
 			return false;
 
 		LAutoPtr<LRegKey> shell = CheckKey(Write, "HKCR\\mailto\\shell");
 		if (!shell)
 			return false;
 		if (!CheckString(Write, shell, NULL, "open"))
 			return false;
 			
 		LAutoPtr<LRegKey> cmd = CheckKey(Write, "HKCR\\mailto\\shell\\open\\command");
 		if (!cmd)
 			return false;
 		if (!CheckString(Write, cmd, NULL, CmdLine))
 			return false;
 		
 			
 		return true;
 	}
 
 	LAutoPtr<LRegKey> CheckKey(bool Write, const char *Key, ...) const
 	{
 		char Buffer[512];
 		va_list Arg;
 		va_start(Arg, Key);
 		vsprintf_s(Buffer, sizeof(Buffer), Key, Arg);
 		va_end(Arg);
 		
 		LAutoPtr<LRegKey> k(new LRegKey(Write, Buffer));
 		if (k && Write && !k->IsOk())
 		{
 			if (!k->Create())
 			{
 				k.Reset();
 				LgiTrace("%s:%i - Failed to create '%s'\n", _FL, Buffer);
 			}
 		}
 		
 		return k;
 	}
 
 	bool CheckInt(bool Write, LRegKey *k, const char *Name, uint32_t Value)
 	{
 		if (!k)
 		{
 			LgiTrace("%s:%i - No key: '%s'\n", _FL, Name);
 			return false;
 		}
 
 		uint32_t Cur;
 		if (!k->GetInt(Name, Cur))
 			Cur = Value + 1;
 		
 		if (Cur == Value)
 			return true;
 
 		if (Write)
 		{
 			bool Status = k->SetInt(Name, Value);
 			if (!Status)
 				LgiTrace("%s:%i - Failed to set key '%s': '%s' to %i\n", _FL, k->Name(), Name, Value);
 			return Status;
 		}
 		
 		return false;
 	}
 	
 	bool CheckString(bool Write, LRegKey *k, const char *StrName, const char *StrValue)
 	{
 		if (!k)
 		{
 			LgiTrace("%s:%i - No key: '%s' to '%s'\n", _FL, StrName, StrValue);
 			return false;
 		}
 
 		LString v;
 		if (k->GetStr(StrName, v))
 		{
 			bool Same = Stricmp(v.Get(), StrValue) == 0;
 			if (Write && !Same)
 			{
 				bool Status = k->SetStr(StrName, StrValue);
 				if (!Status)
 					LgiTrace("%s:%i - Failed to set key '%s': '%s' to '%s'\n", _FL, k->Name(), StrName, StrValue);
 				return Status;
 			}
 			
 			return Same;
 		}
 		else if (Write)
 		{
 			bool Status = k->SetStr(StrName, StrValue);
 			if (!Status)
 				LgiTrace("%s:%i - Failed to set key '%s': '%s' to '%s'\n", _FL, k->Name(), StrName, StrValue);
 			return Status;
 		}
 		
 		return false;
 	}
 
 	bool IsDefault()
 	{
 		LAutoPtr<LRegKey> mail = CheckKey(false, "HKCU\\Software\\Clients\\Mail");
 		if (!mail)
 			return false;
 		
 		LString v;
 		if (!mail->GetStr(NULL, v))
 			return false;
 		
 		return !_stricmp(v, "Scribe");
 	}
 
 	bool SetDefault() const
 	{
 		LAutoPtr<LRegKey> mail = CheckKey(true, "HKCU\\Software\\Clients\\Mail");
 		if (!mail)
 			return false;
 			
 		// Set the default client in the current user tree.
 		mail->SetStr(NULL, "Scribe");
 
 		// Configure the mailto handler
 		const char *Base = "HKEY_ROOT";
 		bool Error = false;
 		LRegKey Mt(true, "%s\\mailto", Base);
 		if (Mt.IsOk() || Mt.Create())
 		{
 			if (!Mt.SetStr(0, "URL:MailTo Protocol") ||
 				!Mt.SetStr("URL Protocol", ""))
 				Error = true;
 		}
 		else
 		{
 			LgiTrace("%s:%i - Couldn't open/create registry key (err=%i).\n", _FL, GetLastError());
 			Error = true;
 		}
 
 		LRegKey Di(true, "%s\\mailto\\DefaultIcon", Base);
 		if (Di.IsOk() || Di.Create())
 		{
 			if (!Di.SetStr(0, DefIcon))
 				Error = true;
 		}
 		else
 		{
 			LgiTrace("%s:%i - Couldn't open/create registry key (err=%i).\n", _FL, GetLastError());
 			Error = true;
 		}
 
 		LRegKey c(true, "%s\\mailto\\shell\\open\\command", Base);
 		if (c.IsOk() || c.Create())
 		{
 			if (!c.SetStr(NULL, CmdLine))
 				Error = true;
 		}
 		else
 		{
 			LgiTrace("%s:%i - Couldn't open/create registry key (err=%i).\n", _FL, GetLastError());
 			Error = true;
 		}
 		
 		return Error;
 	}
 
 	bool InstallAsClient(char *Base, bool Write)
 	{
 		// Create software client entry, to put Scribe in the Internet Options for mail clients.
 		LAutoPtr<LRegKey> mail = CheckKey(Write, "%s\\Software\\Clients\\Mail", Base);
 		if (!mail)
 			return false;
 
 		LAutoPtr<LRegKey> app = CheckKey(Write, "%s\\Software\\Clients\\Mail\\Scribe", Base);
 		if (!app)
 			return false;
 		if (!CheckString(Write, app, NULL, AppName))
 			return false;
 		if (!CheckString(Write, app, "DllPath", DllPath))
 			return false;
 
 		LAutoPtr<LRegKey> shell = CheckKey(Write, "%s\\Software\\Clients\\Mail\\Scribe\\shell\\open\\command", Base);
 		if (!shell)
 			return false;
 		if (!CheckString(Write, shell, NULL, CmdLine))
 			return false;
 
 		LAutoPtr<LRegKey> icon = CheckKey(Write, "%s\\Software\\Clients\\Mail\\Scribe\\DefaultIcon", Base);
 		if (!icon)
 			return false;
 		if (!CheckString(Write, icon, NULL, DefIcon))
 			return false;
 
 		LAutoPtr<LRegKey> proto = CheckKey(Write, "%s\\Software\\Classes\\Protocol\\mailto", Base);
 		if (!proto)
 			return false;
 		if (!CheckString(Write, proto, NULL, "URL:MailTo Protocol"))
 			return false;
 		if (!CheckString(Write, proto, "URL Protocol", ""))
 			return false;
 		if (!CheckInt(Write, proto, "EditFlags", 0x2))
 			return false;
 
 		LAutoPtr<LRegKey> proto_cmd = CheckKey(Write, "%s\\Software\\Classes\\Protocol\\mailto\\shell\\open\\command", Base);
 		if (!proto_cmd)
 			return false;
 		if (!CheckString(Write, proto_cmd, NULL, CmdLine))
 			return false;
 		
 		return true;
 	}
 	
 	struct FileType
 	{
 		char *Name;
 		char *Desc;
 		int Icon;
 	};
 	
 	static FileType FileTypes[];
 	
 	bool Win7Install(bool Write)
 	{
 		// http://msdn.microsoft.com/en-us/library/windows/desktop/cc144154%28v=vs.85%29.aspx
 		LArray<int> Ver;
 		int Os = LGetOs(&Ver);
 		if
 		(
 			(
 				Os == LGI_OS_WIN32
 				||
 				Os == LGI_OS_WIN64
 			)
 			&&
 			Ver[0] >= 6)
 		{
 			char Path[MAX_PATH_LEN];
 			auto Exe = LGetExeFile();
 
 			for (int i=0; FileTypes[i].Name; i++)
 			{
 				LAutoPtr<LRegKey> base = CheckKey(Write, "HKEY_CLASSES_ROOT\\%s", FileTypes[i].Name);
 				if (!base)
 					return false;
 				if (!CheckString(Write, base, NULL, FileTypes[i].Desc))
 					return false;
 
 				LAutoPtr<LRegKey> r = CheckKey(Write, "HKEY_CLASSES_ROOT\\%s\\shell\\Open\\command", FileTypes[i].Name);
 				if (!r)
 					return false;
 				sprintf_s(Path, sizeof(Path), "\"%s\" -u \"%%1\"", Exe.Get());
 				if (!CheckString(Write, r, NULL, Path))
 					return false;
 
 				LAutoPtr<LRegKey> ico = CheckKey(Write, "HKEY_CLASSES_ROOT\\%s\\DefaultIcon", FileTypes[i].Name);
 				if (!ico)
 					return false;
 				sprintf_s(Path, sizeof(Path), "%s,%i", Exe.Get(), FileTypes[i].Icon);
 				if (!CheckString(Write, ico, NULL, Path))
 					return false;
 			}
 			
 			LAutoPtr<LRegKey> r = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities");
 			if (!r)
 				return false;
 			if (!CheckString(Write, r, "ApplicationDescription", "Scribe is a small lightweight email client.") &&
 				!CheckString(Write, r, "ApplicationName", "Scribe") &&
 				!CheckString(Write, r, "ApplicationIcon", DefIcon))
 				return false;
 			
 			LAutoPtr<LRegKey> as = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities\\FileAssociations");
 			if (!as)
 				return false;
 			if (!CheckString(Write, as, ".eml", "Scribe.Email") &&
 				!CheckString(Write, as, ".msg", "Scribe.Email") &&
 				!CheckString(Write, as, ".mbox", "Scribe.Folder") &&
 				!CheckString(Write, as, ".mbx", "Scribe.Folder") &&
 				!CheckString(Write, as, ".ics", "Scribe.Calendar") &&
 				!CheckString(Write, as, ".vcs", "Scribe.Calendar") &&
 				!CheckString(Write, as, ".vcf", "Scribe.Contact") &&
 				!CheckString(Write, as, ".mail3", "Scribe.MailStore"))
 				return false;
 
 			LAutoPtr<LRegKey> ua = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities\\UrlAssociations");
 			if (!ua)
 				return false;
 			if (!CheckString(Write, ua, "mailto", "Scribe.Mailto"))
 				return false;
 			
 			LAutoPtr<LRegKey> a = CheckKey(Write, "HKEY_LOCAL_MACHINE\\SOFTWARE\\RegisteredApplications");
 			if (!a)
 				return false;
 			if (!CheckString(Write, a, "Scribe", "SOFTWARE\\Clients\\Mail\\Scribe\\Capabilities"))
 				return false;
 		}
 		
 		return true;
 	}
 
 	void Win7Uninstall()
 	{
 		for (int i=0; FileTypes[i].Name; i++)
 		{
 			LRegKey base(true, "HKEY_CLASSES_ROOT\\%s", FileTypes[i].Name);
 			base.DeleteKey();
 		}
 	}
 };
 
 DefaultClient::FileType DefaultClient::FileTypes[] =
 {
 	{ "Scribe.Email", "Email", 2 },
 	{ "Scribe.Folder", "Mailbox", 0 },
 	{ "Scribe.Calendar", "Calendar Event", 6 },
 	{ "Scribe.Contact", "Contact", 4 },
 	{ "Scribe.MailStore", "Mail Store", 0 },
 	{ "Scribe.Mailto", "Mailto Protocol", 0 },
 	{ 0, 0 }
 };
 #endif
 
 void ScribeWnd::SetDefaultHandler()
 {
 	#if WINNATIVE
 
 	if (LAppInst->GetOption("noreg"))
 		return;
 		
 	LVariant RegisterClient;
 	if (!GetOptions()->GetValue(OPT_RegisterWindowsClient, RegisterClient))
 		RegisterClient = true;
 	
 	if (!RegisterClient.CastInt32())
 		return;
 
 	// Create IE mail client entries for local machine and current user
 	DefaultClient Def;
 	bool OldAssert = LRegKey::AssertOnError;
 	LRegKey::AssertOnError = false;
 	bool RegistryOk =	(
 							!Def.IsWindowsXp()
 							||
 							Def.InstallMailto(true)
 						)
 						&&
 						Def.InstallAsClient("HKLM", true)
 						&&
 						Def.Win7Install(true);
 	LRegKey::AssertOnError = OldAssert;
 	if (!RegistryOk)
 	{
 		// Need write permissions to fix up the registry?
 		NeedsCapability("RegistryWritePermissions");
 		return;
 	}
 
 	// Check if the user wants us to be the default client
 	LVariant n = true;
 	GetOptions()->GetValue(OPT_CheckDefaultEmail, n);
 	if (n.CastInt32())
 	{
 		// HKEY_CURRENT_USER\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\mailto\UserChoice
 		
 		LRegKey::AssertOnError = false;
 		bool IsDef = Def.IsDefault();
 		if (!IsDef)
 		{
 			// Ask the user...
 			auto Dlg = new DefaultClientDlg(this);
 			Dlg->DoModal([this, Dlg, Def, OldAssert](auto dlg, auto id)
 			{
 				if (id)
 				{
 					auto Error = !Def.SetDefault();
 					LVariant v;
 					GetOptions()->SetValue(OPT_CheckDefaultEmail, v = (int) (!Dlg->DontWarn));
 					OnSetDefaultHandler(Error, OldAssert);
 				}
 				delete dlg;
 			});
 		}
 		else OnSetDefaultHandler(false, OldAssert);
 	}
 
 	#endif
 }
 
 void ScribeWnd::OnSetDefaultHandler(bool Error, bool OldAssert)
 {
 	#if WINDOWS
 	LRegKey::AssertOnError = OldAssert;
 	#endif
 	if (Error)
 		NeedsCapability("RegistryWritePermissions");
 }
 
 void ScribeWnd::OnSelect(List<Thing> *l, bool ChangeEvent)
 {
 	Mail *m = (l && l->Length() == 1) ? (*l)[0]->IsMail() : 0;
 
 	if (Commands)
 	{
 		bool NotCreated = m && !TestFlag(m->GetFlags(), MAIL_CREATED);
 
 		Commands->SetCtrlEnabled(IDM_DELETE, l && l->Length() > 0);
 		Commands->SetCtrlEnabled(IDM_DELETE_AS_SPAM, l && l->Length() > 0);
 		Commands->SetCtrlEnabled(IDM_PRINT, l && l->Length() == 1);
 		
 		Commands->SetCtrlEnabled(IDM_REPLY, NotCreated);
 		Commands->SetCtrlEnabled(IDM_REPLY_ALL, NotCreated);
 		Commands->SetCtrlEnabled(IDM_FORWARD, m != 0);
 		Commands->SetCtrlEnabled(IDM_BOUNCE, m != 0);
 	}
 
 	if (PreviewPanel && GetEffectiveLayoutMode() != 3)
 	{
 		if (!PreviewPanel->IsAttached())
 		{
 			SetItemPreview(PreviewPanel);
 		}
 
 		Thing *t = (l && l->Length() == 1) ? (*l)[0] : 0;
 		PreviewPanel->OnThing(t, ChangeEvent);
 		
 		/*
 		if (d->Debug)
 			d->Debug->OnThing(t);
 		*/
 	}
 }
 
 class SpellErrorInst
 {
 public:
 	int Id;
 	LString Word;
 	LString::Array Suggestions;
 
 	SpellErrorInst(int id)
 	{
 		Id = id;
 		// Decor = LCss::TextDecorSquiggle;
 		// DecorColour.Rgb(255, 0, 0);		
 	}
 	
 	~SpellErrorInst()
 	{
 	}
 
 	bool OnMenu(LSubMenu *m)
 	{
 		if (Suggestions.Length())
 		{
 			for (unsigned i=0; i<Suggestions.Length() && i<10; i++)
 			{
 				m->AppendItem(Suggestions[i], 100 + i, true);
 			}
 
 			m->AppendSeparator();
 		}
 
 		char Buf[256];
 		sprintf_s(Buf, sizeof(Buf), LLoadString(IDS_ADD_TO_DICTIONARY, "Add '%s' to dictionary"), Word.Get());
 		m->AppendItem(Buf, 1, true);
 		return true;
 	}
 	
 	void OnMenuClick(int i)
 	{
 		if (i == 1)
 		{
 			// Add to dictionary...
 			/*
 			if (PostThreadEvent(SpellHnd, M_ADD_WORD, (LMessage::Param) new LString(Word)))
 			{
 				// FIXME
 				LAssert(!"Impl me.");
 				// View->PostEvent(M_DELETE_STYLE, (LMessage::Param) dynamic_cast<LTextView3::LStyle*>(this));
 			}
 			*/
 		}
 		else if (i >= 100 && i < 100 + (int)Suggestions.Length())
 		{
 			// Change spelling..
 			char *Replace = Suggestions[i - 100];
 			if (Replace)
 			{
 				char16 *w = Utf8ToWide(Replace);
 				if (w)
 				{
 					/*
 					int NewLen = StrlenW(w);
 					if (NewLen > Len)
 					{
 						// Bigger...
 						memcpy(View->NameW() + Start, w, Len * sizeof(char16));
 						View->Insert(Start + Len, w + Len, NewLen - Len);
 					}
 					else if (NewLen < Len)
 					{
 						// Smaller...
 						memcpy(View->NameW() + Start, w, NewLen * sizeof(char16));
 						View->Delete(Start + NewLen, Len - NewLen);
 					}
 					else
 					{
 						// Just copy...
 						memcpy(View->NameW() + Start, w, Len * sizeof(char16));
 						RefreshLayout(Start, Len);
 					}
 					*/
 
 					DeleteArray(w);
 				}
 			}
 		}
 	}
 };
 
 class MailTextView : public LTextView3
 {
 	ScribeWnd *App;
 	LSpellCheck *Thread;
 	LColour c[8];
 	LHashTbl<IntKey<int>, SpellErrorInst*> ErrMap;
 
 	SpellErrorInst *NewErrorInst()
 	{
 		int Id;
 		while (ErrMap.Find(Id = LRand(10000)))
 			;
 		SpellErrorInst *Inst = new SpellErrorInst(Id);
 		if (!Inst) return NULL;
 		ErrMap.Add(Id, Inst);
 		return Inst;
 	}
 
 public:
 	MailTextView(ScribeWnd *app, int Id, int x, int y, int cx, int cy, LFontType *FontType) :
 		LTextView3(Id, x, y, cx, cy, FontType)
 	{
 		App = app;
 		Thread = 0;
 
 		int i=0;
 		c[i++].Rgb(0x80, 0, 0);
 		c[i++].Rgb(0, 0x80, 0);
 		c[i++].Rgb(0, 0, 0x80);
 		c[i++].Rgb(0x80, 0x80, 0);
 		c[i++].Rgb(0x80, 0, 0x80);
 		c[i++].Rgb(0, 0x80, 0x80);
 		c[i++].Rgb(0x80, 0x80, 0x80);
 		c[i++].Rgb(0xc0, 0xc0, 0xc0);
 
 		for (i=0; i<CountOf(c); i++)
 		{
 			char s[64];
 			sprintf_s(s, sizeof(s), "colour-LC_REPLY_LVL_%i", i + 1);
 			LColour::GetConfigColour(s, c[i]);
 		}
 	}
 
 	~MailTextView()
 	{
 	}
 
 	void PourStyle(size_t Start, ssize_t Length)
 	{
 		LTextView3::PourStyle(Start, Length);
 
 		if (!GetReadOnly())
 		{
 			ssize_t Origin = Start;
 			ssize_t Len = Length;
 			while (Start > 0 && !StrchrW(SpellDelim, Text[Start-1]))
 				Start--;
 
 			if (Len > 0)
 			{
 				// Text being added
 				Len += Origin - Start;
 				while ((ssize_t)Start + Len < Size && !StrchrW(SpellDelim, Text[Start + Len]))
 					Len++;
 			}
 			else if (Len < 0)
 			{
 				// Text being deleted
 				Len = Origin - Start;
 				while ((ssize_t)Start + Len < Size && !StrchrW(SpellDelim, Text[Start + Len]))
 					Len++;
 			}
 
 			if (!Thread)
 				Thread = App->GetSpellThread();
 			if (Thread && Len > 0)
 			{
 				LString Str(Text+Start, Len);
 				LArray<LVariant> Params;
 				Thread->Check(AddDispatch(), Str, Start, Len, &Params);
 			}
 
 			// Adjust all the positions of the styles after this.
 			for (auto s = Style.begin(); s != Style.end(); )
 			{
 				if (s->Start >= Origin &&
 					s->Owner == 1)
 				{
 					if (Length < 0 &&
 						s->Start < Origin - Length)
 					{
 						// In the deleted text...
 						Style.Delete(s);
 						continue;
 					}
 
 					// After the deleted text
 					s->Start += Length;
 					LAssert(s->Start >= 0);
 				}
 
 				s++;
 			}
 		}
 	}
 
 	void PourText(size_t Start, ssize_t Len)
 	{
 		LTextView3::PourText(Start, Len);
 
 		for (auto l: Line)
 		{
 			int n=0;
 			char16 *t = Text + l->Start;
 			char16 *e = t + l->Len;
 			while ((*t == ' ' || *t == '>') && t < e)
 				if (*t++ == '>') n++;
 
 			if (n > 0)
 				l->c = c[(n-1)%CountOf(c)];
 		}
 	}
 
 	LMessage::Result OnEvent(LMessage *m)
 	{
 		switch (m->Msg())
 		{
 			case M_CHECK_TEXT:
 			{
 				LAutoPtr<LSpellCheck::CheckText> Ct((LSpellCheck::CheckText*)m->A());
 				if (!Ct || !Thread)
 					break;
 				
 				// Clear existing spelling error styles
 				ssize_t Start = Ct->Start;
 				ssize_t End = Start + Ct->Len;
 				for (auto i = Style.begin(); i != Style.end(); )
 				{
 					if (i->End() < (size_t)Start ||
 						i->Start >= End)
 					{
 						// Outside the area we are re-styling.
 						i++;
 					}
 					else
 					{
 						if (i->Owner == STYLE_SPELLING)
 						{
 							// Existing error style inside the area
 							Style.Delete(i);
 						}
 						else
 						{
 							// Existing non-error style...
 							i++;
 						}
 					}
 				}
 
 				// Insert the new styles
 				for (auto Ct: Ct->Errors)
 				{
 					SpellErrorInst *ErrInst = NewErrorInst();
 					LAutoPtr<LTextView3::LStyle> Style(new LTextView3::LStyle(STYLE_SPELLING));
 					if (Style && ErrInst)
 					{
 						Style->View = this;
 						Style->Start = Ct.Start;
 						Style->Len = Ct.Len;
 						Style->Font = GetFont();
 						Style->Data = ErrInst->Id;
 						Style->DecorColour = LColour::Red;
 						Style->Decor = LCss::TextDecorSquiggle;
 
 						ErrInst->Word = LString(Text + Style->Start, Style->End());
 						ErrInst->Suggestions = Ct.Suggestions;
 						
 						InsertStyle(Style);
 					}
 				}
 
 				// Update the screen...
 				Invalidate();
 				break;
 			}
 			case M_DELETE_STYLE:
 			{
 				/*
 				LTextView3::LStyle *s = (LTextView3::LStyle*)m->A();
 				if (s && Style.HasItem(s))
 				{
 					Style.Delete(s);
 					Invalidate();
 				}
 				else LAssert(0);
 				*/
 				break;
 			}
 		}
 
 		return LTextView3::OnEvent(m);
 	}
 
 	bool OnStyleClick(LStyle *style, LMouse *m)
 	{
 		switch (style->Owner)
 		{
 			case STYLE_URL:
 			{
 				if (m->Left() &&
 					m->Down() &&
 					m->Double())
 				{
 					LString s(Text + style->Start, style->Len);
 					LUri u(s);
 					if
 					(
 						(u.sProtocol && !_stricmp(u.sProtocol, "mailto"))
 						||
 						LIsValidEmail(s)
 					)
 					{
 						Mailto m(App, s);
 						Mail *email = App->CreateMail();
 						if (email)
 						{
 							m.Apply(email);
 							email->DoUI();
 							return true;
 						}
 					}
 					else
 					{
 						// Web link?
 						LExecute(s);
 					}
 				}
 				break;
 			}
 			default:
 				return false;
 		}
 
 		return true;
 	}
 };
 
 LDocView *ScribeWnd::CreateTextControl(int Id, const char *MimeType, bool Editor, Mail *m)
 {
 	LDocView *Ctrl = 0;
 	
 	// Get the default font
 	LFontType FontType;
 	bool UseFont = FontType.Serialize(GetOptions(), OPT_EditorFont, false);
 
 	if (Editor)
 	{
-		if (MimeType && !_stricmp(MimeType, sTextHtml))
+		if (!Stricmp(MimeType, sTextHtml))
 		{		
 			// Use the built in html editor
 			LRichTextEdit *Rte;
 			if ((Ctrl = Rte = new LRichTextEdit(Id)))
 			{
 				if (UseFont)
 					Ctrl->SetFont(FontType.Create(), true);
 				
 				// Give the control the speller settings:
 				LVariant Check, Lang, Dict;
 				if (GetOptions()->GetValue(OPT_SpellCheck, Check) &&
 					Check.CastInt32() != 0)
 				{
 					if (GetOptions()->GetValue(OPT_SpellCheckLanguage, Lang))
 						Rte->SetValue(LDomPropToString(SpellCheckLanguage), Lang);
 					if (GetOptions()->GetValue(OPT_SpellCheckDictionary, Dict))
 						Rte->SetValue(LDomPropToString(SpellCheckDictionary), Dict);
 					
 					
 					// Set the spell thread:
 					LSpellCheck *t = GetSpellThread();
 					if (t)
 						Rte->SetSpellCheck(t);
 				}
 			}
 		}
 		else
 		{
 			// Use the built in plain text editor
 			Ctrl = new MailTextView(this, Id, 0, 0, 200, 200, (UseFont) ? &FontType : 0);
 		}
 	}
 	else
 	{
 		// Create a view only control for the mime type:
 		LDocView *HtmlCtrl = NULL;
-		if (!MimeType || _stricmp(MimeType, sTextPlain) == 0)
+		if (!MimeType ||
+			!Stricmp(MimeType, sTextPlain) ||
+			!Stricmp(MimeType, sMultipartEncrypted))
+		{
 			Ctrl = new MailTextView(this, Id, 0, 0, 200, 200, (UseFont) ? &FontType : 0);
-		#if 0 // defined(WINDOWS) && !defined(__GTK_H__)
-		else if (_stricmp(MimeType, sApplicationInternetExplorer) == 0)
-			HtmlCtrl = Ctrl = CreateIeControl(Id);
-		#endif
+		}
 		else
+		{
 			HtmlCtrl = Ctrl = new Html1::LHtml(Id, 0, 0, 200, 200);
+		}
 		
 		if (HtmlCtrl && UseFont)
 		{
 			LVariant LoadImg;
 			if (GetOptions()->GetValue(OPT_HtmlLoadImages, LoadImg))
 				HtmlCtrl->SetLoadImages(LoadImg.CastInt32() != 0);
 			HtmlCtrl->SetFont(FontType.Create(), true);
 		}
 	}
 
 	if (Ctrl)
 	{
 		Ctrl->SetUrlDetect(true);
 		Ctrl->SetAutoIndent(true);
 
 		LVariant WrapOption;
 		if (GetOptions()->GetValue(OPT_WordWrap, WrapOption))
 		{
 			if (WrapOption.CastInt32())
 			{
 				LVariant WrapCols = 80;
 				GetOptions()->GetValue(OPT_WrapAtColumn, WrapCols);
 				Ctrl->SetWrapAtCol(WrapCols.CastInt32());
 			}
 			else
 			{
 				Ctrl->SetWrapAtCol(0);
 			}
 		}
 	}
 
 	return Ctrl;
 }
 
 void ScribeWnd::GrowlInfo(LString title, LString text)
 {
 	LGrowl *g = d->GetGrowl();
 	if (!g)
 		return;
 
 	LAutoPtr<LGrowl::LNotify> n(new LGrowl::LNotify);
 	n->Name = "info";
 	n->Title = title;
 	n->Text = text;
 	g->Notify(n);
 }
 
 void ScribeWnd::GrowlOnMail(Mail *m)
 {
 	LVariant v;
 	LAutoPtr<LGrowl::LNotify> n(new LGrowl::LNotify);
 	n->Name = "new-mail";
 	n->Title = m->GetSubject();
 	
 	int Len = 64;
 	char sLen[16];
 	sprintf_s(sLen, sizeof(sLen), "%i", Len);
 	if (m->GetVariant("BodyAsText", v, sLen))
 	{
 		char *s = v.Str();
 		if (s)
 		{
 			int Words = 0;
 			bool Lut[256];
 			memset(Lut, 0, sizeof(Lut));
 			Lut[(int)' '] = Lut[(int)'\t'] = Lut[(int)'\r'] = Lut[(int)'\n'] = true;
 			char *c;
 			for (c = s; *c && Words < 30; )
 			{
 				while (*c && Lut[(int)*c]) c++;
 				while (*c && !Lut[(int)*c]) c++;
 				Words++;
 			}
 			
 			n->Text.Set(s, c - s);
 		}
 	}
 	
 	LGrowl *g = d->GetGrowl();
 	if (g)
 	{
 		g->Notify(n);
 		m->NewEmail = Mail::NewEmailTray;
 	}
 }
 
 void ScribeWnd::OnNewMailSound()
 {
 	static uint64 PrevTs = 0;
 	auto Now = LCurrentTime();
 	if (Now - PrevTs > 30000)
 	{
 		PrevTs = Now;
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_NewMailSoundFile, v) &&
 			LFileExists(v.Str()))
 		{
 			LPlaySound(v.Str(), SND_ASYNC);
 		}
 	}
 }
 
 void ScribeWnd::OnFolderSelect(ScribeFolder *f)
 {
 	if (SearchView)
 		SearchView->OnFolder();
 }
 
 void ScribeWnd::OnNewMail(List<Mail> *MailObjs, bool Add)
 {
 	if (!MailObjs)
 		return;
 
 	LVariant v;
 	bool ShowDetail = MailObjs->Length() < 5;
 	List<Mail> NeedsFiltering;
 	LArray<Mail*> NeedsBayes;
 	LArray<Mail*> NeedsGrowl;
 	LArray<ScribeFolder*> Resort;
 
 	for (auto m: *MailObjs)
 	{
 		if (Add)
 		{
 			#if DEBUG_NEW_MAIL
 			LgiTrace("%s:%i - NewMail.OnNewMail t=%p, uid=%s, mode=%s\n",
 				_FL, (Thing*)m, m->GetServerUid().ToString().Get(), toString(m->NewEmail));
 			#endif
 
 			switch (m->NewEmail)
 			{
 				case Mail::NewEmailNone:
 				{
 					auto Loaded = m->GetLoaded();
 					#if DEBUG_NEW_MAIL
 					LgiTrace("%s:%i - NewMail.OnNewMail.GetLoaded=%i uid=%s\n", _FL, (int)Loaded, m->GetServerUid().ToString().Get());
 					#endif
 					if (Loaded != Store3Loaded)
 					{
 						LOG_STORE("\tOnNewMail calling SetLoaded.\n");
 						m->SetLoaded();
 						m->NewEmail = Mail::NewEmailLoading;
 					}
 					else
 					{
 						m->NewEmail = Mail::NewEmailFilter;
 						LOG_STORE("\tOnNewMail none->NeedsFiltering.\n");
 						NeedsFiltering.Insert(m);
 					}
 					break;
 				}
 				case Mail::NewEmailLoading:
 				{
 					auto Loaded = m->GetLoaded();
 					if (Loaded == Store3Loaded)
 					{
 						m->NewEmail = Mail::NewEmailFilter;
 						NeedsFiltering.Insert(m);
 
 						if (m->GetFolder() &&
 							!Resort.HasItem(m->GetFolder()))
 						{
 							Resort.Add(m->GetFolder());
 						}
 					}
 					break;
 				}
 				case Mail::NewEmailFilter:
 				{
 					NeedsFiltering.Insert(m);
 					break;
 				}
 				case Mail::NewEmailBayes:
 				{
 					NeedsBayes.Add(m);
 					break;
 				}
 				case Mail::NewEmailGrowl:
 				{
 					if (d->Growl)
 					{
 						NeedsGrowl.Add(m);
 						break;
 					}
 					else
 					{
 						m->NewEmail = Mail::NewEmailTray;
 						// no Growl loaded so fall through to new tray mail
 					}
 				}
 				case Mail::NewEmailTray:
 				{
 					LAssert(m->GetObject());
 					Mail::NewMailLst.Insert(m);
 					OnNewMailSound();
 					break;
 				}
 				default:
 				{
 					LAssert(!"Hmmm what happen?");
 					break;
 				}
 			}
 		}
 		else
 		{
 			#if DEBUG_NEW_MAIL
 			LgiTrace("%s:%i - NewMail.OnNewMail.RemoveNewMail t=%p, uid=%s\n",
 				_FL, (Thing*)m, m->GetServerUid().ToString().Get());
 			#endif
 
 			Mail::NewMailLst.Delete(m);
 			
 			if (m->NewEmail == Mail::NewEmailFilter)
 				m->NewEmail = Mail::NewEmailNone;
 		}
 	}
 
 	if (Add)
 	{
 		// Do filtering
 		if (NeedsFiltering.Length())
 		{
 			List<Filter> Filters;
 			if (!GetOptions()->GetValue(OPT_DisableUserFilters, v) ||
 				!v.CastInt32())
 			{
 				GetFilters(Filters, true, false, false);
 			}
 		
 			if (Filters.Length() > 0)
 			{
 				// Run the filters
 				#if DEBUG_NEW_MAIL
 				LgiTrace("%s:%i - NewMail.OnNewMail.Filtering %i mail through %i filters\n",
 					_FL, (int)NeedsFiltering.Length(), (int)Filters.Length());
 				#endif
 				Filter::ApplyFilters(NULL, Filters, NeedsFiltering);
 				
 				// All the email not filtered now needs to be sent to the bayes filter.
 				for (auto m: NeedsFiltering)
 				{
 					if (m->NewEmail == Mail::NewEmailBayes)
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnNewMail.NeedsBayes t=%p, msgid=%s\n",
 							_FL, (Thing*)m, m->GetMessageId());
 						#endif
 
 						NeedsBayes.Add(m);
 					}
 					else if (m->NewEmail == Mail::NewEmailGrowl)
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnNewMail.NeedsGrowl t=%p, msgid=%s\n",
 							_FL, (Thing*)m, m->GetMessageId());
 						#endif
 
 						NeedsGrowl.Add(m);
 					}
 				}
 			}
 		}
 
 		// Do bayes
 		if (NeedsBayes.Length())
 		{
 			ScribeBayesianFilterMode FilterMode = BayesOff;
 			if (GetOptions()->GetValue(OPT_BayesFilterMode, v))
 				FilterMode = (ScribeBayesianFilterMode)v.CastInt32();
 
 			for (unsigned i=0; i<NeedsBayes.Length(); i++)
 			{
 				Mail *m = NeedsBayes[i];
 				if (FilterMode != BayesOff)
 				{
 					double Rating = 0.0;
 					
 					// This adds the mail to a message ID map, so even if it moves we
 					// can do the filtering later on when the Bayesian result is returned.
 					m->MailMessageIdMap();
 					
 					// Start the Bayesian rating process off
 					Store3Status Status = IsSpam(Rating, m);
 					if (Status == Store3Success)
 					{
 						// Bayes done... this stops OnBayesResult from passing it back to OnNewMail
 						m->NewEmail = Mail::NewEmailGrowl;
 						
 						// Process bayes result
 						if (!OnBayesResult(m, Rating))
 						{
 							// Not spam... so on to growl
 							#if DEBUG_NEW_MAIL
 							LgiTrace("%s:%i - NewMail.Bayes.NeedsGrowl t=%p, msgid=%s\n",
 								_FL, (Thing*)m, m->GetMessageId());
 							#endif
 
 							NeedsGrowl.Add(m);
 						}
 						else
 						{
 							// Is spam... do nothing...
 							#if DEBUG_NEW_MAIL
 							LgiTrace("%s:%i - NEW_MAIL: Bayes->IsSpam t=%p, msgid=%s\n",
 								_FL, (Thing*)m, m->GetMessageId());
 							#endif
 
 							m->NewEmail = Mail::NewEmailNone;
 							m = 0;
 						}
 					}
 					else
 					{
 						// Didn't get classified immediately, so it'll be further
 						// processed when OnBayesResult gets called later.
 					}
 				}
 				else
 				{
 					// Bayes filter not active... move it to growl
 					m->NewEmail = Mail::NewEmailGrowl;
 					NeedsGrowl.Add(m);
 				}
 			}
 		}
 
 		if (NeedsGrowl.Length())
 		{
 			if (d->Growl)
 			{
 				if (!ShowDetail)
 				{
 					LAutoPtr<LGrowl::LNotify> n(new LGrowl::LNotify);
 					n->Name = "new-mail";
 					n->Title = "New Mail";
 					n->Text.Printf("%i new messages", (int)MailObjs->Length());
 					d->Growl->Notify(n);
 				}
 				else
 				{
 					for (unsigned i=0; i<NeedsGrowl.Length(); i++)
 					{
 						auto m = NeedsGrowl[i];
 						
 						#ifdef _DEBUG
 						auto state =
 						#endif
 						m->GetLoaded();
 						LAssert(state == Store3Loaded);
 
 						// If loaded then notify			                
 						GrowlOnMail(m);
 					}
 				}
 			}
 
 			for (unsigned i=0; i<NeedsGrowl.Length(); i++)
 			{
 				auto m = NeedsGrowl[i];
 				m->NewEmail = Mail::NewEmailTray;
 
 				#if DEBUG_NEW_MAIL
 				LgiTrace("%s:%i - NewMail.OnNewMail.Growl->Tray t=%p, msgid=%s\n",
 					_FL, (Thing*)m, m->GetMessageId());
 				#endif
 
 				LAssert(m->GetObject());
 				Mail::NewMailLst.Insert(m);
 				OnNewMailSound();
 			}
 		}
 
 		if (GetOptions()->GetValue(OPT_NewMailNotify, v) &&
 			v.CastInt32())
 		{
 			PostEvent(M_SCRIBE_NEW_MAIL);
 		}
 
 		for (unsigned i=0; i<Resort.Length(); i++)
 		{
 			#if DEBUG_NEW_MAIL
 			auto Path = Resort[i]->GetPath();
 			LgiTrace("%s:%i - NewMail.OnNewMail.Resort=%s\n", _FL, Path.Get());
 			#endif
 
 			Resort[i]->ReSort();
 		}
 	}
 }
 
 LColour ScribeWnd::GetColour(int i)
 {
 	static LColour MailPreview;
 	static LColour UnreadCount;
 	#define ReadColDef(Var, Tag, Default)		\
 		case Tag: \
 		{ \
 			if (!Var.IsValid()) \
 			{ \
 				Var = Default; \
 				LColour::GetConfigColour("Colour."#Tag, Var); \
 			} \
 			return Var; \
 			break; \
 		}
 
 	switch (i)
 	{
 		ReadColDef(MailPreview, L_MAIL_PREVIEW, LColour(0, 0, 255));
 		ReadColDef(UnreadCount, L_UNREAD_COUNT, LColour(0, 0, 255));
 		default:
 		{
 			return LColour((LSystemColour)i);
 			break;
 		}
 	}
 
 	return LColour();
 }
 
 bool WriteXmlTag(LStream &p, LXmlTag *t)
 {
 	const char *Tag = t->GetTag();
 	bool ValidTag = ValidStr(Tag) && !IsDigit(Tag[0]);
 	if (ValidTag)
 		p.Print("<%s", Tag);
 	else
 	{
 		LAssert(0);
 		return false;
 	}
 
 	LXmlTree Tree;
 	static const char *EncodeEntitiesAttr	= "\'<>\"\n";
 	for (unsigned i=0; i<t->Attr.Length(); i++)
 	{
 		auto &a = t->Attr[i];
 
 		// Write the attribute name
 		p.Print(" %s=\"", a.GetName());
 		
 		// Encode the value
 		if (!Tree.EncodeEntities(&p, a.GetValue(), -1, EncodeEntitiesAttr))
 		{
 			LAssert(0);
 			return false;
 		}
 
 		// Write the delimiter
 		p.Write((void*)"\"", 1);
 
 		if (i<t->Attr.Length()-1 /*&& TestFlag(d->Flags, GXT_PRETTY_WHITESPACE)*/)
 		{
 			p.Write((void*)"\n", 1);
 		}
 	}
 	
 	p.Write(">", 1);
 	
 	return true;
 }
 
 LString ScribeWnd::ProcessReplyForwardTemplate(Mail *m, Mail *r, char *Xml, int &Cursor, const char *MimeType)
 {
 	LStringPipe p(256);
 
 	if (m && r && Xml)
 	{
 		bool IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 		LMemStream mem(Xml, strlen(Xml));
 		LXmlTag x;
 		LXmlTree t(GXT_KEEP_WHITESPACE | GXT_NO_DOM);
 		if (t.Read(&x, &mem, 0))
 		{
 			ScribeDom Dom(this);
 			Dom.Email = m;
 
 			if (IsHtml)
 			{
 				const char *EncodeEntitiesContent	= "\'<>\"";
 				
 				for (auto Tag: x.Children)
 				{
 					if (!WriteXmlTag(p, Tag))
 					{
 						break;
 					}
 					
 					for (const char *c = Tag->GetContent(); c; )
 					{
 						const char *s = strstr(c, "<?");
 						const char *e = s ? strstr(s + 2, "?>") : NULL;
 						if (s && e)
 						{
 							if (s > c)
 							{
 								t.EncodeEntities(&p, (char*)c, s - c, EncodeEntitiesContent);
 							}
 							s += 2;
 							
 							LString Var = LString(s, e - s).Strip();
 							LVariant v;
 							if (Var)
 							{
 								LString::Array parts = Var.SplitDelimit(" ");
 								if (parts.Length() > 0)
 								{
 									if (Dom.GetValue(parts[0], v))
 									{
 										for (unsigned mod = 1; mod < parts.Length(); mod++)
 										{
 											LString::Array m = parts[mod].SplitDelimit("=", 1);
 											if (m.Length() == 2)
 											{
 												if (m[0].Equals("quote"))
 												{
 													LVariant Quote;
 													if (Dom.GetValue(m[1], Quote))
 													{
 														LVariant WrapColumn;
 														if (!GetOptions()->GetValue(OPT_WrapAtColumn, WrapColumn) ||
 															WrapColumn.CastInt32() <= 0)
 															WrapColumn = 76;
 															
 														WrapAndQuote(p, Quote.Str(), WrapColumn.CastInt32(), v.Str(), NULL, MimeType);
 														v.Empty();
 													}
 												}
 											}
 										}
 										
 										switch (v.Type)
 										{
 											case GV_STRING:
 											{
 												p.Push(v.Str());
 												break;
 											}
 											case GV_DATETIME:
 											{
 												p.Push(v.Value.Date->Get());
 												break;
 											}
 											case GV_NULL:
 												break;
 											default:
 											{
 												LAssert(!"Unsupported type.");
 												break;
 											}
 										}
 									}
 								}
 							}
 							
 							c = e + 2;
 						}
 						else
 						{						
 							p.Print("%s", c);
 							break;
 						}
 					}
 				}
 			}
 			else
 			{			
 				LArray<LXmlTag*> Tags;
 				Tags.Add(&x);
 				for (auto Tag: x.Children)
 				{
 					Tags.Add(Tag);
 				}
 				
 				for (unsigned i=0; i<Tags.Length(); i++)
 				{
 					LXmlTag *Tag = Tags[i];
 					
 					LVariant v;
 					if (Tag->GetTag() && Dom.GetValue(Tag->GetTag(), v))
 					{
 						char *s = v.Str();
 						if (s)
 						{
 							const char *Quote;
 							if ((Quote = Tag->GetAttr("quote")))
 							{
 								LVariant q, IsQuote;
 								GetOptions()->GetValue(OPT_QuoteReply, IsQuote);
 								if (r->GetValue(Quote, q))
 								{
 									Quote = q.Str();
 								}
 								else
 								{
 									Quote = "> ";
 								}
 
 								if (Quote && IsQuote.CastInt32())
 								{
 									LVariant WrapColumn;
 									if (!GetOptions()->GetValue(OPT_WrapAtColumn, WrapColumn) ||
 										WrapColumn.CastInt32() <= 0)
 										WrapColumn = 76;
 										
 									WrapAndQuote(p, Quote, WrapColumn.CastInt32(), s);
 								}
 								else
 								{
 									p.Push(s);
 								}
 							}
 							else
 							{
 								p.Push(s);
 							}
 						}
 						else if (v.Type == GV_DATETIME &&
 								 v.Value.Date)
 						{
 							char b[64];
 							v.Value.Date->Get(b, sizeof(b));
 							p.Push(b);
 						}
 					}
 					else if (Tag->IsTag("cursor"))
 					{
 						int Size = (int)p.GetSize();
 						char *Buf = new char[Size+1];
 						if (Buf)
 						{
 							p.Peek((uchar*)Buf, Size);
 							Buf[Size] = 0;
 							RemoveReturns(Buf);
 
 							Cursor = LCharLen(Buf, "utf-8");
 							DeleteArray(Buf);
 						}
 					}
 
 					if (Tag->GetContent())
 					{
 						p.Push(Tag->GetContent());
 					}
 				}
 			}
 		}
 	}
 
 	return p.NewLStr();
 }
 
 LAutoString	ScribeWnd::ProcessSig(Mail *m, char *Xml, const char *MimeType)
 {
 	LStringPipe p;
 
 	if (!m || !Xml)
 		return LAutoString();
 	
 	if (MimeType && !_stricmp(MimeType, sTextHtml))
 		p.Write(Xml, strlen(Xml));
 	else
 	{
 		LMemStream mem(Xml, strlen(Xml));
 		LXmlTag x;
 		LXmlTree t(GXT_KEEP_WHITESPACE|GXT_NO_DOM);
 		if (t.Read(&x, &mem, 0))
 		{
 			for (auto Tag: x.Children)
 			{
 				if (Tag->IsTag("random-line"))
 				{
 					char *FileName = 0;
 					if ((FileName = Tag->GetAttr("Filename")))
 					{
 						LFile f(FileName);
 						if (f)
 						{
 							auto Lines = f.Read().SplitDelimit("\r\n");
 							char *RandomLine = Lines[LRand((unsigned)Lines.Length())];
 							if (RandomLine)
 							{
 								p.Push(RandomLine);
 							}
 						}
 					}
 				}
 				else if (Tag->IsTag("random-paragraph"))
 				{
 					char *FileName = 0;
 					if ((FileName = Tag->GetAttr("Filename")))
 					{
 						char *File = LReadTextFile(FileName);
 						if (File)
 						{
 							List<char> Para;
 							for (char *f=File; f && *f; )
 							{
 								// skip whitespace
 								while (strchr(" \t\r\n", *f)) f++;
 								if (*f)
 								{
 									char *Start = f;
 									char *n;
 									while ((n = strchr(f, '\n')))
 									{
 										f = n + 1;
 										if (f[1] == '\n' ||
 											(f[1] == '\r' && f[2] == '\n'))
 										{
 											break;
 										}
 									}
 									if (f == Start) f += strlen(f);
 
 									Para.Insert(NewStr(Start, f-Start));
 								}
 							}
 							DeleteArray(File);
 
 							char *RandomPara = Para.ItemAt(LRand((int)Para.Length()));
 							if (RandomPara)
 							{
 								p.Push(RandomPara);
 							}
 
 							Para.DeleteArrays();
 						}
 					}
 				}
 				else if (Tag->IsTag("include-file"))
 				{
 					char *FileName = 0;
 					if ((FileName = Tag->GetAttr("filename")))
 					{
 						char *File = LReadTextFile(FileName);
 						if (File)
 						{
 							p.Push(File);
 							DeleteArray(File);
 						}
 					}
 				}
 				else if (Tag->IsTag("quote-file"))
 				{
 					char *FileName = 0;
 					char *QuoteStr = 0;
 					if ((FileName = Tag->GetAttr("filename")) &&
 						(QuoteStr = Tag->GetAttr("Quote")))
 					{
 					}
 				}
 				else
 				{
 					p.Push(Tag->GetContent());
 				}
 			}
 		}
 	}
 
 	return LAutoString(p.NewStr());
 }
 
 // Get the effective permissions for a resource.
 //
 // This method can be used by both sync and async code:
 // In sync mode, don't supply a callback (ie = NULL) and the return value will be:
 //		Store3Error - no access
 //		Store3Delayed - no access, asking the user for password
 //		Store3Success - allow immediate access
 //
 // In async mode, supply a callback and wait for the response.
 //		callback(false) - no access
 //		callback(true) - allow immediate access
 // in this mode the same return values as sync mode are used.
 Store3Status ScribeWnd::GetAccessLevel(LViewI *Parent, ScribePerm Required, const char *ResourceName, std::function<void(bool)> Callback)
 {
 	if (Required >= CurrentAuthLevel)
 	{
 		if (Callback) Callback(true);
 		return Store3Success;
 	}
 	
 	if (!Parent)
 		Parent = this;
 	
 	switch (Required)
 	{
 		default:
 			break;
 		case PermRequireUser:
 		{
 			LPassword p;
 			if (!p.Serialize(GetOptions(), OPT_UserPermPassword, false))
 			{
 				if (Callback) Callback(true);
 				return Store3Success;
 			}
 
 			char Msg[256];
 			sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_ASK_USER_PASS), ResourceName);
 				
 			auto d = new LInput(Parent, "", Msg, AppName, true);
 			d->DoModal([this, d, p, Callback](auto dlg, auto id)
 			{
 				if (id && d->GetStr())
 				{
 					char Pass[256];
 					p.Get(Pass);
 					bool Status = strcmp(Pass, d->GetStr()) == 0;
 					if (Status)
 					{
 						CurrentAuthLevel = PermRequireUser;
 						
 						auto i = Menu->FindItem(IDM_LOGOUT);
 						if (i) i->Enabled(true);
 						if (Callback) Callback(true);
 					}
 					else
 					{
 						if (Callback) Callback(false);
 					}
 				}
 				delete dlg;
 			});
 
 			return Store3Delayed;
 		}
 		case PermRequireAdmin:
 		{
 			LString Key;
 			Key.Printf("Scribe.%s", OPT_AdminPassword);
 			auto Hash = LAppInst->GetConfig(Key);
 			if (ValidStr(Hash))
 			{
 				if (Callback) Callback(false);
 				return Store3Error;
 			}
 
 			uchar Bin[256];
 			ssize_t BinLen = 0;
 			if ((BinLen = ConvertBase64ToBinary(Bin, sizeof(Bin), Hash, strlen(Hash))) != 16)
 			{
 				LgiMsg(Parent, "Admin password not correctly encoded.", AppName);
 				if (Callback) Callback(false);
 				return Store3Error;
 			}
 
 			auto d = new LInput(Parent, "", LLoadString(IDS_ASK_ADMIN_PASS), AppName, true);
 			d->DoModal([this, d, Bin, Callback](auto dlg, auto id)
 			{
 				if (id && d->GetStr())
 				{
 					unsigned char Digest[16];
 					char Str[256];
 					sprintf_s(Str, sizeof(Str), "%s admin", d->GetStr().Get());
 					MDStringToDigest(Digest, Str);
 						
 					if (memcmp(Bin, Digest, 16) == 0)
 					{
 						CurrentAuthLevel = PermRequireAdmin;
 						auto i = Menu->FindItem(IDM_LOGOUT);
 						if (i) i->Enabled(true);
 						if (Callback) Callback(true);
 					}
 					else
 					{
 						if (Callback) Callback(false);
 					}
 				}
 				delete dlg;
 			});
 
 			return Store3Delayed;
 		}
 	}
 
 	if (Callback) Callback(true);
 	return Store3Success;
 }
 
 void ScribeWnd::GetAccountSettingsAccess(LViewI *Parent, ScribeAccessType AccessType, std::function<void(bool)> Callback)
 {
 	LVariant Level = (int)PermRequireNone;
 	
 	// Check if user level access is required
 	char *Opt = (char*)(AccessType == ScribeReadAccess ? OPT_AccPermRead : OPT_AccPermWrite);
 	GetOptions()->GetValue(Opt, Level);
 
 	/*
 	// Check if admin access is required
 	char *Admin = GetScribeAccountPerm((char*) (AccessType == ScribeReadAccess ? "Read" : "Write"));
 	if (Admin && _stricmp(Admin, "Admin") == 0)
 	{
 		Level = PermRequireAdmin;
 	}
 	*/
 
 	GetAccessLevel(Parent ? Parent : this, (ScribePerm)Level.CastInt32(), "Account Settings", Callback);
 }
 
 LMutex *ScribeWnd::GetLock()
 {
 	return _Lock;
 }
 
 void ScribeWnd::OnBeforeConnect(ScribeAccount *Account, bool Receive)
 {
 	if (Receive)
 	{
 		Account->Receive.Enabled(false);
 	}
 	else
 	{
 		Account->Send.Enabled(true);
 	}
 
 	if (StatusPanel)
 	{
 		StatusPanel->Invalidate();
 	}
 }
 
 void ScribeWnd::OnAfterConnect(ScribeAccount *Account, bool Receive)
 {
 	if (Account)
 	{
 		SaveOptions();
 		if (ScribeState == ScribeExiting)
 		{
 			LCloseApp();
 		}
 	}
 
 	if (Receive)
 	{
 		Account->Receive.Enabled(true);
 	}
 	else
 	{
 		Account->Send.Enabled(true);
 	}
 
 	if (StatusPanel)
 	{
 		StatusPanel->Invalidate();
 	}
 
 	if (d->SendAfterReceive)
 	{
 		bool Online = false;
 		for (auto a: Accounts)
 		{
 			bool p = a->Receive.IsPersistant();
 			bool o = a->Receive.IsOnline();
 			if (!p && o)
 			{
 				Online = true;
 				break;
 			}
 		}
 		if (!Online)
 		{
 			Send(-1, true);
 			d->SendAfterReceive = false;
 		}
 	}
 }
 
 void ScribeWnd::Send(int Which, bool Quiet)
 {
 	if (ScribeState == ScribeExiting)
 		return;
 
 	if (Which < 0)
 	{
 		LVariant v;
 		if (GetOptions()->GetValue(OPT_DefaultSendAccount, v))
 			Which = v.CastInt32();
 	}
 
 	LArray<ScribeFolder*> Outboxes;
 	unsigned i;
 	for (i=0; i<Folders.Length(); i++)
 	{
 		ScribeFolder *OutBox = GetFolder(FOLDER_OUTBOX, &Folders[i]);
 		if (OutBox)
 		{
 			OutBox->LoadThings();
 			Outboxes.Add(OutBox);
 		}
 	}
 
 	if (Outboxes.Length() < 1)
 	{
 		LgiMsg(this, LLoadString(IDS_NO_OUTGOING_FOLDER), AppName, MB_OK);
 		return;
 	}
 
 	int MailToSend = 0;
 	List<SendAccountlet> Acc;
 	SendAccountlet *Default = 0;
 	
 	{
 		// Create list of accounts
 		for (auto a: Accounts)
 		{
 			Acc.Insert(&a->Send);
 			a->Send.Outbox.DeleteObjects();
 		
 			if (Which < 0 || a->GetIndex() == Which)
 				Default = &a->Send;
 		}
 		
 		// If the default it not in the list try the first one..
 		if (!Default)
 			Default = Acc[0];
 	}
 
 	for (i=0; i<Outboxes.Length(); i++)
 	{
 		ScribeFolder *OutBox = Outboxes[i];
 		for (auto t: OutBox->Items)
 		{
 			Mail *m = t->IsMail();
 			if (!m)
 				continue;
 
 			uint32_t Flags = m->GetFlags();
 			if (!TestFlag(Flags, MAIL_SENT) &&
 				TestFlag(Flags, MAIL_READY_TO_SEND))
 			{
 				LDataIt To = m->GetObject()->GetList(FIELD_TO);
 				if (To && To->Length())
 				{
 					LAutoPtr<ScribeEnvelope> Out(new ScribeEnvelope);
 					if (Out)
 					{
 						if (m->OnBeforeSend(Out))
 						{
 							SendAccountlet *Send = 0;
 							for (auto a: Acc)
 							{
 								LVariant Ie = a->GetAccount()->Identity.Email();
 								if (ValidStr(Ie.Str()) &&
 									a->OnlySendThroughThisAccount())
 								{
 									if (Ie.Str() &&
 										m->GetFromStr(FIELD_EMAIL) &&
 										_stricmp(Ie.Str(), m->GetFromStr(FIELD_EMAIL)) == 0)
 									{
 										Send = a;
 										break;
 									}
 								}
 							}
 
 							if (!Send)
 							{
 								Send = Default;
 							}
 							
 							if (Send)
 							{
 								LAssert(Out->To.Length() > 0);
 								Out->SourceFolder = OutBox->GetPath();
 								Send->Outbox.Add(Out.Release());
 								MailToSend++;
 							}
 						}
 					}
 				}
 				else
 				{
 					LgiMsg(	this,
 							LLoadString(IDS_ERROR_NO_RECIPIENTS),
 							AppName,
 							MB_OK,
 							m->GetSubject() ? m->GetSubject() : (char*)"(none)");
 				}
 			}
 		}
 	}
 
 	if (MailToSend)
 	{
 		for (auto a: Acc)
 		{
 			if (a->Outbox.Length() > 0 && !a->IsOnline())
 			{
 				if (a->IsConfigured())
 				{
 					a->Connect(0, Quiet);
 				}
 				else
 				{
 					auto d = new LAlert(this,
 							AppName,
 							LLoadString(IDS_ERROR_NO_CONFIG_SEND),
 							LLoadString(IDS_CONFIGURE),
 							LLoadString(IDS_CANCEL));
 					d->DoModal([this, d, a](auto dlg, auto id)
 					{
 						if (id == 1)
 							a->GetAccount()->InitUI(this, 1, NULL);
 						delete dlg;
 					});
 				}
 			}
 		}
 	}
 	else
 	{
 		LgiMsg(this, LLoadString(IDS_NO_MAIL_TO_SEND), AppName, MB_OK, Outboxes[0]->GetText());
 	}
 }
 
 void ScribeWnd::Receive(int Which)
 {
 	#define LOG_RECEIVE		0
 	
 	if (ScribeState == ScribeExiting)
 	{
 		LgiTrace("%s:%i - Won't receive, is trying to exit.\n", _FL);
 		return;
 	}
 
 	for (ScribeAccount *i: Accounts)
 	{
 		if (i->GetIndex() != Which)
 			continue;
 			
 		if (i->Receive.IsOnline())
 		{
 			#if LOG_RECEIVE
 			LgiTrace("%s:%i - %i already online.\n", _FL, Which);
 			#endif
 		}
 		else if (i->Receive.Disabled() > 0)
 		{
 			#if LOG_RECEIVE
 			LgiTrace("%s:%i - %i is disabled.\n", _FL, Which);
 			#endif
 		}
 		else if (!i->Receive.IsConfigured())
 		{
 			#if LOG_RECEIVE
 			LgiTrace("%s:%i - %i is not configured.\n", _FL, Which);
 			#endif
 
 			auto a = new LAlert(this,
 					AppName,
 					LLoadString(IDS_ERROR_NO_CONFIG_RECEIVE),
 					LLoadString(IDS_CONFIGURE),
 					LLoadString(IDS_CANCEL));
 			a->DoModal([this, a, i](auto dlg, auto id)
 			{
 				if (id == 1)
 					i->InitUI(this, 2, NULL);
 				delete dlg;
 			});
 		}
 		else
 		{
 			i->Receive.Connect(0, false);
 		}
 		break;
 	}
 }
 
 bool ScribeWnd::GetHelpFilesPath(char *Path, int PathSize)
 {
 	const char *Index = "index.html";
 	char Install[MAX_PATH_LEN];
 	strcpy_s(Install, sizeof(Install), ScribeResourcePath());
 	
 	for (int i=0; i<5; i++)
 	{
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), Install, "help");
 		LMakePath(p, sizeof(p), p, Index);
 		LgiTrace("Trying '%s'\n", p);
 		if (LFileExists(p))
 		{
 			LTrimDir(p);
 			strcpy_s(Path, PathSize, p);
 			return true;
 		}
 		#ifdef MAC
 		LMakePath(p, sizeof(p), Install, "Resources/Help");
 		LMakePath(p, sizeof(p), p, Index);
 		// LgiTrace("Trying '%s'\n", p);
 		if (LFileExists(p))
 		{
 			LTrimDir(p);
 			strcpy_s(Path, PathSize, p);
 			return true;
 		}
 		#endif
 		LTrimDir(Install); // Try all the parent folders...
 	}
 
 	LArray<const char*> Ext;
 	LArray<char*> Help;
 	Ext.Add("index.html");
 	LMakePath(Install, sizeof(Install), ScribeResourcePath(), "..");
 	LRecursiveFileSearch(Install, &Ext, &Help);
 	for (unsigned i=0; i<Help.Length(); i++)
 	{
 		if (stristr(Help[i], "leveldb"))
 			continue;
 		strcpy_s(Path, PathSize, Help[i]);
 		LTrimDir(Path);
 		Help.DeleteArrays();
 		return true;
 	}
 	
 	return false;
 }
 
 bool ScribeWnd::LaunchHelp(const char *File)
 {
 	if (File)
 	{
 		char *Hash = 0;
 		LBrowser *Browse = 0;
 		
 		// Find help files...
 		char Path[MAX_PATH_LEN];
 		if (!GetHelpFilesPath(Path, sizeof(Path)))
 		{
 			LgiTrace("%s:%i - GetHelpFilesPath failed.\n", _FL);
 			goto HelpError;
 		}
 
 		// Add filename...
 		LMakePath(Path, sizeof(Path), Path, File);
 		
 		// Check existance...
 		Hash = strrchr(Path, '#');
 		if (Hash) *Hash = 0;
 		if (!LFileExists(Path))
 		{
 			LgiTrace("%s:%i - FileExists('%s') failed.\n", _FL, Path);
 			goto HelpError;
 		}
 		if (Hash) *Hash = '#';
 
 		#if USE_INTERNAL_BROWSER
 
 		Browse = new LBrowser(this, "Help");
 		if (Browse)
 		{
 			Browse->AddPath(ScribeResourcePath());
 			Browse->SetEvents(d);
 			return Browse->SetUri(Path);
 		}
 
 		#else
 
 			#ifdef MAC
 
 			if (LExecute(Path))
 				return true;
 			
 			#else
 
 			if (Hash) *Hash = '#';
 			
 			// Get browser...
 			char Browser[256];
 			if (!LGetAppForMimeType("application/browser", Browser, sizeof(Browser)))
 			{
 				LgiTrace("%s:%i - LGetAppForMimeType('text/html') failed.\n", _FL);
 				goto HelpError;
 			}
 			
 			// Execute browser to view help...
 			char Uri[256];
 			sprintf_s(Uri, sizeof(Uri), "\"file://%s\"", Path);
 			#ifdef WIN32
 			char *c;
 			while (c = strchr(Uri, '\\')) *c = '/';
 			#endif
 
 			LgiTrace("LaunchHelp('%s','%s').\n", Browser, Uri);
 			if (!LExecute(Browser, Uri))
 			{
 				LgiTrace("%s:%i - LExecute('%s','%s') failed.\n", _FL, Browser, Uri);
 				goto HelpError;
 			}
 			return true;
 			
 			#endif
 
 		#endif
 		
 		HelpError:
 		LgiMsg(this, LLoadString(IDS_ERROR_NO_HELP), AppName, MB_OK);
 	}
 	
 	return false;
 }
 
 void ScribeWnd::Preview(int Which)
 {
 	LArray<ScribeAccount*> a;
 	a.Add(Accounts[Which]);
 	OpenPopView(this, a);
 }
 
 bool MergeSegments(LDataPropI *DstProp, LDataPropI *SrcProp, LDom *Dom)
 {
 	LDataI *Src = dynamic_cast<LDataI *>(SrcProp);
 	LDataI *Dst = dynamic_cast<LDataI *>(DstProp);
 	if (!Dst || !Src)
 		return false;
 
 	Store3MimeType Mt(Src->GetStr(FIELD_MIME_TYPE));
 	if (Mt.IsText())
 	{
 		// Set the headers...
 		Dst->SetStr(FIELD_INTERNET_HEADER, Src->GetStr(FIELD_INTERNET_HEADER));
 
 		// Do mail merge of data part...
 		LAutoStreamI Data = Src->GetStream(_FL);
 		if (Data)
 		{
 			// Read data out into a string string...
 			LAutoString Str(new char[(int)Data->GetSize()+1]);
 			Data->Read(Str, (int)Data->GetSize());
 			Str[Data->GetSize()] = 0;
 
 			// Do field insert and save result to segment
 			char *Merged = ScribeInsertFields(Str, Dom);
 			LAutoStreamI Mem(new LMemStream(Merged, strlen(Merged)));
 			Dst->SetStream(Mem);
 		}
 	}
 	else
 	{
 		// Straight copy...
 		Dst->CopyProps(*Src);
 	}
 
 	// Merge children segments as well
 	LDataIt Sc = Src->GetList(FIELD_MIME_SEG);
 	LDataIt Dc = Dst->GetList(FIELD_MIME_SEG);
 	if (Dc && Sc)
 	{
 		for (unsigned i=0; i<Sc->Length(); i++)
 		{
 			// Create new dest child, and merge the source child across
 			LDataPropI *NewDestChild = Dc->Create(Dst->GetStore());
 			if (!MergeSegments(NewDestChild, (*Sc)[i], Dom))
 				return false;
 
 			LDataI *NewDest = dynamic_cast<LDataI*>(NewDestChild);
 			if (NewDest)
 				NewDest->Save(Dst);
 		}
 	}
 
 	return true;
 }
 
 // Either 'FileName' or 'Source' will be valid
 void ScribeWnd::MailMerge(LArray<ListAddr*> &Contacts, const char *FileName, Mail *Source)
 {
 	ScribeFolder *Outbox = GetFolder(FOLDER_OUTBOX);
 
 	if (Outbox && Contacts.Length() && (FileName || Source))
 	{
 		LAutoPtr<Mail> ImportEmail;
 		if (FileName)
 		{
 			LAutoPtr<LFile> File(new LFile);
 			if (File->Open(FileName, O_READ))
 			{
 				Thing *t = CreateItem(MAGIC_MAIL, Outbox, false);
 				ImportEmail.Reset(Source = t->IsMail());
 				if (!Source->Import(Source->AutoCast(File), sMimeMessage))
 				{
 					Source = 0;
 				}
 			}
 		}
 		
 		if (Source)
 		{
 			List<Mail> Msgs;
 			ScribeDom Dom(this);
 
 			// Do the merging of the document with the database
 			for (unsigned i=0; i<Contacts.Length(); i++)
 			{
 				ListAddr *la = Contacts[i];
 				RecipientItem *ri = (*la)[0];
 				Contact *c = ri ? ri->GetContact() : 0;
 				Contact *temp = new Contact(this);
 				if (!c)
 				{
 					temp->SetFirst(la->sName);
 					temp->SetEmail(la->sAddr);
 					c = temp;
 				}
 
 				Dom.Con = c;
 				Thing *t = CreateItem(MAGIC_MAIL, Outbox, false);
 				if (t)
 				{
 					Dom.Email = t->IsMail();
 					
 					LAutoString s;
 					if (s.Reset(ScribeInsertFields(Source->GetSubject(), &Dom)))
 						Dom.Email->SetSubject(s);
 					LDataPropI *Recip = Dom.Email->GetTo()->Create(Dom.Email->GetObject()->GetStore());
 					if (Recip)
 					{
 						Recip->CopyProps(*Dom.Con->GetObject());
 						Recip->SetInt(FIELD_CC, 0);
 						Dom.Email->GetTo()->Insert(Recip);
 					}
 					MergeSegments(	Dom.Email->GetObject()->GetObj(FIELD_MIME_SEG),
 									Source->GetObject()->GetObj(FIELD_MIME_SEG),
 									&Dom);
 
 					Msgs.Insert(Dom.Email);
 				}
 
 				temp->DecRef();
 			}
 
 			// Ask user what to do
 			if (Msgs[0])
 			{
 				char Msg[256];
 				sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_MAIL_MERGE_Q), Msgs.Length());
 				
 				auto Ask = new LAlert(this, AppName, Msg,
 					LLoadString(IDS_SAVE_TO_OUTBOX), LLoadString(IDS_CANCEL));
 
 				Ask->DoModal([this, Msgs, Outbox](auto dlg, auto id)
 				{
 					switch (id)
 					{
 						case 1: // Save To Outbox
 						{
 							for (size_t i=0; i<Msgs.Length(); i++)
 							{
 								Msgs[i]->Save(Outbox);
 							}
 							break;
 						}
 						case 2: // Cancel
 						{
 							for (size_t i=0; i<Msgs.Length(); i++)
 							{
 								Msgs[i]->OnDelete();
 							}
 							break;
 						}
 					}
 					delete dlg;
 				});
 			}
 			else
 			{
 				LgiMsg(this, LLoadString(IDS_MAIL_MERGE_EMPTY), AppName);
 			}
 		}
 	}
 }
 
 ScribeFolder *CastFolder(LDataI *f)
 {
 	if (!f)
 	{
 		LAssert(!"Null pointer");
 		return 0;
 	}
 
 	if (f->Type() == MAGIC_FOLDER)
 	{
 		return (ScribeFolder*)f->UserData;
 	}
 
 	return 0;
 }
 
 Thing *CastThing(LDataI *t)
 {
 	if (!t)
 	{
 		LAssert(!"Null pointer");
 		return 0;
 	}
 
 	if (t->Type() == MAGIC_FOLDER)
 	{
 		LAssert(!"Shouldn't be a folder");
 		return 0;
 	}
 
 	return (Thing*)t->UserData;
 }
 
 LString _GetUids(LArray<LDataI*> &items)
 {
 	LString::Array a;
 	for (auto i: items)
 		a.New().Printf(LPrintfInt64, i->GetInt(FIELD_SERVER_UID));
 	return LString(",").Join(a);
 }
 
 /// Received new items from a storage backend.
 void ScribeWnd::OnNew(
 	/// The parent folder of the new item
 	LDataFolderI *Parent,
 	/// All the new items
 	LArray<LDataI*> &NewItems,
 	/// The position in the parent folder or -1
 	int Pos,
 	/// Non-zero if the object is a new email.
 	bool IsNew)
 {
 	ScribeFolder *Fld = CastFolder(Parent);
 	int UnreadDiff = 0;
 
 	if (Stricmp(Parent->GetStr(FIELD_FOLDER_NAME), "Contacts") &&
 		Stricmp(Parent->GetStr(FIELD_FOLDER_NAME), "Calendar"))
 	{
 		LOG_STORE("OnNew(%s, %s, %i, %i)\n", Parent->GetStr(FIELD_FOLDER_NAME), _GetUids(NewItems).Get(), Pos, IsNew);
 	}
 
 	if (!Fld)
 	{
 		// When this happens the parent hasn't been loaded by the UI thread
 		// yet, so if say the IMAP back end notices a new sub-folder then we
 		// can safely ignore it until such time as the UI loads the parent
 		// folder. At which point the child we got told about here will be 
 		// loaded anyway.
 
 		#if DEBUG_NEW_MAIL
 		LDataFolderI *p = dynamic_cast<LDataFolderI*>(Parent);
 		LgiTrace("%s:%i - NewMail.OnNew no UI object for '%s'\n", _FL, p ? p->GetStr(FIELD_FOLDER_NAME) : NULL);
 		#endif
 		return;
 	}
 	
 	if (!Parent || !NewItems.Length())
 	{
 		LAssert(!"Param error");
 		return;
 	}
 
 	for (auto cb: d->Store3EventCallbacks)
 		cb->OnNew(Parent, NewItems, Pos, IsNew);
 
 	List<Mail> NewMail;
 	for (auto Item: NewItems)
 	{
 		if (Item->Type() == MAGIC_FOLDER)
 		{
 			// Insert new folder into the right point on the tree...
 			LDataFolderI *SubObject = dynamic_cast<LDataFolderI*>(Item);
 			if (!SubObject)
 			{
 				LAssert(!"Not a valid folder.");
 				continue;
 			}
 			
 			
 			ScribeFolder *Sub = CastFolder(SubObject);
 			// LgiTrace("OnNew '%s', Sub=%p Children=%i\n", SubObject->GetStr(FIELD_FOLDER_NAME), Sub, SubObject->SubFolders().Length());
 
 			if (!Sub)
 			{
 				// New folder...
 				if ((Sub = new ScribeFolder))
 				{
 					Sub->App = this;
 					Sub->SetObject(SubObject, false, _FL);
 
 					Fld->Insert(Sub);
 				}
 			}
 			else
 			{
 				// Existing folder...
 				Fld->Insert(Sub, Pos);
 			}
 		}
 		else
 		{
 			Thing *t = CastThing(Item);
 			if (!t)
 			{
 				// Completely new thing...
 				t = CreateThingOfType((Store3ItemTypes) Item->Type(), Item);
 			}
 			
 			if (t)
 			{
 				if (t->DeleteOnAdd.Obj)
 				{
 					// Complete a delayed move
 					auto OldFolder = t->App->GetFolder(t->DeleteOnAdd.Path);
 					if (!OldFolder)
 					{
 						LgiTrace("%s:%i - Couldn't resolve old folder '%s'\n", _FL, t->DeleteOnAdd.Path.Get());
 					}
 					else
 					{
 						auto OldItem = t->DeleteOnAdd.Obj;
 						if (!OldFolder->Items.HasItem(OldItem))
 							LgiTrace("%s:%i - Couldn't find old obj.\n", _FL);
 						else
 							OldItem->OnDelete();
 					}
 				}
 
 				t->SetParentFolder(Fld);
 				Fld->Update();
 
 				if (Fld->Select())
 				{
 					// Existing thing...
 					t->SetFieldArray(Fld->GetFieldArray());
 
 					ThingFilter *Filter = GetThingFilter();
 					if (!Filter || Filter->TestThing(t))
 					{
 						MailList->Insert(t, -1, false);
 					}
 				}
 
 				Mail *m = t->IsMail();
 				if (m)
 				{
 					// LgiTrace("OnNew %p\n", m->GetObject());
 					UnreadDiff += TestFlag(m->GetFlags(), MAIL_READ) ? 0 : 1;
 
 					#if DEBUG_NEW_MAIL
 					LgiTrace("%s:%i - NewMail.OnNew t=%p uid=%s IsNew=%i\n", _FL, t, m->GetServerUid().ToString().Get(), IsNew);
 					#endif
 
 					if (IsNew)
 					{
 						LAssert(!NewMail.HasItem(m));
 						NewMail.Insert(m);
 					}
 				}
 
 				t->Update();
 			}
 		}
 	}
 
 	if (UnreadDiff)
 		Fld->OnUpdateUnRead(UnreadDiff, false);
 
 	if (MailList && Fld->Select())
 		MailList->Sort(ListItemCompare, (NativeInt)Fld);
 
 	if (NewMail.Length())
 		OnNewMail(&NewMail);
 }
 
 void ScribeWnd::OnPropChange(LDataStoreI *store, int Prop, LVariantType Type)
 {
 	switch (Prop)
 	{
 		case FIELD_IS_ONLINE:
 		{
 			// This is in case we receive a message after the app has shutdown and
 			// deleted 'this'.
 			if (ScribeState > ScribeRunning)
 				break;
 			
 			if (StatusPanel)
 				StatusPanel->Invalidate();
 			
 			for (auto a : Accounts)
 			{
 				if (a->Receive.GetDataStore() == store)
 				{
 					int64 Online = store->GetInt(FIELD_IS_ONLINE);
 
 					auto Old = ScribeState;
 
 					// This prevents the folders unloading during this call.
 					// Which causes crashes.
 					ScribeState = ScribeLoadingFolders;
 
 					a->Receive.OnOnlineChange(Online != 0);
 					ScribeState = Old;
 					break;
 				}
 			}
 			break;
 		}
 	}
 }
 
 void ScribeWnd::SetContext(const char *file, int line)
 {
 	d->CtxFile = file;
 	d->CtxLine = line;
 }
 
 bool ScribeWnd::OnChange(LArray<LDataI*> &items, int FieldHint)
 {
 	bool UpdateSelection = false;
 	List<Mail> NewMail;
 	ScribeFolder *Parent = 0;
 
 	// LOG_STORE("OnChange(%i, %i)\n", (int)items.Length(), FieldHint);
 	LAssert(d->CtxFile != NULL);
 
 	for (unsigned c=0; c<d->Store3EventCallbacks.Length(); c++)
 	{
 		d->Store3EventCallbacks[c]->OnChange(items, FieldHint);
 	}
 
 	for (unsigned i=0; i<items.Length(); i++)
 	{
 		LDataI *Item = items[i];
 		Thing *t;
 
 		if (Item->Type() == MAGIC_FOLDER)
 		{
 			auto ItemFolder = dynamic_cast<LDataFolderI*>(Item);
 			ScribeFolder *fld = CastFolder(ItemFolder);
 			if (fld)
 			{
 				if (FieldHint == FIELD_STATUS)
 				{
 					// This is the delayed folder load case:
 					fld->IsLoaded(true);
 					if (fld->Select())
 						fld->Populate(GetMailList());
 				}
 				else
 				{
 					fld->Update();
 				}
 			}
 			else
 			{
 				// LAssert(!"Can't cast to folder?");
 			}
 		}
 		else if ((t = CastThing(Item)))
 		{
 			ThingUi *Ui = t->GetUI();
 			if (Ui)
 				Ui->OnChange();
 				
 			Mail *m = t->IsMail();
 			if (m)
 			{
 				auto StoreFlags = Item->GetInt(FIELD_FLAGS);
 
 				#if 0
 				LgiTrace("App.OnChange(%i) handler %p: %s -> %s\n", 
 					FieldHint, m,
 					EmailFlagsToStr(m->FlagsCache).Get(),
 					EmailFlagsToStr(StoreFlags).Get());
 				#endif
 				
 				if (TestFlag(m->FlagsCache, MAIL_NEW) &&
 					!TestFlag(StoreFlags, MAIL_NEW))
 				{
 					Mail::NewMailLst.Delete(m);
 					Parent = m->GetFolder();
 				}
 					
 				if (m->FlagsCache != StoreFlags)
 				{
 					// LgiTrace("%s:%i - OnChange mail flags changed.\n", _FL);
 					m->SetFlagsCache(StoreFlags, false, false);
 					Parent = m->GetFolder();
 				}
 
 				if (m->NewEmail == Mail::NewEmailLoading)
 				{
 					auto Loaded = m->GetLoaded();
 					if (Loaded < Store3Loaded)
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnChange.GetBody t=%p, uid=%s, mode=%s, loaded=%s (%s:%i)\n",
 							_FL, (Thing*)m, m->GetServerUid().ToString().Get(),
 							toString(m->NewEmail), toString(Loaded),
 							d->CtxFile, d->CtxLine);
 						#endif
 
 						m->GetBody();
 					}
 					else
 					{
 						#if DEBUG_NEW_MAIL
 						LgiTrace("%s:%i - NewMail.OnChange.NewMail t=%p, uid=%s, mode=%s, loaded=%s (%s:%i)\n",
 							_FL, (Thing*)m, m->GetServerUid().ToString().Get(),
 							toString(m->NewEmail), toString(Loaded),
 							d->CtxFile, d->CtxLine);
 						#endif
 
 						NewMail.Insert(m);
 					}
 				}
 			}
 			else if (t->IsCalendar())
 			{
 				for (auto cv: CalendarView::CalendarViews)
 					cv->OnContentsChanged();
 			}
 
 			if (FieldHint != FIELD_FLAGS)
 			{
 				// Call the on load handler...
 				t->IsLoaded(true);
 			}
 
 			if (t->GetList())
 			{
 				t->Update();
 				if (FieldHint != FIELD_FLAGS)
 					UpdateSelection |= t->Select();
 			}
 		}
 	}
 
 	if (MailList && UpdateSelection)
 	{
 		List<Thing> Sel;
 		if (MailList->GetSelection(Sel))
 		{
 			OnSelect(&Sel, true);
 		}
 	}
 
 	if (Parent)
 		Parent->OnUpdateUnRead(0, true);
 
 	if (NewMail.Length())
 		OnNewMail(&NewMail);
 
 	d->CtxFile = NULL;
 	d->CtxLine = 0;
 	return true;
 }
 
 ContactGroup *ScribeWnd::FindGroup(char *SearchName)
 {
 	ScribeFolder *g = GetFolder(FOLDER_GROUPS);
 	if (!g || !SearchName)
 		return 0;
 
 	g->LoadThings();
 	for (Thing *t: g->Items)
 	{
 		ContactGroup *Grp = t->IsGroup();
 		if (!Grp)
 			continue;
 
 		auto Name = Grp->GetObject()->GetStr(FIELD_GROUP_NAME);
 		if (Name)
 		{
 			if (!_stricmp(Name, SearchName))
 			{
 				return Grp;
 			}
 		}
 	}
 
 	return 0;
 }
 
 bool ScribeWnd::Match(LDataStoreI *Store, LDataPropI *Address, int ObjType, LArray<LDom*> &Matches)
 {
 	if (!Store || !Address)
 		return 0;
 
 	// char *Addr = Address->GetStr(ObjType == MAGIC_CONTACT ? FIELD_EMAIL : FIELD_NAME);
 	auto Addr = Address->GetStr(FIELD_EMAIL);
 	if (!Addr)
 		return 0;
 
 	List<Contact> *l = GetEveryone();
 	if (!l)
 		return 0;
 
 	Matches.Length(0);
 
 	if (ObjType == MAGIC_CONTACT)
 	{
 		for (auto c: *l)
 		{
 			if (strchr(Addr, '@'))
 			{
 				auto Emails = c->GetEmails();
 				for (auto e: Emails)
 				{
 					if (e.Equals(Addr))
 					{
 						Matches.Add(c);
 						break;
 					}
 				}
 			}
 		}
 	}
 	else if (ObjType == MAGIC_GROUP)
 	{
 		ScribeFolder *g = GetFolder(FOLDER_GROUPS);
 		if (!g)
 			return false;
 
 		g->LoadThings();
 		for (auto t: g->Items)
 		{
 			ContactGroup *Grp = t->IsGroup();
 			if (!Grp)
 				continue;
 
 			List<char> GrpAddr;
 			if (!Grp->GetAddresses(GrpAddr))
 				continue;
 
 			for (auto a: GrpAddr)
 			{
 				if (_stricmp(a, Addr) == 0)
 				{
 					Matches.Add(t);
 					break;
 				}
 			}
 
 			GrpAddr.DeleteArrays();
 		}
 	}
 
 
 	return Matches.Length() > 0;
 }
 
 bool ScribeWnd::OnMove(LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items)
 {
 	if (!new_parent || items.Length() == 0)
 		return false;
 
 	bool Status = false;
 
 	for (auto cb: d->Store3EventCallbacks)
 		cb->OnMove(new_parent, old_parent, items);
 
 	ScribeFolder *New = CastFolder(new_parent);
 	ScribeFolder *Old = old_parent ? CastFolder(old_parent) : NULL;
 	if (New)
 	{
 		ssize_t SelIdx = -1;
 		for (unsigned n=0; n<items.Length(); n++)
 		{
 			switch ((uint32_t)items[n]->Type())
 			{
 				case MAGIC_FOLDER:
 				{
 					ScribeFolder *i = CastFolder(items[n]);
 					if (i)
 					{
 						i->Detach();
 						New->Insert(i);
 						Status = true;
 					}
 					break;
 				}
 				default:
 				{
 					Thing *t = CastThing(items[n]);
 					if (t)
 					{
 						int UnreadMail = t->IsMail() ? !TestFlag(t->IsMail()->GetFlags(), MAIL_READ) : false;
 
 						if (Old && UnreadMail)
 							Old->OnUpdateUnRead(-1, false);
 
 						if (t->GetList())
 						{
 							if (t->Select() && SelIdx < 0)
 								SelIdx = t->GetList()->IndexOf(t);
 							t->GetList()->Remove(t);
 						}
 						
 						// This closes the user interface if the object is being moved to the trash...
 						if (New->GetSystemFolderType() == Store3SystemTrash)
 							t->SetUI();
 
 						t->SetParentFolder(New);
 						if (New->Select())
 						{
 							MailList->Insert(t);
 							MailList->ReSort();
 						}
 						if (UnreadMail) New->OnUpdateUnRead(1, false);
 						if (New->GetItemType() == MAGIC_ANY &&
 							t->IsMail())
 						{
 							Mail::NewMailLst.Delete(t->IsMail());
 						}
 
 						Status = true;
 					}
 					break;
 				}
 			}
 		}
 
 		if (MailList && SelIdx >= 0 && MailList->Length() > 0)
 		{
 			if (SelIdx >= (ssize_t)MailList->Length())
 				SelIdx = MailList->Length()-1;
 			MailList->Value(SelIdx);
 		}
 	}
 
 	return Status;
 }
 
 bool ScribeWnd::OnDelete(LDataFolderI *Parent, LArray<LDataI*> &Items)
 {
 	int UnreadAdjust = 0;
 	int SelectIdx = -1;
 
 	LOG_STORE("OnDelete(%s, %i)\n", Parent->GetStr(FIELD_FOLDER_NAME), (int)Items.Length());
 
 	if (!Items.Length())
 		return false;
 
 	for (unsigned c=0; c<d->Store3EventCallbacks.Length(); c++)
 	{
 		d->Store3EventCallbacks[c]->OnDelete(Parent, Items);
 	}
 
 	ScribeFolder *Fld = NULL;
 	for (unsigned i=0; i<Items.Length(); i++)
 	{
 		LDataI *Item = Items[i];
 
 		if (Item->Type() == MAGIC_FOLDER)
 		{
 			// Insert new folder into the right point on the tree...
 			ScribeFolder *Sub = CastFolder(Item);
 			if (!Sub)
 				return true;
 
 			LgiTrace("OnDelete folder %p (%i)\n", (ThingType*)Sub, ThingType::DirtyThings.HasItem(Sub));
 			// Remove the deleted object from the dirty queue...
 			ThingType::DirtyThings.Delete(Sub);
 			// And make sure it can't get dirty again...
 			Sub->SetWillDirty(false);
 
 			// Remove all the children
 			LDataIterator<LDataI*> &SubItems = Sub->GetFldObj()->Children();
 			LArray<LDataI*> Children;
 			for (LDataI *c = SubItems.First(); c; c = SubItems.Next())
 			{
 				Children.Add(c);
 			}
 			OnDelete(Sub->GetFldObj(), Children);
 
 			// Remove the UI element
 			Sub->Remove();
 			
 			// Free the memory for the object
 			DeleteObj(Sub);
 		}
 		else
 		{
 			Fld = Parent ? CastFolder(Parent) : 0;
 			if (!Fld)
 				return false;
 
 			Thing *t = CastThing(Item);
 			if (!t)
 			{
 				// This happens when the item moves from one store to another
 				// of a different type and a copy of the old object is made. The
 				// 'Thing' is detached from 'Item' and attached to the new LDataI
 				// object.
 
 				// However if the object is an unread email... we should still decrement the 
 				// folder's unread count.
 				if (Item->Type() == MAGIC_MAIL &&
 					!(Item->GetInt(FIELD_FLAGS) & MAIL_READ))
 				{
 					Fld->OnUpdateUnRead(-1, false);
 				}
 			}
 			else
 			{
 				LAssert(!Fld || Fld == t->GetFolder());
 				
 				// LgiTrace("OnDelete thing %p (%i)\n", (ThingType*)t, ThingType::DirtyThings.HasItem(t));
 				
 				// Remove the deleted object from the dirty queue...
 				ThingType::DirtyThings.Delete(t);
 				// And make sure it can't get dirty again...
 				t->SetWillDirty(false);
 				
 				// Was the thing currently being previewed?
 				if (PreviewPanel && PreviewPanel->GetCurrent() == t)
 					PreviewPanel->OnThing(0, false);
 
 				// Was the object selected in the thing list?
 				if (Fld && Fld->Select())
 				{
 					// If so, select an adjacent item.
 					if (SelectIdx < 0 && t->Select())
 						SelectIdx = MailList->IndexOf(t);
 					MailList->Remove(t);
 				}
 
 				// Was the object an unread email?
 				Mail *m = t->IsMail();
 				if (m)
 				{
 					if (!TestFlag(m->GetFlags(), MAIL_READ) && Fld)
 						UnreadAdjust--;
 					Mail::NewMailLst.Delete(m);
 				}
 
 				t->SetUI();
 				t->SetParentFolder(NULL);
 				t->SetObject(NULL, false, _FL);
 
 				if (Fld)
 					Fld->Update();
 
 				if (!t->DecRef())
 				{
 					t->SetDirty(false);
 					t->SetWillDirty(false);
 				}
 			}
 		}
 	}
 
 	if (Fld)
 		Fld->OnUpdateUnRead(UnreadAdjust, false);
 
 	if (SelectIdx >= 0)
 	{
 		LListItem *i = MailList->ItemAt(SelectIdx);
 		if (!i && MailList->Length() > 0)
 			i = MailList->ItemAt(MailList->Length()-1);
 		if (i)
 			i->Select(true);
 	}
 
 	return true;
 }
 
 bool ScribeWnd::AddStore3EventHandler(LDataEventsI *callback)
 {
 	if (!d->Store3EventCallbacks.HasItem(callback))
 	{
 		d->Store3EventCallbacks.Add(callback);
 	}
 	return true;
 }
 
 bool ScribeWnd::RemoveStore3EventHandler(LDataEventsI *callback)
 {
 	d->Store3EventCallbacks.Delete(callback);
 	return true;
 }
 
 bool ScribeWnd::OnMailTransferEvent(MailTransferEvent *t)
 {
 	if (!Lock(_FL))
 		return false;
 
 	LAssert(t);
 	d->Transfers.Add(t);
 	Unlock();
 	
 	return true;
 }
 
 bool ScribeWnd::OnTransfer()
 {
 	LVariant v;
 	LArray<MailTransferEvent*> Local;
 	
 	// Lock the transfer list
 	if (Lock(_FL))
 	{
 		// Take out a bunch of emails...
 		for (int i=0; i<5 && d->Transfers.Length() > 0; i++)
 		{
 			auto t = d->Transfers[0];
 			LAssert(t);
 			d->Transfers.DeleteAt(0, true);
 
 			// Save them to a local array
 			Local.Add(t);
 		}
 
 		Unlock();
 
 		if (Local.Length() == 0)
 			// Didn't get any
 			return false;
 	}
 
 	LArray<LDataStoreI::StoreTrans> Trans;
 	for (auto &f: Folders)
 	{
 		if (f.Store)
 			Trans.New() = f.Store->StartTransaction();
 	}
 
 	for (auto Transfer: Local)
 	{
 		ReceiveStatus NewStatus = MailReceivedError;
 
 		if (!Transfer)
 		{
 			LAssert(0);
 			continue;
 		}
 		
 		// We have to set Transfer->Status to something other than "waiting"
 		// in all branches of this loop. Otherwise the account thread will hang.
 		
 		Accountlet *Acc = Transfer->Account;
 		#if DEBUG_NEW_MAIL
 		LgiTrace(	"%s:%i - NewMail.OnTransfer t=%p receive=%i act=%i\n",
 					_FL, Transfer, Acc->IsReceive(), Transfer->Action);
 		#endif
 		if (Acc->IsReceive())
 		{
 			switch (Transfer->Action)
 			{
 				default: break;
 				case MailDownload:
 				case MailDownloadAndDelete:
 				{
 					// Import newly received mail from file
 					ReceiveAccountlet *Receive = dynamic_cast<ReceiveAccountlet*>(Acc);
 					if (Receive)
 					{
 						LVariant Path = Receive->DestinationFolder();
 						ScribeFolder *Inbox = Path.Str() ? GetFolder(Path.Str()) : NULL;
 						if (!Inbox)
 							Inbox = GetFolder(FOLDER_INBOX);
 
 						if (Inbox)
 						{
 							Mail *m = new Mail(this, Inbox->GetObject()->GetStore()->Create(MAGIC_MAIL));
 							if (m)
 							{
 								// Just in case
 								m->SetParentFolder(Inbox);
 								
 								// Set the new flag...
 								m->SetFlags(m->GetFlags() | MAIL_NEW, true, false);
 
 								// Set the account to, which is used to map the email back
 								// to the incoming account in the case that the headers
 								// don't have the correct "To" information.
 								m->SetAccountId(Receive->Id());
 
 								// Decode the email
 								m->OnAfterReceive(Transfer->Rfc822Msg);
 								
 								LVariant v;
 								m->SetServerUid(v = Transfer->Uid);
 
 								// Save to permanent storage
 								if (m->Save(Inbox))
 								{
 									m->SetDirty(false);
 									
 									NewStatus = MailReceivedOk;
 
 									// Only after we've safely stored the email can we 
 									// actually mark it as downloaded.
 									if (Transfer->Uid)
 									{
 										Receive->AddMsg(Transfer->Uid);
 									}
 								}
 								else LgiTrace("%s:%i - Error: Couldn't save mail to folders.\n", _FL);
 							}
 							else LgiTrace("%s:%i - Error: Memory alloc failed.\n", _FL);
 						}
 						else LgiTrace("%s:%i - Error: No Inbox.\n", _FL);
 					}
 					else LgiTrace("%s:%i - Error: Bad ptr.\n", _FL);
 					
 					break;
 				}
 				case MailHeaders:
 				{
 					LList *Lst;
 					if (Transfer->Msg &&
 						(Lst = Transfer->GetList()))
 					{
 						//LgiTrace("Using Lst=%p\n", Lst);
 						Lst->Insert(Transfer->Msg);
 						NewStatus = MailReceivedOk;
 					}
 					break;
 				}
 			}
 		}
 		else if (Transfer->Send)
 		{
 			ScribeFolder *Outbox = GetFolder(Transfer->Send->SourceFolder);
 			if (!Outbox)
 				Outbox = GetFolder(FOLDER_OUTBOX);
 			if (!Outbox)
 				break;
 				
 			Outbox->GetMessageById(Transfer->Send->MsgId, [this, Transfer](auto m)
 			{
 				if (!m)
 				{
 					LAssert(!"Where is the email?");
 					LgiTrace("%s:%i - Can't find outbox for msg id '%s'\n", _FL, Transfer->Send->MsgId.Get());
 				}
 				else
 				{
 					if (Transfer->OutgoingHeaders)
 					{
 						m->SetInternetHeader(Transfer->OutgoingHeaders);
 						DeleteArray(Transfer->OutgoingHeaders);
 					}
 					
 					m->OnAfterSend();
 					m->Save();
 
 					// Do filtering
 					LVariant DisableFilters;
 					GetOptions()->GetValue(OPT_DisableUserFilters, DisableFilters);
 					if (!DisableFilters.CastInt32())
 					{
 						// Run the filters
 						List<Filter> Filters;
 						GetFilters(Filters, false, true, false);
 						if (Filters[0])
 						{													
 							List<Mail> In;
 							In.Insert(m);
 							
 							Filter::ApplyFilters(0, Filters, In);
 						}
 					}
 
 					// Add to bayesian spam whitelist...
 					LVariant v;
 					ScribeBayesianFilterMode FilterMode = BayesOff;
 					GetOptions()->GetValue(OPT_BayesFilterMode, v);
 					FilterMode = (ScribeBayesianFilterMode) v.CastInt32();
 
 					if (FilterMode != BayesOff &&
 						m->GetObject())
 					{
 						LDataIt To = m->GetObject()->GetList(FIELD_TO);
 						if (To)
 						{
 							for (LDataPropI *a = To->First();
 								a;
 								a = To->Next())
 							{
 								if (a->GetStr(FIELD_EMAIL))
 									WhiteListIncrement(a->GetStr(FIELD_EMAIL));
 							}
 						}
 					}
 
 					// FIXME:
 					// NewStatus = MailReceivedOk;
 				}
 			});
 		}
 
 		#if DEBUG_NEW_MAIL
 		LgiTrace(	"%s:%i - NewMail.OnTransfer t=%p NewStatus=%i\n",
 					_FL, Transfer, NewStatus);
 		#endif
 
 		if (NewStatus != MailReceivedOk)
 		{
 			// So tell the thread not to delete it from the server
 			LgiTrace("%s:%i - Mail[%i] error: %s\n", _FL, Transfer->Index, ReceiveStatusName(Transfer->Status));
 			Transfer->Action = MailNoop;
 		}
 
 		Transfer->Status = NewStatus;
 	}
 
 	return Local.Length() > 0;
 }
 
 bool ScribeWnd::OnIdle()
 {
 	bool Status = false;
 	
 	for (auto a : Accounts)
 		Status |= a->Receive.OnIdle();
 
 	Status |= OnTransfer();
 
 	LMessage m(M_SCRIBE_IDLE);
 	BayesianFilter::OnEvent(&m);
 
 	SaveDirtyObjects();	
 
 	#ifdef _DEBUG
 	static uint64_t LastTs = 0;
 	auto Now = LCurrentTime();
 	if (Now - LastTs >= 1000)
 	{
 		LastTs = Now;
 		if (Thing::DirtyThings.Length() > 0)
 			LgiTrace("%s:%i - Thing::DirtyThings=" LPrintfInt64 "\n", _FL, Thing::DirtyThings.Length());
 	}
 	#endif
 
 	return Status;
 }
 
 void ScribeWnd::OnScriptCompileError(const char *Source, Filter *f)
 {
 	const char *CompileMsg = LLoadString(IDS_ERROR_SCRIPT_COMPILE);
 	LArray<const char*> Actions;
 	Actions.Add(LLoadString(IDS_SHOW_CONSOLE));
 	Actions.Add(LLoadString(IDS_OPEN_SOURCE));
 	Actions.Add(LLoadString(IDS_OK));
 	if (!d->Bar)
 	{
 		// FYI Capabilities are handled in ScribeWnd::StartAction.
 		d->ErrSource = Source;
 		d->ErrFilter = f;
 		d->Bar = new MissingCapsBar(this, &d->MissingCaps, CompileMsg, this, Actions);
 		AddView(d->Bar, 2);
 		AttachChildren();
 		OnPosChange();
 	}
 }
 
 #ifdef _DEBUG
 #include "Store3Mail3/Mail3.h"
 
 class NoSaveOptions : public LOptionsFile
 {
 	bool Serialize(bool Write) { return true; }
 public:
 	NoSaveOptions(LOptionsFile *opts) :
 		LOptionsFile(PortableMode, AppName)
 	{
 	}
 };
 
 struct ScribeUnitTest
 {
 	uint64_t StartTs = 0;
 	int Timeout = 5000;
 
 	virtual ~ScribeUnitTest() {}
 	virtual void OnTimeout() {}
 	virtual void Run(std::function<void(bool)> Callback) = 0;
 
 	virtual void OnPulse()
 	{
 		if (StartTs != 0 &&
 			LCurrentTime() - StartTs >= Timeout)
 		{
 			LgiTrace("%s:%i - UnitTest timed out.\n", _FL);
 			StartTs = 0;
 			OnTimeout();
 		}
 	}
 };
 
 struct UnitTestState :
 	public LView::ViewEventTarget,
 	public LThread,
 	public LCancel
 {
 	ScribeWnd *App = NULL;
 	NoSaveOptions *Opts = NULL;
 	std::function<void(bool)> Callback;
 	LArray<ScribeUnitTest*> Tests;
 	LAutoPtr<ScribeUnitTest> t;
 	bool Status = true;
 	bool IsFinished = false;
 
 	// Old app state..
 	LAutoPtr<LOptionsFile> OldOpts;
 	LArray<LMailStore> OldFolders;
 
 	UnitTestState(ScribeWnd *app, std::function<void(bool)> callback);
 	~UnitTestState();
 	LMessage::Result OnEvent(LMessage *Msg) override;
 	bool Iterate();
 	bool Done();
 	int Main() override;
 	LDataStoreI *CreateTestMail3();
 
 	// Wrappers for protected elements:
 	LArray<LMailStore> &GetFolders() { return App->Folders; }
 	void UnLoadFolders() { App->UnLoadFolders(); }
 };
 
 #define UnitTestFail()	{ if (Callback) Callback(false); return; }
 #define UnitTestPass()	{ if (Callback) Callback(true); return; }
 
 // Basic load mail3 folder...
 struct LoadMailStore1 : public ScribeUnitTest
 {
 	UnitTestState *s;
 	LString folderPath;
 	bool GotCallback = false;
 	std::function<void(bool)> Callback;
 
 	LoadMailStore1(UnitTestState *state) : s(state)
 	{
 	}
 
 	~LoadMailStore1()
 	{
 		if (folderPath)
 		{
 			s->UnLoadFolders();
 
 			LFile::Path p = folderPath;
 			p--;
 			FileDev->RemoveFolder(p, true);
 		}
 		LAssert(GotCallback);
 	}
 
 	// Do operations on mail store before we try and load it...
 	virtual void OnMailStore(LDataStoreI *store) {}
 	virtual void ConfigureLoadMailStoreState(LoadMailStoreState *state) {}
 
 	void OnTimeout()
 	{
 		GotCallback = true;
 		Callback(false); // This should delete 'this'
 	}
 
 	void Run(std::function<void(bool)> cb)
 	{
 		Callback = cb;
 
 		if (auto store = s->CreateTestMail3())
 		{
 			folderPath = store->GetStr(FIELD_NAME);
 			OnMailStore(store);
 			delete store;
 		}
 
 		// Setup the options saying what folders to load...
 		s->Opts->CreateTag(OPT_MailStores);
 		auto MailStores = s->Opts->LockTag(OPT_MailStores, _FL);
 		if (MailStores == NULL)
 			UnitTestFail();
 
 		auto ms = MailStores->CreateTag(OPT_MailStore);
 		ms->SetAttr(OPT_MailStoreLocation, folderPath);
 		ms->SetAttr(OPT_MailStoreDisable, "0");
 		ms->SetAttr(OPT_MailStoreName, "testing");
 
 		s->Opts->Unlock();
 		if (!ms)
 			UnitTestFail();
 
 		// Try the load...
 		if (auto state = new LoadMailStoreState(s->App, [this](auto status)
 			{
 				GotCallback = true;
 
 				auto &Folders = s->GetFolders();
 				if (Folders.Length() == 0)
 					UnitTestFail()
 
 				bool found = false;
 				for (auto &f: Folders)
 				{
 					if (f.Path == folderPath &&
 						f.Store != NULL)
 					{
 						found = true;
 						break;
 					}
 				}
 				if (!found)
 					UnitTestFail();
 
 				Callback(status);
 			})
 		)
 		{
 			ConfigureLoadMailStoreState(state);
 			state->Start();
 		}
 	}
 };
 
 // This tests the DB schema upgrade functionality of the mail3 store.
 struct LoadMailStore2 : public LoadMailStore1
 {
 	LoadMailStore2(UnitTestState *state) :
 		LoadMailStore1(state)
 	{
 	}
 
 	void OnMailStore(LDataStoreI *store) override
 	{
 		auto ms3 = dynamic_cast<LMail3Store*>(store);
 		if (!ms3)
 			UnitTestFail();
 
 		// Delete a field from the database so that we force an "upgrade"
 		LMail3Store::LStatement s(ms3, "alter table Calendar rename column DateModified to DateMod");
 		if (!s.Exec())
 			UnitTestFail();
 	}
 
 	// This is a simple placeholder dialog to simulate asking the user to
 	// upgrade the mail store. It then returns a 'Yes' to the callback after
 	// a few seconds.
 	struct UpgradeYes : public LWindow
 	{
 		UnitTestState *s;
 		LoadMailStoreState::IntCb Cb;
 
 		UpgradeYes(UnitTestState *state, LoadMailStoreState::IntCb cb) :
 			s(state),
 			Cb(cb)
 		{
 			Name("Upgrade Dlg");
 			
 			// Just needs to be open long enough to run the msg loop a bit.
 			SetPulse(500);
 
 			LRect r(0, 0, 100, 100);
 			SetPos(r);
 			MoveSameScreen(s->App);
 
 			if (Attach(NULL))
 				Visible(true);
 		}
 
 		void OnPulse()
 		{
 			Cb(IDYES);
 			Quit();
 		}
 	};
 
 	void ConfigureLoadMailStoreState(LoadMailStoreState *state) override
 	{
 		state->AskStoreUpgrade = [this](auto path, auto detail, auto cb)
 		{
 			new UpgradeYes(s, cb);
 		};
 	}
 };
 
 UnitTestState::UnitTestState(ScribeWnd *app, std::function<void(bool)> callback) :
 	LView::ViewEventTarget(app, M_UNIT_TEST_TICK),
 	LThread("UnitTestState"),
 	App(app),
 	Callback(callback)
 {
 	OldOpts = App->d->Options;
 	OldFolders.Swap(App->Folders);
 	App->d->Options.Reset(Opts = new NoSaveOptions(OldOpts));
 
 	Tests.Add(new LoadMailStore1(this));
 	Tests.Add(new LoadMailStore2(this));
 	
 	LgiTrace("%s:%i - Starting with " LPrintfInt64 " unit tests.\n", _FL, Tests.Length());
 	Run();
 }
 
 UnitTestState::~UnitTestState()
 {
 	Cancel();
 
 	// Restore app state...
 	App->d->Options = OldOpts;
 	OldFolders.Swap(App->Folders);
 
 	WaitForExit();
 }
 
 LMessage::Result UnitTestState::OnEvent(LMessage *Msg)
 {
 	if (!IsFinished &&
 		Msg->Msg() == M_UNIT_TEST_TICK)
 	{
 		if (t)
 			t->OnPulse();
 		else
 			Iterate();
 	}
 	return 0;
 }
 
 bool UnitTestState::Iterate()
 {
 	if (Tests.Length() == 0)
 		return Done();
 		
 	t.Reset(Tests[0]);
 	Tests.DeleteAt(0, true);
 	t->StartTs = LCurrentTime();
 	LgiTrace("%s:%i - Running unit test..\n", _FL);
 	t->Run([this](auto ok)
 	{
 		LgiTrace("%s:%i - Unit test status: %i\n", _FL, ok);
 		Status &= ok;
 		t.Reset(); // Reset for the next unit test.
 	});
 
 	return true;
 }
 
 bool UnitTestState::Done()
 {
 	// Stop more tick events..
 	IsFinished = true;
 	Cancel();
 
 	if (Callback)
 		Callback(Status);
 
 	delete this;
 	return true;
 }
 
 int UnitTestState::Main()
 {
 	while (!IsCancelled())
 	{
 		PostEvent(M_UNIT_TEST_TICK);
 		LSleep(500);
 	}
 
 	return 0;
 }
 
 LDataStoreI *UnitTestState::CreateTestMail3()
 {
 	LFile::Path p(ScribeTempPath());
 	p += "UnitTesting";
 	if (!p.Exists())
 		FileDev->CreateFolder(p);
 	p += "Folders.mail3";
 
 	return App->CreateDataStore(p, true);
 }
 
 void ScribeWnd::UnitTests(std::function<void(bool)> Callback)
 {
 	UnLoadFolders();
 	new UnitTestState(this, Callback);
 }
 
 #endif
diff --git a/src/ScribeMail.cpp b/src/ScribeMail.cpp
--- a/src/ScribeMail.cpp
+++ b/src/ScribeMail.cpp
@@ -1,10311 +1,10334 @@
 /*
 **	FILE:			ScribeMail.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			11/11/98
 **	DESCRIPTION:	Scribe Mail Object and UI
 **
 **	Copyright (C) 1998-2003, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/timeb.h>
 #include <math.h>
 
 #include "Scribe.h"
 #include "ScribePageSetup.h"
 #include "lgi/common/NetTools.h"
 #include "lgi/common/Popup.h"
 #include "lgi/common/ColourSelect.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/Html.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/ThreadEvent.h"
 #include "lgi/common/GdcTools.h"
 #include "lgi/common/Charset.h"
 
 #include "../src/common/Coding/ScriptingPriv.h"
 #include "PrintPreview.h"
 #include "ScribeListAddr.h"
 #include "PrintContext.h"
 #include "lgi/common/LgiRes.h"
 #include "Encryption/GnuPG.h"
 #include "ObjectInspector.h"
 #include "lgi/common/EventTargetThread.h"
 #include "Store3Common.h"
 #include "Tables.h"
 #include "Calendar.h"
 #include "CalendarView.h"
 #include "AddressSelect.h"
 #include "Store3Imap/ScribeImap.h"
 #include "lgi/common/TextConvert.h"
 #include "lgi/common/FileSelect.h"
 
 #include "resdefs.h"
 #include "resource.h"
 #include "lgi/common/Printer.h"
 #include "lgi/common/SubProcess.h"
 
 #define SAVE_HEADERS					0
 
 static char MsgIdEncodeChars[] = "%/";
 static char ScribeReplyClass[] = "scribe_reply";
 static char ScribeReplyStyles[] =	"margin-left: 0.5em;\n"
 									"padding-left: 0.5em;\n"
 									"border-left: 1px solid #ccc;";
 
 char DefaultTextReplyTemplate[] =
 {
 	"---------- Original Message ----------\n"
 	"To: <mail.to[0].name> &lt;<mail.to[0].email>&gt;\n"
 	"From: <mail.from.name> &lt;<mail.from.email>&gt;\n"
 	"Subject: <mail.subject>\n"
 	"Date: <mail.datesent>\n"
 	"\n"
 	"<mail.bodyastext quote=scribe.quote>\n"
 	"<cursor>\n"
 	"<mail.sig>\n"
 };
 
 char DefaultHtmlReplyTemplate[] =
 {
 	"<html>\n"
 	"<head>\n"
 	"<style>\n"
 	"	.Style1 {\n"
 	"		color: #919191;\n"
 	"	}\n"
 	"	.Style2 {\n"
 	"		font-weight: bold;\n"
 	"	}\n"
 	"	.Style3 {\n"
 	"		color: #ae0000;\n"
 	"	}\n"
 	"	</style>\n"
 	"</head>\n"
 	"<body>\n"
 	"	<p><span class='Style1'>---------- Original Message ----------</span><br>\n"
 	"	<b>To:</b> &lt;?mail.tohtml?&gt;<br>\n"
 	"	<b>From:</b> &lt;?mail.fromhtml?&gt;<br>\n"
 	"	<b>Subject:</b> &lt;?mail.subject?&gt;<br>\n"
 	"	<b>Date:</b> &lt;?mail.datesent?&gt;<br>\n"
 	"	<br>\n"
 	"	<span class='Style3'>&lt;?mail.bodyastext quote=scribe.quote?&gt;</span><br>\n"
 	"	&lt;?cursor?&gt;<br>\n"
 	"	&lt;?mail.sig[html]?&gt;</p>\n"
 	"</body>\n"
 	"</html>\n"
 };
 
 class DepthCheck
 {
 	int &i;
 
 public:
 	constexpr static int MaxDepth = 5;
 
 	DepthCheck(int &val) : i(val)
 	{
 		i++;
 		if (!*this)
 			LAssert(!"Recursion?");
 	}
 
 	~DepthCheck()
 	{
 		i--;
 	}
 
 	operator bool() const
 	{
 		return i < MaxDepth;
 	}
 };
 
 void CollectAttachments(LArray<LDataI*> *Attachments,
 						LArray<LDataI*> *Related,
 						LDataI **Text,
 						LDataI **Html,
 						LDataPropI *d,
 						Store3MimeType *ParentMime = NULL)
 {
 	if (!d)
 		return;
 
 	Store3MimeType Mt(d->GetStr(FIELD_MIME_TYPE));
 	auto FileName = d->GetStr(FIELD_NAME);
 	if (!Mt)
 		Mt = "text/plain";
 	
 	// printf("Collect %s %s\n", (char*)Mt, FileName);
 	
 	auto Att = dynamic_cast<LDataI*>(d);
 	if (ParentMime && Att && ParentMime->IsRelated() && Related)
 	{
 		auto Id = d->GetStr(FIELD_CONTENT_ID);
 		if (ValidStr(Id))
 		{
 			if (Related)
 				Related->Add(Att);
 			Att = NULL;
 		}
 		else if (Mt.IsHtml() && Html)
 		{
 			*Html = Att;
 			Att = NULL;
 		}
 	}
 
 	if (Att)
 	{
 		if (ValidStr(FileName))
 		{
 			if (Attachments)
 				Attachments->Add(Att);
 		}
 		else if (Mt.IsHtml())
 		{
 			if (Html)
 				*Html = Att;
 		}
 		else if (Mt.IsPlainText())
 		{
 			if (Text)
 				*Text = Att;
 		}
 		else if (!Mt.IsMultipart())
 		{
 			if (Attachments)
 				Attachments->Add(Att);
 		}
 
 		/*
 		if (d->GetInt(FIELD_SIZE) < (512 << 10))
 			a.Add(dynamic_cast<LDataI*>(d));
 		*/
 	}
 
 	auto It = d->GetList(FIELD_MIME_SEG);
 	if (It)
 	{
 		for (auto i = It->First(); i; i = It->Next())
 			CollectAttachments(Attachments, Related, Text, Html, i, Mt.IsMultipart() ? &Mt : NULL);
 	}
 }
 
 void RemoveReturns(char *s)
 {
 	// Delete out the '\r' chars.
 	char *In = s;
 	char *Out = s;
 	while (*In)
 	{
 		if (*In != '\r')
 		{
 			*Out++ = *In;
 		}
 		In++;
 	}
 	*Out++ = 0;
 }
 
 class XmlSaveStyles : public LXmlTree
 {
 	void OnParseComment(LXmlTag *Ref, const char *Comment, ssize_t Bytes)
 	{
 		if (Ref && Ref->IsTag("style"))
 		{
 			Ref->SetContent(Comment, Bytes);
 		}
 	}
 
 public:
 	XmlSaveStyles(int flags) : LXmlTree(flags)
 	{
 	}
 };
 
 bool ExtractHtmlContent(LString &OutHtml,
 						LString &Charset,
 						LString &Styles,
 						const char *InHtml)
 {
 	if (!InHtml)
 		return false;
 
 	XmlSaveStyles t(GXT_NO_ENTITIES | GXT_NO_DOM | GXT_NO_HEADER);
 	LXmlTag r;
 	LMemStream mem(InHtml, strlen(InHtml), false);
 	if (!t.Read(&r, &mem))
 		return false;
 	bool InHead = false;
 	LStringPipe Style;
 
 	r.Children.SetFixedLength(false);
 	for (auto It = r.Children.begin(); It != r.Children.end(); )
 	{
 		LXmlTag *c = *It;
 
 		if (c->IsTag("style"))
 		{
 			if (ValidStr(c->GetContent()))
 				Style.Print("%s\n", c->GetContent());
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("/head"))
 		{
 			InHead = false;
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("body"))
 		{
 			// We remove this tag, but KEEP the content... if any
 			if (ValidStr(c->GetContent()))
 			{
 				c->SetTag(NULL);
 				It++;
 			}
 			else
 			{
 				// No content, remove entirely.
 				c->Parent = NULL;
 				r.Children.Delete(It);
 				DeleteObj(c);
 			}
 		}
 		else if (InHead || 
 				c->IsTag("html") ||
 				c->IsTag("/html") ||
 				c->IsTag("/body") ||
 				c->IsTag("/style"))
 		{
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("head"))
 		{
 			InHead = true;
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else
 			It++;
 	}
 
 	LStringPipe p;
 	t.Write(&r, &p);
 	OutHtml = p.NewLStr();
 	Styles = Style.NewLStr();
 
 	#if 0
 	LgiTrace("InHtml=%s\n", InHtml);
 	LgiTrace("OutHtml=%s\n", OutHtml.Get());
 	LgiTrace("Styles=%s\n", Styles.Get());
 	#endif
 	
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 char MailToStr[] = "mailto:";
 char SubjectStr[] = "subject=";
 char ContentTypeDefault[] = "Content-type: text/plain; charset=us-ascii";
 
 extern LString HtmlToText(const char *Html, const char *InitialCharSet);
 extern LString TextToHtml(const char *Txt, const char *Charset);
 
 class ImageResizeThread : public LEventTargetThread
 {
 	LOptionsFile *Opts;
 
 public:
 	class Job
 	{
 		#ifdef __GTK_H__
 		/* This object may not exist when the worker is finished.
 			However LAppInst->PostEvent can handle that so we'll allow
 			it, so long as it's never used in the Sink->PostEvent form.	*/
 		LViewI *Sink;
 		#else
 		OsView Sink;
 		#endif
 
 	public:
 		LString FileName;
 		LAutoStreamI Data;
 
 		void SetSink(LViewI *v)
 		{
 			#if !LGI_VIEW_HANDLE
 			Sink = v;
 			#else
 			Sink = v->Handle();
 			#endif
 		}
 
 		bool PostEvent(int Msg, LMessage::Param a = 0, LMessage::Param b = 0)
 		{
 			#ifdef __GTK_H__
 			return LAppInst->PostEvent(Sink, Msg, a, b);
 			#else
 			return LPostEvent(Sink, Msg, a, b);
 			#endif
 		}
 	};
 
 	ImageResizeThread(LOptionsFile *opts) : LEventTargetThread("ImageResize")
 	{
 		Opts = opts;
 	}
 
 	void Resize(LAutoPtr<ImageResizeThread::Job> &Job)
 	{
 		LVariant Qual = 80, Px = 1024, SizeLimit = 200, v;
 		Opts->GetValue(OPT_ResizeJpegQual, Qual);
 		Opts->GetValue(OPT_ResizeMaxPx, Px);
 		Opts->GetValue(OPT_ResizeMaxKb, SizeLimit);
 
 		LAutoStreamI Input = Job->Data;
 		LAutoStreamI MemBuf(new LMemFile(4 << 10));
 		int64 FileSize = Input->GetSize();
 
 		LStream *sImg = dynamic_cast<LStream*>(Input.Get());
 		LAutoPtr<LSurface> Img(GdcD->Load(sImg, Job->FileName));
 		if (Img)
 		{
 			int iPx = Px.CastInt32();
 			int iKb = SizeLimit.CastInt32();
 			
 			if (Img->X() > iPx ||
 				Img->Y() > iPx ||
 				FileSize >= iKb << 10)
 			{
 				// Create a JPEG filter
 				auto Jpeg = LFilterFactory::New(".jpg", FILTER_CAP_WRITE, NULL);
 				if (Jpeg)
 				{
 					// Re-sample the image...
 					double XScale = (double) Img->X() / iPx;
 					double YScale = (double) Img->Y() / iPx;
 					// double Aspect = (double) Img->X() / Img->Y();
 					double Scale = XScale > YScale ? XScale : YScale;
 					if (Scale > 1.0)
 					{
 						int Nx = (int)(Img->X() / Scale + 0.001);
 						int Ny = (int)(Img->Y() / Scale + 0.001);
 						
 						LAutoPtr<LSurface> ResizedImg(new LMemDC(Nx, Ny, Img->GetColourSpace()));
 						if (ResizedImg)
 						{
 							if (ResampleDC(ResizedImg, Img))
 							{
 								Img = ResizedImg;
 							}
 						}
 					}
 																
 					// Compress the image..
 					LXmlTag Props;
 					Props.SetValue(LGI_FILTER_QUALITY, Qual);
 					Props.SetValue(LGI_FILTER_SUBSAMPLE, v = 1); // 2x2
 					Jpeg->Props = &Props;
 					if (Jpeg->WriteImage(dynamic_cast<LStream*>(MemBuf.Get()), Img) == LFilter::IoSuccess)
 					{
 						Job->Data = MemBuf;
 					}
 				}
 			}
 		}
 		
 		Job->PostEvent(M_RESIZE_IMAGE, (LMessage::Param)Job.Get());
 		Job.Release(); // Do this after the post event... so the deref doesn't crash.
 	}
 	
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		switch (Msg->Msg())
 		{
 			case M_RESIZE_IMAGE:
 			{
 				LAutoPtr<Job> j((Job*)Msg->A());
 				if (j)
 					Resize(j);
 				break;
 			}
 		}
 		
 		return 0;
 	}	
 };
 
 #include "lgi/common/RichTextEdit.h"
 #include "../src/common/Widgets/Editor/RichTextEditPriv.h"
 
 class MailRendererScript : public LThread, public LCancel, public LDom
 {
 	Mail *m;
 	LScriptCallback *cb;
 
 public:
 	MailRendererScript(Mail *ml, LScriptCallback *script) : m(ml), cb(script), LThread("MailRendererScript")
 	{
 		Run();
 	}
 
 	~MailRendererScript()
 	{
 		Cancel(true);
 		while (!IsExited())
 			LSleep(1);
 	}
 
 	int Main()
 	{
 		LVirtualMachine Vm;				
 		LScriptArguments Args(&Vm);
 		Args.New() = new LVariant(m->App);
 		Args.New() = new LVariant(m);
 		Args.New() = new LVariant((LDom*)this);
 		m->App->ExecuteScriptCallback(*cb, Args);
 		Args.DeleteObjects();
 		return 0;
 	}
 
 	bool CallMethod(const char *MethodName, LVariant *Ret, LArray<LVariant*> &Args)
 	{
 		ScribeDomType Method = StrToDom(MethodName);
 
 		*Ret = false;
 		switch (Method)
 		{		
 			case SdGetTemp:
 			{
 				*Ret = ScribeTempPath();
 				break;
 			}
 			case SdExecute:
 			{
 				*Ret = false;
 				if (Args.Length() >= 3)
 				{
 					auto Dir = Args[0]->Str();
 					auto Exe = Args[1]->Str();
 					auto Arg = Args[2]->Str();
 					if (Dir && Exe && Arg)
 					{
 						LSubProcess p(Exe, Arg);
 						p.SetInitFolder(Dir);
 						if (p.Start())
 						{
 							char Buf[256];
 							LStringPipe Out;
 							Out.Print("%s %s\n", Exe, Arg);
 
 							ssize_t Rd;
 							while (p.IsRunning() && !IsCancelled())
 							{
 								Rd = p.Read(Buf, sizeof(Buf));
 								if (Rd < 0)
 									break;
 								if (Rd == 0)
 									LSleep(1);
 								else
 									Out.Write(Buf, Rd);
 							}
 
 							while (!IsCancelled() && (Rd = p.Read(Buf, sizeof(Buf))) > 0)
 								Out.Write(Buf, Rd);
 
 							// LgiTrace("%s:%i - Process:\n%s\n", _FL, Out.NewLStr().Get());
 							if (p.IsRunning())
 								p.Kill();
 							else
 								*Ret = true;
 						}
 					}
 				}
 				break;
 			}
 			case SdSetHtml:
 			{
 				if (!IsCancelled() && Args.Length() > 0)
 				{
 					LView *Ui = m->GetUI();
 					if (!Ui)
 					{
 						// Maybe hasn't finished opening the UI?
 						LSleep(100);
 						Ui = m->GetUI();
 					}
 					if (!Ui)
 						Ui = m->App;
 					if (Ui)
 						Ui->PostEvent(M_SET_HTML, (LMessage::Param)new LString(Args[0]->Str()));
 				}
 				break;
 			}
 			default:
 				LAssert(!"Unsupported call.");
 				return false;
 		}
 
 		return true;
 	}
 };
 
 class MailPrivate
 {
 	LAutoPtr<ImageResizeThread> Resizer;
 	Mail *m;
 
 public:
 	struct HtmlBody
 	{
 		LString Html, Charset, Styles;
 	};
 	LAutoPtr<HtmlBody> Body;
 	LAutoPtr<MailRendererScript> Renderer;
 	LString MsgIdCache;
 	LString DomainCache;
 	int InSetFlags = 0;
 	int InSetFlagsCache = 0;
 	
 	MailPrivate(Mail *mail)
 	{
 		m = mail;
 	}
 	
 	void OnSave()
 	{
 		Resizer.Reset();
 	}
 
 	HtmlBody *GetBody()
 	{
 		if (!Body && !Body.Reset(new HtmlBody))
 			return NULL;
 		
 		if (ValidStr(m->GetHtml()))
 		{
 			ExtractHtmlContent(	Body->Html,
 								Body->Charset,
 								Body->Styles,
 								m->GetHtml());
 		}
 		else if (ValidStr(m->GetBody()))
 		{
 		    Body->Charset = m->GetCharSet();
 			Body->Html = TextToHtml(m->GetBody(), Body->Charset);
 		}
 		
 		return Body;
 	}
 
 	bool AddResizeImage(Attachment *File)
 	{
 		if (!File || !m->GetUI())
 			return false;
 		
 		if (!Resizer)
 			Resizer.Reset(new ImageResizeThread(m->App->GetOptions()));
 		
 		if (!Resizer)
 			return false;
 
 		LAutoStreamI Obj = File->GetObject()->GetStream(_FL);
 		if (!Obj)
 			return false;
 
 		ImageResizeThread::Job *j = new ImageResizeThread::Job;
 		if (!j)
 			return false;
 
 		// The user interface will handle the response...				
 		j->SetSink(m->GetUI());
 		j->FileName = File->GetName();					
 
 		// Make a complete copy of the stream...
 		j->Data.Reset(new LMemStream(Obj, 0, -1));
 	
 		// Post the work over to the thread...
 		Resizer->PostEvent(M_RESIZE_IMAGE, (LMessage::Param)j);
 
 		// Mark the image resizing						
 		File->SetIsResizing(true);
 		
 		return true;
 	}	
 };
 
 bool Mail::ResizeImage(Attachment *a)
 {
 	return d->AddResizeImage(a);
 }
 
 AttachmentList::AttachmentList(int id, int x, int y, int cx, int cy, MailUi *ui)
 	: LList(id, x, y, cx, cy, 0)
 {
 	Ui = ui;
 }
 
 AttachmentList::~AttachmentList()
 {
 	RemoveAll();
 }
 
 void AttachmentList::OnItemClick(LListItem *Item, LMouse &m)
 {
 	LList::OnItemClick(Item, m);
 
 	if (!Item &&
 		m.IsContextMenu() &&
 		Ui)
 	{
 		LSubMenu RClick;
 		RClick.AppendItem(LLoadString(IDS_ATTACH_FILE), IDM_OPEN, true);
 		switch (RClick.Float(this, m))
 		{
 			case IDM_OPEN:
 			{
 				Ui->PostEvent(M_COMMAND, IDM_ATTACH_FILE, 0);
 				break;
 			}
 		}
 	}
 }
 
 bool AttachmentList::OnKey(LKey &k)
 {
 	if (k.vkey == LK_DELETE)
 	{
 		if (k.Down())
 		{
 			List<LListItem> s;
 			if (GetSelection(s))
 			{
 				Attachment *a = dynamic_cast<Attachment*>(s[0]);
 				if (a)
 				{
 					a->OnDeleteAttachment(this, true);
 				}
 			}
 		}
 		
 		return true;
 	}
 	
 	return LList::OnKey(k);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 int Strnlen(const char *s, int n)
 {
 	int i = 0;
 	if (s)
 	{
 		if (n < 0)
 		{
 			while (*s++)
 			{
 				i++;
 			}
 		}
 		else
 		{
 			while (*s++ && n-- > 0)
 			{
 				i++;
 			}
 		}
 	}
 
 	return i;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 MailContainer::~MailContainer()
 {
 	MailContainerIter *i;
 	while ((i = Iters[0]))
 	{
 		Iters.Delete(i);
 		if (i->Container)
 		{
 			i->Container = 0;
 		}
 	}
 }
 
 MailContainerIter::MailContainerIter()
 {
 	Container = 0;
 }
 
 MailContainerIter::~MailContainerIter()
 {
 	if (Container)
 	{
 		Container->Iters.Delete(this);
 	}
 }
 
 void MailContainerIter::SetContainer(MailContainer *c)
 {
 	Container = c;
 	if (Container)
 	{
 		Container->Iters.Insert(this);
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 uint32_t MarkColours32[IDM_MARK_MAX] =
 {
 	Rgb32(255, 0, 0),	// red
 	Rgb32(255, 166, 0),	// orange
 	Rgb32(255, 222, 0),	// yellow
 	Rgb32(0, 0xa0, 0),	// green
 	Rgb32(0, 0xc0, 255),// cyan
 	Rgb32(0, 0, 255),	// blue
 	Rgb32(192, 0, 255),	// purple
 	Rgb32(128, 128, 128) // grey
 };
 
 ItemFieldDef MailFieldDefs[] =
 {
 	{"To", SdTo,							GV_STRING,		FIELD_TO},
 	{"From", SdFrom,						GV_STRING,		FIELD_FROM},
 	{"Subject", SdSubject,					GV_STRING,		FIELD_SUBJECT},
 	{"Size", SdSize,						GV_INT64,		FIELD_SIZE},
 	{"Received Date", SdReceivedDate,		GV_DATETIME,	FIELD_DATE_RECEIVED},
 	{"Send Date", SdSendDate,				GV_DATETIME,	FIELD_DATE_SENT},
 	{"Body", SdBody,						GV_STRING,		FIELD_TEXT},
 	{"Internet Header", SdInternetHeader,	GV_STRING,		FIELD_INTERNET_HEADER, IDC_INTERNET_HEADER},
 	{"Message ID", SdMessageId, 			GV_STRING,		FIELD_MESSAGE_ID},
 	{"Priority", SdPriority, 				GV_INT32,		FIELD_PRIORITY},
 	{"Flags", SdFlags, 						GV_INT32,		FIELD_FLAGS},
 	{"Html", SdHtml, 						GV_STRING,		FIELD_ALTERNATE_HTML},
 	{"Label", SdLabel, 						GV_STRING,		FIELD_LABEL},
 	{"From Contact", SdContact,				GV_STRING,		FIELD_FROM_CONTACT_NAME},
 	
 	{"File", SdFile, 						GV_STRING,		FIELD_CACHE_FILENAME},
 	{"ImapFlags", SdImapFlags, 				GV_STRING,		FIELD_CACHE_FLAGS},
 	{"ImapSeq", SdFile, 					GV_INT32,		FIELD_IMAP_SEQ},
 	{"ImapUid", SdImapFlags, 				GV_INT32,		FIELD_SERVER_UID},
 	{"ReceivedDomain", SdReceivedDomain,	GV_STRING,		FIELD_RECEIVED_DOMAIN},
 	{"MessageId", SdMessageId,				GV_STRING,		FIELD_MESSAGE_ID},
 	
 	{0}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 class LIdentityItem : public LListItem
 {
 	ScribeWnd *App;
 	ScribeAccount *Acc;
 	char *Txt;
 
 public:
 	LIdentityItem(ScribeWnd *app, ScribeAccount *acc)
 	{
 		App = app;
 		Acc = acc;
 		Txt = 0;
 
 		LVariant e, n;
 		if (Acc)
 		{
 			n = Acc->Identity.Name();
 			e = Acc->Identity.Email();
 		}
 		else
 		{
 			LAssert(!"No account specified");
 		}
 
 		if (e.Str() && n.Str())
 		{
 			char t[256];
 			sprintf_s(t, sizeof(t), "%s <%s>", n.Str(), e.Str());
 			Txt = NewStr(t);
 		}
 		else if (e.Str())
 		{
 			Txt = NewStr(e.Str());
 		}
 		else if (n.Str())
 		{
 			Txt = NewStr(n.Str());
 		}
 		else
 		{
 			Txt = NewStr("(error)");
 		}
 	}
 	
 	~LIdentityItem()
 	{
 		DeleteArray(Txt);
 	}
 
 	ScribeAccount *GetAccount()
 	{
 		return Acc;
 	}
 
 	const char *GetText(int i)
 	{
 		switch (i)
 		{
 			case 0:
 			{
 				return Txt;
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 class LIdentityDropDrop : public LPopup
 {
 	ScribeWnd *App;
 	Mail *Email;
 	LList *Lst;
 
 public:
 	LIdentityDropDrop(ScribeWnd *app, Mail *mail, LView *owner) :
 		LPopup(owner)
 	{
 		App = app;
 		Email = mail;
 		LRect r(0, 0, 300, 100);
 		SetPos(r);
 		Children.Insert(Lst = new LList(IDC_LIST, 2, 2, X()-4, Y()-4));
 		if (Lst)
 		{
 			Lst->SetParent(this);
 			Lst->AddColumn("Identity", Lst->GetClient().X());
 			Lst->MultiSelect(false);
 
 			if (App)
 			{
 				Lst->Insert(new LIdentityItem(App, 0));
 
 				for (auto a : *App->GetAccounts())
 				{
 					if (a->Identity.Name().Str())
 					{
 						Lst->Insert(new LIdentityItem(App, a));
 					}
 				}
 				
 				/*
 				for (LListItem *i = List->First(); i; i = List->Next())
 				{
 					LIdentityItem *Item = dynamic_cast<LIdentityItem*>(i);
 					if (Item)
 					{
 						char *IdEmail = a->Send.IdentityEmail();
 						if (Email &&
 							IdEmail &&
 							Email->From->Addr &&
 							_stricmp(Email->From->Addr, IdEmail) == 0)
 						{
 							Item->Select(true);
 						}
 					}
 				}
 				*/
 			}
 		}
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		LRect r(GetClient());
 		LWideBorder(pDC, r, DefaultRaisedEdge);
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_LIST:
 			{
 				if (n.Type == LNotifyItemClick)
 				{
 					Visible(false);
 
 					LIdentityItem *NewFrom = dynamic_cast<LIdentityItem*>(Lst->GetSelected());
 					if (Email && NewFrom)
 					{
 						// ScribeAccount *a = NewFrom->GetAccount();
 						if (Email->GetUI())
 						{
 							LList *FromList;
 							if (GetViewById(IDC_FROM, FromList))
 							{
 								// Change item data
 
 								/* FIXME
 								DeleteArray(Email->From->Name);
 								DeleteArray(Email->From->Addr);
 								DeleteArray(Email->Reply->Name);
 								DeleteArray(Email->Reply->Addr);
 								
 								if (a)
 								{
 									Email->From->Addr = NewStr(a->Send.IdentityEmail().Str());
 									Email->From->Name = NewStr(a->Send.IdentityName().Str());
 									Email->Reply->Addr = NewStr(a->Send.IdentityReplyTo().Str());
 									if (Email->Reply->Addr)
 									{
 										Email->Reply->Name = NewStr(Email->From->Name);
 									}
 								}
 								else
 								{
 									LVariant e, n, r;
 									App->GetOptions()->GetValue(OPT_EmailAddr, e);
 									App->GetOptions()->GetValue(OPT_UserName, n);
 									App->GetOptions()->GetValue(OPT_ReplyToEmail, n);
 									Email->From->Addr = NewStr(e.Str());
 									Email->From->Name = NewStr(n.Str());
 									Email->Reply->Addr = NewStr(r.Str());
 									if (Email->Reply->Addr)
 									{
 										Email->Reply->Name = NewStr(Email->From->Name);
 									}
 								}
 
 								// Change UI
 								FromList->Empty();
 								LDataPropI *na = new LDataPropI(Email->From);
 								if (na)
 								{
 									na->CC = MAIL_ADDR_FROM;
 									FromList->Insert(na);
 								}
 								*/
 							}
 						}
 					}
 				}
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 LSubMenu*
 BuildMarkMenu(	LSubMenu *MarkMenu,
 				MarkedState MarkState,
 				uint32_t SelectedMark,
 				bool None,
 				bool All,
 				bool Select)
 {
 	int SelectedIndex = -1;
 
 	// Build image list
 	LImageList *ImgLst = new LImageList(16, 16);
 	if (ImgLst &&
 		ImgLst->Create(16 * CountOf(MarkColours32), 16, System32BitColourSpace))
 	{
 		// ImgLst->Colour(1);
 		ImgLst->Colour(L_MED);
 		ImgLst->Rectangle();
 
 		for (int i=0; i<CountOf(MarkColours32); i++)
 		{
 			if (MarkState == MS_One &&
 				MarkColours32[i] == SelectedMark)
 			{
 				ImgLst->Colour(L_LOW);
 				ImgLst->Box(i*16+1, 0, i*16+15, 14);
 				SelectedIndex = i;
 			}
 
 			ImgLst->Colour(MarkColours32[i], 32);
 			ImgLst->Rectangle(i*16+3, 2, i*16+13, 12);
 		}
 	}
 
 	// Build Submenu
 	if (MarkMenu && ImgLst)
 	{
 		ImgLst->Update(-1);
 		MarkMenu->SetImageList(ImgLst);
 
 		LMenuItem *Item = NULL;
 		if (None)
 		{
 			Item = MarkMenu->AppendItem(LLoadString(IDS_NONE), Select ? IDM_SELECT_NONE : IDM_UNMARK, MarkState != MS_None);
 		}
 		if (All)
 		{
 			Item = MarkMenu->AppendItem(LLoadString(IDS_ALL), Select ? IDM_SELECT_ALL : IDM_MARK_ALL, true);
 		}
 		if (Item)
 		{
 			MarkMenu->AppendSeparator();
 		}
 
 		for (int i=0; i<CountOf(MarkColours32); i++)
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), " (%i, %i, %i)", R32(MarkColours32[i]), G32(MarkColours32[i]), B32(MarkColours32[i]));
 			Item = MarkMenu->AppendItem(s,
 										((Select) ? IDM_MARK_SELECT_BASE : IDM_MARK_BASE) + i,
 										(MarkState != 1) || (i != SelectedIndex));
 			if (Item)
 			{
 				Item->Icon(i);
 			}
 		}
 	}
 
 	return MarkMenu;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 char *WrapLines(char *Str, int Len, int WrapColumn)
 {
 	if (Str &&
 		Len > 0 &&
 		WrapColumn > 0)
 	{
 		LMemQueue Temp;
 		int LastWhite = -1;
 		int StartLine = 0;
 		int XPos = 0;
 		int i;
 
 		for (i=0; Str[i] && i<Len; i++)
 		{
 			if (Str[i] == ' ')
 			{
 				int Len = LastWhite - StartLine;
 				if (XPos >= WrapColumn && Len > 0)
 				{
 					Temp.Write((uchar*) Str+StartLine, Len);
 					Temp.Write((uchar*) "\n", 1);
 					XPos = 0;
 					StartLine = StartLine + Len + 1;
 					LastWhite = -1;
 				}
 				else
 				{
 					LastWhite = i;
 					XPos++;
 				}
 			}
 			else if (Str[i] == '\t')
 			{
 				XPos = ((XPos + 7) / 8) * 8;
 			}
 			else if (Str[i] == '\n')
 			{
 				Temp.Write((uchar*) Str+StartLine, i - StartLine + 1);
 				XPos = 0;
 				StartLine = i+1;
 			}
 			else
 			{
 				XPos++;
 			}
 		}
 
 		Temp.Write((uchar*) Str+StartLine, i - StartLine + 1);
 
 		int WrapLen = (int)Temp.GetSize();
 		char *Wrapped = new char[WrapLen+1];
 		if (Wrapped)
 		{
 			Temp.Read((uchar*) Wrapped, WrapLen);
 			Wrapped[WrapLen] = 0;
 
 			return Wrapped;
 		}
 	}
 
 	return Str;
 }
 
 char *DeHtml(const char *Str)
 {
 	char *r = 0;
 	if (Str)
 	{
 		LMemQueue Buf;
 		char Buffer[256];
 
 		auto s = Str;
 		while (s && *s)
 		{
 			// Search for start of next tag
 			const char *Start = s;
 			const char *End = Start;
 			for (; *End && *End != '<'; End++);
 			
 			// Push pre-tag data onto pipe
 			size_t Len = End-Start;
 			for (size_t i=0; i<Len; )
 			{
 				size_t n;
 				for (n=0; n<sizeof(Buffer) && i<Len; i++)
 				{
 					if (Start[i] != '\n' &&
 						Start[i] != '\r' &&
 						Start[i] != '\t')
 					{
 						if (_strnicmp(Start+i, "&nbsp", 5) == 0)
 						{
 							Buffer[n++] = ' ';
 							i += 5;
 							if (Start[i] != ';') i--;
 						}
 						else if (_strnicmp(Start+i, "&copy", 4) == 0)
 						{
 							Buffer[n++] = 'c';
 							i += 5;
 							if (Start[i] != ';') i--;
 						}
 						else
 						{
 							Buffer[n++] = Start[i];
 						}
 					}
 					else if (Start[i] == '\n')
 					{
 						Buffer[n++] = ' ';
 					}
 				}
 
 				Buf.Write((uchar*)Buffer, n);
 			}
 
 			if (*End == '<')
 			{
 				char Temp[32];
 				int n;
 				End++;
 				for (n=0;
 					n<sizeof(Temp)-1 &&
 					End[n] &&
 					End[n] != ' ' &&
 					End[n] != '>';
 					n++)
 				{
 					Temp[n] = End[n];
 				}
 				Temp[n] = 0;
 
 				if (_stricmp(Temp, "br") == 0 ||
 					_stricmp(Temp, "li") == 0)
 				{
 					Buf.Write((uchar*) "\n", 1);
 				}
 				else if (_stricmp(Temp, "p") == 0 ||
 						 _stricmp(Temp, "/tr") == 0 ||
 						 _stricmp(Temp, "/ul") == 0)
 				{
 					Buf.Write((uchar*) "\n\n", 2);
 				}
 			}
 
 			// Start to end of tag
 			for (; *End && *End != '>'; End++);
 			s = End + 1;
 		}
 
 		int Len = (int)Buf.GetSize();
 		r = new char[Len+1];
 		if (r)
 		{
 			Buf.Read((uchar*)r, Len);
 			r[Len] = 0;
 		}
 	}
 
 	return r;
 }
 
 char *ExtractCodePage(char *ContentType)
 {
 	// int Status = -1;
 
 	if (ContentType)
 	{
 		const char *Match = "charset=";
 		char *Charset = stristr(ContentType, Match);
 		if (Charset)
 		{
 			Charset += strlen(Match);
 			char Delim = ' ';
 			if (*Charset == '\'' ||
 				*Charset == '\"')
 			{
 				Delim = *Charset++;
 			}
 
 			char Str[256];
 			char *Out = Str;
 			while (	*Charset &&
 					*Charset != Delim &&
 					*Charset != ';')
 			{
 				*Out++ = *Charset++;
 			}
 			*Out++ = 0;
 
 			return ValidStr(Str) ? NewStr(Str) : 0;
 		}
 	}
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 extern ItemFieldDef CalendarFields[];
 extern ItemFieldDef FilterFieldDefs[];
 extern ItemFieldDef GroupFieldDefs[];
 
 ItemFieldDef *FieldLists[] =
 {
 	MailFieldDefs,
 	ContactFieldDefs,
 	CalendarFields,
 	FilterFieldDefs,
 	GroupFieldDefs,
 	0
 };
 
 ItemFieldDef *GetFieldDefByName(char *Name)
 {
 	if (Name)
 	{
 		static LHashTbl<ConstStrKey<char,false>, ItemFieldDef*> Lut(256);
 		if (Lut.Length() == 0)
 		{
 			for (ItemFieldDef **l=FieldLists; *l; l++)
 			{
 				for (ItemFieldDef *i = *l; i->FieldId; i++)
 				{
 					if (i->Option)
 						Lut.Add(i->Option, i);
 				}
 			}
 		}
 
 		return (ItemFieldDef*) Lut.Find(Name);
 	}
 
 	return 0;
 }
 
 static bool FieldLutInit = false;
 static LArray<ItemFieldDef*> IdToFieldLut;
 
 ItemFieldDef *GetFieldDefById(int Id)
 {
 	if (!FieldLutInit)
 	{
 		FieldLutInit = true;
 
 		for (ItemFieldDef **l=FieldLists; *l; l++)
 		{
 			for (ItemFieldDef *i = *l; i->FieldId; i++)
 			{
 				IdToFieldLut[i->FieldId] = i;
 			}
 		}
 	}
 
 	if (Id >= 0 && Id < (int)IdToFieldLut.Length())
 		return IdToFieldLut[Id];
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 void Log(char *File, char *Str, ...)
 {
 	#if defined WIN32
 	const char *DefFile = "c:\\temp\\list.txt";
 	#else
 	const char *DefFile = "/home/list.txt";
 	#endif
 
 	if (Str)
 	{
 		LFile f;
 		if (f.Open((File) ? File : DefFile, O_WRITE))
 		{
 			char Buf[1024];
 			va_list Arg;
 
 			va_start(Arg, Str);
 			vsprintf_s(Buf, sizeof(Buf), Str, Arg);
 			va_end(Arg);
 
 			f.Seek(0, SEEK_END);
 			f.Write(Buf, (int)strlen(Buf));
 		}
 	}
 	else
 	{
 		LFile f;
 		if (f.Open((File) ? File : DefFile, O_WRITE))
 		{
 			f.SetSize(0);
 		}
 	}
 }
 
 char *NewPropStr(LOptionsFile *Options, char *Name)
 {
 	LVariant n;
 	if (Options->GetValue(Name, n) && n.Str() && strlen(n.Str()) > 0)
 	{
 		return NewStr(n.Str());
 	}
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Columns of controls
 #define MAILUI_Y						0
 
 #define	IDM_REMOVE_GRTH					1000
 #define IDM_REMOVE_GRTH_SP				1001
 #define IDM_REMOVE_HTML					1002
 #define IDM_CONVERT_B64_TO_BIN			1003
 #define IDM_CONVERT_BIN_TO_B64			1004
 
 #define RECIP_SX						500
 #define ADD_X							(RECIP_X + RECIP_SX + 10)
 #ifdef MAC
 #define	ADD_RECIP_BTN_X					36
 #else
 #define	ADD_RECIP_BTN_X					20
 #endif
 
 #define CONTENT_BORDER					3
 
 #if defined WIN32
 
 	#define DLG_X						15
 	#define DLG_Y						30
 
 #else
 
 	#define DLG_X						6
 	#define DLG_Y						6
 
 #endif
 
 MailUi::MailUi(Mail *item, MailContainer *container) :
 	ThingUi(item, LLoadString(IDS_MAIL_MESSAGE)), WorkingDlg(NULL),
 	Sx(0), Sy(0),
 	CmdAfterResize(NULL), MissingCaps(NULL),
 	BtnPrev(NULL), BtnNext(NULL), BtnSend(NULL), BtnSave(NULL), BtnSaveClose(NULL),
 	BtnAttach(NULL), BtnReply(NULL), BtnReplyAll(NULL), BtnForward(NULL), BtnBounce(NULL),
 	GpgUi(NULL), ToPanel(NULL), Entry(NULL), Browse(NULL), SetTo(NULL),
 	To(NULL), Remove(NULL), FromPanel(NULL), FromList(NULL), FromCbo(NULL),
 	ReplyToPanel(NULL), ReplyToChk(NULL), ReplyToCbo(NULL),
 	SubjectPanel(NULL), Subject(NULL), CalendarPanel(NULL), CalPanelStatus(NULL),
 	Tab(NULL), TabText(NULL), TextView(NULL), TabHtml(NULL), HtmlView(NULL),
 	TabAttachments(NULL), Attachments(NULL), TabHeader(NULL), Header(NULL)
 {
 	// Init everything to 0
 	Container = container;
 	if (!item || !item->App)
 	{
 		LAssert(!"Invalid ptrs");
 		return;
 	}
 
 	AddMode = MAIL_ADDR_TO;
 	CurrentEditCtrl = -1;
 	MetaFieldsDirty = IgnoreShowImgNotify = HtmlCtrlDirty = TextCtrlDirty = TextLoaded = HtmlLoaded = false;
 
     // This allows us to hook iconv conversion events
     LFontSystem::Inst()->Register(this);
     
     // This allows us to hook missing image library events
     GdcD->Register(this);
 
 	// Read/Write access
 	bool ReadOnly = !TestFlag(GetItem()->GetFlags(), MAIL_CREATED | MAIL_BOUNCE);
 	int MinButY = 0;
 
 	// Get position
 	LRect r(150, 150, 800, 750);
 	SetPos(r);
 	int FontHeight = GetFont()->GetHeight();
 
 	LVariant v;
 	LOptionsFile *Options = App ? App->GetOptions() : 0;
 	if (Options)
 	{
 		if (Options->GetValue("MailUI.Pos", v))
 		{
 			r.SetStr(v.Str());
 		}
 	}
 	SetPos(r);
 	MoveSameScreen(App);
 
 	Name(LLoadString(IDS_MAIL_MESSAGE));
 
 	#if WINNATIVE
 	CreateClassW32("Scribe::MailUi", LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_MAIL)));
 	#endif
 	bool IsCreated = TestFlag(GetItem()->GetFlags(), MAIL_CREATED);
 
 	if (Attach(0))
 	{
 		DropTarget(true);
 
 		// Setup main toolbar
 		Commands.Toolbar = App->LoadToolbar(this,
 											App->GetResourceFile(ResToolbarFile),
 											App->GetToolbarImgList());
 		if (Commands.Toolbar)
 		{
 			Commands.Toolbar->Raised(false);
 			Commands.Toolbar->Attach(this);
 
 			BtnSend = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SEND)), IDM_SEND_MSG, TBT_PUSH, !ReadOnly, IMG_SEND);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnSave = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE)), IDM_SAVE, TBT_PUSH, !ReadOnly, IMG_SAVE);
 			BtnSaveClose = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE_CLOSE)), IDM_SAVE_CLOSE, TBT_PUSH, !ReadOnly, IMG_SAVE_AND_CLOSE);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_DELETE)), IDM_DELETE_MSG, TBT_PUSH, true, IMG_TRASH);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SPAM)), IDM_DELETE_AS_SPAM, TBT_PUSH, true, IMG_DELETE_SPAM);
 			BtnAttach = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_ATTACH_FILE)), IDM_ATTACH_FILE, TBT_PUSH, !ReadOnly, IMG_ATTACH_FILE);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnReply = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_REPLY)), IDM_REPLY, TBT_PUSH, ReadOnly, IMG_REPLY);
 			BtnReplyAll = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_REPLYALL)), IDM_REPLY_ALL, TBT_PUSH, ReadOnly, IMG_REPLY_ALL);
 			BtnForward = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_FORWARD)), IDM_FORWARD, TBT_PUSH, ReadOnly, IMG_FORWARD);
 			BtnBounce = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_BOUNCE)), IDM_BOUNCE, TBT_PUSH, ReadOnly, IMG_BOUNCE);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnPrev = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_PREV_MSG)), IDM_PREV_MSG, TBT_PUSH, true, IMG_PREV_ITEM);
 			BtnNext = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_NEXT_MSG)), IDM_NEXT_MSG, TBT_PUSH, true, IMG_NEXT_ITEM);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_HIGH_PRIORITY)), IDM_HIGH_PRIORITY, TBT_TOGGLE, true, IMG_HIGH_PRIORITY);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_LOW_PRIORITY)), IDM_LOW_PRIORITY, TBT_TOGGLE, true, IMG_LOW_PRIORITY);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_READ_RECEIPT)), IDM_READ_RECEIPT, TBT_TOGGLE, true, IMG_READ_RECEIPT);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_PRINT)), IDM_PRINT, TBT_PUSH, true, IMG_PRINT);
 
 			for (LViewI *w: Commands.Toolbar->IterateViews())
 				MinButY = MAX(MinButY, w->Y());
 
 			Commands.Toolbar->Customizable(App->GetOptions(), "MailWindowToolbar");
 			Commands.SetupCallbacks(App, this, GetItem(), LThingUiToolbar);
 		}
 
 		// Setup to/from panels
 		LVariant AlwaysShowFrom;
 		if (IsCreated)
 			App->GetOptions()->GetValue(OPT_MailShowFrom, AlwaysShowFrom);
 
 		bool ShowFrom = !IsCreated &&
 						!TestFlag(GetItem()->GetFlags(), MAIL_BOUNCE);
 
 		LDisplayString Recip(LSysFont, LLoadString(IDS_RECIPIENTS));
 		LAutoPtr<LCheckBox> ReplyChk(new LCheckBox(IDC_USE_REPLY_TO, 21,
 													#ifdef MAC
 													1,
 													#else
 													6,
 													#endif
 													-1, -1, "Reply To"));
 		int ReplyChkPx = ReplyChk ? ReplyChk->X() : 0;
 		int RECIP_X = 20 + MAX(ReplyChkPx, Recip.X()) + 10;
 		int EditHeight = FontHeight + 6;
 
 		LVariant HideGpg;
 		if (!item->App->GetOptions()->GetValue(OPT_HideGnuPG, HideGpg) ||
 			HideGpg.CastInt32() == 0)
 		{
 			GpgUi = new MailUiGpg(	App,
 									this,
 									21,
 									RECIP_X,
 									!ReadOnly && !TestFlag(GetItem()->GetFlags(), MAIL_SENT));
 			if (GpgUi)
 				GpgUi->Attach(this);
 		}
 		
 		ToPanel = new LPanel(LLoadString(IDS_TO), FontHeight * 8, !ShowFrom);
 		if (ToPanel)
 		{
 		    int Cy = 4;
 			ToPanel->AddView(SetTo = new LCombo(IDC_SET_TO, 20, Cy, 60, EditHeight, 0));
 			if (SetTo)
 			{
 				SetTo->Insert(LLoadString(IDS_TO));
 				SetTo->Insert(LLoadString(IDS_CC));
 				SetTo->Insert(LLoadString(IDS_BCC));
 				
 				if (SetTo->GetPos().x2 + 10 > RECIP_X)
 				    RECIP_X = SetTo->GetPos().x2 + 10;
 			}
 			
 			ToPanel->AddView(Entry = new LEdit(IDC_ENTRY, RECIP_X, Cy, RECIP_SX, EditHeight, ""));
 			
 			Cy = SetTo->GetPos().y2 + 5;
 
 			ToPanel->AddView(To = new AddressList(App, IDC_TO, RECIP_X, Cy, RECIP_SX, ToPanel->GetOpenSize() - Cy - 6));
 			if (To)
 				To->SetImageList(App->GetIconImgList(), false);
 			ToPanel->AddView(new LTextLabel(IDC_STATIC, 20, Cy, -1, -1, LLoadString(IDS_RECIPIENTS)));
 			
 			ToPanel->Raised(false);
 			ToPanel->Attach(this);
 		}
 
 		FromPanel = new LPanel(LLoadString(IDS_FROM), FontHeight + 13, AlwaysShowFrom.CastInt32() || ShowFrom);
 		if (FromPanel)
 		{
 			FromPanel->AddView(new LTextLabel(IDC_STATIC, 21,
 										#ifdef MAC
 										8,
 										#else
 										4,
 										#endif
 										-1, -1, LLoadString(IDS_FROM)));
 
 			if (ShowFrom)
 			{
 				FromPanel->AddView(FromList = new AddressList(App, IDC_FROM, RECIP_X, 2, RECIP_SX, EditHeight));
 			}
 			else
 			{
 				FromPanel->AddView(FromCbo = new LCombo(IDC_FROM, RECIP_X, 2, RECIP_SX, EditHeight, 0));
 			}
 
 			if (IsCreated)
 			{
 				LCheckBox *Chk;
 				auto Label = LLoadString(IDS_ALWAYS_SHOW);
 				FromPanel->AddView(Chk = new LCheckBox(IDC_SHOW_FROM, ADD_X,
 														#ifdef MAC
 														1,
 														#else
 														6,
 														#endif
 														-1, -1, Label));
 				if (Chk) Chk->Value(AlwaysShowFrom.CastInt32());
 			}
 
 			FromPanel->Raised(false);
 			FromPanel->Attach(this);
 		}
 
 		ReplyToPanel = new LPanel("Reply To:", FontHeight + 13, false);
 		if (ReplyToPanel)
 		{
 			ReplyToPanel->Raised(false);
 			ReplyToPanel->AddView(ReplyToChk = ReplyChk.Release());
 			ReplyToPanel->AddView(ReplyToCbo = new LCombo(IDC_REPLY_TO_ADDR, RECIP_X, 2, RECIP_SX, EditHeight, 0));
 			ReplyToPanel->Attach(this);
 		}
 
 		SubjectPanel = new LPanel(LLoadString(IDS_SUBJECT), -(LSysFont->GetHeight() + 16));
 		if (SubjectPanel)
 		{
 			SubjectPanel->Raised(false);
 			SubjectPanel->AddView(			new LTextLabel(IDC_STATIC, 21, 8, -1, -1, LLoadString(IDS_SUBJECT)));
 			SubjectPanel->AddView(Subject = new LEdit(IDC_SUBJECT, RECIP_X, 4, RECIP_SX, EditHeight, ""));
 			SubjectPanel->Attach(this);
 		}
 
 		CalendarPanel = new LPanel(LLoadString(IDC_CALENDAR), -(LSysFont->GetHeight() + 16), false);
 		if (CalendarPanel)
 		{
 			CalendarPanel->Raised(false);
 			LTableLayout *t = new LTableLayout(IDC_TABLE);
 			if (t)
 			{
 				t->GetCss(true)->Margin(LCss::Len(LCss::LenPx, LTableLayout::CellSpacing));
 				t->GetCss()->Width(LCss::LenAuto);
 				t->GetCss()->Height(LCss::LenAuto);
 
 				CalendarPanel->AddView(t);
 				auto c = t->GetCell(0, 0);
 				
 				c->Width(LCss::Len(LCss::LenPx, RECIP_X - (LTableLayout::CellSpacing * 2)));
 				c->PaddingLeft(LCss::Len(LCss::LenPx, 21 - LTableLayout::CellSpacing));
 				c->Debug = true;
 
 				c->Add(new LTextLabel(IDC_STATIC, 0, 0, -1, -1, LLoadString(IDS_CALENDAR)));
 				c = t->GetCell(1, 0);
 				c->Add(new LButton(IDC_ADD_CAL_EVENT, 0, 0, -1, -1, LLoadString(IDS_ADD_CAL)));
 				c = t->GetCell(2, 0);
 				c->Add(new LButton(IDC_ADD_CAL_EVENT_POPUP, 0, 0, -1, -1, LLoadString(IDS_ADD_CAL_POPUP)));
 				c = t->GetCell(3, 0);
 				c->Add(CalPanelStatus = new LTextLabel(IDC_STATIC, 0, 0, -1, -1, NULL));
 			}
 
 			CalendarPanel->Attach(this);
 		}
 
 		Tab = new LTabView(IDC_MAIL_UI_TABS, 0, 0, 1000, 1000, 0);
 		if (Tab)
 		{
 			Tab->GetCss(true)->PaddingTop("3px");
 
 			// Don't attach text and html controls here, because OnLoad will do it later...
 			TabText = Tab->Append(LLoadString(IDS_TEXT));
 			TabHtml = Tab->Append("HTML");
 
 			TabAttachments = Tab->Append(LLoadString(IDS_ATTACHMENTS));
 			TabHeader = Tab->Append(LLoadString(IDS_INTERNETHEADER));
 
 			if (TabAttachments)
 			{
 				TabAttachments->Append(Attachments = new AttachmentList(IDC_ATTACHMENTS,
 																		CONTENT_BORDER,
 																		CONTENT_BORDER,
 																		200,
 																		200,
 																		this));
 
 				if (Attachments)
 				{
 					Attachments->AddColumn(LLoadString(IDS_FILE_NAME), 160);
 					Attachments->AddColumn(LLoadString(IDS_SIZE), 80);
 					Attachments->AddColumn(LLoadString(IDS_MIME_TYPE), 100);
 					Attachments->AddColumn(LLoadString(IDS_CONTENT_ID), 250);
 				}
 			}
 
 			if (TabHeader)
 			{
 				TabHeader->Append(Header = new LTextView3(	IDC_INTERNET_HEADER,
 															CONTENT_BORDER,
 															CONTENT_BORDER,
 															100,
 															20));
 				if (Header)
 				{
 					Header->Sunken(true);
 				}
 			}
 
 			LTabPage *Fields = Tab->Append(LLoadString(IDS_FIELDS));
 			if (Fields)
 			{
 				Fields->LoadFromResource(IDD_MAIL_FIELDS);
 				
 				LTableLayout *l;
 				if (GetViewById(IDC_TABLE, l))
 				{
 				    l->SetPourLargest(false);
 				}
 			}
 
 			Tab->Attach(this);
 
 			// Colours
 			LColourSelect *Colour;
 			if (GetViewById(IDC_COLOUR, Colour))
 			{
 				LArray<LColour> c32;
 				for (int i=0; i<CountOf(MarkColours32); i++)
 					c32.New().Set(MarkColours32[i], 32);
 				Colour->SetColourList(&c32);
 			}
 			else LAssert(!"No colour control?");
 		}
 
 		PourAll();
 
 		if (Commands.Toolbar)
 		{
 			if (ToPanel)
 				ToPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 			if (FromPanel)
 				FromPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 			if (ReplyToPanel)
 				ReplyToPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 		}
 
 		SetIcon("About64px.png");
 		OnLoad();
 		_Running = true;
 		Visible(true);
 		RegisterHook(this, LKeyEvents);
 		LResources::StyleElement(this);
 	}
 }
 
 MailUi::~MailUi()
 {
 	DeleteObj(TextView);
 
 	if (Attachments)
 	{
 		Attachments->RemoveAll();
 	}
 	LOptionsFile *Options = (GetItem() && App) ? App->GetOptions() : 0;
 	if (Options)
 	{
 		LRect p = GetPos();
 		if (p.x1 >= 0 &&
 			p.y1 >= 0)
 		{
 			LVariant v = p.GetStr();
 			Options->SetValue("MailUI.Pos", v);
 		}
 	}
 
 	Tab = 0;
 	if (GetItem())
 	{
 		GetItem()->Ui = NULL;
 	}
 	else LgiTrace("%s:%i - Error: no item to clear UI ptr?\n", _FL);
 
 	// We delete the LView here because objects
 	// need to have their virtual tables intact
 	_Delete();
 }
 
 Mail *MailUi::GetItem()
 {
 	return _Item ? _Item->IsMail() : 0;
 }
 
 void MailUi::SetItem(Mail *m)
 {
 	if (_Item)
 	{
 		Mail *old = _Item->IsMail();
 		if (old)
 			old->Ui = NULL;
 		else
 			LAssert(0);
 		_Item = NULL;
 	}
 
 	if (m)
 	{
 		_Item = m;
 		m->Ui = this;
 	}
 }
 
 bool MailUi::SetDirty(bool Dirty, bool Ui)
 {
 	bool b = ThingUi::SetDirty(Dirty, Ui);
 	
 	if (MetaFieldsDirty && !Dirty)
 	{
 		Mail *m = GetItem();
 		if (m)
 		{
 			LColourSelect *Colour;
 			if (GetViewById(IDC_COLOUR, Colour))
 			{
 				uint32_t Col = (uint32_t)Colour->Value();
 				m->SetMarkColour(Col);
 			}
 			else LgiTrace("%s:%i - Can't find IDC_COLOUR\n", _FL);
 
 			auto s = GetCtrlName(IDC_LABEL);
 			m->SetLabel(s);
 			
 			if (m->GetObject()->GetInt(FIELD_STORE_TYPE) != Store3Imap) // Imap knows to save itself.
 				m->SetDirty();
 			m->Update();
 		}
 		
 		MetaFieldsDirty = false;
 	}
 	
 	return b;
 }
 
 #define IDM_FILTER_BASE		2000
 #define IDM_CHARSET_BASE	3000
 void AddActions(LSubMenu *Menu, List<Filter> &Filters, LArray<ScribeFolder*> Folders)
 {
 	if (!Menu)
 		return;
 
 	auto StartLen = Menu->Length();
 
 	for (auto Folder: Folders)
 	{
 		for (ScribeFolder *f=Folder->GetChildFolder(); f; f=f->GetNextFolder())
 		{
 			auto Sub = Menu->AppendSub(f->GetName(true));
 			if (Sub)
 			{
 				auto Item = Sub->GetParent();
 				if (Item) Item->Icon(ICON_CLOSED_FOLDER);
 				Sub->SetImageList(Menu->GetImageList(), false);
 				f->LoadThings();
 				AddActions(Sub, Filters, {f});
 			}
 		}
 
 		List<Filter> a;
 		Folder->LoadThings();
 		for (auto t: Folder->Items)
 		{
 			a.Insert(t->IsFilter());
 		}
 
 		a.Sort(FilterCompare);
 
 		for (auto i: a)
 		{
 			LVariant Name;
 			if (i->GetVariant("Name", Name) && Name.Str())
 			{
 				char n[256];
 				strcpy_s(n, sizeof(n), Name.Str());
 				for (char *s=n; *s; s++)
 				{
 					if (*s == '&')
 					{
 						memmove(s + 1, s, strlen(s)+1);
 						s++;
 					}
 				}
 
 				auto Item = Menu->AppendItem(n, (int) (IDM_FILTER_BASE + Filters.Length()), true);
 				if (Item)
 				{
 					Item->Icon(ICON_FILTER);
 					Filters.Insert(i);
 				}
 			}
 		}
 	}
 
 	if (StartLen == Menu->Length())
 	{
 		char s[64];
 		sprintf_s(s, sizeof(s), "(%s)", LLoadString(IDS_EMPTY));
 		Menu->AppendItem(s, 0, false);
 	}
 }
 
 bool MailUi::OnViewKey(LView *v, LKey &k)
 {
 	if (k.Down() && k.CtrlCmd() && !k.Alt())
 	{
 		switch (k.vkey)
 		{
 			case LK_RETURN:
 			{
 				PostEvent(M_COMMAND, IDM_SEND_MSG);
 				return true;
 			}
 			case LK_UP:
 			{
 				SeekMsg(-1);
 				return true;
 			}
 			case LK_DOWN:
 			{
 				SeekMsg(1);
 				return true;
 			}
 		}
 		switch (k.c16)
 		{
 			case 'p':
 			case 'P':
 			{
 				App->ThingPrint(NULL, GetItem(), NULL, this);
 				break;
 			}
 			case 'f':
 			case 'F':
 			{
 				if (Tab->Value() == 0)
 				{
 					if (TextView)
 						TextView->DoFind(NULL);
 				}
 				else if (Tab->Value() == 1)
 				{
 					if (HtmlView)
 						HtmlView->DoFind(NULL);
 				}
 				return true;
 			}
 			case 'r':
 			case 'R':
 			{
 				OnCommand(IDM_REPLY, 0, NULL);
 				return true;
 			}
 			case 'w':
 			case 'W':
 			{
 				if (OnRequestClose(false))
 					Quit();
 				return true;
 			}
 			case 's':
 			case 'S':
 			{
 				if (IsDirty())
 				{
 					SetDirty(false);
 				}
 				return true;
 			}
 			case '1':
 			{
 				Tab->Value(0);
 				if (TextView) TextView->Focus(true);
 				return true;
 			}
 			case '2':
 			{
 				Tab->Value(1);
 				if (HtmlView) HtmlView->Focus(true);
 				return true;
 			}
 		}
 	}
 
 	return ThingUi::OnViewKey(v, k);
 }
 
 void MailUi::SerializeText(bool FromCtrl)
 {
 	if (GetItem() && TextView)
 	{
 		if (FromCtrl)
 		{
 			GetItem()->SetBody(TextView->Name());
 		}
 		else
 		{
 			TextView->Name(GetItem()->GetBody());
 		}
 	}
 }
 
 const char *FilePart(const char *Uri)
 {
 	const char *Dir = Uri + strlen(Uri) - 1;
 	while (Dir > Uri &&
 		Dir[-1] != '/' &&
 		Dir[-1] != '\\')
 	{
 		Dir--;
 	}
 	
 	return Dir;
 }
 
 void MailUi::OnAttachmentsChange()
 {
 	Attachments->ResizeColumnsToContent();
 
 	if (GetItem())
 	{
 		TabAttachments->GetCss(true)->FontBold(GetItem()->Attachments.Length() > 0);
 		TabAttachments->OnStyleChange();
 	}
 }
 
 bool MailUi::NeedsCapability(const char *Name, const char *Param)
 {
     if (!InThread())
     {
         PostEvent(M_NEEDS_CAP, (LMessage::Param)NewStr(Name));
     }
     else
     {
         if (!Name)
             return false;
             
         if (Caps.Find(Name))
             return true;
 
         Caps.Add(Name, true);
 
 	    char msg[256];
 		LArray<const char *> Actions;
 		LAutoPtr<LColour> Back;
 	    
 	    if (!_stricmp(Name, "RemoteContent"))
 	    {
 			Actions.Add(LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT));
 			Actions.Add(LLoadString(IDS_SHOW_REMOTE_CONTENT));
 
 			Back.Reset(new LColour(L_LOW));
 			strcpy_s(msg, sizeof(msg),
 					LLoadString
 					(
 						IDS_REMOTE_CONTENT_MSG,
 						"To protect your privacy Scribe has blocked the remote content in this message."
 					));
 	    }
 	    else
 	    {
 			Actions.Add(LLoadString(IDS_INSTALL));
 			int ch = 0;
 			for (auto k : Caps)
 				ch += sprintf_s(msg+ch, sizeof(msg)-ch, "%s%s", ch?", ":"", k.key);
 			ch += sprintf_s(msg+ch, sizeof(msg)-ch, " is required to display this content.");
 		}
     		
         if (!MissingCaps)
         {
             MissingCaps = new MissingCapsBar(this, &Caps, msg, App, Actions, Back);
 
 			auto c = IterateViews();
 			auto Idx = c.IndexOf(GpgUi);
 			AddView(MissingCaps, (int)Idx+1);
             AttachChildren();
             OnPosChange();
         }
         else
         {
 		    MissingCaps->SetMsg(msg);
         }
     }
 
     return true;
 }
 
 void MailUi::OnCloseInstaller()
 {
 	if (MissingCaps)
 	{
 		DeleteObj(MissingCaps);
 		PourAll();
 	}
 }
 
 void MailUi::OnInstall(LCapabilityTarget::CapsHash *Caps, bool Status)
 {
 }
 
 void MailUi::OnChildrenChanged(LViewI *Wnd, bool Attaching)
 {
 	if (Wnd == (LViewI*)MissingCaps &&
 		!Attaching)
 	{
 		MissingCaps = NULL;
 		PourAll();
 	}
 }
 
 LDocView *MailUi::GetDoc(const char *MimeType)
 {
 	if (!MimeType)
 	{
 		MimeType = sTextPlain;
 		LVariant v;
 		if (App->GetOptions()->GetValue(OPT_DefaultAlternative, v) &&
 			v.CastInt32() > 0)
 			MimeType = sTextHtml;
 	}
 	
 	LAssert(MimeType != NULL);
 	
 	if (!_stricmp(MimeType, sTextPlain))
 		return TextView;
 	else if (!_stricmp(MimeType, sTextHtml))
 		return HtmlView;
 	else
 		LAssert(!"Invalid mime type.");
 	
 	return NULL;
 }
 
 bool MailUi::SetDoc(LDocView *v, const char *MimeType)
 {
 	if (!MimeType)
 	{
 		MimeType = sTextPlain;
 		LVariant v;
 		if (App->GetOptions()->GetValue(OPT_DefaultAlternative, v) &&
 			v.CastInt32() > 0)
 			MimeType = sTextHtml;
 	}
 	
 	LAssert(MimeType != NULL);
 
 	if (!_stricmp(MimeType, sTextPlain))
 	{
 		LTextView3 *Txt = static_cast<LTextView3*>(v);
 		if (Txt)
 		{
 			if (Txt != TextView)
 			{
 				DeleteObj(TextView);
 				TextView = Txt;
 				if (TabText && !TextView->IsAttached())
 					TabText->Append(TextView);
 			}
 			TextLoaded = true;
 			if (_Running)
 				TabText->Select();
 		}
 		else
 		{
 			LAssert(!"Invalid ctrl.");
 			return false;
 		}
 	}
 	else if (!_stricmp(MimeType, sTextHtml))		
 	{
 		LDocView *Html = dynamic_cast<LDocView*>(v);
 		if (Html)
 		{
 			if (Html != HtmlView)
 			{
 				DeleteObj(HtmlView);
 				HtmlView = Html;
 
 				LCapabilityClient *cc = dynamic_cast<LCapabilityClient*>(v);
 				if (cc)
 					cc->Register(this);
 
 				if (TabHtml && !HtmlView->IsAttached())
 					TabHtml->Append(HtmlView);
 			}
 			HtmlLoaded = true;
 			if (_Running)
 				TabHtml->Select();
 		}
 		else
 		{
 			LAssert(!"Invalid ctrl.");
 			return false;
 		}
 	}
 	else
 	{
 		LAssert(!"Invalid mime type.");
 		return false;
 	}
 
     return true;
 }
 
 bool MailUi::IsWorking(int Set)
 {
 	if (!GetItem())
 		return false;
 
 	// Are any of the attachments busy doing something?
 	LDataI *AttachPoint = GetItem() && Set >= 0 ? GetItem()->GetFileAttachPoint() : NULL;
 
 	List<Attachment> Attachments;
 	if (GetItem()->GetAttachments(&Attachments))
 	{
 		// Attachment *Match = NULL;
 		for (auto a: Attachments)
 		{
 			if (Set >= 0)
 			{
 				a->SetIsResizing(Set != 0);
 				if (AttachPoint)
 				{
 					a->GetObject()->Save(AttachPoint);
 				}
 			}
 			else if (a->GetIsResizing())
 			{
 				return true;
 			}
 		}
 	}
 	
 	// Check rich text control as well...
 	auto Rte = dynamic_cast<LRichTextEdit*>(HtmlView);
 	if (Rte)
 	{
 		if (Rte->IsBusy())
 		{
 			return true;
 		}
 	}
 
 	return false;
 }
 
 class BusyPanel : public LPanel
 {
 public:
 	BusyPanel() : LPanel("Working...", LSysFont->GetHeight() << 1)
 	{
 		LViewI *v;
 		LCss::ColorDef Bk(LColour(255, 128, 0));
 		GetCss(true)->BackgroundColor(Bk);
 
 		AddView(v = new LTextLabel(IDC_STATIC, 30, 5, -1, -1, "Still resizing images..."));
 		v->GetCss(true)->BackgroundColor(Bk);
 
 		AddView(v = new LButton(IDCANCEL, 200, 3, -1, -1, LLoadString(IDS_CANCEL)));
 		v->GetCss(true)->NoPaintColor(Bk);
 	}
 };
 
 void MailUi::SetCmdAfterResize(int Cmd)
 {
 	if (CmdAfterResize == 0)
 	{
 		CmdAfterResize = Cmd;
 		if (!WorkingDlg)
 		{
 			WorkingDlg = new BusyPanel;
 			if (WorkingDlg)
 			{
 				AddView(WorkingDlg, 1);
 				AttachChildren();
 				OnPosChange();
 			}
 		}
 	}
 }
 
 bool MailUi::OnRequestClose(bool OsClose)
 {
 	bool Working = IsWorking();
 	if (Working)
 	{
 		SetCmdAfterResize(IDM_SAVE_CLOSE);
 		return false;
 	}
 	
 	return ThingUi::OnRequestClose(OsClose);
 }
 
 void MailUi::OnChange()
 {
 	if (!IsDirty())
 		OnLoad();
 }
 
 struct MailUiNameAddr
 {
 	LString Name, Addr;
 	
 	MailUiNameAddr(const char *name = 0, const char *addr = 0)
 	{
 		Name = name;
 		Addr = addr;
 	}
 };
 
 void MailUi::OnLoad()
 {
 	bool Edit = false;
 	bool ReadOnly = true;
 	Mail *Item = GetItem();
 
 	_Running = false;
 
 	if (Item &&
 		Item->App)
 	{
 		Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 		ReadOnly = !TestFlag(Item->GetFlags(), MAIL_CREATED | MAIL_BOUNCE);
 
 		if (Entry)
 		{
 			Entry->Name("");
 		}
 
 		if (To)
 		{
 			To->OnInit(Item->GetTo());
 		}
 
 		if (FromCbo)
 		{
 			LHashTbl<StrKey<char,false>, MailUiNameAddr*> ReplyToAddrs;
 			const char *Template = "%s <%s>";
 			FromCbo->Empty();
 
 			int Idx = -1;
 			LVariant DefName, DefAddr;
 
 			// LOptionsFile *Opts = Item->Window->GetOptions();
 			for (auto a : *Item->App->GetAccounts())
 			{
 				LVariant Name = a->Identity.Name();
 				LVariant Addr = a->Identity.Email();
 				LVariant ReplyTo = a->Identity.ReplyTo();
 				
 				if (!a->IsValid() || a->Send.Disabled())
 					continue;
 				
 				if (ReplyTo.Str())
 				{
 					if (!ReplyToAddrs.Find(ReplyTo.Str()))
 						ReplyToAddrs.Add(ReplyTo.Str(), new MailUiNameAddr(Name.Str(), ReplyTo.Str()));
 				}
 				else if (Addr.Str())
 				{
 					if (!ReplyToAddrs.Find(Addr.Str()))
 						ReplyToAddrs.Add(Addr.Str(), new MailUiNameAddr(Name.Str(), Addr.Str()));
 				}
 
 				if (Name.Str() && Addr.Str())
 				{
 					if (!DefAddr.Str() ||
 						_stricmp(DefAddr.Str(), Addr.Str()))
 					{
 						auto FromAddr = Item->GetFromStr(FIELD_EMAIL);
 						if (FromAddr && _stricmp(Addr.Str(), FromAddr) == 0)
 						{
 							Idx = (int)FromCbo->Length();
 						}
 
 						LString p;
 						p.Printf(Template, Name.Str(), Addr.Str());
 						
 						int Id = a->Receive.Id();
 						int CurLen = (int)FromCbo->Length();
 						
 						LAssert(Id != 0);
 						
 						FromAccountId[CurLen] = Id;
 						
 						FromCbo->Insert(p);
 					}
 				}
 			}
 			
 			if (Idx < 0)
 			{
 				auto FromName = Item->GetFromStr(FIELD_NAME);
 				auto FromAddr = Item->GetFromStr(FIELD_EMAIL);
 				if (FromAddr)
 				{
 					LStringPipe p;
 					if (FromName)
 						p.Print(Template, FromName, FromAddr);
 					else
 						p.Print("<%s>", FromAddr);
 					LAutoString s(p.NewStr());
 					FromAccountId[FromCbo->Length()] = -1;
 					Idx = (int)FromCbo->Length();
 					FromCbo->Insert(s);
 					FromCbo->Value(Idx);
 				}
 			}
 			else
 			{
 				FromCbo->Value(Idx);
 			}
 
 			if (ReplyToAddrs.Length() > 0 && ReplyToCbo)
 			{
 				auto CurAddr = Item->GetReply() ? Item->GetReply()->GetStr(FIELD_EMAIL) : NULL;
 				int CurIdx = -1;
 				// for (MailUiNameAddr *na = ReplyToAddrs.First(); na; na = ReplyToAddrs.Next())
 				for (auto na : ReplyToAddrs)
 				{
 					char s[256];
 					sprintf_s(s, sizeof(s), Template, na.value->Name.Get(), na.value->Addr.Get());
 					if (CurAddr && !_stricmp(na.value->Addr, CurAddr))
 						CurIdx = (int)ReplyToCbo->Length();
 					
 					ReplyToCbo->Insert(s);
 				}
 				if (CurIdx >= 0)
 				{
 					ReplyToCbo->Value(CurIdx);
 					ReplyToChk->Value(true);
 				}
 				else
 				{
 					ReplyToChk->Value(false);
 				}
 			}
 			ReplyToAddrs.DeleteObjects();
 		}
 		else if (FromList)
 		{
 			FromList->Empty();
 			ListAddr *na = new ListAddr(App, Item->GetFrom());
 			if (na)
 			{
 				na->CC = MAIL_ADDR_FROM;
 				na->OnFind();
 				FromList->Insert(na);
 			}
 		}
 
 		if (Subject)
 		{
 			Subject->Name(Item->GetSubject());
 			
 			char Title[140];
 			auto Subj = Item->GetSubject();
 			if (Subj)
 				sprintf_s(Title, sizeof(Title), "%s - %.100s", LLoadString(IDS_MAIL_MESSAGE), Subj);
 			else
 				sprintf_s(Title, sizeof(Title), "%s", LLoadString(IDS_MAIL_MESSAGE));
 			Title[sizeof(Title)-1] = 0;
 			for (char *s = Title; *s; s++)
 				if (*s == '\n' || *s == '\r') *s = ' ';
 			Name(Title);
 		}
 
 		int64_t Rgb32 = Item->GetMarkColour();
 		SetCtrlValue(IDC_COLOUR, Rgb32 > 0 ? Rgb32 : -1);
 		SetCtrlName(IDC_LABEL, Item->GetLabel());
 
 		char Date[256];
 		Item->GetDateReceived()->Get(Date, sizeof(Date));
 		SetCtrlName(IDC_RECEIVED_DATE, Date);
 		Item->GetDateSent()->Get(Date, sizeof(Date));
 		SetCtrlName(IDC_SENT_DATE, Date);
 
 		TextLoaded = false;
 		HtmlLoaded = false;
 
 		auto TextContent = Item->GetBody();
 		auto HtmlContent = Item->GetHtml();
 
 		Sx = Sy = -1;
 
 		LDocView *DocView = NULL;
 		if (TabText &&
 			(DocView = Item->CreateView(this, sTextPlain, true, -1, !Edit)))
 		{
 			if (DocView == HtmlView)
 			{
 				// CreateView converted the text to HTML to embed Emojis. If we have
 				// actual HTML content it'll overwrite the text portion, so we need
 				// to move the HTML control to the text tab to leave room for actual HTML.
 				DeleteObj(TextView);
 				TextView = HtmlView;
 				HtmlView = NULL;
 				TextView->Detach();
 				TabText->Append(TextView);
 				TextLoaded = true;
 				HtmlLoaded = false;
 			}
 			
 			if (!TextView && Edit)
 			{
 				// What the? Force creation of control...
 				LAssert(!"Must have an edit control.");
 				LDocView *Dv = App->CreateTextControl(IDC_TEXT_VIEW, sTextPlain, Edit, GetItem());
 				if (Dv)
 					SetDoc(Dv, sTextPlain);
 				LAssert(TextView != NULL);
 			}
 			
 			if (TextView)
 			{
 				TextView->Visible(true);
 				
 				// This needs to be below the resize of the control so that
 				// any wrapping has already been done and thus the scroll
 				// bar is laid out already.
 				if (Item->Cursor > 0)
 					TextView->SetCaret(Item->Cursor, false);
 
 				TabText->GetCss(true)->FontBold(ValidStr(TextContent));
 				TabText->OnStyleChange();
 			}
 		}
 
 		bool ValidHtml = ValidStr(HtmlContent);
 		if (TabHtml &&
 			Item->CreateView(this, sTextHtml, true, -1, !Edit) &&
 			HtmlView)
 		{
 			HtmlView->Visible(true);
 			if (Item->Cursor > 0)
 				HtmlView->SetCaret(Item->Cursor, false);
 
 			TabHtml->GetCss(true)->FontBold(ValidHtml);
 			TabHtml->OnStyleChange();
 		}
 		
 		LVariant DefTab;
 		Item->App->GetOptions()->GetValue(Edit ? OPT_EditControl : OPT_DefaultAlternative, DefTab);
 		CurrentEditCtrl = (Edit || ValidHtml) && DefTab.CastInt32();
 		Tab->Value(CurrentEditCtrl);
 		HtmlCtrlDirty = !ValidHtml;
 		TextCtrlDirty = !ValidStr(TextContent);
 
 		if (CalendarPanel)
 		{
 			auto CalEvents = GetItem()->GetCalendarAttachments();
 			CalendarPanel->Open(CalEvents.Length() > 0);
 		}
 
 		OnPosChange();
 
 		if (Attachments)
 		{
 			Attachments->RemoveAll();
 			
 			List<Attachment> Files;
 			if (Item->GetAttachments(&Files))
 			{
 				for (auto a: Files)
 					Attachments->Insert(a);
 			}
 
 			OnAttachmentsChange();
 		}
 
 		if (Header)
 		{
 			LAutoString Utf((char*)LNewConvertCp("utf-8", Item->GetInternetHeader(), "iso-8859-1"));
 			Header->Name(Utf);
 			Header->SetEnv(Item);
 		}
 
 		bool Update =	(Item->GetFlags() & MAIL_READ) == 0 &&
 						(Item->GetFlags() & MAIL_CREATED) == 0;
 		if (Update)
 		{
 			Item->SetFlags(Item->GetFlags() | MAIL_READ);
 		}
 
 		if (Commands.Toolbar)
 		{
 			int p = Item->GetPriority();
 			Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, p < MAIL_PRIORITY_NORMAL);
 			Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, p > MAIL_PRIORITY_NORMAL);
 			Commands.Toolbar->SetCtrlValue(IDM_READ_RECEIPT, TestFlag(Item->GetFlags(), MAIL_READ_RECEIPT));
 		}
 	}
 
 	if (Item->GetFlags() & (MAIL_CREATED | MAIL_BOUNCE))
 	{
 		if (Entry)
 			Entry->Focus(true);
 	}
 	else
 	{
 		if (TextView)
 			TextView->Focus(true);
 	}
 
 	if (BtnPrev && BtnNext)
 	{
 		if (Item && Container)
 		{
 			/*
 			int Items = Item->GetList()->Length();
 			int i = Item->GetList()->IndexOf(Item);
 			*/
 
 			auto Items = Container->Length();
 			auto i = Container->IndexOf(Item);
 
 			BtnPrev->Enabled(i < (ssize_t)Items - 1);
 			BtnNext->Enabled(i > 0);
 		}
 		else
 		{
 			BtnPrev->Enabled(false);
 			BtnNext->Enabled(false);
 		}
 	}
 
 	if (BtnSend) BtnSend->Enabled(!ReadOnly);
 	if (BtnSave) BtnSave->Enabled(!ReadOnly);
 	if (BtnSaveClose) BtnSaveClose->Enabled(!ReadOnly);
 	if (BtnAttach) BtnAttach->Enabled(!ReadOnly);
 
 	if (BtnReply) BtnReply->Enabled(ReadOnly);
 	if (BtnReplyAll) BtnReplyAll->Enabled(ReadOnly);
 	if (BtnForward) BtnForward->Enabled(true);
 	if (BtnBounce) BtnBounce->Enabled(ReadOnly);
 
 	if (Commands.Toolbar)
 	{
 		Commands.Toolbar->SetCtrlEnabled(IDM_HIGH_PRIORITY, Edit);
 		Commands.Toolbar->SetCtrlEnabled(IDM_LOW_PRIORITY, Edit);
 		Commands.Toolbar->SetCtrlEnabled(IDM_READ_RECEIPT, Edit);
 	}
 
 	_Running = true;
 }
 
 void MailUi::OnSave()
 {
 	if (!GetItem())
 		return;
 
 	if (GetItem()->GetFlags() & MAIL_SENT)
 	{
 		// Save a copy instead of over writing the original sent email
 		Mail *Copy = new Mail(App, GetItem()->GetObject()->GetStore()->Create(MAGIC_MAIL));
 		if (Copy)
 		{
 			*Copy = *_Item;
 			Copy->SetFlags(MAIL_READ | MAIL_CREATED, true);
 			Copy->SetFolder(GetItem()->GetFolder());				
 			Copy->SetDateSent(0);
 			SetItem(Copy);
 		}
 	}
 
 	Mail *Item = GetItem();
 	if (To)
 	{
 		To->OnSave(Item->GetObject()->GetStore(), Item->GetTo());
 	}
 	
 	LMailStore *AccountMailStore = NULL;
 	
 	if (FromCbo && Item->GetFrom() && FromAccountId.Length() > 0)
 	{
 		int64 CboVal = FromCbo->Value();
 		LAssert(CboVal < (ssize_t)FromAccountId.Length());
 		int AccountId = FromAccountId[(int)CboVal];
 		
 		LDataPropI *Frm = Item->GetFrom();
 		if (AccountId < 0)
 		{
 			// From is a literal address, not an account ID. This can happen when bouncing email.
 			Mailto mt(App, FromCbo->Name());
 			if (mt.To.Length() == 1)
 			{
 				AddressDescriptor *a = mt.To[0];
 				if (a)
 				{
 					Frm->SetStr(FIELD_NAME, a->sName);
 					Frm->SetStr(FIELD_EMAIL, a->sAddr);
 				}
 			}
 			else LAssert(0);
 		}
 		else if (AccountId > 0)
 		{
 			ScribeAccount *a = Item->App->GetAccountById(AccountId);
 			if (a)
 			{
 				Frm->SetStr(FIELD_NAME, a->Identity.Name().Str());
 				Frm->SetStr(FIELD_EMAIL, a->Identity.Email().Str());
 			}
 			else LAssert(!"From account missing.");
 			
 			// Find the associated mail store for this account. Hopefully we can put any new
 			// mail into the mail store that the account is using.
 			// 
 			// Check for IMAP mail store?
 			AccountMailStore = a->Receive.GetMailStore();
 			if (!AccountMailStore)
 			{
 				// Nope... what about a receive path?
 				LVariant DestFolder = a->Receive.DestinationFolder();
 				if (ValidStr(DestFolder.Str()))
 				{
 					AccountMailStore = Item->App->GetMailStoreForPath(DestFolder.Str());
 				}
 			}
 		}
 		else LAssert(!"No account id.");
 	}
 	
 	LDataPropI *ReplyObj = Item->GetReply();
 	if (ReplyToCbo != NULL &&
 		ReplyObj != NULL   &&
 		ReplyToChk != NULL &&
 		ReplyToChk->Value())
 	{		
 		Mailto mt(App, ReplyToCbo->Name());
 		if (mt.To.Length() == 1)
 		{
 			AddressDescriptor *a = mt.To[0];
 			if (a && a->sAddr)
 			{
 				if (a->sName)
 					ReplyObj->SetStr(FIELD_NAME, a->sName);
 				ReplyObj->SetStr(FIELD_EMAIL, a->sAddr);
 			}			
 		}
 	}
 
 	Item->SetSubject(Subject->Name());
 
 	Item->SetLabel(GetCtrlName(IDC_LABEL));
 	
 	auto c32 = GetCtrlValue(IDC_COLOUR);
 	Item->SetMarkColour(c32);
 
 	LDocView *Ctrl = CurrentEditCtrl ? HtmlView : TextView;
 	if (Ctrl)
 	{
 		// Delete all existing data...
 		Item->SetBody(0);
 		Item->SetBodyCharset(0);
 		Item->SetHtml(0);
 		Item->SetHtmlCharset(0);
 
 		const char *MimeType = Ctrl->GetMimeType();
 		const char *Charset = Ctrl->GetCharset();
 		if (!_stricmp(MimeType, sTextHtml))
 		{
 			LArray<LDocView::ContentMedia> Media;
 
 			// Set the HTML part
 			LString HtmlFormat;
 			if (!Ctrl->GetFormattedContent("text/html", HtmlFormat, &Media))
 				HtmlFormat = Ctrl->Name();
 			Item->SetHtml(HtmlFormat);
 			Item->SetHtmlCharset(Charset);
 
 			// Also set a text version for the alternate
 			LString TxtFormat;
 			if (!Ctrl->GetFormattedContent(sTextPlain, TxtFormat))
 			{
 				TxtFormat = HtmlToText(Item->GetHtml(), Charset);
 			}
 			if (TxtFormat)
 			{
 				Item->SetBody(TxtFormat);
 				Item->SetBodyCharset(Charset);
 			}
 
 			auto Obj = Item->GetObject();
 
 			// This clears any existing multipart/related objects...
 			Obj->SetObj(FIELD_HTML_RELATED, NULL);
 
 			if (Media.Length() > 0)
 			{
 				// Make a table of existing attachments so that we don't duplicate
 				// these new ones.
 				LArray<LDataI*> Objs;
 				LHashTbl<ConstStrKey<char,false>,LDataI*> Map;
 				if (GetItem()->GetAttachmentObjs(Objs))
 				{
 					for (auto i : Objs)
 					{
 						auto Cid = i->GetStr(FIELD_CONTENT_ID);
 						if (Cid)
 							Map.Add(Cid, i);
 					}
 				}
 
 				// If there are media attachments, splice them into the MIME tree.
 				// This should go after setting the text part so that the right
 				// MIME alternative structure is generated.
 				auto Store = Obj->GetStore();
 				for (auto &Cm : Media)
 				{
 					LDataI *a = Store->Create(MAGIC_ATTACHMENT);
 					if (a)
 					{
 						LAssert(Cm.Valid());
 						
 						auto Existing = Map.Find(Cm.Id);
 						if (Existing)
 						{
 							// Delete the existing attachment
 							Thing *t = CastThing(Existing);
 							Attachment *a = t ? t->IsAttachment() : NULL;
 							if (a)
 							{
 								// Delete both the Attachment and it's store object...
 								auto it = GetItem();
 								it->DeleteAttachment(a);
 							}
 							else
 							{
 								// There is Attachment object for the LDataI.... but we can
 								// still delete it from the store.
 								LArray<LDataI*> del;
 								del.Add(Existing);
 								Existing->GetStore()->Delete(del, false);
 							}
 						}
 
 						LgiTrace("Adding related: %s %s " LPrintfInt64 "\n",
 							Cm.FileName.Get(),
 							Cm.MimeType.Get(),
 							Cm.Stream->GetSize());
 
 						a->SetStr(FIELD_CONTENT_ID, Cm.Id);
 						a->SetStr(FIELD_NAME, Cm.FileName);
 						a->SetStr(FIELD_MIME_TYPE, Cm.MimeType);
 						a->SetStream(Cm.Stream);
 						
 						Obj->SetObj(FIELD_HTML_RELATED, a);
 					}
 				}
 			}
 		}
 		else
 		{
 			auto Text = Ctrl->Name();
 			Item->SetBody(Text);
 			Item->SetBodyCharset(Charset);
 		}
 	}
 
 	#if SAVE_HEADERS
 	char *Headers = Header ? Header->Name() : 0;
 	if (Headers)
 	{
 		DeleteArray(Item->InternetHeader);
 		Item->InternetHeader = NewStr(Headers);
 	}
 	#endif
 
 	Item->GetMessageId(true);
 	Item->CreateMailHeaders();
 	Item->Update();
 	
 	ScribeFolder *Folder = Item->GetFolder();
 
 	// Now get the associated outbox for this mail
 	ScribeFolder *Outbox = Item->App->GetFolder(FOLDER_OUTBOX, AccountMailStore);
 	
 	auto Fld = Folder ? Folder : Outbox;
 	LAssert(Fld != NULL);
 	bool Status = Fld ? Item->Save(Fld) : false;
 	if (Status)
 	{
 		LArray<LDataI*> c;
 		c.Add(Item->GetObject());
 
 		Item->App->SetContext(_FL);
 		Item->App->OnChange(c, 0);
 	}
 }
 
 bool MailUi::AddRecipient(AddressDescriptor *Addr)
 {
 	if (Addr && To)
 	{
 		ListAddr *La = dynamic_cast<ListAddr *>(Addr);
 		if (La)
 		{
 			To->Insert(La);
 			return true;
 		}
 	}
 	return false;
 }
 
 bool MailUi::AddRecipient(Contact *c)
 {
 	ListAddr *La = new ListAddr(c);
 	if (La)
 	{
 		To->Insert(La);
 		return true;
 	}
 
 	return false;
 }
 
 bool MailUi::AddRecipient(const char *Email, const char *Name)
 {
 	ListAddr *La = new ListAddr(App, Email, Name);
 	if (La)
 	{
 		To->Insert(La);
 		return true;
 	}
 
 	return false;
 }
 
 bool MailUi::SeekMsg(int delta)
 {
 	bool Status = false;
 
 	if (Container)
 	{
 		Mail *Item = GetItem();
 		auto Index = Container->IndexOf(Item);
 		Mail *Next = Index >= 0 ? (*Container)[Index + delta] : 0;
 		if (Next)
 		{
 			SetDirty(false); // called OnSave() if necessary
 			_Running = false;
 
 			if (Item->Ui)
 			{
 				// close any existing user interface
 				if (Item->Ui != this)
 				{
 					Item->Ui->Quit();
 				}
 				else
 				{
 					Item->Ui = 0;
 				}
 			}
 			if (Header)
 				Header->SetEnv(0);
 
 			Caps.Empty();
 			SetItem(Next);
 			Item = GetItem();
 
 			// select this item in the list
 			if (Item->GetList())
 			{
 				Item->GetList()->Select(Item);
 				Item->ScrollTo();
 			}
 
 			Status = true;
 
 			OnLoad();
 			_Running = true;
 		}
 	}
 
 	return Status;
 }
 
 int MailUi::HandleCmd(int Cmd)
 {
 	switch (Cmd)
 	{
 		case IDM_READ_RECEIPT:
 		{
 			if (Commands.Toolbar)
 			{
 				int f = GetItem()->GetFlags();
 				if (Commands.Toolbar->GetCtrlValue(IDM_READ_RECEIPT))
 				{
 					SetFlag(f, MAIL_READ_RECEIPT);
 				}
 				else
 				{
 					ClearFlag(f, MAIL_READ_RECEIPT);
 				}
 				GetItem()->SetFlags(f);
 			}
 			break;
 		}
 		case IDM_HIGH_PRIORITY:
 		{
 			if (Commands.Toolbar)
 			{
 				GetItem()->SetPriority(Commands.Toolbar->GetCtrlValue(IDM_HIGH_PRIORITY) ? MAIL_PRIORITY_HIGH : MAIL_PRIORITY_NORMAL);
 				SetDirty(true);
 
 				Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, GetItem()->GetPriority() < MAIL_PRIORITY_NORMAL);
 				Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, GetItem()->GetPriority() > MAIL_PRIORITY_NORMAL);
 			}
 			break;
 		}
 		case IDM_LOW_PRIORITY:
 		{
 			if (Commands.Toolbar)
 			{
 				GetItem()->SetPriority(Commands.Toolbar->GetCtrlValue(IDM_LOW_PRIORITY) ? MAIL_PRIORITY_LOW : MAIL_PRIORITY_NORMAL);
 				SetDirty(true);
 
 				Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, GetItem()->GetPriority() < MAIL_PRIORITY_NORMAL);
 				Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, GetItem()->GetPriority() > MAIL_PRIORITY_NORMAL);
 			}
 			break;
 		}
 		case IDM_PREV_MSG:
 		{
 			SeekMsg(1);
 			break;
 		}
 		case IDM_NEXT_MSG:
 		{
 			SeekMsg(-1);
 			break;
 		}
 		case IDM_SEND_MSG:
 		{
 			bool Working = IsWorking();
 			if (Working)
 			{
 				SetCmdAfterResize(Cmd);
 				break;
 			}
 
 			if (!GetItem() || !App)
 			{
 				LAssert(!"Missing item or window ptr.");
 				break;
 			}
 			
 			// Normal save
 			bool IsInPublicFolder = GetItem()->GetFolder() && GetItem()->GetFolder()->IsPublicFolders();
 			if (IsInPublicFolder)
 			{
 				auto i = GetItem();
 				LDateTime n;
 				n.SetNow();
 				i->SetDateSent(&n);
 				i->Update();
 			}
 
 			OnDataEntered();
 			OnSave();
 			SetDirty(false, false);
 			GetItem()->Send(true);
 			Quit();
 			return 0;
 		}
 		case IDM_DELETE_MSG:
 		{
 			LVariant ConfirmDelete, DelDirection;
 			App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 			App->GetOptions()->GetValue(OPT_DelDirection, DelDirection);
 			int WinAction = DelDirection.CastInt32() - 1; // -1 == Next, 0 == Close, 1 == Prev
 
 			if (!ConfirmDelete.CastInt32() ||
 				LgiMsg(this, LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 			{
 				Mail *Del = GetItem()->GetObject() ? GetItem() : 0;
 				if (Del)
 				{
 					if (!Del->GetObject()->IsOnDisk())
 						Del = 0;
 				}
 				
 				if (!WinAction || !SeekMsg(WinAction))
 				{
 					SetItem(0);
 					PostEvent(M_CLOSE);
 				}
 				
 				if (Del && Del->GetObject())
 				{
 					Del->OnDelete();
 				}
 			}
 			break;
 		}
 		case IDM_DELETE_AS_SPAM:
 		{
 			LVariant DelDirection;
 			App->GetOptions()->GetValue(OPT_DelDirection, DelDirection);
 			int WinAction = DelDirection.CastInt32() - 1; // -1 == Next, 0 == Close, 1 == Prev
 			
 			if (GetItem())
 			{
 				Mail *Del = GetItem()->GetObject() ? GetItem() : 0;
 
 				if (!WinAction || !SeekMsg(WinAction))
 				{
 					SetItem(0);
 					PostEvent(M_CLOSE);
 				}
 
 				if (Del)
 				{
 					Del->DeleteAsSpam(this);
 				}
 			}
 			break;
 		}
 		case IDM_SAVE:
 		{
 			OnDataEntered();
 			SetDirty(false, false);
 			break;
 		}
 		case IDM_SAVE_CLOSE:
 		{
 			bool Working = IsWorking();
 			if (Working)
 			{
 				SetCmdAfterResize(Cmd);
 				break;
 			}
 
 			OnDataEntered();
 			SetDirty(false, false);
 			// fall thru
 		}
 		case IDM_CLOSE:
 		{
 			Quit();
 			return 0;
 		}
 		case IDM_REPLY:
 		case IDM_REPLY_ALL:
 		{
 			App->MailReplyTo(GetItem(), Cmd == IDM_REPLY_ALL);
 			SetDirty(false);
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_FORWARD:
 		{
 			App->MailForward(GetItem());
 			if (IsDirty())
 				OnSave();
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_BOUNCE:
 		{
 			App->MailBounce(GetItem());
 			OnSave();
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_PRINT:
 		{
 			if (GetItem() && App)
 			{
 				if (IsDirty())
 				{
 					OnDataEntered();
 					OnSave();
 				}
 				App->ThingPrint(NULL, GetItem(), 0, this);
 			}
 			break;
 		}
 		case IDM_ATTACH_FILE:
 		{
 			auto Select = new LFileSelect(this);
 			Select->MultiSelect(true);
 			Select->Type("All files", LGI_ALL_FILES);
 			Select->Open([this](auto dlg, auto status)
 			{
 				if (status)
 				{
 					Mail *m = GetItem();
 					if (m)
 					{
 						for (size_t i=0; i<dlg->Length(); i++)
 						{
 							char File[MAX_PATH_LEN];
 							if (!LResolveShortcut((*dlg)[i], File, sizeof(File)))
 							{
 								strcpy_s(File, sizeof(File), (*dlg)[i]);
 							}
 
 							Attachment *a = m->AttachFile(this, File);
 							if (a && Attachments)
 							{
 								Attachments->Insert(a);
 								Attachments->ResizeColumnsToContent();
 							}
 						}
 					}
 				}
 				delete dlg;
 			});
 			break;
 		}
 		default:
 		{
 			if (Commands.ExecuteCallbacks(App, this, GetItem(), Cmd))
 				return true;
 			
 			return false;
 		}
 	}
 
 	return true;
 }
 
 int MailUi::OnCommand(int Cmd, int Event, OsView From)
 {
 	if (GpgUi)
 	{
 		GpgUi->DoCommand(Cmd, [this, Cmd](auto r)
 		{
 			if (!r)
 				HandleCmd(Cmd);
 		});
 	}
 	else
 	{
 		HandleCmd(Cmd);
 	}
 
 	return LWindow::OnCommand(Cmd, Event, From);
 }
 
 LArray<Attachment*> Mail::GetCalendarAttachments()
 {
 	List<Attachment> Attachments;
 	if (!GetAttachments(&Attachments))
 		return false;
 
 	LArray<Attachment*> Cal;
 	for (auto a: Attachments)
 	{
 		LString Mt = a->GetMimeType();
 		if (Mt.Equals("text/calendar"))
 			Cal.Add(a);
 	}
 
 	return Cal;
 }
 
 bool MailUi::AddCalendarEvent(bool AddPopupReminder)
 {
 	LString Msg;
 	auto Result = GetItem()->AddCalendarEvent(this, AddPopupReminder, &Msg);
 
 	auto css = CalPanelStatus->GetCss(true);
 	if (Result) css->Color(LCss::ColorInherit);
 	else css->Color(LColour::Red);
 	CalPanelStatus->Name(Msg);
 
 	return Result;
 }
 
 
 bool Mail::AddCalendarEvent(LViewI *Parent, bool AddPopupReminder, LString *Msg)
 {
 	LString Err, s;
 	auto Cal = GetCalendarAttachments();
 	int NewEvents = 0, DupeEvents = 0, Processed = 0, Cancelled = 0, NotMatched = 0;
 	ScribeFolder *Folder = NULL;
 	if (Cal.Length() == 0)
 	{
 		Err = "There are no attached events to add.";
 		goto OnError;
 	}
 
 	Folder = App->GetFolder(FOLDER_CALENDAR);
 	if (!Folder)
 	{
 		Err = "There no calendar folder to save to.";
 		goto OnError;
 	}
 
 	for (auto a: Cal)
 	{
 		auto Event = App->CreateThingOfType(MAGIC_CALENDAR);
 		if (Event)
 		{
 			LString Mt = a->GetMimeType();
 			LAutoPtr<LStreamI> Data(a->GotoObject(_FL));
 			if (Data)
 			{
 				if (Event->Import(AutoCast(Data), Mt))
 				{
 					auto c = Event->IsCalendar();
 					auto obj = c ? c->GetObject() : NULL;
 					if (!obj)
 						continue;
 					
 					if (AddPopupReminder)
 					{
 						LString s;
 						s.Printf("%g,%i,%i,", 10.0, CalMinutes, CalPopup);
 						obj->SetStr(FIELD_CAL_REMINDERS, s);
 					}
 					
 					// Is it a cancellation?
 					auto Status = obj->GetStr(FIELD_CAL_STATUS);
 					auto IsCancel = Stristr(Status, "CANCELLED") != NULL;
 					if (!IsCancel)
 					{
 						// Does the folder already have a copy of this event?
 						bool AlreadyAdded = false;
 						for (auto t: Folder->Items)
 						{
 							auto Obj = t->IsCalendar();
 							if (Obj && *Obj == *c)
 							{
 								AlreadyAdded = true;
 								break;
 							}
 						}
 
 						if (AlreadyAdded)
 						{
 							DupeEvents++;
 						}
 						else
 						{
 							// Write the event to the folder
 							auto Status = Folder->WriteThing(Event);
 							if (Status > Store3Error)
 							{
 								NewEvents++;
 								Event = NULL;
 							}
 						}
 					}
 					else
 					{
 						// Cancellation processing
 						auto Uid = obj->GetStr(FIELD_UID);
 						Thing *Match = NULL;
 						for (auto t: Folder->Items)
 						{
 							auto tCal = t->IsCalendar();
 							if (tCal && tCal->GetObject())
 							{
 								auto tUid = tCal->GetObject()->GetStr(FIELD_UID);
 								if (!Stricmp(Uid, tUid))
 								{
 									Match = t;
 									break;
 								}
 							}
 						}
 						if (Match)
 						{
 							if (!Parent || LgiMsg(Parent, "Delete cancelled event?", "Calendar", MB_YESNO) == IDYES)
 							{
 								auto f = Match->GetFolder();
 								LArray<Thing*> items;
 								items.Add(Match);
 								f->Delete(items, true);
 								Cancelled++;
 							}
 						}
 						else NotMatched++;
 					}
 				}
 				else LgiTrace("%s:%i - vCal event import failed.\n", _FL);
 			}
 			else LgiTrace("%s:%i - GotoObject failed.\n", _FL);
 
 			if (Event)
 				Event->DecRef();
 		}
 		else LgiTrace("%s:%i - CreateThingOfType failed.\n", _FL);
 	}
 
 	Processed = NewEvents + DupeEvents;
 	if (Processed != Cal.Length())
 	{
 		Err.Printf("There were errors processing %i events, check the console.", (int)Cal.Length() - Processed);
 		goto OnError;
 	}
 
 	if (NewEvents || DupeEvents)
 		s.Printf("%i new events, %i duplicates.", NewEvents, DupeEvents);
 	else
 		s.Printf("%i events cancelled, %i not matched.", Cancelled, NotMatched);
 
 	if (Msg)
 		*Msg = s;
 
 	if (Processed > 0)
 	{
 		for (auto v: CalendarView::CalendarViews)
 			v->OnContentsChanged();
 	}
 
 	return true;
 
 OnError:
 	if (Msg)
 		*Msg = Err;
 	return false;
 }
 
 int MailUi::OnNotify(LViewI *Col, LNotification n)
 {
 	if (dynamic_cast<LPanel*>(Col))
 	{
 		Sx = Sy = -1;
 		OnPosChange();
 		return 0;
 	}
 
 	if (GpgUi)
 	{
 		if (n.Type == LNotifyItemDelete &&
 			Col == (LViewI*)GpgUi)
 		{
 			GpgUi = NULL;			
 		}
 		else
 		{
 			int r = GpgUi->OnNotify(Col, n);
 			if (r)
 				return r;
 		}
 	}	
 
 	int CtrlId = Col->GetId();
 	switch (CtrlId)
 	{
 		case IDC_MAIL_UI_TABS:
 		{
 			Mail *Item = GetItem();
 			if (!Item)
 				break;
 			// bool Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 			
 			if (n.Type == LNotifyValueChanged)
 			{
 				switch (Col->Value())
 				{
 					case 0: // Text tab
 					{
 						if (!TextLoaded)
 						{
 							Item->CreateView(this, sTextPlain, true, -1);
 							OnPosChange();
 						}
 						
 						if (CurrentEditCtrl == 1)
 						{
 							if (HtmlView &&
 								TextView &&
 								TextCtrlDirty)
 							{
 								// Convert HTML to Text here...
 								TextCtrlDirty = false;
 								auto Html = HtmlView->Name();
 								if (Html)
 								{
 									LString Txt = HtmlToText(Html, HtmlView->GetCharset());
 									if (Txt)
 										TextView->Name(Txt);
 								}
 							}
 
 							CurrentEditCtrl = 0;
 						}
 						break;
 					}
 					case 1: // Html tab
 					{
 						if (!HtmlLoaded)
 						{
 							Item->CreateView(this, sTextHtml, true, -1);
 							OnPosChange();
 						}
 
 						if (CurrentEditCtrl == 0)
 						{
 							if (HtmlView &&
 								TextView &&
 								HtmlCtrlDirty)
 							{
 								// Convert Text to HTML here...
 								HtmlCtrlDirty = false;
 								auto Text = TextView->Name();
 								if (Text)
 								{
 									LString Html = TextToHtml(Text, TextView->GetCharset());
 									if (Html)
 										HtmlView->Name(Html);
 								}
 							}
 
 							CurrentEditCtrl = 1;
 						}
 						break;
 					}
 					default: // Do nothing on other tabs..
 						break;
 				}
 			}
 			else if (n.Type == LNotifyItemClick)
 			{
 				LMouse m;
 				if (!Col->GetMouse(m))
 					break;
 				
 				int TabIdx = Tab->HitTest(m);
 				if (TabIdx == 0 || TabIdx == 1)
 				{
 					if (Item && m.IsContextMenu())
 					{
 						LSubMenu s;
 						s.AppendItem(LLoadString(IDS_DELETE), IDM_DELETE);
 						
 						m.ToScreen();
 						int Cmd = s.Float(this, m.x, m.y, false);
 						if (Cmd == IDM_DELETE)
 						{
 							if (TabIdx == 0) // Txt
 							{
 								Item->SetBody(NULL);
 								Item->SetBodyCharset(NULL);
 								TextView->Name(NULL);
 
 								if (TabText)
 								{
 									TabText->GetCss(true)->FontBold(false);
 									TabText->OnStyleChange();
 								}
 								TextCtrlDirty = false;
 							}
 							else // HTML
 							{
 								Item->SetHtml(NULL);
 								Item->SetHtmlCharset(NULL);
 								HtmlView->Name(NULL);
 
 								if (TabHtml)
 								{
 									TabHtml->GetCss(true)->FontBold(false);
 									TabHtml->OnStyleChange();
 								}
 								HtmlCtrlDirty = false;
 							}
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDC_FROM:
 		{
 			if (_Running &&
 				FromCbo &&
 				n.Type == LNotifyValueChanged)
 				SetDirty(true);
 			break;
 		}
 		case IDC_SHOW_FROM:
 		{
 			LVariant Show = Col->Value();;
 			App->GetOptions()->SetValue(OPT_MailShowFrom, Show);
 			break;
 		}
 		case IDC_LAUNCH_HTML:
 		{
 			char File[MAX_PATH_LEN];
 			if (GetItem() &&
 				GetItem()->WriteAlternateHtml(File))
 			{
 				LExecute(File);
 			}
 			break;
 		}
 		case IDC_ENTRY:
 		{
 			if (Entry)
 			{
 				if (ValidStr(Entry->Name()))
 				{
 					if (!Browse)
 					{
 						Browse = new AddressBrowse(App, Entry, To, SetTo);
 					}
 				}
 				if (Browse)
 				{
 					Browse->OnNotify(Entry, n);
 				}
 				
 				if (n.Type == LNotifyReturnKey)
 				{
 					OnDataEntered();
 				}
 			}
 			break;
 		}
 		case IDC_SET_TO:
 		{
 			if (SetTo)
 			{
 				AddMode = (int)SetTo->Value();
 			}
 			break;
 		}
 		case IDC_SEND:
 		{
 			OnCommand(IDM_SEND_MSG, 0,
 				#if LGI_VIEW_HANDLE
 				Col->Handle()
 				#else
 				(OsView)NULL
 				#endif
 				);
 			break;
 		}
 		#if SAVE_HEADERS
 		case IDC_INTERNET_HEADER: 
 		#endif
 		case IDC_TEXT_VIEW:
 		case IDC_HTML_VIEW:
 		{
 			Mail *Item = GetItem();
 			if (!Item)
 				break;
 			bool Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 
 			if
 			(
 				(
 					n.Type == LNotifyDocChanged
 					||
 					n.Type == LNotifyCharsetChanged
 					||
 					n.Type == LNotifyFixedWidthChanged
 					||
 					(!IgnoreShowImgNotify && n.Type == LNotifyShowImagesChanged)
 				)
 				&&
 				_Running
 			)
 			{
 				if (GetItem())
 					GetItem()->OnNotify(Col, n);
 				SetDirty(true);
 				
 				if (Edit)
 				{
 					if (CtrlId == IDC_TEXT_VIEW)
 					{
 						CurrentEditCtrl = 0;
 						HtmlCtrlDirty = true;						
 						TabText->GetCss(true)->FontBold(true);
 						TabText->OnStyleChange();
 					}
 					else if (CtrlId == IDC_HTML_VIEW)
 					{
 						CurrentEditCtrl = 1;
 						TextCtrlDirty = true;						
 						TabHtml->GetCss(true)->FontBold(true);
 						TabHtml->OnStyleChange();
 					}
 
 					// LgiTrace("%s:%i - OnNotify: TextLoaded=%i, HtmlLoaded=%i\n", _FL, TextLoaded, HtmlLoaded);
 				}
 			}
 			break;
 		}
 		case IDC_ATTACHMENTS:
 		{
 			if (n.Type == LNotifyItemInsert ||
 				n.Type == LNotifyItemDelete)
 			{
 				// fall thru
 			}
 			else
 			{
 				break;
 			}
 		}
 		case IDC_TO:
 		{
 			if
 			(
 				_Running
 				&&
 				(
 					n.Type == LNotifyItemInsert
 					||
 					n.Type == LNotifyItemDelete
 					||
 					n.Type == LNotifyItemChange
 				)
 			)
 			{
 				SetDirty(true);
 			}
 			break;
 		}
 		case IDC_COLOUR:
 		{
 			if (_Running && GetItem())
 			{
 				MetaFieldsDirty = true;
 				OnDirty(true);
 			}
 			break;
 		}
 		case IDC_LABEL:
 		{
 			if (_Running)
 			{
 				MetaFieldsDirty = true;
 				OnDirty(true);
 			}
 			break;
 		}
 		case IDC_SUBJECT:
 		{
 			if (_Running)
 			{
 				SetDirty(true);
 			}
 			break;
 		}
 		case IDCANCEL:
 		{
 			if (CmdAfterResize)
 			{
 				int Cmd = CmdAfterResize;
 				CmdAfterResize = 0;
 				IsWorking(false);		
 				
 				OnCommand(Cmd, 0, NULL);
 			}
 			break;
 		}
 		case IDC_ADD_CAL_EVENT:
 		{
 			AddCalendarEvent(false);
 			break;
 		}
 		case IDC_ADD_CAL_EVENT_POPUP:
 		{
 			AddCalendarEvent(true);
 			break;
 		}
 	}
 	return 0;
 }
 
 void MailUi::OnDataEntered()
 {
 	auto Name = Entry->Name();
 	if (ValidStr(Name))
 	{
 		List<AddressDescriptor> New;
 		
 		// Decode the entries
 		Mailto mt(App, Name);
 		New = mt.To;
 		mt.To.Empty();
 		
 		if (mt.Subject &&
 			!ValidStr(GetCtrlName(IDC_SUBJECT)))
 		{
 			SetCtrlName(IDC_SUBJECT, mt.Subject);
 		}
 
 		// Add the new entries
 		List<Contact> Cache;
 		App->GetContacts(Cache);
 		AddressDescriptor *ad;
 		while ((ad = New[0]))
 		{
 			New.Delete(ad);
 
 			ListAddr *t = dynamic_cast<ListAddr*>(ad);
 			if (t)
 			{
 				t->CC = (EmailAddressType)GetCtrlValue(IDC_SET_TO);
 				t->OnFind(&Cache);
 				To->Insert(t, 0);
 			}
 			else
 			{
 				DeleteObj(ad);
 			}
 		}
 
 		// Clear the entry box for the next one
 		Entry->Name("");
 		Entry->Select(-1, -1);
 	}
 }
 
 void MailUi::OnPosChange()
 {	
 	LWindow::OnPosChange();
 
 	if (Tab && (Sx != X() || Sy != Y()))
 	{
 		Sx = X();
 		Sy = Y();
 
 		LRect r = Tab->GetCurrent()->GetClient();
 		r.Inset(CONTENT_BORDER, CONTENT_BORDER);
 
 		if (TextView)
 			TextView->SetPos(r, true);
 
 		if (HtmlView)
 			HtmlView->SetPos(r, true);
 
 		if (Attachments)
 			Attachments->SetPos(r, true);
 
 		if (Header)
 			Header->SetPos(r, true);
 	}
 }
 
 void MailUi::OnPaint(LSurface *pDC)
 {
 	LCssTools Tools(this);
 	Tools.PaintContent(pDC, GetClient());
 }
 
 void MailUi::OnPulse()
 {
 	if (IsDirty() && TextView && GetItem())
 	{
 		// Ui -> Object
 		OnSave();
 		
 		// Object -> Disk
 		GetItem()->Save(0);
 	}
 	else
 	{
 		SetPulse();
 	}
 }
 
 void MailUi::OnDirty(bool Dirty)
 {
 	SetCtrlEnabled(IDM_SAVE, Dirty);
 	SetCtrlEnabled(IDM_SAVE_CLOSE, Dirty);
 	
 	if (Dirty)
 	{
 		SetPulse(60 * 1000); // every minute
 	}
 	else
 	{
 		SetPulse();
 	}
 }
 
 bool MailUi::CallMethod(const char *Name, LVariant *Dst, LArray<LVariant*> &Arg)
 {
 	ScribeDomType Method = StrToDom(Name);
 
 	*Dst = false;
 	switch (Method)
 	{
 		case SdShowRemoteContent: // Type: ()
 			if (HtmlView)
 			{
 				bool Always = Arg.Length() > 0 ? Arg[0]->CastBool() : false;
 				if (Always && GetItem())
 				{
 					auto From = GetItem()->GetFrom();
 					if (From)
 						App->RemoteContent_AddSender(From->GetStr(FIELD_EMAIL), true);
 					else
 						LgiTrace("%s:%i - No from address.\n", _FL);
 				}
 
 				IgnoreShowImgNotify = true;
 				HtmlView->SetLoadImages(true);
 				IgnoreShowImgNotify = false;
 				PostEvent(M_UPDATE);
 				*Dst = true;
 			}
 			break;
 		case SdSetHtml: // Type: (String Html)
 			if (HtmlView)
 			{
 				if (Arg.Length() > 0)
 				{
 					HtmlView->Name(Arg[0]->Str());
 					*Dst = true;
 				}
 			}
 			break;
 		default:
 			return false;
 	}
 	
 	return true;	
 }
 
 LMessage::Result MailUi::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_SET_HTML:
 		{
 			LAutoPtr<LString> s((LString*)Msg->A());
 			if (s && HtmlView)
 				HtmlView->Name(*s);
 			break;
 		}
 		case M_NEEDS_CAP:
 		{
 			LAutoString c((char*)Msg->A());
 			NeedsCapability(c);
 			return 0;
 		}
 		case M_RESIZE_IMAGE:
 		{
 			LAutoPtr<ImageResizeThread::Job> Job((ImageResizeThread::Job*)Msg->A());
 			if (Job && GetItem())
 			{
 				// Find the right attachment...
 				List<Attachment> Attachments;
 				if (GetItem()->GetAttachments(&Attachments))
 				{
 					Attachment *Match = NULL;
 					for (auto a: Attachments)
 					{
 						LString Nm = a->GetName();
 						if (Nm.Equals(Job->FileName))
 						{
 							Match = a;
 							break;
 						}
 					}
 					if (Match)
 					{
 						if (Job->Data)
 							Match->Set(Job->Data);
 						
 						auto Mt = Match->GetMimeType();
 						if (_stricmp(Mt, "image/jpeg"))
 						{
 							auto Name = Match->GetName();
 							char *Ext = LGetExtension(Name);
 							if (Ext)
 								*Ext = 0;
 							LString NewName = Name;
 							NewName += "jpg";
 							Match->SetName(NewName);
 							Match->SetMimeType("image/jpeg");
 						}
 						
 						Match->SetIsResizing(false);
 						
 						LDataI *AttachPoint = GetItem()->GetFileAttachPoint();
 						if (AttachPoint)
 						{
 							// Do final save to the mail store...
 							Match->GetObject()->Save(AttachPoint);
 						}
 						else
 						{
 							LAssert(0);
 							Match->DecRef();
 							Match = NULL;
 						}
 						
 						if (CmdAfterResize)
 						{
 							bool Working = IsWorking();
 							if (!Working)
 							{
 								// All resizing work is done...
 								OnCommand(CmdAfterResize, 0, NULL);
 								return 0;
 							}
 						}
 					}
 					else LAssert(!"No matching attachment image to store resized image in.");
 				}
 			}
 			break;
 		}
 		#if WINNATIVE
 		case WM_COMMAND:
 		{
 			LAssert((NativeInt)Commands.Toolbar != 0xdddddddd);
 
 			if (Commands.Toolbar && Commands.Toolbar->Handle() == (HWND)Msg->b)
 			{
 				return LWindow::OnEvent(Msg);
 			}
 			break;
 		}
 		#endif
 	}
 
 	return LWindow::OnEvent(Msg);
 }
 
 void MailUi::OnReceiveFiles(LArray<const char*> &Files)
 {
 	List<Attachment> Att;
 	GetItem()->GetAttachments(&Att);
 
 	for (unsigned i=0; i<Files.Length(); i++)
 	{
 		auto FileName = Files[i];
 		bool Add = true;
 		char Path[MAX_PATH_LEN];
 
 		if (!LResolveShortcut(FileName, Path, strlen(Path)))
 		{
 			strcpy_s(Path, sizeof(Path), FileName);
 		}
 
 		for (auto a: Att)
 		{
 			char *f = Path;
 			while (strchr(f, '\\'))
 			{
 				f = strchr(f, '\\') + 1;
 			}
 
 			if (_stricmp(a->GetName(), f) == 0)
 			{
 				int Result = LgiMsg(this, LLoadString(IDS_ATTACH_WARNING_DLG), LLoadString(IDS_ATTACHMENTS), MB_YESNO);
 				if (Result == IDNO)
 				{
 					Add = false;
 					break;
 				}
 			}
 		}
 
 		if (Add)
 		{
 			Attachment *a = GetItem()->AttachFile(this, Path);
 			if (a)
 			{
 				Attachments->Insert(a);
 				Attachments->ResizeColumnsToContent();
 			}
 		}
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 bool Mail::PreviewLines = false;
 bool Mail::RunMailPipes = true;
 List<Mail> Mail::NewMailLst;
 bool Mail::AdjustDateTz = true;
 LHashTbl<ConstStrKey<char>,Mail*> Mail::MessageIdMap;
 
 Mail::Mail(ScribeWnd *app, LDataI *object) : Thing(app, object)
 {
 	DefaultObject(object);
 	d = new MailPrivate(this);
 	_New();
 }
 
 Mail::~Mail()
 {
     if (GetObject())
     {
         auto Id = GetObject()->GetStr(FIELD_MESSAGE_ID);
         if (Id)
             MessageIdMap.Delete(Id);
     }
 
 	NewMailLst.Delete(this);
 	_Delete();
 	DeleteObj(d);
 }
 
 void Mail::_New()
 {
 	SendAttempts = 0;
 	Container = 0;
 	FlagsCache = -1;
 	PreviewCacheX = 0;
 	Cursor = 0;
 	ParentFile = 0;
 	PreviousMail = 0;
 	NewEmail = NewEmailNone;
 	
 	Ui = 0;
 	TotalSizeCache = -1;
 }
 
 void Mail::_Delete()
 {
 	if (ParentFile)
 	{
 		ParentFile->SetMsg(0);
 	}
 
 	UnloadAttachments();
 	PreviewCache.DeleteObjects();
 	DeleteObj(Container);
 
 	if (Ui)
 		Ui->PostEvent(M_CLOSE);
 	if (Ui)
 		Ui->SetItem(0);
 }
 
 bool Mail::AppendItems(LSubMenu *Menu, const char *Param, int Base)
 {
 	auto Remove = Menu->AppendSub(LLoadString(IDS_REMOVE));
 	if (Remove)
 	{
 		Remove->AppendItem("'>'", IDM_REMOVE_GRTH, true);
 		Remove->AppendItem("'> '", IDM_REMOVE_GRTH_SP, true);
 		Remove->AppendItem(LLoadString(IDS_HTML_TAGS), IDM_REMOVE_HTML, true);
 	}
 
 	auto FilterMenu = Menu->AppendSub(LLoadString(IDS_FILTER));
 	if (FilterMenu)
 	{
 		FilterMenu->SetImageList(App->GetIconImgList(), false);
 		Actions.Empty();
 		AddActions(FilterMenu, Actions, App->GetThingSources(MAGIC_FILTER));
 	}
 
 	auto Convert = Menu->AppendSub(LLoadString(IDS_CONVERT_SELECTION));
 	if (Convert)
 	{
 		Convert->AppendItem("To Base64", IDM_CONVERT_BIN_TO_B64, true);
 		Convert->AppendItem("To Binary", IDM_CONVERT_B64_TO_BIN, true);
 	}
 	
 	if (!TestFlag(GetFlags(), MAIL_CREATED))
 	{
 		auto Charset = Menu->AppendSub(LLoadString(L_CHANGE_CHARSET));
 		if (Charset)
 		{
 			int n=0;
 			for (LCharset *c = LGetCsList(); c->Charset; c++, n++)
 				Charset->AppendItem(c->Charset, IDM_CHARSET_BASE + n, c->IsAvailable());
 		}
 	}
 
 	return true;
 }
 
 bool Mail::OnMenu(LDocView *View, int Id, void *Context)
 {
 	const char *RemoveStr = 0;
 
 	switch (Id)
 	{
 		case IDM_REMOVE_GRTH:
 		{
 			RemoveStr = ">";
 			break;
 		}
 		case IDM_REMOVE_GRTH_SP:
 		{
 			RemoveStr = "> ";
 			break;
 		}
 		case IDM_REMOVE_HTML:
 		{
 			auto s = View ? View->Name() : 0;
 			if (s)
 			{
 				auto n = DeHtml(s);
 				if (n)
 				{
 					View->Name(n);
 					DeleteArray(n);
 				}
 			}
 			break;
 		}
 		default:
 		{
 			if (Id >= IDM_CHARSET_BASE)
 			{
 				int n=0;
 				LCharset *c;
 				for (c = LGetCsList(); c->Charset; c++, n++)
 				{
 					if (Id - IDM_CHARSET_BASE == n)
 					{
 						break;
 					}
 				}
 				if (c->Charset)
 				{
 					SetBodyCharset((char*)c->Charset);
 					SetDirty();
 					if (GetBodyCharset() && Ui)
 					{
 						Ui->OnLoad();
 					}
 				}
 			}
 			else if (Id >= IDM_FILTER_BASE)
 			{
 				Filter *Action = Actions[Id-IDM_FILTER_BASE];
 				if (Action)
 				{
 					// Save the message...
 					SetDirty(false);
 
 					// Hide the mail window...
 					if (Ui) Ui->Visible(false);
 
 					// Do the action
 					bool Stop;
 					Mail *This = this;
 					Action->DoActions(This, Stop);
 					if (This != this)
 						break;
 
 					if (Ui) DeleteObj(Ui);
 
 					return true;
 				}
 			}
 			break;
 		}
 		#ifdef _DEBUG
 		case IDM_CONVERT_BIN_TO_B64:
 		{
 			char *t = View->GetSelection();
 			if (t)
 			{
 				size_t In = strlen(t);
 				size_t Len = BufferLen_BinTo64(In);
 				char *B64 = new char[Len+1];
 				if (B64)
 				{
 					ConvertBinaryToBase64(B64, Len, (uchar*)t, In);
 					B64[Len] = 0;
 
 					char Temp[256];
 					ConvertBase64ToBinary((uchar*)Temp, sizeof(Temp), B64, Len);
 
 					char16 *Str = Utf8ToWide(B64);
 					if (Str)
 					{
 						LTextView3 *Tv = dynamic_cast<LTextView3*>(View);
 						if (Tv)
 						{
 							Tv->DeleteSelection();
 							Tv->Insert(Tv->GetCaret(), Str, Len);
 						}
 						DeleteArray(Str);
 					}
 					DeleteArray(B64);
 				}
 			}
 			break;
 		}
 		case IDM_CONVERT_B64_TO_BIN:
 		{
 			char *t = View->GetSelection();
 			if (t)
 			{
 				size_t In = strlen(t);
 				size_t Len = BufferLen_64ToBin(In);
 				char *Bin = new char[Len+1];
 				if (Bin)
 				{
 					ssize_t Out = ConvertBase64ToBinary((uchar*)Bin, Len, t, In);
 					Bin[Out] = 0;
 
 					char16 *Str = Utf8ToWide(Bin, Out);
 					if (Str)
 					{
 						LTextView3 *Tv = dynamic_cast<LTextView3*>(View);
 						if (Tv)
 						{
 							Tv->DeleteSelection();
 							Tv->Insert(Tv->GetCaret(), Str, Out);
 						}
 						DeleteArray(Str);
 					}
 					DeleteArray(Bin);
 				}
 			}
 			break;
 		}
 		#endif
 	}
 
 	if (RemoveStr)
 	{
 		size_t TokenLen = strlen(RemoveStr);
 		auto s = View ? View->Name() : 0;
 		if (s)
 		{
 			LMemQueue Temp;
 			auto Start = s;
 			const char *End;
 
 			while (*Start)
 			{
 				// seek to EOL
 				for (End = Start; *End && *End != '\n'; End++);
 				End++;
 				ssize_t Len = End - Start;
 
 				if (_strnicmp(Start, RemoveStr, TokenLen) == 0)
 				{
 					Temp.Write((uchar*)Start + TokenLen, Len - TokenLen);
 				}
 				else
 				{
 					Temp.Write((uchar*)Start, Len);
 				}
 
 
 				Start = End;
 			}
 
 			int Size = (int)Temp.GetSize();
 			char *Buf = new char[Size+1];
 			if (Buf)
 			{
 				Temp.Read((uchar*) Buf, Size);
 				Buf[Size] = 0;
 				View->Name(Buf);
 				DeleteArray(Buf);
 			}
 
 		}
 	}
 
 	return true;
 }
 
 LDocumentEnv::LoadType Mail::GetContent(LoadJob *&j)
 {
 	if (!j)
 		return LoadError;
 
 	LUri Uri(j->Uri);
 	if
 	(
 		Uri.sProtocol &&
 		(
 			!_stricmp(Uri.sProtocol, "http") ||
 			!_stricmp(Uri.sProtocol, "https") ||
 			!_stricmp(Uri.sProtocol, "ftp")
 		)
 	)
 	{
 		// We don't check OPT_HtmlLoadImages here because it's done elsewhere:
 		// - ScribeWnd::CreateTextControl calls LHtml::SetLoadImages with the value from OPT_HtmlLoadImages
 		// - LTag::LoadImage checks LHtml::GetLoadImages
 		//
 		// If there is a remote job here, it's because it's probably whitelisted.			
 		if (!Worker)		
 			Worker = App->GetImageLoader();
 		if (!Worker)
 			return LoadError;
 
 		Worker->AddJob(j);
 		j = 0;
 		return LoadDeferred;
 	}
 	else if (Uri.sProtocol && !_stricmp(Uri.sProtocol, "file"))
 	{
 		if (!_strnicmp(Uri.sPath, "//", 2))
 		{
 			// This seems to hang the windows CreateFile function...
 		}
 		else
 		{
 			// Is it a local file then?
 			if (j->pDC.Reset(GdcD->Load(Uri.sPath)))
 			{
 				return LoadImmediate;
 			}
 		}
 	}
 	else
 	{
 		List<Attachment> Files;
 		if (GetAttachments(&Files))
 		{
 			auto Dir = FilePart(j->Uri);
 			
 			Attachment *a = NULL;
 			for (auto It = Files.begin(); It != Files.end(); It++)
 			{
 				a = *It;
 
 				if (_strnicmp(j->Uri, "cid:", 4) == 0)
 				{
 					char *ContentId = j->Uri + 4;
 					auto AttachmentId = a->GetContentId();
 					if (AttachmentId)
 					{
 						if (AttachmentId[0] == '<')
 						{
 							auto s = AttachmentId + 1;
 							auto e = strrchr(s, '>');
 							if (e)
 							{
 								ssize_t len = e - s;
 								if (strlen(ContentId) == len &&
 									!strncmp(s, ContentId, len))
 									break;
 							}
 						}
 						else if (!strcmp(AttachmentId, ContentId))
 						{
 							break;
 						}
 					}
 				}
 				else
 				{
 					auto Name = a->GetName();
 					if (Name)
 					{
 						auto NameDir = FilePart(Name);
 						if (_stricmp(NameDir, Dir) == 0)
 						{
 							break;
 						}
 					}
 				}
 			}
 
 			if (a)
 			{
 				j->MimeType = a->GetMimeType();
 				j->ContentId = a->GetContentId();
 
 				if (j->Pref == LoadJob::FmtStream)
 				{
 					j->Filename = a->GetName();
 					j->Stream = a->GetObject()->GetStream(_FL);
 					return LoadImmediate;
 				}
 				else
 				{
 					char *Tmp = ScribeTempPath();
 					if (Tmp)
 					{
 						auto File = a->GetName();
 						auto Ext = LGetExtension(File);
 						char s[MAX_PATH_LEN] = "";
 						LString part;
 						do
 						{
 							if (part.Printf("%x.%s", LRand(), Ext) < 0)
 								return LoadError;
 							if (!LMakePath(s, sizeof(s), Tmp, part))
 								return LoadError;
 						}
 						while (LFileExists(s));
 
 						if (a->SaveTo(s, true))
 						{
 							if (j->Pref == LoadJob::FmtFilename)
 							{
 								j->Filename = s;
 								return LoadImmediate;
 							}
 							else
 							{
 								int Promote = GdcD->SetOption(GDC_PROMOTE_ON_LOAD, 0);
 								j->pDC.Reset(GdcD->Load(s));
 								j->Filename = a->GetName();
 								GdcD->SetOption(GDC_PROMOTE_ON_LOAD, Promote);
 								FileDev->Delete(s, false);
 								return LoadImmediate;
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	return LoadError;
 }
 
 class MailCapabilities : public LLayout
 {
     LArray<LAutoString> MissingCaps;
     LDocView *Doc;
     LButton *Install;
 
 public:
     MailCapabilities(LDocView *d)
     {
         Doc = d;
         Install = 0;
     }
     
 	const char *GetClass() { return "MailCapabilities"; }
 	
     void OnPosChange()
     {
         LRect c = GetClient();
         if (MissingCaps.Length())
         {
             if (!Install)
             {
                 if ((Install = new LButton(IDOK, 0, 0, -1, -1, "Install")))
                     Install->Attach(this);
             }
             
             LRect r = c;
             r.x1 = r.x2 - Install->X();
             r.y2 -= 7;
             Install->SetPos(r);
         }
     }
     
     void OnPaint(LSurface *pDC)
     {
         LRect cli = GetClient();
         if (MissingCaps.Length())
         {
             char Msg[256];
             int c = sprintf_s(Msg, sizeof(Msg), "This content requires ");
             for (unsigned i=0; i<MissingCaps.Length(); i++)
                 c += sprintf_s(Msg+c, sizeof(Msg)-c, "%s%s", i ? ", " : "", MissingCaps[i].Get());
             c += sprintf_s(Msg+c, sizeof(Msg)-c, " to display correctly");
             
             LDisplayString ds(LSysFont, Msg);
             LSysFont->Transparent(false);
             LSysFont->Colour(L_TEXT, L_MED);
             ds.Draw(pDC, cli.x1, cli.y1, &cli);
         }
         else
         {
             pDC->Colour(L_MED);
             pDC->Rectangle();
         }
     }
 };
 
 LDocView *Mail::CreateView(	MailViewOwner *Owner,
 							LString MimeType,
 							bool Sunken,
 							size_t MaxBytes,
 							bool NoEdit)
 {
 	bool Created = TestFlag(GetFlags(), MAIL_CREATED);
 	bool Edit = NoEdit ? false : Created;
 	bool ReadOnly = !Created;
-	LAutoString Mem;
+	bool DisabledLook = false;
+	LString TextMem;
 	LVariant DefAlt;
 	App->GetOptions()->GetValue(OPT_DefaultAlternative, DefAlt);
 
 	auto TextBody = GetBody();
 	auto TextCharset = GetBodyCharset();
 	
 	auto HtmlBody = GetHtml();
 	auto HtmlCharset = GetHtmlCharset();
 
 	const char *CtrlType = NULL;
 
 	if (!MimeType)
 	{
 		bool TextValid = TextBody != NULL;
 		bool HtmlValid = HtmlBody != NULL;
 
 		if (TextValid && HtmlValid)
 			MimeType = DefAlt.CastInt32() ? sTextHtml : sTextPlain;
 		else if (TextValid)
 			MimeType = sTextPlain;
 		else if (HtmlValid)
 			MimeType = sTextHtml;
 		else
-			return NULL;
+		{
+			auto rootSeg = GetObject()->GetObj(FIELD_MIME_SEG);
+			if (rootSeg)
+				MimeType = rootSeg->GetStr(FIELD_MIME_TYPE);
+			if (!MimeType)
+				return NULL;
+
+			// This is the 'multipart/encrypted' case here...
+			TextMem.Printf("'%s' content.", MimeType.Get());
+			TextBody = TextMem;
+			DisabledLook = ReadOnly = true;
+		}
 	}
 	
 	#ifdef WINDOWS
 	if (DefAlt.CastInt32() == 2 && MimeType == sTextHtml)
 		CtrlType = sApplicationInternetExplorer;
 	else
 	#endif
 		CtrlType = MimeType;
 
 	const char *Content, *Charset;
 	if (MimeType == sTextHtml)
 	{
 		Content = HtmlBody;
 		Charset = HtmlCharset;
 	}
 	else
 	{
 		Content = TextBody;
 		Charset = TextCharset;
 	}
 
 	// Emoji check
 	LVariant NoEmoji;
 	App->GetOptions()->GetValue(OPT_NoEmoji, NoEmoji);
 
 	// Check if the control needs changing
 	LDocView *View = Owner->GetDoc(MimeType);
 	if (View)
 	{
 		const char *ViewMimeType = View->GetMimeType();
 		if (MimeType != ViewMimeType)
 		{
 			Owner->SetDoc(NULL, ViewMimeType);
 			View = NULL;
 		}
 	}
 
 	if (!View)
 	{
 		View = App->CreateTextControl(	MimeType == sTextHtml ? IDC_HTML_VIEW : IDC_TEXT_VIEW,
 										MimeType,
 										Edit,
 										this);
 	}
 
-	if (View)
-	{
-		// Control setup
-		View->Sunken(Sunken);
-		View->SetReadOnly(ReadOnly);
-		View->SetEnv(this);
+	if (!View)
+		return NULL;
+
+	// Control setup
+	View->Sunken(Sunken);
+	View->SetReadOnly(ReadOnly);
+	View->SetEnv(this);
+
+	if (DisabledLook)
+	{
+		View->GetCss(true)->BackgroundColor(L_MED);
+		View->GetCss()->Color(L_LOW);
+	}
+	else
+	{
+		View->GetCss(true)->BackgroundColor(LCss::ColorInherit);
+		View->GetCss()->Color(LCss::ColorInherit);
+	}
 		
-		LVariant UseCid = true;
-		View->SetValue(LDomPropToString(HtmlImagesLinkCid), UseCid);
+	LVariant UseCid = true;
+	View->SetValue(LDomPropToString(HtmlImagesLinkCid), UseCid);
 		
-		LVariant LoadImages;
-		App->GetOptions()->GetValue(OPT_HtmlLoadImages, LoadImages);
-		bool AppLoadImages = LoadImages.CastInt32() != 0;
-		bool MailLoadImages = TestFlag(GetFlags(), MAIL_SHOW_IMAGES);
-		const char *SenderAddr = GetFrom() ? GetFrom()->GetStr(FIELD_EMAIL) : NULL;
-		auto SenderStatus = App->RemoteContent_GetSenderStatus(SenderAddr);
+	LVariant LoadImages;
+	App->GetOptions()->GetValue(OPT_HtmlLoadImages, LoadImages);
+	bool AppLoadImages = LoadImages.CastInt32() != 0;
+	bool MailLoadImages = TestFlag(GetFlags(), MAIL_SHOW_IMAGES);
+	const char *SenderAddr = GetFrom() ? GetFrom()->GetStr(FIELD_EMAIL) : NULL;
+	auto SenderStatus = App->RemoteContent_GetSenderStatus(SenderAddr);
 		
-		View->SetLoadImages
+	View->SetLoadImages
+	(
+		SenderStatus != RemoteNeverLoad
+		&&
 		(
-			SenderStatus != RemoteNeverLoad
-			&&
-			(
-				AppLoadImages ||
-				MailLoadImages ||
-				SenderStatus == RemoteAlwaysLoad
-			)
-		);
-
-        // Attach control
-		Owner->SetDoc(View, MimeType);
-		LCharset *CsInfo = LGetCsInfo(Charset);
-
-		// Check for render scripts
-		LArray<LScriptCallback*> Renderers;
-		LString RenderMsg = "Rendering...";
-		if (App->GetScriptCallbacks(LRenderMail, Renderers))
-		{
-			for (auto r: Renderers)
-			{
-				LVirtualMachine Vm;
+			AppLoadImages ||
+			MailLoadImages ||
+			SenderStatus == RemoteAlwaysLoad
+		)
+	);
+
+    // Attach control
+	Owner->SetDoc(View, MimeType);
+	LCharset *CsInfo = LGetCsInfo(Charset);
+
+	// Check for render scripts
+	LArray<LScriptCallback*> Renderers;
+	LString RenderMsg = "Rendering...";
+	if (App->GetScriptCallbacks(LRenderMail, Renderers))
+	{
+		for (auto r: Renderers)
+		{
+			LVirtualMachine Vm;
 				
-				LScriptArguments Args(&Vm);
-				Args.New() = new LVariant(App);
-				Args.New() = new LVariant(this);
-				Args.New() = new LVariant((void*)NULL);
-				bool Status = App->ExecuteScriptCallback(*r, Args);
-				Args.DeleteObjects();
-				if (Status)
-				{
-					auto Ret = Args.GetReturn();
-					if (Ret->IsString() || Ret->CastInt32())
-					{
-						if (Ret->IsString())
-							RenderMsg = Ret->Str();
-						d->Renderer.Reset(new MailRendererScript(this, r));
-						break;
-					}
-				}
-			}
-		}
-
-		if (d->Renderer)
-		{
-			LString Nm;
-			if (MimeType.Equals(sTextHtml))
-				Nm.Printf("<html><body>%s</body></html>", RenderMsg.Get());
+			LScriptArguments Args(&Vm);
+			Args.New() = new LVariant(App);
+			Args.New() = new LVariant(this);
+			Args.New() = new LVariant((void*)NULL);
+			bool Status = App->ExecuteScriptCallback(*r, Args);
+			Args.DeleteObjects();
+			if (Status)
+			{
+				auto Ret = Args.GetReturn();
+				if (Ret->IsString() || Ret->CastInt32())
+				{
+					if (Ret->IsString())
+						RenderMsg = Ret->Str();
+					d->Renderer.Reset(new MailRendererScript(this, r));
+					break;
+				}
+			}
+		}
+	}
+
+	if (d->Renderer)
+	{
+		LString Nm;
+		if (MimeType.Equals(sTextHtml))
+			Nm.Printf("<html><body>%s</body></html>", RenderMsg.Get());
+		else
+			Nm = RenderMsg;
+		View->Name(Nm);
+	}
+	else
+	{
+		// Send the data to the control
+		size_t ContentLen = Content ? strlen(Content) : 0;
+		Html1::LHtml *Html = dynamic_cast<Html1::LHtml*>(View);
+		if (MimeType.Equals(sTextHtml))
+		{
+			if (CsInfo)
+			{
+				int OverideDocCharset = *Charset == '>' ? 1 : 0;
+				View->SetCharset(Charset + OverideDocCharset);
+				if (Html)
+					Html->SetOverideDocCharset(OverideDocCharset != 0);
+			}
 			else
-				Nm = RenderMsg;
-			View->Name(Nm);
+			{
+				View->SetCharset(0);
+				if (Html)
+					Html->SetOverideDocCharset(0);
+			}
+
+			View->Name(Content);
 		}
 		else
 		{
-			// Send the data to the control
-			size_t ContentLen = Content ? strlen(Content) : 0;
-			Html1::LHtml *Html = dynamic_cast<Html1::LHtml*>(View);
-			if (MimeType.Equals(sTextHtml))
-			{
-				if (CsInfo)
-				{
-					int OverideDocCharset = *Charset == '>' ? 1 : 0;
-					View->SetCharset(Charset + OverideDocCharset);
-					if (Html)
-						Html->SetOverideDocCharset(OverideDocCharset != 0);
-				}
-				else
-				{
-					View->SetCharset(0);
-					if (Html)
-						Html->SetOverideDocCharset(0);
-				}
-
-				View->Name(Content);
+			LAutoPtr<uint32_t,true> Utf32((uint32_t*)LNewConvertCp("utf-32",
+            														Content,
+            														Charset ? Charset : (char*)"utf-8",
+            														MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
+			if (Utf32)
+			{
+				int Len = 0;
+				while (Utf32[Len])
+					Len++;
+					
+				#if 0
+				LFile f;
+				if (f.Open("c:\\temp\\utf32.txt", O_WRITE))
+				{
+					uchar bom[4] = { 0xff, 0xfe, 0, 0 };
+					f.Write(bom, 4);
+					f.Write(Utf32, Len * sizeof(uint32));
+					f.Close();
+				}
+				#endif
+			}
+			
+			LAutoWString Wide;
+			Wide.Reset((char16*)LNewConvertCp(LGI_WideCharset,
+												Content,
+												Charset ? Charset : (char*)"utf-8",
+												MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
+			if (Wide)
+			{
+				View->NameW(Wide);
 			}
 			else
 			{
-				LAutoPtr<uint32_t,true> Utf32((uint32_t*)LNewConvertCp("utf-32",
-            															Content,
-            															Charset ? Charset : (char*)"utf-8",
-            															MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
-				if (Utf32)
-				{
-					int Len = 0;
-					while (Utf32[Len])
-						Len++;
-					
-					#if 0
-					LFile f;
-					if (f.Open("c:\\temp\\utf32.txt", O_WRITE))
+				// Fall back... try and show something at least
+				LAutoString t(NewStr(Content, MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
+				if (t)
+				{
+					uint8_t *i = (uint8_t*)t.Get();
+					while (*i)
 					{
-						uchar bom[4] = { 0xff, 0xfe, 0, 0 };
-						f.Write(bom, 4);
-						f.Write(Utf32, Len * sizeof(uint32));
-						f.Close();
+						if (*i & 0x80)
+							*i &= 0x7f;
+						i++;
 					}
-					#endif
-				}
-			
-				LAutoWString Wide;
-				Wide.Reset((char16*)LNewConvertCp(LGI_WideCharset,
-													Content,
-													Charset ? Charset : (char*)"utf-8",
-													MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
-				if (Wide)
-				{
-					View->NameW(Wide);
+					
+					View->Name(t);
 				}
 				else
-				{
-					// Fallback... try and show something at least
-					LAutoString t(NewStr(Content, MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
-					if (t)
-					{
-						uint8_t *i = (uint8_t*)t.Get();
-						while (*i)
-						{
-							if (*i & 0x80)
-								*i &= 0x7f;
-							i++;
-						}
-					
-						View->Name(t);
-					}
-					else
-						View->NameW(0);
-				}
-
-				View->SetFixedWidthFont(TestFlag(GetFlags(), MAIL_FIXED_WIDTH_FONT));
-			}
+					View->NameW(0);
+			}
+
+			View->SetFixedWidthFont(TestFlag(GetFlags(), MAIL_FIXED_WIDTH_FONT));
 		}
 	}
 
 	return View;
 }
 
 bool Mail::OnNavigate(LDocView *Parent, const char *Uri)
 {
 	if (Uri)
 	{
 		if
 		(
 			_strnicmp(Uri, "mailto:", 7) == 0
 			||
 			(
 				strchr(Uri, '@')
 				&&
 				!strchr(Uri, '/')
 			)
 		)
 		{
 			// Mail address
 			return App->CreateMail(0, Uri, 0) != 0;
 		}
 		else
 		{
 			return LDefaultDocumentEnv::OnNavigate(Parent, Uri);
 		}
 	}
 
 	return false;
 }
 
 void Mail::Update()
 {
 	TotalSizeCache = -1;
 	LListItem::Update();
 }
 
 LString::Array ParseIdList(const char *In)
 {
 	LString::Array result;
 
     if (!In)
         return result;
         
     while (*In && strchr(WhiteSpace, *In))
         In++;
 
     if (*In == '<')
     {
         // Standard msg-id list..
 	    for (auto s = In; s && *s; )
 	    {
 		    s = strchr(s, '<');
 		    if (!s)
 				break;
 		    while (*s == '<') s++;
 
             char *e = strchr(s, '>');
             if (e)
             {
 	            result.New().Set(s, e-s);
 	            s = e + 1;
             }
             else break;
 	    }
     }
     else
     {
         // Non compliant msg-id list...
         const char Delim[] = ", \t\r\n";
 	    for (auto s = In; s && *s; )
 	    {
 	        if (strchr(Delim, *s))
 	            s++;
 		    else
 		    {
 	            auto Start = s;
 
 	            while (*s && !strchr(Delim, *s))
 	                s++;
 	            
 				result.New().Set(Start, s - Start);
 		    }
 	    }
 	}
 
 	return result;
 }
 
 void Base36(char *Out, uint64 In)
 {
 	while (In)
 	{
 		int p = (int)(In % 36);
 		if (p < 10)
 		{
 			*Out++ = '0' + p;
 		}
 		else
 		{
 			*Out++ = 'A' + p - 10;
 		}
 		In /= 36;
 	}
 
 	*Out++ = 0;
 }
 
 void Mail::ClearCachedItems()
 {
 	TotalSizeCache = -1;
 	PreviewCacheX = -1;
 	PreviewCache.DeleteObjects();
 
 	Attachment *a;
 	int i = 0;
 	while ((a = Attachments[i]))
 	{
 		if (!a->DecRef())
 			i++;
 	}
 }
 
 void Mail::NewRecipient(char *Email, char *Name)
 {
 	LDataPropI *a = GetTo()->Create(GetObject()->GetStore());
 	if (a)
 	{
 		a->SetStr(FIELD_EMAIL, Email);
 		a->SetStr(FIELD_NAME, Name);
 		GetTo()->Insert(a);
 	}
 }
 
 void Mail::PrepSend()
 {
 	// Set flags and other data
 	SetDirty();
 
 	int OldFlags = GetFlags();
 	SetFlags((OldFlags | MAIL_READY_TO_SEND) & ~MAIL_SENT); // we want to send now...
 
 	// Check we're in the Outbox
 	ScribeFolder *OutBox = App->GetFolder(FOLDER_OUTBOX, GetObject());
 	if (OutBox)
 	{
 		ScribeFolder *f = GetFolder();
 		if (!f || f != OutBox)
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			OutBox->MoveTo(Items, false);
 		}
 	}
 }
 
 bool Mail::Send(bool Now)
 {
 	// Check for any "on before send" callbacks:
 	bool AllowSend = true;
 	LArray<LScriptCallback*> Callbacks;
 	if (App->GetScriptCallbacks(LMailOnBeforeSend, Callbacks))
 	{
 		for (unsigned i=0; AllowSend && i<Callbacks.Length(); i++)
 		{
 			LScriptCallback &c = *Callbacks[i];
 			if (c.Func)
 			{
 				LVirtualMachine Vm;
 				
 				LScriptArguments Args(&Vm);
 				Args.New() = new LVariant(App);
 				Args.New() = new LVariant(this);
 				if (App->ExecuteScriptCallback(c, Args))
 				{
 					if (!Args.GetReturn()->CastInt32())
 						AllowSend = false;
 				}
 
 				Args.DeleteObjects();
 			}
 		}
 	}
 	
 	if (!AllowSend)
 		return false;
 
 	// Set the ready to send flag..
 	bool IsInPublicFolder = GetFolder() && GetFolder()->IsPublicFolders();
 	if (!IsInPublicFolder)
 	{
 		PrepSend();
 
 		if (Now)
 		{
 			// Kick off send thread if relevant
 			LVariant Offline;
 			App->GetOptions()->GetValue(OPT_WorkOffline, Offline);
 			if (!Offline.CastInt32() && !IsInPublicFolder)
 			{
 				App->PostEvent(M_COMMAND, IDM_SEND_MAIL, (LMessage::Param)Handle());
 			}
 		}
 	}
 
 	return true;
 }
 
 bool Mail::MailMessageIdMap(bool Add)
 {
     if (Add)
     {
 		auto LoadState = GetLoaded();
 		if (LoadState < Store3Headers)
 		{
 			LAssert(!"Not loaded yet.");
 			LStackTrace("MailMessageIdMap msg not loaded yet: %i\n", LoadState);
 			return false;
 		}
 
 		// char *ObjId = GetObject()->GetStr(FIELD_MESSAGE_ID);
 		auto Id = GetMessageId(true);
 		if (!Id)
 		{
 			LAssert(!"No message ID? Impossible!");
 			GetMessageId(true);
 			return false;
 		}
 
 		#if 0
 		LgiTrace("MailMessageIdMap(%i) Old=%s Id=%s Mail=%p\n", Add, ObjId, Id, this);
 		#endif
 		return MessageIdMap.Add(Id, this);
     }
     else
     {
         auto Id = GetMessageId();
     	#if 0
         LgiTrace("MailMessageIdMap(%i) Id=%s Mail=%p\n", Add, Id, this);
         #endif
         return MessageIdMap.Delete(Id);
     }
 }
 
 Mail *Mail::GetMailFromId(const char *Id)
 {
     Mail *m = MessageIdMap.Find(Id);
     // LgiTrace("GetMailFromId(%s)=%p\n", Id, m);
     return m;
 }
 
 bool Mail::SetMessageId(const char *MsgId)
 {
 	if (LAppInst->InThread())
 	{
         LAssert(GetObject() != NULL);
         
         auto OldId = GetObject()->GetStr(FIELD_MESSAGE_ID);
 		if (OldId)
 		    MessageIdMap.Delete(OldId);
 
 		LAutoString m(NewStr(MsgId));
 		LAutoString s(TrimStr(m, "<>"));
 		if (GetObject()->SetStr(FIELD_MESSAGE_ID, s))
 			SetDirty();
 			
 		return s != 0;
 	}
 	else
 	{
 		// No no no NO NON NOT NADA.
 		LAssert(0);
 	}
 
 	return false;
 }
 
 LAutoString Mail::GetThreadIndex(int TruncateChars)
 {
     LAutoString Id;
     LAutoString Raw(InetGetHeaderField(GetInternetHeader(), "Thread-Index"));
     if (Raw)
     {
         Id = ConvertThreadIndex(Raw, TruncateChars);
     }
     
     return Id;
 }
 
 const char *Mail::GetMessageId(bool Create)
 {
     LAssert(GetObject() != NULL);
  	
  	d->MsgIdCache = GetObject()->GetStr(FIELD_MESSAGE_ID);
  	if (!d->MsgIdCache)
 	{
 		bool InThread = GetCurrentThreadId() == LAppInst->GetGuiThreadId();
 
 		LAutoString Header(InetGetHeaderField(GetInternetHeader(), "Message-ID"));
 		if (Header)
 		{
 			LAssert(InThread);
 			if (InThread)
 			{
 				auto Ids = ParseIdList(Header);
 				SetMessageId(d->MsgIdCache = Ids[0]);
 			}
 		}
 
 		if (!d->MsgIdCache && Create)
 		{
 			LAssert(InThread);
 			
 			if (InThread)
 			{
 				auto FromEmail = GetFromStr(FIELD_EMAIL);
 				const char *At = FromEmail ? strchr(FromEmail, '@') : 0;
 				LVariant Email;
 				if (!At)
 				{
 					if (App->GetOptions()->GetValue(OPT_Email, Email) && Email.Str())
 					{
 						At = strchr(Email.Str(), '@');
 					}
 					else
 					{
 						At = "@domain.com";
 					}
 				}
 				
 				if (At)
 				{
 					char m[96], a[32], b[32];
 					Base36(a, LCurrentTime());
 					Base36(b, LRand(RAND_MAX));
 					sprintf_s(m, sizeof(m), "<%s.%i%s%s>", a, LRand(RAND_MAX), b, At);
 					if (GetObject()->SetStr(FIELD_MESSAGE_ID, m))
 						SetDirty();
 					
 				 	d->MsgIdCache = GetObject()->GetStr(FIELD_MESSAGE_ID);
 				}
 				else LgiTrace("%s:%i - Error, no '@' in %s.\n", _FL, FromEmail);
 			}
 			else LgiTrace("%s:%i - Error, not in thread.\n", _FL);
 		}
 	}
 	else
 	{
 		d->MsgIdCache = d->MsgIdCache.Strip("<>").Strip();
 	}
 
 	LAssert
 	(
 		(!d->MsgIdCache && !Create)
 		||
 		(d->MsgIdCache && !strchr(d->MsgIdCache, '\n'))
 	);
 
 	return d->MsgIdCache;
 }
 
 bool Mail::GetReferences(LString::Array &Ids)
 {
 	LAutoString References(InetGetHeaderField(GetInternetHeader(), "References"));
 	if (References)
 	{
 		Ids = ParseIdList(References);
 	}
 
 	LAutoString InReplyTo(InetGetHeaderField(GetInternetHeader(), "In-Reply-To"));
 	if (InReplyTo)
 	{
 		auto To = ParseIdList(InReplyTo);
 		
 		bool Has = false;
 		auto &r = To[0];
 		if (r)
 		{
 		    for (auto h: Ids)
 		    {
 		        if (!strcmp(h, r))
 		            Has = true;
 		    }
     		
 		    if (!Has)
 		    {
 			    To.Delete(r);
 			    Ids.New() = r;
 		    }
 		}
 		
 		To.DeleteArrays();
 	}
 	
 	if (Ids.Length() == 0)
 	{
 	    LAutoString Id = GetThreadIndex(5);
         if (Id)
         {
             size_t Len = strlen(Id);
             size_t Bytes = Len >> 1;
             if (Bytes >= 22)
             {
                 Ids.New() = Id.Get();
             }
         }
 	}
 	
 	return Ids.Length() > 0;
 }
 
 LString AddrToHtml(LDataPropI *a)
 {
 	LString s;
 	if (a)
 	{
 		auto Name = a->GetStr(FIELD_NAME);
 		auto Addr = a->GetStr(FIELD_EMAIL);
 		LXmlTree t;
 		LAutoString eName(t.EncodeEntities(Name));
 		LAutoString eAddr(t.EncodeEntities(Addr));
 
 		if (Name && Addr)
 			s.Printf("<a href=\"mailto:%s\">%s</a>", eAddr.Get(), eName.Get());
 		else if (Name)
 			s = eName.Get();
 		else if (Addr)
 			s.Printf("<a href=\"mailto:%s\">%s</a>", eAddr.Get(), eAddr.Get());
 	}
 
 	return s;
 }
 
 LDataPropI *FindMimeSeg(LDataPropI *s, char *Type)
 {
 	if (!s)
 		return 0;
 
 	const char *Mt = s->GetStr(FIELD_MIME_TYPE);
 	if (!Mt) Mt = "text/plain";
 	if (!_stricmp(Type, Mt))
 		return s;
 
 	LDataIt c = s->GetList(FIELD_MIME_SEG);
 	if (!c)
 		return 0;
 
 	for (LDataPropI *i=c->First(); i; i=c->Next())
 	{
 		LDataPropI *Child = FindMimeSeg(i, Type);
 		if (Child)
 			return Child;
 	}
 
 	return 0;
 }
 
 bool Mail::GetAttachmentObjs(LArray<LDataI*> &Objs)
 {
 	if (!GetObject())
 		return false;
 
 	CollectAttachments(&Objs, NULL, NULL, NULL, GetObject()->GetObj(FIELD_MIME_SEG));
 	return Objs.Length() > 0;
 }
 
 void DescribeMime(LStream &p, LDataI *Seg)
 {
 	auto Mt = Seg->GetStr(FIELD_MIME_TYPE);
 	p.Print("%s", Mt);
 	auto Cs = Seg->GetStr(FIELD_CHARSET);
 	if (Cs) p.Print("&nbsp;-&nbsp;%s", Cs);
 	p.Print("<br>\n");
 
 	LDataIt c = Seg->GetList(FIELD_MIME_SEG);
 	if (c && c->First())
 	{
 		p.Print("<div style='padding-left:1em;'>\n");
 		for (LDataPropI *i=c->First(); i; i=c->Next())
 		{
 			LDataI *a = dynamic_cast<LDataI*>(i);
 			if (a)
 				DescribeMime(p, a);
 		}
 		p.Print("</div>\n");
 	}
 }
 
 bool Mail::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdFrom: // Type: ListAddr
 		{
 			Value = GetFrom();
 			break;
 		}
 		case SdFromHtml: // Type: String
 		{
 			LString s = AddrToHtml(GetFrom());
 			if (s.Length() == 0)
 				return false;
 			Value = s;
 			break;
 		}
 		case SdContact: // Type: Contact
 		{
 			if (!GetFrom())
 				return false;
 
 			auto Addr = GetFrom()->GetStr(FIELD_EMAIL);
 			if (!Addr)
 				return false;
 			
 			Contact *c = Contact::LookupEmail(Addr);
 			if (!c)
 				return App->GetVariant("NoContact", Value);
 
 			Value = (LDom*)c;
 			break;
 		}
 		case SdTo: // Type: ListAddr[]
 		{
 			if (Array)
 			{
 				LDataIt To = GetTo();
 
 				int Idx = atoi(Array);
 				bool Create = false;
 				if (Idx < 0)			
 				{
 					Create = true;
 					Idx = -Idx;
 				}
 
 				LDataPropI *a = Idx < (int)To->Length() ? (*To)[Idx] : 0;
 				if (!a && Create)
 				{
 					if ((a = To->Create(GetObject()->GetStore())))
 					{
 						To->Insert(a);
 					}
 				}
 
 				Value = a;
 			}
 			else if (Value.SetList())
 			{
 				LDataIt To = GetTo();
 				for (LDataPropI *a=To->First(); a; a=To->Next())
 				{
 					LVariant *Recip = new LVariant;
 					if (Recip)
 					{
 						*Recip = a;
 						Value.Value.Lst->Insert(Recip);
 					}
 				}
 			}
 			else return false;
 			break;
 		}
 		case SdToHtml: // Type: String
 		{
 			if (GetTo())
 			{
 				LStringPipe p;
 				for (LDataPropI *t=GetTo()->First(); t; t=GetTo()->Next())
 				{
 					if (p.GetSize())
 						p.Write((char*)", ", 2);
 					LString s = AddrToHtml(t); 
 					if (s)
 						p.Write(s, s.Length());
 				}
 				Value.Type = GV_STRING;
 				Value.Value.String = p.NewStr();
 			}
 			break;
 		}
 		case SdSubject: // Type: String
 		{
 			Value = GetSubject();
 			break;
 		}
 		case SdBody: // Type: String
 		{
 			if (Array)
 			{
 				auto Body = GetBody();
 				LAutoString h;
 
 				for (auto c = Body; c && *c; )
 				{
 					while (*c && strchr(WhiteSpace, *c)) c++;
 					auto Start = c;
 					while (*c && *c != ':' && *c != '\n') c++;
 					if (*c == ':')
 					{
 						if (Start[0] == '\"' && c[1] == '\"')
 							c++;
 
 						LString s(Start, c - Start);
 						s = s.Strip("\'\" \t[]<>{}:");
 						if (s.Equals(Array))
 						{
 							// Match...
 							c++;
 							while (*c && strchr(WhiteSpace, *c)) c++;
 							Start = c;
 							while (*c && *c != '\n') c++;
 							while (c > Start && strchr(WhiteSpace, c[-1])) c--;
 
 							h.Reset(NewStr(Start, c - Start));
 							break;
 						}
 						else
 						{
 							while (*c && *c != '\n')
 								c++;
 						}
 					}
 
 					if (*c == '\n')
 						c++;
 				}
 
 				if (h)
 				{
 					if (GetBodyCharset())
 					{
 						char *u = (char*)LNewConvertCp("utf-8", h, GetBodyCharset());
 						if (u)
 						{
 							Value.OwnStr(u);
 						}
 						else
 						{
 							Value.OwnStr(h.Release());
 						}
 					}
 					else
 					{
 						Value.OwnStr(h.Release());
 					}
 				}
 			}
 			else
 			{
 				Value = GetBody();
 			}
 			break;
 		}
 		case SdBodyAsText: // Type: String
 		{
 			size_t MaxSize = Atoi(Array);
 			auto Txt = GetBody();
 			auto Html = GetHtml();
 
 			if (ValidStr(Txt) && ValidStr(Html))
 			{
 				LVariant Def;
 				App->GetOptions()->GetValue(OPT_DefaultAlternative, Def);			
 				if (Def.CastInt32())
 				{
 					goto DoHtml;
 				}
 				goto DoText;
 			}
 			else if (ValidStr(Txt))
 			{
 				DoText:
 				LAutoString CharSet = GetCharSet();
 				if (CharSet)
 				{
 					size_t TxtLen = strlen(Txt);
 					Value.OwnStr((char*)LNewConvertCp("utf-8", Txt, CharSet, MIN(TxtLen, MaxSize)));
 				}
 				else
 					Value = Txt;
 			}
 			else if (ValidStr(Html))
 			{
 				DoHtml:
 				auto cs = GetHtmlCharset();
 				auto v = HtmlToText(Html, cs);
 				Value = v.Get();
 			}
 			else return false;
 			break;
 		}
 		case SdBodyAsHtml: // Type: String
 		{
 			// int MaxSize = ValidStr(Array) ? atoi(Array) : -1;
 
 			MailPrivate::HtmlBody *b = d->GetBody();
 			if (!b)
 				return false;
 			
 			LStringPipe p;
 			p.Print("<div class='%s'>\n%s\n</div>\n", ScribeReplyClass, b->Html.Get());
 			Value.OwnStr(p.NewStr());
 			LgiTrace("Value=%s\n", Value.Str());
 			break;
 		}
 		case SdHtmlHeadFields: // Type: String
 		{
 			MailPrivate::HtmlBody *b = d->GetBody();
 			if (!b)
 				return false;
 			
 			LStringPipe p;
 			if (ValidStr(b->Charset))
 				p.Print("\t<meta charset=\"%s\">\n", b->Charset.Get());
 
 			p.Print("\t<style>\n");
 			if (ValidStr(b->Styles))
 			{
 				// rewrite the style rules to change 'body' to 'div.scribe_reply'.
 				// Otherwise the source document's styles spill over into the edit
 				// section of the reply
 				const char *s = b->Styles;
 				LCss::Store Store;
 				if (Store.Parse(s))
 				{
 					LCss::SelArray *Body = Store.TypeMap.Find("body");
 					if (Body)
 					{
 						for (unsigned i=0; i<Body->Length(); i++)
 						{
 							LCss::Selector *Sel = (*Body)[i];
 							if (Sel)
 							{
 								for (unsigned p=0; p<Sel->Parts.Length(); p++)
 								{
 									LCss::Selector::Part &Part = Sel->Parts[p];
 									const char *sBody = "body";
 									if (Part.Type == LCss::Selector::SelType &&
 										Part.Value &&
 										!_stricmp(Part.Value, sBody))
 									{
 										Part.Value.Reset(NewStr("div"));
 										
 										LCss::Selector::Part cls;
 										cls.Type = LCss::Selector::SelClass;
 										cls.Value.Reset(NewStr(ScribeReplyClass));
 										Sel->Parts.AddAt(p + 1, cls);
 										break;
 									}
 								}
 							}
 						}
 					}
 					
 					// Output modified styles to the string buffer
 					Store.ToString(p);
 				}
 			}
 			
 			// Add our own styles at the end, overwriting source doc styles...
 			p.Print("\tdiv.%s { %s }\n",
 					ScribeReplyClass,
 					ScribeReplyStyles);
 					
 			p.Print("\t</style>");
 		
 			Value.OwnStr(p.NewStr());
 			break;
 		}
 		case SdMessageId: // Type: String
 		{
 			Value = GetMessageId();
 			return true;
 		}
 		case SdInternetHeaders: // Type: String
 		{
 			Value = GetInternetHeader();
 			break;
 		}
 		case SdInternetHeader: // Type: String[]
 		{
 			if (!Array || !GetInternetHeader())
 				return false;
 
 			LAutoString s(InetGetHeaderField(GetInternetHeader(), Array));
 			if (s)
 				Value = s;
 			else
 				Value.Empty();
 			break;
 		}
 		case SdPriority: // Type: Int32
 		{
 			Value = (int)GetPriority();
 			break;
 		}
 		case SdHtml: // Type: String
 		{
 			Value = GetHtml();
 			break;
 		}
 		case SdFlags: // Type: Int32
 		{
 			if (Array)
 			{
 				int Flag = StringToMailFlag(Array);
 				Value = (GetFlags() & Flag) != 0;
 			}
 			else
 			{
 				Value = (int)GetFlags();
 			}
 			break;
 		}
 		case SdFolder: // Type: ScribeFolder
 		{
 			ScribeFolder *f = GetFolder();
 			if (!f)
 				return false;
 			Value = (LDom*)f;
 			break;
 		}
 		case SdScribe: // Type: ScribeWnd
 		{
 			Value = (LDom*)App;
 			break;
 		}
 		case SdMail: // Type: Mail
 		{
 			Value = PreviousMail;
 			break;
 		}
 		case SdDateSent: // Type: DateTime
 		{
 			Value = GetDateSent();
 			break;
 		}
 		case SdDateReceived: // Type: DateTime
 		{
 			Value = GetDateReceived();
 			break;
 		}
 		case SdSig: // Type: String
 		{
 			bool Type = false;
 			if (Array && stristr(Array, "html"))
 				Type = true;
 			Value = GetSig(Type);
 			break;
 		}
 		case SdSize: // Type: Int64
 		{
 			Value = TotalSizeof();
 			break;
 		}
 		case SdLabel: // Type: String
 		{
 			Value = GetLabel();
 			break;
 		}
 		case SdAttachments: // Type: Int32
 		{
 			LArray<LDataI*> Lst;
 			GetAttachmentObjs(Lst);
 			Value = (int)Lst.Length();
 			break;
 		}
 		case SdAttachment: // Type: Attachment[]
 		{
 			List<Attachment> Files;
 			if (GetAttachments(&Files) && Array)
 			{
 				int i = atoi(Array);
 				Value = Files[i];
 				if (Value.Type == GV_DOM)
 					return true;
 			}
 			
 			LAssert(!"Not a valid attachment?");
 			return false;
 		}
 		case SdMimeTree: // Type: String
 		{
 			LDataI *Root = dynamic_cast<LDataI*>(GetObject()->GetObj(FIELD_MIME_SEG));
 			if (!Root)
 				return false;
 			
 			LStringPipe p(256);
 			DescribeMime(p, Root);
 			Value.OwnStr(p.NewStr());
 			break;
 		}
 		case SdUi: // Type: LView
 		{
 			Value = Ui;
 			break;
 		}
 		case SdType: // Type: Int32
 		{
 			Value = GetObject()->Type();
 			break;
 		}
 		case SdSelected: // Type: Bool
 		{
 			Value = Select();
 			break;
 		}
 		case SdRead: // Type: Bool
 		{
 			Value = (GetFlags() & MAIL_READ) != 0;
 			break;
 		}
 		case SdShowImages: // Type: Bool
 		{
 			Value = (GetFlags() & MAIL_SHOW_IMAGES) != 0;
 			break;
 		}
 		case SdColour: // Type: Int32
 		{
 			Value = GetMarkColour();
 			break;
 		}
 		case SdReceivedDomain: // Type: String
 		{
 			Value = GetFieldText(FIELD_RECEIVED_DOMAIN);
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 #define DomSetStr(Dom, Fld)							\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_STRING)		\
 			GetObject()->SetStr(Fld, Value.Str());		\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 #define DomSetInt(Dom, Fld)							\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_INT32)		\
 			GetObject()->SetInt(Fld, Value.Value.Int);	\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 #define DomSetDate(Dom, Fld)						\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_DATETIME)	\
 			GetObject()->SetDate(Fld, Value.Value.Date);	\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 bool Mail::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		DomSetStr(SdSubject, FIELD_SUBJECT)
 		DomSetStr(SdMessageId, FIELD_MESSAGE_ID)
 		DomSetStr(SdInternetHeaders, FIELD_INTERNET_HEADER)
 		DomSetInt(SdPriority, FIELD_PRIORITY)
 		DomSetDate(SdDateSent, FIELD_DATE_SENT)
 		DomSetDate(SdDateReceived, FIELD_DATE_RECEIVED)
 		case SdBody:
 		{
 			if (!SetBody(Value.Str()))
 				return false;
 			break;
 		}
 		case SdHtml:
 		{
 			if (!SetHtml(Value.Str()))
 				return false;
 			break;
 		}
 		case SdRead:
 		{
 			if (Value.CastInt32())
 				SetFlags(GetFlags() | MAIL_READ);
 			else
 				SetFlags(GetFlags() & ~MAIL_READ);
 			break;
 		}
 		case SdColour:
 		{
 			auto u32 = Value.IsNull() ? 0 : (uint32_t)Value.CastInt32();
 			if (!SetMarkColour(u32))
 				return false;
 			break;
 		}
 		case SdShowImages:
 		{
 			if (Value.CastInt32())
 				SetFlags(GetFlags() | MAIL_SHOW_IMAGES);
 			else
 				SetFlags(GetFlags() & ~MAIL_SHOW_IMAGES);
 			break;
 		}
 		case SdSelected:
 		{
 			Select(Value.CastInt32() != 0);
 			break;
 		}
 		case SdLabel:
 		{
 			if (!SetLabel(Value.Str()))
 				return false;
 			break;
 		}
 		case SdFlags:
 		{
 			if (Array)
 			{
 				int Flag = StringToMailFlag(Array);
 				if (Value.CastInt32())
 					// Set
 					SetFlags(GetFlags() | Flag);
 				else
 					SetFlags(GetFlags() & ~Flag);
 			}
 			else
 			{
 				SetFlags(Value.CastInt32());
 			}
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	SetDirty();
 	Update();
 	return true;
 }
 
 bool Mail::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType Fld = StrToDom(MethodName);
 	switch (Fld)
 	{
 		default:
 			break;
 		case SdSend: // Type: ([Bool SendNow = true])
 		{
 			bool Now = Args.Length() > 0 ? Args[0]->CastInt32() != 0 : true;
 			bool Result = Send(Now);
 			if (ReturnValue)
 				*ReturnValue = Result;
 			return true;
 		}
 		case SdAddCalendarEvent: // Type: ([Bool AddPopupReminder])
 		{
 			bool AddPopupReminder = Args.Length() > 0 ? Args[0]->CastInt32() != 0 : true;
 			bool Result = AddCalendarEvent(NULL, AddPopupReminder, NULL);
 			if (ReturnValue)
 				*ReturnValue = Result;
 			return true;
 		}
 		case SdGetRead: // Type: ()
 		{
 			*ReturnValue = (GetFlags() & MAIL_READ) != 0;
 			return true;
 		}
 		case SdSetRead: // Type: (Bool IsRead = true)
 		{
 			bool Rd = Args.Length() ? Args[0]->CastInt32() != 0 : true;
 			auto Flags = GetFlags();
 			if (Rd) SetFlags(Flags | MAIL_READ);
 			else SetFlags(Flags & ~MAIL_READ);
 			*ReturnValue = true;
 			return true;
 		}
 		case SdBayesianChange: // Type: (int SpamWordOffset, int HamWordOffset)
 		{
 			if (Args.Length() != 2)
 			{
 				LgiTrace("%s:%i - Invalid arg count, expecting (int SpamWordOffset, int HamWordOffset)\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto SpamWordOffset = Args[0]->CastInt32();
 			auto HamWordOffset = Args[1]->CastInt32();
 
 			if (SpamWordOffset > 1)
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailSpam);
 			else if (SpamWordOffset < 0)
 				App->OnBayesianMailEvent(this, BayesMailSpam, BayesMailUnknown);
 			
 			if (HamWordOffset > 1)
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailHam);
 			else if (HamWordOffset < 1)
 				App->OnBayesianMailEvent(this, BayesMailHam, BayesMailUnknown);
 			break;
 		}
 		case SdBayesianScore: // Type: ()
 		{
 			double Result;
 			if (App->IsSpam(Result, this))
 			{
 				*ReturnValue = Result;
 				return true;
 			}
 			break;
 		}
 		case SdSearchHtml: // Type: (String SearchExpression)
 		{
 			if (Args.Length() != 2)
 			{
 				LgiTrace("%s:%i - Method needs 1 argument.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto Html = GetHtml();
 			if (!Html)
 			{
 				LgiTrace("%s:%i - No HTML to parse.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 				
 			// auto Cs = GetHtmlCharset();
 			SearchHtml(ReturnValue, Html, Args[0]->Str(), Args[1]->Str());
 			return true;
 		}
 		case SdDeleteAsSpam: // Type: ()
 		{
 			DeleteAsSpam(App);
 			return true;
 		}
 	}
 	
 	return Thing::CallMethod(MethodName, ReturnValue, Args);
 }
 
 char *Mail::GetDropFileName()
 {
 	if (!DropFileName)
 	{
 		LString Subj = GetSubject();
 		Subj = Subj.Strip(" \t\r\n.");
 		DropFileName.Reset(MakeFileName(ValidStr(Subj) ? Subj.Get() : (char*)"Untitled", "eml"));
 	}
 	return DropFileName;
 }
 
 bool Mail::GetDropFiles(LString::Array &Files)
 {
 	if (!GetDropFileName())
 		return false;
 
 	if (!LFileExists(DropFileName))
 	{
 		LAutoPtr<LFile> F(new LFile);
 		if (F->Open(DropFileName, O_WRITE))
 		{
 			F->SetSize(0);
 			if (!Export(AutoCast(F), sMimeMessage))
 				return false;
 		}
 		else return false;
 	}
 
 	if (!LFileExists(DropFileName))
 		return false;
 
 	Files.Add(DropFileName.Get());
 	return true;
 }
 
 OsView Mail::Handle()
 {
 	return
 		#if LGI_VIEW_HANDLE
 		(Ui) ? Ui->Handle() :
 		#endif
 		NULL;
 }
 
 Thing &Mail::operator =(Thing &t)
 {
 	Mail *m = t.IsMail();
 	if (m)
 	{
 		#define CopyStr(dst, src) \
 			{ DeleteArray(dst); dst = NewStr(src); }
 			
 		/*
 		for (LDataPropI *a = m->GetTo()->First(); a; a = m->GetTo()->Next())
 		{
 			LDataPropI *NewA = GetTo()->Create(Object->GetStore());
 			if (NewA)
 			{
 				*NewA = *a;
 				GetTo()->Insert(NewA);
 			}
 		}
 		*/
 
 		if (GetObject() && m->GetObject())
 		{
 			GetObject()->CopyProps(*m->GetObject());
 		}
 		else LAssert(!"This shouldn't happen right?");
 
 		Update();
 	}
 
 	return *this;
 }
 
 bool Mail::HasAlternateHtml(Attachment **Attach)
 {
 	// New system of storing alternate HTML in a Mail object field.
 	if (GetHtml()) return true;
 
 	// Old way of storing alternate HTML, in an attachment.
 	// pre v1.53
 	List<Attachment> Files;
 	if (GetAttachments(&Files))
 	{
 		for (auto a: Files)
 		{
 			if ((_stricmp(a->GetText(0), "attachment.html") == 0 ||
 				_stricmp(a->GetText(0), "index.html") == 0) &&
 				(a->GetMimeType() ? _stricmp(a->GetMimeType(), "text/html") == 0 : 1))
 			{
 				if (Attach)
 				{
 					*Attach = a;
 				}
 
 				return true;
 			}
 		}
 	}
 
 	// None found
 	return false;
 }
 
 char *Mail::GetAlternateHtml(List<Attachment> *Refs)
 {
 	char *Status = 0;
 	Attachment *Attach = 0;
 	if (HasAlternateHtml(&Attach))
 	{
 		if (GetHtml())
 		{
 			// New system of storing alternate HTML in a Mail object field.
 			Status = NewStr(GetHtml());
 		}
 		else if (Attach)
 		{
 			// Old way of storing alternate HTML, in an attachment.
 			// pre v1.53
 			char *Ptr;
 			ssize_t Size;
 			if (Attach->Get(&Ptr, &Size))
 			{
 				Status = NewStr((char*)Ptr, Size);
 			}
 		}
 
 		if (Status && Refs)
 		{
 			// Turn all the cid: references into file names...
 			LStringPipe Out;
 			
 			char *n;
 			for (char *s=Status; *s; s=n)
 			{
 				n = stristr(s, "\"cid:");
 				if (n)
 				{
 					// Extract cid
 					n++;
 					Out.Push(s, n-s);
 					s = n += 4;
 					while (*n && !strchr("\"\' >", *n)) n++;
 					char *Cid = NewStr(s, n-s);
 					if (Cid)
 					{
 						// Find attachment
 						List<Attachment> Files;
 						if (GetAttachments(&Files))
 						{
 							for (auto a: Files)
 							{
 								if (a->GetContentId() &&
 									strcmp(a->GetContentId(), Cid) == 0)
 								{
 									Refs->Insert(a);
 									Out.Push(a->GetName());
 								}
 							}
 						}
 					}					
 				}
 				else
 				{
 					Out.Push(s);
 					break;
 				}
 			}
 
 			DeleteArray(Status);
 			Status = Out.NewStr();
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::WriteAlternateHtml(char *DstFile, int DstFileLen)
 {
 	bool Status = false;
 	char *Tmp = ScribeTempPath();
 
 	List<Attachment> Refs;
 	char *Html;
 	if (Tmp &&
 		(Html = GetAlternateHtml(&Refs)))
 	{
 		char FileName[256];
 
 		LMakePath(FileName, sizeof(FileName), Tmp, "Alt.html");
 		if (DstFile)
 		{
 			strcpy_s(DstFile, DstFileLen, FileName);
 		}
 
 		LFile f;
 		if (f.Open(FileName, O_WRITE))
 		{
 			size_t Len = strlen(Html);
 			Status = f.Write(Html, Len) == Len;
 			f.Close();
 		}
 
 		DeleteArray(Html);
 
 		for (auto a: Refs)
 		{
 			LMakePath(FileName, sizeof(FileName), Tmp, a->GetName());
 			FileDev->Delete(FileName, false);
 			a->SaveTo(FileName);
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::DeleteAttachment(Attachment *File)
 {
 	bool Status = false;
 	if (File)
 	{
 		if (Attachments.HasItem(File))
 		{
 			Attachments.Delete(File);
 			if (File->GetObject())
 			{
 				auto r = File->GetObject()->Delete();
 				if (r > Store3Error)
 				{
 					auto o = File->GetObject();
 					if (o->IsOrphan())
 						o = NULL; // SetObject will delete...
 					File->SetObject(NULL, false, _FL);
 					DeleteObj(o);
 				}
 			}
 
 			File->DecRef();
 			File = NULL;
 
 			if (Attachments.Length() == 0)
 			{
 				// Remove attachments flag
 				SetFlags(GetFlags() & (~MAIL_ATTACHMENTS));
 			}
 
 			Update();
 
 			if (Ui)
 			{
 				Ui->OnAttachmentsChange();
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::UnloadAttachments()
 {
 	for (auto it = Attachments.begin(); it != Attachments.end(); )
 	{
 		Attachment *a = *it;
 		if (!a->DecRef())
 			it++;
 	}
 
 	return true;
 }
 
 LArray<Attachment*> Mail::GetAttachments()
 {
 	LArray<Attachment*> result;
 
 	LArray<LDataI*> Lst;
 	if (GetAttachmentObjs(Lst))
 	{
 		LHashTbl<PtrKey<LDataI*>, bool> Loaded;
 		for (size_t i=0; i<Attachments.Length(); i++)
 		{
 			Loaded.Add(Attachments[i]->GetObject(), true);
 		}
 
 		// Load attachments
 		for (unsigned i=0; i<Lst.Length(); i++)
 		{
 			LDataI *Att = Lst[i];
 			if (!Loaded.Find(Att))
 			{
 				Attachment *k = new Attachment(App, Att);
 				if (k)
 				{
 					k->SetOwner(this);
 					Attachments.Insert(k);
 				}
 			}
 		}
 	}
 
 	for (auto a: Attachments)
 	{
 		if (a->GetObject()->UserData != a)
 			LAssert(!"Wut?");
 		else
 			result.Add(a);
 	}
 	
 	return result;
 }
 
 bool Mail::GetAttachments(List<Attachment> *Files)
 {
 	if (!Files)
 		return false;
 	auto files = GetAttachments();
 	for (auto a: files)
 		Files->Add(a);
 	return true;
 }
 
 int64 Mail::TotalSizeof()
 {
 	if (TotalSizeCache < 0)
 	{
 		int Size = GetObject() ? (int)GetObject()->GetInt(FIELD_SIZE) : -1;
 		if (Size >= 0)
 		{
 			TotalSizeCache = Size;
 		}
 		else
 		{
 			TotalSizeCache =	((GetBody()) ? strlen(GetBody()) : 0) +
 								((GetHtml()) ? strlen(GetHtml()) : 0);
 
 			List<Attachment> Attachments;
 			if (GetAttachments(&Attachments))
 			{
 				for (auto a: Attachments)
 				{
 					TotalSizeCache += a->GetSize();
 				}
 			}
 		}
 	}
 
 	return TotalSizeCache;
 }
 
 bool Mail::_GetListItems(List<LListItem> &l, bool All)
 {
 	LList *ParentList = LListItem::Parent;
 
 	l.Empty();
 
 	if (All)
 	{
 		if (ParentList)
 		{
 			ParentList->GetAll(l);
 		}
 		else
 		{
 			l.Insert(this);
 		}
 	}
 	else
 	{
 		if (ParentList)
 		{
 			ParentList->GetSelection(l);
 		}
 		else if (Select())
 		{
 			l.Insert(this);
 		}
 	}
 
 	return l.Length() > 0;
 }
 
 void Mail::GetThread(List<Mail> &Thread)
 {
 	MContainer *c;
 	for (c=Container; c->Parent; c=c->Parent);
 	List<MContainer> Stack;
 	Stack.Insert(c);
 	while ((c=Stack[0]))
 	{
 		Stack.Delete(c);
 		
 		for (unsigned i=0; i<c->Children.Length(); i++)
 		    Stack.Insert(c->Children[i]);
 		
 		if (c->Message && !Thread.HasItem(c->Message))
 		{
 			Thread.Insert(c->Message);
 		}
 	}
 }
 
 void Mail::SetListRead(bool Read)
 {
 	List<LListItem> Sel;
 	if (!_GetListItems(Sel, false))
 		return;
 
 	LArray<LDataI*> a;
 	for (auto t: Sel)
 	{
 		auto m = dynamic_cast<Mail*>(t);
 		if (!m)
 			continue;
 
 		bool isRead = (m->GetFlags() & MAIL_READ) != 0;
 		if (Read ^ isRead)
 			a.Add(m->GetObject());
 	}
 
 	if (!a.Length())
 		return;
 
 	auto Store = a[0]->GetStore();
 	if (!Store)
 	{
 		LAssert(0);
 		return;
 	}
 
 	LVariant read = MAIL_READ;
 	Store->Change(a, FIELD_FLAGS, read, Read ? OpPlusEquals : OpMinusEquals);
 }
 
 void SetFolderCallback(LInput *Dlg, LViewI *EditCtrl, void *Param)
 {
 	ScribeWnd *App = (ScribeWnd*) Param;
 	auto Str = EditCtrl->Name();
 	auto Select = new FolderDlg(Dlg, App, MAGIC_MAIL, 0, Str);
 	Select->DoModal([Select, EditCtrl](auto dlg, auto id)
 	{
 		if (id)
 			EditCtrl->Name(Select->Get());
 		delete dlg;
 	});
 }
 
 void Mail::DoContextMenu(LMouse &m, LView *p)
 {
 	#ifdef _DEBUG
 	LAutoPtr<LProfile> Prof(new LProfile("Mail::DoContextMenu"));
 	Prof->HideResultsIfBelow(100);
 	#endif
 	
 	if (!p)
 		p = Parent;
 
 	// open the right click menu
 	MarkedState MarkState = MS_None;
 	
 	// Pre-processing for marks
 	List<LListItem> Sel;
 	if (_GetListItems(Sel, false))
 	{
 		int Marked = 0;
 		for (auto t: Sel)
 		{
 			Mail *m = dynamic_cast<Mail*>(t);
 			if (m)
 			{
 				if (m->GetMarkColour())
 				{
 					Marked++;
 				}
 			}
 		}
 
 		if (Marked == 1)
 		{
 			MarkState = MS_One;
 		}
 		else if (Marked)
 		{
 			MarkState = MS_Multiple;
 		}
 	}
 
 	#ifdef _DEBUG
 	Prof->Add("CreateMenu");
 	#endif
 
 	// Create menu
 	LScriptUi s(new LSubMenu);
 	if (s.Sub)
 	{
 		/*
 		Keyboard shortcuts:
 
 		o - Open
 		d - Delete
 		x - Export
 		e - Set read
 		u - Set unread
 		r - Reply
 		a - Reply all
 		f - Forward
 		b - Bounce
 		m - Mark
 		s - Select marked
 		c - Create filter
 		i - Inspect
 		p - Properties
 		
 		*/
 		LMenuItem *i;
 		s.Sub->SetImageList(App->GetIconImgList(), false);
 
 		s.Sub->AppendItem(LLoadString(IDS_OPEN), IDM_OPEN, true);
 		i = s.Sub->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE, true);
 		i->Icon(ICON_TRASH);
 		s.Sub->AppendItem(LLoadString(IDS_EXPORT), IDM_EXPORT, true);
 		int AttachBaseMsg = 10000;
 
 		#ifdef _DEBUG
 		Prof->Add("GetAttachments");
 		#endif
 
 		List<Attachment> AttachLst;
 		if (GetAttachments(&AttachLst) &&
 			AttachLst[0])
 		{
 			LSubMenu *Attachments = s.Sub->AppendSub(LLoadString(IDS_SAVE_ATTACHMENT_AS));
 			if (Attachments)
 			{
 				int n=0;
 				for (auto a: AttachLst)
 				{
 					auto Name = a->GetName();
 					Attachments->AppendItem(Name?Name:(char*)"Attachment.txt", AttachBaseMsg+(n++), true);
 				}
 			}
 		}
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Read/Unread");
 		#endif
 
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_SET_READ), 'e'), IDM_SET_READ, true);
 		i->Icon(ICON_READ_MAIL);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_SET_UNREAD), 'u'), IDM_SET_UNREAD, true);
 		i->Icon(ICON_UNREAD_MAIL);
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Reply/Bounce");
 		#endif
 
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_REPLY), 'r'), IDM_REPLY, true);
 		i->Icon(ICON_FLAGS_REPLY);
 		s.Sub->AppendItem(AddAmp(LLoadString(IDS_REPLYALL), 'a'), IDM_REPLY_ALL, true);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_FORWARD), 'f'), IDM_FORWARD, true);
 		i->Icon(ICON_FLAGS_FORWARD);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_BOUNCE), 'b'), IDM_BOUNCE, true);
 		i->Icon(ICON_FLAGS_BOUNCE);
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Thread");
 		#endif
 
 		if (App->GetCtrlValue(IDM_THREAD))
 		{
 			auto Thread = s.Sub->AppendSub(LLoadString(IDS_THREAD));
 			if (Thread)
 			{
 				Thread->AppendItem(LLoadString(IDS_THREAD_SELECT), IDM_SELECT_THREAD);
 				Thread->AppendItem(LLoadString(IDS_THREAD_DELETE), IDM_DELETE_THREAD);
 				Thread->AppendItem(LLoadString(IDS_THREAD_IGNORE), IDM_IGNORE_THREAD);
 				s.Sub->AppendSeparator();
 			}
 		}
 
 		#ifdef _DEBUG
 		Prof->Add("Mark");
 		#endif
 
 		auto MarkMenu = s.Sub->AppendSub(AddAmp(LLoadString(IDS_MARK), 'm'));
 		if (MarkMenu)
 		{
 			BuildMarkMenu(MarkMenu, MarkState, (uint32_t)GetMarkColour(), true);
 		}
 
 		MarkMenu = s.Sub->AppendSub(AddAmp(LLoadString(IDS_SELECT_MARKED), 's'));
 		if (MarkMenu)
 		{
 			BuildMarkMenu(MarkMenu, MS_Multiple, 0, true, true, true);
 		}
 
 		s.Sub->AppendSeparator();
 		s.Sub->AppendItem(AddAmp(LLoadString(IDS_INSPECT), 'i'), IDM_INSPECT);
 		s.Sub->AppendItem(LLoadString(IDS_REPARSE), IDM_REPARSE);
 		s.Sub->AppendItem(LLoadString(IDS_PROPERTIES), IDM_PROPERTIES);
 
 		#ifdef _DEBUG
 		Prof->Add("ScriptCallbacks");
 		#endif
 
 		LArray<LScriptCallback*> Callbacks;
 		if (App->GetScriptCallbacks(LThingContextMenu, Callbacks))
 		{
 			LScriptArguments Args(NULL);
 			Args[0] = new LVariant(App);
 			Args[1] = new LVariant(this);
 			Args[2] = new LVariant(&s);
 			
 			for (auto c: Callbacks)
 				App->ExecuteScriptCallback(*c, Args);
 			
 			Args.DeleteObjects();
 		}
 
 		m.ToScreen();
 		int Result;
 
 		#ifdef _DEBUG
 		Prof.Reset();
 		#endif
 
 		int Btn = 0;
 		if (m.Left())
 			Btn = LSubMenu::BtnLeft;
 		else if (m.Right())
 			Btn = LSubMenu::BtnRight;
 
 		Result = s.Sub->Float(p, m.x, m.y);
 		switch (Result)
 		{
 			case IDM_OPEN:
 			{
 				DoUI();
 				break;
 			}
 			case IDM_DELETE:
 			{
 				LVariant ConfirmDelete = false;
 				App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 				if (!ConfirmDelete.CastInt32() ||
 					LgiMsg(GetList(), LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 				{
 					if (_GetListItems(Sel, false))
 					{
 						int Index = -1;
 						LList *TheList = LListItem::Parent;
 						LArray<Thing*> Items;
 
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (m)
 							{
 								if (Index < 0) Index = TheList->IndexOf(m);
 								Items.Add(m);
 							}
 						}
 						
 						GetFolder()->Delete(Items, true);
 
 						if (Index >= 0)
 						{
 							LListItem *i = TheList->ItemAt(Index);
 							if (i) i->Select(true);
 						}
 					}
 				}
 				break;
 			}
 			case IDM_EXPORT:
 			{
 				ExportAll(Parent, sMimeMessage, NULL);
 				break;
 			}
 			case IDM_REPLY:
 			case IDM_REPLY_ALL:
 			{
 				App->MailReplyTo(this, Result == IDM_REPLY_ALL);
 				SetDirty(false);
 				break;
 			}
 			case IDM_FORWARD:
 			{
 				App->MailForward(this);
 				SetDirty(false);
 				break;
 			}
 			case IDM_BOUNCE:
 			{
 				App->MailBounce(this);
 				SetDirty(false);
 				break;
 			}
 			case IDM_SET_READ:
 			{
 				SetListRead(true);
 				break;
 			}
 			case IDM_SET_UNREAD:
 			{
 				SetListRead(false);
 				break;
 			}
 			case IDM_INSPECT:
 			{
 				OnInspect();
 				break;
 			}
 			case IDM_PROPERTIES:
 			{
 				OnProperties();
 				break;
 			}
 			case IDM_SELECT_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->Select(true);
 					}
 				}
 				break;
 			}
 			case IDM_DELETE_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->OnDelete();
 					}
 				}
 				break;
 			}
 			case IDM_IGNORE_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->SetFlags(m->GetFlags() | MAIL_IGNORE | MAIL_READ);
 					}
 				}
 				break;
 			}
 			case IDM_REPARSE:
 			{
 				if (!_GetListItems(Sel, false))
 					break;
 
 				for (auto s: Sel)
 				{
 					Mail *m = dynamic_cast<Mail*>(s);
 					if (m)
 						m->Reparse();
 				}
 				break;
 			}
 			case IDM_UNMARK:
 			case IDM_SELECT_NONE:
 			case IDM_SELECT_ALL:
 			default:
 			{
 				if (Result == IDM_UNMARK ||
 					(Result >= IDM_MARK_BASE && Result < IDM_MARK_BASE+CountOf(MarkColours32)))
 				{
 					bool Marked = Result != IDM_UNMARK;
 
 					if (_GetListItems(Sel, false))
 					{
 						COLOUR Col32 = Marked ? MarkColours32[Result - IDM_MARK_BASE] : 0;
 
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (m)
 							{
 								if (m->SetMarkColour(Col32))
 								{
 									if (m->GetObject()->GetInt(FIELD_STORE_TYPE) != Store3Imap) // Imap knows to save itself.
 										m->SetDirty();
 								}
 								m->Update();
 							}
 						}
 					}
 				}
 				else if (Result == IDM_SELECT_NONE ||
 						 Result == IDM_SELECT_ALL ||
 						(Result >= IDM_MARK_SELECT_BASE && Result < IDM_MARK_SELECT_BASE+CountOf(MarkColours32)))
 				{
 					bool None = Result == IDM_SELECT_NONE;
 					bool All = Result == IDM_SELECT_ALL;
 					uint32_t c32 = MarkColours32[Result - IDM_MARK_SELECT_BASE];
 
 					if (_GetListItems(Sel, true))
 					{
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (!m)
 								break;
 
 							auto CurCol = m->GetMarkColour();
 							if (None)
 							{
 								m->Select(CurCol <= 0);
 							}
 							else
 							{
 								if (CurCol > 0)
 								{
 									if (All)
 									{
 										m->Select(true);
 									}
 									else
 									{
 										m->Select(CurCol && CurCol == c32);
 									}
 								}
 								else
 								{
 									m->Select(false);
 								}
 							}
 						}
 					}
 				}
 				else if (Result >= AttachBaseMsg &&
 						 Result < AttachBaseMsg + (ssize_t)AttachLst.Length())
 				{
 					// save attachment as...
 					Attachment *a = AttachLst.ItemAt(Result - AttachBaseMsg);
 					if (a)
 					{
 						a->OnSaveAs(Parent);
 					}
 				}
 				else
 				{
 					// Handle any installed callbacks for menu items
 					for (unsigned i=0; i<s.Callbacks.Length(); i++)
 					{
 						LScriptCallback &Cb = s.Callbacks[i];
 						if (Cb.Param == Result)
 						{
 							LScriptArguments Args(NULL);
 							Args[0] = new LVariant(App);
 							Args[1] = new LVariant(this);
 							Args[2] = new LVariant(Cb.Param);
 							
 							App->ExecuteScriptCallback(Cb, Args);
 						}
 					}
 				}
 				break;
 			}
 		}
 
 		DeleteObj(s.Sub);
 	}
 }
 
 void Mail::OnMouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		if (!m.IsContextMenu())
 		{
 			if (m.Double())
 			{
 				// open the UI for the Item
 				DoUI();
 			}
 		}
 		else
 		{
 			DoContextMenu(m);
 		}
 	}
 }
 
 void Mail::OnCreate()
 {
 	LOptionsFile *Options = App->GetOptions();
 	LVariant v;
 	if (GetObject()) GetObject()->SetInt(FIELD_FLAGS, MAIL_CREATED);
 
 	// Get identity and set from info
 	ScribeAccount *Ident = App->GetCurrentAccount();
 	if (Ident)
 	{
 		v = Ident->Identity.Name();
 		GetFrom()->SetStr(FIELD_NAME, v.Str());
 		v = Ident->Identity.Email();
 		GetFrom()->SetStr(FIELD_EMAIL, v.Str());
 		
 		v = Ident->Identity.ReplyTo();
 		if (v.Str())
 			GetReply()->SetStr(FIELD_REPLY, v.Str());
 	}
 	else
 	{
 		LAssert(!"No identity selected");
 	}
 
 	LVariant EditCtrl;
 	App->GetOptions()->GetValue(OPT_EditControl, EditCtrl);
 	LAutoString Sig = GetSig(EditCtrl.CastInt32() != 0, Ident);
 	if (!Sig && EditCtrl.CastInt32())
 	{
 		Sig = GetSig(false, Ident);
 		SetBody(Sig);
 	}
 	else if (EditCtrl.CastInt32())
 	{
 		SetHtmlCharset("utf-8");
 		SetHtml(Sig);
 	}
 	else
 	{
 		SetBodyCharset("utf-8");
 		SetBody(Sig);
 	}
 
 	LVariant ClipRecip;
 	if (Options->GetValue(OPT_RecipientFromClipboard, ClipRecip) &&
 		ClipRecip.CastInt32())
 	{
 		LClipBoard Clip(App);
 		char *Txt = Clip.Text();
 		if (Txt && strchr(Txt, '@') && strlen(Txt) < 100)
 		{
 			for (char *s=Txt; *s; s++)
 			{
 				if (*s == '\n' || *s == '\r')
 				{
 					*s = 0;
 				}
 			}
 
 			Mailto mt(App, Txt);
 
 			for (auto a: mt.To)
 			{
 				LDataPropI *OldA = dynamic_cast<LDataPropI*>(a);
 				if (OldA)
 				{
 					LDataPropI *NewA = GetTo()->Create(GetObject()->GetStore());
 					if (NewA)
 					{
 						NewA->CopyProps(*OldA);
 						GetTo()->Insert(NewA);
 					}
 				}
 			}
 			mt.To.Empty();
 			
 			if (mt.Subject && !ValidStr(GetSubject()))
 			{
 				SetSubject(mt.Subject);
 			}
 
 			/*
 			if (_strnicmp(Txt, MailToStr, 7) == 0)
 			{
 				char *Question = strchr(Txt + 7, '?');
 				if (Question)
 				{
 					*Question = 0;
 					Question++;
 
 					int Len = strlen(SubjectStr);
 					if (_strnicmp(Question, SubjectStr, Len) == 0)
 					{
 						Subject = NewStr(Question + Len);
 					}
 				}
 
 				La->Addr = NewStr(Txt + 7);
 			}
 			else
 			{
 				La->Addr = NewStr(Txt);
 			}
 
 			To.Insert(La);
 			*/
 		}
 	}
 
 	Update();
 }
 
 void Mail::Reparse()
 {
 	#ifdef _DEBUG
 	_debug = true;
 	#endif
 
 	// This temporarily removes the attachments that will be 
 	// deleted by the call to ParseHeaders after this...
 	ClearCachedItems();
 
 	Thing::Reparse();
 }
 
 void Mail::CreateMailHeaders()
 {
 	LStringPipe Hdrs(256);
 	MailProtocol Protocol;
 	LVariant HideId;
     App->GetOptions()->GetValue(OPT_HideId, HideId);
 	Protocol.ProgramName = GetFullAppName(!HideId.CastInt32());
 		
 	LDataI *Obj = GetObject();
 	if (Obj && ::CreateMailHeaders(App, Hdrs, Obj, &Protocol))
 	{
 		LAutoString FullHdrs(Hdrs.NewStr());
 		Obj->SetStr(FIELD_INTERNET_HEADER, FullHdrs);
 	}
 	else LAssert(!"CreateMailHeaders failed.");
 }
 
 bool Mail::OnBeforeSend(ScribeEnvelope *Out)
 {
 	if (!Out)
 	{
 		LAssert(!"No output envelope.");
 		return false;
 	}
 	
 	// First check the email from address...
 	if (!ValidStr(GetFrom()->GetStr(FIELD_EMAIL)))
 	{
 		LOptionsFile *Options = App->GetOptions();
 		if (Options)
 		{
 			ScribeAccount *Ident = App->GetAccounts()->ItemAt(App->GetCurrentIdentity());
 			if (Ident)
 			{
 				LVariant v = Ident->Identity.Email();
 				GetFrom()->SetStr(FIELD_EMAIL, v.Str());
 				v = Ident->Identity.Name();
 				GetFrom()->SetStr(FIELD_NAME, v.Str());
 			}
 		}
 	}
 
 	Out->From = GetFromStr(FIELD_EMAIL);
 	LDataIt To = GetTo();
 	ContactGroup *Group = NULL;
 	for (LDataPropI *t = To->First(); t; t = To->Next())
 	{
 		LString Addr = t->GetStr(FIELD_EMAIL);
 		if (LIsValidEmail(Addr))
 			Out->To.New() = Addr;
 		else if ((Group = LookupContactGroup(App, Addr)))
 		{
 			LString::Array a = Group->GetAddresses();
 			Out->To.Add(a);
 		}
 	}
 
 	LDataPropI *Root = GetObject()->GetObj(FIELD_MIME_SEG);
 	if (!Root)
 	{
 		LAssert(!"No root element.");
 		return false;
 	}
 
 	// Check the headers have been created..
 	if (!Root->GetStr(FIELD_INTERNET_HEADER))
 		CreateMailHeaders();
 
 	Out->MsgId = GetMessageId(true);
 	
 	// Convert the mime stream
 	LMime Mime(ScribeTempPath());
 	LTempStream Buf(ScribeTempPath());
 	
 	Store3ToLMime(&Mime, Root);
 	
 	// Do the encode
 	if (!Mime.Text.Encode.Push(&Buf))
 	{
 		LAssert(!"Mime encode failed.");
 		return false;
 	}
 
 	Out->References = GetReferences();
 	Out->FwdMsgId = GetFwdMsgId();
 	Out->BounceMsgId = GetBounceMsgId();
 	
 	// Read the resulting string into the output envelope
 	int Sz = (int)Buf.GetSize();
 	Out->Rfc822.Length(Sz);
 	Buf.SetPos(0);
 	Buf.Read(Out->Rfc822.Get(), Sz);
 	Out->Rfc822.Get()[Sz] = 0;
 
 	return true;
 }
 
 void Mail::OnAfterSend()
 {
 	int f = GetFlags();
 	f |= MAIL_SENT | MAIL_READ;	// set sent flag
 	f &= ~MAIL_READY_TO_SEND;	// clear read to send flag
 
 	// LgiTrace("Setting flags: %x\n", f);
 	SetFlags(f);
 
 	LDateTime n;
 	n.SetNow();
 	SetDateSent(&n);
 	// LString s = GetDateSent()->Get();
 	// LgiTrace("Setting sent date: %s\n", s.Get());
 
 	Update();
 	SetDirty();
 
 	if (App)
 	{
 		ScribeFolder *Sent = App->GetFolder(FOLDER_SENT, GetObject());
 		if (Sent)
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			Sent->MoveTo(Items, false);
 		}
 	}
 }
 
 bool Mail::OnBeforeReceive()
 {
 	return true;
 }
 
 enum MimeDecodeMode
 {
 	MODE_FIELDS,
 	MODE_WAIT_MSG,
 	MODE_SEGMENT,
 	MODE_WAIT_TYPE,
 	MODE_WAIT_BOUNDRY
 };
 
 #define MF_UNKNOWN						1
 #define MF_SUBJECT						2
 #define MF_TO							3
 #define MF_FROM							4
 #define MF_REPLY_TO						5
 #define MF_CONTENT_TYPE					6
 #define MF_CC							7
 #define MF_CONTENT_TRANSFER_ENCODING	9
 #define MF_DATE_SENT					10
 #define MF_PRIORITY						11
 #define MF_COLOUR						12
 #define MF_DISPOSITIONNOTIFICATIONTO	13
 
 void MungCharset(Mail *Msg, bool &HasRealCs, ScribeAccount *Acc)
 {
 	if (ValidStr(Msg->GetBodyCharset()))
 	{
 		HasRealCs = true;
 	}
 
 	if (Acc)
 	{
 		// LCharset *Cs = 0;
 		if (Msg->GetBodyCharset() &&
 			stristr(Msg->GetBodyCharset(), "ascii") &&
 			Acc->Receive.AssumeAsciiCharset().Str())
 		{
 			Msg->SetBodyCharset(Acc->Receive.AssumeAsciiCharset().Str());
 			HasRealCs = false;
 		}
 		else if (!ValidStr(Msg->GetBodyCharset()) ||
 				!LGetCsInfo(Msg->GetBodyCharset()))
 		{
 			Msg->SetBodyCharset(Acc->Receive.Assume8BitCharset().Str());
 			HasRealCs = false;
 		}
 	}
 }
 
 bool Mail::OnAfterReceive(LStreamI *Msg)
 {
 	if (!Msg)
 	{
 		LAssert(!"No input.");
 		return false;
 	}
 
 	// Clear the codepage setting here so that we can
 	// check later, down the bottom we must set it to
 	// the default if it's not set anywhere along the
 	// way.
 	SetBodyCharset(0);
 
 	auto obj = GetObject();
 	if (!obj)
 	{
 		LAssert(!"No storage object.");
 		return false;
 	}
 
 	if (!obj->SetRfc822(Msg))
 	{
 		LAssert(!"Failed to set mime content.");
 		return false;
 	}
 
 	// Now parse them into the meta fields...
 	obj->ParseHeaders();
 	
 	ScribeAccount *Acc = GetAccountSentTo();
 	LAutoString ContentType;
 	
 	// Fill out any Contact's TimeZone if missing
 	LAutoString DateStr(InetGetHeaderField(GetInternetHeader(), "Date"));
 	LDateTime DateObj;
 	if (DateStr &&
 		DateObj.Decode(DateStr))
 	{
 	    double SenderTz = DateObj.GetTimeZoneHours();
 	    if (SenderTz != 0.0)
 	    {
 		    ListAddr *Sender = dynamic_cast<ListAddr*>(GetFrom());
 		    if (Sender)
 		    {
 				auto It = Sender->begin();
 				if (*It)
 				{
 					Contact *c = (*It)->GetContact();
 					if (c)
 					{
 						const char *Tz = "";
 						if (!c->Get(OPT_TimeZone, Tz) ||
 							atof(Tz) != SenderTz)
 						{
 							char s[32];
 							sprintf_s(s, sizeof(s), "%.1f", SenderTz);
 							c->Set(OPT_TimeZone, s);
 							c->SetDirty(true);
 						}
 					}
 				}
 		    }
 	    }
 	}
 
 	auto BodyText = GetBody();
 	if (BodyText)
 	{
 		if (!GetBodyCharset())
 		{
 			if (Acc && Acc->Receive.Assume8BitCharset().Str())
 			{
 				SetBodyCharset(Acc->Receive.Assume8BitCharset().Str());
 			}
 			else
 			{
 				SetBodyCharset("us-ascii");
 			}
 		}
 
 		LStringPipe NewBody;
 		LArray<LDataI*> Files;
 		if (DecodeUuencodedAttachment(obj->GetStore(), Files, &NewBody, BodyText))
 		{
 			LDataI *AttachPoint = GetFileAttachPoint();
 			if (AttachPoint)
 			{
 				for (unsigned i=0; i<Files.Length(); i++)
 				{
 					Files[i]->SetStr(FIELD_MIME_TYPE, sAppOctetStream);
 					Files[i]->Save(AttachPoint);
 				}
 
 				SetDirty(!TestFlag(GetFlags(), MAIL_ATTACHMENTS));
 				SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 
 				LAutoString n(NewBody.NewStr());
 				SetBody(n);
 
 				Update();
 				if (Ui) Ui->OnAttachmentsChange();
 			}
 		}
 	}
 
 	LDateTime n;
 	n.SetNow();
 	SetDateReceived(&n);
 
 	Update();
 	SetDirty();
 
 	// Call any 'after receive' callbacks
 	LArray<LScriptCallback*> Callbacks;
 	if (App->GetScriptCallbacks(LMailOnAfterReceive, Callbacks))
 	{
 		for (auto c: Callbacks)
 		{
 			if (!c->Func)
 				continue;
 
 			LVirtualMachine Vm;				
 			LScriptArguments Args(&Vm);
 			Args.New() = new LVariant(App);
 			Args.New() = new LVariant(this);
 			App->ExecuteScriptCallback(*c, Args);
 			Args.DeleteObjects();
 		}
 	}
 
 	return true;
 }
 
 ThingUi *Mail::GetUI()
 {
 	return Ui;
 }
 
 LVariant Mail::GetServerUid()
 {
 	LVariant v;
 	
 	if (GetObject())
 	{
 		auto Type = (Store3Backend)GetObject()->GetInt(FIELD_STORE_TYPE);
 		if (Type == Store3Imap)
 			v = GetObject()->GetInt(FIELD_SERVER_UID);
 		else
 			v = GetObject()->GetStr(FIELD_SERVER_UID);
 	}
 	else LAssert(!"No object.");
 
 	return v;
 }
 
 bool Mail::SetServerUid(LVariant &v)
 {
 	if (!GetObject())
 		return false;
 	
 	Store3Status s;
 	if (GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 		s = GetObject()->SetInt(FIELD_SERVER_UID, v.CastInt32());
 	else
 		s = GetObject()->SetStr(FIELD_SERVER_UID, v.Str());
 
 	return s > Store3Error;
 }
 
 bool Mail::SetObject(LDataI *o, bool IsDestructor, const char *File, int Line)
 {
 	bool b = LDataUserI::SetObject(o, IsDestructor, File, Line);
 	if (b)
 	{
 		// Clear out stale attachment objects...
 		UnloadAttachments();
 	}
 	return b;
 }
 
 bool Mail::SetUI(ThingUi *new_ui)
 {
 	MailUi *NewMailUi = dynamic_cast<MailUi*>(new_ui);
 	if (NewMailUi == Ui)
 		return true;
 
 	if (Ui)
 	{
 		LWindow *w = Ui;
 		Ui->SetItem(0);
 		w->Quit();
 		LAssert(Ui == NULL);
 	}
 	
 	if (new_ui)
 	{
 		Ui = dynamic_cast<MailUi*>(new_ui);
 		if (Ui)
 			Ui->SetItem(this);
 		else
 			LAssert(!"Incorrect object.");
 	}
 	
 	return true;
 }
 
 ThingUi *Mail::DoUI(MailContainer *c)
 {
 	if (App &&
 		!Ui)
 	{
 		if (App->InThread())
 		{
 			Ui = new MailUi(this, c ? c : GetFolder());
 		}
 		else
 		{
             App->PostEvent(M_SCRIBE_OPEN_THING, (LMessage::Param)this, 0);
 		}
 	}
 
 	if (Ui)
 	{
 		#if WINNATIVE
 		SetActiveWindow(Ui->Handle());
 		#endif
 	}
 
 	return Ui;
 }
 
 int Mail::Compare(LListItem *t, ssize_t Field)
 {
 	Thing *T = (Thing*)t->_UserPtr;
 	Mail *m = T ? T->IsMail() : 0;
 	if (m)
 	{
 		static int Fields[] = {FIELD_FROM, FIELD_SUBJECT, FIELD_SIZE, FIELD_DATE_RECEIVED};
 		if (Field < 0)
 		{
 			auto i = -Field - 1;
 			if (i >= 0 && i < CountOf(Fields))
 			{
 				Field = Fields[i];
 			}
 		}
 
 		LVariant v1, v2;
 		const char *s1 = "", *s2 = "";
 		switch (Field)
 		{
 			case 0:
 			{
 				break;
 			}
 			case FIELD_TO:
 			{
 				LDataPropI *a1 = GetTo()->First();
 				if (a1)
 				{
 					if (a1->GetStr(FIELD_NAME)) s1 = a1->GetStr(FIELD_NAME);
 					else if (a1->GetStr(FIELD_EMAIL)) s1 = a1->GetStr(FIELD_EMAIL);
 				}
 
 				LDataPropI *a2 = m->GetTo()->First();
 				if (a2)
 				{
 					if (a2->GetStr(FIELD_NAME)) s2 = a2->GetStr(FIELD_NAME);
 					else if (a2->GetStr(FIELD_EMAIL)) s2 = a2->GetStr(FIELD_EMAIL);
 				}
 				break;
 			}
 			case FIELD_FROM:
 			{
 				LDataPropI *f1 = GetFrom();
 				LDataPropI *f2 = m->GetFrom();
 
 				if (f1->GetStr(FIELD_NAME)) s1 = f1->GetStr(FIELD_NAME);
 				else if (f1->GetStr(FIELD_EMAIL)) s1 = f1->GetStr(FIELD_EMAIL);
 
 				if (f2->GetStr(FIELD_NAME)) s2 = f2->GetStr(FIELD_NAME);
 				else if (f2->GetStr(FIELD_EMAIL)) s2 = f2->GetStr(FIELD_EMAIL);
 				break;
 			}
 			case FIELD_SUBJECT:
 			{
 				s1 = GetSubject();
 				s2 = m->GetSubject();
 				break;
 			}
 			case FIELD_SIZE:
 			{
 				return (int) (TotalSizeof() - m->TotalSizeof());
 				break;
 			}
 			case FIELD_DATE_SENT:
 			{
 			    auto Sent1 = GetDateSent();
 			    auto Sent2 = m->GetDateSent();
 			    if (!Sent1 || !Sent2)
 			        break;
 				return Sent1->Compare(Sent2);
 				break;
 			}
 			case FIELD_DATE_RECEIVED:
 			{
 				return GetDateReceived()->Compare(m->GetDateReceived());
 				break;
 			}
 			case FIELD_PRIORITY:
 			{
 				return GetPriority() - m->GetPriority();
 				break;
 			}
 			case FIELD_FLAGS:
 			{
 				int Mask = MAIL_FORWARDED | MAIL_REPLIED | MAIL_READ;
 				return (GetFlags() & Mask) - (m->GetFlags() & Mask);
 				break;
 			}
 			case FIELD_LABEL:
 			{
 				if (GetLabel()) s1 = GetLabel();
 				if (m->GetLabel()) s2 = m->GetLabel();
 				break;
 			}
 			case FIELD_MESSAGE_ID:
 			{
 				s1 = GetMessageId();
 				s2 = m->GetMessageId();
 				break;
 			}
 			case FIELD_FROM_CONTACT_NAME:
 			{
 				s1 = GetFieldText(FIELD_FROM_CONTACT_NAME);
 				s2 = m->GetFieldText(FIELD_FROM_CONTACT_NAME);
 				break;
 			}
 			case FIELD_SERVER_UID:
 			{
 				v1 = GetServerUid();
 				v2 = m->GetServerUid();
 				if (v1.Str() && v2.Str())
 				{
 					s1 = v1.Str();
 					s2 = v2.Str();					
 				}
 				else
 				{
 					auto diff = v1.CastInt64() - v2.CastInt64();
 					if (diff < 0) return -1;
 					return diff > 1;
 				}
 			}
 			default:
 			{
 				s1 = GetObject() ? GetObject()->GetStr((int)Field) : 0;
 				s2 = m->GetObject() ? m->GetObject()->GetStr((int)Field) : 0;
 				break;
 			}
 		}
 
 		const char *Empty = "";
 		return _stricmp(s1?s1:Empty, s2?s2:Empty);
 	}
 
 	return -1;
 }
 
 class MailPropDlg : public LDialog
 {
 	List<Mail> Lst;
 	LViewI *Table = NULL;
 
 	struct FlagInfo
 	{
 		int Flag = 0, Ctrl = 0;
 
 		void Set(int f, int c)
 		{
 			Flag = f;
 			Ctrl = c;
 		}
 	};
 	LArray<FlagInfo> Flags;
 
 public:
 	MailPropDlg(LView *Parent, List<Mail> &lst)
 	{
 		SetParent(Parent);
 		
 		Lst = lst;
 
 		Flags.New().Set(MAIL_SENT, IDC_SENT);
 		Flags.New().Set(MAIL_RECEIVED, IDC_RECEIVED);
 		Flags.New().Set(MAIL_CREATED, IDC_CREATED);
 		Flags.New().Set(MAIL_FORWARDED, IDC_FORWARDED);
 		Flags.New().Set(MAIL_REPLIED, IDC_REPLIED);
 		Flags.New().Set(MAIL_ATTACHMENTS, IDC_HAS_ATTACH);
 		Flags.New().Set(MAIL_READ, IDC_READ);
 		Flags.New().Set(MAIL_READY_TO_SEND, IDC_READY_SEND);
 
 		if (LoadFromResource(IDD_MAIL_PROPERTIES))
 		{
 			GetViewById(IDC_TABLE, Table);
 			LAssert(Table != NULL);
 			SetCtrlEnabled(IDC_OPEN_INSPECTOR, Lst.Length() == 1);
 			
 			for (auto &i: Flags)
 			{
 				int Set = 0;
 				for (auto m: Lst)
 				{
 					if (m->GetFlags() & i.Flag)
 						Set++;
 				}
 				
 				if (Set == Lst.Length())
 				{
 					SetCtrlValue(i.Ctrl, LCheckBox::CheckOn);
 				}
 				else if (Set)
 				{
 					LCheckBox *Cb;
 					if (GetViewById(i.Ctrl, Cb))
 						Cb->ThreeState(true);
 
 					SetCtrlValue(i.Ctrl, LCheckBox::CheckPartial);
 				}
 			}
 
 			SetCtrlEnabled(IDC_HAS_ATTACH, false);
 
 			char Msg[512] = "";
 			if (Lst.Length() == 1)
 			{
 				Mail *m = Lst[0];
 				auto mObj = m->GetObject();
 				if (mObj)
 				{
 					auto dt = mObj->GetDate(FIELD_DATE_RECEIVED);
 					sprintf_s(	Msg, sizeof(Msg),
 								LLoadString(IDS_MAIL_PROPS_DLG),
 								LFormatSize(mObj->GetInt(FIELD_SIZE)).Get(),
 								dt ? dt->Get().Get() : LLoadString(IDS_NONE),
 								mObj->GetStr(FIELD_DEBUG));
 
 					SetCtrlName(IDC_MSG_ID, mObj->GetStr(FIELD_MESSAGE_ID));
 				}
 			}
 			else
 			{
 				sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_MULTIPLE_ITEMS), Lst.Length());
 				SetCtrlEnabled(IDC_MSG_ID, false);
 			}
 			SetCtrlName(IDC_MAIL_DESCRIPTION, Msg);
 
 			MoveSameScreen(Parent);
 		}
 	}
 	
 	void OnPosChange()
 	{
 		if (Table)
 		{
 			LRect r = GetClient();
 			r.Inset(LTableLayout::CellSpacing, LTableLayout::CellSpacing);
 			Table->SetPos(r);
 		}
 	}
 
 	int OnNotify(LViewI *Ctr, LNotification n)
 	{
 		switch (Ctr->GetId())
 		{
 			case IDC_OPEN_INSPECTOR:
 			{
 				if (Lst.Length())
 					Lst[0]->OnInspect();
 				break;
 			}
 			case IDOK:
 			{
 				for (auto &i: Flags)
 				{
 					auto v = GetCtrlValue(i.Ctrl);
 					LAssert(v >= 0); // the control couldn't be found... check the .lr8 file
 					
 					for (auto m: Lst)
 					{
 						if (v == 1)
 							m->SetFlags(m->GetFlags() | i.Flag);
 						else if (v == 0)
 							m->SetFlags(m->GetFlags() & ~i.Flag);
 					}
 				}
 				// fall thru
 			}
 			case IDCANCEL:
 			{
 				EndModal(Ctr->GetId());
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 void Mail::OnInspect()
 {
 	new ObjectInspector(App, this);
 }
 
 void Mail::OnProperties(int Tab)
 {
 	List<LListItem> Sel;
 	if (GetList()->GetSelection(Sel))
 	{
 		List<Mail> Lst;
 		for (auto i: Sel)
 		{
 			Lst.Insert(dynamic_cast<Mail*>(i));
 		}
 		
 		if (Lst[0])
 		{
 			auto Dlg = new MailPropDlg(GetList(), Lst);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id == IDOK)
 				{
 					SetDirty();
 					Update();
 				}
 				delete dlg;
 			});
 		}
 	}
 }
 
 int Mail::GetImage(int SelFlags)
 {
 	if (TestFlag(GetFlags(), MAIL_READY_TO_SEND) &&
 		!TestFlag(GetFlags(), MAIL_SENT))
 	{
 		return ICON_UNSENT_MAIL;
 	}
 		
 	if (GetFlags() & MAIL_READ)
 	{
 		return (GetFlags() & MAIL_ATTACHMENTS) ? ICON_READ_ATT_MAIL : ICON_READ_MAIL;
 	}
 	else
 	{
 		return (GetFlags() & MAIL_ATTACHMENTS) ? ICON_UNREAD_ATT_MAIL : ICON_UNREAD_MAIL;
 	}
 
 	return ICON_READ_MAIL;
 }
 
 int *Mail::GetDefaultFields()
 {
 	return DefaultMailFields;
 }
 
 void Mail::DeleteAsSpam(LView *View)
 {
 	// Set read..
 	SetFlags(GetFlags() | MAIL_READ | MAIL_BAYES_SPAM, true);
 
 	// Remove from NewMail
 	NewMailLst.Delete(this);
 
 	LVariant DeleteOnServer, DeleteAttachments, SetRead;
 	auto Opts = App->GetOptions();
 	if (!Opts->GetValue(OPT_BayesDeleteOnServer, DeleteOnServer))
 		DeleteOnServer = false;
 	if (!Opts->GetValue(OPT_BayesDeleteAttachments, DeleteAttachments))
 		DeleteAttachments = false;
 	if (!Opts->GetValue(OPT_BayesSetRead, SetRead))
 		SetRead = false;
 
 	if (DeleteOnServer.CastBool())
 	{
 		// Tell the account it's spam... so that any further connects can
 		// delete it off the server.
 		ScribeAccount *a = GetAccountSentTo();
 		if (a)
 		{
 			auto ServerUid = GetServerUid();
 			if (ServerUid.Str())
 			{
 				a->Receive.DeleteAsSpam(ServerUid.Str());
 				SetServerUid(ServerUid = NULL);
 			}
 			else
 			{
 				LAutoString Uid(InetGetHeaderField(GetInternetHeader(), "X-UIDL"));
 				if (Uid)
 					a->Receive.DeleteAsSpam(Uid);
 			}
 		}
 		else
 		{
 			#if 0 // def _DEBUG
 			if (LgiMsg(Ui?(LView*)Ui:(LView*)App, "Debug: GetAccountSentTo failed. Debug?", AppName, MB_YESNO) == IDYES)
 			{
 				LAssert(0);
 			}
 			#endif
 		}
 	}
 
 	if (DeleteAttachments.CastBool())
 	{
 		// Delete all attachments... they're useless and more than likely
 		// just virii anyway.
 		List<Attachment> Files;
 		if (GetAttachments(&Files))
 		{
 			for (auto a: Files)
 			{
 				DeleteAttachment(a);
 			}
 			Files.Empty();
 		}
 	}
 
 	if (SetRead.CastInt32() != 0)
 	{
 		SetFlags(GetFlags() | MAIL_READ);
 	}
 
 	// Move it to the spam folder if it exists.
 	auto FolderPath = GetFolder()->GetPath();
 	auto Parts = FolderPath.SplitDelimit("/");
 	
 	if (Parts.Length() == 0)
 		LgiMsg(View, "Error: No folder path?", AppName);
 	else
 	{
 		LString SpamPath;
 		LString SpamLeaf = "Spam";
 		SpamPath.Printf("/%s/%s", Parts[0].Get(), SpamLeaf.Get());
 
 		ScribeFolder *Spam = App->GetFolder(SpamPath);
 		if (!Spam)
 		{
 			LMailStore *Ms = App->GetMailStoreForPath(FolderPath);
 			if (!Ms)
 			{
 				if (GetFolder()->GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 				{
 					Ms = App->GetDefaultMailStore();
 					if (Ms && Ms->Root)
 					{
 						Spam = Ms->Root->GetSubFolder(SpamLeaf);
 						if (!Spam)
 							Spam = Ms->Root->CreateSubDirectory(SpamLeaf, MAGIC_MAIL);
 					}
 				}
 				else
 					LgiMsg(View, "Error: Couldn't get mail store for '%s'.", AppName, MB_OK, FolderPath.Get());
 			}
 			else
 				Spam = Ms->Root->CreateSubDirectory("Spam", MAGIC_MAIL);
 		}
 
 		if (Spam && Spam != GetFolder())
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			Spam->MoveTo(Items, false, [View](auto result, auto status)
 			{
 				if (!result)
 					LgiMsg(View, "Error: Couldn't move email to spam folder.", AppName);
 			});
 		}
 	}
 }
 
 void Mail::SetFlagsCache(int64_t NewFlags, bool IgnoreReceipt, bool UpdateScreen)
 {
 	if (FlagsCache == NewFlags)
 		return;
 
 	DepthCheck Depth(d->InSetFlagsCache);
 		
 	bool Read1 = TestFlag(FlagsCache, MAIL_READ);
 	bool Read2 = TestFlag(NewFlags, MAIL_READ);
 	bool ChangeRead = Read1 ^ Read2;
 
 	// LgiTrace("%p::SetFlagsCache: %s -> %s\n", this, EmailFlagsToStr(FlagsCache).Get(), EmailFlagsToStr(StoreFlags).Get());
 	FlagsCache = NewFlags;
 
 	if (ChangeRead && App)
 	{
 		if (Read2)
 		{
 			// Becoming read
 			List<Mail> Objs;
 			Objs.Insert(this);
 			App->OnNewMail(&Objs, false);
 			PreviewCache.DeleteObjects();
 
 			// Read receipt
 			if (!IgnoreReceipt &&
 				!TestFlag(NewFlags, MAIL_CREATED) &&
 				TestFlag(NewFlags, MAIL_READ_RECEIPT))
 			{
 				LAutoString Header(InetGetHeaderField(GetInternetHeader(), "Disposition-Notification-To"));
 				if (Header)
 				{
 					LAutoString Name, Addr;
 					DecodeAddrName(Header, Name, Addr, 0);
 					if (Addr)
 					{
 						if (LgiMsg(	Ui != 0 ? (LView*)Ui : (LView*)App,
 									LLoadString(IDS_RECEIPT_ASK),
 									AppName,
 									MB_YESNO,
 									GetSubject(),
 									GetFrom()->GetStr(FIELD_NAME),
 									GetFrom()->GetStr(FIELD_EMAIL),
 									(char*)Name,
 									(char*)Addr) == IDYES)
 						{
 							Mail *m = new Mail(App);
 							if (m)
 							{
 								m->App = App;
 
 								LDataPropI *ToAddr = m->GetTo()->Create(m->GetObject()->GetStore());
 								if (ToAddr)
 								{
 									ToAddr->SetStr(FIELD_NAME, Name);
 									ToAddr->SetStr(FIELD_EMAIL, Addr);
 									m->GetTo()->Insert(ToAddr);
 								}
 									
 								m->OnReceipt(this);
 								m->Save();
 								App->Send();
 							}
 						}
 					}
 				}
 			}
 
 			LVariant Inc;
 			if (App->GetOptions()->GetValue(OPT_BayesIncremental, Inc) &&
 				Inc.CastInt32())
 			{
 				// Incremental bayesian update
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailHam);
 			}
 		}
 
 		if (UpdateScreen)
 		{
 			// Changing read status
 			ScribeFolder *t = GetFolder();
 			if (t)
 				t->OnUpdateUnRead(0, true);
 		}
 	}
 
 	if (UpdateScreen || ChangeRead)
 	{
 		Update();
 	}
 }
 
 
 uint32_t Mail::GetFlags()
 {
 	if (GetObject())
 	{
 		// Make sure the objects are in sync...
 		auto StoreFlags = GetObject()->GetInt(FIELD_FLAGS);
 		if (FlagsCache < 0)
 			FlagsCache = StoreFlags;
 		else if (FlagsCache != StoreFlags)
 			SetFlagsCache(StoreFlags, false, true);
 	}
 
 	return (uint32_t)FlagsCache;
 }
 
 void Mail::SetFlags(ulong NewFlags, bool IgnoreReceipt, bool UpdateScreen)
 {
 	if (FlagsCache == NewFlags)
 		return;
 
 	DepthCheck SetFlagsDepth(d->InSetFlags);
 
 	if (GetObject())
 	{
 		Store3Status Result = GetObject()->SetInt(FIELD_FLAGS, NewFlags);
 		if (Result == Store3Success &&
 			GetObject()->IsOnDisk())
 		{
 			// Imap mail shouldn't fall in here.
 			SetDirty();
 		}
 	}
 	else
 	{
 		LAssert(0);
 		return;
 	}
 
 	SetFlagsCache(NewFlags, IgnoreReceipt, UpdateScreen);
 }
 
 const char *Mail::GetFieldText(int Field)
 {
 	static char Buf[512];
 
 	switch (Field)
 	{
 		case FIELD_TO:
 		{
 			size_t ch = 0;
 			Buf[0] = 0;
 			
 			LDataIt To = GetTo();
 			for (LDataPropI *a=To->First(); a; a=To->Next())
 			{
 				if (ch > 0)
 					ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, ", ");
 				
 				auto Name = a->GetStr(FIELD_NAME);
 				auto Addr = a->GetStr(FIELD_EMAIL);
 				auto n = Name ? Name : Addr;
 				if (!n)
 					continue;
 
 				// Is the buffer too small?
 				size_t n_len = strlen(n);
 				if (ch + n_len + 8 >= sizeof(Buf))
 				{
 					// Yes... just truncate it with "..." and bail.
 					ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, "...");
 					break;
 				}
 				ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, "%s", n);
 				
 				LAssert(ch < sizeof(Buf) - 1);
 			}
 			return Buf;
 			break;
 		}
 		case FIELD_FROM_CONTACT_NAME:
 		{
 			static bool InMethod = false;
 			if (!InMethod)
 			{
 				InMethod = true;
 				
 				LDataPropI *la = GetFrom();
 				if (la)
 				{
 					auto Email = la->GetStr(FIELD_EMAIL);
 					Contact *c = Contact::LookupEmail(Email);
 					if (c)
 					{
 						const char *f = 0, *l = 0;
 						c->Get(OPT_First, f);
 						c->Get(OPT_Last, l);
 						
 						if (f && l)
 							sprintf_s(Buf, sizeof(Buf), "%s %s", f, l);
 						else if (f)
 							strcpy_s(Buf, sizeof(Buf), f);
 						else if (l)
 							strcpy_s(Buf, sizeof(Buf), l);
 						else
 							Buf[0] = 0;
 
 						InMethod = false;
 						return Buf;
 					}
 				}
 				
 				InMethod = false;
 			}
 			else
 			{
 				LAssert(0);
 			}
 			
 			// fall through
 		}
 		case FIELD_FROM:
 		{
 		    LDataPropI *f = GetFrom();
 			auto n = f->GetStr(FIELD_NAME);
 		    if (n)
 		        return n;
 
 			auto e = f->GetStr(FIELD_EMAIL);
 			if (e)
 			    return e;
 			break;
 		}
 		case FIELD_SUBJECT:
 		{
 			auto s = GetSubject();
 			
 			if (Strchr(s, '\n'))
 			{
 				char *e = Buf + sizeof(Buf) - 1;
 				char *o = Buf;
 				for (auto i = s; o<e && *i; i++)
 				{
 					if (*i != '\n')
 						*o++ = *i;
 				}
 				*o++ = 0;
 				return Buf;
 			}
 			
 			return s;
 		}
 		case FIELD_SIZE:
 		{
 			if (TotalSizeCache < 0)
 				TotalSizeof();
 				
 			if (OptionSizeInKiB)
 			{
 				int ch = sprintf_s(Buf, sizeof(Buf), "%.0f KiB", (double)TotalSizeCache/1024.0);
 				if (ch > 4 + 3)
 				{
 					int digits = ch - 4;
 					char *s = Buf + ((digits % 3) ? digits % 3 : 3);
 					char *e = Buf + ch - 4;
 					while (s < e)
 					{
 						memmove(s + 1, s, strlen(s)+1);
 						*s = ',';
 						s += 3;
 					}
 				}
 			}
 			else
 				LFormatSize(Buf, sizeof(Buf), TotalSizeCache);
 			return Buf;
 		}
 		case FIELD_DATE_SENT:
 		{
 			auto DateSent = GetDateSent();
 			if (DateSent->Year())
 			{
 				LDateTime dt = *DateSent;
 				if (GetObject() &&
 					GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 				{
 					ValidateImapDate(dt);
 				}
 
 			    if (AdjustDateTz)
 			    {
                     if (dt.GetTimeZone() != LDateTime::SystemTimeZone())
     			        dt.SetTimeZone(LDateTime::SystemTimeZone(), true);
 				}
 
 				if (ShowRelativeDates)
 				{
 					auto rel = RelativeTime(dt);
 					strcpy_s(Buf, sizeof(Buf), rel ? rel : "#error:RelativeTime");
 				}
 				else
 				{
 					dt.Get(Buf, sizeof(Buf));
 				}
 			}
 			else
 			{
 				sprintf_s(Buf, sizeof(Buf), "(%s)", LLoadString(IDS_NONE, "None"));
 			}			
 			return Buf;
 		}
 		case FIELD_DATE_RECEIVED:
 		{
 			auto DateReceived = GetDateReceived();
 			if (DateReceived->Year())
 			{
 		        LDateTime dt = *DateReceived;
 			    if (AdjustDateTz)
 			    {
                     if (dt.GetTimeZone() != LDateTime::SystemTimeZone())
     			        dt.SetTimeZone(LDateTime::SystemTimeZone(), true);
 			    }
 
 				dt.Get(Buf, sizeof(Buf));
 				if (ShowRelativeDates)
 				{
 					auto rel = RelativeTime(dt);
 					strcpy_s(Buf, sizeof(Buf), rel ? rel : "#error:RelativeTime");
 				}
 				else
 				{
 				    dt.Get(Buf, sizeof(Buf));
 				}
 			}
 			else
 			{
 				sprintf_s(Buf, sizeof(Buf), "(%s)", LLoadString(IDS_NONE, "None"));
 			}			
 			return Buf;
 		}
 		case FIELD_TEXT:
 			return GetBody();
 		case FIELD_MESSAGE_ID:
 			return GetMessageId();
 		case FIELD_INTERNET_HEADER:
 			return GetInternetHeader();
 		case FIELD_ALTERNATE_HTML:
 			return GetHtml();
 		case FIELD_LABEL:
 			return GetLabel();
 		case FIELD_PRIORITY:
 		case FIELD_FLAGS:
 			return 0;
 		case FIELD_SERVER_UID:
 			sprintf_s(Buf, sizeof(Buf), "%i", GetObject() ? (int)GetObject()->GetInt(Field) : -1);
 			return Buf;
 		case FIELD_RECEIVED_DOMAIN:
 		{
 			if (!d->DomainCache)
 			{
 				if (!GetObject())
 					return NULL;
 
 				auto hdr = GetObject()->GetStr(FIELD_INTERNET_HEADER);
 				if (!hdr)
 					return NULL;
 
 				for (auto ln: LString(hdr).SplitDelimit("\n"))
 				{
 					if (ln.Find("Received: from") == 0)
 					{
 						auto p = ln.SplitDelimit();
 						if (p.Length() > 2)
 						{
 							auto t = p[2];
 							if (t.Find(".") > 0)
 								d->DomainCache = t.Strip("[]");
 						}
 					}
 				}
 			}
 
 			return d->DomainCache;
 		}
 		default:
 			return GetObject() ? GetObject()->GetStr(Field) : NULL;
 	}
 
 	return 0;
 }
 
 int Mail::DefaultMailFields[] =
 {
 	/*
 	FIELD_FLAGS,
 	FIELD_PRIORITY,
 	*/
 	FIELD_FROM,
 	FIELD_SUBJECT,
 	FIELD_SIZE,
 	FIELD_DATE_SENT
 };
 
 const char *Mail::GetText(int i)
 {
 	if (FieldArray.Length())
 	{
 		if (i >= 0 && i < (int)FieldArray.Length())
 			return GetFieldText(FieldArray[i]);
 	}
 	else if (i < CountOf(DefaultMailFields))
 	{
 		return GetFieldText(DefaultMailFields[i]);
 	}
 	
 	return NULL;
 }
 
 LDataI *Mail::GetFileAttachPoint()
 {
 	if (!GetObject())
 	{
 		LAssert(!"No object ptr.");
 		return 0;
 	}
 
 	auto Store = GetObject()->GetStore();
 	
 	// Check existing root node for "multipart/mixed"?
 	auto r = dynamic_cast<LDataI*>(GetObject()->GetObj(FIELD_MIME_SEG));
 	if (!r)
 	{
 		// Create one...
 		r = Store->Create(MAGIC_ATTACHMENT);
 		if (!r)
 		{		
 			LAssert(!"No MIME segment ptr.");
 			return NULL;
 		}
 		
 		r->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 		if (!GetObject()->SetObj(FIELD_MIME_SEG, r))
 		{
 			LAssert(!"Can't set MIME segment.");
 			return NULL;
 		}
 	}
 
 	auto Mt = r->GetStr(FIELD_MIME_TYPE);
 	if (!Stricmp(Mt, sMultipartMixed))
 	{
 		// Yes is it mixed... return that...
 		return r;
 	}
 
 	// No, a different type of segment, make the parent segment a "mixed", and attach the old segment to the mixed
 	auto Mixed = Store->Create(MAGIC_ATTACHMENT);
 	if (!Mixed)
 	{
 		LAssert(!"Failed to create MAGIC_ATTACHMENT.");
 		return NULL;
 	}
 
 	// Set the type...
 	Mixed->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 
 	// Re-parent the content to the mixed
 	if (!r->Save(Mixed))
 	{
 		LAssert(!"Can't reparent the content into the mixed seg.");
 		return NULL;
 	}
 
 	// Re-parent the mixed to the mail object
 	if (!Mixed->Save(GetObject()))
 	{
 		LAssert(!"Can't reparent the mixed seg into the mail object.");
 		return NULL;
 	}
 
 	return Mixed;
 }
 
 bool Mail::AttachFile(Attachment *File)
 {
 	bool Status = false;
 
 	if (File && !Attachments.HasItem(File))
 	{
 		LDataI *AttachPoint = GetFileAttachPoint();
 		if (AttachPoint)
 		{
 			if (File->GetObject()->Save(AttachPoint))
 			{
 				File->App = App;
 				File->SetOwner(this);
 				Attachments.Insert(File);
 
 				Status = true;
 
 				SetDirty(!TestFlag(GetFlags(), MAIL_ATTACHMENTS));
 				SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 
 				Update();
 
 				if (Ui)
 				{
 					Ui->OnAttachmentsChange();
 				}
 			}
 		}
 		else
 		{
 			File->DecRef();
 		}
 	}
 
 	return Status;
 }
 
 Attachment *Mail::AttachFile(LView *Parent, const char *FileName)
 {
 	LString MimeType = ScribeGetFileMimeType(FileName);
 	LVariant Resize = false;
 	if (!Strnicmp(MimeType.Get(), "image/", 6))
 	{
 		// Check if we have to do a image resize
 		App->GetOptions()->GetValue(OPT_ResizeImgAttachments, Resize);
 	}
 
 	auto AttachPoint = GetFileAttachPoint();
 	if (!AttachPoint)
 	{
 		LAssert(!"No attachment point in MIME heirarchy for file");
 		return NULL;
 	}
 	
 	auto File = new Attachment(	App,
 								GetObject()->GetStore()->Create(MAGIC_ATTACHMENT),
 								FileName);
 	if (File)
 	{
 		File->App = App;
 		if (Resize.CastInt32() || File->GetSize() > 0)
 		{
 			File->SetOwner(this);
 			Attachments.Insert(File);
 			if (Resize.CastInt32())
 				d->AddResizeImage(File);
 			else
 				File->GetObject()->Save(AttachPoint);
 			SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 			Update();
 
 			if (Ui)
 				Ui->OnAttachmentsChange();
 		}
 		else
 		{
 			LgiMsg(Parent, LLoadString(IDS_ERROR_FILE_EMPTY), AppName);
 			File->DecRef();
 			File = NULL;
 		}
 	}
 
 	return File;
 }
 
 bool Mail::Save(ScribeFolder *Into)
 {
 	bool Status = false;
 
 	if (!Into)
 	{
 	    if (GetFolder())
 		    Into = GetFolder();
 		else
 			Into = App->GetFolder(FOLDER_OUTBOX);
 	}
 
 	if (Into)
 	{
 		ScribeFolder *Old = GetFolder();
 
         if (!GetFolder())
         {
 	        SetParentFolder(Into);
 	    }
 	    else if (GetFolder() != Into)
 	    {
             // If this fails, you should really by using ScribeFolder::MoveTo to move
             // the item from it's existing location to the new folder...
             LAssert(!"Use MoveTo instead.");
             return false;
 	    }
 
 		Store3Status Result = Into->WriteThing(this);
 		if (Result != Store3Error)
 		{
 			Status = true;
 			SetDirty(false);
 			
 			if (Into &&
 				Into == App->GetFolder(FOLDER_TEMPLATES, NULL, true))
 			{
 				// saving into the templates folder... update the menu
 				App->BuildDynMenus();
 			}
 
 			if (Status && DropFileName)
 			{
 				FileDev->Delete(DropFileName, false);
 				DropFileName.Reset();
 			}
 		}
 		else
 		{
 			SetParentFolder(Old);
 		}
 	}
 	
 	// This frees the resizer thread... 
 	// so they aren't hanging around pointlessly
 	d->OnSave();	
 	
 	return Status;
 }
 
 struct WrapQuoteBlock
 {
 	int Depth;
 	LArray<char*> Text;
 };
 
 void WrapAndQuote(	LStream &Pipe,
 					const char *Quote,
 					int Wrap,
 					const char *Text,
 					const char *Cp,
 					const char *MimeType)
 {
 	int IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 	LAutoString In((char*) LNewConvertCp("utf-8", Text, Cp ? Cp : (char*)"utf-8"));
 	const char *QuoteStr = Quote;
 	if (In)
 	{
 		size_t QuoteChars = Strlen(QuoteStr);
 		char NewLine[8];
 		int NewLineLen = sprintf_s(NewLine, sizeof(NewLine), "%s", IsHtml ? "<br>\n" : "\n");
 
 		// Two step process, parse all the input into an array of paragraph blocks and then output each block
 		// in wrapped form
 		LArray<WrapQuoteBlock> Para;
 		
 		// 1) Parse all input into paragraphs
 		char *i = In;
 		while (*i)
 		{
 			// Parse out the next line...
 			char *e = i;
 			while (*e && *e != '\n')
 				e++;
 			ssize_t len = e - i;
 			int depth = 0;
 			for (int n=0; n<len; n++)
 			{
 				if (i[n] == '>')
 					depth++;
 				else if (i[n] != ' ' || i[n] != '\t')
 					break;
 			}
 			
 			if (Para.Length())
 			{
 				// Can this be added to the previous paragraph?
 				WrapQuoteBlock &Prev = Para[Para.Length()-1];
 				if (Prev.Depth == depth)
 				{
 					// Yes?!
 					Prev.Text.Add(NewStr(i, len));
 					i = *e ? e + 1 : e;
 					continue;
 				}
 			}
 
 			// Create a new paragraph
 			WrapQuoteBlock &New = Para.New();
 			New.Depth = depth;
 			New.Text.Add(NewStr(i, len));
 			
 			// Move current position to next line
 			i = *e ? e + 1 : e;
 		}
 		
 		// 2) Output all paragraphs
 		const char *PrefixCharacters = "> \t";
 		for (unsigned n=0; n<Para.Length(); n++)
 		{
 			WrapQuoteBlock &p = Para[n];
 			ssize_t CharPos = 0;
 			
 			if (QuoteStr)
 			{
 				Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 				CharPos += QuoteChars;
 			}
 			
 			// Each line has the format:
 			//		[QuoteStr][Prefix][TextWords][NewLine]
 			
 			LAutoString Prefix;
 			ssize_t PrefixChars = 0;
 			for (unsigned l=0; l<p.Text.Length(); l++)
 			{
 				char *Line = p.Text[l];
 				// int LineLen = strlen(Line);
 				bool HardNewLine = true; // LineLen < Wrap;
 				char *Start = Line;
 				while (*Start && strchr(PrefixCharacters, *Start))
 					Start++;
 
 				if (!l)
 				{
 					// Create the prefix string
 					PrefixChars = Start - Line;
 					Prefix.Reset(NewStr(Line, PrefixChars));
 					
 					// Write the prefix string for the current line...
 					Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 					CharPos += PrefixChars;
 				}
 				
 				// Output [Start:EndOfLine] unless we run out of space on this line
 				while (*Start)
 				{
 					// Find end of the word.
 					char *End = Start;
 					while (*End && strchr(WhiteSpace, *End))
 						End++;
 					while (*End && !strchr(WhiteSpace, *End))
 						End++;
 					ssize_t WordLen = End - Start;
 					LAssert(WordLen > 0);
 					if (WordLen == 0)
 						break; // This won't end well...
 					
 					if (Wrap > 0)
 					{
 						// Check if we can put this word on the current line without making it longer than 'Wrap'
 						if (CharPos + WordLen > Wrap)
 						{
 							// No it won't fit... so emit [NewLine][QuoteStr][Prefix]
 							Pipe.Write(NewLine, NewLineLen);
 							if (QuoteStr)
 								Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 							Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 							
 							// Now we are ready to write more words...
 							CharPos = QuoteChars + PrefixChars;
 						}
 						// else Yes it fits...
 					}
 					
 					// Write out the word...
 					if (IsHtml && Strnchr(Start, '<', WordLen))
 					{
 						for (auto *c = Start; c < Start + WordLen; c++)
 							if (*c == '<')
 								Pipe.Print("&lt;");
 							else if (*c == '>')
 								Pipe.Print("&gt;");
 							else
 								Pipe.Write(c, sizeof(*c));
 					}
 					else
 						Pipe.Write(Start, WordLen * sizeof(*Start));
 					CharPos += WordLen;
 					
 					Start = End;
 				}
 				
 				if (HardNewLine)
 				{
 					Pipe.Write(NewLine, NewLineLen);
 					if (QuoteStr)
 						Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 					Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 					CharPos = QuoteChars + PrefixChars;
 				}
 			}
 
 			// Finish the paragraph
 			Pipe.Write(NewLine, NewLineLen);
 		}		
 	}
 }
 
 void Mail::WrapAndQuote(LStringPipe &p, const char *Quote, int WrapAt)
 {
 	LString Mem;
 	LAutoString Cp;
 	if (!ValidStr(GetBody()))
 		Mem = HtmlToText(GetHtml(), GetHtmlCharset());
 	else
 		Cp = GetCharSet();
 	
 	::WrapAndQuote(p, Quote, WrapAt > 0 ? WrapAt : 76, Mem ? Mem.Get() : GetBody(), Cp);
 }
 
 LAutoString Mail::GetSig(bool HtmlVersion, ScribeAccount *Account)
 {
 	LAutoString r;
 	LVariant Xml;
 		
 	if (!Account)
 		Account = GetAccountSentTo();
 
 	if (Account)
 	{
 		if (HtmlVersion)
 			Xml = Account->Identity.HtmlSig();
 		else
 			Xml = Account->Identity.TextSig();
 	}
 	
 	if (Xml.Str())
 	{
 		r = App->ProcessSig(this, Xml.Str(), HtmlVersion ? sTextHtml : sTextPlain);
 	}
 
 	return r;
 }
 
 void Mail::ProcessTextForResponse(Mail *From, LOptionsFile *Options, ScribeAccount *Account)
 {
 	LStringPipe Temp;
 	LVariant QuoteStr, Quote, WrapAt;
 	Options->GetValue(OPT_QuoteReply, Quote);
 	Options->GetValue(OPT_WrapAtColumn, WrapAt);
 	Options->GetValue(OPT_QuoteReplyStr, QuoteStr);
 
 	From->WrapAndQuote(Temp, Quote.CastInt32() ? QuoteStr.Str() : NULL, WrapAt.CastInt32());
 	
 	LAutoString s = From->GetSig(false, Account);
 	if (s)
 		Temp.Write(s, strlen(s));
 
 	s.Reset(Temp.NewStr());
 	SetBody(s);
 	SetBodyCharset("utf-8");
 }
 
 ScribeAccount *Mail::GetAccountSentTo()
 {
 	ScribeAccount *Account = App->GetAccountById(GetAccountId());
 	if (!Account)
 	{
 		// Older style lookup based on to address...
 		for (auto a : *App->GetAccounts())
 		{
 			LVariant e = a->Identity.Email();
 			if (ValidStr(e.Str()))
 			{
 				for (LDataPropI *t=GetTo()->First(); t; t=GetTo()->Next())
 				{
 					auto Addr = t->GetStr(FIELD_EMAIL);
 					if (ValidStr(Addr))
 					{
 						if (_stricmp(Addr, e.Str()) == 0)
 						{
 							Account = a;
 							break;
 						}
 					}
 				}
 			}
 		}
 	}
 	return Account;
 }
 
 void Mail::OnReceipt(Mail *m)
 {
 	if (m)
 	{
 		SetFlags(MAIL_CREATED | MAIL_READY_TO_SEND);
 
 		ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 		if (!MatchedAccount)
 		{
 			MatchedAccount = App->GetAccounts()->ItemAt(App->GetCurrentIdentity());
 		}
 		if (MatchedAccount)
 		{
 			GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		}
 
 		char Sent[64];
 		m->GetDateReceived()->Get(Sent, sizeof(Sent));
 
 		char Read[64];
 		LDateTime t;
 		t.SetNow();
 		t.Get(Read, sizeof(Read));
 
 		char s[256];
 		sprintf_s(s, sizeof(s), 
 				LLoadString(IDS_RECEIPT_BODY),
 				GetFrom()->GetStr(FIELD_NAME),
 				GetFrom()->GetStr(FIELD_EMAIL),
 				Sent,
 				m->GetSubject(),
 				Read);
 		SetBody(s);
 
 		sprintf_s(s, sizeof(s), "Read: %s", m->GetSubject() ? m->GetSubject() : (char*)"");
 		SetSubject(s);
 	}
 }
 
 LString Mail::GetMailRef()
 {
 	LString Ret;
 
 	if (auto MsgId = GetMessageId(true))
 	{
 	    LAssert(!strchr(MsgId, '\n'));
 	    
 		ScribeFolder *Fld = GetFolder();
 		LString FldPath;
 		if (Fld)
 		    FldPath = Fld->GetPath();
 
 		if (FldPath)
 		{
 			LUri u;
 			auto a = u.EncodeStr(MsgId, MsgIdEncodeChars);
 			if (a)
 				Ret.Printf("%s/%s", FldPath.Get(), a.Get());
 		}
 		else
 		{
 			Ret = MsgId;
 		}
 	}
 	
 	return Ret;
 }
 
 void Mail::OnReply(Mail *m, bool All, bool MarkOriginal)
 {
 	if (!m)
 	    return;
 
 	SetWillDirty(false);
 
 	LVariant ReplyAllSetting = MAIL_ADDR_TO;
 	if (All)
 	{
 		App->GetOptions()->GetValue(OPT_DefaultReplyAllSetting, ReplyAllSetting);
 	}
 		
 	if (MarkOriginal)
 	{
 		// source email has been replyed to
 		m->SetFlags(m->GetFlags() | MAIL_READ);
 	}
 
 	// this email is ready to send
 	SetFlags(GetFlags() | MAIL_READ | MAIL_CREATED);
 
 	LDataPropI *ToAddr = GetTo()->Create(GetObject()->GetStore());
 	if (ToAddr)
 	{
 		bool CopyStatus;
 		auto From = m->GetFrom();
 		auto Reply = m->GetReply();
 		auto ReplyTo = Reply->GetStr(FIELD_EMAIL);
 		if (ReplyTo)
 			CopyStatus = ToAddr->CopyProps(*Reply);
 		else
 			CopyStatus = ToAddr->CopyProps(*From);
 		LAssert(CopyStatus);
 
 		ToAddr->SetInt(FIELD_CC, ReplyAllSetting.CastInt32());
 		GetTo()->Insert(ToAddr);
 	}
 
 	LVariant UserName, EmailAddr, ReplyTo;
 
 	ScribeAccount *a = App->GetCurrentAccount();
 	if (a)
 	{
 		UserName = a->Identity.Name();
 		EmailAddr = a->Identity.Email();
 		ReplyTo = a->Identity.ReplyTo();
 	}
 	else LAssert(!"No current account.");
 
 	if (All)
 	{
 		for (LDataPropI *a = m->GetTo()->First(); a; a = m->GetTo()->Next())
 		{
 			bool Same = App->IsMyEmail(a->GetStr(FIELD_EMAIL));
 			
 			bool AlreadyThere = false;
 			for (LDataPropI *r = GetTo()->First(); r; r=GetTo()->Next())
 			{
 				if (_stricmp(r->GetStr(FIELD_EMAIL), a->GetStr(FIELD_EMAIL)) == 0)
 				{
 					AlreadyThere = true;
 					break;
 				}
 			}
 
 			if (!Same && !AlreadyThere)
 			{
 				LDataPropI *New = GetTo()->Create(GetObject()->GetStore());
 				if (New)
 				{
 					New->SetInt(FIELD_CC, ReplyAllSetting.CastInt32());
 					New->SetStr(FIELD_EMAIL, a->GetStr(FIELD_EMAIL));
 					New->SetStr(FIELD_NAME, a->GetStr(FIELD_NAME));
 					GetTo()->Insert(New);
 				}
 			}
 		}
 	}
 
 	ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 	if (MatchedAccount &&
 		MatchedAccount->Identity.Email().Str())
 	{
 		GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 		GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		
 		ReplyTo = MatchedAccount->Identity.ReplyTo();
 		if (ReplyTo.Str())
 		{
 			GetReply()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 	else
 	{
 		GetFrom()->SetStr(FIELD_NAME, UserName.Str());
 		GetFrom()->SetStr(FIELD_EMAIL, EmailAddr.Str());
 
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, UserName.Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 
 	char Re[32];
 	sprintf_s(Re, sizeof(Re), "%s:", LLoadString(IDS_REPLY_PREFIX));
 
 	auto SrcSubject = (m->GetSubject()) ? m->GetSubject() : "";
 	if (_strnicmp(SrcSubject, Re, strlen(Re)) != 0)
 	{
 		size_t Len = strlen(SrcSubject) + strlen(Re) + 2;
 		char *s = new char[Len];
 		if (s)
 		{
 			sprintf_s(s, Len, "%s %s", Re, SrcSubject);
 			SetSubject(s);
 			DeleteArray(s);
 		}
 	}
 	else
 	{
 		SetSubject(m->GetSubject());
 	}
 
 	auto EditMimeType = App->EditCtrlMimeType();
 	auto Xml = App->GetReplyXml(EditMimeType);
 	if (ValidStr(Xml))
 	{
 		RemoveReturns(Xml);
 		PreviousMail = m;
 
 		LString Body = App->ProcessReplyForwardTemplate(m, this, Xml, Cursor, EditMimeType);
 		
 		LVariant EditCtrl;
 		if (App->GetOptions()->GetValue(OPT_EditControl, EditCtrl) &&
 			EditCtrl.CastInt32())
 		{
 			SetHtml(Body);
 		}
 		else
 		{			
 			SetBody(Body);
 			SetBodyCharset("utf-8");
 		}
 
 		PreviousMail = 0;
 	}
 	else
 	{
 		ProcessTextForResponse(m, App->GetOptions(), MatchedAccount);
 	}
 
 	// Reference
 	SetReferences(0);
 	auto MailRef = m->GetMailRef();
 	if (MailRef)
 		SetReferences(MailRef);
 
 	GetMessageId(true);
 	SetWillDirty(true);
 
 	ScribeFolder *Folder = m->GetFolder();
 	if (Folder && Folder->IsPublicFolders())
 	{
 		SetParentFolder(Folder);
 	}
 }
 
 bool Mail::OnForward(Mail *m, bool MarkOriginal, int WithAttachments)
 {
 	if (!m)
 	{
 		LAssert(!"No mail object.");
 		LgiTrace("%s:%i - No mail object.\n", _FL);
 		return false;
 	}
 
 	// ask about attachments?
 	List<Attachment> Attach;
 	if (m->GetAttachments(&Attach) &&
 		Attach.Length() > 0)
 	{
 		if (WithAttachments < 0)
 		{
 			LView *p = (m->Ui)?(LView*)m->Ui:(LView*)App;
 			int Result = LgiMsg(p, LLoadString(IDS_ASK_FORWARD_ATTACHMENTS), AppName, MB_YESNOCANCEL);
 			if (Result == IDYES)
 			{
 				WithAttachments = 1;
 			}
 			else if (Result == IDCANCEL)
 			{
 				return false;
 			}
 		}
 	}
 
 	if (MarkOriginal)
 	{
 		// source email has been forwarded
 		auto MailRef = m->GetMailRef();
 		if (MailRef)
 			SetFwdMsgId(MailRef);
 	}
 
 	// this email is ready to send
 	SetFlags(GetFlags() | MAIL_CREATED);
 	SetDirty();
 
 	LVariant UserName, EmailAddr, ReplyTo;
 	ScribeAccount *a = App->GetCurrentAccount();
 	if (a)
 	{
 		UserName = a->Identity.Name();
 		EmailAddr = a->Identity.Email();
 		ReplyTo = a->Identity.ReplyTo();
 	}
 	else LAssert(!"No current account.");
 
 	ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 	if (MatchedAccount &&
 		MatchedAccount->Identity.Email().Str())
 	{
 		GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 		GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		
 		ReplyTo = MatchedAccount->Identity.ReplyTo();
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 	else
 	{
 		GetFrom()->SetStr(FIELD_NAME, UserName.Str());
 		GetFrom()->SetStr(FIELD_EMAIL, EmailAddr.Str());
 
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, UserName.Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 
 	SetBodyCharset(0);
 
 	char PostFix[32];
 	sprintf_s(PostFix, sizeof(PostFix), "%s:", LLoadString(IDS_FORWARD_PREFIX));
 
 	auto SrcSubject = (m->GetSubject()) ? m->GetSubject() : "";
 	if (_strnicmp(SrcSubject, PostFix, strlen(PostFix)) != 0)
 	{
 		size_t Len = strlen(SrcSubject) + strlen(PostFix) + 2;
 		char *s = new char[Len];
 		if (s)
 		{
 			sprintf_s(s, Len, "%s %s", PostFix, SrcSubject);
 			SetSubject(s);
 			DeleteArray(s);
 		}
 	}
 	else
 	{
 		SetSubject(m->GetSubject());
 	}
 
 	// Wrap/Quote/Sig the text...
 	const char *EditMimeType = App->EditCtrlMimeType();
 	LAutoString Xml = App->GetForwardXml(EditMimeType);
 	if (ValidStr(Xml))
 	{
 		RemoveReturns(Xml);
 		PreviousMail = m;
 		
 		LString Body = App->ProcessReplyForwardTemplate(m, this, Xml, Cursor, EditMimeType);
 		
 		LVariant EditCtrl;
 		if (App->GetOptions()->GetValue(OPT_EditControl, EditCtrl) &&
 			EditCtrl.CastInt32())
 		{
 			SetHtml(Body);
 		}
 		else
 		{			
 			SetBody(Body);
 			SetBodyCharset("utf-8");
 		}
 
 		PreviousMail = 0;
 	}
 	else
 	{
 		ProcessTextForResponse(m, App->GetOptions(), MatchedAccount);
 	}
 
 	// Attachments
 	if (WithAttachments > 0)
 		for (auto From: Attach)
 			AttachFile(new Attachment(App, From));
 
 	// Set MsgId
 	GetMessageId(true);
 
 	// Unless the user edits the message it shouldn't be made dirty.
 	SetDirty(false);
 
 	return true;
 }
 
 bool Mail::OnBounce(Mail *m, bool MarkOriginal, int WithAttachments)
 {
 	if (m)
 	{
 		if (MarkOriginal)
 		{
 			// source email has been forwarded
 			auto MsgId = m->GetMessageId(true);
 			if (MsgId)
 			{
 				ScribeFolder *Fld = m->GetFolder();
 				LString FldPath;
 				if (Fld)
 				    FldPath = Fld->GetPath();
 
 				if (FldPath)
 				{
 					LUri u;
 					LString a = u.EncodeStr(MsgId, MsgIdEncodeChars);
 					if (a)
 					{
 						LString p;
 						p.Printf("%s/%s", FldPath.Get(), a.Get());
 						SetBounceMsgId(p);
 					}
 				}
 				else
 				{
 					SetBounceMsgId(MsgId);
 				}
 			}
 			else m->SetFlags(m->GetFlags() | MAIL_BOUNCED);
 		}
 		
 		*this = (Thing&)*m;
 
 		GetTo()->DeleteObjects();
 		SetFlags(MAIL_READ | MAIL_BOUNCE);
 		return true;
 	}
 	
 	return false;
 }
 
 void Mail::OnMeasure(LPoint *Info)
 {
 	LListItem::OnMeasure(Info);
 
 	if (PreviewLines &&
 		!(GetFlags() & MAIL_READ) &&
 		(!GetObject() || !GetObject()->GetInt(FIELD_DONT_SHOW_PREVIEW)))
 	{
     	LFont *PreviewFont = App->GetPreviewFont();
 		Info->y += PreviewFont ? PreviewFont->GetHeight() << 1 : 28;
 	}
 }
 
 void Mail::OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c)
 {
 	int Field = 0;
 	if (FieldArray.Length())
 	{
 		Field = i >= 0 && i < (int)FieldArray.Length() ? FieldArray[i] : 0;
 	}
 	else if (i >= 0 && i < CountOf(DefaultMailFields))
 	{
 		Field = DefaultMailFields[i];
 	}
 
 	if (Container &&
 		i >= 0 &&
 		Field == FIELD_SUBJECT)
 	{
 		LFont *f = Parent->GetFont();
 		auto Subj = GetSubject();
 
 		if (Container)
 		{
 			// Container needs to paint the subject...
 			Container->OnPaint(Ctx.pDC, Ctx, c, Ctx.Fore, Ctx.Back, f?f:LSysFont, Subj);
 		}
 	}
 	else
 	{
 		LListItem::OnPaintColumn(Ctx, i, c);
 
 		if (i >= 0 && App->GetIconImgList())
 		{
 			int Icon = -1;
 			
 			switch (Field)
 			{
 				case FIELD_PRIORITY:
 				{
 					switch (GetPriority())
 					{
 						case MAIL_PRIORITY_HIGH:
 						{
 							Icon = ICON_PRIORITY_HIGH;
 							break;
 						}
 						case MAIL_PRIORITY_LOW:
 						{
 							Icon = ICON_PRIORITY_LOW;
 							break;
 						}
 						default:
 							break;
 					}
 
 					break;
 				}
 				case FIELD_FLAGS:
 				{
 					if (GetFlags() & MAIL_BOUNCED)
 					{
 						Icon = ICON_FLAGS_BOUNCE;
 					}
 					else if (GetFlags() & MAIL_REPLIED)
 					{
 						Icon = ICON_FLAGS_REPLY;
 					}
 					else if (GetFlags() & MAIL_FORWARDED)
 					{
 						Icon = ICON_FLAGS_FORWARD;
 					}
 					break;
 				}
 				default:
 					break;
 			}
 
 			if (Icon >= 0)
 			{
 				LRect *b = App->GetIconImgList()->GetBounds();
 				if (b)
 				{
 					b += Icon;
 					int x = Ctx.x1 + ((Ctx.X()-b->X())/2) - b->x1;
 					int y = Ctx.y1 + ((MIN(Ctx.Y(), 16)-b->Y())/2) - b->y1;
 
 					LColour Back(Ctx.Back);
 					App->GetIconImgList()->Draw(Ctx.pDC, x, y, Icon, Back);
 				}
 			}
 		}
 	}
 }
 
 void Mail::OnPaint(LItem::ItemPaintCtx &InCtx)
 {
 	LItem::ItemPaintCtx Ctx = InCtx;
 	
 	int64_t MarkCol = GetMarkColour();
 	if (MarkCol > 0)
 	{
         LColour Col((uint32_t)MarkCol, 32);
         LColour CtxBack(Ctx.Back);
 		LColour Mixed = Col.Mix(CtxBack, MarkColourMix);
         Ctx.Back = Mixed;
 	}
 
 	if (Parent) ((ThingList*)Parent)->CurrentMail = this;
 	LListItem::OnPaint(Ctx);
 	if (Parent) ((ThingList*)Parent)->CurrentMail = 0;
 	LFont *PreviewFont = App->GetPreviewFont();
 	LFont *ColumnFont = Parent && Parent->GetFont() ? Parent->GetFont() : LSysFont;
 
 	if (Parent &&
 		PreviewLines &&
 		PreviewFont &&
 		ColumnFont &&
 		GetObject() &&
 		!GetObject()->GetInt(FIELD_DONT_SHOW_PREVIEW) &&
 		!(GetFlags() & MAIL_READ))
 	{
 		int y = ColumnFont->GetHeight() + 2;
 		int Space = (Ctx.Y() - y) >> 1;
 		int Line = MAX(PreviewFont->GetHeight(), Space);
 		PreviewFont->Transparent(true);
 
 		// Setup
 		if (PreviewCache.Length() == 0 || abs(PreviewCacheX - Ctx.X()) > 20)
 		{
 			PreviewCache.DeleteObjects();
 			PreviewCacheX = Ctx.X();
 
 			LVariant v;
 			if (GetValue("BodyAsText[1024]", v) &&
 				v.Str())
 			{
 				char16 *Base = Utf8ToWide(v.Str());
 				char16 *Txt = Base;
 				int i;
 				for (i=0; Txt[i]; i++)
 				{
 					if (Txt[i] < ' ')
 						Txt[i] = ' ';
 				}
 
 				auto TxtLen = StrlenW(Txt);
 				for (i=0; Txt && *Txt && i<2; i++)
 				{
 					LDisplayString *Temp = new LDisplayString(PreviewFont, Txt, MIN(1024, TxtLen));
 					if (Temp)
 					{
 						int W = Ctx.X()-18;
 						ssize_t Cx = Temp->CharAt(W);
 						if (Cx > 0 && Cx <= TxtLen)
 						{
 							LDisplayString *d = new LDisplayString(PreviewFont, Txt, Cx);
 							if (d)
 							{
 								PreviewCache.Insert(d);
 							}
 							DeleteObj(Temp);
 							Txt += Cx; // LSeekUtf8
 							TxtLen -= Cx;
 						}
 						else break;
 					}
 				}
 				DeleteArray(Base);
 			}
 		}
 
 		// Display
 		LColour PreviewCol(App->GetColour(L_MAIL_PREVIEW));
 		if (Select())
 		{
 			int GreyPrev = PreviewCol.GetGray();
 			int GreyBack = Ctx.Back.GetGray();
 			
 			int d = GreyPrev - GreyBack;
 			if (d < 0) d = -d;
 			if (d < 128)
 			{
 				// too near
 				PreviewFont->Colour(Ctx.Fore, Ctx.Back);
 			}
 			else
 			{
 				// ok
 				PreviewFont->Colour(PreviewCol, Ctx.Back);
 			}
 		}
 		else
 		{
 			PreviewFont->Colour(PreviewCol, Ctx.Back);
 		}
 
 		for (auto p: PreviewCache)
 		{
 			p->Draw(Ctx.pDC, Ctx.x1+16, Ctx.y1+y, 0);
 			y += Line;
 		}
 	}
 }
 
 bool Mail::GetFormats(bool Export, LString::Array &MimeTypes)
 {
 	if (Export)
 	{
 		MimeTypes.Add("text/plain");
 		MimeTypes.Add(sMimeMbox);
 	}
 
 	MimeTypes.Add(sMimeMessage);
 	return MimeTypes.Length() > 0;
 }
 
 Thing::IoProgress Mail::Import(IoProgressImplArgs)
 {
 	if (!mimeType)
 		IoProgressError("No mime type.");
 
 	if (Stricmp(mimeType, sMimeMessage))
 		IoProgressNotImpl();
 
 	// Single email..
 	OnAfterReceive(stream);
 
 	int Flags = GetFlags();
 	Flags &= ~MAIL_CREATED;
 	Flags |= MAIL_READ;
 	SetFlags(Flags);
 
 	Update();
 
 	IoProgressSuccess();
 }
 
 #define TIMEOUT_OBJECT_LOAD		20000
 
 Thing::IoProgress Mail::Export(IoProgressImplArgs)
 {
 	if (!mimeType)	
 		IoProgressError("No mimetype.");
 
 	if (!Stricmp(mimeType, "text/plain"))
 	{
 		LStringPipe Buf;
 		char Str[256];
 		char Eol[] = EOL_SEQUENCE;
 
 		// Addressee
 		if (GetFlags() & MAIL_CREATED)
 		{
 			Buf.Push("To:");
 			for (LDataPropI *a=GetTo()->First(); a; a=GetTo()->Next())
 			{
 				sprintf_s(Str, sizeof(Str), "\t%s <%s>%s", a->GetStr(FIELD_NAME), a->GetStr(FIELD_EMAIL), Eol);
 				Buf.Push(Str);
 			}
 		}
 		else
 		{
 			sprintf_s(Str, sizeof(Str), "From: %s <%s>%s", GetFrom()->GetStr(FIELD_NAME), GetFrom()->GetStr(FIELD_EMAIL), Eol);
 			Buf.Push(Str);
 		}
 
 		// Subject
 		sprintf_s(Str, sizeof(Str), "Subject: %s%s", GetSubject(), Eol);
 		Buf.Push(Str);
 
 		// Sent date
 		if (GetDateSent()->Year())
 		{
 			int ch = sprintf_s(Str, sizeof(Str), "Sent Date: ");
 			GetDateSent()->Get(Str+ch, sizeof(Str)-ch);
 		}
 		else
 		{
 			int ch = sprintf_s(Str, sizeof(Str), "Date Received: ");
 			GetDateReceived()->Get(Str+ch, sizeof(Str)-ch);
 		}
 		strcat(Str, Eol);
 		Buf.Push(Str);
 
 		// Body
 		Buf.Push(Eol);
 		Buf.Push(GetBody());
 
 		// Write the output
 		auto s = Buf.NewLStr();
 		if (!s)
 			IoProgressError("No data to output.");
 		stream->Write(s.Get(), s.Length());
 
 		IoProgressSuccess();
 	}
 	else if (!Stricmp(mimeType, sMimeMbox))
 	{
 		char Temp[256];
 		
 		// generate from header
 		sprintf_s(Temp, sizeof(Temp), "From %s ", GetFrom()->GetStr(FIELD_EMAIL));
 		struct tm Ft;
 		
 		ZeroObj(Ft);
 		LDateTime Rec = *GetDateReceived();
 		if (!Rec.Year())
 		    Rec.SetNow();
 		Ft.tm_sec = Rec.Seconds();			/* seconds after the minute - [0,59] */
 		Ft.tm_min = Rec.Minutes();			/* minutes after the hour - [0,59] */
 		Ft.tm_hour = Rec.Hours();			/* hours since midnight - [0,23] */
 		Ft.tm_mday = Rec.Day();			/* day of the month - [1,31] */
 		Ft.tm_mon = Rec.Month() - 1;		/* months since January - [0,11] */
 		Ft.tm_year = Rec.Year() - 1900;    /* years since 1900 */
 		Ft.tm_wday = Rec.DayOfWeek();
 
 		strftime(Temp+strlen(Temp), MAX_NAME_SIZE, "%a %b %d %H:%M:%S %Y", &Ft);
 		strcat(Temp, "\r\n");
 		
 		// write mail
 		stream->Write(Temp, strlen(Temp));
 		auto Status = Export(stream, sMimeMessage, [cb](auto io, auto stream)
 		{
 			if (io->status == Store3Success)
 				stream->Write((char*)"\r\n.\r\n", 2);
 			else if (io->status == Store3Delayed)
 				LAssert(!"We should never get delayed here... it's the callback!");
 
 			if (cb)
 				cb(io, stream);
 		});
 
 		return Status;
 	}
 	else if (!Stricmp(mimeType, sMimeMessage))
 	{
 		// This function can't be asynchronous, it must complete with UI or waiting for a callback.
 		// Because it is used by the drag and drop system. Which won't wait.
 		auto state = GetLoaded();
 		if (state != Store3Loaded)
 			IoProgressError("Mail not loaded.");
 
 		if (!GetObject())
 			IoProgressError("No store object.");
 		
 		auto Data = GetObject()->GetStream(_FL);
 		if (!Data)
 			IoProgressError("Mail for export has no data.");
 		
 		Data->SetPos(0);
 		LCopyStreamer Cp(512<<10);
 		if (Cp.Copy(Data, stream) <= 0)
 			IoProgressError("Mail copy stream failed.");
 
 		IoProgressSuccess();
 	}
 
 	IoProgressNotImpl();
 }
 
 char *Mail::GetNewText(int Max, const char *AsCp)
 {
 	LAutoString CharSet = GetCharSet();
 	char *Txt = 0;
 
 	// This limits the preview of the text to
 	// the first 64kb, which is reasonable.
 	int Len = Max > 0 ? Strnlen(GetBody(), Max) : -1;
 
 	// Convert or allocate the text.
 	if (CharSet)
 	{
 		Txt = (char*)LNewConvertCp(AsCp, GetBody(), GetBodyCharset(), Len);
 	}
 	else
 	{
 		Txt = NewStr(GetBody(), Len);
 	}
 
 	return Txt;
 }
 
 LAutoString Mail::GetCharSet()
 {
 	LAutoString Status;
 	LAutoString ContentType;
 
 	if (GetBodyCharset())
 	{
 		// If the charset has a stray colon...
 		char *Colon = strchr(GetBodyCharset(), ';');
 		// Kill it.
 		if (Colon) *Colon = 0;
 		
 		// Copy the string..
 		Status.Reset(NewStr(GetBodyCharset()));
 	}
 
 	if (!GetBodyCharset())
 	{
 		ContentType.Reset(InetGetHeaderField(GetInternetHeader(), "Content-Type"));
 		if (ContentType)
 		{
 			char *CharSet = stristr(ContentType, "charset=");
 			if (CharSet)
 			{
 				CharSet += 8;
 				if (*CharSet)
 				{
 					if (strchr("\"\'", *CharSet))
 					{
 						char Delim = *CharSet++;
 						char *e = CharSet;
 						
 						while (*e && *e != Delim)
 						{
 							e++;
 						}
 						Status.Reset(NewStr(CharSet, e - CharSet));
 					}
 					else
 					{
 						char *e = CharSet;
 						while (*e && (IsDigit(*e) || IsAlpha(*e) || strchr("-_", *e)))
 						{
 							e++;
 						}
 						Status.Reset(NewStr(CharSet, e - CharSet));
 					}
 				}
 			}
 		}
 
 		/*
 		// If it's not a valid charset...
 		if (!LGetCsInfo(Status))
 		{
 			// Then kill it.
 			Status.Reset();
 			if (GetBodyCharset())
 			{
 				SetBodyCharset(0);
 				SetDirty();
 			}
 		}
 		*/
 	}
 
 	return Status;
 }
 
 /* Old Body Printing Code
 
 	int Lines = 0;
 	char *n;
 	for (n=Body.Str(); n && *n; n++)
 	{
 		if (*n == '\n') Lines++;
 	}
 
 	char *c = Body.Str();
 	if (c)
 	{
 		c = WrapLines(c, c ? strlen(c) : 0, 76);
 
 		Lines = 0;
 		for (n=c; *n; n++)
 		{
 			if (*n == '\n') Lines++;
 		}
 
 		while (c && *c)
 		{
 			if (Cy + Line > r.y2)
 			{
 				pDC->EndPage();
 
 				if (Window->GetMaxPages() > 0 &&
 					++Page >= Window->GetMaxPages())
 				{
 					break;
 				}
 
 				pDC->StartPage();
 				Cy = 0;
 			}
 
 			char *Eol = strchr(c, '\n');
 			int Len = 0;
 			int Ret = 0;
 			if (Eol)
 			{
 				Len = (int) Eol - (int) c;
 				if (Len > 0 && c[Len-1] == '\r')
 				{
 					Len--;
 					Ret = 1;
 				}
 			}
 			else
 			{
 				Len = strlen(c);
 			}
 
 			MailFont->Text(pDC, r.x1, Cy, c, Len);
 			Cy += Line;
 			c += Len + Ret;
 			if (*c == '\n') c++;
 		}
 	}
 */
 
 int Mail::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_TEXT:
 		{
 			LDocView *Doc = dynamic_cast<LDocView*>(Ctrl);
 			if (Doc)
 			{
 				if (n.Type == LNotifyShowImagesChanged)
 				{
 					if (Doc->GetLoadImages() ^ TestFlag(GetFlags(), MAIL_SHOW_IMAGES))
 					{
 						if (Doc->GetLoadImages())
 						{
 							SetFlags(GetFlags() | MAIL_SHOW_IMAGES);
 						}
 						else
 						{
 							SetFlags(GetFlags() & ~MAIL_SHOW_IMAGES);
 						}
 					}
 				}
 
 				if (n.Type == LNotifyFixedWidthChanged)
 				{
 					bool DocFixed = Doc->GetFixedWidthFont();
 					bool MailFixed = TestFlag(GetFlags(), MAIL_FIXED_WIDTH_FONT);
 
 					if (DocFixed ^ MailFixed)
 					{
 						if (Doc->GetFixedWidthFont())
 						{
 							SetFlags(GetFlags() | MAIL_FIXED_WIDTH_FONT);
 						}
 						else
 						{
 							SetFlags(GetFlags() & ~MAIL_FIXED_WIDTH_FONT);
 						}
 					}
 				}
 
 				if (n.Type == LNotifyCharsetChanged &&
 					dynamic_cast<Html1::LHtml*>(Doc))
 				{
 					char s[256];
 					sprintf_s(s, sizeof(s), ">%s", Doc->GetCharset());
 					SetHtmlCharset(s);
 				}
 			}
 			break;
 		}
 	}
 
 	return 0;
 }
 
 void Mail::OnPrintHeaders(ScribePrintContext &Context)
 {
 	char Str[256];
 
 	// print document
 	LDrawListSurface *Page = Context.Pages.Last();
 	
 	int Line = Context.AppFont->GetHeight();
 	Page->SetFont(Context.AppFont);
     LDisplayString *Ds = Context.Text(LLoadString(IDS_MAIL_MESSAGE));
 	Context.CurrentY += Line;
 
 	LDataPropI *Ad = GetTo()->First();
 	if (Ad)
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(FIELD_TO));
 
         Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		for (; Ad; Ad = GetTo()->Next())
 		{
 			if (Ad->GetStr(FIELD_EMAIL) && Ad->GetStr(FIELD_NAME))
 			{
 				sprintf_s(Str, sizeof(Str), "%s <%s>", Ad->GetStr(FIELD_NAME), Ad->GetStr(FIELD_EMAIL));
 			}
 			else if (Ad->GetStr(FIELD_EMAIL))
 			{
 				strcpy_s(Str, sizeof(Str), Ad->GetStr(FIELD_EMAIL));
 			}
 			else if (Ad->GetStr(FIELD_EMAIL))
 			{
 				strcpy_s(Str, sizeof(Str), Ad->GetStr(FIELD_EMAIL));
 			}
 			else continue;
 
 			Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 			Context.CurrentY += Ds->Y();
 		}
 	}
 
 	if (GetFrom()->GetStr(FIELD_EMAIL) || GetFrom()->GetStr(FIELD_NAME))
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(FIELD_FROM));
 
         Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		if (GetFrom()->GetStr(FIELD_EMAIL) && GetFrom()->GetStr(FIELD_NAME))
 		{
 			sprintf_s(Str, sizeof(Str), "%s <%s>", GetFrom()->GetStr(FIELD_NAME), GetFrom()->GetStr(FIELD_EMAIL));
 		}
 		else if (GetFrom()->GetStr(FIELD_EMAIL))
 		{
 			strcpy_s(Str, sizeof(Str), GetFrom()->GetStr(FIELD_EMAIL));
 		}
 		else if (GetFrom()->GetStr(FIELD_NAME))
 		{
 			strcpy_s(Str, sizeof(Str), GetFrom()->GetStr(FIELD_NAME));
 		}
 		else Str[0] = 0;
 
 		Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 		Context.CurrentY += Ds->Y();
 	}
 	
 	{
 		// Subject
 		LString s;
 		const char *Subj = GetSubject();
 		s.Printf("%s: %s", LLoadString(FIELD_SUBJECT), Subj?Subj:"");
 		Context.Text(s);
 	}
 
 	{
 		// Date
 		LString s;
 		GetDateSent()->Get(Str, sizeof(Str));
 		s.Printf("%s: %s", LLoadString(IDS_DATE), Str);
 		Context.Text(s);
 	}
 
 	// attachment list...
 	List<Attachment> Attached;
 	if (GetAttachments(&Attached) &&
 		Attached.Length() > 0)
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(IDS_ATTACHMENTS));
 		Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		for (auto a: Attached)
 		{
 			char Size[32];
 			LFormatSize(Size, sizeof(Size), a->GetSize());
 			sprintf_s(Str, sizeof(Str), "%s (%s)", a->GetName(), Size);
 			Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 			Context.CurrentY += Ds->Y();
 		}
 	}
 
 	// separator line
 	LRect Sep(Context.MarginPx.x1, Context.CurrentY + (Line * 5 / 10), Context.MarginPx.x2, Context.CurrentY + (Line * 6 / 10));
 	Page->Rectangle(&Sep);
 	Context.CurrentY += Line;
 }
 
 void Mail::OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages)
 {
 	// Text printing
 	LDrawListSurface *Page = Context.Pages.Last();
 	LVariant Body;
 	if (!GetVariant("BodyAsText", Body) || !Body.Str())
 	{
 		LgiTrace("%s:%i - No content to print.\n", _FL);
 		return;
 	}
 
 	LAutoWString w(Utf8ToWide(Body.Str()));
 	if (!w)
 	{
 		LgiTrace("%s:%i - Utf8ToWide failed.\n", _FL);
 		return;
 	}
 
 	Page->SetFont(Context.MailFont);
 	
 	for (char16 *s = w; s && *s; )
 	{
 		// Find end of line..
 		char16 *n = StrchrW(s, '\n');
 		if (!n) n = s + StrlenW(s);
 		ssize_t LineLen = n - s;
 
 		// Find how many characters will fit on the page
 		ssize_t Fit = 0;
 		if (n > s)
 		{
 			LDisplayString a(Context.MailFont, s, MIN(LineLen, 1024));
 			Fit = a.CharAt(Context.MarginPx.X());
 		}
 		if (Fit < 0)
 		{
 			break;
 		}
 
 		char16 *e = s + Fit;
 
 		if (e < n)
 		{
 			// The whole line doesn't fit on the page...
 			// Find the best breaking opportunity before that...
 			#define ExtraBreak(c) (	( (c) >= 0x3040 && (c) <= 0x30FF ) ||	\
 									( (c) >= 0x3300 && (c) <= 0x9FAF )		\
 								)
 			char16 *StartE = e;
 			while (e > s)
 			{
 				if (e[-1] == ' ' || ExtraBreak(e[-1]))
 				{
 					break;
 				}
 				e--;
 			}
 			if (e == s)
 			{
 				e = StartE;
 			}
 		}
 
 		// Output the segment of text
 		bool HasRet = e > s ? e[-1] == '\r' : false;
 		LString Str(s, (e - s) - (HasRet ? 1 : 0));
 		Context.Text(Str);
 
 		// Update the pointers
 		s = e;
 		if (*s == '\n') s++;
 	}
 }
 
 /// \returns the number of pages printed
 int Mail::OnPrintHtml(ScribePrintContext &Context, LPrintPageRanges &Pages, LSurface *RenderedHtml)
 {
 	// HTML printing...
 	LDrawListSurface *Page = Context.Pages.Last();
 
 	// Work out the scaling from memory bitmap to page..
 	double MemScale = (double) Context.pDC->X() / (double) RenderedHtml->X();
 	
 	// Now paint the bitmap onto the existing page
 	int PageIdx = 0, Printed = 0;
 	for (int y = 0; y < RenderedHtml->Y(); PageIdx++)
 	{
 		if (Pages.InRanges(PageIdx))
 		{
 			// Work out how much bitmap we can paint onto the current page...
 			int PageRemaining = Context.MarginPx.Y() - Context.CurrentY;
 			int MemPaint = (int) (PageRemaining / MemScale);
 
 			// This is how much of the memory context we can fit on the page
 			LRect MemRect(0, y, RenderedHtml->X()-1, y + MemPaint - 1);
 			LRect Bnds = RenderedHtml->Bounds();
 			MemRect.Bound(&Bnds);
 		
 			// Work out how much page that is take up
 			int PageHeight = (int) (MemRect.Y() * MemScale);
 		
 			// This is the position on the page we are blting to
 			LRect PageRect(Context.MarginPx.x1, Context.CurrentY, Context.MarginPx.x2, Context.CurrentY + PageHeight - 1);
 		
 			// Do the blt
 			Page->StretchBlt(&PageRect, RenderedHtml, &MemRect);
 			Printed++;
 		
 			// Now move our position down the page..
 			Context.CurrentY += PageHeight;
 			if ((Context.MarginPx.Y() - Context.CurrentY) * 100 / Context.MarginPx.Y() < 5)
 			{
 				// Ok we hit the end of the page and need to go to the next page
 				Context.CurrentY = Context.MarginPx.y1;
 				Page = Context.NewPage();
 			}
 
 			y += MemRect.Y();
 		}
 	}
 
 	return Printed;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 size_t Mail::Length()
 {
 	size_t Status = 0;
 
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			Status++;
 		}
 	}
 
 	return Status;
 }
 
 ssize_t Mail::IndexOf(Mail *m)
 {
 	ssize_t Status = -1;
 
 	ssize_t n = 0;
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			if (a->GetMsg() == m)
 			{
 				Status = n;
 				break;
 			}
 			n++;
 		}
 	}
 
 	return Status;
 }
 
 Mail *Mail::operator [](size_t i)
 {
 	size_t n = 0;
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			if (n == i)
 				return a->GetMsg();
 			n++;
 		}
 	}
 
 	return NULL;
 }
 
 bool Mail::LoadFromFile(char *File)
 {
 	if (File)
 	{
 		LAutoPtr<LFile> f(new LFile);
 		if (f->Open(File, O_READ))
 		{
 			return Import(AutoCast(f), sMimeMessage);
 		}
 	}
 
 	return false;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 bool CreateMailAddress(LStream &Out, LDataPropI *Addr, MailProtocol *Protocol)
 {
     if (!Addr)
         return false;
 
     auto Name = Addr->GetStr(FIELD_NAME);
     auto Email = Addr->GetStr(FIELD_EMAIL);
     if (!Email)
         return false;
     
 	Name = EncodeRfc2047(NewStr(Name), 0, &Protocol->CharsetPrefs);
 	if (Name)
 	{
 		if (strchr(Name, '\"'))
 			Out.Print("'%s' ", Name);
 		else
 			Out.Print("\"%s\" ", Name);
 		DeleteArray(Name);
 	}
 
 	Out.Print("<%s>", Email);
 	return true;
 }
 
 bool CreateMailHeaders(ScribeWnd *App, LStream &Out, LDataI *Mail, MailProtocol *Protocol)
 {
 	bool Status = true;
 
 	// Setup
 	char Buffer[1025];
 
 	// Construct date
 	LDateTime Dt;
 	int TimeZone = Dt.SystemTimeZone();
 	Dt.SetNow();
 	sprintf_s(Buffer, sizeof(Buffer),
 			"Date: %s, %i %s %i %i:%2.2i:%2.2i %s%2.2d%2.2d\r\n",
 			LDateTime::WeekdaysShort[Dt.DayOfWeek()],
 			Dt.Day(),
 			LDateTime::MonthsShort[Dt.Month()-1],
 			Dt.Year(),
 			Dt.Hours(),
 			Dt.Minutes(),
 			Dt.Seconds(),
 			(TimeZone >= 0) ? "+" : "",
 			TimeZone / 60,
 			abs(TimeZone) % 60);
 	Status &= Out.Write(Buffer, strlen(Buffer)) > 0;
 
 	if (Protocol && Protocol->ProgramName)
 	{
 		// X-Mailer:
 		Status &= Out.Print("X-Mailer: %s\r\n", Protocol->ProgramName.Get()) > 0;
 	}
 
 	if (Protocol && Protocol->ExtraOutgoingHeaders)
 	{
 		for (char *s=Protocol->ExtraOutgoingHeaders; s && *s; )
 		{
 			char *e = s;
 			while (*e && *e != '\r' && *e != '\n') e++;
 			ssize_t l = e-s;
 			if (l > 0)
 			{
 				Status &= Out.Write(s, l) > 0;
 				Status &= Out.Write((char*)"\r\n", 2) > 0;
 			}
 			while (*e && (*e == '\r' || *e == '\n')) e++;
 			s = e;
 		}
 	}
 
 	int Priority = (int)Mail->GetInt(FIELD_PRIORITY);
 	if (Priority != MAIL_PRIORITY_NORMAL)
 	{
 		// X-Priority:
 		Status &= Out.Print("X-Priority: %i\r\n", Priority) > 0;
 	}
 
     uint32_t MarkColour = (uint32_t)Mail->GetInt(FIELD_COLOUR);
 	if (MarkColour)
 	{
 		// X-Color (HTML Colour Ref for email marking)
 		Status &= Out.Print("X-Color: #%2.2X%2.2X%2.2X\r\n",
 			                R24(MarkColour),
 			                G24(MarkColour),
 			                B24(MarkColour)) > 0;
 	}
 
 	// Message-ID:
 	auto MessageID = Mail->GetStr(FIELD_MESSAGE_ID);
 	if (MessageID)
 	{
 		for (auto m=MessageID; *m; m++)
 		{
 			if (*m <= ' ')
 			{
 				printf("%s:%i - Bad message ID '%s'\n", _FL, MessageID);
 				return false;
 			}			
 		}
 		
 		Status &= Out.Print("Message-ID: %s\r\n", MessageID) > 0;
 	}
 
 	// References:
 	auto References = Mail->GetStr(FIELD_REFERENCES);
 	if (ValidStr(References))
 	{
 		auto Dir = strrchr(References, '/');
 		LString Ref;
 		if (Dir)
 		{
 			LUri u;
 			Ref = u.DecodeStr(Dir + 1);
 		}
 		else
 			Ref = References;
 
 		if (*Ref == '<')
     		Status &= Out.Print("References: %s\r\n", Ref.Get()) > 0;
     	else
 	    	Status &= Out.Print("References: <%s>\r\n", Ref.Get()) > 0;
 	}
 
 	// To:
 	LDataIt Addr = Mail->GetList(FIELD_TO);
 	LArray<Store3Addr*> Objs;
 	LArray<LDataPropI*> To, Cc;
 	ContactGroup *Group;
 	for (unsigned i=0; i<Addr->Length(); i++)
 	{
 	    LDataPropI *a = (*Addr)[i];
 	    EmailAddressType AddrType = (EmailAddressType)a->GetInt(FIELD_CC);
 
 		LString Addr = a->GetStr(FIELD_EMAIL);
 		if (LIsValidEmail(Addr))
 		{
 			if (AddrType == MAIL_ADDR_CC)
 				Cc.Add(a);
 			else if (AddrType == MAIL_ADDR_TO)
 				To.Add(a);
 		}
 		else if ((Group = LookupContactGroup(App, Addr)))
 		{
 			Group->UsedTs.SetNow();
 
 			LString::Array Addrs = Group->GetAddresses();
 			for (unsigned n=0; n<Addrs.Length(); n++)
 			{
 				Store3Addr *sa = new Store3Addr(Group->GetObject()->GetStore(), NULL);
 				if (sa)
 				{
 					sa->Addr = Addrs[n];
 					Objs.Add(sa);
 
 					if (AddrType == MAIL_ADDR_CC)
 						Cc.Add(sa);
 					else if (AddrType == MAIL_ADDR_TO)
 						To.Add(sa);
 				}
 			}
 		}
 	}
 	if (To.Length())
 	{
 	    for (unsigned i=0; i<To.Length(); i++)
 	    {
 	        if (i)
 	            Out.Print(",\r\n\t");
 	        else
     	        Out.Print("To: ");
             
             if (!CreateMailAddress(Out, To[i], Protocol))
                 return false;
 	    }
 	    Out.Print("\r\n");
 	}
 	if (Cc.Length())
 	{
 	    for (unsigned i=0; i<Cc.Length(); i++)
 	    {
 	        if (i)
 	            Out.Print(",\r\n\t");
 	        else
     	        Out.Print("Cc: ");
             
             if (!CreateMailAddress(Out, Cc[i], Protocol))
                 return false;
 	    }
 	    Out.Print("\r\n");
 	}
 
 	// From:
 	LDataPropI *From = Mail->GetObj(FIELD_FROM);
 	if (From && From->GetStr(FIELD_EMAIL))
 	{
 		Out.Print("From: ");
 		if (!CreateMailAddress(Out, From, Protocol))
 		    return false;
 		Out.Print("\r\n");
 	}
 	else
 	{
 		LgiTrace("%s:%i - No from address.\n", _FL);
 		return false;
 	}
 
 	// Reply-To:
 	LDataPropI *Reply = Mail->GetObj(FIELD_REPLY);
 	if (Reply && ValidStr(Reply->GetStr(FIELD_EMAIL)))
 	{
 		Out.Print("Reply-To: ");
 		if (!CreateMailAddress(Out, Reply, Protocol))
 		    return false;
 		Out.Print("\r\n");
 	}
 
 	// Subject:
 	char *Subj = EncodeRfc2047(NewStr(Mail->GetStr(FIELD_SUBJECT)), 0, &Protocol->CharsetPrefs, 9);
 	sprintf_s(Buffer, sizeof(Buffer), "Subject: %s\r\n", (Subj) ? Subj : "");
 	Status &= Out.Write(Buffer, strlen(Buffer)) > 0;
 	DeleteArray(Subj);
 
 	// DispositionNotificationTo
 	uint8_t DispositionNotificationTo = TestFlag(Mail->GetInt(FIELD_FLAGS), MAIL_READ_RECEIPT);
 	if (DispositionNotificationTo && From)
 	{
 		int ch = sprintf_s(Buffer, sizeof(Buffer), "Disposition-Notification-To:");
 		char *Nme = EncodeRfc2047(NewStr(From->GetStr(FIELD_NAME)), 0, &Protocol->CharsetPrefs);
 		if (Nme)
 		{
 			ch += sprintf_s(Buffer+ch, sizeof(Buffer)-ch, " \"%s\"", Nme);
 			DeleteArray(Nme);
 		}
 		ch += sprintf_s(Buffer+ch, sizeof(Buffer)-ch, " <%s>\r\n", From->GetStr(FIELD_EMAIL));
 		Status &= Out.Write(Buffer, ch) > 0;
 	}
 	
 	// Content-Type
 	LDataPropI *Root = Mail->GetObj(FIELD_MIME_SEG);
 	if (Root)
 	{
 		auto MimeType = Root->GetStr(FIELD_MIME_TYPE);
 		auto Charset = Root->GetStr(FIELD_CHARSET);
 		if (MimeType)
 		{
 			LString s;
 			s.Printf("Content-Type: %s%s%s\r\n", MimeType, Charset?"; charset=":"", Charset?Charset:"");
 			Status &= Out.Write(s, s.Length()) == s.Length();
 		}
 	}
 	else LAssert(0);
 	
 	Objs.DeleteObjects();
 	return Status;
 }