diff --git a/src/ScribeAttachment.cpp b/src/ScribeAttachment.cpp
--- a/src/ScribeAttachment.cpp
+++ b/src/ScribeAttachment.cpp
@@ -1,1186 +1,1108 @@
 /*
 **	FILE:			ScribeAttachment.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			7/12/98
 **	DESCRIPTION:	Scribe Attachments
 **
 **	Copyright (C) 1998, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 
 #include "Scribe.h"
 #include "resdefs.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/Tnef.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/TextConvert.h"
 #include "lgi/common/FileSelect.h"
 
 extern char *ExtractCodePage(char *ContentType);
 
 #ifdef WIN32
 char NotAllowed[] = "\\/*:?\"|<>";
 #else
 char NotAllowed[] = "\\/";
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
 char *StripPath(const char *Full)
 {
 	if (Full)
 	{
 		auto Dos = strrchr(Full, '\\');
 		auto Unix = strrchr(Full, '/');
 		if (Dos)
 		{
 			return NewStr(Dos+1);
 		}
 		else if (Unix)
 		{
 			return NewStr(Unix+1);
 		}
 	}
 
 	return NewStr(Full);
 }
 
 void CleanFileName(char *i)
 {
 	if (i)
 	{
 		char *o = i;
 		while (*i)
 		{
 			if ((uint8_t)*i >= ' ' && !strchr(NotAllowed, *i))
 			{
 				*o++ = *i;
 			}
 			i++;
 		}
 		*o++ = 0;
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 void Attachment::_New(LDataI *object)
 {
 	DefaultObject(object);
 	LAssert(GetObject() != NULL);
 	Owner = 0;
 	Msg = 0;
 	IsResizing = false;
 }
 
 Attachment::Attachment(ScribeWnd *App, Attachment *From) : Thing(App)
 {
 	_New(From &&
 		From->GetObject() ?
 		From->GetObject()->GetStore()->Create(MAGIC_ATTACHMENT) : 0);
 	if (From)
 	{
 		char *Ptr = 0;
 		ssize_t Len = 0;
 
 		if (From->Get(&Ptr, &Len))
 		{
 			Set(Ptr, Len);
 			SetName(From->GetName());
 			SetMimeType(From->GetMimeType());
 			SetContentId(From->GetContentId());
 			SetCharset(From->GetCharset());
 		}
 	}
 }
 
 Attachment::Attachment(ScribeWnd *App, LDataI *object, const char *Import) : Thing(App)
 {
 	_New(object);	
 	if (Import)
 		ImportFile(Import);
 }
 
 Attachment::~Attachment()
 {
 	DeleteObj(Msg);
 
 	if (Owner)
 		Owner->Attachments.Delete(this);
 }
 
 bool Attachment::ImportFile(const char *FileName)
 {
 	LAutoPtr<LFile> f(new LFile);
 	if (!f)
 	{
 		LAssert(!"Out of memory");
 		return false;
 	}
 
 	LString Mime = ScribeGetFileMimeType(FileName);
 	if (!f->Open(FileName, O_READ))
 	{
 		LAssert(!"Can't open file.");
 		return false;
 	}
 
 	char *c = strrchr((char*)FileName, DIR_CHAR);
 	if (c) SetName(c + 1);
 	else SetName(FileName);
 
 	if (Mime)
 		SetMimeType(Mime);
 	
 	LAutoStreamI s(f.Release());
 	GetObject()->SetStream(s);
 	return true;
 }
 
 bool Attachment::ImportStream(const char *FileName, const char *MimeType, LAutoStreamI Stream)
 {
 	if (!FileName ||
 		!MimeType ||
 		!Stream)
 	{
 		LAssert(!"Parameter error");
 		return false;
 	}
 	
 	char *c = strrchr((char*)FileName, DIR_CHAR);
 	if (c) SetName(c + 1);
 	else SetName(FileName);
 
 	SetMimeType(MimeType);
 
 	GetObject()->SetStream(Stream);	
 	return true;
 }
 
 void Attachment::SetOwner(Mail *msg)
 {
 	Owner = msg;
 }
 
 bool Attachment::CallMethod(const char *MethodName, LScriptArguments &Args)
 {
 	ScribeDomType Fld = StrToDom(MethodName);
 
 	*Args.GetReturn() = false;
 	switch (Fld)
 	{
 		case SdSave: // Type: (String FileName)
 		{
 			auto Fn = Args.Length() > 0 ? Args[0]->Str() : NULL;
 			if (Fn)
 				*Args.GetReturn() = SaveTo(Fn, true);
 			return true;
 		}
 		default:
 			break;
 	}
 
 	return Thing::CallMethod(MethodName, Args);
 }
 
 bool Attachment::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdLength: // Type: Int64
 		{
 			Value = GetSize();
 			break;
 		}
 		case SdName: // Type: String
 		{
 			Value = GetName();
 			break;
 		}
 		case SdMimeType: // Type: String
 		{
 			Value = GetMimeType();
 			break;
 		}
 		case SdContentId: // Type: String
 		{
 			Value = GetContentId();
 			break;
 		}
 		case SdData: // Type: Binary
 		{
 			LAutoPtr<LStreamI> s(GotoObject(_FL));
 			if (!s)
 				return false;
 
 			Value.Empty();
 			Value.Type = GV_BINARY;
 			if ((Value.Value.Binary.Data = new char[Value.Value.Binary.Length = (int)s->GetSize()]))
 				s->Read(Value.Value.Binary.Data, Value.Value.Binary.Length);
 			break;
 		}
 		case SdType: // Type: Int32
 		{
 			Value = GetObject()->Type();
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 Thing &Attachment::operator =(Thing &t)
 {
 	LAssert(0);
 	return *this;
 }
 
 void IncFileIndex(char *FilePath, size_t FilePathLen)
 {
 	char File[MAX_PATH_LEN];
 	char Ext[256] = "";
 
 	// Get the extension part
 	char *Dot = strrchr(FilePath, '.');
 	if (Dot)
 	{
 		strcpy_s(Ext, sizeof(Ext), Dot);
 	}
 
 	// Get the filename part
 	ssize_t FileLen = (ssize_t)strlen(FilePath) - strlen(Ext);
 	memcpy(File, FilePath, FileLen);
 	File[FileLen] = 0;
 
 	// Seek to start of digits
 	char *Digits = File + strlen(File) - 1;
 	while (IsDigit(*Digits) && Digits > File)
 	{
 		Digits--;
 	}
 	if (!IsDigit(*Digits)) Digits++;
 
 	// Increment the index
 	int Index = atoi(Digits);
 	sprintf_s(Digits, sizeof(File)-(Digits-File), "%i", Index + 1);
 
 	// Write the resulting filename
 	sprintf_s(FilePath, FilePathLen, "%s%s", File, Ext);
 }
 
 void Attachment::SetMsg(Mail *m)
 {
 	Msg = m;
 }
 
 Mail *Attachment::GetMsg()
 {
 	if (!Msg && IsMailMessage())
 	{
 		// is an email
 		LAutoStreamI f = GetObject()->GetStream(_FL);
 		if (f)
 		{
 			if ((Msg = new Mail(App)))
 			{
 				Msg->SetWillDirty(false);
 				Msg->App = App;
 				Msg->ParentFile = this;
 
 				Msg->OnAfterReceive(f);
 			}
 		}
 	}
 
 	return Msg;
 }
 
 bool Attachment::GetIsResizing()
 {
 	return IsResizing;
 }
 
 void Attachment::SetIsResizing(bool b)
 {
 	IsResizing = b;
 	Update();
 }
 
 bool Attachment::IsMailMessage()
 {
 	return	GetMimeType() &&
 			!_stricmp(GetMimeType(), sMimeMessage);
 }
 
 bool Attachment::IsVCalendar()
 {
 	return	GetMimeType()
 			&&
 			(
 				!_stricmp(GetMimeType(), sMimeVCalendar)
 				||
 				!_stricmp(GetMimeType(), sMimeICalendar)
 			);
 }
 
 bool Attachment::IsVCard()
 {
 	return	GetMimeType() &&
 			!_stricmp(GetMimeType(), sMimeVCard);
 }
 
 char *Attachment::GetDropFileName()
 {
 	if (!DropFileName)
 		DropFileName = MakeFileName();
 	return DropFileName;
 }
 
 bool Attachment::GetDropFiles(LString::Array &Files)
 {
 	bool Status = false;
 
 	if (GetDropFileName())
 	{
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), ScribeTempPath(), DropFileName);
 		if (SaveTo(p, true))
 		{
 			Files.Add(p);
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 LAutoString Attachment::MakeFileName()
 {
 	auto Name = GetName();
 	LAutoString CleanName;
 	
 	if (Name)
 	{
 		CleanName.Reset(StripPath(Name));
 		CleanFileName(CleanName);
 	}
 	else
 	{
 		LArray<LString> Ext;
 		char s[256] = "Attachment";
 		auto MimeType = GetMimeType();
 
 		LGetMimeTypeExtensions(MimeType, Ext);
 		if (Ext.Length())
 		{
 			size_t len = strlen(s);
 			sprintf_s(s+len, sizeof(s)-len, ".%s", Ext[0].Get());
 		}
 		CleanName.Reset(NewStr(s));
 	}
 
 	return CleanName;
 }
 
 void Attachment::OnOpen(LView *Parent, char *Dest)
 {
 	bool VCal;
 	if (GetMsg())
 	{
 		// Open the mail message...
 		Msg->DoUI(Owner);
 	}
 	else if ((VCal = IsVCalendar()) || IsVCard())
 	{
 		// Open the event or contact...
 		Thing *c = App->CreateItem(VCal ? MAGIC_CALENDAR : MAGIC_CONTACT, 0, false);
 		if (c)
 		{
 			LAutoPtr<LStreamI> f(GotoObject(_FL));
 			if (f)
 			{
 				if (c->Import(f, GetMimeType()))
 				{
 					c->DoUI();
 				}
 				else LgiMsg(Parent, "Failed to parse calendar.", "Error");
 			}
 			else LgiTrace("%s:%i - Failed to get attachment stream.\n", _FL);
 		}
 	}
 	else // is some generic file
 	{
 		bool IsExe = false;
 		int TnefSizeLimit = 8 << 20;
 		LStream *TnefStream = 0;
 		LArray<TnefFileInfo*> TnefIndex;
 
 		int64 AttachPos = -1;
 		LAutoStreamI f = GetObject()->GetStream(_FL);
 		if (f)
 		{
 			IsExe = LIsFileExecutable(GetName(), f, AttachPos = f->GetPos(), f->GetSize());
 			if (!IsExe &&
 				f->GetSize() < TnefSizeLimit)
 			{
 				f->SetPos(AttachPos);
 				if (!TnefReadIndex(f, TnefIndex))
 				{
 					DeleteObj(TnefStream);
 				}
 			}
 			f.Reset();
 		}
 
 		if (IsExe)
 		{
 			LgiMsg(Parent, LLoadString(IDS_ERROR_EXE_FILE), AppName);
 			return;
 		}
 
 		// Check for TNEF
 		if (TnefStream)
 		{
 			LStringPipe p;
 			for (unsigned n=0; n<TnefIndex.Length(); n++)
 			{
 				char Size[64];
 				LFormatSize(Size, sizeof(Size), TnefIndex[n]->Size);
 				p.Print("\t%s (%s)\n", TnefIndex[n]->Name, Size);
 			}
 			char *FileList = p.NewStr();
 			if (Owner &&
 				LgiMsg(Parent, LLoadString(IDS_ASK_TNEF_DECODE), AppName, MB_YESNO, FileList) == IDYES)
 			{
 				char *Tmp = ScribeTempPath();
 				if (Tmp)
 				{
 					for (unsigned i=0; i<TnefIndex.Length(); i++)
 					{
 						char s[MAX_PATH_LEN];
 						LMakePath(s, sizeof(s), Tmp, TnefIndex[i]->Name);
 						
 						LFile Out;
 						if (Out.Open(s, O_WRITE))
 						{
 							Out.SetSize(0);
 							if (TnefExtract(TnefStream, &Out, TnefIndex[i]))
 							{
 								Out.Close();
 
 								Attachment *NewFile = 0;
 								Owner->AttachFile(NewFile = new Attachment(App, GetObject()->GetStore()->Create(MAGIC_ATTACHMENT), s));
 								if (NewFile && Owner->GetUI())
 								{
 									AttachmentList *Lst = Owner->GetUI()->GetAttachments();
 									if (Lst)
 									{
 										Lst->Insert(NewFile);
 										Lst->ResizeColumnsToContent();
 									}
 								}
 							}
 							Out.Close();
 						}
 					}
 				}
 
 				Owner->Save();
 				OnDeleteAttachment(Parent, false);
 			}
 			DeleteObj(TnefStream);
 			DeleteArray(FileList);
 		}
 		else
 		{
 			// Open file...
 			LAutoString FileToExecute;
 			char *Tmp = ScribeTempPath();
 			if (!Tmp)
 				return;
 				
 			// get the file name
 			char FileName[MAX_PATH_LEN];
 			LAutoString CleanName = MakeFileName();
 			if (CleanName)
 			{
 				LMakePath(FileName, sizeof(FileName), Tmp, CleanName);
 
 				while (LFileExists(FileName))
 				{
 					IncFileIndex(FileName, sizeof(FileName));
 				}
 
 				// write the file out
 				if (SaveTo(FileName))
 				{
 					FileToExecute.Reset(NewStr(FileName));
 				}
 			}
 			
 			// open the file
 			auto Mime = GetMimeType();
 			if (FileToExecute)
 			{
 				LAutoString AssociatedApp;
 				LXmlTag *FileTypes = App->GetOptions()->LockTag(OPT_FileTypes, _FL);
 				if (FileTypes)
 				{
 					auto Mime = GetMimeType();
 					auto FileName = GetName();
 					
 					for (auto t: FileTypes->Children)
 					{
 						char *mt = t->GetAttr("mime");
 						char *ext = t->GetAttr("extension");
 						bool MimeMatch = mt && Mime && !_stricmp(mt, Mime);
 						bool ExtMatch = ext && FileName && MatchStr(ext, FileName);
 						if (MimeMatch || ExtMatch)
 						{
 							AssociatedApp.Reset(TrimStr(t->GetContent()));
 							break;
 						}
 					}
 					
 					App->GetOptions()->Unlock();
 				}
 				
 				if (AssociatedApp)
 				{
 					const char *s = AssociatedApp;
 					LAutoString Exe(LTokStr(s));
 					if (Exe)
 					{
 						char Args[MAX_PATH_LEN+100];
 						
 						if (!strchr(s, '%') ||
 							sprintf_s(Args, sizeof(Args), s, FileToExecute.Get()) < 0)
 						{
 							if (sprintf_s(Args, sizeof(Args), "\"%s\"", FileToExecute.Get()) < 0)
 								Args[0] = 0;
 						}
 						
 						if (Args[0] && LExecute(Exe, Args))
 						{
 							// Successful..
 							return;
 						}
 					}
 				}
 				
 				if (!LExecute(FileToExecute, 0, Tmp))
 				{
 					// if the default open fails.. open as text
 					LString AppPath = LGetAppForMimeType(Mime ? Mime : sTextPlain);
 					bool Status = false;
 					if (AppPath)
 					{
 						char *s = strchr(AppPath, '%');
 						if (s) s[0] = 0;
 						Status = LExecute(AppPath, FileToExecute, Tmp);
 					}
 
 					if (!Status)
 					{
 						LgiMsg(Parent, "Couldn't open file.", AppName, MB_OK);
 					}
 				}
 			}
 		}
 	}
 }
 
 void Attachment::OnDeleteAttachment(LView *Parent, bool Ask)
 {
 	if (Owner)
 	{
 		LVariant ConfirmDelete;
 		App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 		if (!Ask ||
 			!ConfirmDelete.CastInt32() ||
 			LgiMsg(GetList(), LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 		{
 			List<LListItem> Sel;
 			LList *p = GetList();
 
 			if (p)
 			{
 				p->GetSelection(Sel);
 			}
 			else
 			{
 				Sel.Insert(this);
 			}
 
 			for (LListItem *i: Sel)
 			{
 				Attachment *a = dynamic_cast<Attachment*>(i);
 				if (a)
 				{
 					if (p)
 					{
 						p->Remove(i);
 					}
 					
 					a->Owner->DeleteAttachment(a);
 				}
 			}
 
 			if (p)
 			{
 				p->Invalidate();
 			}
 		}
 	}
 }
 
 bool Attachment::SaveTo(char *FileName, bool Quite, LView *Parent)
 {
 	bool Status = false;
 	if (FileName)
 	{
 		LFile Out;
 		Status = true;
 
 		if (LFileExists(FileName))
 		{
 			if (Quite)
 			{
 				return true;
 			}
 			else
 			{
 				Out.Close();
 				LString Msg = AskOverwriteMsg(FileName);
 				Status = LgiMsg(Parent ? Parent : App, Msg, AppName, MB_YESNO) == IDYES;
 			}
 		}
 
 		if (!Out.Open(FileName, O_WRITE))
 		{
 			if (!Quite)
 				LgiMsg(App, LLoadString(IDS_ERROR_CANT_WRITE), AppName, MB_OK, FileName);
 			else
 				LgiTrace("%s:%i - Can't open '%s' for writing (err=0x%x)\n", _FL, FileName, Out.GetError());
 			Status = false;
 		}
 
 		if (Status)
 		{
 			Out.SetSize(0);
 
 			if (GetObject())
 			{
 				int BufSize = 64 << 10;
 				char *Buf = new char[BufSize];
 
 				LStreamI *f = GotoObject(_FL);
 				if (f && Buf)
 				{
 					f->SetPos(0);					
 					Out.SetSize(0);
 					int64 MySize = f->GetSize();
 					int64 s = MySize;
 					while (s > 0)
 					{
 						ssize_t r = (int)MIN(BufSize, s);
 						r = f->Read(Buf, r);
 						if (r > 0)
 						{
 							Out.Write(Buf, r);
 							s -= r;
 						}
 						else break;
 					}
 
 					int64 OutPos = Out.GetPos();
 					if (OutPos < MySize)
 					{
 						// Error writing to disk...
 						Out.Close();
 						FileDev->Delete(FileName, false);
 						LAssert(!"Failed to write whole attachment to disk.");
 						Status = false;
 					}
 				}
 				else
 				{
 					LgiTrace("%s:%i - GotoObject failed.\n", _FL);
 					Status = false;
 				}
 
 				DeleteObj(f);
 				DeleteArray(Buf);
 			}
 			/*
 			else if (Data)
 			{
 				int Written = Out.Write(Data, Size);
 				Status = Written == Size;
 			}
 			*/
 		}
 	}
 
 	return Status;
 }
 
 void Attachment::OnSaveAs(LView *Parent)
 {
 	auto Name = GetName();
 	char *n = StripPath(Name);
 	if (!n)
 	{
 		n = NewStr("untitled");
 	}
 	
 	if (n)
 	{
 		CleanFileName(n);
 
 		auto Select = new LFileSelect(Parent);
 
 		Select->Type("All files", LGI_ALL_FILES);
 		Select->Name(n);
 
 		List<LListItem> Files;
 
 		if (LListItem::Parent)
 		{
 			LListItem::Parent->GetSelection(Files);
 		}
 		else
 		{
 			Files.Insert(this);
 		}
 
 		if (Files.Length() > 0)
 		{
 			auto DoSave = [this, Files, Parent](LFileSelect *Select)
 			{
 				char Dir[MAX_PATH_LEN];
 				strcpy_s(Dir, sizeof(Dir), Select->Name());
 
 				if (Files.Length() > 1)
 				{
 					// Loop through all the files and write them to that directory
 					for (unsigned idx=0; idx<Files.Length(); idx++)
 					{
 						LListItem *i = Files[idx];
 						Attachment *a = dynamic_cast<Attachment*>(i);
 						if (a)
 						{
 							char Path[MAX_PATH_LEN];
 							auto d = StripPath(a->GetName());
 							if (d)
 							{
 								sprintf_s(Path, sizeof(Path), "%s%s%s", Dir, DIR_STR, d);
 								a->SaveTo(Path);
 								DeleteArray(d);
 							}
 						}
 					}
 				}
 				else
 				{
 					// Write the file
 					Attachment *a = dynamic_cast<Attachment*>(Files[0]);
 					if (a)
 					{
 						a->SaveTo(Dir, false, Parent);
 					}
 				}
 			};
 
 			if (Files.Length() > 1)
 			{
 				// multiple files, ask which directory to write to
 				Select->OpenFolder([DoSave](auto dlg, auto status)
 				{
 					if (status)
 						DoSave(dlg);
 					delete dlg;
 				});
 			}
 			else
 			{
 				// single file, ask for filename and path
 				Select->Save([DoSave](auto dlg, auto status)
 				{
 					if (status)
 						DoSave(dlg);
 					delete dlg;
 				});
 			}
 		}
 
 		DeleteArray(n);
 	}
 }
 
 bool Attachment::OnKey(LKey &k)
 {
 	if (k.vkey == LK_RETURN && k.IsChar)
 	{
 		if (k.Down())
 		{
 			OnOpen(GetList());
 		}
 
 		return true;
 	}
 
 	return false;
 }
 
 void Attachment::OnMouseClick(LMouse &m)
 {
 	auto mt = GetMimeType();
 	bool OpenAttachment = false;
 
 	if (m.IsContextMenu())
 	{
 		// open the right click menu
 		LSubMenu RClick;
 		LString MimeType = GetMimeType();
 
 		RClick.AppendItem(LLoadString(IDS_ADD_TO_CAL), IDM_ADD_TO_CAL, IsVCalendar());
 		RClick.AppendSeparator();
 		RClick.AppendItem(LLoadString(IDS_OPEN), IDM_OPEN, true);
 		RClick.AppendItem(LLoadString(IDS_SAVEAS), IDM_SAVEAS, true);
 		RClick.AppendItem(LLoadString(IDS_DELETE), IDM_DELETE, true);
 		RClick.AppendSeparator();
 		RClick.AppendItem(LLoadString(IDS_RESIZE), IDM_RESIZE, MimeType.Lower().Find("image/") >= 0);
 
 		if (Parent->GetMouse(m, true))
 		{
 			switch (RClick.Float(Parent, m.x, m.y))
 			{
 				case IDM_OPEN:
 				{
 					OpenAttachment = true;
 					break;
 				}
 				case IDM_DELETE:
 				{
 					OnDeleteAttachment(Parent, true);
 					break;
 				}
 				case IDM_SAVEAS:
 				{
 					OnSaveAs(Parent);
 					break;
 				}
 				case IDM_ADD_TO_CAL:
 				{
 					ScribeFolder *Cal = App->GetFolder(FOLDER_CALENDAR);
 					if (!Cal)
 						LgiMsg(Parent, "Can't find the calendar folder.", AppName);
 					else
 					{
 						Thing *c = App->CreateItem(MAGIC_CALENDAR, 0, false);
 						if (c)
 						{
 							LAutoPtr<LStreamI> f(GotoObject(_FL));
 							if (f)
 							{
 								if (c->Import(c->AutoCast(f), mt))
 								{
 									c->Save(Cal);
 									c->DoUI();
 								}
 								else LgiTrace("%s:%i - Failed to import cal stream.\n", _FL);
 							}
 							else LgiTrace("%s:%i - Failed to get attachment stream.\n", _FL);
 						}
 						else LgiTrace("%s:%i - Failed to create calendar obj.\n", _FL);
 					}
 					break;
 				}
 				case IDM_RESIZE:
 				{
 					List<Attachment> Sel;
 					if (GetList() && GetList()->GetSelection(Sel))
 					{
 						for (auto a: Sel)
 						{
 							if (!a->Owner)
 							{
 								LgiTrace("%s:%i - No owner?", _FL);
 								break;
 							}
 
 							a->Owner->ResizeImage(a);
 						}
 						
 						GetList()->ResizeColumnsToContent();
 					}
 					break;
 				}
 			}
 		}
 	}
 	else if (m.Double())
 	{
 		OpenAttachment = true;
 	}	
 	
 	if (OpenAttachment)
 	{
 		// open the attachment
 		OnOpen(Parent);
 	}
 }
 
 bool Attachment::GetFormats(LDragFormats &Formats)
 {
 	Formats.SupportsFileDrops();
 	return Formats.Length() > 0;
 }
 
 bool Attachment::GetData(LArray<LDragData> &Data)
 {
 	int SetCount = 0;
 	
 	for (unsigned idx=0; idx<Data.Length(); idx++)
 	{
 		LDragData &dd = Data[idx];
 		if (dd.IsFileDrop())
 		{
 			List<Attachment> Att;
 			if (Parent->GetSelection(Att))
 			{
 				LString::Array Files;
 
 				for (auto a: Att)
 				{
 					// char *Nm = a->GetName();
 
 					if (!a->DropSourceFile || !LFileExists(a->DropSourceFile))
 					{
 						a->DropSourceFile.Reset();
 
 						char p[MAX_PATH_LEN];
 						LAutoString Clean = a->MakeFileName();
 						LMakePath(p, sizeof(p), ScribeTempPath(), Clean);
 
 						char Ext[256];
 						char *d = strrchr(p, '.');
 						if (!d) d = p + strlen(p);
 						strcpy_s(Ext, sizeof(Ext), d);
 
 						for (int i=1; LFileExists(p); i++)
 						{
 							sprintf_s(d, sizeof(p)-(d-p), "_%i%s", i, Ext);
 						}
 
 						if (a->SaveTo(p, true))
 						{
 							a->DropSourceFile.Reset(NewStr(p));
 						}
 					}
 
 					if (a->DropSourceFile)
 					{
 						Files.Add(a->DropSourceFile.Get());
 					}
 					else LAssert(0);
 				}
 
 				if (Files.First())
 				{
 					LMouse m;
 					App->GetMouse(m, true);
 					if (CreateFileDrop(&dd, m, Files))
 					{
 						SetCount++;
 					}
 				}
 			}
 		}
 	}
 
 	return SetCount > 0;
 }
 
 LStreamI *Attachment::GotoObject(const char *file, int line)
 {
 	if (!GetObject())
 		return 0;
 
 	LAutoStreamI s = GetObject()->GetStream(file, line);
 	return s.Release();
 }
 
-char *GetSubField(char *s, char *Field, bool AllowConversion = true)
-{
-	char *Status = 0;
-
-	if (s && Field)
-	{
-		s = strchr(s, ';');
-		if (s)
-		{
-			s++;
-
-			size_t FieldLen = strlen(Field);
-			char White[] = " \t\r\n";
-			while (*s)
-			{
-				// Skip leading whitespace
-				while (*s && (strchr(White, *s) || *s == ';')) s++;
-
-				// Parse field name
-				if (IsAlpha(*s))
-				{
-					char *f = s;
-					while (*s && (IsAlpha(*s) || *s == '-')) s++;
-					bool HasField = ((s-f) == FieldLen) && (_strnicmp(Field, f, FieldLen) == 0);
-					while (*s && strchr(White, *s)) s++;
-					if (*s == '=')
-					{
-						s++;
-						while (*s && strchr(White, *s)) s++;
-						if (*s && strchr("\'\"", *s))
-						{
-							// Quote Delimited Field
-							char d = *s++;
-							char *e = strchr(s, d);
-							if (e)
-							{
-								if (HasField)
-								{
-									if (AllowConversion)
-									{
-										Status = DecodeRfc2047(NewStr(s, e-s));
-									}
-									else
-									{
-										Status = NewStr(s, e-s);
-									}
-									break;
-								}
-
-								s = e + 1;
-							}
-							else break;
-						}
-						else
-						{
-							// Delimited Field
-							char *e = s;
-							while (*e && *e != ';') e++;
-
-							if (HasField)
-							{
-								Status = DecodeRfc2047(NewStr(s, e-s));
-								break;
-							}
-
-							s = e;
-						}
-					}
-					else break;
-				}
-				else break;
-			}
-		}
-	}
-
-	return Status;
-}
-
 const char *Attachment::GetText(int i)
 {
 	if (FieldArray.Length())
 	{
 		return "This is an attachment!!!!!";
 	}
 	else
 	{
 		switch (i)
 		{
 			case 0:
 			{
 				auto Nm = GetName();
 
 				if (IsResizing)
 				{
 					Buf.Printf("%s (%s)", Nm, LLoadString(IDS_RESIZING));
 					return Buf;
 				}
 
 				return Nm;
 			}
 			case 1:
 			{
 				static char s[64];
 				LFormatSize(s, sizeof(s), GetSize());
 				return s;
 			}
 			case 2:
 			{
 				return GetMimeType();
 			}
 			case 3:
 			{
 				return GetContentId();
 			}
 		}
 	}
 
 	return 0;
 }
 
 bool Attachment::Get(char **ptr, ssize_t *size)
 {
 	if (!ptr || !size)
 		return false;
 
 	LStreamI *f = GotoObject(_FL);
 	if (!f)
 		return false;
 
 	*size = f->GetSize();
 	*ptr = new char[*size+1];
 	if (*ptr)
 	{
 		auto r = f->Read(*ptr, *size);
 		(*ptr)[r] = 0;
 	}
 
 	DeleteObj(f);
 	return true;
 }
 
 bool Attachment::Set(LAutoStreamI Stream)
 {
 	if (!GetObject())
 	{
 		LAssert(0);
 		return false;
 	}
 
 	if (!GetObject()->SetStream(Stream))
 	{
 		LAssert(0);
 		return false;
 	}
 	
 	return true;
 }
 
 bool Attachment::Set(char *ptr, ssize_t size)
 {
 	LAutoStreamI s(new LMemStream(ptr, size));
 	return Set(s);
 }
diff --git a/src/ScribeSendReceive.cpp b/src/ScribeSendReceive.cpp
--- a/src/ScribeSendReceive.cpp
+++ b/src/ScribeSendReceive.cpp
@@ -1,2849 +1,2838 @@
 /*
 **	FILE:			ScribeAccount.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			19/10/99
 **	DESCRIPTION:	Scribe account
 **
 **	Copyright (C) 2002, Matthew Allen
 **		fret@memecode.com
 */
 
 // Includes
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 
 #include "Scribe.h"
 #include "lgi/common/OpenSSLSocket.h"
 #include "ScribePrivate.h"
 #include "resdefs.h"
 #include "lgi/common/LgiRes.h"
 #include "ScribeAccountPreview.h"
 #include "ScribeUtils.h"
 #include "lgi/common/TextConvert.h"
 
 #define MAIL_POSTED_TO_GUI			0x0001
 #define MAIL_EXPLICIT				0x0002
 
 #define SECONDS(i)					((i)*1000)
 #define TRANSFER_WAIT_TIMEOUT		SECONDS(30)
 #define DEFAULT_SOCKET_TIMEOUT		SECONDS(15)
 
 LColour SocketMsgTypeToColour(LSocketI::SocketMsgType flags)
 {
 	LColour col;
 	switch (flags)
 	{
 		case LSocketI::SocketMsgInfo:
 		case LSocketI::SocketMsgNone:
 			col.Set(MAIL_INFO_COLOUR, 24);
 			break;
 		case LSocketI::SocketMsgSend:
 			col.Set(MAIL_SEND_COLOUR, 24);
 			break;
 		case LSocketI::SocketMsgReceive:
 			col.Set(MAIL_RECEIVE_COLOUR, 24);
 			break;
 		case LSocketI::SocketMsgError:
 			col.Set(MAIL_ERROR_COLOUR, 24);
 			break;
 		case LSocketI::SocketMsgWarning:
 			col.Set(MAIL_WARNING_COLOUR, 24);
 			break;
 		default:
 			LAssert(0);
 			break;
 	}
 	return col;
 }
 
 int MakeOpenFlags(ScribeAccount *a, bool Send)
 {
 	int OpenFlags = 0;
 	Accountlet *l = Send ? (Accountlet*)&a->Send : (Accountlet*)&a->Receive;
 
 	auto Nam = a->Identity.Name();
 	auto Em = a->Identity.Email();
 	// auto SslSmtp = a->Send.UseSSL();
 
 	ScribeSslMode SslMode = (ScribeSslMode)l->UseSSL();
 	switch (SslMode)
 	{
 		case SSL_STARTTLS:
 			OpenFlags |= MAIL_USE_STARTTLS;
 			break;
 		case SSL_DIRECT:
 			OpenFlags |= MAIL_SSL;
 			break;
 		default:
 			break;
 	}
 
 	if (!Send && a->Receive.SecureAuth())
 	{
 		OpenFlags |= MAIL_SECURE_AUTH;
 	}
 
 	if (Send)
 	{
 		if (a->Send.RequireAuthentication())
 		{
 			OpenFlags |= MAIL_USE_AUTH;
 		}
 
 		switch (a->Send.AuthType())
 		{
 			case 1:
 				OpenFlags |= MAIL_USE_PLAIN;
 				break;
 			case 2:
 				OpenFlags |= MAIL_USE_LOGIN;
 				break;
 			case 3:
 				OpenFlags |= MAIL_USE_CRAM_MD5;
 				break;
 			case 4:
 				OpenFlags |= MAIL_USE_OAUTH2;
 				break;
 		}
 	}
 	else
 	{
 		switch (a->Receive.AuthType())
 		{
 			case 1:
 				OpenFlags |= MAIL_USE_PLAIN;
 				break;
 			case 2:
 				OpenFlags |= MAIL_USE_LOGIN;
 				break;
 			case 3:
 				OpenFlags |= MAIL_USE_NTLM;
 				break;
 			case 4:
 				OpenFlags |= MAIL_USE_OAUTH2;
 				break;
 		}
 	}
 
 	return OpenFlags;
 }
 
 /*
 class LProtocolLogger : public LStreamI
 {
 	LViewI *Wnd;
 	int Msg;
 	List<LogEntry> *Log;
 
 public:
 	LProtocolLogger(LViewI *wnd, int msg, List<LogEntry> *log)
 	{
 		Wnd = wnd;
 		Msg = msg;
 		Log = log;
 	}
 
 	ssize_t Read(void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		return -1;
 	}
 	
 	ssize_t Write(const void *b, ssize_t len, int f = 0)
 	{
 		LogEntry *l = new LogEntry(SocketMsgTypeToColour((GSocketI::SocketMsgType)f));
 		if (l)
 		{
 			l->Add((const char*)b, len);
             Wnd->PostEvent(Msg, (LMessage::Param)Log, (LMessage::Param)l);
 		}
 		return len;
 	}
 };
 */
 
 void MakeTempPath(char *Path, int PathSize)
 {
 	// Create unique temporary filename
 	char r[32];
 
 	do
 	{
 		sprintf_s(r, sizeof(r), "%X.eml", LRand());
 		LMakePath(Path, PathSize, ScribeTempPath(), r);
 	}
 	while (LFileExists(Path));
 }
 
 const char *AccountThreadStateName(AccountThreadState i)
 {
 	switch (i)
 	{
 		case ThreadIdle: return "ThreadIdle";
 		case ThreadSetup: return "ThreadSetup";
 		case ThreadConnecting: return "ThreadConnecting";
 		case ThreadTransfer: return "ThreadTransfer";
 		case ThreadWaiting: return "ThreadWaiting";
 		case ThreadDeleting: return "ThreadDeleting";
 		case ThreadDone: return "ThreadDone";
 		case ThreadCancel: return "ThreadCancel";
 		case ThreadError: return "ThreadError";
 	}
 
 	return "(none)";
 }
 
 const char *ReceiveActionName(ReceiveAction i)
 {
 	switch (i)
 	{
 		case MailNoop:				return "MailNoop";
 		case MailDelete:			return "MailDelete";
 		case MailDownloadAndDelete:	return "MailDownloadAndDelete";
 		case MailDownload:			return "MailDownload";
 		case MailUpload:			return "MailUpload";
 		case MailHeaders:			return "MailHeaders";
 		default:					break;
 	}
 
 	return "(error)";
 }
 
 const char *ReceiveStatusName(ReceiveStatus i)
 {
 	switch (i)
 	{
 		case MailReceivedNone:		return "ReceiveNone";
 		case MailReceivedWaiting:	return "ReceiveWaiting";
 		case MailReceivedOk:		return "ReceiveOk";
 		case MailReceivedError:		return "ReceiveError";
 		default:					break;
 	}
 	
 	return "(none)";
 }
 
 
 bool Accountlet::WaitForTransfers(List<MailTransferEvent> &Files)
 {
 	LArray<int> Counts;
 	auto StartTs = LCurrentTime();
 	do
 	{
 		Counts.Length(0);
 
 		for (auto e: Files)
 			Counts[e->Status]++;
 
 		LSleep(100);
 		
 		if (LCurrentTime() - StartTs > TRANSFER_WAIT_TIMEOUT)
 		{
 			LgiTrace("%s:%i - WaitForTransfers timed out.\n", _FL);
 			for (ReceiveStatus rs = MailReceivedNone; rs < MailReceivedMax; rs = (ReceiveStatus)(((int)rs)+1))
 				LgiTrace("...%s=%i\n", ReceiveStatusName(rs), Counts[rs]);
 			return false;
 		}
 		else if (Thread && Thread->IsCancelled())
 		{
 			LgiTrace("%s:%i - WaitForTransfers exiting because thread is cancelled.\n", _FL);
 			return false;
 		}
 	}
 	while (Counts[MailReceivedWaiting] > 0);
 	
 	return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 char *NewStrCat(char *a, char *b)
 {
 	size_t Len = ((a)?strlen(a):0) + ((b)?strlen(b):0);
 	char *s = new char[Len+1];
 	if (s)
 	{
 		s[0] = 0;
 		if (a) strcat(s, a);
 		if (b) strcat(s, b);
 	}
 	DeleteArray(a);
 	return s;
 }
 
 class AccountletThread : public AccountThread
 {
 	friend class SendAccountlet;
 	friend class ReceiveAccountlet;
 	friend bool AfterReceived(MailTransaction *Trans, void *Data);
 
 	List<MailTransferEvent> Files;
 
 	void MakeTempPath(char *Buf);
 	void SetState(AccountThreadState s);
 	AccountThreadState GetState();
 
 public:
 	// Object - Api
 	AccountletThread(Accountlet *acc, List<char> *Input);
 	~AccountletThread();
 
 	// Methods
 	void Delete(int Index);
 	void Complete();		// Called by the app when the all the files have been processed
 	// void Cancel();			// Called by the app to signal the user is canceling the transfer
 	
 	// Thread
 	int Main();
 };
 
 ////////////////////////////////////////////////////////////////////////////
 AccountletThread::AccountletThread(Accountlet *acc, List<char> *Input) :
 	AccountThread(acc)
 {
 }
 
 AccountletThread::~AccountletThread()
 {
 	Files.DeleteObjects();
 }
 
 void AccountletThread::SetState(AccountThreadState s)
 {
 	Acc->State = s;
 }
 
 AccountThreadState AccountletThread::GetState()
 {
 	return Acc->GetState();
 }
 
 void AccountletThread::Delete(int Index)
 {
 	MailTransferEvent *e = Files[Index];
 	if (e)
 	{
 		e->Action = MailDelete;
 	}
 }
 
 void AccountletThread::Complete()
 {
 	for (auto f: Files)
 	{
 		f->Rfc822Msg.Reset();
 	}
 	Acc->State = ThreadDeleting;
 }
 
 int AccountletThread::Main()
 {
 	// We're running...
 	SetState(ThreadSetup);
 
 	// Do all the connect, transfer and clean up
 	Acc->Main(this);
 
 	// This tells the app we're all done
 	SetState(ThreadIdle);
 	
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 LList *MailTransferEvent::GetList()
 {	
 	if (!Account)
 	{
 		LAssert(!"No account.");
 		return NULL;
 	}
 
 	// As the list is set in the GUI thread, we should only ever use it in the
 	// GUI thread... so check for that here. Otherwise we need to lock it while it's
 	// in use. Which is not currently done.
 	#ifdef _DEBUG
 	ScribeWnd *App = Account->GetApp();
 	#endif
 	LAssert(App->InThread());
 
 	ReceiveAccountlet *ra = dynamic_cast<ReceiveAccountlet*>(Account);
 	return ra ? ra->GetItems() : NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 Accountlet::Accountlet(ScribeAccount *a) : PrivLock("Accountlet")
 {
 	DataStore = NULL;
 	MailStore = NULL;
 	Root = 0;
 	Account = a;
 	ConnectionStatus = true;
 	OptPassword = 0;
 	Client = 0;
 	LastOnline = 0;
 	Parent = 0;
 
 	State = ThreadIdle;
 
 	// Update sig to new format...
 	char Buf[256];
 	LVariant Old;
 	if (GetApp()->GetOptions()->GetValue(OptionName("AccSig", Buf, sizeof(Buf)), Old))
 	{
 		if (LFileExists(Old.Str()))
 		{
 			char *Xml = LReadTextFile(Old.Str());
 			if (Xml)
 			{
 				GetAccount()->Identity.TextSig(Xml);
 				DeleteArray(Xml);
 			}
 		}
 		
 		GetApp()->GetOptions()->DeleteValue(Buf);
 	}
 }
 
 Accountlet::~Accountlet()
 {
 	I Lck = Lock(_FL);
 	if (Lck)
 	{
 		Lck->d->Log.DeleteObjects();
 		Lck.Reset();
 	}
 	DeleteObj(Root);
 	DeleteObj(DataStore);
 }
 
 void Accountlet::OnBeforeDelete()
 {
 	// This has to be before ~ScribeAccount is finished, so that the
 	// account's index is still valid, if we are going to save the "Expanded"
 	// setting.
 	LString p;
 	if (DataStore && Root)
 	{
 		p = Root->GetPath();
 		bool e = Root->Expanded();
 		Expanded(e);
 	}
 }
 
 bool Accountlet::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	char k[128];
 	bool mapped = Account->IsMapped(OptionName(Name, k, sizeof(k)));
 	auto Opts = GetApp()->GetOptions();
 	Value.Empty();
 	if (mapped)
 		Opts->GetValue(k, Value);
 
 	return true;
 }
 
 bool Accountlet::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	char k[128];
 	bool mapped = Account->IsMapped(OptionName(Name, k, sizeof(k)));
 	auto Opts = GetApp()->GetOptions();
 	if (mapped)
 		Opts->SetValue(k, Value);
 
 	return true;
 }
 
 void Accountlet::StrOption(const char *Opt, LVariant &v, const char *Set)
 {
 	char Key[128];
 	OptionName(Opt, Key, sizeof(Key));
 	if (Set)
 		GetApp()->GetOptions()->SetValue(Key, v = Set);
 	else
 		GetApp()->GetOptions()->GetValue(Key, v);
 }
 
 void Accountlet::IntOption(const char *Opt, LVariant &v, int Set)
 {
 	char Key[128];
 	OptionName(Opt, Key, sizeof(Key));
 	if (Set >= 0)
 		GetApp()->GetOptions()->SetValue(Key, v = Set);
 	else
 		GetApp()->GetOptions()->GetValue(Key, v);
 }
 
 const char *Accountlet::GetStateName()
 {
 	switch (State)
 	{
 		case ThreadIdle: return LLoadString(IDS_ACCSTAT_IDLE);
 		case ThreadSetup: return LLoadString(IDS_ACCSTAT_SETUP);
 		case ThreadConnecting: return LLoadString(IDS_ACCSTAT_CONNECT);
 		case ThreadTransfer: return LLoadString(IDS_ACCSTAT_TRANS);
 		case ThreadWaiting: return LLoadString(IDS_ACCSTAT_WAIT);
 		case ThreadDeleting: return LLoadString(IDS_ACCSTAT_DELETING);
 		case ThreadDone: return LLoadString(IDS_ACCSTAT_FINISHED);
 		case ThreadCancel: return LLoadString(IDS_ACCSTAT_CANCELLED);
 		case ThreadError: return LLoadString(IDS_ERROR);
 	}
 
 	return "(none)";
 }
 
 void Accountlet::OnThreadDone()
 {
 	Thread.Reset();
 
 	if (DataStore && Root)
 		Expanded(Root->Expanded());
 
 	DeleteObj(Root);
 }
 
 ScribeWnd *Accountlet::GetApp()
 {
 	LAssert(Account->Parent != NULL);
 	return Account->Parent;
 }
 
 LSocketI *Accountlet::CreateSocket(bool Sending, LCapabilityClient *Caps, bool RawLFCheck)
 {
 	LSocketI *Socket = 0;
 	LVariant File;
 	LVariant Socks5Proxy;
 	LVariant UseSocks;
 	LVariant Format = (int)NET_LOG_NONE;
 
 	GetApp()->GetOptions()->GetValue(OPT_LogFile, File);
 	GetApp()->GetOptions()->GetValue(OPT_LogFormat, Format);
 
 	int SslMode = UseSSL();
 	if (SslMode > 0)
 	{
 		Socket = new SslSocket(this, Caps, SslMode == SSL_DIRECT, RawLFCheck);
 	}
 	else if (	GetApp()->GetOptions()->GetValue(OPT_UseSocks, UseSocks) &&
 				UseSocks.CastInt32() &&
 				GetApp()->GetOptions()->GetValue(OPT_Socks5Server, Socks5Proxy) &&
 				ValidStr(Socks5Proxy.Str()))
 	{
 		LVariant Socks5UserName;
 		LVariant Socks5Password;
 		GetApp()->GetOptions()->GetValue(OPT_Socks5UserName, Socks5UserName);
 		GetApp()->GetOptions()->GetValue(OPT_Socks5Password, Socks5Password);
 		LUri Server(Socks5Proxy.Str());
 
 		Socket = new ILogSocks5Connection(	Server.sHost,
 											Server.Port?Server.Port:1080,
 											Socks5UserName.Str(),
 											Socks5Password.Str(),
 											this);
 	}
 	else
 	{
 		Socket = new ILogConnection(this);
 	}
 
 	if (Socket)
 	{
 		Socket->SetTimeout(DEFAULT_SOCKET_TIMEOUT);
 
 		if (File.Str())
 		{
 			Socket->SetValue(OPT_LogFile, File);
 			Socket->SetValue(OPT_LogFormat, Format);
 		}
 
 		Socket->SetCancel(Thread);
 	}
 
 	return Socket;
 }
 
 void Accountlet::Disconnect()
 {
 	if (Thread)
 	{
 		Thread->Disconnect();
 	}
 	else
 	{
 		if (MailStore)
 			Account->Parent->OnMailStore(&MailStore, false);
 		if (Root)
 		{
 			if (DataStore && Root)
 				Expanded(Root->Expanded());
 			Root->Remove();
 			DeleteObj(Root);
 		}
 		DeleteObj(DataStore);
 	}
 }
 
 void Accountlet::Kill()
 {
 	if (Thread)
 	{
 		Thread->Kill();
 	}
 }
 
 bool Accountlet::Lock()
 {
 	return Account->Parent->Lock(_FL);
 }
 
 void Accountlet::Unlock()
 {
 	Account->Parent->Unlock();
 }
 
 ssize_t Accountlet::Write(const void *buf, ssize_t size, int flags)
 {
 	if (!Account->GetApp())
 		return 0;
 
 	LColour col = SocketMsgTypeToColour((LSocketI::SocketMsgType)flags);
 	I Lck = Lock(_FL);
 	if (Lck)
 	{
 		bool Match = false;
 		LArray<LogEntry*> &Log = Lck->d->Log;
 		if (Log.Length() > 0)
 			Match = Log.Last()->GetColour() == col;
 
 		if (Match)
 		{
 			Log.Last()->Add((const char*)buf, size);
 		}
 		else
 		{
 			LogEntry *le = new LogEntry(col);
 			if (le)
 			{
 				le->Add((const char*)buf, size);
 				Log.Add(le);
 			}
 		}
 	}
 
 	return size;
 }
 
 void Accountlet::OnOnlineChange(bool Online)
 {
 	if (DataStore && Root && Expanded())
 	{
 		// uint64 s = LCurrentTime();
 		Root->Expanded(true);
 		// uint64 e = LCurrentTime();
 		// LgiTrace("Expanded took: %i\n", (int)(e-s));
 	}
 }
 
 bool Accountlet::Connect(LView *p, bool quiet)
 {
 	bool Status = false;
 
 	I Lck = Lock(_FL);
 	if (Lck)
 	{
 		Lck->d->Log.DeleteObjects();
 		Lck.Reset();
 	}
 
 	if (Lock())
 	{
 		Parent = p;
 		Quiet = quiet;
 		if (!Thread)
 		{
 			ReceiveAccountlet *Receive = NULL;
 			if (IsReceive() &&
 				(Receive = &GetAccount()->Receive) &&
 				Receive->IsPersistant())
 			{
 				LVariant Proto = GetAccount()->Receive.Protocol();
 				ScribeWnd *Wnd = GetAccount()->Parent;
 
 				ScribeProtocol Protocol = ProtocolStrToEnum(Proto.Str());
 				#ifdef ImapSupport
 				LString HostName = Server().Str();
 				
 				if (!DataStore &&
 					Protocol == ProtocolImapFull &&
 					ValidStr(HostName))
 				{
 					char Password[256] = "";
 					LPassword p;
 					if (GetPassword(&p))
 					{
 						p.Get(Password);
 					}
 
 					int OpenFlags = MakeOpenFlags(Account, false);
 					MailProtocolProgress *Prog[2] = { &Group, &Item };
 					LAutoPtr<ProtocolSettingStore> Store;
 					char StorePath[128];
 					if (OptionName(NULL, StorePath, sizeof(StorePath)))
 					{
 						Store.Reset(new ProtocolSettingStore(Wnd->GetOptions(), StorePath));
 					}
 					
 					
 					DataStore = OpenImap(HostName,
 										Receive->Port(),
 										UserName().Str(),
 										Password,
 										OpenFlags,
 										Account->GetApp(),
 										GetAccount(),
 										Prog,
 										this,
 										Id(),
 										Store);
 					if (DataStore)
 					{
    						DeleteObj(Root);
     					if ((Root = new ScribeFolder))
     					{
     						Root->App = Account->GetApp();
     						Root->SetLoadOnDemand();
 
 						    LDataFolderI *r = DataStore->GetRoot();
 							if (r)
     							Root->SetObject(r, false, _FL);
 
     						Wnd->Tree->Insert(Root);
     					}
 					}
 				}
 				#endif
 
 				#ifdef WIN32
 				if (!DataStore &&
 					Protocol == ProtocolMapi &&
 					ValidStr(Server().Str()))
 				{
 					char Password[256] = "";
 					LPassword p;
 					if (GetPassword(&p))
 						p.Get(Password);
 
 					DataStore = OpenMapiStore(	Server().Str(),
 												UserName().Str(),
 												Password,
 												Account->Receive.Id(),
 												Account->GetApp());
 					if (DataStore)
 					{
 					    LDataFolderI *r = DataStore->GetRoot();
 					    if (r)
 					    {					    
     						DeleteObj(Root);
     						if ((Root = new ScribeFolder))
     						{
     							Root->App = Account->GetApp();
     							Root->SetLoadOnDemand();
     							Root->SetObject(r, false,_FL);
     							Wnd->Tree->Insert(Root);
     						}
     					}
     					else LgiTrace("%s:%i - Failed to get data store root.\n", _FL);
 					}
 				}
 				#endif
 			}
 			else
 			{
 				// Setup
 				Enabled(false);
 
 				I Lck = Lock(_FL);
 				if (Lck)
 				{
 					Lck->d->Log.DeleteObjects();
 					Lck.Reset();
 				}
 
 				auto StartThread = [this]()
 				{
 					if (Thread.Reset(new AccountletThread(this, 0)))
 					{
 						Thread->Run();
 						Account->Parent->OnBeforeConnect(Account, IsReceive());
 					}
 				};
 
 				// Do we need the password?
 				LString Password;
 				LPassword Psw;
 				GetPassword(&Psw);
 				Password = Psw.Get();
 				auto User = UserName();
 
 				if (User.Str() && !ValidStr(Password))
 				{
 					auto RemoteHost = Server();
 
 					LString Msg;
 					Msg.Printf(LLoadString(IDS_ASK_ACCOUNT_PASSWORD), User.Str(), RemoteHost.Str());
 					GetApp()->GetUserInput(	Parent ? Parent : GetApp(),
 											Msg,
 											true,
 											[this, StartThread](auto Psw)
 											{
 												this->TempPsw = Psw;
 												StartThread();
 											});
 				}
 				else StartThread();		
 			}
 		}
 
 		Unlock();
 	}
 
 	return Status;
 }
 
 void Accountlet::IsCancelled(bool b)
 {
 	if (Thread)
 		Thread->Cancel(b);
 }
 
 bool Accountlet::IsCancelled()
 {
 	return Thread ? Thread->IsCancelled() : false;
 }
 
 char *Accountlet::OptionName(const char *Opt, char *Dest, int DestLen)
 {
 	int Idx = Account->GetIndex();
 	LAssert(Idx >= 0);
 	if (Opt)
 	{
 		if (sprintf_s(Dest, DestLen, "Accounts.Account-%i.%s", Idx, Opt) < 0)
 			return NULL;
 	}
 	else
 	{
 		if (sprintf_s(Dest, DestLen, "Accounts.Account-%i", Idx) < 0)
 			return NULL;
 	}
 	
 	return Dest;
 }
 
 bool Accountlet::GetPassword(LPassword *p)
 {
 	bool Status = false;
 
 	if (p &&
 		OptPassword &&
 		Lock())
 	{
 		char Name[128];
 		OptionName(OptPassword, Name, sizeof(Name));
 		Status = p->Serialize(Account->GetApp()->GetOptions(), Name, false);
 		Unlock();
 	}
 
 	return Status;
 }
 
 void Accountlet::SetPassword(LPassword *p)
 {
 	if (OptPassword &&
 		Lock())
 	{
 		char Name[128];
 		OptionName(OptPassword, Name, sizeof(Name));
 		if (p)
 		{
 			p->Serialize(Account->GetApp()->GetOptions(), Name, true);
 		}
 		else
 		{
 			Account->GetApp()->GetOptions()->DeleteValue(Name);
 		}
 		Unlock();
 	}
 }
 
 bool Accountlet::IsCheckDialup()
 {
 	LVariant CheckDialUp;
 	char Name[128];
 	Account->GetApp()->GetOptions()->GetValue(OptionName(OPT_CheckForDialUp, Name, sizeof(Name)), CheckDialUp);
 	return CheckDialUp.CastInt32() != 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 AccountIdentity::AccountIdentity(ScribeAccount *a) : Accountlet(a)
 {
 }
 
 bool AccountIdentity::IsValid()
 {
 	return	ValidStr(Email().Str()) &&
 			ValidStr(Name().Str());
 }
 
 void AccountIdentity::CreateMaps()
 {
 	char Name[128];
 	Account->Map(OptionName(OPT_AccIdentName, Name, sizeof(Name)), IDC_NAME, GV_STRING);
 	Account->Map(OptionName(OPT_AccIdentEmail, Name, sizeof(Name)), IDC_EMAIL, GV_STRING);
 	Account->Map(OptionName(OPT_AccIdentReply, Name, sizeof(Name)), IDC_REPLY_TO, GV_STRING);
 	Account->Map(OptionName(OPT_AccIdentTextSig, Name, sizeof(Name)), IDC_SIG, GV_STRING);
 	Account->Map(OptionName(OPT_AccIdentHtmlSig, Name, sizeof(Name)), IDC_SIG_HTML, GV_STRING);
 }
 
 bool AccountIdentity::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	/*
 	case SdName:			// Type: String
 	case SdEmail:			// Type: String
 	case SdReply:			// Type: String
 	case SdSig:				// Type: String
 	case SdHtmlSig:			// Type: String
 	*/
 	char n[128];
 	sprintf_s(n, sizeof(n), "Identity.%s", Name);
 	return Accountlet::GetVariant(n, Value, Array);
 }
 
 bool AccountIdentity::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	char n[128];
 	sprintf_s(n, sizeof(n), "Identity.%s", Name);
 	return Accountlet::SetVariant(n, Value, Array);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 SendAccountlet::SendAccountlet(ScribeAccount *a) : Accountlet(a)
 {
 	SendItem = 0;
 
 	// Options
 	OptPassword = OPT_EncryptedSmtpPassword;
 }
 
 SendAccountlet::~SendAccountlet()
 {
 }
 
 bool SendAccountlet::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	/*
 	case SdServer:		// Type: String
 	case SdPort:		// Type: Integer
 	case SdDomain:		// Type: String
 	case SdName:		// Type: String
 	case SdAuth:		// Type: Bool
 	case SdAuthType:	// Type: Integer
 	case SdPrefCharset1: // Type: String
 	case SdPrefCharset2: // Type: String
 	case SdOnlySendThis: // Type: Bool
 	case SdSSL:			// Type: Integer
 	*/
 
 	char n[128];
 	sprintf_s(n, sizeof(n), "Send.%s", Name);
 	return Accountlet::GetVariant(n, Value, Array);
 }
 
 bool SendAccountlet::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	char n[128];
 	sprintf_s(n, sizeof(n), "Send.%s", Name);
 	return Accountlet::SetVariant(n, Value, Array);
 }
 
 void SendAccountlet::CreateMaps()
 {
 	// Fields
 	char Name[256] = "";
 	Account->Map(OptionName(OPT_SmtpServer, Name, sizeof(Name)), IDC_SMTP_SERVER, GV_STRING);
 	Account->Map(OptionName(OPT_SmtpPort, Name, sizeof(Name)), IDC_SMTP_PORT, GV_INT32);
 	Account->Map(OptionName(OPT_SmtpDomain, Name, sizeof(Name)), IDC_SMTP_DOMAIN, GV_STRING);
 	Account->Map(OptionName(OPT_SmtpName, Name, sizeof(Name)), IDC_SMTP_NAME, GV_STRING);
 	Account->Map(OptionName(OPT_SmtpAuth, Name, sizeof(Name)), IDC_SMTP_AUTH, GV_BOOL);
 	Account->Map(OptionName(OPT_SmtpAuthType, Name, sizeof(Name)), IDC_SEND_AUTH_TYPE, GV_INT32);
 	Account->Map(OptionName(OPT_SendCharset1, Name, sizeof(Name)), IDC_SEND_CHARSET1, GV_STRING);
 	Account->Map(OptionName(OPT_SendCharset2, Name, sizeof(Name)), IDC_SEND_CHARSET2, GV_STRING);
 	Account->Map(OptionName(OPT_OnlySendThroughThis, Name, sizeof(Name)), IDC_ONLY_SEND_THIS, GV_BOOL);
 	Account->Map(OptionName(OPT_SmtpSSL, Name, sizeof(Name)), IDC_SEND_SSL, GV_INT32);
 }
 
 ScribeAccountletStatusIcon SendAccountlet::GetStatusIcon()
 {
 	return IsOnline() ? STATUS_ONLINE : STATUS_OFFLINE;
 }
 
 bool SendAccountlet::InitMenus()
 {
 	// Menus
 	LVariant n = Name();
 	LVariant s = Server();
 	LVariant u = UserName();
 	if (s.Str())
 	{
 		char Name[256];
 
 		// Base name of menu
 		if (n.Str())
 		{
 			strcpy_s(Name, sizeof(Name), n.Str());
 		}
 		else if (u.Str())
 		{
 			sprintf_s(Name, sizeof(Name), "%s@%s", u.Str(), s.Str());
 		}
 		else
 		{
 			strcpy_s(Name, sizeof(Name), s.Str());
 		}
 
 		// Add send menuitem
 		if (GetApp()->SendMenu)
 		{
 			LVariant Default;
 			GetApp()->GetOptions()->GetValue(OPT_DefaultSendAccount, Default);
 			if (Default.CastInt32() == Account->GetIndex())
 			{
 				strcat(Name+strlen(Name), "\tCtrl-S");
 			}
 
 			SendItem = GetApp()->SendMenu->AppendItem(Name, IDM_SEND_FROM+Account->GetIndex(), true);
 		}
 
 		return true;
 	}
 
 	return false;
 }
 
 void SendAccountlet::Enabled(bool b)
 {
 	if (Account->GetIndex() == 0)
 	{
 		GetApp()->CmdSend.Enabled(b);
 	}
 	else if (SendItem)
 	{
 		SendItem->Enabled(b);
 	}
 }
 
 void SendAccountlet::Main(AccountletThread *Thread)
 {
 	bool Status = false;
 	bool MissingConfig = false;
 	LStringPipe Err;
 
 	if (GetApp())
 	{
 		LVariant v;
 		GetApp()->GetOptions()->GetValue(OPT_DebugTrace, v);
 		int DebugTrace = v.CastInt32();
 
 		LastOnline = LCurrentTime();
 
 		{
 			MailSink *Sink;
 			// LProtocolLogger Logger(GetApp(), M_SCRIBE_LOG_MSG, &Log);
 
 			LVariant SendHotFolder = HotFolder();
 			if (SendHotFolder.Str() && LDirExists(SendHotFolder.Str()))
 			{
 				Client = Sink = new MailSendFolder(SendHotFolder.Str());
 			}
 			else
 			{
 				Client = Sink = new MailSmtp;
 			}
 
 			if (Client)
 			{
 				LVariant s;
 				if (GetApp()->GetOptions()->GetValue(OPT_ExtraHeaders, s))
 				{
 					Client->ExtraOutgoingHeaders = s.Str();
 				}
 
 				s = PrefCharset1();
 				if (s.Str())
 				{
 					Sink->CharsetPrefs.Add(s.Str());
 				}
 				
 				s = PrefCharset2();
 				if (s.Str())
 				{
 					Sink->CharsetPrefs.Add(s.Str());
 				}
 			}
 
 			if (Outbox.Length())
 			{
 				int n = 0;
 				
 				for (unsigned Idx=0; Idx<Outbox.Length(); Idx++)
 				{
 					ScribeEnvelope *m = Outbox[Idx]; 
 					char Buf[256];
 					MakeTempPath(Buf, sizeof(Buf));
 					MailTransferEvent *t = new MailTransferEvent;
 					if (t)
 					{
 						t->Action = MailUpload;
 						t->Index = n++;
 						t->Send = m;
 
 						Thread->Files.Insert(t);
 					}
 				}
 				
 if (DebugTrace) LgiTrace("Send(%i) got %i mail to send\n", Account->GetIndex(), Thread->Files.Length());
 
 				if (Sink &&
 					Thread->Files.Length())
 				{
 					Sink->Logger = this;
 					Sink->Transfer = &Item;
 
 					if (Client)
 					{
 						LVariant _HotFld = HotFolder();
 						LVariant _Server = Server();
 						LVariant _Domain = Domain();
 						LVariant _UserName = UserName();
 						LString _Password;
 						int Sent = 0;
 						// int Total = Outbox.Length();
 						LVariant HideId = false;
 						auto Opts = GetApp()->GetOptions();
 						Opts->GetValue(OPT_HideId, HideId);
 						if (!HideId.CastInt32())
 						{
 							Opts->GetValue(OPT_HideId, HideId);
 							Client->ProgramName = GetFullAppName(!HideId.CastInt32());
 						}
 						Client->SetSettingStore(Opts);
 
 						if (ValidStr(_HotFld.Str()) ||
 							ValidStr(_Server.Str()))
 						{
 							bool Error = false;
 
 							if (RequireAuthentication())
 							{
 								LPassword p;
 								if (GetPassword(&p))
 									_Password = p.Get();
 							}
 
 if (DebugTrace) LgiTrace("Send(%i) connecting to SMTP server\n", Account->GetIndex());
 
 							Thread->SetState(ThreadConnecting);
 							
 							int OpenFlags = MakeOpenFlags(Account, true);
 							auto Params = GetOAuth2Params(_Server.Str(), MAGIC_MAIL);
 							if (Params.IsValid())
 							{
 								Sink->SetOAuthParams(Params);
 							}
 							
 							if (!Sink->Open(CreateSocket(true, GetAccount(), true),
 											_Server.Str(),
 											_Domain.Str(),
 											_UserName.Str(),
 											_Password,
 											Port(),
 											OpenFlags))
 							{
 if (DebugTrace) LgiTrace("Send(%i) %s:%i\n", Account->GetIndex(), _FL);
 								Err.Push(LLoadString(IDS_NO_CONNECTION_TO_SERVER));
 								Err.Push("\n");
 							}
 							else
 							{
 if (DebugTrace) LgiTrace("Send(%i) connected\n", Account->GetIndex());
 
 								Group.Value = 0;
 								Group.Range = Thread->Files.Length();
 
 								Thread->SetState(ThreadTransfer);
 								
 								MailTransferEvent *e = NULL;
 								for (auto FileIt = Thread->Files.begin();
 									FileIt != Thread->Files.end() &&
 										(e = dynamic_cast<MailTransferEvent*>(*FileIt)) &&
 										!Thread->IsCancelled();
 									FileIt++, Group.Value++)
 								{
 if (DebugTrace) LgiTrace("Send(%i) Item(%i) starting send\n", Account->GetIndex(), Group.Value);
 									
 									AddressDescriptor From;
 									From.sAddr = e->Send->From;
 
 									List<AddressDescriptor> ToLst;
 									for (unsigned n=0; n<e->Send->To.Length(); n++)
 									{
 										AddressDescriptor *ad = new AddressDescriptor;
 										ad->sAddr = e->Send->To[n];
 										ToLst.Insert(ad);
 									}
 									
 									MailProtocolError SendErr;
 									LStringPipe *Out = Sink->SendStart(ToLst, &From, &SendErr);
 									List<AddressDescriptor> *To = &ToLst;
 
 									bool BadAddress = false;
 									for (auto a: *To)
 									{
 										if (!a->Status)
 										{
 											if (a->sAddr.Find(",") >= 0)
 											{
 												auto t = a->sAddr.SplitDelimit(",");
 												for (unsigned i=0; i<t.Length(); i++)
 													Err.Print("%s\n", t[i].Get());
 											}
 											else
 											{
 												Err.Print("%s\n", a->Print().Get());
 											}
 											BadAddress = true;
 										}
 									}
 									if (BadAddress)
 									{
 										LString m;
 										m.Printf(LLoadString(Sink->ErrMsgId, Sink->ErrMsgFmt), Sink->ErrMsgParam.Get());
 										Err.Push(m.Get());
 									}
 
 									if (Out)
 									{
 										LStringPipe InetHeaders;
 										ssize_t Len = e->Send->Rfc822.Length();
 										ssize_t Written = 0;
 										
 										Item.Range = Len;
 										Item.Start = LCurrentTime();
 										
 										for (ssize_t Pos = 0; Pos < Len; )
 										{
 											ssize_t Remaining = Len - Pos;
 											ssize_t Block = MIN(Remaining, 4 << 10);
 											ssize_t Wr = Out->Write(e->Send->Rfc822.Get() + Pos, Block);
 											if (Wr <= 0)
 												break;
 											
 											Pos += Wr;
 											Written += Wr;
 											Item.Value = Pos;
 										}
 										
 										Item.Start = 0;
 										
 										if (Written == Len)
 										{
 											if (Sink->SendEnd(Out))
 											{
 if (DebugTrace) LgiTrace("Send(%i) Item(%i) success\n", Account->GetIndex(), Group.Value);
 												Status = true;
 												Sent++;
 												e->OutgoingHeaders = InetHeaders.NewStr();
 												
 												if (e->Send->References)
 												{
 													GetApp()->PostEvent(M_SCRIBE_SET_MSG_FLAG,
 																		(LMessage::Param)NewStr(e->Send->References),
 																		MAIL_REPLIED);
 												}
 												if (e->Send->FwdMsgId)
 												{
 													GetApp()->PostEvent(M_SCRIBE_SET_MSG_FLAG,
 																		(LMessage::Param)NewStr(e->Send->FwdMsgId),
 																		MAIL_FORWARDED);
 												}
 												if (e->Send->BounceMsgId)
 												{
 													GetApp()->PostEvent(M_SCRIBE_SET_MSG_FLAG,
 																		(LMessage::Param)NewStr(e->Send->BounceMsgId),
 																		MAIL_BOUNCED);
 												}
 
 												e->Account = this;
 												e->Status = MailReceivedWaiting;
 												GetApp()->OnMailTransferEvent(e);
 											}
 											else
 											{
 												Write("SendEnd failed.\n", -1, LSocketI::SocketMsgError);
 												Error = true;
 												break;
 											}
 										}
 										else
 										{
 											Write("Encoding failed.\n", -1, LSocketI::SocketMsgError);
 											Error = true;
 											break;
 										}
 									}
 									else
 									{
 										LString s;
 										s.Printf("SendStart failed: %i, %s\n", SendErr.Code, SendErr.ErrMsg.Get());
 										Write(s, -1, LSocketI::SocketMsgError);
 										Error = true;
 										break;
 									}
 								}
 
 if (DebugTrace) LgiTrace("Send(%i) closing, Error=%i\n", Account->GetIndex(), Error);
 								if (Error)
 								{
 									// we can't call Client->Close() on error because it
 									// sends a quit command and expects a reply. Under
 									// error conditions that can fail because the server
 									// might not be in a state to handle that request.
 									// So just close the socket and call it a day.
 if (DebugTrace) LgiTrace("Send(%i) %s:%i\n", Account->GetIndex(), _FL);
 									Sink->CloseSocket();
 								}
 								else
 								{
 									// Normal quit
 if (DebugTrace) LgiTrace("Send(%i) %s:%i\n", Account->GetIndex(), _FL);
 									Sink->Close();
 								}
 
 if (DebugTrace) LgiTrace("Send(%i) %s:%i\n", Account->GetIndex(), _FL);
 								Group.Value = 0;
 								Group.Range = 0;
 								Item.Value = 0;
 								Item.Range = 0;
 
 								Status &= WaitForTransfers(Thread->Files);
 							}
 
 if (DebugTrace) LgiTrace("Send(%i) %s:%i, status=%i\n", Account->GetIndex(), _FL, Status);
 							if (!Status)
 							{
 if (DebugTrace) LgiTrace("Send(%i) %s:%i, Client=%p\n", Account->GetIndex(), _FL, Client);
 								if (ValidStr(Client->ErrMsgFmt))
 								{
 									LString m;
 									m.Printf(LLoadString(Sink->ErrMsgId, Sink->ErrMsgFmt), Sink->ErrMsgParam.Get());
 
 									Err.Push("\n");
 									Err.Push(m.Get());
 									Err.Push("\n");
 								}
 							}
 						}
 						else
 						{
 							MissingConfig = true;
 							Err.Push(LLoadString(IDS_NO_SMTP_SERVER_SETTINGS));
 							Err.Push("\n");
 						}
 					}
 
 if (DebugTrace) LgiTrace("Send(%i) %s:%i, Thread=%p\n", Account->GetIndex(), _FL, Thread);
 if (DebugTrace) LgiTrace("Send(%i) %s:%i\n", Account->GetIndex(), _FL);
 				}
 
 				Outbox.DeleteObjects();
 			}
 
 			DeleteObj(Sink);
 		}
 
 if (DebugTrace) LgiTrace("Send(%i) exit\n", Account->GetIndex());
 	}
 	else
 	{
 		Thread->SetState(ThreadError);
 	}
 
 	char *e = 0;
 	if (MissingConfig)
 	{
 		Err.Push(LLoadString(IDS_ASK_ABOUT_OPTIONS));
 		Err.Push("\n");
 		e = Err.NewStr();
 		GetApp()->PostEvent(M_SCRIBE_MSG, (LMessage::Param)e, 1);
 	}
 	else if ((e = Err.NewStr()))
 	{
 		GetApp()->PostEvent(M_SCRIBE_MSG, (LMessage::Param)e);
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////
 ReceiveAccountlet::ReceiveAccountlet(ScribeAccount *a) : Accountlet(a)
 {
 	// Init
 	SecondsTillOnline = -1;
 
 	LVariant Ct = CheckTimeout();
 	if (Ct.Str())
 	{
 		SecondsTillOnline = GetCheckTimeout();
 	}
 
 	ReceiveItem = 0;
 	PreviewItem = 0;
 	Items = 0;
 	IdTemp = 0;
 
 	char Key[128];
 	OptionName("Messages", Key, sizeof(Key));
 	Msgs.Reset(new MsgList(a->GetApp()->GetOptions(), Key));
 	OptionName("Spam", Key, sizeof(Key));
 	Spam.Reset(new MsgList(a->GetApp()->GetOptions(), Key));
 
 	// Upgrade props
 	LVariant OldType = -1;
 	char Buf[128];
 	LOptionsFile *Options = GetApp()->GetOptions();
 	if (Options->GetValue(OptionName(OPT_Pop3Type, Buf, sizeof(Buf)), OldType))
 	{
 		// Old Account types: 
 		#define MAIL_SOURCE_POP3			0
 		#define MAIL_SOURCE_IMAP4			1
 		#define MAIL_SOURCE_MAPI			2
 		#define MAIL_SOURCE_SCP				3
 		#define MAIL_SOURCE_HTTP			4
 
 		switch (OldType.CastInt32())
 		{
 			case MAIL_SOURCE_POP3:
 				Protocol(PROTOCOL_POP3); break;
 			case MAIL_SOURCE_IMAP4:
 				Protocol(PROTOCOL_IMAP4_FETCH); break;
 			case MAIL_SOURCE_SCP:
 				Protocol(PROTOCOL_CALENDAR); break;
 			case MAIL_SOURCE_HTTP:
 				Protocol(PROTOCOL_POP_OVER_HTTP); break;
 			case MAIL_SOURCE_MAPI:
 				Protocol(PROTOCOL_MAPI); break;
 		}
 		
 		Options->DeleteValue(Buf);
 	}
 
 	char Name[256] = "";
 	LVariant Auto;
 	if (!Options->GetValue(OptionName(OPT_Pop3AutoReceive, Name, sizeof(Name)), Auto))
 	{
 		LVariant s;
 		Options->GetValue(OptionName(OPT_Pop3CheckEvery, Name, sizeof(Name)), s);
 		if (s.Str())
 		{
 			int Timeout = atoi(s.Str());
 			Options->SetValue(OptionName(OPT_Pop3AutoReceive, Name, sizeof(Name)), s = (Timeout > 0));
 		}
 	}
 
 
 	// Options
 	OptPassword = OPT_EncryptedPop3Password;
 }
 
 ReceiveAccountlet::~ReceiveAccountlet()
 {
 }
 
 bool ReceiveAccountlet::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {	
 	char n[128];
 	sprintf_s(n, sizeof(n), "Receive.%s", Name);
 	return Accountlet::GetVariant(n, Value, Array);
 }
 
 bool ReceiveAccountlet::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	char n[128];
 	sprintf_s(n, sizeof(n), "Receive.%s", Name);
 	return Accountlet::SetVariant(n, Value, Array);
 }
 
 ScribeAccountletStatusIcon ReceiveAccountlet::GetStatusIcon()
 {
 	if (DataStore)
 	{
 		int64 s = DataStore->GetInt(FIELD_STORE_STATUS);
 		if (s >= STATUS_OFFLINE && s < STATUS_MAX)
 			return (ScribeAccountletStatusIcon)s;
 	}
 
 	if (IsOnline())
 		return STATUS_ONLINE;
 
 	if (!GetStatus())
 		return STATUS_ERROR;
 
 	if (AutoReceive())
 		return STATUS_WAIT;
 
 	return STATUS_OFFLINE;
 }
 
 void ReceiveAccountlet::CreateMaps()
 {
 	char Name[256] = "";
 
 	// Fields
 	Account->Map(OptionName(OPT_Pop3Protocol, Name, sizeof(Name)), IDC_REC_TYPE, GV_STRING);
 	Account->Map(OptionName(OPT_Pop3Server, Name, sizeof(Name)), IDC_REC_SERVER, GV_STRING);
 	Account->Map(OptionName(OPT_Pop3Port, Name, sizeof(Name)), IDC_REC_PORT, GV_INT32);
 	Account->Map(OptionName(OPT_Pop3Name, Name, sizeof(Name)), IDC_REC_NAME, GV_STRING);
 	Account->Map(OptionName(OPT_Pop3AutoReceive, Name, sizeof(Name)), IDC_CHECK_EVERY, GV_BOOL);
 	Account->Map(OptionName(OPT_Pop3CheckEvery, Name, sizeof(Name)), IDC_REC_CHECK, GV_STRING);
 	
 	Account->Map(OptionName(OPT_Pop3LeaveOnServer, Name, sizeof(Name)), IDC_POP3_LEAVE, GV_BOOL);
 	Account->Map(OptionName(OPT_DeleteAfter, Name, sizeof(Name)), IDC_DELETE_AFTER, GV_BOOL);
 	Account->Map(OptionName(OPT_DeleteDays, Name, sizeof(Name)), IDC_DELETE_DAYS, GV_INT32);
 	Account->Map(OptionName(OPT_DeleteIfLarger, Name, sizeof(Name)), IDC_DELETE_LARGER, GV_BOOL);
 	Account->Map(OptionName(OPT_DeleteIfLargerSize, Name, sizeof(Name)), IDC_DELETE_SIZE, GV_INT32);
 
 	Account->Map(OptionName(OPT_Pop3Folder, Name, sizeof(Name)), IDC_FOLDER, GV_STRING);
 	Account->Map(OptionName(OPT_MaxEmailSize, Name, sizeof(Name)), IDC_MAX_SIZE, GV_INT32);
 	Account->Map(OptionName(OPT_Receive8BitCs, Name, sizeof(Name)), IDC_REC_8BIT_CS, GV_STRING);
 	Account->Map(OptionName(OPT_ReceiveAsciiCs, Name, sizeof(Name)), IDC_REC_ASCII_CP, GV_STRING);
 	Account->Map(OptionName(OPT_ReceiveAuthType, Name, sizeof(Name)), IDC_RECEIVE_AUTH_TYPE, GV_INT32);
 	Account->Map(OptionName(OPT_Pop3SSL, Name, sizeof(Name)), IDC_RECEIVE_SSL, GV_INT32);
 	Account->Map(OptionName(OPT_ReceiveSecAuth, Name, sizeof(Name)), IDC_SEC_AUTH, GV_INT32);
 }
 
 int ReceiveAccountlet::GetCheckTimeout()
 {
 	int Sec = -1;
 	LVariant Timeout = CheckTimeout();
 	if (Timeout.Str())
 	{
 		auto t = Timeout.LStr().SplitDelimit(":");
 		if (t.Length() == 2)
 		{
 			Sec = (atoi(t[0]) * 60) + atoi(t[1]);
 		}
 		else
 		{
 			Sec = atoi(Timeout.Str()) * 60;
 		}
 	}
 	return Sec;
 }
 
 bool ReceiveAccountlet::InitMenus()
 {
 	// Menus
 	LVariant n = Name();
 	LVariant s = Server();
 	LVariant u = UserName();
 	if (IsConfigured())
 	{
 		char Name[256];
 
 		// Base name of menu
 		if (n.Str())
 			strcpy_s(Name, sizeof(Name), n.Str());
 		else if (u.Str() && s.Str())
 			sprintf_s(Name, sizeof(Name), "%s@%s", u.Str(), s.Str());
 		else if (u.Str())
 			strcpy_s(Name, sizeof(Name), u.Str());
 		else if (s.Str())
 			strcpy_s(Name, sizeof(Name), s.Str());
 		else
 			strcpy_s(Name, sizeof(Name), "(untitled)");
 
 		// Add preview menuitem
 		if (GetApp()->PreviewMenu)
 		{
 			PreviewItem = GetApp()->PreviewMenu->AppendItem(Name, IDM_PREVIEW_FROM+Account->GetIndex(), !Disabled());
 		}
 
 		// Add shortcut
 		if (Account->GetIndex() < 9)
 		{
 			size_t Len = strlen(Name);
 			sprintf_s(Name+Len, sizeof(Name)-Len, "\tCtrl+%i", Account->GetIndex()+1);
 		}
 
 		// Add receive menuitem
 		if (GetApp()->ReceiveMenu)
 		{
 			ReceiveItem = GetApp()->ReceiveMenu->AppendItem(Name, IDM_RECEIVE_FROM+Account->GetIndex(), !Disabled());
 		}
 
 		return true;
 	}
 
 	return false;
 }
 
 bool ReceiveAccountlet::RemoveFromSpamIds(const char *Id)
 {
 	if (!Id || !Spam)
 		return false;
 
 	if (!Lock())
 		return false;
 
 	Spam->Delete(Id);
 	Spam->Dirty = true;
 
 	Unlock();
 
 	return true;
 }
 
 void ReceiveAccountlet::DeleteAsSpam(const char *Id)
 {
 	if (HasMsg(Id))
 	{
 		RemoveMsg(Id);
 
 		if (Lock())
 		{
 			if (Spam)
 			{
 				if (!Spam->Find(Id))
 				{
 					Spam->Add(Id);
 					Spam->Dirty = true;
 				}
 			}
 
 			Unlock();
 		}
 	}
 }
 
 bool ReceiveAccountlet::IsSpamId(const char *Id, bool Delete)
 {
 	bool Status = false;
 
 	if (ValidStr(Id))
 	{
 		if (Lock())
 		{
 			if (Spam)
 			{
 				Status = Spam->Find(Id);
 			}
 
 			Unlock();
 		}
 	}	
 
 	return Status;
 }
 
 bool ReceiveAccountlet::SetActions(LArray<ReceiveAction> *a)
 {
 	bool Status = false;
 
 	if (Lock())
 	{
 		if (!IsOnline())
 		{
 			if (a)
 				Actions = *a;
 			else
 				Actions.Length(0);
 
 			Status = true;
 		}
 		else LAssert(!"Trying to set actions when online is forbidden.");
 
 		Unlock();
 	}
 
 	return Status;
 }
 
 bool ReceiveAccountlet::SetItems(LList *l)
 {
 	bool Status = false;
 
 	if (Lock())
 	{
 		Items = l;
 		Status = true;
 
 		Unlock();
 	}
 
 	return Status;
 }
 
 void ReceiveAccountlet::Enabled(bool b)
 {
 	if (Account->GetIndex() == 0)
 	{
 		GetApp()->CmdReceive.Enabled(b);
 		GetApp()->CmdPreview.Enabled(b);
 	}
 
 	if (ReceiveItem)
 	{
 		ReceiveItem->Enabled(b);
 	}
 	if (PreviewItem)
 	{
 		PreviewItem->Enabled(b);
 	}
 }
 
 int FilterCompare(Filter *a, Filter *b, NativeInt Data)
 {
 	return a->GetIndex() - b->GetIndex();
 }
 
 bool ReceiveAccountlet::IsPersistant()
 {
 	LVariant Proto = Protocol();
 	if (Proto.Str())
 	{
 		#ifdef ImapSupport
 		if (_stricmp(Proto.Str(), PROTOCOL_IMAP4) == 0)
 			return true;
 		#endif
 		
 		#ifdef WIN32
 		if (!_stricmp(Proto.Str(), PROTOCOL_MAPI))
 			return true;
 		#endif
 	}
 
 	return false;
 }
 
 int64 ConvertRelativeSize(char *Size, int64 Total)
 {
 	int64 Status = -1;
 	if (Size)
 	{
 		double f = atof(Size);
 		if (strchr(Size, '%'))
 		{
 			Status = (int64)(Total * f) / 100;
 		}
 		else if (stristr(Size, "KB"))
 		{
 			Status = (int64)(f * 1024);
 		}
 		else if (stristr(Size, "MB"))
 		{
 			Status = (int64)(f * 1024 * 1024);
 		}
 		else if (stristr(Size, "GB"))
 		{
 			Status = (int64)(f * 1024 * 1024 * 1024);
 		}
 		else
 		{
 			Status = (int64)f;
 		}
 	}
 
 	return Status;
 }
 
 struct MailReceiveParams
 {
 	ScribeWnd *App;
 	AccountletThread *Thread;
 
 	uint64 MaxSize;
 	uint64 NoAttachLimit;
 	uint64 NoDownloadLimit;
 	char *KitFileName;
 	int DownloadLines;
 
 	MailReceiveParams()
 	{
 		App = 0;
 		Thread = 0;
 
 		MaxSize = 0;
 		NoAttachLimit = 0;
 		NoDownloadLimit = 0;
 		KitFileName = 0;
 		DownloadLines = 0;
 	}
 };
 
 bool AfterReceived(MailTransaction *Trans, void *Data)
 {
 	if (Trans->Oversize)
 	{
 	}
 	else if (Trans->Status)
 	{
 		MailReceiveParams *p = (MailReceiveParams*) Data;
 		if (!p)
 			return false;
 
 		MailTransferEvent *t = p->Thread->Files[Trans->Index];
 		if (!t)
 			return false;
 
 		Trans->Flags |= MAIL_POSTED_TO_GUI;
 
 		if (t->Rfc822Msg)
 		{
 			// t->Data->Parse();
 		}
 
 		// Set the event status
 		t->Status = MailReceivedWaiting;
 		t->Account = p->Thread->GetAccountlet();
 
 		// Ask the gui thread to load the mail in
 		p->App->OnMailTransferEvent(t);
 	}
 
 	return true;
 }
 
 MailSrcStatus ReceiveCallback(MailTransaction *Trans, uint64 Size, int *TopLines, void *Data)
 {
 	MailReceiveParams *Params = (MailReceiveParams*) Data;
 
 	if (Params->KitFileName)
 	{
 		uint64 Free;
 		if (LGetDriveInfo(Params->KitFileName, &Free))
 		{
 			if (Free <= Params->NoDownloadLimit)
 			{
 				return DownloadNone;
 			}
 			else if (Free <= Params->NoAttachLimit)
 			{
 				if (TopLines && Params->DownloadLines > 0)
 				{
 					*TopLines = Params->DownloadLines;
 				}
 
 				return DownloadTop;
 			}
 		}
 	}
 
 	if (Params->MaxSize)
 	{
 		if (Size > Params->MaxSize)
 		{
 			if (!TestFlag(Trans->Flags, MAIL_EXPLICIT))
 			{
 				return DownloadNone;
 			}
 		}
 	}
 
 	return DownloadAll;
 }
 
 bool ReceiveAccountlet::OnIdle()
 {
  	return DataStore ? DataStore->OnIdle() : false;
 }
 
 void ReceiveAccountlet::Main(AccountletThread *Thread)
 {
 	bool Status = false;
 	LVariant v;
 
 	LastOnline = LCurrentTime();
 	#define TimeDelta() ((int) (LCurrentTime() - LastOnline))
 	SecondsTillOnline = -1;
 
 int DebugTrace = false;
 GetApp()->GetOptions()->GetValue(OPT_DebugTrace, v);
 DebugTrace = v.CastInt32();
 if (DebugTrace) LgiTrace("Receive(%i) starting, %i\n", Account->GetIndex(), TimeDelta());
 
 	auto RemoteHost = Server();
 	auto RemotePort = Port();
 	auto User = UserName();
 
 	// int LeaveCopy = LeaveOnServer();
 	int DeleteIfLargerThan = DeleteLarger() ? DeleteSize() << 10 : 0;
 
 	MailReceiveParams Params;
 	Params.App = GetApp();
 	Params.Thread = Thread;
 	Params.MaxSize = DownloadLimit() << 10;
 
 	auto MailSourceType = ProtocolStrToEnum(Protocol().Str());
 	// auto Ms = GetApp()->GetDefaultMailStore();
 
 	LString Password;
 
 	LPassword Psw;
 	GetPassword(&Psw);
 	Password = Psw.Get();
 
 	MailSource *Source = 0;
 	LVariant RecHotFolder = HotFolder();
 	if (RecHotFolder.Str() && LDirExists(RecHotFolder.Str()))
 	{
 		Client = Source = new MailReceiveFolder(RecHotFolder.Str());
 	}
 	else
 	{
 		switch (MailSourceType)
 		{
 			case ProtocolPop3:
 			{
 				Client = Source = new MailPop3;
 				break;
 			}
 			case ProtocolImapFetch:
 			{
 				Client = Source = new MailIMap;
 				break;
 			}
 			case ProtocolPopOverHttp:
 			{
 				Client = Source = new MailPhp;
 				break;
 			}
 			default:
 			{
 				LAssert(!"Unsupported protocol.");
 				return;
 			}
 		}
 	}
 
 if (DebugTrace) LgiTrace("Receive(%i) protocol=%i client=%p, time=%i\n", Account->GetIndex(), MailSourceType, Client, TimeDelta());
 
 	if (Source)
 	{
 		auto HttpProxy = GetApp()->GetHttpProxy();
 		if (HttpProxy)
 		{
 			LUri Host(HttpProxy);
 			if (Host.sHost)
 				Source->SetProxy(Host.sHost, Host.Port?Host.Port:80);
 		}
 	
 		// Setup logging
 		Source->Logger = this;
 		Source->Items = &Group;
 		Source->Transfer = &Item;
 
 		auto OpenFlags = MakeOpenFlags(Account, false);
 		auto NeedsPassword = !ValidStr(Password) && ValidStr(User.Str());
 		if (NeedsPassword)
 		{
 			if (TempPsw)
 				Password = TempPsw;
 			else if (!SecureAuth())
 				LAssert(!"Need to ask user for password BEFORE we're in the worker thread.");
 		}
 
 if (DebugTrace) LgiTrace("Receive(%i) opening connection..., time=%i\n", Account->GetIndex(), TimeDelta());
 		Thread->SetState(ThreadConnecting);
 
 		LHashTbl<StrKey<char>,bool> Uids;
 		ReceiveAccountlet *Receive = dynamic_cast<ReceiveAccountlet*>(Thread->Acc);
 
 		if (!RecHotFolder.Str() && !SecureAuth() && !ValidStr(Password))
 		{
 			Status = true;
 		}
 		else if (!Source->Open(	CreateSocket(false, GetAccount(), false),
 								RemoteHost.Str(),
 								RemotePort,
 								User.Str(),
 								Password,
 								SettingStore,
 								OpenFlags))
 		{
 			Thread->SetState(ThreadError);
 		}
 		else
 		{
 if (DebugTrace) LgiTrace("Receive(%i) connected, time=%i\n", Account->GetIndex(), TimeDelta());
 			SecondsTillOnline = -1;
 
 			// Get all the messages..
 			Thread->SetState(ThreadTransfer);
 			auto Msgs = Source->GetMessages();
 			if (Msgs)
 			{
 				bool LeaveOnServer = Receive->LeaveOnServer() != 0;
 				bool DeleteAfter = Receive->DeleteAfter() != 0;
 				int DeleteDays = Receive->DeleteDays();
 				bool GetUids = LeaveOnServer;
 				bool HasGetHeaders = false;
 
 				if (DeleteDays < 1)
 				{
 					Receive->DeleteDays(DeleteDays = 1);
 				}
 
 				for (int i=0; i<Msgs; i++)
 				{
 					MailTransferEvent *t = new MailTransferEvent;
 					if (t)
 					{
 						t->Rfc822Msg.Reset(new LTempStream(ScribeTempPath()));
 						t->Index = i;
 
 						if (Actions.Length())
 						{
 							t->Action = (unsigned)i < Actions.Length() ? Actions[i] : MailNoop;
 							t->Explicit = true;
 						}
 						else if (Receive->Items)
 						{
 							t->Action = MailHeaders;
 							GetUids = true;
 						}
 						else
 						{
 							t->Action = LeaveOnServer ? MailDownload : MailDownloadAndDelete;
 						}
 
 						switch (t->Action)
 						{
 							default:
 								break;
 							case MailHeaders:
 							{
 								HasGetHeaders = true;
 								// fall thru
 							}
 							case MailDownloadAndDelete:
 							case MailDownload:
 							case MailUpload:
 							{
 								Group.Range++;
 								break;
 							}
 						}
 
 						Thread->Files.Insert(t);
 					}
 				}
 
 if (DebugTrace) LgiTrace("Receive(%i) got %i actions, time=%i\n", Account->GetIndex(), Thread->Files.Length(), TimeDelta());
 
 				if (HasGetHeaders || DeleteIfLargerThan)
 				{
 					LArray<int64_t> Sizes;
 					if (Source->GetSizes(Sizes))
 					{
 						unsigned i = 0;
 						for (auto t: Thread->Files)
 						{
 							if (i >= Sizes.Length())
 								break;
 
 							t->Size = Sizes[i];
 
 							if (t->Action == MailHeaders)
 							{
 								t->Msg = new AccountMessage(Account);
 								if (t->Msg)
 								{
 									t->Msg->Size = t->Size;
 								}
 							}
 							i++;
 						}
 					}
 				}
 
 				// Getting the UID's of the messages on the server
 				if (GetUids || Receive->Msgs->Length() > 0)
 				{
 if (DebugTrace) LgiTrace("Receive(%i) getting UID's, time=%i\n", Account->GetIndex(), TimeDelta());
 					LString::Array UidLst;
 					Source->GetUidList(UidLst);
 					for (auto u: UidLst)
 						Uids.Add(u, true);
 
 					// Assign all the ID strings to the transfer events
 					LDateTime Now;
 					Now.SetNow();
 					for (auto t: Thread->Files)
 					{
 						auto k = UidLst[0];
 						if (k)
 						{
 							UidLst.DeleteAt(0, true);
 							t->Uid = k;
 if (DebugTrace) LgiTrace("\tUid[%i]='%s' (time=%i)\n", t->Index, t->Uid.Get(), TimeDelta());
 						}
 						else break;
 
 						if (!t->Explicit && DeleteAfter)
 						{
 							// Check how long the message has been on the server.
 							LDateTime MsgDate;
 							if (Receive->Msgs->GetDate(t->Uid, &MsgDate))
 							{
 								LDateTime Days = Now - MsgDate;
 								if (Days.Day() > DeleteDays)
 								{
 									if (t->Action == MailDownload)
 										t->Action = MailDownloadAndDelete;
 								}
 							}
 						}
 					}
 				}
 
 if (DebugTrace) LgiTrace("Receive(%i) starting main action loop, time=%i\n", Account->GetIndex(), TimeDelta());
 				
 				Group.Start = LCurrentTime();
 				bool Error = false;
 				LArray<MailTransaction*> Trans;
 				char NotLoaded[256];
 				sprintf_s(	NotLoaded, sizeof(NotLoaded),
 							"%s: %s",
 							LLoadString(FIELD_SUBJECT),
 							LLoadString(IDS_NOT_LOADED));	
 
 				for (auto it = Thread->Files.rbegin();
 					it != Thread->Files.end() && !Thread->IsCancelled();
 					it--)
 				{
 					MailTransferEvent *t = *it;
 					if (!t)
 						continue;
 						
 					bool Ok = false;
 					switch (t->Action)
 					{
 						case MailDownload:
 						case MailDownloadAndDelete:
 						{
 							if (!t->Explicit &&
 								t->Uid &&
 								Receive->Msgs->Find(t->Uid))
 							{
 								// Already got it...
 // if (DebugTrace) LgiTrace("Receive(%i) Item(%i) Already got msg\n", Account->GetIndex(), t->Index);
 								Status = true;
 								Group.Value++;
 
 								if (DeleteIfLargerThan > 0 &&
 									t->Size > 0 &&
 									t->Size > DeleteIfLargerThan)
 								{
 									t->Action = MailDelete;
 								}
 								continue;
 							}
 							else
 							{
 								if (t->Uid && Receive->IsSpamId(t->Uid))
 								{
 									// Delete the spam
 									t->Action = MailDelete;
 									Status = true;
 									Group.Value++;
 									continue;
 								}
 								else
 								{
 									// Download it
 									MailTransaction *Get = new MailTransaction;
 									if (Get)
 									{
 										if (t->Explicit)
 											Get->Flags |= MAIL_EXPLICIT;
 
 										Get->Index = t->Index;
 										Get->Stream = t->Rfc822Msg;
 										Trans.Add(Get);
 										continue;										
 									}
 								}
 								Group.Value++;
 							}
 							break;
 						}
 						case MailHeaders:
 						{
 if (DebugTrace) LgiTrace("Receive(%i) Item(%i) Getting headers..., time=%i\n", Account->GetIndex(), t->Index, TimeDelta());
 							auto Headers = Source->GetHeaders(t->Index);
 if (DebugTrace) LgiTrace("Receive(%i) Item(%i) headers=%p, time=%i\n", Account->GetIndex(), t->Index, Headers.Get(), TimeDelta());
 
                             if (!Headers)
 								Headers = NotLoaded;
 							
 							if (Headers)
 							{
 								if (!t->Msg)
 									t->Msg = new AccountMessage(Account);
 								if (t->Msg)
 								{
-									bool Attachments = false;
-									LAutoString ContentType(InetGetHeaderField(Headers, "Content-Type"));
-									if (ContentType)
-									{
-										Attachments = stristr(ContentType, "multipart/mixed") != NULL;
-									}
-
 									t->Msg->Index = t->Index;
-
-									LAutoString From(DecodeRfc2047(InetGetHeaderField(Headers, "From")));
-									LAutoString Subject(DecodeRfc2047(InetGetHeaderField(Headers, "Subject")));
-									t->Msg->From = From.Get();
-									t->Msg->Subject = LString(Subject).Replace("\n");
 									t->Msg->ServerUid = t->Uid;
+									t->Msg->From = LDecodeRfc2047(LGetHeaderField(Headers, "From"));
+									t->Msg->Subject = LDecodeRfc2047(LGetHeaderField(Headers, "Subject")).Replace("\n");
 									
-									LAutoString d(InetGetHeaderField(Headers, "Date"));
-									if (d)
-										t->Msg->Date.Decode(d);
+									auto date = LGetHeaderField(Headers, "Date");
+									if (date)
+										t->Msg->Date.Decode(date);
 									
-									t->Msg->Attachments = Attachments;
-									
+									t->Msg->Attachments = LGetHeaderField(Headers, "Content-Type").Find("multipart/mixed") >= 0;
 									if (IsSpamId(t->Uid))
 									{
 										t->Msg->Download->Value(false);
 										t->Msg->Delete->Value(true);
 										t->Msg->New = false;
 									}
 									else
 									{
 										t->Msg->New = !HasMsg(t->Uid);
 									}
 									
 									Ok = true;
 								}
 							}
 
 							Group.Value++;
 							break;
 						}
 						default:
 						{
 							continue;
 						}
 					}
 
 					if (Ok)
 					{
 						Status = true;
 						t->Account = this;
 						t->Status = MailReceivedWaiting;							
 						GetApp()->OnMailTransferEvent(t);
 					}
 					else
 					{
 if (DebugTrace) LgiTrace("Receive(%i) Item(%i) Error, time=%i\n", Account->GetIndex(), t->Index, TimeDelta());
 						Error = true;
 						break;
 					}
 				}
 
 				if (Trans.Length() > 0)
 				{
 					MailCallbacks Callbacks;
 					ZeroObj(Callbacks);
 					Callbacks.CallbackData = &Params;
 					Callbacks.OnSrc = ReceiveCallback;
 					Callbacks.OnReceive = AfterReceived;
 
 					Error = !Source->Receive(Trans, &Callbacks);
 
 					for (unsigned i=0; i<Trans.Length(); i++)
 					{
 						MailTransaction *Tran = Trans[i];
 						MailTransferEvent *t = Thread->Files[Tran->Index];
 						if (t)
 						{
 							LgiTrace("%s:%i - Trans[%i]: No 't' ptr for idx=%i files.len=%i.\n",
 								_FL,
 								i,
 								Tran->Index,
 								(int)Thread->Files.Length());
 						}
 						else
 						{
 							if (Tran->Oversize)
 							{
 								// Ignore
 								t->Action = MailNoop;
 								t->Status = MailReceivedOk;
 								Status = true;
 							}
 							else if (Tran->Status)
 							{
 								if (t->Status == MailReceivedNone)
 								{
 if (DebugTrace) LgiTrace("Receive(%i) Item(%i) Posting WM_SCRIBE_THREAD_ITEM, time=%i\n", Account->GetIndex(), t->Index, TimeDelta());
 									Status = true;
 
 									if (!TestFlag(Tran->Flags, MAIL_POSTED_TO_GUI))
 									{
 										// Ask the gui thread to load the mail in
 										t->Status = MailReceivedWaiting;
 										GetApp()->OnMailTransferEvent(t);
 									}
 								}
 								else
 								{
 									Status = true;
 								}
 							}
 							else
 							{
 								LgiTrace("%s:%i - Error: Bad Status on download %i of %i.\n", _FL, i, Trans.Length());
 								// Don't delete a mail that failed to download
 								t->Action = MailNoop;
 							}
 						}
 					}
 					Trans.DeleteObjects();
 				}
 
 				// Done... wait for main thread to finish processing
 if (DebugTrace) LgiTrace("Receive(%i) Waiting for main thread, time=%i\n", Account->GetIndex(), TimeDelta());
 				Thread->SetState(ThreadWaiting);
 
 				// Wait for the main thread to finish with all the items we sent over
 				if (!WaitForTransfers(Thread->Files))
 					Error = true;
 
 				if (Error)
 				{
 					LgiTrace("%s:%i - Error receiving mail.\n", _FL);
 				}
 				else
 				{
 					// Do delete's
 if (DebugTrace) LgiTrace("Receive(%i) Delete phase, time=%i\n", Account->GetIndex(), TimeDelta());
 
 					Group.Empty();
 					{
 						for (auto d: Thread->Files)
 						{
 							if (d->Action == MailDelete ||
 								d->Action == MailDownloadAndDelete)
 							{
 								Group.Range++;
 							}
 						}
 					}
 					
 					Group.Start = LCurrentTime();
 					Thread->SetState(ThreadDeleting);
 					for (auto It = Thread->Files.rbegin();
 						It != Thread->Files.end() && Thread->GetState() == ThreadDeleting;
 						It--)
 					{
 						MailTransferEvent *d = *It;
 
 						if (d->Action == MailDelete ||
 							d->Action == MailDownloadAndDelete)
 						{
 if (DebugTrace) LgiTrace("Receive(%i) Delete(%i) Deleting, time=%i\n", Account->GetIndex(), d->Index, TimeDelta());
 
 							if (Source->Delete(d->Index))
 							{
 								Status = true;
 								if (d->Uid)
 								{
 									Uids.Delete(d->Uid);
 								}
 							}
 							Group.Value++;
 						}
 					}
 				}
 
 				WaitForTransfers(Thread->Files);
 				Thread->Files.DeleteObjects();
 				Group.Empty();
 			}
 			else
 			{
 				Receive->RemoveAllMsgs();
 				Status = true;
 			}
 
 			// Clear out the UID's
 			if (Uids.Length() && Receive->Msgs)
 			{
 				// ssize_t UidsLen = Uids.Length();
 				// ssize_t AllMsgIdsLen = Receive->Msgs->Length();
 
 				auto MsgKeys = Receive->Msgs->CopyKeys();
 				for (auto &k : MsgKeys)
 				{
 					if (!Uids.Find(k))
 						RemoveMsg(k);
 				}
 
 				if (Spam)
 				{
 					auto SpamKeys = Spam->CopyKeys();
 					for (auto &s : SpamKeys)
 	 				{
 						if (!Uids.Find(s))
 							Spam->Delete(s);
 					}
 				}
 			}
 
 if (DebugTrace) LgiTrace("Receive(%i) Closing the connection, time=%i\n", Account->GetIndex(), TimeDelta());
 			// Close the connection.
 			Source->Close();
 		}
 
 		DeleteObj(Source);
 	}
 	else
 	{
 		Thread->SetState(ThreadError);
 	}
 
 	// Clean up, notify the app
 	ConnectionStatus = Status;
 	Actions.Length(0);
 
 if (DebugTrace) LgiTrace("Receive(%i) Exit, time=%i\n", Account->GetIndex(), TimeDelta());
 }
 
 void ReceiveAccountlet::OnPulse(char *s, int s_len)
 {
 	// this is called every second
 	if (Lock())
 	{
 		LVariant Offline;
 
 		bool On = IsOnline();
 		LString Serv = Server().Str();
 		if (On)
 		{
 			strcat(s, "Online");
 			SecondsTillOnline = -1;
 			
             if (Thread && Thread->GetState() == LThread::THREAD_EXITED)
 			{
 				#ifdef _DEBUG
 				LgiTrace("Caught exited thread state, Accountlet[%i]=%p, Thread=%p, &Thread=%p\n",
 					GetAccount()->GetIndex(),
 					this,
 					Thread.Get(),
 					&Thread);
 				#endif
 				Thread.Reset();
 			}
 		}
 		else if ((GetApp()->GetOptions()->GetValue(OPT_WorkOffline, Offline) && Offline.CastInt32()) ||
 				Disabled() > 0)
 		{
 			strcat(s, "Offline");
 			SecondsTillOnline = -1;
 		}
 		else
 		{
 			if (AutoReceive())
 			{
 				if (SecondsTillOnline < 0)
 				{				
 					int To = GetCheckTimeout();
 					SecondsTillOnline = To > 0 ? To : 10 * 60;
 				}
 			}
 			else
 			{
 				SecondsTillOnline = -1;
 			}
 
 			if (SecondsTillOnline == 0)
 			{
 				SecondsTillOnline = -1;
 
 				if ((!IsCheckDialup() || HaveNetConnection()) &&
 					!Offline.CastInt32())
 				{
 					Connect(0, false);
 				}
 			}
 			else if (SecondsTillOnline > 0)
 			{
 				SecondsTillOnline--;
 
 				if (CheckTimeout().Str())
 				{
 					sprintf_s(s, s_len, "%i:%2.2i", SecondsTillOnline/60, SecondsTillOnline%60);
 				}
 			}
 		}
 
 		Unlock();
 	}
 }
 
 bool ReceiveAccountlet::HasMsg(const char *Id)
 {
 	if (!Id || !Msgs || !Lock())
 		return false;
 
 	auto Status = Msgs->Find(Id);
 	Unlock();
 
 	return Status;
 }
 
 void ReceiveAccountlet::AddMsg(const char *Id)
 {
 	if (!Msgs || !Lock())
 		return;
 
 	if (!Msgs->Find(Id))
 		Msgs->Add(Id);
 
 	Unlock();
 }
 
 void ReceiveAccountlet::RemoveMsg(const char *Id)
 {
 	if (!Id || !Msgs || !Lock())
 		return;
 
 	Msgs->Delete(Id);
 
 	Unlock();
 }
 
 void ReceiveAccountlet::RemoveAllMsgs()
 {
 	if (!Msgs || !Lock())
 		return;
 
 	Msgs->Empty();
 
 	Unlock();
 }
 
 int ReceiveAccountlet::GetMsgs()
 {
 	int Status = 0;
 
 	if (Lock())
 	{
 		if (Msgs)
 		{
 			Status = Msgs->Length();
 		}
 
 		Unlock();
 	}
 
 	return Status;
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 #define OPT_MsgDate			"Date"
 
 MsgList::MsgList(LOptionsFile *opts, char *tag)
 {
 	Opts = opts;
 	Tag = tag;
 	Loaded = false;
 	Dirty = false;
 }
 
 MsgList::~MsgList()
 {
 }
 
 bool MsgList::Load()
 {
 	if (Opts && Tag && !Loaded)
 	{
 		LXmlTag *Msg = Opts->LockTag(Tag, _FL);
 
 		if (!Msg)
 		{
 			Opts->CreateTag(Tag);
 			Msg = Opts->LockTag(Tag, _FL);
 		}
 
 		if (Msg)
 		{
 			for (auto t: Msg->Children)
 			{
 				if (!t->GetAttr(OPT_MsgDate))
 				{
 					LDateTime Now;
 					char n[64];
 
 					Now.SetNow();
 					Now.Get(n, sizeof(n));
 
 					t->SetAttr(OPT_MsgDate, n);
 				}
 
 				Parent::Add(t->GetContent(), t);
 			}
 
 			Opts->Unlock();
 		}
 
 		Loaded = true;
 	}
 
 	return Loaded;
 }
 
 LXmlTag *MsgList::LockId(const char *id, const char *file, int line)
 {
 	if (Load())
 	{
 		LXmlTag *r = Opts->LockTag(Tag, file, line);
 		if (r)
 		{
 			LXmlTag *m = (LXmlTag*) Parent::Find(id);
 			if (m)
 			{
 				// deliberately leave the options locked.
 				return m;
 			}
 
 			Opts->Unlock();
 		}
 	}
 
 	return 0;
 }
 
 void MsgList::Unlock()
 {
 	Opts->Unlock();
 }
 
 bool MsgList::Add(const char *id)
 {
 	bool Status = false;
 	
 	LXmlTag *r = Opts->LockTag(Tag, _FL);
 	if (r)
 	{
 		if (!Parent::Find(id))
 		{
 			LXmlTag *t = new LXmlTag("Message");
 			if (t)
 			{
 				LDateTime Now;
 				char n[64];
 
 				Now.SetNow();
 				Now.Get(n, sizeof(n));
 
 				t->SetContent(id);
 				t->SetAttr(OPT_MsgDate, n);				
 				r->InsertTag(t);
 
 				Status = Parent::Add(id, t);
 			}
 		}
 
 		Unlock();
 	}
 	
 	return Status;
 }
 
 bool MsgList::Delete(const char *id)
 {
 	bool Status = false;
 
 	LXmlTag *r = Opts->LockTag(Tag, _FL);
 	if (r)
 	{
 		LXmlTag *t = Parent::Find(id);
 		if (t)
 		{			
 			// LgiTrace("DelMsg '%s' = %p\n", id, t);
 
 			Parent::Delete(id);
 			t->RemoveTag();
 			DeleteObj(t);
 
 			Status = true;
 		}
 
 		Opts->Unlock();
 	}
 
 	return Status;
 }
 
 int MsgList::Length()
 {
 	if (Load())
 	{
 		return (int)Parent::Length();
 	}
 
 	return 0;
 }
 
 bool MsgList::Find(const char *id)
 {
 	if (Load())
 	{
 		return Parent::Find(id) != 0;
 	}
 
 	return 0;
 }
 
 LString::Array MsgList::CopyKeys()
 {
 	LString::Array a(Length());
 	for (auto i : *this)
 	{
 		a.Add(i.key);
 	}
 	return a;
 }
 
 void MsgList::Empty()
 {
 	if (!Load())
 		return;
 
 	LXmlTag *Msg = Opts->LockTag(Tag, _FL);
 	if (!Msg)
 		return;
 
 	LXmlTag *t;
 	while (	Msg->Children.Length() &&
 			(t = Msg->Children[0]))
 	{
 		DeleteObj(t);
 	}
 
 	Opts->Unlock();
 	Parent::Empty();
 }
 
 bool MsgList::SetDate(char *id, LDateTime *dt)
 {
 	bool Status = false;
 
 	if (id && dt)
 	{
 		LXmlTag *t = LockId(id, _FL);
 		if (t)
 		{
 			char s[64];
 
 			LAssert(dt->IsValid());
 
 			// Force the date to save in a guessable format.
 			// yyyy/m/d is always easy to sniff.
 			dt->SetFormat(GDTF_YEAR_MONTH_DAY);
 			dt->Get(s, sizeof(s));
 
 			t->SetAttr(OPT_MsgDate, s);
 			Status = true;
 
 			Unlock();
 		}
 	}
 
 	return Status;
 }
 
 bool MsgList::GetDate(char *id, LDateTime *dt)
 {
 	if (!id || !dt)
 		return false;
 
 	LXmlTag *t = LockId(id, _FL);
 	if (!t)
 		return false;
 
 	char *s = t->GetAttr(OPT_MsgDate);
 	if (s)
 	{
 		// This is where I fucked up... previous versions of the software
 		// saved the date in whatever the currently selected date format.
 		// Which could've been anything... and the user can change that.
 		// So if they do change it, the saved dates are now in the wrong
 		// format to load back in (or mixed). Setting the format to '0' 
 		// here puts the LDateTime object into "guess" mode based on the 
 		// data. Which is going to be the closest we get to recovering 
 		// from the ugly situation of not saving the date in a specific
 		// format.
 		dt->SetFormat(0);
 		dt->Set(s);
 		LAssert(dt->IsValid());
 	}
 
 	Unlock();
 
 	return s != NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 LMimeStream::LMimeStream() : LTempStream(ScribeTempPath(), 4 << 20)
 {
 }
 
 #ifdef _DEBUG
 #define DEBUG_MIME_STREAM	1
 #else
 #define DEBUG_MIME_STREAM	0
 #endif
 
 bool LMimeStream::Parse()
 {
 	if (Tmp)
 		Tmp->SetPos(0);
 
 	#if DEBUG_MIME_STREAM
 	LMemStream *Src = dynamic_cast<LMemStream*>(s);
 	#endif
 
 	bool Status = Text.Decode.Pull(s) != 0;
 	if (!Status)
 	{
 		#if DEBUG_MIME_STREAM
 		LFile f;
 		if (Src && f.Open("c:\\temp\\mime_error.txt", O_WRITE))
 		{
 			Src->SetSize(0);
 			Src->SetPos(0);
 			Src->Write(&f, (int)Src->GetSize());
 			f.Close();
 		}
 
 		s->SetPos(0);
 		#endif
 		LAssert(!"Mime Parsing Failed.");
 	}
 	
 	LTempStream::Empty();
 
 	return Status;
 }
diff --git a/src/Store3Mail3/Mail3.h b/src/Store3Mail3/Mail3.h
--- a/src/Store3Mail3/Mail3.h
+++ b/src/Store3Mail3/Mail3.h
@@ -1,780 +1,781 @@
 #ifndef _MAIL3_H_
 #define _MAIL3_H_
 
 #include "lgi/common/Lgi.h"
 #include "Store3Common.h"
 #include "v3.41.2/sqlite3.h"
 
 // Debugging stuff
 #define MAIL3_TRACK_OBJS		0
 
 #define MAIL3_DB_FILE			"Database.sqlite"
 #define MAIL3_TBL_FOLDER		"Folder"
 #define MAIL3_TBL_FOLDER_FLDS	"FolderFields"
 #define MAIL3_TBL_MAIL			"Mail"
 #define MAIL3_TBL_MAILSEGS		"MailSegs"
 #define MAIL3_TBL_CONTACT		"Contact"
 #define MAIL3_TBL_GROUP			"ContactGroup"
 #define MAIL3_TBL_FILTER		"Filter"
 #define MAIL3_TBL_CALENDAR		"Calendar"
 
 class LMail3Store;
 class LMail3Mail;
 
 enum Mail3SubFormat
 {
 	Mail3v1, // All the mail and segs in a single tables.
 	Mail3v2, // All the mail and segs in per folders tables.
 };
 
 struct LMail3Def
 {
 	const char *Name;
 	const char *Type;
 };
 
 struct GMail3Idx
 {
 	const char *IdxName;
 	const char *Table;
 	const char *Column;
 };
 
 class Mail3BlobStream : public LStream
 {
 	LMail3Store *Store;
 	sqlite3_blob *b;
 	int64 Pos, Size;
 	int SegId;
 	bool WriteAccess;
 	
 	bool OpenBlob();
 	bool CloseBlob();
 
 public:
 	const char *File;
 	int Line;
 
 	Mail3BlobStream(LMail3Store *Store, int segId, int size, const char *file, int line, bool Write = false);
 	~Mail3BlobStream();
 	
 	int64 GetPos();
 	int64 SetPos(int64 p);
 	int64 GetSize();
 	int64 SetSize(int64 sz);
 	
 	ssize_t Read(void *Buf, ssize_t Len, int Flags = 0);
 	ssize_t Write(const void *Buf, ssize_t Len, int Flags = 0);
 };
 
 
 extern LMail3Def TblFolder[];
 extern LMail3Def TblFolderFlds[];
 extern LMail3Def TblMail[];
 extern LMail3Def TblMailSegs[];
 extern LMail3Def TblContact[];
 extern LMail3Def TblFilter[];
 extern LMail3Def TblGroup[];
 extern LMail3Def TblCalendar[];
 
 #define SERIALIZE_STR(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetStr(Col, Var.Str())) \
 			return false; \
 	} \
 	else \
 		Var = s.GetStr(Col);
 
 #define SERIALIZE_DATE(Var, Col) \
 	if (Write) \
 	{ \
 		if (Var.IsValid()) Var.ToUtc(); \
 		if (!s.SetDate(Col, Var)) \
 			return false; \
 	} \
 	else \
 	{ \
 		int Fmt = Var.GetFormat(); \
 		Var.SetFormat(GDTF_YEAR_MONTH_DAY|GDTF_24HOUR); \
 		Var.Set(s.GetStr(Col)); \
 		Var.SetFormat(Fmt); \
 		Var.SetTimeZone(0, false); \
 	}
 
 #define SERIALIZE_BOOL(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetBool(Col);
 
 #define SERIALIZE_INT(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetInt(Col);
 
 
 #define SERIALIZE_INT64(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt64(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetInt64(Col);
 
 #define SERIALIZE_COLOUR(Colour, Col) \
 	if (Write) \
 	{ \
 		int64_t c = Colour.IsValid() ? Colour.c32() : 0; \
 		if (!s.SetInt64(Col, c)) \
 			return false; \
 	} \
 	else \
 	{ \
 		int64_t c = s.GetInt64(Col); \
 		if (c > 0) Colour.c32((uint32_t)c); \
 		else Colour.Empty(); \
 	}
 
 #define SERIALIZE_AUTOSTR(var, Col) \
 	{ \
 		if (Write) \
 		{ \
 			if (!s.SetStr(Col, var)) \
 				return false; \
 		} \
 		else \
 		{ \
 			var.Reset(NewStr(s.GetStr(Col))); \
 		} \
 	}
 
 #define SERIALIZE_LSTR(var, Col) \
 	{ \
 		if (Write) \
 		{ \
 			if (!s.SetStr(Col, var)) \
 				return false; \
 		} \
 		else \
 		{ \
 			var = s.GetStr(Col); \
 		} \
 	}
 	
 struct LMail3StoreMsg
 {
 	enum Type
 	{
 		MsgNone,
 		MsgCompactComplete,
 		MsgRepairComplete,
 	}	Msg;
 
 	int64_t Int;
 	LString Str;
 
 	LMail3StoreMsg(Type type)
 	{
 		Msg = type;
 	}
 };
 
 class LMail3Store : public LDataStoreI
 {
 	friend class LMail3Obj;
 	friend class LMail3Mail;
 	friend class Mail3Trans;
 	friend class CompactThread;
 
 	LDataEventsI *Callback;
 	sqlite3 *Db;
 	LString Folder;
 	LString DbFile;
 	class LMail3Folder *Root;
 	LHashTbl<ConstStrKey<char,false>, LMail3Def*> Fields;
 	LHashTbl<StrKey<char,false>, GMail3Idx*> Indexes;
 	Store3Status OpenStatus;
 	LHashTbl<ConstStrKey<char,true>, Store3Status> TableStatus;
 	LString ErrorMsg;
 	LString StatusMsg;
 	LString TempPath;
 
 	std::function<void(bool)> CompactOnStatus;
 	std::function<void(bool)> RepairOnStatus;
 
 	struct TableDefn : LArray<LMail3Def>
 	{
 		LString::Array t;
 	};
 
 	bool ParseTableFormat(const char *Name, TableDefn &Defs);
 	Store3Status CheckTable(const char *Name, LMail3Def *Flds);
 	bool UpdateTable(const char *Name, LMail3Def *Flds, Store3Status Check);
 	bool DeleteMailById(int64 Id);
 	bool OpenDb();
 	bool CloseDb();
 	LMail3Folder *GetSystemFolder(int Type);
 
 public:
 	Mail3SubFormat Format;
 
 	class LStatement
 	{
 		struct PostBlob
 		{
 			int64 Size;
 			LVariant ColName;
 			LStreamI *Data;
 		};
 
 		LArray<PostBlob> Post;
 
 	protected:
 		LMail3Store *Store;
 		sqlite3_stmt *s;
 		LVariant Table;
 		LAutoString TempSql;
 		
 	public:
 		LStatement(LMail3Store *store, const char *sql = NULL);
 		virtual ~LStatement();
 
 		operator sqlite3_stmt *() { return s; }
 
 		bool IsOk()
 		{
 			return
 				#ifndef __llvm__
 				this != 0 &&
 				#endif
 				Store != 0 &&
 				s != 0;
 		}
 		bool Prepare(const char *Sql);
 		bool Row();
 		bool Exec();
 		bool Reset();
 		bool Finalize();
 		int64 LastInsertId();
 		
 		int GetSize(int Col);
 
 		bool GetBool(int Col);
 		int GetInt(int Col);
 		bool SetInt(int Col, int n);
 		int64 GetInt64(int Col);
 		bool SetInt64(int Col, int64 n);
 		char *GetStr(int Col);
 		bool GetBinary(int Col, LVariant *v);
 
 		bool SetStr(int Col, const char *s);
 		bool SetDate(int Col, LDateTime &d);
 		bool SetStream(int Col, const char *ColName, LStreamI *s);
 		bool SetBinary(int Col, const char *ColName, LVariant *v);
 
 		virtual int64 GetRowId() { LAssert(0); return -1; }
 	};
 
 	class LInsert : public LStatement
 	{
 	public:
 		LInsert(LMail3Store *store, const char *Tbl);
 
 		int64 GetRowId() { return LastInsertId(); }
 	};
 
 	class LUpdate : public LStatement
 	{
 		int64 RowId;
 
 	public:
 		LUpdate(LMail3Store *store, const char *Tbl, int64 rowId, char *ExcludeField = 0);
 
 		int64 GetRowId() { return RowId; }
 	};
 
 	class LTransaction
 	{
 		LMail3Store *Store;
 		bool Open;
 
 	public:
 		LTransaction(LMail3Store *store);
 		~LTransaction();
 		
 		bool RollBack();
 	};
 
 	#if MAIL3_TRACK_OBJS
 	struct SqliteObjs
 	{
 		LStatement *Stat;
 		Mail3BlobStream *Stream;
 		SqliteObjs()
 		{
 			Stat = 0;
 			Stream = 0;
 		}
 	};
 	LArray<SqliteObjs> All;
 	template<typename T>
 	bool RemoveFromAll(T *p)
 	{
 		for (int i=0; i<All.Length(); i++)
 		{
 			SqliteObjs &d = All[i];
 			if ((d.Stream && (void*)d.Stream == (void*)p)
 				||
 				(d.Stat && (void*)d.Stat == (void*)p))
 			{
 				All.DeleteAt(i);
 				return true;
 			}
 		}
 		LAssert(0);
 		return false;
 	}
 	#endif
 
 	LMail3Store(const char *Mail3Folder, LDataEventsI *Callback, bool Create);
 	~LMail3Store();
 
 	int64 GetFolderId(char *Path);
 	LDataEventsI *GetEvents() { return Callback; }
 	bool OnIdle() { return false; }
 	sqlite3 *GetDb() { return Db; }
 	bool IsOk();
 	int64 GetInt(int id);
 	Store3Status SetInt(int id, int64 i);
 	const char *GetStr(int id);
 	Store3Status SetStr(int id, const char *s);
 	LDataPropI *GetObj(int id);
 	uint64 Size();
 	LDataI *Create(int Type);
 	LDataFolderI *GetRoot(bool create = false);
 	Store3Status Move(LDataFolderI *NewFolder, LArray<LDataI*> &Items);
 	Store3Status Delete(LArray<LDataI*> &Items, bool ToTrash);
 	Store3Status Change(LArray<LDataI*> &Items, int PropId, LVariant &Value, LOperator Operator);
 	void Compact(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	void Upgrade(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	void Repair(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	bool SetFormat(LViewI *Parent, LDataPropI *Props);
 	void PostStore(LMail3StoreMsg *m) { Callback->Post(this, m); }
 	void OnEvent(void *Param);
 	bool Check(int Code, const char *Sql);
 	LMail3Def *GetFields(const char *t) { return Fields.Find(t); }
 
 	StoreTrans StartTransaction();
 
 	// LDataEventsI wrappers
 	void OnNew(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new);
 	bool OnMove(const char *File, int Line, LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items);
 	bool OnChange(const char *File, int Line, LArray<LDataI*> &items, int FieldHint);
 	bool OnDelete(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &items);
 
 private:
 	class Mail3Trans : public LDataStoreI::LDsTransaction
 	{
 		Mail3Trans **Ptr;
 		LTransaction Trans;
 
 	public:
 		Mail3Trans(LMail3Store *s, Mail3Trans **ptr);
 		~Mail3Trans();
 	} *Transaction;
 };
 
 class LMail3Obj
 {
 protected:
 	bool Check(int r, char *sql);
 
 public:
 	LMail3Store *Store;
 	int64 Id;
 	int64 ParentId;
 
 	LMail3Obj(LMail3Store *store)
 	{
 		Id = ParentId = -1;
 		Store = store;
 	}
 
 	bool Write(const char *Table, bool Insert);
 
 	virtual const char *GetClass() { return "LMail3Obj"; }
 	virtual bool Serialize(LMail3Store::LStatement &s, bool Write) = 0;
 	virtual void SetStore(LMail3Store *s) { Store = s; }
 };
 
 class LMail3Thing : public LDataI, public LMail3Obj 
 {
 	friend class LMail3Store;
 	LMail3Thing &operator =(LMail3Thing &p) = delete;
 
 protected:
     bool NewMail = false;
 
 	virtual const char *GetTable() { LAssert(0); return  0; }
 	virtual void OnSave() {};
 
 public:
 	LMail3Folder *Parent = NULL;
 
 	LMail3Thing(LMail3Store *store) : LMail3Obj(store)
 	{
 	}
 
 	~LMail3Thing();
 
 	const char *GetClass() { return "LMail3Thing"; }
 	bool IsOnDisk() { return Id > 0; }
 	bool IsOrphan() { return Store == NULL || Parent == NULL; }
 	uint64 Size() { return sizeof(*this); }
 	uint32_t Type() { LAssert(0); return 0; }
 	Store3Status Delete(bool ToTrash);
 	LDataStoreI *GetStore() { return Store; }
 	LAutoStreamI GetStream(const char *file, int line) { LAssert(0); return LAutoStreamI(0); }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) { LAssert(0); return false; }
 
 	Store3Status Save(LDataI *Folder = 0);
 	virtual bool DbDelete() { LAssert(0); return false; }
 };
 
 class LMail3Folder : public LDataFolderI, public LMail3Obj
 {
 public:
 	LVariant Name;
 	int Unread;
 	int Open;
 	int ItemType;
 	int Sort; // Which field to sort contents on
 	int Threaded;
 	int SiblingIndex; // The index of this folder when sorting amongst other sibling folders
 	union {
 		int AccessPerms;
 		struct {
 			int16_t ReadPerm;
 			int16_t WritePerm;
 		};
 	};
 	Store3SystemFolder System;
 
 	LMail3Folder *Parent;
 	DIterator<LDataFolderI, LMail3Folder, LMail3Store> Sub;
 	DIterator<LDataI, LMail3Thing, LMail3Store> Items;
 	DIterator<LDataPropI, Store3Field, LMail3Store> Flds;
 
 	LMail3Folder(LMail3Store *store);
 	~LMail3Folder();
 
 	Store3CopyDecl;
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	const char *GetClass() override { return "LMail3Folder"; }
 
 	uint32_t Type() override;
 	bool IsOnDisk() override;
 	bool IsOrphan() override;
 	uint64 Size() override;
 	Store3Status Save(LDataI *Folder) override;
 	Store3Status Delete(bool ToTrash) override;
 	LDataStoreI *GetStore() override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI stream) override;
 	LDataIterator<LDataFolderI*> &SubFolders() override;
 	LDataIterator<LDataI*> &Children() override;
 	LDataIterator<LDataPropI*> &Fields() override;
 	Store3Status DeleteAllChildren() override;
 	Store3Status FreeChildren() override;
 	LMail3Folder *FindSub(char *Name);
 	bool DbDelete();
 	bool GenSizes();
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 };
 
 class LMail3Attachment : public Store3Attachment<LMail3Store, LMail3Mail, LMail3Attachment>
 {
 	int64 SegId;
 	int64 BlobSize;
 
-	LAutoString Headers;
+	LString Headers;
 
 	LString Name;
 	LString MimeType;
 	LString ContentId;
 	LString Charset;
 	
 	/// This is set when the segment is not to be stored on disk.
 	/// When signed and/or encrypted messages are stored, the original
 	/// rfc822 image is maintained by not MIME decoding into separate
 	/// segments but leaving it MIME encoded in one seg (headers and body).
 	/// At runtime the segment is loaded and parsed into a temporary tree
 	/// of LMail3Attachment objects. This flag is set for those temporary
 	/// nodes.
 	bool InMemoryOnly;
 
 public:
 	LMail3Attachment(LMail3Store *store);
 	~LMail3Attachment();
 
 	void SetInMemoryOnly(bool b);
 	int64 GetId() { return SegId; }
 	LMail3Attachment *Find(int64 Id);
 	bool Load(LMail3Store::LStatement &s, int64 &ParentId);
 	bool ParseHeaders() override;
 	char *GetHeaders();
 	bool HasHeaders() { return ValidStr(Headers); }
 
 	Store3CopyDecl;
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 	Store3Status Delete(bool ToTrash = false) override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI stream) override;
 
 	uint32_t Type() override { return MAGIC_ATTACHMENT; }
 	bool IsOnDisk() override { return SegId > 0; }
 	bool IsOrphan() override { return false; }
 	uint64 Size() override;
 	uint64 SizeChildren();
 	Store3Status Save(LDataI *Folder = 0) override;
 	void OnSave() override;
 };
 
 class LMail3Mail : public LMail3Thing
 {
 	LAutoString TextCache;
 	LAutoString HtmlCache;
 	LString IdCache;
 	LAutoPtr<uint64> SizeCache;
 	LString InferredCharset;
 	LString ErrMsg;
 
 	void LoadSegs();
 	void OnSave() override;
 
 	const char *GetTable() override { return MAIL3_TBL_MAIL; }
 	void ParseAddresses(char *Str, int CC);
-	const char *InferCharset();
+	const char *InferCharset(const char *ExampleTxt);
+	bool Utf8Check(LString &v);
 	bool Utf8Check(LVariant &v);
 	bool Utf8Check(LAutoString &v);
 
 public:
 	int Priority = MAIL_PRIORITY_NORMAL;
 	int Flags = 0;
 	int AccountId = 0;
 	int64 MailSize = 0;
 	uint32_t MarkColour = Rgba32(0, 0, 0, 0); // FIELD_MARK_COLOUR, 32bit rgba colour
 
-	LVariant Subject;
+	LString Subject;
 	DIterator<LDataPropI, Store3Addr, LMail3Store> To;
 	LMail3Attachment *Seg = NULL;
 	Store3Addr From;
 	Store3Addr Reply;
 	LVariant Label;
 	LVariant MessageID;
 	LVariant References;
 	LVariant FwdMsgId;
 	LVariant BounceMsgId;
 	LVariant ServerUid;
 
 	LDateTime DateReceived;
 	LDateTime DateSent;
 
 	LMail3Mail(LMail3Store *store);
 	~LMail3Mail();
 
 	Store3CopyDecl;
 	void SetStore(LMail3Store *s) override;
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	const char *GetClass() override { return "LMail3Mail"; }
 	LMail3Attachment *GetAttachment(int64 Id);
 	bool FindSegs(const char *MimeType, LArray<LMail3Attachment*> &Segs, bool Create = false);
 	int GetAttachments(LArray<LMail3Attachment*> *Lst = 0);
     bool ParseHeaders() override;
     void ResetCaches();
 
 	uint32_t Type() override;
 	uint64 Size() override;
 	bool DbDelete() override;
 	LDataStoreI *GetStore() override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI  stream) override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *t) override;
 	LDataPropI *GetObj(int id) override;
 	Store3Status SetObj(int id, LDataPropI *i) override;
 	LDataIt GetList(int id) override;
 	Store3Status SetRfc822(LStreamI *m) override;
 };
 
 class LMail3Contact : public LMail3Thing
 {
 	const char *GetTable() override { return MAIL3_TBL_CONTACT; }
 	LHashTbl<IntKey<int64>, LString*> f;
 
 public:
 	LVariant Image;
 	LDateTime DateMod;
 
 	LMail3Contact(LMail3Store *store);
 	~LMail3Contact();
 
 	uint32_t Type() override { return MAGIC_CONTACT; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Contact"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 
 	int64 GetInt(int id) override { return -1; }
 
 	LVariant *GetVar(int id) override;
 	Store3Status SetVar(int id, LVariant *i) override;
 
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Group : public LMail3Thing
 {
 	const char *GetTable() override { return MAIL3_TBL_GROUP; }
 
 	LString Name;
 	LString Group;
 	LDateTime DateMod;
 
 public:
 	LMail3Group(LMail3Store *store);
 	~LMail3Group();
 
 	uint32_t Type() override { return MAGIC_GROUP; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Group"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 
 	int64 GetInt(int id) override { return -1; }
 
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Filter : public LMail3Thing
 {
 	int Index;
 	int StopFiltering;
 	int Direction;
 	LString Name;
 	LString ConditionsXml;
 	LString ActionsXml;
 	LString Script;
 	LDateTime Modified;
 
 	const char *GetTable() override { return MAIL3_TBL_FILTER; }
 
 public:
 	LMail3Filter(LMail3Store *store);
 	~LMail3Filter();
 
 	uint32_t Type() override { return MAGIC_FILTER; }
 	LDataStoreI *GetStore() override { return Store; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Filter"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;	
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int Col, int64 n) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Calendar : public LMail3Thing
 {
 	LString ToCache;
 
 private:
 	int CalType = 0; // FIELD_CAL_TYPE
 	LString To; // FIELD_TO
 	CalendarPrivacyType CalPriv = CalDefaultPriv; // FIELD_CAL_PRIVACY
 	int Completed = 0; // FIELD_CAL_COMPLETED
 	LDateTime Start; // FIELD_CAL_START_UTC
 	LDateTime  End; // FIELD_CAL_END_UTC
 	LString TimeZone; // FIELD_CAL_TIMEZONE
 	LString Subject; // FIELD_CAL_SUBJECT
 	LString Location; // FIELD_CAL_LOCATION
 	LString Uid; // FIELD_UID
 	bool AllDay = false; // FIELD_CAL_ALL_DAY
 	int64 StoreStatus = Store3Success; // FIELD_STATUS - ie the current Store3Status
 	LString EventStatus; // FIELD_CAL_STATUS
 	LDateTime Modified; // FIELD_DATE_MODIFIED
 
 	LString Reminders; // FIELD_CAL_REMINDERS
 	LDateTime LastCheck; // FIELD_CAL_LAST_CHECK
 	int ShowTimeAs = 0; // FIELD_CAL_SHOW_TIME_AS
 
 	int Recur = 0; // FIELD_CAL_RECUR
 	int RecurFreq = 0; // FIELD_CAL_RECUR_FREQ
 	int RecurInterval = 0; // FIELD_CAL_RECUR_INTERVAL
 	LDateTime RecurEnd; // FIELD_CAL_RECUR_END_DATE
 	int RecurCount = 0; // FIELD_CAL_RECUR_END_COUNT
 	int RecurEndType = 0; // FIELD_CAL_RECUR_END_TYPE
 	LString RecurPos; // FIELD_CAL_RECUR_FILTER_POS
 	
 	int FilterDays = 0; // FIELD_CAL_RECUR_FILTER_DAYS
 	int FilterMonths = 0; // FIELD_CAL_RECUR_FILTER_MONTHS
 	LString FilterYears; // FIELD_CAL_RECUR_FILTER_YEARS
 	LString Notes; // FIELD_CAL_NOTES
 	
 	LColour Colour;
 
 	const char *GetTable() override { return MAIL3_TBL_CALENDAR; }
 
 public:
 	LMail3Calendar(LMail3Store *store);
 	~LMail3Calendar();
 
 	uint32_t Type() override { return MAGIC_CALENDAR; }
 	LDataStoreI *GetStore() override { return Store; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Filter"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int Col, int64 n) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *t) override;
 };
 
 #endif
diff --git a/src/Store3Mail3/Mail3Attachment.cpp b/src/Store3Mail3/Mail3Attachment.cpp
--- a/src/Store3Mail3/Mail3Attachment.cpp
+++ b/src/Store3Mail3/Mail3Attachment.cpp
@@ -1,581 +1,582 @@
 #include "Mail3.h"
 #include "lgi/common/TextConvert.h"
 
 Mail3BlobStream::Mail3BlobStream(LMail3Store *store, int segid, int size, const char *file, int line, bool Write)
 {
 	Store = store;
 	File = file;
 	Line = line;
 	b = 0;
 	Pos = 0;
 	Size = size;
 	SegId = segid;
 	WriteAccess = Write;
 	
 	#if MAIL3_TRACK_OBJS
 	LMail3Store::SqliteObjs &_d = Store->All.New();
 	_d.Stream = this;
 	#endif
 
 	OpenBlob();
 }
 
 Mail3BlobStream::~Mail3BlobStream()
 {
 	CloseBlob();
 	#if MAIL3_TRACK_OBJS
 	Store->RemoveFromAll(this);
 	#endif
 }
 
 bool Mail3BlobStream::OpenBlob()
 {
 	bool Res = Store->Check(sqlite3_blob_open(Store->GetDb(),
 											NULL, // Database
 											"MailSegs",
 											"Data",
 											SegId,
 											WriteAccess,
 											&b), 0);
 	// if (b) LgiTrace("%s:%i - open blob %p\n", _FL, b);
 	return Res;
 }
 
 bool Mail3BlobStream::CloseBlob()
 {
 	if (!b)
 		return true;
 
 	// LgiTrace("%s:%i - close blob %p\n", _FL, b);
 	int Res = sqlite3_blob_close(b);
 	b = NULL;
 	return Store->Check(Res, 0);
 }
 
 int64 Mail3BlobStream::GetPos()
 {
 	return Pos;
 }
 
 int64 Mail3BlobStream::SetPos(int64 p)
 {
 	if (p < 0)
 		p = 0;
 	if (p > Size)
 		p = Size;
 	return Pos = p;
 }
 
 int64 Mail3BlobStream::GetSize()
 {
 	return Size;
 }
 
 int64 Mail3BlobStream::SetSize(int64 sz)
 {
 	LAssert(!"You can't set the size of a blob.");
 	return Size;
 }
 
 
 
 ssize_t Mail3BlobStream::Read(void *Buf, ssize_t Len, int Flags)
 {
 	if (!b)
 		return 0;
 
 	int64 Remain = Size - Pos;
 	int64 Copy = MIN(Remain, Len);
 	auto Res = sqlite3_blob_read(b, Buf, (int)Copy, (int)Pos);
 	if (Res == SQLITE_ABORT)
 	{
 		if (!CloseBlob())
 			return 0;	
 		if (!OpenBlob())
 			return 0;	
 		Res = sqlite3_blob_read(b, Buf, (int)Copy, (int)Pos);
 	}
 	
 	if (!Store->Check(Res, 0))
 		return 0;
 
 	Pos += Copy;
 	return (ssize_t) Copy;
 }
 
 ssize_t Mail3BlobStream::Write(const void *Buf, ssize_t Len, int Flags)
 {
 	if (!b)
 		return 0;
 
 	auto Res = sqlite3_blob_write(b, Buf, (int)Len, (int)Pos);
 	if (Res == SQLITE_ABORT)
 	{
 		if (!CloseBlob())
 			return 0;	
 		if (!OpenBlob())
 			return 0;	
 		Res = sqlite3_blob_write(b, Buf, (int)Len, (int)Pos);
 	}
 
 	if (!Store->Check(Res, 0))
 		return 0;
 	
 	Pos += Len;
 	return Len;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////
 LMail3Attachment::LMail3Attachment(LMail3Store *store) :
 	Store3Attachment<LMail3Store, LMail3Mail, LMail3Attachment>(store)
 {
 	SegId = -1;
 	BlobSize = 0;
 	InMemoryOnly = false;
 }
 
 LMail3Attachment::~LMail3Attachment()
 {
 	_Delete();
 }
 
 void LMail3Attachment::SetInMemoryOnly(bool b)
 {
 	InMemoryOnly = b;
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		Children.a[i]->SetInMemoryOnly(b);
 	}
 }
 
 uint64 LMail3Attachment::Size()
 {
-	int64 HeaderSz = Headers ? strlen(Headers) : 0;
+	int64 HeaderSz = Headers.Length();
 	int64 NameSz = Name.Length();
 	int64 MimeSz = MimeType.Length();
 	int64 ContentIdSz = ContentId.Length();
 	int64 CharsetSz = Charset.Length();
 	int64 ImportSz = Import ? Import->GetSize() : 0;
 	
 	return	HeaderSz +
 			NameSz +
 			MimeSz +
 			ContentIdSz +
 			CharsetSz +
 			BlobSize +
 			sizeof(BlobSize) + 
 			sizeof(SegId) +
 			ImportSz;
 }
 
 uint64 LMail3Attachment::SizeChildren()
 {
 	uint64 s = 0;
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LMail3Attachment *c = Children.a[i];
 		s += c->Size();
 		s += c->SizeChildren();
 	}
 	return s;	
 }
 
 LMail3Attachment *LMail3Attachment::Find(int64 Id)
 {
 	if (SegId == Id)
 		return this;
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LMail3Attachment *r = Children.a[i]->Find(Id);
 		if (r)
 			return r;
 	}
 
 	return 0;
 }
 
 Store3CopyImpl(LMail3Attachment)
 {
-	Headers.Reset(NewStr(p.GetStr(FIELD_INTERNET_HEADER)));
+	Headers = p.GetStr(FIELD_INTERNET_HEADER);
 	if (Headers)
 	{
 		// Source supports headers...
 		ParseHeaders();
 	}
 	else
 	{
 		// Copy over whatever fields we can...
 		Name = p.GetStr(FIELD_NAME);
 		MimeType = p.GetStr(FIELD_MIME_TYPE);
 		ContentId = p.GetStr(FIELD_CONTENT_ID);
 		Charset = p.GetStr(FIELD_CHARSET);
 	}
 	
 	LDataI *Data = dynamic_cast<LDataI*>(&p);
 	if (Data)
 	{
 		LAutoStreamI tmp = Data->GetStream(_FL);
 		SetStream(tmp);
 	}
 	return true;
 }
 
 char *LMail3Attachment::GetHeaders()
 {
 	if (!Headers)
 	{
 		LStringPipe p;
 		if (!MimeType)
 		{
 			LAssert(!"MimeType is required.");
 			return NULL;
 		}
 		p.Print("Content-Type: %s", MimeType?MimeType.Get():(char*)"text/plain");
 		if (Charset)
 			p.Print("; charset=%s", Charset.Get());
 		if (Name)
 			p.Print("; name=\"%s\"", Name.Get());
 		p.Print("\r\n");
 		if (ContentId)
 		{
 			p.Print("Content-Id: <%s>\r\n", ContentId.Strip("<>").Get());
 			if (Name)
 				p.Print("Content-Disposition: inline; filename=\"%s\"\r\n", Name.Get());
 		}
-		Headers.Reset(p.NewStr());		
+		Headers = p.NewLStr();		
 	}
 
 	return Headers;
 }
 
 bool LMail3Attachment::ParseHeaders()
 {
-	LAutoString Ct(InetGetHeaderField(Headers, "Content-Type"));
+	auto Ct = LGetHeaderField(Headers, "Content-Type");
 	char *Colon = Ct ? strchr(Ct, ';') : 0;
 	if (Colon)
 	{
 		while (Colon > Ct.Get() && strchr(" \t\r\n", Colon[-1])) Colon--;
 
 		LAutoString Cs(InetGetSubField(Colon, "charset"));
 		if (Cs)
 		{
 			Charset = Cs.Get();
 			LAssert(!strchr(Charset, '>'));
 		}
 		
 		*Colon = 0;
 	}
 
 	MimeType = Ct;
 	
 	return true;
 }
 
 bool LMail3Attachment::Load(LMail3Store::LStatement &s, int64 &ParentId)
 {
-	SegId = s.GetInt64(0);
-	ParentId = s.GetInt64(2);
-	
-	Headers.Reset(NewStr(s.GetStr(3)));
+	SegId    = s.GetInt64(0);
+	ParentId = s.GetInt64(2);	
+	Headers  = s.GetStr(3);
 	ParseHeaders();
 	
 	BlobSize = s.GetSize(4);
 	Dirty = false;
 
 	#ifdef _DEBUG
 	// This was a hack to fix a dumb bug in a dev build... so so dumb.
 	if (Headers)
 	{
 		auto cdcd = Strstr(Headers.Get(), "\xcd\xcd");
 		if (cdcd)
 		{
 			*cdcd = 0;
 			Dirty = true;
 		}
 	}	
 	#endif
 
 	LAssert(!Mail || Kit == Mail->Store);
 
 	return true;
 }
 
 Store3Status LMail3Attachment::Save(LDataI *NewParent)
 {
 	if (NewParent)
 	{
 		// Check hierarchy
 		LMail3Attachment *NewSeg = dynamic_cast<LMail3Attachment*>(NewParent);
 		if (NewSeg)
 		{
 			// This propagates the in mem only setting down the tree of nodes
 			InMemoryOnly = NewSeg->InMemoryOnly;
 			if (NewSeg != Parent)
 				AttachTo(NewSeg);
 		}
 		else
 		{
 			LMail3Mail *NewMail = dynamic_cast<LMail3Mail*>(NewParent);
 			if (NewMail)
 			{
 				if (NewMail != Mail)
 					AttachTo(NewMail);
 			}
 		}
 	}
 
 	if (Mail)
 	{
 		// Mark the mail size dirty.
 		Mail->MailSize = -1;
 
 		LAssert(Kit == Mail->Store);
 	}
 
 	if (!InMemoryOnly)
 	{
 		if (Mail && Mail->Id > 0)
 		{
 			if (SegId <= 0)
 			{
 				LMail3Attachment *Parent = GetParent();
 
 				LMail3Store::LInsert Ins(Kit, MAIL3_TBL_MAILSEGS);
 				Ins.SetInt64(1, Mail->Id);
 				Ins.SetInt64(2, Parent ? Parent->SegId : -1);
 				Ins.SetStr(3, GetHeaders());
 				if (Import)
 					Ins.SetStream(4, "Data", Import);
 				if (!Ins.Exec())
 					return Store3Error;
 
 				SegId = Ins.LastInsertId();
 			}
 			else if (Dirty)
 			{
 				LMail3Attachment *Parent = GetParent();
 
 				LMail3Store::LUpdate Up(Kit, MAIL3_TBL_MAILSEGS, SegId, Import ? 0 : (char*)"Data");
 				Up.SetInt64(0, SegId);
 				Up.SetInt64(1, Mail->Id);
 				Up.SetInt64(2, Parent ? Parent->SegId : -1);
 				Up.SetStr(3, GetHeaders());
 				if (Import)
 					Up.SetStream(4, "Data", Import);
 				if (!Up.Exec())
 					return Store3Error;
 
 			}
 
  			Import.Reset();
 			Dirty = false;
 		}
 		else
 		{
 			Dirty = true;
 		}
 	}
 
 	return Store3Success;
 }
 
 void LMail3Attachment::OnSave()
 {
 	if (!Mail)
 	{
 		LAssert(!"Segment is not attached to a mail!");
 		return;
 	}
 
 	if (Dirty || SegId <= 0)
 	{
 		Save();
 	}
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		Children.a[i]->OnSave();
 	}
 }
 
 const char *LMail3Attachment::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_CHARSET:
 		{
 		    if (!Charset)
 		    {
 			    // Maybe a parent segment has a charset?
 			    for (LMail3Attachment *p = GetParent(); p; p = p->GetParent())
 			    {
 			        auto Cs = p->GetStr(FIELD_CHARSET);
 			        if (Cs)
 			            return Cs;
 			    }
 			}
 
 			return Charset;
 		}
 		case FIELD_NAME:
 		{
 			if (!Name)
 			{
-				LAutoString t(InetGetHeaderField(Headers, "Content-Disposition"));
-				
-				LAutoString n(DecodeRfc2047(InetGetSubField(t, "filename")));
+				auto t = LGetHeaderField(Headers, "Content-Disposition");				
+				auto n = LDecodeRfc2047(LGetSubField(t, "filename"));
 				if (n)
 					Name = n.Get();
 				else
 				{
-					LAutoString ct(InetGetHeaderField(Headers, "Content-Type"));
+					auto ct = LGetHeaderField(Headers, "Content-Type");
 					if (ct)
 					{
-						if (n.Reset(DecodeRfc2047(InetGetSubField(ct, "name"))))
+						if (n = LDecodeRfc2047(LGetSubField(ct, "name")))
 							Name = n.Get();
 					}
 				}
 			}
 
 			return Name;
 			break;
 		}
 		case FIELD_MIME_TYPE:
 		{
 			if (!MimeType)
 			{
-				LAutoString t(InetGetHeaderField(Headers, "Content-Type"));
+				auto t = LGetHeaderField(Headers, "Content-Type");
 				if (t)
 				{
-					char *c = strchr(t, ';');
+					// Trim off any sub-feilds.
+					auto c = strchr(t, ';');
 					if (c)
 					{
-						while (strchr(" \t\r\n", c[-1])) c--;
-						MimeType.Set(t, c ? c - t : -1);
+						while (strchr(" \t\r\n", c[-1]))
+							c--;
+						*c = 0;
+						MimeType.Set(t, c - t.Get());
 					}
 				}
 			}
 
 			return MimeType;
 			break;
 		}
 		case FIELD_CONTENT_ID:
 		{
 			if (!ContentId)
 			{
 				LAutoString Id(InetGetHeaderField(Headers, "Content-Id"));
 				ContentId = LString(Id.Get()).Strip("<>");
 			}
 
 			return ContentId;
 			break;
 		}
 		case FIELD_INTERNET_HEADER:
 			return Headers;
 	}
 
 	LAssert(!"Unknown id.");
 	return NULL;
 }
 
 Store3Status LMail3Attachment::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_INTERNET_HEADER:
-        	Headers.Reset(NewStr(str));
+        	Headers = str;
 			ParseHeaders();
 			break;
 		case FIELD_NAME:
 			Name = str;
-			Headers.Reset();
+			Headers.Empty();
 			break;
 		case FIELD_MIME_TYPE:
 			MimeType = str;
 
 			// FIXME: If we have headers from an incoming mail, this is an error to delete them here.
 			LAssert(Headers.Get() == NULL);
 
-			Headers.Reset();
+			Headers.Empty();
 			break;
 		case FIELD_CONTENT_ID:
 			ContentId = LString(str).Strip("<>");
-			Headers.Reset();
+			Headers.Empty();
 			break;
 		case FIELD_CHARSET:
 			Charset = str;
 			if (Charset.Find(">") >= 0)
 				LAssert(!"Invalid char");
 			
-			Headers.Reset();
+			Headers.Empty();
 			break;
 		default:
 			LAssert(!"Unknown id.");
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 int64 LMail3Attachment::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_STORE_TYPE:
 			return Store3Sqlite;
 		case FIELD_SIZE:
 			return BlobSize;
 	}
 
 	LAssert(!"Unknown id.");
 	return false;
 }
 
 Store3Status LMail3Attachment::SetInt(int id, int64 i)
 {
 	LAssert(!"Unknown id.");
 	return Store3Error;
 }
 
 Store3Status LMail3Attachment::Delete(bool ToTrash)
 {
 	if (InMemoryOnly)
 		return Store3Success;
 
 	if (SegId <= 0)
 		return Store3Error;
 
 	LString Sql;
 	Sql.Printf("delete from " MAIL3_TBL_MAILSEGS " where Id=" LPrintfInt64, SegId);
 	LMail3Store::LStatement s(Kit, Sql);
 	if (!s.Exec())
 		return Store3Error;
 
 	SegId = -1;
 	return Store3Success;
 }
 
 LAutoStreamI LMail3Attachment::GetStream(const char *file, int line)
 {
 	LAutoStreamI Ret;
 
 	if (Import)
 		Ret.Reset(new LProxyStream(Import));
 	else if (SegId > 0 && BlobSize > 0)
 		Ret.Reset(new Mail3BlobStream(Kit, (int)SegId, (int)BlobSize, file, line));
 
 	return Ret;
 }
 
 bool LMail3Attachment::SetStream(LAutoStreamI s)
 {
 	Import = s;
 	Dirty = true;
 	BlobSize = Import ? Import->GetSize() : 0;
 	
 	if (Mail)
 		Mail->ResetCaches();
 	
 	return true;
 }
diff --git a/src/Store3Mail3/Mail3Mail.cpp b/src/Store3Mail3/Mail3Mail.cpp
--- a/src/Store3Mail3/Mail3Mail.cpp
+++ b/src/Store3Mail3/Mail3Mail.cpp
@@ -1,1646 +1,1663 @@
 #include "Mail3.h"
 #include "lgi/common/Mail.h"
 #include "lgi/common/Store3MimeTree.h"
 #include "lgi/common/StreamConcat.h"
 #include "lgi/common/TextConvert.h"
 #include "ScribeUtils.h"
 
 LMail3Def TblMail[] =
 {
 	{"Id",				"INTEGER PRIMARY KEY AUTOINCREMENT"},
 	{"ParentId",		"INTEGER"},
 
 	// Integers
 		{"Priority",		"INTEGER"},
 		{"Flags",			"INTEGER"},
 		{"AccountId",		"INTEGER"},
 		{"MarkColour",		"INTEGER"},
 
 	// Strings
 		{"Subject",			"TEXT"},
 		{"ToAddr",			"TEXT"},
 		{"FromAddr",		"TEXT"},
 		{"Reply",			"TEXT"},
 		{"Label",			"TEXT"},
 		{"InternetHeader",	"TEXT"},
 		{"MessageID",		"TEXT"},
 		{"Ref",				"TEXT"},
 		{"FwdMsgId",		"TEXT"},
 		{"BounceMsgId",		"TEXT"},
 		{"ServerUid",		"TEXT"},
 
 	// Date/times
 		{"DateReceived",	"TEXT"},
 		{"DateSent",		"TEXT"},
 
     // Other meta data
 		{"Size",    		"INTEGER"},
 
 	{0, 0}
 };
 
 LMail3Def TblMailSegs[] =
 {
 	{"Id",				"INTEGER PRIMARY KEY AUTOINCREMENT"},
 	{"MailId",			"INTEGER"},
 	{"ParentId",		"INTEGER"},
 	{"Headers",			"TEXT"},
 	{"Data",			"BLOB"},
 	
 	{0,					0},
 };
 
 bool Mail3_InsertSeg(LMail3Store::LInsert &Ins, LMime *m, int64 ParentId, int64 ParentSeg, int64 &MailSize)
 {
 	Ins.SetInt64(1, ParentId);
 	Ins.SetInt64(2, ParentSeg);
 	Ins.SetStr(3, m->GetHeaders());
 
 	LStreamI *MimeData = m->GetData();
 	int64 Sz = MimeData ? MimeData->GetSize() : 0;
 	if (Sz > 0)
 		MailSize += Sz;
 	
 	Ins.SetStream(4, "Data", MimeData);
 
 	if (!Ins.Exec())
 		return false;
 
 	ParentSeg = Ins.LastInsertId();
 	Ins.Reset();
 
 	for (int i=0; i<m->Length(); i++)
 	{
 		LMime *c = (*m)[i];
 		if (!Mail3_InsertSeg(Ins, c, ParentId, ParentSeg, MailSize))
 			return false;
 	}
 
 	return true;
 }
 
 bool Mail3_CopySegs(LMail3Mail *m, LMail3Attachment *parent, LDataI *in)
 {
 	const char *Mt = in->GetStr(FIELD_MIME_TYPE);
 	if (!Mt)
 	{
 		return false;
 	}
 	
 	LMail3Attachment *out = new LMail3Attachment(m->Store);
 	if (!out)
 		return false;
 
 	out->CopyProps(*in);
 	if (parent)
 		out->AttachTo(parent);
 	else
 		out->AttachTo(m);
 
 	LDataIt It = in->GetList(FIELD_MIME_SEG);
 	for (LDataPropI *c = It->First(); c; c = It->Next())
 	{
 		LDataI *child = dynamic_cast<LDataI*>(c);
 		if (child && !Mail3_CopySegs(m, out, child))
 			return false;
 	}
 
 	return true;
 }
 
 LMail3Mail::LMail3Mail(LMail3Store *store) :
 	LMail3Thing(store),
 	From(store),
 	Reply(store)
 {
 	To.State = Store3Loaded;
 }
 
 LMail3Mail::~LMail3Mail()
 {
 	To.DeleteObjects();
 	DeleteObj(Seg);
 }
 
 #define DEBUG_COPY_PROPS		0
 
 Store3CopyImpl(LMail3Mail)
 {
 #if DEBUG_COPY_PROPS
 LProfile Prof("Store3CopyProps");
 #endif
 	Priority = (int)p.GetInt(FIELD_PRIORITY);
 	Flags = (int)p.GetInt(FIELD_FLAGS);
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 
 	SetStr(FIELD_INTERNET_HEADER, p.GetStr(FIELD_INTERNET_HEADER));
 	MessageID = p.GetStr(FIELD_MESSAGE_ID);
 	Subject = p.GetStr(FIELD_SUBJECT);
 	MarkColour = (int)p.GetInt(FIELD_COLOUR);
 	AccountId = (int)p.GetInt(FIELD_ACCOUNT_ID);
 	SetStr(FIELD_LABEL, p.GetStr(FIELD_LABEL));
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	LDataPropI *i = p.GetObj(FIELD_FROM);
 	if (i) From.CopyProps(*i);
 	i = p.GetObj(FIELD_REPLY);
 	if (i) Reply.CopyProps(*i);
 	
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	const LDateTime *d = p.GetDate(FIELD_DATE_RECEIVED);
 	if (d) DateReceived = *d;
 	d = p.GetDate(FIELD_DATE_SENT);
 	if (d) DateSent = *d;
 	
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	To.DeleteObjects();
 	LDataIt pTo = p.GetList(FIELD_TO);
 	for (unsigned n=0; n<pTo->Length(); n++)
 	{
 		To.Insert(new Store3Addr(GetStore(), (*pTo)[n]), -1, true);
 	}
 	To.State = Store3Loaded;
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 	LDataI *Root = dynamic_cast<LDataI*>(p.GetObj(FIELD_MIME_SEG));
 	if (Root)
 	{
 		// Must commit ourselves now and get an Id if needed
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 		if (Id > 0 || Write(MAIL3_TBL_MAIL, true))
 		{
 		    // Clear existing segment if present...
 		    LAssert(!Seg || Seg->GetId() < 0);
 			DeleteObj(Seg);
 
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 			// Save all the segments out
 			Mail3_CopySegs(this, NULL, Root);
 			
 #if DEBUG_COPY_PROPS
 Prof.Add(_FL);
 #endif
 			OnSave();
 		}
 	}
 
 	return true;
 }
 
 void LMail3Mail::SetStore(LMail3Store *s)
 {
 	if (Id < 0)
 	{
 		LMail3Thing::SetStore(s);
 		From.SetStore(s);
 		Reply.SetStore(s);
 		if (Seg)
 			Seg->SetMail(this);
 	}
 	else LAssert(!"Object is already commited to another store.");
 }
 
 bool SafeAddrTokenize(const char *In, List<char> &Out, bool Debug = false)
 {
 	if (!In)
 		return false;
 	
 	// Find all the characters of interest...
 	LArray<const char*> a;
 	for (const char *c = In; *c; c++)
 	{
 		if (strchr("\':,<@>", *c))
 			a.Add(c);
 	}
 	
 	// Now do pattern matching. We may encounter weird numbers of single
 	// quotes due to recipient names having un-escaped single quotes.
 	const char *Last = In;
 	LAutoString Str;
 	for (ssize_t i=0; i<(ssize_t)a.Length(); i++)
 	{
 		// Check for '<' '@', '>' pattern
 		if (i < (ssize_t)a.Length() - 4 &&
 			*a[i] == '<' &&
 			*a[i+1] == '@' &&
 			*a[i+2] == '>' &&
 			*a[i+3] == ':' &&
 			*a[i+4] == ',')
 		{
 			const char *e = a[i+4];
 			Str.Reset(NewStr(Last, e-Last));
 			Last = e + 1;
 		}
 		else if (i < (ssize_t)a.Length() - 3 &&
 			*a[i] == '<' &&
 			*a[i+1] == '@' &&
 			*a[i+2] == '>' &&
 			*a[i+3] == ':')
 		{
 			const char *e = a[i+3];
 			while (*e) e++;
 			Str.Reset(NewStr(Last, e-Last));
 			Last = e;
 		}
 		else if (i < (ssize_t)a.Length() - 2 &&
 			*a[i] == '<' &&
 			*a[i+1] == '>' &&
 			*a[i+2] == ':')
 		{
 			// This case handles a group name without a '@' in it...
 			const char *e = a[i+2];
 			while (*e) e++;
 			Str.Reset(NewStr(Last, e-Last));
 			Last = e;
 		}
 		else break;
 		
 		if (Str)
 		{
 			Out.Insert(Str.Release());
 		}
 	}
 	
 	return true;
 }
 
 #if 1
 #define DEBUG_SERIALIZE(...)	 if (Debug) LgiTrace(__VA_ARGS__)
 #else
 #define DEBUG_SERIALIZE(...)
 #endif
 
 bool LMail3Mail::Serialize(LMail3Store::LStatement &s, bool Write)
 {
 	static LVariant vTo, vFrom, vReply;
 	bool Debug = false;
 	
 	// Save the objects to strings
 	if (Write)
 	{
 		if (MailSize < 0 && Seg)
 		{
 			MailSize = (uint32_t) (Seg->Size() + Seg->SizeChildren());
 		}
 		
 		if (!From.GetValue("Text", vFrom))
 			vFrom.Empty();
 		if (!Reply.GetValue("Text", vReply))
 			vReply.Empty();
 
 		LStringPipe p;
 		int Done = 0;
 		for (unsigned i=0; i<To.Length(); i++)
 		{
 			LVariant v;
 			Store3Addr *a = To.a[i];
 			if (a->GetValue("Text", v) && v.Str())
 			{
 			    const char *Comma = Done ? ", " : "";
 				DEBUG_SERIALIZE("ToText='%s'\n", v.Str());
 				p.Print("%s%s:%i", Comma, v.Str(), a->CC);
 				Done++;
 			}
 		}
 		vTo.OwnStr(p.NewStr());
 		DEBUG_SERIALIZE("vTo='%s'\n", vTo.Str());
 	}
 
 	int i = 0;
 	LVariant NullInternetHeader; // The internet header is now stored
 								// In the first segment ONLY. But it
 								// wasn't worth removing the field in
 								// the DB.
 
 	SERIALIZE_INT64(Id, i++);
 	SERIALIZE_INT64(ParentId, i++);
 
 	SERIALIZE_INT(Priority, i++);
 	SERIALIZE_INT(Flags, i++);
 	SERIALIZE_INT(AccountId, i++);
 	SERIALIZE_INT(MarkColour, i++);
 
-	SERIALIZE_STR(Subject, i++);
+	SERIALIZE_LSTR(Subject, i++);
 	SERIALIZE_STR(vTo, i++);
 	SERIALIZE_STR(vFrom, i++);
 	SERIALIZE_STR(vReply, i++);
 	SERIALIZE_STR(Label, i++);
 	SERIALIZE_STR(NullInternetHeader, i++);
 	SERIALIZE_STR(MessageID, i++);
 	SERIALIZE_STR(References, i++);
 	SERIALIZE_STR(FwdMsgId, i++);
 	SERIALIZE_STR(BounceMsgId, i++);
 	SERIALIZE_STR(ServerUid, i++);
 
 	SERIALIZE_DATE(DateReceived, i++);
 	SERIALIZE_DATE(DateSent, i++);
 
 	SERIALIZE_INT64(MailSize, i++);
 
 	// Load the objects from the strings
 	if (!Write)
 	{
 		From.SetValue("Text", vFrom);
 		Reply.SetValue("Text", vReply);
 
 		To.DeleteObjects();
 		List<char> Addr;
 		char *ToStr = vTo.Str();
 		//DEBUG_SERIALIZE("ReadTo='%s'\n", ToStr);
 		int Colons = 0;
 		int Commas = 0;
 		for (char *c = ToStr; c && *c; c++)
 		{
 			if (*c == ':')
 				Colons++;
 			else if (*c == ',')
 				Commas++;
 		}
 		if (Commas == 1 && Colons > 1)
 		{
 			// Broken data
 			char *c = ToStr;
 			while (*c)
 			{
 				while (*c && (strchr(WhiteSpace, *c) || *c == ','))
 					c++;
 					
 				char *e = strchr(c, '>');
 				if (!e)
 					break;
 				e++;
 				if (*e == ':')
 					e++;
 				while (IsDigit(*e))
 					e++;
 				
 				char *a = NewStr(c, e - c);
 				if (!a)
 					break;
 					
 				Addr.Insert(a);
 				c = e;
 			}
 		}
 		else
 		{
 			// Correct data? Hopefully...
 			#if 1
 			SafeAddrTokenize(vTo.Str(), Addr);
 			#else
 			TokeniseStrList(vTo.Str(), Addr, ",");
 			#endif
 		}
 		
 		for (auto r: Addr)
 		{
 			Store3Addr *a = new Store3Addr(GetStore());
 			if (a)
 			{
 				char *CcType = strrchr(r, ':');
 				if (CcType)
 					*CcType++ = 0;
 
 				LAutoString Name, Addr;
 				DecodeAddrName(r, Name, Addr, 0);
 				
 				a->SetStr(FIELD_NAME, Name);
 				a->SetStr(FIELD_EMAIL, Addr);
 				a->CC = CcType ? atoi(CcType) : 0;
 				
 				To.Insert(a, -1, true);
 			}
 		}
 		Addr.DeleteArrays();
 		To.State = Store3Loaded;
 	}
 
 	return true;
 }
 
 uint32_t LMail3Mail::Type()
 {
 	return MAGIC_MAIL;
 }
 
 size_t Sizeof(LVariant &v)
 {
 	int s = 0;
 	switch (v.Type)
 	{
 		default:
 			break;
 		case GV_STRING:
 			return (int)strlen(v.Str());
 		case GV_WSTRING:
 			return StrlenW(v.WStr()) * sizeof(char16);
 	}
 	return s + sizeof(v);
 }
 
+size_t Sizeof(LString &s)
+{
+	return sizeof(s) + s.Length();
+}
+
 size_t Sizeof(DIterator<LDataPropI, Store3Addr, LMail3Store> &i)
 {
 	size_t s = sizeof(i);
 	for (unsigned n=0; n<i.Length(); n++)
 		s += i.a[n]->Sizeof();
 
 	return s;
 }
 
 uint64 LMail3Mail::Size()
 {
 	if (MailSize < 0 && Seg)
 	{
 		MailSize = (uint32_t) (Seg->Size() + Seg->SizeChildren());
 	}
 
 	return	MailSize + // Size of mime segments...
 			sizeof(Priority) +
 			sizeof(Flags) +
 			sizeof(AccountId) +
 			Sizeof(Subject) +
 			Sizeof(To) +
 			From.Sizeof() +
 			Reply.Sizeof() +
 			Sizeof(Label) +
 			// Sizeof(InternetHeader) +
 			Sizeof(MessageID) +
 			Sizeof(References) +
 			Sizeof(FwdMsgId) +
 			Sizeof(BounceMsgId) +
 			Sizeof(ServerUid) +
 			sizeof(DateReceived) +
 			sizeof(DateSent);
 }
 
 bool LMail3Mail::DbDelete()
 {
 	return Store->DeleteMailById(Id);
 }
 
 LDataStoreI *LMail3Mail::GetStore()
 {
 	return Store;
 }
 
 LAutoStreamI LMail3Mail::GetStream(const char *file, int line)
 {
 	LAutoStreamI Ret;
 	const char *TmpPath = Store->GetStr(FIELD_TEMP_PATH);
 	
 	if (Flags & MAIL_STORED_FLAT)
 	{
 		// Construct from the single segment...
 		LString Sql;
 		Sql.Printf("select * from '%s' where MailId=" LPrintfInt64, MAIL3_TBL_MAILSEGS, Id);
 		LMail3Store::LStatement s(Store, Sql);
 		if (s.Row())
 		{
 			LStreamConcat *Sc;
 			int64 SegId = s.GetInt64(0);
 			char *Hdr	= s.GetStr(3);
 			
 			if (Hdr && Ret.Reset(Sc = new LStreamConcat))
 			{
 				size_t HdrLen	= strlen(Hdr);
 				int BlobSize	= s.GetSize(4);
 
 				Sc->Add(new LMemStream(Hdr, HdrLen));
 				Sc->Add(new LMemStream("\r\n\r\n", 4));
 				Sc->Add(new Mail3BlobStream(Store, (int)SegId, BlobSize, file, line));
 				
 				LFile f;
 				if (f.Open("c:\\temp\\email.eml", O_WRITE))
 				{
 					LCopyStreamer Cp(64<<10);
 					Cp.Copy(Sc, &f);
 					f.Close();
 					
 					Sc->SetPos(0);
 				}
 			}
 		}
 	}
 	else if (Ret.Reset(new LTempStream(TmpPath)))
 	{
 		// Encode from multiple segments...
 		LoadSegs();
 		if (Seg)
 		{
 			LMime Mime(TmpPath);
 			if (Store3ToLMime(&Mime, Seg))
 			{
 				if (!Mime.Text.Encode.Push(Ret))
 				{
 					LgiTrace("%s:%i - Mime encode failed.\n", _FL);
 					Ret.Reset();					
 				}
 			}
 			else
 			{
 				LgiTrace("%s:%i - Store3ToGMime failed.\n", _FL);
 				Ret.Reset();
 			}
 		}
 		else
 		{
 			LgiTrace("%s:%i - No segment to encode.\n", _FL);
 			Ret.Reset();
 		}
 	}
 	
 	return Ret;
 }
 
 bool LMail3Mail::SetStream(LAutoStreamI stream)
 {
 	if (!stream)
 		return false;
 
 	DeleteObj(Seg);
 
 	// MIME parse the stream and store it to segments.
 	LMime Mime;
 	if (Mime.Text.Decode.Pull(stream))
 	{
 		Seg = new LMail3Attachment(Store);
 		if (Seg)
 		{
 			// This stops the objects being written to disk.
 			// Which would mean we have multiple copies of the same
 			// data on disk. This setting also propagates down the
 			// tree automatically as GMimeToStore3 saves new child
 			// notes to their parents.
 			Seg->SetInMemoryOnly(true);
 			Seg->AttachTo(this);
 			
 			GMimeToStore3(Seg, &Mime);
 		}
 	}
 
 	return false;
 }
 
 bool LMail3Mail::FindSegs(const char *MimeType, LArray<LMail3Attachment*> &Results, bool Create)
 {
 	LoadSegs();
 	
 	if ((!Seg || !Seg->FindSegs(MimeType, Results)) && Create)
 	{
 		LMail3Attachment *a = new LMail3Attachment(Store);
 		if (!a)
 			return false;
 		a->SetStr(FIELD_MIME_TYPE, MimeType);
 
 		Store3MimeTree<LMail3Store, LMail3Mail, LMail3Attachment> Tree(this, Seg);
 		Tree.Add(a);
 		if (!Tree.Build())
 			return false;
 		
 		Results.Add(a);
 	}
 	
 	/* 
 	for (unsigned i=0; i<Results.Length(); i++)
 	{
 		LMail3Attachment *a = Results[i];
 		if (!a->GetStr(FIELD_MIME_TYPE))
 		{
 			// Ugh, a bug has caused a bunch of NULL mime-types..
 			a->SetStr(FIELD_MIME_TYPE, MimeType);
 		}
 	}
 	*/
 
 	return Results.Length() > 0;
 }
 
 LMail3Attachment *LMail3Mail::GetAttachment(int64 Id)
 {
 	return Seg ? Seg->Find(Id) : 0;
 }
 
 struct Pair
 {
 	int64 Parent;
 	LMail3Attachment *Seg;
 };
 
 int LMail3Mail::GetAttachments(LArray<LMail3Attachment*> *Lst)
 {
 	if (!Seg)
 		return -1;
 
 	int Count = 0;
 	if (Seg->IsMultipart())
 	{
 		LDataIt It = Seg->GetList(FIELD_MIME_SEG);
 		if (It)
 		{
 			for (LDataPropI *i=It->First(); i; i=It->Next())
 			{
 				const char *Mt = i->GetStr(FIELD_MIME_TYPE);
 				const char *Name = i->GetStr(FIELD_NAME);
 				if
 				(
 					(
 						Mt &&
 						_stricmp("text/plain", Mt) &&
 						_stricmp("text/html", Mt)
 					)
 					||
 					ValidStr(Name)
 				)
 				{
 					Count++;
 					if (Lst)
 					{
 						LMail3Attachment *a = dynamic_cast<LMail3Attachment*>(i);
 						if (a)
 							Lst->Add(a);
 					}
 				}
 			}
 		}
 	}
 
 	return Count;
 }
 
 void LMail3Mail::LoadSegs()
 {
 	if (Id > 0 && !Seg)
 	{
 		if (Flags & MAIL_STORED_FLAT)
 		{
 			// Decompression flat MIME storage to tree
 			
 			// GetStream will do the hard work of joining the message back
 			// into RFC822 format.
 			LAutoStreamI Rfc822 = GetStream(_FL);
 			if (!Rfc822)
 				return;
 
 			// Then we MIME parse it and store it to segments.
 			SetStream(Rfc822);
 		}
 		else
 		{
 			LArray<Pair> Others;
 
 			char Sql[256];
 			sprintf_s(Sql, sizeof(Sql), "select * from '%s' where MailId=" LPrintfInt64, MAIL3_TBL_MAILSEGS, Id);
 			LMail3Store::LStatement s(Store, Sql);
 			while (s.Row())
 			{
 				Pair p;
 				p.Seg = new LMail3Attachment(Store);
 				if (p.Seg->Load(s, p.Parent))
 				{
 					if (p.Parent <= 0)
 					{
 						if (Seg)
 						{
 							// hmmm, this shouldn't happen
 							p.Seg->AttachTo(Seg);
 						}
 						else
 						{
 							p.Seg->AttachTo(this);
 						}
 
 						#ifdef _DEBUG
 						// This was a hack to fix a dumb bug in a dev build... so so dumb.
 						if (p.Seg->GetDirty())
 						{
 							LArray<LDataI*> items{this};
 							Store->OnChange(_FL, items, FIELD_MIME_SEG);
 						}
 						#endif
 					}
 					else
 					{
 						Others.Add(p);
 					}
 				}
 			}
 
 			while (Seg && Others.Length())
 			{
 				ssize_t StartSize = Others.Length();
 
 				for (unsigned i=0; i<Others.Length(); i++)
 				{
 					LMail3Attachment *p = Seg->Find(Others[i].Parent);
 					if (p)
 					{
 						Others[i].Seg->AttachTo(p);
 						Others.DeleteAt(i--);
 					}
 				}
 
 				if (StartSize == Others.Length())
 				{
 					// No segments could be attached? Must have borked up parent id's
 					while (Others.Length())
 					{
 						// Just attach them somewhere... anywhere...!
 						if (Seg)
 							Others[0].Seg->AttachTo(Seg);
 						else
 							Others[0].Seg->AttachTo(this);
 						Others.DeleteAt(0);
 					}
 				}
 			}
 
 			if (Seg)
 			{
 				int Attached = GetAttachments();
 				int NewFlags;
 				if (Attached > 0)
 					NewFlags = Flags | MAIL_ATTACHMENTS;
 				else
 					NewFlags = Flags & ~MAIL_ATTACHMENTS;
 				if (NewFlags != Flags)
 				{
 					Flags = NewFlags;
 					Save();
 				}
 			}
 		}
 	}
 }
 
 static auto DefaultCharset = "windows-1252";
 			
 const char *LMail3Mail::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_DEBUG:
 		{
 			static char s[64];
 			sprintf_s(s, sizeof(s), "Mail3.Id=" LPrintfInt64, Id);
 			return s;
 		}
 		case FIELD_SUBJECT:
 		{
-			if (!LIsUtf8(Subject.Str()))
-			{
-				auto cs = DetectCharset(Subject.Str());
-				LAutoString conv;
-				if (conv.Reset((char*)LNewConvertCp("utf-8", Subject.Str(), cs ? cs.Get() : DefaultCharset)))
-					Subject = conv;
-			}
-
-			#if 0
-			int32 ch;
-			LgiTrace("Subj:");
-			for (LUtf8Ptr p(Subject.Str()); ch = p; p++)
-				LgiTrace(" u+%x", ch);
-			LgiTrace("\n");
-			#endif
-
-			return Subject.Str();
+			Utf8Check(Subject);
+			return Subject;
 		}
 		case FIELD_CHARSET:
 		{
 			return "utf-8";
 		}
 		case FIELD_TEXT:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (!TextCache && FindSegs("text/plain", Results))
 			{
 				LStringPipe p;
 				for (auto seg: Results)
 				{
 					if (seg->GetStr(FIELD_NAME))
 						continue;
 
 					auto s = seg->GetStream(_FL);
 					if (!s)
 						continue;
 
 					LString Charset = seg->GetStr(FIELD_CHARSET);
 
 					LAutoString Buf;
 					auto Size = s->GetSize();
 					if (Size <= 0)
 						continue;
 
 					Buf.Reset(new char[Size+1]);
 					s->Read(&Buf[0], Size);
 					Buf[Size] = 0;
 
 					if (!Charset)
 						Charset = DetectCharset(Buf.Get());
 					if (!Charset)
 						Charset = DefaultCharset;
 
 					LAutoString Utf8;
 					if (!Stricmp(Charset.Get(), "utf-8") && LIsUtf8(Buf))
 						Utf8 = Buf;
 					else
 						Utf8.Reset((char*)LNewConvertCp("utf-8", Buf, Charset, Size));
 
 					if (Results.Length() > 1)
 					{
 						if (p.GetSize())
 							p.Print("\n---------------------------------------------\n");
 						p.Push(Utf8);
 					}
 					else
 					{
 						TextCache = Utf8;
 						return TextCache;
 					}
 				}
 
 				TextCache.Reset(p.NewStr());
 			}
 			return TextCache;
 		}
 		case FIELD_HTML_CHARSET:
 		{
 			return "utf-8";
 		}
 		case FIELD_ALTERNATE_HTML:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (!HtmlCache && FindSegs("text/html", Results))
 			{
 				LMemQueue Blocks(1024);
 				int64 Total = 0;
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						LAutoStreamI s = Results[i]->GetStream(_FL);
 						if (s)
 						{
 							int64 Size = s->GetSize();
 							if (Size > 0)
 							{
 								auto Charset = Results[i]->GetStr(FIELD_CHARSET);
 							
 								char *Buf = new char[(size_t)Size+1];
 								ssize_t Rd = s->Read(Buf, (int)Size);
 								if (Rd > 0)
 								{
 									Buf[Rd] = 0;
 									
 									if (Charset && _stricmp("utf-8", Charset) != 0)
 									{
 										char *Tmp = (char*)LNewConvertCp("utf-8", Buf, Charset, (int)Size);
 										if (Tmp)
 										{
 											DeleteArray(Buf);
 											Buf = Tmp;
 											Size = strlen(Tmp);
 										}
 									}
 									
 									Blocks.Write(Buf, (int)Size);
 									Total += Size;
 									DeleteArray(Buf);
 								}
 							}
 						}
 					}
 				}
 				
 				HtmlCache.Reset((char*)Blocks.New(1));				
 			}
 			return HtmlCache;
 		}
 
 		case FIELD_LABEL:
 			return Label.Str();
 		case FIELD_INTERNET_HEADER:
 		{
 			auto Root = GetObj(FIELD_MIME_SEG);
 			if (Root)
 				return Root->GetStr(id);
 			else
 				return NULL;
 		}
 		case FIELD_REFERENCES:
 			return References.Str();
 		case FIELD_FWD_MSG_ID:
 			return FwdMsgId.Str();
 		case FIELD_BOUNCE_MSG_ID:
 			return BounceMsgId.Str();
 		case FIELD_SERVER_UID:
 			return ServerUid.Str();
 		case FIELD_MESSAGE_ID:
 		{
 			if (!MessageID.Str())
 			{
 				LAutoString Header(InetGetHeaderField(GetStr(FIELD_INTERNET_HEADER), "Message-ID"));
 				if (Header)
 				{
 					auto Ids = ParseIdList(Header);
 					MessageID = Ids[0];
 				}
 			}
 			return MessageID.Str();
 		}
 		case FIELD_UID:
 		{
 			IdCache.Printf(LPrintfInt64, Id);
 			return IdCache;
 		}
 		case FIELD_ERROR:
 			return ErrMsg;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 void LMail3Mail::OnSave()
 {
 	if (Seg)
 	{
 		LDataStoreI::StoreTrans Trans = Store->StartTransaction();
 		Seg->OnSave();
 	}
 }
 
 void LMail3Mail::ParseAddresses(char *Str, int CC)
 {
 	List<char> Addr;
 	TokeniseStrList(Str, Addr, ",");
 	
 	for (auto RawAddr: Addr)
 	{
 		LAutoPtr<LDataPropI> a(To.Create(Store));
 		if (a)
 		{
 			Store3Addr *sa = dynamic_cast<Store3Addr*>(a.Get());
 			LAssert(sa != NULL);
 			if (sa)
 			{
 				DecodeAddrName(RawAddr, sa->Name, sa->Addr, 0);
 				sa->CC = CC;
 				To.Insert(a.Release());
 			}
 		}
 	}
 	Addr.DeleteArrays();
 }
 
 void LMail3Mail::ResetCaches()
 {
 	TextCache.Reset();
 	HtmlCache.Reset();
 	SizeCache.Reset();
 }
 
-const char *LMail3Mail::InferCharset()
+const char *LMail3Mail::InferCharset(const char *ExampleTxt)
 {
 	if (!InferredCharset)
 	{
 		// Sometimes mailers don't follow the rules... *cough*outlook*cough*
 		// So lets play the "guess the charset" game...
 	
 		// Maybe one of the segments has a charset?
 		InferredCharset = Seg->GetStr(FIELD_CHARSET);		
 		if (!InferredCharset)
 		{
 			// What about 'Content-Language'?
 			auto InetHdrs = GetStr(FIELD_INTERNET_HEADER);
 			if (InetHdrs)
 			{
 				LAutoString ContentLang(InetGetHeaderField(InetHdrs, "Content-Language"));
 				if (ContentLang)
 				{
 					LLanguage *Lang = LFindLang(ContentLang);
 					if (Lang)
 						InferredCharset = Lang->Charset;
 				}
 			}
 		}
 	}
+
+	if (!InferredCharset && ExampleTxt)
+	{
+		// Fall back to detecting the charset based on the text itself:
+		static LString Cs;
+		Cs = DetectCharset(ExampleTxt);
+		if (Cs)
+			InferredCharset = Cs;
+	}
 		
 	return InferredCharset;
 }
 
 bool LMail3Mail::Utf8Check(LAutoString &v)
 {
 	if (!LIsUtf8(v.Get()))
 	{
-		const char *Cs = InferCharset();
+		const char *Cs = InferCharset(v.Get());
 		if (Cs)
 		{
 			LAutoString Value((char*) LNewConvertCp("utf-8", v, Cs, -1));
 			if (Value)
 			{
 				v = Value;
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
+bool LMail3Mail::Utf8Check(LString &v)
+{
+	if (LIsUtf8(v))
+		return true;
+
+	// auto cs = DetectCharset(Subject);
+	auto Cs = InferCharset(v);
+	if (!Cs)
+		return false;
+
+	LAutoString Value((char*) LNewConvertCp("utf-8", v, Cs, v.Length()));
+	if (!Value)
+		return false;
+
+	v = Value.Get();
+	return true;
+}
+
 bool LMail3Mail::Utf8Check(LVariant &v)
 {
 	if (!LIsUtf8(v.Str()))
 	{
-		const char *Cs = InferCharset();
+		const char *Cs = InferCharset(v.Str());
 		if (Cs)
 		{
 			LAutoString Value((char*) LNewConvertCp("utf-8", v.Str(), Cs, -1));
 			if (Value)
 			{
 				v.OwnStr(Value.Release());
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 bool LMail3Mail::ParseHeaders()
 {
 	// Reload from headers...
-	auto InetHdrs = GetStr(FIELD_INTERNET_HEADER);
-	Subject.OwnStr(DecodeRfc2047(InetGetHeaderField(InetHdrs, "subject")));
+	LString InetHdrs = GetStr(FIELD_INTERNET_HEADER);
+	Subject = LDecodeRfc2047(LGetHeaderField(InetHdrs, "subject"));
 	Utf8Check(Subject);
 
 	// From
-	LAutoString s(DecodeRfc2047(InetGetHeaderField(InetHdrs, "from")));
+	auto s = LDecodeRfc2047(LGetHeaderField(InetHdrs, "from"));
 	Utf8Check(s);
 	From.Empty();
 	DecodeAddrName(s, From.Name, From.Addr, NULL);
 
-	s.Reset(DecodeRfc2047(InetGetHeaderField(InetHdrs, "reply-to")));
+	s = LDecodeRfc2047(LGetHeaderField(InetHdrs, "reply-to"));
 	Utf8Check(s);
 	Reply.Empty();
 	DecodeAddrName(s, Reply.Name, Reply.Addr, NULL);
 
 	// Parse To and CC headers.
 	To.DeleteObjects();
-	if (s.Reset(DecodeRfc2047(InetGetHeaderField(InetHdrs, "to"))))
+	if (s = LDecodeRfc2047(LGetHeaderField(InetHdrs, "to")))
 	{
 		Utf8Check(s);
 		ParseAddresses(s, MAIL_ADDR_TO);
 	}
-	if (s.Reset(DecodeRfc2047(InetGetHeaderField(InetHdrs, "cc"))))
+	if (s = LDecodeRfc2047(LGetHeaderField(InetHdrs, "cc")))
 	{
 		Utf8Check(s);
 		ParseAddresses(s, MAIL_ADDR_CC);
 	}
 
 	// Data
-	if (s.Reset(InetGetHeaderField(InetHdrs, "date")))
+	if (s = LGetHeaderField(InetHdrs, "date"))
 	{
 	    DateSent.Decode(s);
 		DateSent.ToUtc();
 	}
 				
 	DeleteObj(Seg);
 	ResetCaches();
 	
 	return true;
 }
 
 Store3Status LMail3Mail::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_SUBJECT:
 			Subject = str;
 			break;
 
 		case FIELD_TEXT:
 		{
 			TextCache.Reset();
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/plain", Results, str != 0))
 			{
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 					    LAutoStreamI s(str ? new LMemStream((char*)str, strlen(str)) : 0);
 						Results[i]->SetStream(s);
 						break;
 					}
 				}
 			}
 			break;
 		}
 		case FIELD_CHARSET:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/plain", Results, str != 0))
 			{
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						Results[i]->SetStr(FIELD_CHARSET, str);
 						break;
 					}
 				}
 			}
 			break;
 		}
 		case FIELD_ALTERNATE_HTML:
 		{
 			HtmlCache.Reset();
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/html", Results, str != 0))
 			{
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						if (str)
 						{
 							LAutoStreamI tmp(new LMemStream((char*)str, strlen(str)));
 							Results[i]->SetStream(tmp);
 						}
 						else
 						{
 							auto s = Results[i];
 							s->Delete();
 							delete s;
 						}
 						break;
 					}
 				}
 			}
 			break;
 		}
 		case FIELD_HTML_CHARSET:
 		{
 			LArray<LMail3Attachment*> Results;
 			if (FindSegs("text/html", Results, str != 0))
 			{
 				const char *Charset = str && *str == '>' ? str + 1 : str;
 				for (unsigned i=0; i<Results.Length(); i++)
 				{
 					if (!Results[i]->GetStr(FIELD_NAME))
 					{
 						if (Results[i]->SetStr(FIELD_CHARSET, Charset))
 							return Store3Success;
 						break;
 					}
 				}
 			}
 
 			return Store3Error;
 		}
 
 		case FIELD_LABEL:
 			Label = str;
 			break;
 		case FIELD_INTERNET_HEADER:
 		{
 			LoadSegs();
 			
 			if (!ValidStr(str))
 				// There is no point continuing as it will just attach an empty
 				// attachment which eventually asserts in the save code.
 				//		e.g. LMail3Attachment::GetHeaders()
 				break;
 
 			if (!Seg)
 			{
 				// This happens when the user re-sends an email and it creates
 				// a new empty email to copy the old sent email into.
 				LMail3Attachment *a = new LMail3Attachment(Store);
 				if (!a)
 				{
 					LAssert(0);
 					return Store3Error;
 				}
 				
 				a->AttachTo(this);
 			}
 			
 			Seg->SetStr(id, str);
 			break;
 		}
 		case FIELD_MESSAGE_ID:
 			MessageID = str;
 			break;
 		case FIELD_REFERENCES:
 			References = str;
 			break;
 		case FIELD_FWD_MSG_ID:
 			FwdMsgId = str;
 			break;
 		case FIELD_BOUNCE_MSG_ID:
 			BounceMsgId = str;
 			break;
 		case FIELD_SERVER_UID:
 			ServerUid = str;
 			break;
 
 		default:
 			LAssert(0);
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 int64 LMail3Mail::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_STORE_TYPE:
 			return Store3Sqlite;
 		case FIELD_SIZE:
 			return Size();
 		case FIELD_LOADED:
 			return Store3Loaded;
 		case FIELD_PRIORITY:
 			return Priority;
 		case FIELD_FLAGS:
 			return Flags;
 		case FIELD_DONT_SHOW_PREVIEW:
 			return false;
 		case FIELD_ACCOUNT_ID:
 			return AccountId;
 		case FIELD_COLOUR:
 			return (uint64_t)MarkColour;
 		case FIELD_SERVER_UID:
 			return -1;
 	}
 
 	LAssert(0);
 	return -1;
 }
 
 Store3Status LMail3Mail::SetInt(int id, int64 i)
 {
 	switch (id)
 	{
 		case FIELD_LOADED:
 			return Store3Success;
 		case FIELD_PRIORITY:
 			Priority = (int)i;
 			return Store3Success;
 		case FIELD_FLAGS:
 			Flags = (int)i;
 			return Store3Success;
 		case FIELD_ACCOUNT_ID:
 			AccountId = (int)i;
 			return Store3Success;
 		case FIELD_COLOUR:
 			if (i < 0)
 				MarkColour = Rgba32(0, 0, 0, 0); // transparent
 			else
 				MarkColour = (uint32_t)i;
 			return Store3Success;
 	}
 
 	LAssert(0);
 	return Store3NotImpl;
 }
 
 const LDateTime *LMail3Mail::GetDate(int id)
 {
 	switch (id)
 	{
 		case FIELD_DATE_RECEIVED:
 			return &DateReceived;
 		case FIELD_DATE_SENT:
 			return &DateSent;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 Store3Status LMail3Mail::SetDate(int id, const LDateTime *t)
 {
 	switch (id)
 	{
 		case FIELD_DATE_RECEIVED:
 			if (t)
 				DateReceived = *t;
 			else
 				DateReceived.Year(0);
 			return Store3Success;
 		case FIELD_DATE_SENT:
 			if (t)
 				DateSent = *t;
 			else
 				DateSent.Year(0);
 			return Store3Success;
 	}
 
 	LAssert(0);
 	return Store3NotImpl;
 }
 
 LDataPropI *LMail3Mail::GetObj(int id)
 {
 	switch (id)
 	{
 		case FIELD_FROM:
 			return &From;
 		case FIELD_REPLY:
 			return &Reply;
 		case FIELD_MIME_SEG:
 		{
 			LoadSegs();
 
 			/* This causes replies to have the wrong format for "text/plain"
 			if (!Seg)
 			{
 				LMail3Attachment *a = new LMail3Attachment(Store);
 				if (a)
 				{
 					a->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 					a->AttachTo(this);
 				}
 			}
 			*/
 
 			return Seg;
 		}
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 Store3Status LMail3Mail::SetObj(int id, LDataPropI *i)
 {
 	switch (id)
 	{
 		case FIELD_MIME_SEG:
 		{
 			if (Seg)
 			{
 				Seg->SetMail(NULL);
 				Seg = NULL;
 			}
 			
 			LMail3Attachment *a = dynamic_cast<LMail3Attachment*>(i);
 			if (!a)
 			{
 				LAssert(!"Incorrect object...");
 				return Store3Error;
 			}
 			
 			Seg = a;
 			Seg->SetMail(this);
 			break;
 		}
 		case FIELD_HTML_RELATED:
 		{
 			LMail3Attachment *a = i ? dynamic_cast<LMail3Attachment*>(i) : NULL;
 			
 			LoadSegs();
 			if (Seg)
 			{
 				Store3MimeTree<LMail3Store, LMail3Mail, LMail3Attachment> Tree(this, Seg);
 				
 				if (a)
 					Tree.MsgHtmlRelated.Add(a);
 				else
 					Tree.MsgHtmlRelated.Empty();
 				
 				if (!Tree.Build())
 					return Store3Error;
 					
 				MailSize = -1;
 				Seg->Save(this);
 			}
 			break;
 		}
 		default:
 			LAssert(0);
 			return Store3NotImpl;
 	}
 	
 	return Store3Success;
 }
 
 LDataIt LMail3Mail::GetList(int id)
 {
 	switch (id)
 	{
 		case FIELD_TO:
 			return &To;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 class LSubStream : public LStreamI
 {
 	// The source stream to read from
 	LStreamI *s;
 	
 	// The start position in the source stream
 	int64 Start;
 	
 	// The length of the sub-stream
 	int64 Len;
 	
 	// The current position in the sub-stream
 	// (relative to the start of the sub-stream, not the parent stream)
 	int64 Pos;
 
 public:
 	LSubStream(LStreamI *stream, int64 start = 0, int64 len = -1)
 	{
 		s = stream;
 		Pos = 0;
 		Start = MAX(0, start);
 		
 		int64 MaxLen = s->GetSize() - Start;
 		if (MaxLen < 0)
 			MaxLen = 0;
 		Len = len < 0 && s ? MaxLen : MIN(MaxLen, len); 
 	}
 
 	bool IsOpen() { return true; }
 	int Close()
 	{
 		s = NULL;
 		Start = Len = Pos = 0;
 		return true;
 	}
 	
 	int64 GetSize()
 	{
 		return s ? Len : -1;
 	}
 	
 	int64 SetSize(int64 Size)
 	{
 		// Can't set size
 		return GetSize();
 	}
 
 	int64 GetPos()
 	{
 		return s ? Pos : -1;
 	}
 	
 	int64 SetPos(int64 p)
 	{
 		if (p < 0) p = 0;
 		if (p >= Len) p = Len;
 		return Pos = p;
 	}
 	
 	ssize_t Read(void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		ssize_t r = 0;
 		if (s && Buffer)
 		{
 			int64 Remaining = Len - Pos;
 			ssize_t Common = MIN(Size, (int)Remaining);
 			
 			int64 SrcPos = Start + Pos;
 			int64 ActualPos = s->SetPos(SrcPos);
 			if (ActualPos == SrcPos)
 			{			
 				r = s->Read(Buffer, Common, Flags);
 				if (r > 0)
 				{
 					Pos += r;
 				}
 			}
 			else LAssert(0);
 		}
 		return r;
 	}
 	
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		LAssert(!"Not implemented.");
 		return 0;
 	}
 	
 	LStreamI *Clone() { return new LSubStream(s, Start, Len); }
 };
 
 Store3Status LMail3Mail::SetRfc822(LStreamI *m)
 {
 	Store3Status Status = Store3Error;
 
 	if (!m)
 	{
 		ErrMsg = "No input stream.";
 		return Status;
 	}
 
 	// Save all the segments out
 	LDataStoreI::StoreTrans Trans = Store->StartTransaction();
 
 	if (Id < 0)
 	{
 		// Must commit ourselves now and get an Id
 		if (!Write(MAIL3_TBL_MAIL, true))
 		{
 			ErrMsg = "Write to MAIL3_TBL_MAIL failed.";
 			return Store3Error;
 		}
 	}
 	else
 	{
 		char s[256];
 		sprintf_s(s, sizeof(s), "delete from %s where MailId=" LPrintfInt64, MAIL3_TBL_MAILSEGS, Id);
 		LMail3Store::LStatement Del(Store, s);
 		if (!Del.Exec())
 		{
 			ErrMsg = "Delete query failed.";
 			return Store3Error;
 		}
 	}
 
 	DeleteObj(Seg);
 
 	/*
 	Normally the message is parsed into MIME segments and stored parsed and decoded into 
 	the MailSegs table. If the message is encrypted or signed that could the client can't
 	verify the message later because the specifics of MIME encoding varies between clients.
 		
 	So if the message is:
 		
 		Signed and/or Encrypted:	There is only one MAILSEG record with all the headers of the 
 									root MIME segment, and the body stream has all the data of
 									the RFC822 image.
 			
 		Otherwise:					Normal MIME parsing is done, storing the message in different
 									MAILSEG records. Which was the previous behaviour.
 
 	First the headers of the root MIME node are read to see what the Content-Type is.
 	Then a decision about how to store the node is made.
 	*/
 	LString Hdrs = HeadersFromStream(m);
 	LAutoString Type(InetGetHeaderField(Hdrs, "Content-Type"));
 
 	Flags &= ~MAIL_STORED_FLAT;
 	if (Type)
 	{
 		LString s = Type.Get();
 		ptrdiff_t Colon = s.Find(";");
 		if (Colon > 0)
 			s.Length((uint32_t)Colon);
 		s = s.Strip().Lower();
 		if (s == sMultipartEncrypted ||
 			s == sMultipartSigned)
 		{
 			Flags |= MAIL_STORED_FLAT;
 		}
 	}
 
 	LMail3Store::LInsert Ins(Store, MAIL3_TBL_MAILSEGS);
 	MailSize = 0;
 
 	LMime Mime;
 	if (Flags & MAIL_STORED_FLAT)
 	{
 		// Don't parse MIME into a tree.
 		Mime.SetHeaders(Hdrs);
 		Mime.SetData(true, new LSubStream(m, Hdrs.Length()+4));
 		if (Mail3_InsertSeg(Ins, &Mime, Id, -1, MailSize))
 			Status = Store3Success;
 		else
 			ErrMsg = "Flat insert query failed.";
 	}
 	else
 	{
 		// Do normal parsing in to MIME tree.
 		if (Mime.Text.Decode.Pull(m) &&
 			Mail3_InsertSeg(Ins, &Mime, Id, -1, MailSize))
 			Status = Store3Success;
 		else
 			ErrMsg = "Regular insert query failed.";
 	}
 
 	return Status;
 }