diff --git a/Code/Scribe.h b/Code/Scribe.h
--- a/Code/Scribe.h
+++ b/Code/Scribe.h
@@ -1,2559 +1,2563 @@
 /*hdr
 **      FILE:           Scribe.h
 **      AUTHOR:         Matthew Allen
 **      DATE:           22/10/97
 **      DESCRIPTION:    Scribe email application
 **
 **      Copyright (C) 1998-2003 Matthew Allen
 **              fret@memecode.com
 */
 
 // Includes
 #include <stdio.h>
 #include <functional>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DragAndDrop.h"
 #include "lgi/common/DateTime.h"
 #include "lgi/common/Password.h"
 #include "lgi/common/vCard-vCal.h"
 #include "lgi/common/WordStore.h"
 #include "lgi/common/SharedMemory.h"
 #include "lgi/common/XmlTreeUi.h"
 #include "lgi/common/Mime.h"
 #include "lgi/common/OptionsFile.h"
 #include "lgi/common/TextLog.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/ToolBar.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Printer.h"
 
 // Gui controls
 #include "lgi/common/Panel.h"
 #include "lgi/common/DocView.h"
 #include "lgi/common/List.h"
 #include "lgi/common/Tree.h"
 #include "lgi/common/ListItemCheckBox.h"
 
 // Storage
 #include "lgi/common/Store3.h"
 
 // App Includes
 #include "ScribeInc.h"
 #include "ScribeUtils.h"
 #include "ScribeDefs.h"
 #include "DomType.h"
 
 class ListAddr;
 
 // The field definition type
 struct ItemFieldDef
 {
 	const char *DisplayText;
 	ScribeDomType Dom;
 	LVariantType Type;
 	int FieldId; // Was 'Id'
 	int CtrlId;
 	const char *Option;
 	bool UtcConvert;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Classes
 class MailTree;
 class LMailStore;
 class ScribeWnd;
 class Thing;
 class Mail;
 class Contact;
 class ThingUi;
 class MailUi;
 class ScribeFolder;
 class ContactUi;
 class FolderPropertiesDlg;
 class ScribeAccount;
 class Filter;
 class Attachment;
 class Calendar;
 class CalendarSource;
 
 class AttachmentList;
 struct ItemFieldDef;
 class FolderDlg;
 class Filter;
 class ContactGroup;
 class ScribeBehaviour;
 class AccountletThread;
 class ThingList;
 class LSpellCheck;
 
 ////////////////////////////////////////////////////////////////////////
 // Scripting support
 #include "lgi/common/Scripting.h"
 
 /// Script callback types. See 'api.html' in the Scripts folder for more details.
 enum LScriptCallbackType
 {
 	LCallbackNull,
 	LToolsMenu,
 	LThingContextMenu,
 	LThingUiToolbar,
 	LApplicationToolbar,
 	LMailOnBeforeSend, // "OnBeforeMailSend"
 	LMailOnAfterReceive,
 	LBeforeInstallBar,
 	LInstallComponent,
 	LFolderContextMenu,
 	LOnTimer,
 	LRenderMail,
 	LOnLoad
 };
 
 struct LScript;
 struct LScriptCallback
 {
 	LScriptCallbackType Type = LCallbackNull;
 	LScript *Script = NULL;
 	LFunctionInfo *Func = NULL;
 	int Param = 0;
 	double fParam = 0.0;
 	LVariant Data;
 	uint64 PrevTs = 0;
 	bool OnSecond = false;
 };
 
 struct LScript
 {
 	LAutoPtr<LCompiledCode> Code;
 	LArray<LScriptCallback> Callbacks;
 };
 
 typedef void (*ConsoleClosingCallback)(class LScriptConsole *Console, void *user_data);
 
 class LScriptConsole : public LWindow
 {
 	ScribeWnd *App;
 	LTextLog *Txt;
 	ConsoleClosingCallback Callback;
 	void *CallbackData;
 
 	bool OnViewKey(LView *v, LKey &k);
 
 public:
 	LScriptConsole(ScribeWnd *app, ConsoleClosingCallback callback, void *callback_data);
 	~LScriptConsole();
 
 	void Write(const char *s, int64 Len);
 	bool OnRequestClose(bool OsShuttingDown);
 };
 
 /// This class is a wrapper around a user interface element used for
 /// Scripting. The script engine needs to be able to store information 
 /// pertaining to the menu item's callbacks along with the sub menu.
 class LScriptUi : public LDom
 {
 public:
 	LScriptUi *Parent;
 	LSubMenu *Sub;
 	LToolBar *Toolbar;
 	LArray<LScriptCallback> Callbacks;
 	LArray<LScriptUi*> Subs;
 
 	LScriptUi()
 	{
 		Parent = 0;
 		Sub = 0;
 		Toolbar = 0;
 	}
 
 	LScriptUi(LSubMenu *s)
 	{
 		Parent = 0;
 		Toolbar = 0;
 		Sub = s;
 	}
 
 	LScriptUi(LToolBar *t)
 	{
 		Parent = 0;
 		Toolbar = t;
 		Sub = 0;
 	}
 
 	~LScriptUi()
 	{
 		Subs.DeleteObjects();
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Arr = NULL) override
 	{
 		if (Sub)
 			return Sub->GetVariant(Name, Value, Arr);
 
 		LDomProperty Method = LStringToDomProp(Name);
 		if (Method == ObjLength)
 		{
 			if (Toolbar)
 				Value = (int64)Toolbar->Length();
 		}
 		else return false;
 
 		return true;
 	}
 
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override
 	{
 		if (Sub)
 			return Sub->CallMethod(MethodName, ReturnValue, Args);
 
 		return false;
 	}
 
 	bool SetupCallbacks(ScribeWnd *App, ThingUi *Parent, Thing *t, LScriptCallbackType Type);
 	bool ExecuteCallbacks(ScribeWnd *App, ThingUi *Parent, Thing *t, int Cmd);
 };
 
 class LScribeScript : public LScriptContext
 {
 	LScriptEngine *Eng;
 	struct LScribeScriptPriv *d;
 
 public:
 	ScribeWnd *App;
 
 	static LScribeScript *Inst;
 
 	LScribeScript(ScribeWnd *app);
 	~LScribeScript();
 
 	void ShowScriptingWindow(bool show);
 	LAutoString GetDataFolder();
 	LStream *GetLog();
 	GHostFunc *GetCommands();	
 	char *GetIncludeFile(char *FileName);
 
 	// System
 	void SetEngine(LScriptEngine *eng);
 	bool MsgBox(LScriptArguments &Args);
 
 	// Paths
 	bool GetSystemPath(LScriptArguments &Args);
 	bool GetScribeTempPath(LScriptArguments &Args);
 	bool JoinPath(LScriptArguments &Args);
 
 	// Folders
 	bool GetFolder(LScriptArguments &Args);
 	bool GetSourceFolders(LScriptArguments &Args);
 	bool CreateSubFolder(LScriptArguments &Args);
 	bool LoadFolder(LScriptArguments &Args);
 	bool FolderSelect(LScriptArguments &Args);
 	bool BrowseFolder(LScriptArguments &Args);
 
 	// Things
 	bool CreateThing(LScriptArguments &Args);
 	bool MoveThing(LScriptArguments &Args);
 	bool SaveThing(LScriptArguments &Args);
 	bool DeleteThing(LScriptArguments &Args);
 	bool ShowThingWindow(LScriptArguments &Args);
 	bool FilterDoActions(LScriptArguments &Args);
 	bool LookupContact(LScriptArguments &Args);
 
 	// Callbacks
 	bool AddToolsMenuItem(LScriptArguments &Args);
 	bool AddCallback(LScriptArguments &Args);
 
 	// UI
 	bool MenuAddItem(LScriptArguments &Args);
 	bool MenuAddSubmenu(LScriptArguments &Args);
 	bool ToolbarAddItem(LScriptArguments &Args);
 };
 
 ////////////////////////////////////////////////////////////////////////
 class ScribePassword
 {
 	class ScribePasswordPrivate *d;
 
 public:
 	ScribePassword(LOptionsFile *p, const char *opt, int check, int pwd, int confirm);
 	~ScribePassword();
 
 	bool IsOk();
 	bool Load(LView *dlg);
 	bool Save();
 	void OnNotify(LViewI *c, LNotification &n);
 };
 
 
 class ChooseFolderDlg : public LDialog
 {
     ScribeWnd *App;
 	LEdit *Folder;
 	int Type;
 	bool Export;
 	LList *Lst;
 
 	void InsertFile(const char *f);
 
 public:
 	LString DestFolder;
 	LString::Array SrcFiles;
 
 	ChooseFolderDlg
 	(
 		ScribeWnd *parent,
 		bool IsExport,
 		const char *Title,
 		const char *Msg,
 		char *DefFolder = NULL,
 		int FolderType = MAGIC_MAIL,
 		LString::Array *Files = NULL
 	);
 
 	int OnNotify(LViewI *Ctrl, LNotification n);
 };
 
 #define IoProgressImplArgs		LAutoPtr<LStreamI> stream, const char *mimeType, IoProgressCallback cb
 #define IoProgressFnArgs		IoProgressImplArgs = NULL
 #define IoProgressError(err)	\
 	{ \
 		IoProgress p(Store3Error, err); \
 		if (cb) cb(&p, stream); \
 		return p; \
 	}
 #define IoProgressSuccess()	\
 	{ \
 		IoProgress p(Store3Success); \
 		if (cb) cb(&p, stream); \
 		return p; \
 	}
 #define IoProgressNotImpl()	\
 	{ \
 		IoProgress p(Store3NotImpl); \
 		if (cb) cb(&p, stream); \
 		return p; \
 	}
 
 class ScribeClass ThingType :
 	public LDom,
 	public LDataUserI
 {
 	bool Dirty     = false;
 	bool WillDirty = true;
 	bool Loaded    = false;
 
 protected:
 	bool GetDirty() { return Dirty; }
 
 	bool OnError(const char *File, int Line)
 	{
 		_lgi_assert(false, "Object Missing", File, Line);
 		return false;
 	}
 
 	// Callbacks
 	struct ThingEventInfo
 	{
 		const char *File = NULL;
 		int Line = 0;
 		std::function<void()> Callback;
 	};
 	LArray<ThingEventInfo*> OnLoadCallbacks;
 
 public:
 	struct IoProgress;
 	typedef std::function<void(IoProgress*,LStreamI*)> IoProgressCallback;
 	struct IoProgress
 	{
 		// This is the main result to look at:
 		//		Store3NotImpl - typically means the mime type is wrong.
 		//		Store3Error - an error occured.
 		//		Store3Delayed - means the operation will take a long time.
 		//			However progress is report via 'prog' if not NULL.
 		//			And the 'onComplete' handler will be called at the end.
 		//		Store3Success - the operation successfully completed.
 		Store3Status status = Store3NotImpl;
 		
 		// Optional progress for the operation. Really only relevant for
 		// status == Store3Delayed.
 		Progress *prog = NULL;
 		
 		// Optional error message for the operation. Relevant if
 		// status == Store3Error.
 		LString errMsg;
 		
 		IoProgress(Store3Status s, const char *err = NULL)
 		{
 			status = s;
 			if (err)
 				errMsg = err;
 		}
 		
 		operator bool()
 		{
 			return status > Store3Error;
 		}
 	};
 	
 	template<typename T>
 	LAutoPtr<LStreamI> AutoCast(LAutoPtr<T> ap)
 	{
 		return LAutoPtr<LStreamI>(ap.Release());
 	}
 
 	static LArray<ThingType*> DirtyThings;
 	ScribeWnd *App = NULL;
 
 	ThingType();
 	virtual ~ThingType();
 	virtual Store3ItemTypes Type() { return MAGIC_NONE; }
 	virtual bool SetDirty(bool b = true);
 	void SetWillDirty(bool c) { WillDirty = c; }
 
 	virtual bool Save(ScribeFolder *Into) { return false; }
 	virtual void OnProperties(int Tab = -1) {}
 	virtual ScribeFolder *GetFolder() = 0;
 	virtual Store3Status SetFolder(ScribeFolder *f, int Param = -1) = 0;
 	virtual bool IsPlaceHolder() { return false; }
 
 	// Events
 	void WhenLoaded(const char *file, int line, std::function<void()> Callback, int index = -1);
 	bool IsLoaded(int Set = -1);
 
 	// Printing
 	virtual void OnPrintHeaders(struct ScribePrintContext &Context) { LAssert(!"Impl me."); }
 	virtual void OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages) { LAssert(!"Impl me."); }
 	virtual int OnPrintHtml(ScribePrintContext &Context, LPrintPageRanges &Pages, LSurface *RenderedHtml) { LAssert(!"Impl me."); return 0; }
 };
 
 class MailContainerIter;
 class ScribeClass MailContainer
 {
 	friend class MailContainerIter;
 
 	List<MailContainerIter> Iters;
 
 public:
 	virtual ~MailContainer();
 
 	virtual size_t Length() { return 0; }
 	virtual ssize_t IndexOf(Mail *m) { return -1; }
 	virtual Mail *operator [](size_t i) { return NULL; }
 };
 
 class ScribeClass MailContainerIter
 {
 	friend class MailContainer;
 
 protected:
 	MailContainer *Container;
 
 public:
 	MailContainerIter();
 	~MailContainerIter();
 
 	void SetContainer(MailContainer *c);
 };
 
 class ScribeClass ThingStorage // External storage information
 {
 public:
 	int Data;
 
 	ThingStorage() { Data = 0; }
 	virtual ~ThingStorage() {}
 };
 
 class ThingUi;
 
 class ScribeClass Thing :
 	public ThingType,
 	public LListItem,
 	public LDragDropSource,
 	public LRefCount
 {
 	friend class ScribeWnd;
 	friend class ScribeFolder;
 
 	ScribeFolder *_ParentFolder = NULL;
 
 protected:
 	LArray<int> FieldArray;
 	LAutoString DropFileName;
 
 	// This structure allows the app to move objects between
 	// mail stores. After a delayed write to the new mail store
 	// the old item needs to be removed. This keeps track of
 	// where that old item is. Don't assume that the Obj pointer
 	// is valid... check in the folder's items first.
 	struct ThingReference
 	{
 		LString Path;
 		Thing *Obj;
 
 		ThingReference()
 		{
 			Obj = NULL;
 		}
 	}	DeleteOnAdd;
 
 public:
 	ThingStorage *Data = NULL;
 
 	Thing(ScribeWnd *app, LDataI *object = 0);
 	~Thing();
 
 	// Dom
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// D'n'd
 	bool GetData(LArray<LDragData> &Data) override;
 	bool GetFormats(LDragFormats &Formats) override;
 	bool OnBeginDrag(LMouse &m) override;
 
 	// Import / Export
 	virtual bool GetFormats(bool Export, LString::Array &MimeTypes) { return false; }
 
 	// Anything implementing 2 functions should mostly be using one of these 
 	// to "return" an IoProgress and process any callback:
 	//		IoProgressError(msg)
 	//		IoProgressNotImpl()
 	//		IoProgressSuccess()
 	virtual IoProgress Import(IoProgressFnArgs) = 0;
 	virtual IoProgress Export(IoProgressFnArgs) = 0;
 	
 	/// This exports all the selected items
 	void ExportAll(LViewI *Parent, const char *ExportMimeType, std::function<void(bool)> Callback);
 
 	// UI
 	bool OnKey(LKey &k) override;
 
 	// Thing
 	ScribeFolder *GetFolder() override { return _ParentFolder; }
 	void SetParentFolder(ScribeFolder *f);
 	Store3Status SetFolder(ScribeFolder *f, int Param = -1) override;
 	LDataI *DefaultObject(LDataI *arg = 0);
 
 	virtual ThingUi *DoUI(MailContainer *c = 0) { return NULL; }
 	virtual ThingUi *GetUI() { return 0; }
 	virtual bool SetUI(ThingUi *ui = 0) { return false; }
 
 	virtual uint32_t GetFlags() { return 0; }
 	virtual void OnCreate() override;
 	virtual bool OnDelete();
 	virtual int *GetDefaultFields() { return 0; }
 	virtual const char *GetFieldText(int Field) { return 0; }
 	virtual void DoContextMenu(LMouse &m, LView *Parent = 0) {}
 	virtual Thing &operator =(Thing &c) { LAssert(0); return *this; }
 	virtual char *GetDropFileName() = 0;
 	virtual bool GetDropFiles(LString::Array &Files) { return false; }
 	virtual void OnSerialize(bool Write) {}
 
 	// Interfaces
 	virtual Mail *IsMail() { return 0; }
 	virtual Contact *IsContact() { return 0; }
 	virtual ContactGroup *IsGroup() { return 0; }
 	virtual Filter *IsFilter() { return 0; }
 	virtual Attachment *IsAttachment() { return 0; }
 	virtual Calendar *IsCalendar() { return 0; }
 
 	void SetFieldArray(LArray<int> &i) { FieldArray = i; }
 	void OnMove();
 
 	bool SetField(int Field, int n);
 	bool SetField(int Field, double n);
 	bool SetField(int Field, char *n);
 	bool SetField(int Field, LDateTime &n);
 	bool GetField(int Field, int &n);
 	bool GetField(int Field, double &n);
 	bool GetField(int Field, const char *&n);
 	bool GetField(int Field, LDateTime &n);
 	bool DeleteField(int Field);
 };
 
 class ThingUi : public LWindow
 {
 	friend class MailUiGpg;
 
 	bool _Dirty;
 	char *_Name;
 
 protected:
 	Thing *_Item;
 	bool _Running;
 	void SetItem(Thing *i) { _Item = i; }
 
 public:
 	ScribeWnd *App;
 	static LArray<ThingUi*> All;
 
 	ThingUi(Thing *item, const char *name);
 	~ThingUi();
 
 	virtual bool SetDirty(bool d, bool ui = true);
 	bool IsDirty() { return _Dirty; }
 	bool OnRequestClose(bool OsShuttingDown);
 	bool OnViewKey(LView *v, LKey &k);
 
 	virtual void OnDirty(bool Dirty) {}
 	virtual void OnLoad() = 0;
 	virtual void OnSave() = 0;
 	virtual void OnChange() {}
 	virtual AttachmentList *GetAttachments() { return 0; }
 	virtual bool AddRecipient(AddressDescriptor *Addr) { return false; }
 };
 
 class ThingFilter
 {
 public:
 	virtual bool TestThing(Thing *Thing) = 0;
 };
 
 class ScribeClass Attachment : public Thing
 {
 	friend class Mail;
 
 protected:
 	Mail *Msg;
 	Mail *Owner;
 	bool IsResizing;
 	LString Buf;
 
 	// D'n'd
 	LAutoString DropSourceFile;
 	bool GetFormats(LDragFormats &Formats) override;
 	bool GetData(LArray<LDragData> &Data) override;
 
 	void _New(LDataI *object);
 
 public:
 	enum Encoding
 	{
 		OCTET_STREAM,
 		PLAIN_TEXT,
 		BASE64,
 		QUOTED_PRINTABLE,
 	};	
 	
 	Attachment(ScribeWnd *App, Attachment *import = 0);
 	Attachment(ScribeWnd *App, LDataI *object, const char *import = 0);
 	~Attachment();
 
 	bool ImportFile(const char *FileName);
 	bool ImportStream(const char *FileName, const char *MimeType, LAutoStreamI Stream);
 
 	Thing &operator =(Thing &c) override;
 
 	LDATA_INT64_PROP(Size, FIELD_SIZE);
 	LDATA_STR_PROP(Name, FIELD_NAME);
 	LDATA_STR_PROP(MimeType, FIELD_MIME_TYPE);
 	LDATA_STR_PROP(ContentId, FIELD_CONTENT_ID);
 	LDATA_STR_PROP(Charset, FIELD_CHARSET);
 	LDATA_STR_PROP(InternetHeaders, FIELD_INTERNET_HEADER);
 
 	// LDom support
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *Ret, LArray<LVariant*> &Args) override;
 
 	void OnOpen(LView *Parent, char *Dest = 0);
 	void OnDeleteAttachment(LView *Parent, bool Ask);
 	void OnSaveAs(LView *Parent);
 	void OnMouseClick(LMouse &m) override;
 	bool OnKey(LKey &k) override;
 
 	Store3ItemTypes Type() override { return MAGIC_ATTACHMENT; }
 	bool Get(char **ptr, ssize_t *size);
 	bool Set(char *ptr, ssize_t size);
 	bool Set(LAutoStreamI Stream);
 	Attachment *IsAttachment() override { return this; }
 	LAutoString MakeFileName();
 	bool GetIsResizing();
 	void SetIsResizing(bool b);
 	bool IsMailMessage();
 	bool IsVCalendar();
 	bool IsVCard();
 
 	// The owner is the mail that this is attached to
 	Mail *GetOwner() { return Owner; }
 	void SetOwner(Mail *msg);
 
 	// The msg is the mail that this message/rfc822 attachment is rendered into
 	Mail *GetMsg();
 	void SetMsg(Mail *m);
 
 	LStreamI *GotoObject(const char *file, int line);
 	int Sizeof();
 	bool Serialize(LFile &f, bool Write);
 	IoProgress Import(IoProgressFnArgs) override { return Store3Error; }
 	IoProgress Export(IoProgressFnArgs) override { return Store3Error; }
 
 	bool SaveTo(char *FileName, bool Quite = false, LView *Parent = 0);
 
 	const char *GetText(int i) override;
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 };
 
 class ScribeClass Contact :
 	public Thing
 {
 	friend class ContactUi;
 
 protected:
 	class ContactPriv *d = NULL;
 	ContactUi *Ui = NULL;
 
 public:
 	static List<Contact> Everyone;
 	static Contact *LookupEmail(const char *Email);
 	static LHashTbl<ConstStrKey<char,false>, int> PropMap;
 	static int DefaultContactFields[];
 
 	Contact(ScribeWnd *app, LDataI *object = 0);
 	~Contact();
 
 	LDATA_STR_PROP(First, FIELD_FIRST_NAME);
 	LDATA_STR_PROP(Last, FIELD_LAST_NAME);
 	LDATA_STR_PROP(Email, FIELD_EMAIL);
 
 	bool Get(const char *Opt, const char *&Value);
 	bool Set(const char *Opt, const char *Value);
 	bool Get(const char *Opt, int &Value);
 	bool Set(const char *Opt, int Value);
 
 	// operators
 	Thing &operator =(Thing &c) override;
 	Contact *IsContact() override { return this; }
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = 0) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = 0) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Events
 	void OnMouseClick(LMouse &m) override;
 
 	// Printing
 	void OnPrintHeaders(struct ScribePrintContext &Context) override;
 	void OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages) override;
 
 	// Misc
 	Store3ItemTypes Type() override { return MAGIC_CONTACT; }
 	ThingUi *DoUI(MailContainer *c = 0) override;
 	int Compare(LListItem *Arg, ssize_t Field) override;
 	bool IsAssociatedWith(char *PluginName);
 	char *GetLocalTime(const char *TimeZone = 0);
 	
 	// Email address
 	int GetAddrCount();
 	LString::Array GetEmails();
 	LString GetAddrAt(int i);
 	bool HasEmail(LString email);
 
 	// Serialization
 	size_t SizeofField(const char *Name);
 	size_t Sizeof();
 	bool Serialize(LFile &f, bool Write);
 	bool Save(ScribeFolder *Into = 0) override;
 
 	// ListItem
 	const char *GetText(int i) override;
 	int *GetDefaultFields() override;
 	const char *GetFieldText(int Field) override;
 	int GetImage(int Flags = 0) override { return ICON_CONTACT; }
 
 	// Import/Export
 	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
 	IoProgress Import(IoProgressFnArgs) override;
 	IoProgress Export(IoProgressFnArgs) override;
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 };
 
+#define ContactGroupObj					"ContactGroup"
 #define ContactGroupName				"Name"
 #define ContactGroupList				"List"
 #define ContactGroupDateModified		"DateModified"
 extern ItemFieldDef GroupFieldDefs[];
 
 class ContactGroup : public Thing
 {
 	friend class GroupUi;
 	class GroupUi *Ui;
 	class ContactGroupPrivate *d;
 	LString DateCache;
 
 public:
 	LDateTime UsedTs;
 
 	LDATA_STR_PROP(Name, FIELD_GROUP_NAME);	
 
 	ContactGroup(ScribeWnd *app, LDataI *object = 0);
 	~ContactGroup();
 
 	// operators
 	Thing &operator =(Thing &c) override;
 	ContactGroup *IsGroup() override { return this; }
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Events
 	void OnMouseClick(LMouse &m) override;
 	void OnSerialize(bool Write) override;
 
 	// Misc
 	Store3ItemTypes Type() override { return MAGIC_GROUP; }
 	ThingUi *DoUI(MailContainer *c = 0) override;
 	int Compare(LListItem *Arg, ssize_t Field) override;
-	IoProgress Import(IoProgressFnArgs) override { return Store3NotImpl; }
-	IoProgress Export(IoProgressFnArgs) override { return Store3NotImpl; }
 	bool GetAddresses(List<char> &a);
 	LString::Array GetAddresses();
-	char *GetDropFileName() override;
-	bool GetDropFiles(LString::Array &Files) override;
 
 	// Serialization
 	bool Save(ScribeFolder *Into = 0) override;
 
 	// ListItem
 	const char *GetText(int i) override;
 	int *GetDefaultFields() override;
 	const char *GetFieldText(int Field) override;
 	int GetImage(int Flags = 0) override { return ICON_CONTACT_GROUP; }
+
+	// Import / Export
+	char *GetDropFileName() override;
+	bool GetDropFiles(LString::Array &Files) override;
+	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
+	IoProgress Import(IoProgressFnArgs) override;
+	IoProgress Export(IoProgressFnArgs) override;
 };
 
 struct LGroupMapArray : public LArray<ContactGroup*>
 {
 	LString toString()
 	{
 		LString::Array a;
 		for (auto i: *this)
 			a.Add(i->GetName());
 		return LString(",").Join(a);
 	}
 };
 
 class LGroupMap : public LHashTbl<ConstStrKey<char,false>,LGroupMapArray*>
 {
 	ScribeWnd *App;
 
 	void Index(ContactGroup *grp);
 
 public:
 	LGroupMap(ScribeWnd *app);
 	~LGroupMap();
 };
 
 
 /////////////////////////////////////////////////////////////
 // Mail threading
 //
 //    See: http://www.jwz.org/doc/threading.html
 struct ThingSortParams
 {
 	int SortAscend;
 	int SortField;
 };
 
 class MContainer
 {
 	int			Lines;
 	int			Depth;
 	bool		Open;
 	bool		Next;
 
 	void Dump(LStream &s, int Depth = 0);
 
 public:
     typedef LHashTbl<StrKey<char>, MContainer*> ContainerHash;
 
 	// Container data
 	Mail		*Message;
 	MContainer	*Parent;
 	LArray<MContainer*> Children;
 	List<MContainer> Refs;
 	int			Index;
 
 	// Cache data
 	List<char> RefCache;
 	
 	// Debug
 	#ifdef _DEBUG
 	LAutoString MsgId;
 	#endif
 
 	// Methods
 	MContainer(const char *Id, Mail *m = 0);
 	~MContainer();
 
 	void SetMail(Mail *m);
 	Mail *GetTop();
 
 	bool HasChild(MContainer *m);
 	void AddChild(MContainer *m);
 	void RemoveChild(MContainer *m);
 	int CountMessages();
 	
 	void Pour(int &index, int depth, int tree, bool next, ThingSortParams *folder);
 	void OnPaint(LSurface *pDC, LRect &r, LItemColumn *c, LColour Fore, LColour Back, LFont *Font, const char *Txt);
 
 	static void Prune(int &ParentIndex, LArray<MContainer*> &L);
 	static void Thread(List<Mail> &In, LArray<MContainer*> &Out);
 };
 
 extern int ListItemCompare(LListItem *a, LListItem *b, NativeInt Data);
 extern int ContainerIndexer(Thing *a, Thing *b, NativeInt Data);
 extern const char *Store3ItemTypeName(Store3ItemTypes t);
 extern int GetFolderVersion(const char *Path);
 extern bool CreateMailHeaders(ScribeWnd *App, LStream &Out, LDataI *Mail, MailProtocol *Protocol);
 
 ////////////////////////////////////////////////////////////
 // Thing sorting
 
 // The old way
 extern int ContainerCompare(MContainer **a, MContainer **b);
 extern int ThingCompare(Thing *a, Thing *b, NativeInt Data);
 
 // The new way
 extern int ContainerSorter(MContainer *&a, MContainer *&b, ThingSortParams *Params);
 extern int ThingSorter(Thing *a, Thing *b, ThingSortParams *Data);
 
 /////////////////////////////////////////////////////////////
 class MailViewOwner : public LCapabilityTarget
 {
 public:
     virtual LDocView *GetDoc(const char *MimeType) = 0;
     virtual bool SetDoc(LDocView *v, const char *MimeType) = 0;
 };
 
 /////////////////////////////////////////////////////////////
 // The core mail object
 struct MailPrintContext;
 
 class ScribeClass Mail :
 	public Thing,
 	public MailContainer,
 	public LDefaultDocumentEnv
 {
 	friend class MailUi;
 	friend class MailPropDlg;
 	friend class ScribeFolder;
 	friend class Attachment;
 	friend class ScribeWnd;
 
 private:
 	class MailPrivate *d;
 	static LHashTbl<ConstStrKey<char>,Mail*> MessageIdMap;
 
 	// List item preview
 	int PreviewCacheX;
 	List<LDisplayString> PreviewCache;
 	
 	int64_t TotalSizeCache;
 	int64_t FlagsCache;
 	MailUi *Ui;
 	int Cursor; // Stores the cursor position in reply/forward format until the UI needs it
 	Attachment *ParentFile;
 	List<Attachment> Attachments;
 	Mail *PreviousMail; // the mail we are replying to / forwarding
 
 	void _New();
 	void _Delete();
 	bool _GetListItems(List<LListItem> &l, bool All); // All=false is just the selected items
 	void SetListRead(bool Read);
 	void SetFlagsCache(int64_t NewFlags, bool IgnoreReceipt, bool UpdateScreen);
 
 	// LDocumentEnv impl
 	List<Filter> Actions;
 	bool OnNavigate(LDocView *Parent, const char *Uri) override;
 	bool AppendItems(LSubMenu *Menu, const char *Param, int Base = 1000) override;
 	bool OnMenu(LDocView *View, int Id, void *Context) override;
 	LoadType GetContent(LoadJob *&j) override;
 
 public:
 	static bool PreviewLines;
 	static bool AdjustDateTz;
 	static int DefaultMailFields[];
 	static bool RunMailPipes;
 	static List<Mail> NewMailLst;
 	constexpr static float MarkColourMix = 0.9f;
 
 	uint8_t SendAttempts;
 	
 	enum NewEmailState
 	{
 		NewEmailNone,
 		NewEmailLoading,
 		NewEmailFilter,
 		NewEmailBayes,
 		NewEmailGrowl,
 		NewEmailTray
 	};
 	
 	NewEmailState NewEmail;
 
 	Mail(ScribeWnd *app, LDataI *object = 0);
 	~Mail();
 
 	bool SetObject(LDataI *o, bool InDataDestuctor, const char *File, int Line) override;
 
 	LDATA_STR_PROP(Label, FIELD_LABEL);
 	LDATA_STR_PROP(FwdMsgId, FIELD_FWD_MSG_ID);
 	LDATA_STR_PROP(BounceMsgId, FIELD_BOUNCE_MSG_ID);
 	LDATA_STR_PROP(Subject, FIELD_SUBJECT);
 	LDATA_STR_PROP(Body, FIELD_TEXT);
 	LDATA_STR_PROP(BodyCharset, FIELD_CHARSET);
 	LDATA_STR_PROP(Html, FIELD_ALTERNATE_HTML);
 	LDATA_STR_PROP(HtmlCharset, FIELD_HTML_CHARSET);
 	LDATA_STR_PROP(InternetHeader, FIELD_INTERNET_HEADER);
 	LDATA_INT_TYPE_PROP(EmailPriority, Priority, FIELD_PRIORITY, MAIL_PRIORITY_NORMAL);
 	LDATA_INT32_PROP(AccountId, FIELD_ACCOUNT_ID);
 	LDATA_INT64_PROP(MarkColour, FIELD_COLOUR);
 	LDATA_STR_PROP(References, FIELD_REFERENCES);
 	LDATA_DATE_PROP(DateReceived, FIELD_DATE_RECEIVED);
 	LDATA_DATE_PROP(DateSent, FIELD_DATE_SENT);
 	LDATA_INT_TYPE_PROP(Store3State, Loaded, FIELD_LOADED, Store3Loaded);
 	LVariant GetServerUid();
 	bool SetServerUid(LVariant &v);
 
 	const char *GetFromStr(int id)
 	{
 		LDataPropI *From = GetObject() ? GetObject()->GetObj(FIELD_FROM) : 0;
 		return From ? From->GetStr(id) : NULL;
 	}
 
 	LDataPropI *GetFrom()
 	{
 		return GetObject() ? GetObject()->GetObj(FIELD_FROM) : 0;
 	}
 
 	LDataPropI *GetReply()
 	{
 		return GetObject() ? GetObject()->GetObj(FIELD_REPLY) : 0;
 	}
 
 	GDataIt GetTo()
 	{
 		return GetObject() ? GetObject()->GetList(FIELD_TO) : 0;
 	}
 
 	bool GetAttachmentObjs(LArray<LDataI*> &Objs);
 	LDataI *GetFileAttachPoint();
 
 	// Operators
 	Mail *IsMail() override { return this; }
 	Thing &operator =(Thing &c) override;
 	OsView Handle();
 	ThingUi *GetUI() override;
 	bool SetUI(ThingUi *ui) override;
 
 	// References and ID's
 	MContainer *Container;
 	const char *GetMessageId(bool Create = false);
 	bool SetMessageId(const char *val);
 	LAutoString GetThreadIndex(int TruncateChars = 0);
 	
 	static Mail *GetMailFromId(const char *Id);
 	bool MailMessageIdMap(bool Add = true);
 	bool GetReferences(List<char> &Ids);
 	void GetThread(List<Mail> &Thread);
 	LString GetMailRef();
 	bool ResizeImage(Attachment *a);
 
 	// MailContainer
 	size_t Length() override;
 	ssize_t IndexOf(Mail *m) override;
 	Mail *operator [](size_t i) override;
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Events
 	void OnCreate() override;
 	bool OnBeforeSend(struct ScribeEnvelope *Out);
 	void OnAfterSend();
 	bool OnBeforeReceive();
 	bool OnAfterReceive(LStreamI *Msg);
 	void OnMouseClick(LMouse &m) override;
 	void OnProperties(int Tab = -1) override;
 	void OnInspect();
 	void OnReply(Mail *m, bool All, bool MarkOriginal);
 	bool OnForward(Mail *m, bool MarkOriginal, int WithAttachments = -1);
 	bool OnBounce(Mail *m, bool MarkOriginal, int WithAttachments = -1);
 	void OnReceipt(Mail *m);
 	int OnNotify(LViewI *Ctrl, LNotification n) override;
 
 	// Printing
 	void OnPrintHeaders(ScribePrintContext &Context) override;
 	void OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages) override;
 	int OnPrintHtml(ScribePrintContext &Context, LPrintPageRanges &Pages, LSurface *RenderedHtml) override;
 
 	// Misc	
 	uint32_t GetFlags() override;
 	void SetFlags(ulong i, bool IgnoreReceipt = false, bool Update = true);
 	void DeleteAsSpam(LView *View);
 	const char *GetFieldText(int Field) override;
 	LAutoString GetCharSet();
 	char *GetNewText(int Max = 64 << 10, const char *AsCp = "utf-8");
 	int *GetDefaultFields() override;
 	Store3ItemTypes Type() override { return MAGIC_MAIL; }
 	void DoContextMenu(LMouse &m, LView *Parent = 0) override;
 	int Compare(LListItem *Arg, ssize_t Field) override;
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 	LAutoString GetSig(bool HtmlVersion, ScribeAccount *Account = 0);
 	bool LoadFromFile(char *File);
 	void PrepSend();
 	void NewRecipient(char *Email, char *Name = 0);
 	void ClearCachedItems();
 	bool Send(bool Now);
 	void CreateMailHeaders();
 	bool AddCalendarEvent(LViewI *Parent, bool AddPopupReminder, LString *Msg);
 	LArray<Attachment*> GetCalendarAttachments();
 
 	// UI
 	LDocView *CreateView(MailViewOwner *Owner, LString MimeType, bool Sunken, size_t MaxBytes, bool NoEdit = false);
 	ThingUi *DoUI(MailContainer *c = 0) override;
 
 	// Alt HTML
 	bool HasAlternateHtml(Attachment **Attach = 0);
 	char *GetAlternateHtml(List<Attachment> *Refs = 0); // dynamically allocated ptr
 	bool WriteAlternateHtml(char *File = NULL, int FileLen = 0); // defaults to TEMP dir
 
 	// Account stuff
 	void ProcessTextForResponse(Mail *From, LOptionsFile *Options, ScribeAccount *Account);
 	void WrapAndQuote(LStringPipe &Pipe, const char *QuoteStr, int WrapAt = -1);
 	ScribeAccount *GetAccountSentTo();
 
 	// Access
 	int64 TotalSizeof();
 	bool Save(ScribeFolder *Into = 0) override;
 	
 	// Attachments
 	Attachment *AttachFile(LView *Parent, const char *FileName);
 	bool AttachFile(Attachment *File);
 	bool DeleteAttachment(Attachment *File);
 	bool GetAttachments(List<Attachment> *Attachments);
 	bool HasAttachments() { return Attachments.Length() > 0; }
 	bool UnloadAttachments();
 
 	// Import / Export
 	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
 	IoProgress Import(IoProgressFnArgs) override;
 	IoProgress Export(IoProgressFnArgs) override;
 
 	// ListItem
 	void Update() override;
 	const char *GetText(int i) override;
 	int GetImage(int SelFlags = 0) override;
 	void OnMeasure(LPoint *Info) override;
 	void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c) override;
 	void OnPaint(LItem::ItemPaintCtx &Ctx) override;
 };
 
 inline const char *toString(Mail::NewEmailState s)
 {
 	#define _(s) case Mail::s: return #s;
 	switch (s)
 	{
 		_(NewEmailNone)
 		_(NewEmailLoading)
 		_(NewEmailFilter)
 		_(NewEmailBayes)
 		_(NewEmailGrowl)
 		_(NewEmailTray)
 	}
 	#undef _
 	LAssert(0);
 	return "#invalidNewEmailState";
 }
 
 // this is where the items reside
 // and it forms a leaf on the mail box tree
 // to the user it looks like a folder
 class ScribeClass ScribeFolder :
 	public ThingType,
 	public LTreeItem,
 	public LDragDropSource,
 	public MailContainer
 {
 	friend class MailTree;
 	friend class FolderPropertiesDlg;
 	friend class ThingList;
 	friend class ScribeWnd;
 
 protected:
 	class ScribeFolderPriv *d;
 	ThingList *View();
 	LString DropFileName;
 
 	LString GetDropFileName();
 
 	// UI cache
 	LAutoString NameCache;
 	int ChildUnRead = 0;
 	LTreeItem *LoadOnDemand = NULL;
 	LAutoPtr<LListItem> Loading;
 
 	LArray<int> FieldArray;
 	void SerializeFieldWidths(bool Write = false);
 	void EmptyFieldList();
 	void SetLoadFolder(Thing *t) { if (t) t->SetParentFolder(this); }
 	bool HasFieldId(int Id);
 
 	// Tree item stuff
 	void _PourText(LPoint &Size) override;
 	void _PaintText(LItem::ItemPaintCtx &Ctx) override;
 	int _UnreadChildren();
 
 	void UpdateOsUnread();
 
 	// Debugging state
 	enum FolderState
 	{
 		FldState_Idle,
 		FldState_Loading,
 		FldState_Populating,
 	}	CurState = FldState_Idle;
 
 public:
 	List<Thing> Items;
 
 	ScribeFolder();
 	~ScribeFolder();
 
 	// Object
 	LArray<int> &GetFieldArray() { return FieldArray; }
 	LDataFolderI *GetFldObj() { return dynamic_cast<LDataFolderI*>(GetObject()); }
 	bool SetObject(LDataI *o, bool InDataDestuctor, const char *File, int Line) override;
 
 	// ThingType
 	Store3ItemTypes Type() override { return GetObject() ? (Store3ItemTypes)GetObject()->Type() : MAGIC_NONE; }
 	ScribeFolder *GetFolder() override { return dynamic_cast<ScribeFolder*>(LTreeItem::GetParent()); }
 	ScribeFolder *GetChildFolder() { return dynamic_cast<ScribeFolder*>(LTreeItem::GetChild()); }
 	ScribeFolder *GetNextFolder() { return dynamic_cast<ScribeFolder*>(LTreeItem::GetNext()); }
 	Store3Status SetFolder(ScribeFolder *f, int Param = -1) override;
 	ScribeFolder *IsFolder() { return this; }
 	Store3Status CopyTo(ScribeFolder *NewParent, int NewIndex = -1);
 
 	// MailContainer
 	size_t Length() override;
 	ssize_t IndexOf(Mail *m) override;
 	Mail *operator [](size_t i) override;
 
 	/// Update the unread count
 	void OnUpdateUnRead
 	(
 		/// Increments the count, or zero if a child folder is changing.
 		int Offset,
 		/// Re-scan the folder
 		bool ScanItems
 	);							
 
 	// Methods
 	LDATA_INT32_PROP(UnRead, FIELD_UNREAD);
 	LDATA_INT_TYPE_PROP(Store3ItemTypes, ItemType, FIELD_FOLDER_TYPE, MAGIC_MAIL);
 	LDATA_INT32_PROP(Open, FIELD_FOLDER_OPEN);
 	LDATA_INT32_PROP(SortIndex, FIELD_FOLDER_INDEX);
 	LDATA_INT64_PROP(Items, FIELD_FOLDER_ITEMS); // Cached item count
 	LDATA_INT_TYPE_PROP(ScribePerm, ReadAccess, FIELD_FOLDER_PERM_READ, PermRequireNone);
 	LDATA_INT_TYPE_PROP(ScribePerm, WriteAccess, FIELD_FOLDER_PERM_WRITE, PermRequireNone);
 	LDATA_ENUM_PROP(SystemFolderType, FIELD_SYSTEM_FOLDER, Store3SystemFolder);
 
 	void SetSort(int Col, bool Ascend, bool CanDirty = true);
 	int GetSortAscend() { return GetObject()->GetInt(FIELD_SORT) > 0; }
 	int GetSortCol() { return abs((int)GetObject()->GetInt(FIELD_SORT)) - 1; }
 	int GetSortField();
 	void ReSort();
 	bool Save(ScribeFolder *Into = 0) override;
 	bool ReindexField(int OldIndex, int NewIndex);
 	void CollectSubFolderMail(ScribeFolder *To = 0);
 	bool InsertThing(Thing *Item);
 	bool MoveTo(LArray<Thing*> &Items, bool CopyOnly = false, LArray<Store3Status> *Status = NULL);
 	bool Delete(LArray<Thing*> &Items, bool ToTrash);
 	void SetDefaultFields(bool Force = false);
 	bool Thread();
 	ScribePerm GetFolderPerms(ScribeAccessType Access); 
 	void SetFolderPerms(LView *Parent, ScribeAccessType Access, ScribePerm Perm, std::function<void(bool)> Callback); 
 	bool GetThreaded();
 	void SetThreaded(bool t);
 	// void Update();
 	void GetMessageById(const char *Id, std::function<void(Mail*)> Callback);
 	void SetLoadOnDemand();
 	void SortSubfolders();
 	void DoContextMenu(LMouse &m);
 	void OnItemType();
 	bool IsInTrash();
 	bool SortItems();
 	
 	// Virtuals:
 		/// 
 		/// These methods can be used in a synchronous or asynchronous manner:
 		///		sync:	Call with 'Callback=NULL' and use the return value.
 		///				If the function needs to show a dialog (like to get permissions from
 		///				the user) then it'll return Store3Delayed immediately.
 		///		async:	Call with a valid callback, and the method will possibly wait 
 		///				for the user and then either return Store3Error or Store3Success.
 		virtual Store3Status LoadThings(LViewI *Parent = NULL,	std::function<void(Store3Status)> Callback = NULL);
 		virtual Store3Status WriteThing(Thing *t,				std::function<void(Store3Status)> Callback = NULL);
 		virtual Store3Status DeleteThing(Thing *t,				std::function<void(Store3Status)> Callback = NULL);
 		virtual Store3Status DeleteAllThings(					std::function<void(Store3Status)> Callback = NULL);
 		virtual bool LoadFolders();
 		virtual bool UnloadThings();
 		virtual bool IsWriteable() { return true; }
 		virtual bool IsPublicFolders() { return false; }
 
 		virtual void OnProperties(int Tab = -1) override;
 		virtual ScribeFolder *CreateSubDirectory(const char *Name, int Type);
 		virtual void OnRename(char *NewName);
 		virtual void OnDelete();
 		virtual LString GetPath();
 		virtual ScribeFolder *GetSubFolder(const char *Path);
 		virtual void Populate(ThingList *List);
 		virtual bool CanHaveSubFolders(Store3ItemTypes Type = MAGIC_MAIL) { return GetItemType() != MAGIC_ANY; }
 		virtual void OnRethread();
 
 	// Name
 	void SetName(const char *Name, bool Encode);
 	LString GetName(bool Decode);
 
 	// Serialization
 	int Sizeof();
 	bool Serialize(LFile &f, bool Write);
 
 	// Tree Item
 	const char *GetText(int i=0) override;
 	int GetImage(int Flags = 0) override;
 	void OnExpand(bool b) override;
 	bool OnKey(LKey &k) override;
 	void Update() override;
 
 	// Drag'n'drop
 	bool GetFormats(LDragFormats &Formats) override;
 	bool OnBeginDrag(LMouse &m) override;
 	void OnEndData() override;
 	bool GetData(LArray<LDragData> &Data) override;
 	void OnReceiveFiles(LArray<const char*> &Files);
 
 	// Import/Export
 	bool GetFormats(bool Export, LString::Array &MimeTypes);
 	IoProgress Import(IoProgressFnArgs);
 	IoProgress Export(IoProgressFnArgs);
 	void ExportAsync(LAutoPtr<LStreamI> f, const char *MimeType, std::function<void(LProgressDlg*)> Callback = NULL);
 	const char *GetStorageMimeType();
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant *> &Args) override;
 };
 
 //////////////////////////////////////////////////////////////
 class Filter;
 
 class FilterCondition
 {
 protected:
 	bool TestData(Filter *F, LVariant &v, LStream *Log);
 
 public:
 	// Data
 	LAutoString Source; // Data Source (used to be "int Field")
 	LAutoString Value; // Constant
 	char Op;
 	uint8_t Not;
 
 	// Methods
 	FilterCondition();
 	bool Set(class LXmlTag *t);
 
 	// Test condition against email
 	bool Test(Filter *F, Mail *m, LStream *Log);
 	FilterCondition &operator =(FilterCondition &c);
 
 	// Object
 	ThingUi *DoUI(MailContainer *c = 0);
 };
 
 class FilterAction : public LListItem, public LDataPropI
 {
 	LCombo *TypeCbo;
 	LEdit *ArgEdit;
 	LButton *Btn;
 
 public:
 	// Data
 	FilterActionTypes Type;
 	LAutoString Arg1;
 
 	// Methods
 	FilterAction(LDataStoreI *Store);
 	~FilterAction();
 
 	bool Set(LXmlTag *t);
 	bool Get(LXmlTag *t);
 	bool Do(Filter *F, ScribeWnd *App, Mail *&m, LStream *log);
 	void Browse(ScribeWnd *App, LView *Parent);
 	void DescribeHtml(Filter *Flt, LStream &s);
 
 	LDataPropI &operator =(LDataPropI &p);
 
 	// List item
 	const char *GetText(int Col = 0);
 	void OnMeasure(LPoint *Info);
 	bool Select();
 	void Select(bool b);
 	void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c);
 	int OnNotify(LViewI *c, LNotification n);
 
 	// Object
 	ThingUi *DoUI(MailContainer *c = 0);
 	// bool Serialize(ObjProperties &f, bool Write);
 };
 
 class ScribeClass Filter : public Thing
 {
 	friend class FilterUi;
 	
 protected:
 	class FilterUi *Ui;
 	class FilterPrivate *d;
 	static int MaxIndex;
 
 	// Ui
 	LListItemCheckBox *ChkIncoming;
 	LListItemCheckBox *ChkOutgoing;
 	LListItemCheckBox *ChkInternal;
 	bool IgnoreCheckEvents;
 
 	// Current
 	Mail **Current;
 
 	// XML I/O
 	LAutoPtr<LXmlTag> ConditionsCache;
 	LAutoPtr<LXmlTag> Parse(bool Actions);
 
 	// Methods
 	bool EvaluateTree(LXmlTag *n, Mail *m, bool &Stop, LStream *Log);
 	bool EvaluateXml(Mail *m, bool &Stop, LStream *Log);
 
 public:
 	Filter(ScribeWnd *app, LDataI *object = 0);
 	~Filter();
 
 	LDATA_STR_PROP(Name, FIELD_FILTER_NAME);
 	LDATA_STR_PROP(ConditionsXml, FIELD_FILTER_CONDITIONS_XML);
 	LDATA_STR_PROP(ActionsXml, FIELD_FILTER_ACTIONS_XML);
 	LDATA_STR_PROP(Script, FIELD_FILTER_SCRIPT);
 	LDATA_INT32_PROP(Index, FIELD_FILTER_INDEX);
 	LDATA_INT32_PROP(StopFiltering, FIELD_STOP_FILTERING);
 	LDATA_INT32_PROP(Incoming, FIELD_FILTER_INCOMING);
 	LDATA_INT32_PROP(Outgoing, FIELD_FILTER_OUTGOING);
 	LDATA_INT32_PROP(Internal, FIELD_FILTER_INTERNAL);
 
 	int Compare(LListItem *Arg, ssize_t Field) override;
 	Thing &operator =(Thing &c) override;
 	Filter *IsFilter() override { return this; }
 	static void Reindex(ScribeFolder *Folder);
 	int *GetDefaultFields() override;
 	const char *GetFieldText(int Field) override;
 
 	// Methods
 	void Empty();
 	LAutoString DescribeHtml();
 
 	// Import / Export
 	char *GetDropFileName() override;
 	bool GetDropFiles(LString::Array &Files) override;
 	bool GetFormats(bool Export, LString::Array &MimeTypes) override;
 	IoProgress Import(IoProgressFnArgs) override;
 	IoProgress Export(IoProgressFnArgs) override;
 
 	// Dom
 	bool Evaluate(char *s, LVariant &v);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// Filter
 	bool Test(Mail *m, bool &Stop, LStream *Log = 0);
 	bool DoActions(Mail *&m, bool &Stop, LStream *Log = 0);
 	Mail *GetCurrent() { return Current?*Current:0; }
 	
 	/// This filters all the mail in 'Email'. Anything that is handled by a filter
 	/// is removed from the list, leaving just the unfiltered mail.
 	static int ApplyFilters
 	(
 	    /// [In] The window of the filtering caller
 	    LView *Parent,
 	    /// [In] List of all the filter to test and/or apply
 	    List<Filter> &Filters,
 	    /// [In/Out] The email to filter. After the call anything that has been
 	    /// acted on by a filter will be removed from the list.
 	    List<Mail> &Email
 	);
 
 	// Object
 	Store3ItemTypes Type() override { return MAGIC_FILTER; }
 	ThingUi *DoUI(MailContainer *c = 0) override;
 	bool Serialize(LFile &f, bool Write);
 	bool Save(ScribeFolder *Into = 0) override;
 	void OnMouseClick(LMouse &m) override;
 	void AddAction(FilterAction *a);
 	
 	// List item
 	const char *GetText(int i) override;
 	int GetImage(int Flags) override;
 	void OnPaint(ItemPaintCtx &Ctx) override;
 	void OnColumnNotify(int Col, int64 Data) override;
 
 	// Index
 	Filter *GetFilterAt(int Index);
 };
 
 //////////////////////////////////////////////////////////////////////
 class Accountlet;
 
 enum AccountThreadState
 {
 	ThreadIdle,
 	ThreadSetup,
 	ThreadConnecting,
 	ThreadTransfer,
 	ThreadWaiting,
 	ThreadDeleting,
 	ThreadDone,
 	ThreadCancel,
 	ThreadError
 };
 
 enum ReceiveAction
 {
 	MailNoop,
 	MailDelete,
 	MailDownloadAndDelete,
 	MailDownload,
 	MailUpload,
 	MailHeaders,
 
 };
 
 enum ReceiveStatus
 {
 	MailReceivedNone,
 	MailReceivedWaiting,	// This has been given to the main thread
 	MailReceivedOk,			// and one of "Ok" or "Error" has to be
 	MailReceivedError,		// set to continue.
 	MailReceivedMax,
 };
 
 ScribeFunc const char *AccountThreadStateName(AccountThreadState i);
 ScribeFunc const char *ReceiveActionName(ReceiveAction i);
 ScribeFunc const char *ReceiveStatusName(ReceiveStatus i);
 
 class LScribeMime : public LMime
 {
 public:
 	LScribeMime() : LMime(ScribeTempPath())
 	{
 	}
 };
 
 class LMimeStream : public LTempStream, public LScribeMime
 {
 public:
 	LMimeStream();
 	bool Parse();
 };
 
 class MailTransferEvent
 {
 public:
 	// Message
 	LAutoPtr<LStreamI> Rfc822Msg;
 	ReceiveAction Action = MailNoop;
 	ReceiveStatus Status = MailReceivedNone;
 	int Index = 0;
 	bool Explicit = false;
 	LString Uid;
 	int64 Size = 0;
 	int64 StartWait = 0;
 	
 	// Header Listing
 	class AccountMessage *Msg = NULL;
 	LList *GetList();
 
 	// Sending
 	ScribeEnvelope *Send = NULL;
 	LString OutgoingHeaders;
 
 	// Other
 	class Accountlet *Account = NULL;
 
 	MailTransferEvent()
 	{
 	}
 
 	~MailTransferEvent()
 	{
 		#ifndef LGI_STATIC
 		// LStackTrace("%p::~MailTransferEvent\n", this);
 		#endif
 	}
 };
 
 #define RoProp(Type, Name)					\
 	protected:								\
 		Type Name;							\
 	public:									\
 		Type Get##Name() { return Name; }
 
 class AccountThread : public LThread, public LCancel
 {
 protected:
 	Accountlet *Acc;
 	void OnAfterMain();
 
 public:
 	// Object
 	AccountThread(Accountlet *acc);
 	~AccountThread();
 
 	// Api
 	Accountlet *GetAccountlet() { return Acc; }
 	
 	// 1st phase
 	virtual void Disconnect();
 
 	// 2nd phase
 	virtual bool Kill();
 };
 
 #define AccStrOption(func, opt) \
 	LVariant func(const char *Set = 0) { LVariant v; StrOption(opt, v, Set); return v; }
 
 #define AccIntOption(name, opt) \
 	int name(int Set = -1) { LVariant v; IntOption(opt, v, Set); return v.CastInt32(); }
 
 class ScribeClass Accountlet : public LStream
 {
 	friend class ScribeAccount;
 	friend class AccountletThread;
 	friend class AccountThread;
 
 public:
 	struct AccountletPriv
 	{
 		LArray<LogEntry*> Log;
 	};
 
 	class AccountletLock
 	{
 		LMutex *l;
 
 	public:
 		bool Locked;
 		AccountletPriv *d;
 
 		AccountletLock(AccountletPriv *data, LMutex *lck, const char *file, int line)
 		{
 			d = data;
 			l = lck;
 			Locked = lck->Lock(file, line);
 		}
 
 		~AccountletLock()
 		{
 			if (Locked)
 				l->Unlock();
 		}
 	};
 
 	typedef LAutoPtr<AccountletLock> I;
 
 private:
 	AccountletPriv d;
 	LMutex PrivLock;
 
 protected:
 	// Data
 	ScribeAccount *Account;
 	LAutoPtr<AccountThread> Thread;
 	bool ConnectionStatus;
 	MailProtocol *Client;
 	uint64 LastOnline;
 	LString TempPsw;
 	bool Quiet;
 	LView *Parent;
 
 	// Pointers
 	ScribeFolder *Root;
 	LDataStoreI *DataStore;
 	LMailStore *MailStore; // this memory is owned by ScribeWnd
 
 	// Options
 	const char *OptPassword;
 
 	// Members
 	LSocketI *CreateSocket(bool Sending, LCapabilityClient *Caps, bool RawLFCheck);
 	bool WaitForTransfers(List<MailTransferEvent> &Files);
 
 	void StrOption(const char *Opt, LVariant &v, const char *Set);
 	void IntOption(const char *Opt, LVariant &v, int Set);
 
 	// LStringPipe Line;
 	ssize_t Write(const void *buf, ssize_t size, int flags);
 
 public:
 	MailProtocolProgress Group;
 	MailProtocolProgress Item;
 
 	Accountlet(ScribeAccount *a);
 	~Accountlet();
 
 	Accountlet &operator =(const Accountlet &a)
 	{
 		LAssert(0);
 		return *this;
 	}
 
 	I Lock(const char *File, int Line)
 	{
 		I a(new AccountletLock(&d, &PrivLock, File, Line));
 		if (!a->Locked)
 			a.Reset();
 		return a;
 	}
 
 	// Methods
 	bool			Connect(LView *Parent, bool Quiet);
 	bool			Lock();
 	void			Unlock();
 	virtual bool	IsConfigured() 	{ return false; }
 	bool			GetStatus()		{ return ConnectionStatus; }
 	uint64			GetLastOnline()	{ return LastOnline; }
 	ScribeAccount*	GetAccount() 	{ return Account; }
 	bool			IsCancelled();
 	void			IsCancelled(bool b);
 	ScribeWnd*		GetApp();
 	const char*		GetStateName();
 	ScribeFolder* GetRootFolder() { return Root; }
 	RoProp(AccountThreadState, State);
 
 	bool IsOnline()
 	{
 		if (DataStore)
 			return DataStore->GetInt(FIELD_IS_ONLINE) != 0;
 		
 		return Thread != 0;
 	}
 
 	void OnEndSession()
 	{
 		if (DataStore)
 			DataStore->SetInt(FIELD_IS_ONLINE, false);
 	}
 
 	// Commands
 	void Disconnect();
 	void Kill();
 
 	// Data
 	char *OptionName(const char *Opt, char *Dest, int DestLen);
 	void Delete();
 	LThread *GetThread() { return Thread; }
 	LMailStore *GetMailStore() { return MailStore; }
 	LDataStoreI *GetDataStore() { return DataStore; }
 
 	// General options
 	virtual int UseSSL(int Set = -1) = 0;
 
 	AccStrOption(Name, OPT_AccountName);
 	AccIntOption(Disabled, OPT_AccountDisabled);
 	AccIntOption(Id, OPT_AccountUID);
 	AccIntOption(Expanded, OPT_AccountExpanded);
 	bool GetPassword(GPassword *p);
 	void SetPassword(GPassword *p);
 	bool IsCheckDialup();
 	
 	// Events
 	void OnThreadDone();
 	void OnOnlineChange(bool Online);
 	virtual void OnBeforeDelete();
 
 	// LDom impl
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 
 	// Virtuals
 	virtual void Main(AccountletThread *Thread) = 0;
 	virtual LVariant Server(const char *Set = 0) = 0;
 	virtual LVariant UserName(const char *Set = 0) = 0;
 	virtual void Enabled(bool b) = 0;
 	virtual void OnPulse(char *s, int s_len) {}
 	virtual bool IsReceive() { return false; }
 	virtual bool InitMenus() { return false; }
 	virtual void CreateMaps() = 0;
 	virtual ScribeAccountletStatusIcon GetStatusIcon() { return STATUS_ERROR; }
 };
 
 #undef RoProp
 
 class AccountletThread;
 
 class AccountIdentity : public Accountlet
 {
 public:
 	AccountIdentity(ScribeAccount *a);
 
 	AccStrOption(Name, OPT_AccIdentName);
 	AccStrOption(Email, OPT_AccIdentEmail);
 	AccStrOption(ReplyTo, OPT_AccIdentReply);
 	AccStrOption(TextSig, OPT_AccIdentTextSig);
 	AccStrOption(HtmlSig, OPT_AccIdentHtmlSig);
 
 	AccIntOption(Sort, OPT_AccountSort);
 
 	int UseSSL(int Set = -1) { return 0; }
 	void Main(AccountletThread *Thread) {}
 	LVariant Server(const char *Set = 0) { return LVariant(); }
 	LVariant UserName(const char *Set = 0) { return LVariant(); }
 	void Enabled(bool b) {}
 	void CreateMaps();
 	bool IsValid();
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 };
 
 struct ScribeEnvelope
 {
 	LString MsgId;
 	LString SourceFolder;
 	LString From;
 	LArray<LString> To;
 
 	LString References;
 	LString FwdMsgId;
 	LString BounceMsgId;
 
 	LString Rfc822;
 };	
 
 class SendAccountlet : public Accountlet
 {
 	friend class ScribeAccount;
 	friend class ScribeWnd;
 
 	LMenuItem *SendItem;
 
 public:
 	LArray<ScribeEnvelope*> Outbox;
 
 	SendAccountlet(ScribeAccount *a);
 	~SendAccountlet();
 
 	// Methods
 	void Main(AccountletThread *Thread);
 	void Enabled(bool b);
 	bool InitMenus();
 	void CreateMaps();
 	ScribeAccountletStatusIcon GetStatusIcon();
 
 	// Sending options
 	AccStrOption(Server, OPT_SmtpServer);
 	AccIntOption(Port, OPT_SmtpPort);
 	AccStrOption(Domain, OPT_SmtpDomain);
 	AccStrOption(UserName, OPT_SmtpName);
 	AccIntOption(RequireAuthentication, OPT_SmtpAuth);
 	AccIntOption(AuthType, OPT_SmtpAuthType);
 	AccStrOption(PrefCharset1, OPT_SendCharset1);
 	AccStrOption(PrefCharset2, OPT_SendCharset2);
 	AccStrOption(HotFolder, OPT_SendHotFolder);
 	AccIntOption(OnlySendThroughThisAccount, OPT_OnlySendThroughThis);
 	
 	/// Get/Set the SSL mode
 	/// \sa #SSL_NONE, #SSL_STARTTLS or #SSL_DIRECT
 	AccIntOption(UseSSL, OPT_SmtpSSL);
 
 	bool IsConfigured()
 	{
 		LVariant hot = HotFolder();
 		if (hot.Str())
 		{
 			bool Exists = LDirExists(hot.Str());
 			printf("%s:%i - '%s' exists = %i\n", _FL, hot.Str(), Exists);
 			return Exists;
 		}
 
 		return ValidStr(Server().Str());
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 };
 
 typedef LHashTbl<ConstStrKey<char>, LXmlTag*> MsgListHash;
 class MsgList : protected MsgListHash
 {
 	LOptionsFile *Opts;
 	LString Tag;
 	bool Loaded;
 
 	bool Load();
 	LXmlTag *LockId(const char *id, const char *file, int line);
 	void Unlock();
 
 public:
 	typedef MsgListHash Parent;
 	bool Dirty;
 
 	MsgList(LOptionsFile *Opts, char *Tag);
 	~MsgList();
 
 	// Access methods
 	bool Add(const char *id);
 	bool Delete(const char *id);
 	int Length();
 	bool Find(const char *id);
 	void Empty();
 	LString::Array CopyKeys();
 
 	// Dates
 	bool SetDate(char *id, LDateTime *dt);
 	bool GetDate(char *id, LDateTime *dt);
 };
 
 class ReceiveAccountlet : public Accountlet
 {
 	friend class ScribeAccount;
 	friend class ScribeWnd;
 	friend class ImapThread;
 	friend class ScpThread;
 
 	LArray<ReceiveAction> Actions;
 	LList *Items;
 	int	SecondsTillOnline;
 	LMenuItem *ReceiveItem;
 	LMenuItem *PreviewItem;
 	List<char> *IdTemp;
 	LAutoPtr<ProtocolSettingStore> SettingStore;
 	
 	LAutoPtr<MsgList> Msgs;
 	LAutoPtr<MsgList> Spam;
 
 public:
 	ReceiveAccountlet(ScribeAccount *a);
 	~ReceiveAccountlet();
 
 	// Props
 	LList *GetItems() { return Items; }
 	bool SetItems(LList *l);
 	bool SetActions(LArray<ReceiveAction> *a = NULL);
 
 	bool IsReceive() { return true; }
 	bool IsPersistant();
 
 	// Methods
 	void Main(AccountletThread *Thread);
 	void OnPulse(char *s, int s_len);
 	bool OnIdle();
 	void Enabled(bool b);
 	bool InitMenus();
 	int GetCheckTimeout();
 	void CreateMaps();
 	ScribeAccountletStatusIcon GetStatusIcon();
 
 	// Message list
 	bool HasMsg(const char *Id);
 	void AddMsg(const char *Id);
 	void RemoveMsg(const char *Id);
 	void RemoveAllMsgs();
 	int GetMsgs();
 
 	// Spam list
 	void DeleteAsSpam(const char *Id);
 	bool RemoveFromSpamIds(const char *Id);
 	bool IsSpamId(const char *Id, bool Delete = false);
 
 	// Receive options
 	AccStrOption(Protocol, OPT_Pop3Protocol);
 	ScribeProtocol ProtocolType() { return ProtocolStrToEnum(Protocol().Str()); }
 	AccStrOption(Server, OPT_Pop3Server);
 	AccIntOption(Port, OPT_Pop3Port);
 	AccStrOption(UserName, OPT_Pop3Name);
 	AccStrOption(DestinationFolder, OPT_Pop3Folder);
 	AccIntOption(AutoReceive, OPT_Pop3AutoReceive);
 	AccStrOption(CheckTimeout, OPT_Pop3CheckEvery);
 	
 	AccIntOption(LeaveOnServer, OPT_Pop3LeaveOnServer);
 	AccIntOption(DeleteAfter, OPT_DeleteAfter);
 	AccIntOption(DeleteDays, OPT_DeleteDays);
 	AccIntOption(DeleteLarger, OPT_DeleteIfLarger);
 	AccIntOption(DeleteSize, OPT_DeleteIfLargerSize);
 	AccIntOption(DownloadLimit, OPT_MaxEmailSize);
 	
 	AccStrOption(Assume8BitCharset, OPT_Receive8BitCs);
 	AccStrOption(AssumeAsciiCharset, OPT_ReceiveAsciiCs);
 	AccIntOption(AuthType, OPT_ReceiveAuthType);
 	AccStrOption(HotFolder, OPT_ReceiveHotFolder);
 	AccIntOption(SecureAuth, OPT_ReceiveSecAuth);
 	
 	/// Get/Set the SSL mode
 	/// \sa #SSL_NONE, #SSL_STARTTLS or #SSL_DIRECT
 	AccIntOption(UseSSL, OPT_Pop3SSL);
 
 	bool IsConfigured()
 	{
 		LVariant hot = HotFolder();
 		if (hot.Str() && LDirExists(hot.Str()))
 		{
 			return true;
 		}
 		
 		LVariant v = Server();
 		bool s = ValidStr(v.Str());
 		v = Protocol();
 		if (!v.Str() ||
 			_stricmp(v.Str(), PROTOCOL_POP_OVER_HTTP) != 0)
 		{
 			v = UserName();
 			s &= ValidStr(v.Str());
 		}
 		return s;
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL);
 };
 
 class ScribeAccount :
 	public LDom,
 	public LXmlTreeUi,
 	public LCapabilityClient
 {
 	friend class ScribeWnd;
 	friend class ScribePopViewer;
 	friend class AccountStatusPanel;
 	friend class Accountlet;
 	friend class SendAccountlet;
 	friend class ReceiveAccountlet;
 
 protected:
 	class ScribeAccountPrivate *d;
 	ScribeWnd *Parent;
 	
 	ScribeFolder *&GetRoot();
 	void SetIndex(int i);
 
 public:
 	// Data
 	AccountIdentity Identity;
 	SendAccountlet Send;
 	ReceiveAccountlet Receive;
 	LArray<LListItem*> Views;
 
 	// Object
 	ScribeAccount(ScribeWnd *parent, int index);
 	~ScribeAccount();
 
 	// Lifespan
 	bool IsValid();
 	bool Create();
 	bool Delete();
 
 	// Properties
 	ScribeWnd *GetApp() { return Parent; }
 	int GetIndex();
 	bool IsOnline();
 	void SetCheck(bool c);
 	LMenuItem *GetMenuItem();
 	void SetMenuItem(LMenuItem *i);
 	void OnEndSession()
 	{
 		Send.OnEndSession();
 		Receive.OnEndSession();
 	}
 
 	// Commands
 	void Stop();
 	bool Disconnect();
 	void Kill();
 	void SetDefaults();
 
 	// User interface
 	void InitUI(LView *Parent, int Tab, std::function<void(bool)> callback);
 	bool InitMenus();
 	void SerializeUi(LView *Wnd, bool Load);
 	int OnNotify(LViewI *Ctrl, LNotification &n);
 
 	// Worker
 	void OnPulse(char *s = NULL, int s_len = 0);
 	void ReIndex(int i);
 	void CreateMaps();
 
 	// LDom interface
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool SetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 };
 
 //////////////////////////////////////////////////////////////////////
 class ScribeClass ScribeDom : public LDom
 {
 	ScribeWnd *App;
 
 public:
 	Mail *Email;
 	Contact *Con;
 	ContactGroup *Grp;
 	Calendar *Cal;
 	Filter *Fil;
 
 	ScribeDom(ScribeWnd *a);
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = 0);
 };
 
 //////////////////////////////////////////////////////////////////////
 #include "BayesianFilter.h"
 #include "Components.h"
 
 class LMailStore
 {
 public:
 	bool Default, Expanded;
 	LString Name;
 	LString Path;
 	LDataStoreI *Store;
 	ScribeFolder *Root;
 
 	LMailStore()
 	{
 		Expanded = true;
 		Default = false;
 		Store = NULL;
 		Root = NULL;
 	}
 
 	bool IsOk()
 	{
 		return	Store != NULL &&
 				Root != NULL;
 	}
 
 	int Priority()
 	{
 		int Ver = Store ? (int)Store->GetInt(FIELD_VERSION) : 0;
 		return Ver;
 	}
 
 	LMailStore &operator =(LMailStore &a)
 	{
 		LAssert(0);
 		return *this;
 	}
 };
 
 struct OptionsInfo
 {
 	LString File;
 	char *Leaf;
 	int Score;
 	uint64 Mod;
 	bool Usual;
 	
 	OptionsInfo();
 	
 	OptionsInfo &operator =(char *p);
 	LOptionsFile *Load();
 };
 
 class ScribeClass ScribeWnd :
 	public LWindow,
 	public LDom,
 	public LDataEventsI,
 	public BayesianFilter,
 	public CapabilityInstaller,
 	public LCapabilityTarget
 {
 	friend class ScribeAccount;
 	friend class Accountlet;
 	friend class SendAccountlet;
 	friend class ReceiveAccountlet;
 	friend class AccountStatusPanel;
 	friend class ScribeFolder;
 	friend class OptionsDlg;
 	friend class LoadWordStoreThread;
 	friend struct ScribeReplicator;
 
 public:
 	enum LayoutMode
 	{
 		OptionsLayout = 0,
 		
 		///--------------------
 		///         |         |
 		/// Folders |  List   |
 		///         |         |
 		///         |---------|
 		///         | Preview |
 		///--------------------
 		FoldersListAndPreview = 1,
 
 		///-----------------
 		///         |      |
 		/// Folders | List |
 		///         |      |
 		///-----------------
 		///     Preview    |
 		///-----------------
 		PreviewOnBottom,
 
 		///-----------------
 		///         |      |
 		/// Folders | List |
 		///         |      |
 		///-----------------
 		FoldersAndList,
 
 		///---------------------------
 		///         |      |         |
 		/// Folders | List | Preview |
 		///         |      |         |
 		///---------------------------
 		ThreeColumn,
 	};
 
 	enum AppState
 	{
 	    ScribeConstructing, // In Construct1 + Construct2
 	    ScribeConstructed,	// Finished Construct2 and ready for Construct3
 	    ScribeInitializing,	// In Construct3
 	    ScribeRunning,
 	    ScribeExiting,
 	    ScribeLoadingFolders,
 	    ScribeUnloadingFolders,
 	};
 	
 	AppState GetScribeState()
 	{
 	    return ScribeState;
 	}
 
 protected:
 	class ScribeWndPrivate *d = NULL;
 
 	LTrayIcon		TrayIcon;
 	
 	// Ipc
 	LSharedMemory	*ScribeIpc = NULL;
 	class ScribeIpcInstance *ThisInst = NULL;
 	bool ShutdownIpc();
 
 	// Accounts
 	List<ScribeAccount> Accounts;
 
 	// New Mail stuff
 	class LNewMailDlg *NewMailDlg = NULL;
 
 	static AppState ScribeState;
 	DoEvery			Ticker;
 	int64			LastDrop = 0;
 
 	// Static 
 	LSubMenu		*File = NULL;
 	LSubMenu		*ContactsMenu = NULL;
 	LSubMenu		*Edit = NULL;
 	LSubMenu		*Help = NULL;
 	LToolBar		*Commands = NULL;
 
 	// Dynamic
 	LSubMenu		*IdentityMenu = NULL;
 	LMenuItem		*DefaultIdentityItem = NULL;
 	LSubMenu		*MailMenu = NULL;
 	LSubMenu		*SendMenu = NULL, *ReceiveMenu = NULL, *PreviewMenu = NULL;
 	LMenuItem		*SendItem = NULL, *ReceiveItem = NULL, *PreviewItem = NULL;
 	LSubMenu		*NewTemplateMenu = NULL;
 	LMenuItem		*WorkOffline = NULL;
 
 	// Commands
 	LCommand		CmdSend;
 	LCommand		CmdReceive;
 	LCommand		CmdPreview;
 
 	// Storage
 	LArray<LMailStore> Folders;
 	LArray<LEventTargetI*> FolderTasks;
 	
 	List<ScribeFolder> PostValidateFree;
 
 	// Main view
 	LAutoPtr<LImageList> ImageList;
 	LAutoPtr<LImageList> ToolbarImgs;
 	class LBox		*Splitter = NULL;
 	ThingList		*MailList = NULL;
 	class DynamicHtml *TitlePage = NULL;
 	class LSearchView *SearchView = NULL;
 	MailTree		*Tree = NULL;
 	class LPreviewPanel	*PreviewPanel = NULL;
 	class AccountStatusPanel *StatusPanel = NULL;
 
 	// Security
 	ScribePerm		CurrentAuthLevel = PermRequireNone;
 
 	// Methods
 	void			SetupUi();
 	void			SetupAccounts();
 	int				AdjustAllObjectSizes(LDataI *Item);
 	bool			CleanFolders(ScribeFolder *f);
 	LDataStoreI		*CreateDataStore(char *Full, bool CreateIfMissing);
 	void			LoadFolders(std::function<void(bool)> Callback);
 	bool			LoadMailStores();
 	bool			ProcessFolder(LDataStoreI *&Store, int StoreIdx, char *StoreName);
 	bool			UnLoadFolders();
 	void			AddFolderToMru(char *FileName);
 	void			AddContactsToMenu(LSubMenu *Menu);
 	bool			FindWordDb(char *Out, int OutSize, char *Name);
 	void			OnFolderChanged(LDataFolderI *folder);
 	bool			ValidateFolder(LMailStore *s, int Id);
     void            GrowlOnMail(Mail *m);
 	void			GrowlInfo(LString title, LString text);
 	bool			OnTransfer();
 	ScribeDomType	StrToDom(const char *Var) { return ::StrToDom(Var); }
 	const char*		DomToStr(ScribeDomType p) { return ::DomToStr(p); }
 	void			LoadImageResources();
 	void			DoOnTimer(LScriptCallback *c);
 
 public:
 	ScribeWnd();
 	void Construct1();
 	void Construct2();
 	void Construct3();
 	void SetLanguage();
 
 	~ScribeWnd();
 
 	static bool IsUnitTest;
 	const char *GetClass() override { return "ScribeWnd"; }
 	void DoDebug(char *s);
 	void Validate(LMailStore *s);
 
 	// Dom
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = NULL) override;
 	bool CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args) override;
 
 	// ---------------------------------------------------------------------
 	// Methods
 	LAutoString		GetDataFolder();
 	Thing			*CreateThingOfType(Store3ItemTypes Type, LDataI *obj = 0);
 	Thing			*CreateItem(int Type, ScribeFolder *Folder = 0, bool Ui = true);
 	Mail			*CreateMail(Contact *c = 0, const char *Email = 0, const char *Name = 0);
 	Mail			*LookupMailRef(const char *MsgRef, bool TraceAllUids = false);
 	bool			CreateFolders(LAutoString &FileName);
 	bool			CompactFolders(LMailStore &Store, bool Interactive = true);
 	void			Send(int Which = -1, bool Quiet = false);
 	void			Receive(int Which);
 	void			Preview(int Which);
 	void			OnBeforeConnect(ScribeAccount *Account, bool Receive);
 	void			OnAfterConnect(ScribeAccount *Account, bool Receive);
     bool			NeedsCapability(const char *Name, const char *Param = NULL) override;
 	void			OnInstall(CapsHash *Caps, bool Status) override;
     void			OnCloseInstaller() override;
     bool			HasFolderTasks() { return FolderTasks.Length() > 0; }
     int				GetEventHandle();
 
 	void			Update(int What = 0);
 	void			UpdateUnRead(ScribeFolder *Folder, int Delta);
 	void			ThingPrint(std::function<void(bool)> Callback, ThingType *m, LPrinter *Info = NULL, LView *Parent = NULL, int MaxPage = -1);
 	bool			OpenAMail(ScribeFolder *Folder);
 	void			BuildDynMenus();
 	LDocView		*CreateTextControl(int Id, const char *MimeType, bool Editor, Mail *m = 0);
 	void			SetLastDrop() { LastDrop = LCurrentTime(); }
 	void			SetListPane(LView *v);
 	void			SetLayout(LayoutMode Mode = OptionsLayout);
 	bool			IsMyEmail(const char *Email);
 	bool			SetItemPreview(LView *v);
 	LOptionsFile::PortableType GetPortableType();
 	ScribeRemoteContent RemoteContent_GetSenderStatus(const char *Addr);
 	void			RemoteContent_ClearCache();
 	void			RemoteContent_AddSender(const char *Addr, bool WhiteList);
 
 	void			SetDefaultHandler();
 	void			OnSetDefaultHandler(bool Error, bool OldAssert);
 	void			SetCurrentIdentity(int i=-1);
 	int				GetCurrentIdentity();
 
 	bool			MailReplyTo(Mail *m, bool All = false);
 	bool			MailForward(Mail *m);
 	bool			MailBounce(Mail *m);
 	void			MailMerge(LArray<ListAddr*> &Recip, const char *FileName, Mail *Source);
 
 	void			OnNewMail(List<Mail> *NewMailObjs, bool Add = true);
 	void			OnNewMailSound();
 	void			OnCommandLine();
 	void			OnTrayClick(LMouse &m) override;
 	void			OnTrayMenu(LSubMenu &m) override;
 	void			OnTrayMenuResult(int MenuId) override;
 	void			OnFolderSelect(ScribeFolder *f);
 
 	void			AddThingSrc(ScribeFolder *src);
 	void			RemoveThingSrc(ScribeFolder *src);
 	LArray<ScribeFolder*> GetThingSources(Store3ItemTypes Type);
 
 	bool			GetContacts(List<Contact> &Contacts, ScribeFolder *f = 0, bool Deep = true);
 	List<Contact>	*GetEveryone();
 	void			HashContacts(LHashTbl<StrKey<char,false>,Contact*> &Contacts, ScribeFolder *Folder = 0, bool Deep = true);
 	
     // CapabilityInstaller impl
     LAutoString     GetHttpProxy() override;
     InstallProgress *StartAction(MissingCapsBar *Bar, LCapabilityTarget::CapsHash *Components, const char *Action) override;
     
 	class HttpImageThread *GetImageLoader();
 	int				GetMaxPages();
 	ScribeWnd::LayoutMode GetEffectiveLayoutMode();
 	ThingList		*GetMailList() { return MailList; }
 	
 	// Gets the matching mail store for a given identity
 	LMailStore		*GetMailStoreForIdentity
 	(
 		/// If this is NULL, assume the current identity
 		const char *IdEmail = NULL
 	);
 	
 	ScribeFolder	*GetFolder(int Id, LMailStore *s = NULL, bool Quiet = false);
 	ScribeFolder	*GetFolder(int Id, LDataI *s);
 	ScribeFolder	*GetFolder(const char *Name, LMailStore *s = NULL);
 	
 	ScribeFolder	*GetCurrentFolder();
 	int				GetFolderType(ScribeFolder *f);
 	LImageList		*GetIconImgList() { return ImageList; }
 	LAutoPtr<LImageList> &GetToolbarImgList() { return ToolbarImgs; }
 	LString			GetResourceFile(SribeResourceType Type);
 	DoEvery			*GetTicker() { return &Ticker; }
 	ScribeAccount	*GetSendAccount();
 	ScribeAccount	*GetCurrentAccount();
 	ThingFilter		*GetThingFilter();
 	List<ScribeAccount> *GetAccounts() { return &Accounts; }
 	ScribeAccount	*GetAccountById(int Id);
 	ScribeAccount	*GetAccountByEmail(const char *Email);
 	LPrinter		*GetPrinter();
 	int				GetActiveThreads();
 	int				GetToolbarHeight();
 	void			GetFilters(List<Filter> &Filters, bool JustIn, bool JustOut, bool JustInternal);
 	bool			OnFolderTask(LEventTargetI *Ptr, bool Add);
 	LArray<LMailStore> &GetStorageFolders() { return Folders; }
 	LMailStore		*GetDefaultMailStore();
 	LMailStore		*GetMailStoreForPath(const char *Path);
 	bool			OnMailStore(LMailStore **MailStore, bool Add);
 	ThingList		*GetItemList() { return MailList; }
 	LColour			GetColour(int i);
 	LMutex			*GetLock();
 	LFont			*GetPreviewFont();
 	LFont			*GetBoldFont() { return LSysBold; }
 	LToolBar		*LoadToolbar(LViewI *Parent, const char *File, LAutoPtr<LImageList> &Img);
 	class LVmDebuggerCallback *GetDebuggerCallback();
 	class GpgConnector *GetGpgConnector();
 	void			GetUserInput(LView *Parent, LString Msg, bool Password, std::function<void(LString)> Callback);
 
 	int				GetCalendarSources(LArray<CalendarSource*> &Sources);
 
 	Store3Status	GetAccessLevel(LViewI *Parent, ScribePerm Required, const char *ResourceName, std::function<void(bool)> Callback);
 	void			GetAccountSettingsAccess(LViewI *Parent, ScribeAccessType AccessType, std::function<void(bool)> Callback);
 	const char*		EditCtrlMimeType();
 	LAutoString		GetReplyXml(const char *MimeType);
 	LAutoString		GetForwardXml(const char *MimeType);
 	bool			GetHelpFilesPath(char *Path, int PathSize);
 	bool			LaunchHelp(const char *File);
 	LAutoString		ProcessSig(Mail *m, char *Xml, const char *MimeType);
 	LString			ProcessReplyForwardTemplate(Mail *m, Mail *r, char *Xml, int &Cursor, const char *MimeType);
 	bool			LogFilterActivity();
 	ScribeFolder *FindContainer(LDataFolderI *f);
 	bool			SaveDirtyObjects(int TimeLimitMs = 100);
 	class LSpellCheck *CreateSpellObject();
 	class LSpellCheck *GetSpellThread(bool OverrideOpt = false);
 	bool			SetSpellThreadParams(LSpellCheck *Thread);
 	void			OnSpellerSettingChange();
 	bool			OnMailTransferEvent(MailTransferEvent *e);
 	LViewI			*GetView() { return this; }
 	char			*GetUiTags();
 
 	struct MailStoreUpgradeParams
 	{
 		LAutoString OldFolders;
 		LAutoString NewFolders;
 		bool Quiet;
 		LStream *Log;
 		
 		MailStoreUpgradeParams()
 		{
 		    Quiet = false;
 		    Log = 0;
 		}
 	};
 
 	// Scripting support
 	bool GetScriptCallbacks(LScriptCallbackType Type, LArray<LScriptCallback*> &Callbacks);
 	LScriptCallback GetCallback(const char *CallbackMethodName);
 	bool RegisterCallback(LScriptCallbackType Type, LScriptArguments &Args);
 	LStream *ShowScriptingConsole();
 	bool ExecuteScriptCallback(LScriptCallback &c, LScriptArguments &Args, bool ReturnArgs = false);
 	LScriptEngine *GetScriptEngine();
 
 	// Options
 	LOptionsFile	*GetOptions(bool Create = false) override;
 	bool			ScanForOptionsFiles(LArray<OptionsInfo> &Inf, LSystemPath PathType);
 	bool			LoadOptions();
 	bool			SaveOptions();
 	bool			IsSending() { return false; }
 	bool			ShowToolbarText();
 	bool			IsValid();
 
 	// Data events from storage back ends
 	bool GetSystemPath(int Folder, LVariant &Path) override;
 	void OnNew(LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new) override;
 	bool OnDelete(LDataFolderI *parent, LArray<LDataI*> &items) override;
 	bool OnMove(LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &Items) override;
 	void SetContext(const char *file, int line) override;
 	bool OnChange(LArray<LDataI*> &items, int FieldHint) override;
 	void Post(LDataStoreI *store, void *Param) override { PostEvent(M_STORAGE_EVENT, store->Id, (LMessage::Param)Param); }
 	void OnPropChange(LDataStoreI *store, int Prop, LVariantType Type) override;
 	bool Match(LDataStoreI *store, LDataPropI *Addr, int Type, LArray<LDom*> &Matches) override;
 	ContactGroup *FindGroup(char *Name);
 
 	bool AddStore3EventHandler(LDataEventsI *callback);
 	bool RemoveStore3EventHandler(LDataEventsI *callback);
 
 	// ---------------------------------------------------------------------
 	// Events
 	void			OnDelete();
 	int				OnNotify(LViewI *Ctrl, LNotification n) override;
 	void			OnPaint(LSurface *pDC) override;
     LMessage::Result OnEvent(LMessage *Msg) override;
 	int				OnCommand(int Cmd, int Event, OsView Handle) override;
 	void			OnPulse() override;
     void            OnPulseSecond();
 	bool			OnRequestClose(bool OsShuttingDown) override;
 	void			OnSelect(List<Thing> *l = 0, bool ChangeEvent = false);
 	void			OnReceiveFiles(LArray<const char*> &Files) override;
 	void			OnUrl(const char *Url) override;
 	void			OnZoom(LWindowZoom Action) override;
 	void			OnCreate() override;
 	void			OnMinute();
 	void			OnHour();
 	bool			OnIdle();
     void            OnBayesAnalyse(const char *Msg, const char *WhiteListEmail) override;
     
     /// \returns true if spam
     bool            OnBayesResult(const char *MailRef, double Rating) override;
     /// \returns true if spam
     bool            OnBayesResult(Mail *m, double Rating);
 
 	void			OnScriptCompileError(const char *Source, Filter *f);
 };
 
 ////////////////////////////////////////////////////////////////////////////////////
 #ifdef SCRIBE_APP
 #include "ScribePrivate.h"
 #endif
diff --git a/Code/ScribeFilter.cpp b/Code/ScribeFilter.cpp
--- a/Code/ScribeFilter.cpp
+++ b/Code/ScribeFilter.cpp
@@ -1,4201 +1,4203 @@
 /*
 **	FILE:			ScribeFilter.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			29/10/1999
 **	DESCRIPTION:	Scribe filters
 **
 **	Copyright (C) 1999-2022, Matthew Allen
 **		fret@memecode.com
 **
 */
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 #include <ctype.h>
 
 #include "Scribe.h"
 #include "lgi/common/NetTools.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/FilterUi.h"
 #include "lgi/common/XmlTree.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/Printer.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Charset.h"
 
 #include "resdefs.h"
 #include "resource.h"
 
 #define COMBINE_OP_AND				0
 #define COMBINE_OP_OR				1
 
 #define IDM_TRUE					500
 #define IDM_FALSE					501
 #define IDM_NOTNEW					502
 #define IDM_LOCAL					503
 #define IDM_SERVER					504
 #define IDM_LOCAL_AND_SERVER		505
 
 const char *ATTR_NOT				= "Not";
 const char *ATTR_FIELD				= "Field";
 const char *ATTR_OP					= "Op";
 const char *ATTR_VALUE				= "Value";
 
 const char *ELEMENT_AND				= "And";
 const char *ELEMENT_OR				= "Or";
 const char *ELEMENT_CONDITION		= "Condition";
 const char *ELEMENT_CONDITIONS		= "Conditions";
 
 const char *ELEMENT_ACTION			= "Action";
 
 #define SkipWs(s)					while ((*s) && strchr(WhiteSpace, *s)) s++;
 
 //////////////////////////////////////////////////////////////
 class FilterPrivate
 {
 public:
 	bool *Stop;
 	LStream *Log;
 
 	FilterPrivate()
 	{
 		Stop = 0;
 		Log = 0;
 	}
 };
 
 //////////////////////////////////////////////////////////////
 // Filter field definitions
 ItemFieldDef FilterFieldDefs[] = {
 	{"Name", SdName, 			GV_STRING,	FIELD_FILTER_NAME},
 	{"Index", SdIndex, 			GV_INT32,	FIELD_FILTER_INDEX},
 	{"Incoming", SdIncoming, 	GV_INT32,	FIELD_FILTER_INCOMING},
 	{"Outgoing", SdOutgoing, 	GV_INT32,	FIELD_FILTER_OUTGOING},
 	{"Internal", SdInternal, 	GV_INT32,	FIELD_FILTER_INTERNAL},
 	{0}
 };
 
 int DefaultFilterFields[] =
 {
 	FIELD_FILTER_NAME,
 	FIELD_FILTER_INDEX,
 	FIELD_FILTER_INCOMING,
 	FIELD_FILTER_OUTGOING,
 	FIELD_FILTER_INTERNAL,
 	0
 };
 
 #define ForCondField(Macro, Value)							\
 	switch (Value)											\
 	{														\
 		case 0: Macro("To"); break;							\
 		case 1: Macro("From"); break;						\
 		case 2: Macro("Subject"); break;					\
 		case 3: Macro("Size"); break;						\
 		case 4: Macro("DateReceived"); break;				\
 		case 5: Macro("DateSent"); break;					\
 		case 6: Macro("Body"); break;						\
 		case 7: Macro("InternetHeaders"); break;			\
 		case 8: Macro("MessageID"); break;					\
 		case 9: Macro("Priority"); break;					\
 		case 10: /* flags */ break;							\
 		case 11: Macro("Html"); break;						\
 		case 12: Macro("Label"); break;						\
 		case 13: Macro("From.Contact"); break;				\
 		case 14: Macro("ImapCacheFile"); break;				\
 		case 15: Macro("ImapFlags"); break;					\
 		case 16: Macro("Attachments"); break;				\
 		case 17: Macro("AttachmentNames"); break;			\
 		case 18: Macro("From.Groups"); break;				\
 		case 19: Macro("*"); break;							\
 	}
 // Macro("", FIELD_FLAGS)
 
 struct ActionName
 {
 	int Id;
 	const char *Default;
 };
 
 ActionName ActionNames[] = {
 	{IDS_ACTION_MOVE_FOLDER, "Move to Folder"},
 	{IDC_DELETE, "Delete"},
 	{IDS_PRINT, "Print"},
 	{IDS_ACTION_SOUND, "Play Sound"},
 	{IDS_ACTION_OPEN, "Open Email"},
 	{IDS_ACTION_EXECUTE, "Execute Process"},
 	{IDS_ACTION_SET_COLOUR, "Set Colour"},
 	{IDS_SET_READ, "Set Read"},
 	{IDS_ACTION_SET_LABEL, "Set Label"},
 	{IDS_ACTION_EMPTY_FOLDER, "Empty Folder"},
 	{IDS_ACTION_MARK_SPAM, "Mark As Spam"},
 	{IDS_REPLY, "Reply"},
 	{IDS_FORWARD, "Forward"},
 	{IDS_BOUNCE, "Bounce"},
 	{IDS_ACTION_SAVE_ATTACHMENTS, "Save Attachment(s)"},
 	{IDS_ACTION_DELETE_ATTACHMENTS, "Delete Attachments(s)"},
 	{L_CHANGE_CHARSET, "Change Charset"},
 	{IDS_ACTION_COPY, "Copy to Folder"},
 	{IDS_EXPORT, "Export"},
 	{0, 0},
 	{IDS_ACTION_CREATE_FOLDER, "Create Folder"},
 	{0, 0}
 };
 
 // These are the english names used for storing XML
 const char *OpNames[] =
 {
 	"=",
 	"!=",
 	"<",
 	"<=",
 	">=",
 	">",
 	"Like",			// LLoadString(IDS_LIKE),
 	"Contains",		// LLoadString(IDS_CONTAINS),
 	"Starts With",	// LLoadString(IDS_STARTS_WITH),
 	"Ends With",		// LLoadString(IDS_ENDS_WITH),
 	0
 };
 
 const char *TranslatedOpNames[] =
 {
 	"=",
 	"!=",
 	"<",
 	"<=",
 	">=",
 	">",
 	0, // like
 	0, // contains
 	0, // starts with
 	0, // ends with
 	0
 };
 
 const char **GetOpNames(bool Translated)
 {
 	if (Translated)
 	{
 		if (TranslatedOpNames[6] == NULL)
 		{
 			TranslatedOpNames[6] = LLoadString(IDS_LIKE);
 			TranslatedOpNames[7] = LLoadString(IDS_CONTAINS);
 			TranslatedOpNames[8] = LLoadString(IDS_STARTS_WITH);
 			TranslatedOpNames[9] = LLoadString(IDS_ENDS_WITH);
 		}
 
 		if (TranslatedOpNames[6])
 		{
 			return TranslatedOpNames;
 		}
 	}
 
 	return OpNames;
 }
 
 //////////////////////////////////////////////////////////////
 void SkipSep(const char *&s)
 {
 	while (s && *s && strchr(" \t,", *s)) s++;
 }
 
 LCombo *LoadTemplates(ScribeWnd *App, LView *Wnd, List<char> &MsgIds, int Ctrl, char *Template)
 {
 	LCombo *Temp;
 	if (Wnd->GetViewById(IDC_TEMPLATE, Temp))
 	{
 		ScribeFolder *Templates = App->GetFolder(FOLDER_TEMPLATES);
 		if (Templates)
 		{
 			int n=0;
 			for (auto t: Templates->Items)
 			{
 				Mail *m = t->IsMail();
 				if (m)
 				{
 					auto Id = m->GetMessageId(true);
 					if (Id)
 					{
 						MsgIds.Insert(NewStr(Id));
 						Temp->Insert(m->GetSubject() ? m->GetSubject() : (char*)"(no subject)");
 						if (Template && strcmp(Template, Id) == 0)
 						{
 							Temp->Value(n);
 						}
 					}
 				}
 				n++;
 			}
 		}
 	}
 	return Temp;
 }
 
 class BrowseReply : public LDialog
 {
 	List<char> MsgIds;
 	LCombo *Temp;
 
 public:
 	char *Arg;
 
 	BrowseReply(ScribeWnd *App, LView *Parent, const char *arg)
 	{
 		SetParent(Parent);
 		LoadFromResource(IDD_FILTER_REPLY);
 		MoveToCenter();
 		
 		char *Template = LTokStr(arg);
 		SkipSep(arg);
 		char *All = LTokStr(arg);
 		SkipSep(arg);
 		char *MarkReplied = LTokStr(arg);
 		if (All)
 		{
 			SetCtrlValue(IDC_ALL, atoi(All));
 		}
 		if (MarkReplied)
 		{
 			SetCtrlValue(IDC_MARK_REPLIED, atoi(MarkReplied));
 		}
 		
 		Temp = LoadTemplates(App, this, MsgIds, IDC_TEMPLATE, Template);
 		
 		DeleteArray(Template);
 		DeleteArray(MarkReplied);
 		DeleteArray(All);
 	}
 
 	~BrowseReply()
 	{
 		MsgIds.DeleteArrays();
 	}
 	
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDOK:
 			{
 				if (Temp)
 				{
 					char *Template = MsgIds[(int)Temp->Value()];
 					int All = (int)GetCtrlValue(IDC_ALL);
 					int MarkReplied = (int)GetCtrlValue(IDC_MARK_REPLIED);
 					char s[256];
 					sprintf_s(s, sizeof(s), "\"%s\" %i %i", Template?Template:(char*)"", All, MarkReplied);
 					Arg = NewStr(s);
 				}
 				
 				// Fall thru
 			}
 			case IDCANCEL:
 			{
 				EndModal(c->GetId() == IDOK);
 				break;
 			}
 		}
 		
 		return 0;
 	}	
 };
 
 class BrowseForward : public LDialog
 {
 	List<char> MsgIds;
 	ScribeWnd *App;
 	LCombo *Temp;
 	bool UseTemplate;
 
 public:
 	char *Arg;
 
 	BrowseForward(ScribeWnd *app, LView *parent, const char *arg, bool temp)
 	{
 		UseTemplate = temp;
 		App = app;
 		Arg = 0;
 		Temp = 0;
 		SetParent(parent);
 		LoadFromResource(IDD_FILTER_FORWARD);
 		MoveToCenter();
 		
 		char *Template = 0;
 		if (UseTemplate)
 		{
 			Template = LTokStr(arg);
 			SkipSep(arg);
 		}
 		char *Email = LTokStr(arg);
 		SkipSep(arg);
 		char *Forward = LTokStr(arg);
 		SkipSep(arg);
 		char *MarkForwarded = LTokStr(arg);
 
 		if (UseTemplate)
 		{
 			bool HasTemplate = ValidStr(Template) ? strlen(Template) > 1 : 0;
 			SetCtrlValue(IDC_USE_TEMPLATE, HasTemplate);
 			Temp = LoadTemplates(App, this, MsgIds, IDC_TEMPLATE, HasTemplate ? Template : 0);
 		}
 		else
 		{
 			LViewI *v = FindControl(IDC_USE_TEMPLATE);
 			if (v)
 			{
 				int y1 = v->GetPos().y1;
 				Children.Delete(v);
 				DeleteObj(v);
 				v = FindControl(IDC_TEMPLATE);
 				if (v)
 				{
 					int y2 = v->GetPos().y2;
 					Children.Delete(v);
 					DeleteObj(v);
 
 					int Sub = y1 - y2 - 10;
 					
 					for (auto v: Children)
 					{
 						LRect r = v->GetPos();
 						r.Offset(0, Sub);
 						v->SetPos(r);
 					}
 
 					LRect r = GetPos();
 					r.y2 += Sub;
 					SetPos(r);
 				}
 			}
 		}
 
 		SetCtrlName(IDC_EMAIL, Email);
 		if (Forward) SetCtrlValue(IDC_ATTACHMENTS, atoi(Forward));
 		if (MarkForwarded) SetCtrlValue(IDC_MARK_FORWARDED, atoi(MarkForwarded));
 
 		DeleteArray(Template);
 		DeleteArray(Email);
 		DeleteArray(Forward);
 		DeleteArray(MarkForwarded);
 	}
 	
 	~BrowseForward()
 	{
 		DeleteArray(Arg);
 	}
 	
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDOK:
 			{
 				char s[256];
 				bool HasTemplate = GetCtrlValue(IDC_USE_TEMPLATE) != 0;
 				char *MsgId = HasTemplate ? MsgIds[(int)GetCtrlValue(IDC_TEMPLATE)] : 0;
 				const char *Email = GetCtrlName(IDC_EMAIL);
 				int Attachments = (int)GetCtrlValue(IDC_ATTACHMENTS);
 				int MarkForwarded = (int)GetCtrlValue(IDC_MARK_FORWARDED);
 				if (UseTemplate)
 				{
 					sprintf_s(s, sizeof(s), "\"%s\" \"%s\" %i %i", MsgId, Email?Email:(char*)"", Attachments, MarkForwarded);
 				}
 				else
 				{
 					sprintf_s(s, sizeof(s), "\"%s\" %i %i", Email?Email:(char*)"", Attachments, MarkForwarded);
 				}
 				Arg = NewStr(s);
 				// Fall thru				
 			}
 			case IDCANCEL:
 			{
 				EndModal(c->GetId() == IDOK);
 			}
 		}
 		
 		return 0;
 	}
 };
 
 class BrowseSaveAttach : public LDialog
 {
 	ScribeWnd *App;
 
 public:
 	char *Arg;
 
 	BrowseSaveAttach(ScribeWnd *app, LView *parent, const char *arg)
 	{
 		Arg = 0;
 		App = app;
 		SetParent(parent);
 		if (LoadFromResource(IDD_FILTER_SAVE_ATTACH))
 		{
 			MoveToCenter();
 			
 			char *Dir = LTokStr(arg);
 			SkipSep(arg);
 			char *Types = LTokStr(arg);
 			SetCtrlName(IDC_DIR, Dir);
 			SetCtrlName(IDC_TYPES, Types);
 			DeleteArray(Dir);
 			DeleteArray(Types);
 		}
 	}
 	
 	~BrowseSaveAttach()
 	{
 		DeleteArray(Arg);
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_BROWSE_DIR:
 			{
 				auto s = new LFileSelect(this);
 				s->Name(GetCtrlName(IDC_DIR));
 				s->OpenFolder([&](auto dlg, auto status)
 				{
 					if (status)
 						SetCtrlName(IDC_DIR, s->Name());
 					delete dlg;
 				});
 				break;
 			}
 			case IDOK:
 			{
 				char s[512];
 				const char *Dir = GetCtrlName(IDC_DIR);
 				const char *Types = GetCtrlName(IDC_TYPES);
 				sprintf_s(s, sizeof(s), "\"%s\",\"%s\"", Dir?Dir:(char*)"", Types?Types:(char*)"");
 				Arg = NewStr(s);
 				// Fall thru				
 			}
 			case IDCANCEL:
 			{
 				EndModal(c->GetId() == IDOK);
 			}
 		}
 		
 		return 0;
 	}
 };
 
 bool LgiCreateTempFileName(char *Path, int PathLen)
 {
 	if (Path)
 	{
 		#if defined WIN32
 		int Len = GetTempPathA(PathLen, Path);
 		#else
 		strcpy(Path, "/tmp");
 		int Len = (int)strlen(Path);
 		#endif
 		if (Path[Len-1] != DIR_CHAR) strcat(Path, DIR_STR);
 		
 		int len = (int) strlen(Path);
 		sprintf_s(Path+len, PathLen-len, "~%i.txt", LRand(10000));
 		return true;
 	}
 
 	return false;
 }
 
 //////////////////////////////////////////////////////////////
 FilterCondition::FilterCondition()
 {
 	Op = 0;
 	Not = false;
 }
 
 FilterCondition &FilterCondition::operator=(FilterCondition &c)
 {
 	Source.Reset(NewStr(c.Source));
 	Op = c.Op;
 	Not = c.Not;
 	Value.Reset(NewStr(c.Value));
 	
 	return *this;
 }
 
 bool FilterCondition::Test(Filter *F, Mail *m, LStream *Log)
 {
 	if (Log) Log->Print("\tCondition.Test Fld='%s'\n", (char*)Source);
 
 	if (ValidStr(Source))
 	{
 		int Flds = 0;
 		for (; MailFieldDefs[Flds].FieldId; Flds++)
 		{
 		}
 
 		LVariant v;
 
 		// Get data
 		if (_stricmp(Source, "mail.attachments") == 0)
 		{
 			// attachment(s) data
 			List<Attachment> Attachments;
 
 			if (m->GetAttachments(&Attachments))
 			{
 				for (auto a: Attachments)
 				{
 					char *Data;
 					ssize_t Length;
 					LDateTime Temp;
 					
 					if (a->Get(&Data, &Length))
 					{
 						// Zero terminate the string
 						LVariant v;
 						v.SetBinary(Length, Data);
 
 						// Test the file
 						if (TestData(F, v, Log))
 						{
 							return true;
 						}
 					}
 				}
 			}
 
 			return false;
 		}
 		else if (_stricmp(Source, "mail.attachmentnames") == 0)
 		{
 			// attachment(s) name
 			List<Attachment> Attachments;
 			// ItemFieldDef AttachType = {"Attachment(s) Name", SdAttachmentNames, GV_STRING};
 			LDateTime Temp;
 
 			if (m->GetAttachments(&Attachments))
 			{
 				for (auto a: Attachments)
 				{
 					LVariant v = a->GetName();
 					if (TestData(F, v, Log))
 					{
 						return true;
 					}
 				}
 			}
 
 			return false;
 		}
 		else
 		{
 			bool Status = false;
 			ItemFieldDef *f = 0;
 			if (_stricmp(Source, "mail.*") == 0)
 			{
 				ItemFieldDef *Start = MailFieldDefs;
 				ItemFieldDef *End = MailFieldDefs + Flds - 1;
 
 				for (f = Start; f <= End && !Status; f++)
 				{
 					switch (f->FieldId)
 					{
 						case FIELD_TO:
 						{
 							for (LDataPropI *a = m->GetTo()->First(); a;
 								a = m->GetTo()->Next())
 							{
 								char Data[256];
 								sprintf_s(Data, sizeof(Data),
 										"%s <%s>",
 										a->GetStr(FIELD_NAME),
 										a->GetStr(FIELD_EMAIL));
 								LVariant v(Data);
 								if (TestData(F, v, Log))
 								{
 									Status |= true;
 								}
 							}
 							continue;
 							break;
 						}
 						case FIELD_FROM:
 						{
 							char Data[256];
 							sprintf_s(Data, sizeof(Data),
 									"%s <%s>",
 									m->GetFrom()->GetStr(FIELD_NAME),
 									m->GetFrom()->GetStr(FIELD_EMAIL));
 							v = Data;
 							break;
 						}
 						case FIELD_REPLY:
 						{
 							char Data[256];
 							sprintf_s(Data, sizeof(Data),
 									"%s <%s>",
 									m->GetReply()->GetStr(FIELD_NAME),
 									m->GetReply()->GetStr(FIELD_EMAIL));
 							v = Data;
 							break;
 						}
 						case FIELD_SUBJECT:
 							v = m->GetSubject();
 							break;
 						case FIELD_SIZE:
 							v = m->TotalSizeof();
 							break;
 						case FIELD_DATE_RECEIVED:
 							v = m->GetDateReceived();
 							break;
 						case FIELD_DATE_SENT:
 							v = m->GetDateSent();
 							break;
 						case FIELD_TEXT:
 							v = m->GetBody();
 							break;
 						case FIELD_INTERNET_HEADER:
 							v = m->GetInternetHeader();
 							break;
 						case FIELD_MESSAGE_ID:
 							v = m->GetMessageId();
 							break;
 						case FIELD_PRIORITY:
 							v = m->GetPriority();
 							break;
 						case FIELD_ALTERNATE_HTML:
 							v = m->GetHtml();
 							break;
 						case FIELD_LABEL:
 							v = m->GetLabel();
 							break;
 					}
 				}
 			}
 			else
 			{
 				if (F)
 				{
 					F->GetValue(Source, v);
 				}
 				else if (Log)
 				{
 					Log->Print("%s:%i - Error: No filter to query value.\n", __FILE__, __LINE__);
 				}
 			}
 
 			if (v.Type)
 			{
 				// Test data
 				Status |= TestData(F, v, Log);
 			}
 			else if (Log)
 			{
 				Log->Print("%s:%i - Error: Variant doesn't have type!\n", __FILE__, __LINE__);
 			}
 			
 			return Status;
 		}
 	}
 	
 	return false;
 }
 
 char *LogPreview(char *s)
 {
 	LStringPipe p(1 << 10);
 	if (s)
 	{
 		char *c;
 		for (c = s; *c && c - s < 200; c++)
 		{
 			switch (*c)
 			{
 				case '\n': p.Push("\\n"); break;
 				case '\r': p.Push("\\r"); break;
 				case '\t': p.Push("\\t"); break;
 				default:
 				{
 					p.Push(c, 1);
 				}
 			}
 		}
 		if (*c)
 		{
 			p.Push("...");
 		}
 	}
 	return p.NewStr();
 }
 
 bool FilterCondition::TestData(Filter *F, LVariant &Var, LStream *Log)
 {
 	// Do DOM lookup on the Value
 	LVariant Val;
 	if (F && F->Evaluate(Value, Val))
 	{
 		// Compare using type
 		switch (Var.Type)
 		{
 			case GV_LIST:
 			{
 				for (auto v: *Var.Value.Lst)
 				{
 					if (TestData(F, *v, Log))
 					{
 						return true;
 					}
 				}
 				break;
 			}
 			case GV_DOM:
 			{
 				// Probably an address field
 				LVariant n;
 				if (Var.Value.Dom->GetValue("Name", n))
 				{
 					if (TestData(F, n, Log))
 					{
 						return true;
 					}
 				}
 
 				if (Var.Value.Dom->GetValue("Email", n))
 				{
 					if (TestData(F, n, Log))
 					{
 						return true;
 					}
 				}
 				break;
 			}
 			case GV_STRING:
 			{
 				char *sVar = Var.Str();
 				char *sVal = Val.Str();
 				bool IsStr = ValidStr(sVar);
 				bool IsVal = ValidStr(sVal);
 				char *VarLog = Log ? LogPreview(sVar) : 0;
 				bool m = false;
 
 				switch (Op)
 				{
 					case OP_EQUAL:
 					{
 						if (!IsStr && !IsVal)
 						{
 							m = true;
 						}
 						else if (IsStr && IsVal)
 						{
 							m = _stricmp(sVal, sVar) == 0;
 						}
 
 						if (Log) Log->Print("\t\t\t'%s' == '%s' = %i\n", VarLog, sVal, m);
 						break;
 					}
 					case OP_LIKE:
 					{
 						m = MatchStr(sVal, sVar);
 						if (Log) Log->Print("\t\t\t'%s' like '%s' = %i\n", VarLog, sVal, m);
 						break;
 					}
 					case OP_CONTAINS:
 					{
 						if (IsVal && IsStr)
 						{
 							m = stristr(sVar, sVal) != 0;
 							if (Log) Log->Print("\t\t\t'%s' contains '%s' = %i\n", VarLog, sVal, m);
 						}
 						break;
 					}
 					case OP_STARTS_WITH:
 					{
 						if (IsVal && IsStr)
 						{
 							size_t Len = strlen(sVal);
 							m = _strnicmp(sVar, sVal, Len) == 0;
 							if (Log) Log->Print("\t\t\t'%s' starts with '%s' = %i\n", VarLog, sVal, m);
 						}
 						break;
 					}
 					case OP_ENDS_WITH:
 					{
 						if (IsVal && IsStr)
 						{
 							size_t SLen = strlen(sVar);
 							size_t VLen = strlen(sVal);
 							if (SLen >= VLen)
 							{
 								m = _strnicmp(sVar + SLen - VLen, sVal, VLen) == 0;
 								if (Log) Log->Print("\t\t\t'%s' ends with '%s' = %i\n", VarLog, sVal, m);
 							}
 							else
 							{
 								if (Log) Log->Print("\t\t\tEnds With Error: '%s' is shorter than '%s'\n", sVar, sVal);
 							}
 						}
 						else
 						{
 							if (Log) Log->Print("\t\t\tEnds With Error: invalid arguments\n");
 						}
 						break;
 					}
 				}
 
 				DeleteArray(VarLog);
 				return m;
 				break;
 			}
 			case GV_INT32:
 			{
 				// Convert Val to int
 				int Int = 0;
 				if (Val.Str())
 				{
 					Int = atoi(Val.Str());
 				}
 				else if (Val.Type == GV_INT32)
 				{
 					Int = Val.Value.Int; 
 				}
 				
 				int IntVal = Var.Value.Int;
 
 				switch (Op)
 				{
 					case OP_LIKE: // for lack anything better
 					case OP_EQUAL:
 					{
 						bool m = Int == IntVal;
 						if (Log) Log->Print("\t\t\t%i == %i = %i\n", Int, IntVal, m);
 						return m;
 					}
 					case OP_NOT_EQUAL:
 					{
 						bool m = Int != IntVal;
 						if (Log) Log->Print("\t\t\t%i != %i = %i\n", Int, IntVal, m);
 						return m;
 					}
 					case OP_LESS_THAN:
 					{
 						bool m = Int < IntVal;
 						if (Log) Log->Print("\t\t\t%i < %i = %i\n", Int, IntVal, m);
 						return m;
 					}
 					case OP_LESS_THAN_OR_EQUAL:
 					{
 						bool m = Int <= IntVal;
 						if (Log) Log->Print("\t\t\t%i <= %i = %i\n", Int, IntVal, m);
 						return m;
 					}
 					case OP_GREATER_THAN:
 					{
 						bool m = Int > IntVal;
 						if (Log) Log->Print("\t\t\t%i > %i = %i\n", Int, IntVal, m);
 						return m;
 					}
 					case OP_GREATER_THAN_OR_EQUAL:
 					{
 						bool m = Int >= IntVal;
 						if (Log) Log->Print("\t\t\t%i >= %i = %i\n", Int, IntVal, m);
 						return m;
 					}
 				}
 				break;
 			}
 			case GV_DATETIME:
 			{
 				LDateTime Temp;
 				LDateTime *DVal;
 				if (Val.Type == GV_DATETIME)
 				{
 					DVal = Val.Value.Date;
 				}
 				else if (Val.Type == GV_STRING)
 				{
 					Temp.Set(Val.Str());
 					DVal = &Temp;
 				}
 				else break;
 				
 				LDateTime *DVar = Var.Value.Date;
 
 				if (DVal && DVar)
 				{
 					bool Less = *DVar < *DVal;
 					bool Greater = *DVar > *DVal;
 					bool Equal = !Less && !Greater;
 					char LogVal[64];
 					char LogVar[64];
 					if (Log)
 					{
 						DVal->Get(LogVal, sizeof(LogVal));
 						DVar->Get(LogVar, sizeof(LogVar));
 					}
 
 					switch (Op)
 					{
 						case OP_LIKE:
 						case OP_EQUAL:
 						{
 							if (Log) Log->Print("\t\t\t%s = %s == %i\n", LogVar, LogVal, Equal);
 							return Equal;
 						}
 						case OP_NOT_EQUAL:
 						{
 							if (Log) Log->Print("\t\t\t%s != %s == %i\n", LogVar, LogVal, !Equal);
 							return !Equal;
 						}
 						case OP_LESS_THAN:
 						{
 							if (Log) Log->Print("\t\t\t%s <= %s == %i\n", LogVar, LogVal, Less);
 							return Less;
 						}
 						case OP_LESS_THAN_OR_EQUAL:
 						{
 							if (Log) Log->Print("\t\t\t%s < %s == %i\n", LogVar, LogVal, Less || Equal);
 							return Less || Equal;
 						}
 						case OP_GREATER_THAN:
 						{
 							if (Log) Log->Print("\t\t\t%s > %s == %i\n", LogVar, LogVal, Greater);
 							return Greater;
 						}
 						case OP_GREATER_THAN_OR_EQUAL:
 						{
 							if (Log) Log->Print("\t\t\t%s >= %s == %i\n", LogVar, LogVal, Greater || Equal);
 							return Greater || Equal;
 						}
 					}
 				}
 				break;
 			}
 			default:
 			{
 				if (Log) Log->Print("\t\t\tUnknown data type %i.\n", Var.Type);
 				break;
 			}
 		}
 	}
 
 	return false;
 }
 
 ThingUi *FilterCondition::DoUI(MailContainer *c)
 {
 	return NULL;
 }
 
 //////////////////////////////////////////////////////////////
 // #define OPT_Action	"Action"
 #define OPT_Type		"Type"
 #define OPT_Arg1		"Arg1"
 
 #define IDC_TYPE_CBO	2000
 #define IDC_ARG_EDIT	2001
 #define IDC_BROWSE_ARG	2002
 
 FilterAction::FilterAction(LDataStoreI *Store)
 {
 	Type = ACTION_MOVE_TO_FOLDER;
 	TypeCbo = 0;
 	ArgEdit = 0;
 	Btn = 0;
 }
 
 FilterAction::~FilterAction()
 {
 	DeleteObj(TypeCbo);
 	DeleteObj(ArgEdit);
 	DeleteObj(Btn);
 }
 
 int FilterAction::OnNotify(LViewI *c, LNotification n)
 {
 	switch (c->GetId())
 	{
 		case IDC_TYPE_CBO:
 		{
 			Type = (FilterActionTypes) c->Value();
 			break;
 		}
 		case IDC_ARG_EDIT:
 		{
 			Arg1.Reset(NewStr(c->Name()));
 			break;
 		}
 		case IDC_BROWSE_ARG:
 		{
 			if (ArgEdit)
 				ArgEdit->Name(Arg1);
 			break;
 		}
 	}
 
 	return 0;
 }
 
 
 void FilterAction::OnMeasure(LPoint *Info)
 {
 	LListItem::OnMeasure(Info);
 	if (Select())
 		Info->y += 2;
 }
 
 bool FilterAction::Select()
 {
 	return LListItem::Select();
 }
 
 void FilterAction::OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c)
 {
 	LListItem::OnPaintColumn(Ctx, i, c);
 
 	if (LListItem::Select() && !TypeCbo && !ArgEdit)
 		Select(true);
 	else if (i == 0 && TypeCbo)
 		TypeCbo->SetPos(*GetPos(i));
 	else if (i == 1 && ArgEdit)
 		ArgEdit->SetPos(*GetPos(i));
 	else if (i == 2 && Btn)
 		Btn->SetPos(*GetPos(i));
 }
 
 void FilterAction::Select(bool b)
 {
 	LListItem::Select(b);
 
 	if (b)
 	{
 		LList *Lst = LListItem::GetList();
 		if (Lst && Lst->IsAttached())
 		{
 			LRect *r = GetPos(0);
 
 			if (!TypeCbo)
 			{
 				TypeCbo = new LCombo(IDC_TYPE_CBO, r->x1, r->y1, r->X(), r->Y(), 0);
 				for (int i=0; ActionNames[i].Id; i++)
 					TypeCbo->Insert(LLoadString(ActionNames[i].Id));
 				TypeCbo->Attach(Lst);
 			}
 			TypeCbo->Value(Type);
 			TypeCbo->SetPos(*r);
 
 			r = GetPos(1);
 			if (!ArgEdit)
 			{
 				ArgEdit = new LEdit(IDC_ARG_EDIT, r->x1, r->y1, r->X(), r->Y(), 0);
 				ArgEdit->Attach(Lst);
 			}
 			ArgEdit->Name(Arg1);
 			ArgEdit->SetPos(*r);
 
 			r = GetPos(2);
 			if (!Btn)
 			{
 				Btn = new LButton(IDC_BROWSE_ARG, r->x1, r->y1, r->X(), r->Y(), "...");
 				Btn->Attach(Lst);
 			}
 			Btn->SetPos(*r);
 		}
 	}
 	else
 	{
 		DeleteObj(TypeCbo);
 		DeleteObj(ArgEdit);
 		DeleteObj(Btn);
 	}
 }
 
 const char *FilterAction::GetText(int Col)
 {
 	switch (Col)
 	{
 		case 0:
 			return (char*)LLoadString(ActionNames[Type].Id);
 			break;
 		case 1:
 			return Arg1;
 			break;
 		case 2:
 			break;
 	}
 
 	return 0;
 }
 
 bool FilterAction::Get(LXmlTag *t)
 {
 	if (!t) return false;
 
 	// Obj -> XML
 	t->SetAttr(OPT_Type, Type);
 	t->SetAttr(OPT_Arg1, Arg1);
 	return true;
 }
 
 bool FilterAction::Set(LXmlTag *t)
 {
 	if (!t) return false;
 
 	// XML -> Obj
 	Type = (FilterActionTypes) t->GetAsInt(OPT_Type);
 	Arg1.Reset(NewStr(t->GetAttr(OPT_Arg1)));
 	return true;
 }
 
 LDataPropI &FilterAction::operator =(LDataPropI &p)
 {
 	FilterAction *c = dynamic_cast<FilterAction*>(&p);
 	if (c)
 	{
 		Type = c->Type;
 		Arg1.Reset(NewStr(c->Arg1));
 	}
 
 	return *this;
 }
 
 ThingUi *FilterAction::DoUI(MailContainer *c)
 {
 	return 0;
 }
 
 const char *GetFileName(const char *Path)
 {
 	if (Path)
 	{
 		auto d = strrchr(Path, DIR_CHAR);
 		if (d)
 			return d + 1;
 		else
 			return Path;
 	}
 	
 	return 0;
 }
 
 bool CollectAttachmentsByPattern(Mail *m, char *Pattern, List<Attachment> &Files)
 {
 	Files.Empty();
 	
 	if (m)
 	{
 		List<Attachment> Attachments;
 		if (m->GetAttachments(&Attachments))
 		{
 			LToken p(Pattern, " ,;");
 			for (auto a: Attachments)
 			{
 				bool Match = true;
 				for (unsigned i=0; Match && i<p.Length(); i++)
 				{
 					auto d = GetFileName(a->GetName());
 					if (d)
 						Match = MatchStr(p[i], d);
 				}				
 
 				if (Match)
 					Files.Insert(a);
 			}
 		}
 	}
 	
 	return Files[0] != 0;
 }
 
 Mail *GetTemplateMail(ScribeWnd *App, char *TemplateMsgId)
 {
 	ScribeFolder *Templates = App->GetFolder(FOLDER_TEMPLATES);
 	if (Templates)
 	{
 		// Mail *Template = 0;
 		for (auto t: Templates->Items)
 		{
 			Mail *m = t->IsMail();
 			if (m)
 			{
 				auto MsgId = m->GetMessageId();
 				if (MsgId && strcmp(MsgId, TemplateMsgId) == 0)
 				{
 					return m;
 					break;
 				}
 			}
 		}
 	}
 
 	return 0;
 }
 
 class FilterScribeDom : public ScribeDom
 {
 public:
 	FilterScribeDom(ScribeWnd *a) : ScribeDom(a)
 	{
 	}
 
 	bool GetVariant(const char *Name, LVariant &Value, const char *Array = 0)
 	{
 		if (!Name)
 			return false;
 
 		if (!_stricmp(Name, "file"))
 		{
 			LVariant v;
 			if (!GetValue(Array, v))
 				return false;
 
 			char p[MAX_PATH_LEN], fn[32];
 			do
 			{
 				sprintf_s(fn, sizeof(fn), "file_%d.tmp", LRand());
 				LMakePath(p, sizeof(p), ScribeTempPath(), fn);
 			}
 			while (LFileExists(p));
 
 			LFile f;
 			if (f.Open(p, O_WRITE))
 			{
 				switch (v.Type)
 				{
 					case GV_INT32:
 						f.Print("%i", v.Value.Int);
 						break;
 					case GV_INT64:
 						f.Print(LPrintfInt64, v.Value.Int64);
 						break;
 					case GV_BOOL:
 						f.Print("%s", v.Value.Bool ? "true" : "false");
 						break;
 					case GV_DOUBLE:
 						f.Print("%f", v.Value.Dbl);
 						break;
 
 					case GV_STRING:
 					case GV_WSTRING:
 						f.Print("%s", v.Str());
 						break;
 
 					case GV_BINARY:
 						f.Write(v.Value.Binary.Data, v.Value.Binary.Length);
 						break;
 
 					case GV_DATETIME:
 						v.Value.Date->Get(fn, sizeof(fn));
 						f.Write(fn, strlen(fn));
 						break;
 
 					default:
 						f.Print("Unsupported type.");
 						break;
 				}
 
 				f.Close();
 
 				Value = p;
 				return true;
 			}
 		}
 		
 		return ScribeDom::GetVariant(Name, Value, Array);
 	}
 };
 
 bool FilterAction::Do(Filter *F, ScribeWnd *App, Mail *&m, LStream *Log)
 {
     bool Status = false;
     
     if (!F || !App || !m)
     {
         LAssert(!"Param error.");
         return false;
     }
     
 	switch (Type)
 	{
 		case ACTION_MOVE_TO_FOLDER:
 		{
 			ScribeFolder *Folder = App->GetFolder(Arg1);
 			if (Folder)
 			{
 				LArray<Thing*> Items;
 				Items.Add(m);
 				Status = Folder->MoveTo(Items);
 				m = Items[0]->IsMail();
 
 		        if (Log)
     		        Log->Print("\tACTION_MOVE_TO_FOLDER(%s) = %i.\n", Arg1.Get(), Status);
 			}
 			else if (Log)
 			{
 			    Log->Print("\tACTION_MOVE_TO_FOLDER(%s) failed, folder missing.\n", Arg1.Get());
 			}
 			break;
 		}
 		case ACTION_COPY:
 		{
 			ScribeFolder *Folder = App->GetFolder(Arg1);
 			if (Folder)
 			{				
 				LArray<Thing*> Items;
 				Items.Add(m);
 				Status = Folder->MoveTo(Items, true);
 				m = Items[0]->IsMail();
 
 		        if (Log)
     		        Log->Print("\tACTION_COPY(%s) = %i.\n", Arg1.Get(), Status);
 			}
 			else if (Log)
 			{
 			    Log->Print("\tACTION_COPY(%s) failed, folder missing.\n", Arg1.Get());
 			}
 			break;
 		}
 		case ACTION_EXPORT:
 		{
 			LFile::Path p(Arg1);
 			if (!p.IsFolder())
 			{
 				if (Log)
 					Log->Print("\tACTION_EXPORT(%s) failed, folder missing.\n", Arg1.Get());
 				break;
 			}
 		
 			auto Fn = m->GetDropFileName();
 			p += LGetLeaf(Fn);
 			
 			LAutoPtr<LFile> out(new LFile);
 			if (!out->Open(p, O_WRITE))
 			{
 				if (Log)
 					Log->Print("\tACTION_EXPORT(%s) failed: couldn't open file: %s.\n", Arg1.Get(), p.GetFull().Get());
 				break;
 			}
 			
 			if (!m->Export(m->AutoCast(out), sMimeMessage))
 			{
 				if (Log)
 					Log->Print("\tACTION_EXPORT(%s) failed: couldn't export file.\n", Arg1.Get());
 			}
 			break;
 		}
 		case ACTION_DELETE:
 		{
 			bool Local = ValidStr(Arg1) ? stristr(Arg1, "local") != 0 : true;
 			bool Server = stristr(Arg1, "server") != 0;
 
 			if (Server)
 			{
 				ScribeAccount *a = m->GetAccountSentTo();
 				if (!a)
 				    break;
 
 				auto Uid = m->GetServerUid();
 				if (Uid.Str())
 				{
 					if (Log)
 					    Log->Print("\tACTION_DELETE - Setting '%s' to be deleted on the server (Uid=%s)\n", m->GetSubject(), Uid.Str());
 					    
 					a->Receive.DeleteAsSpam(Uid.Str());
 					m->SetServerUid(Uid = NULL);
 				}
 				else
 				{
 					LVariant Uid;
 					if (m->GetValue("InternetHeader[X-UIDL]", Uid))
 					{
 						if (Log)
 					        Log->Print("\tACTION_DELETE - Setting '%s' to be deleted on the server (Uid=%s)\n", m->GetSubject(), Uid.Str());
 					        
 						a->Receive.DeleteAsSpam(Uid.Str());
 					}
 				}
 			}
 
 			if (Local)
 			{
 				bool DeleteStatus = m->OnDelete();
 				if (Log)
 			        Log->Print("\tACTION_DELETE(%s) status %i.\n", Arg1.Get(), DeleteStatus);
 
 				/*
 				ScribeFolder *Folder = App->GetFolder(FOLDER_TRASH);
 				if (Folder)
 				{
 					Thing *t = m;
 					Status = Folder->MoveTo(t);
 					m = t->IsMail();
 
                     if (Log)
 			            Log->Print("\tACTION_DELETE(%s) = %i.\n", Arg1.Get(), Status);
 				}
 			    else if (Log)
 			    {
 			        Log->Print("\tACTION_DELETE(%s) failed, trash missing.\n", Arg1.Get());
 			    }
 			    */
 			}
 			break;
 		}
 		case ACTION_SET_READ:
 		{
 			bool Read = true;
 			bool NotNew = false;
 			
 			if (ValidStr(Arg1))
 			{
 				if (IsDigit(*Arg1))
 				{
 					// boolean number
 					Read = atoi(Arg1) != 0;
 				}
 				else if (stristr(Arg1, "true"))
 				{
 					Read = true;
 				}
 				else if (stristr(Arg1, "false"))
 				{
 					Read = false;
 				}
 				
 				if (stristr(Arg1, "notnew"))
 				{
 					NotNew = true;
 				}
 			}
 
 			int f = m->GetFlags();
 
 			if (Read)
 				SetFlag(f, MAIL_READ);
 			else
 				ClearFlag(f, MAIL_READ);
 
 			m->SetFlags(f);
 			
 			if (Log)
 			    Log->Print("\tACTION_SET_READ(%s)\n", Arg1.Get());
 			
 			if (NotNew)
 			{
 				List<Mail> Objs;
 				Objs.Insert(m);
 				App->OnNewMail(&Objs, false);
 			}
 			break;
 		}
 		case ACTION_LABEL:
 		{
 		    LVariant v;
 		    if (!F || !F->GetValue(Arg1, v))
 				v = Arg1;
 
 		    m->SetVariant("Label", v);
 			break;
 		}
 		case ACTION_EMPTY_FOLDER:
 		{
 			if (F->App && Arg1)
 			{
 				ScribeFolder *Folder = F->App->GetFolder(Arg1);
 				if (Folder)
 				{
 					Folder->LoadThings();
 
 					List<Mail> m;
 
 					Thing *t;
 					while ((t = Folder->Items[0]))
 					{
 						if (t->IsMail())
 						{
 							m.Insert(t->IsMail());
 						}
 
 						if (Folder->DeleteThing(t))
 						{
 							DeleteObj(t);
 						}
 					}
 
 					F->App->OnNewMail(&m, false);
 					Folder->OnUpdateUnRead(0, true);
 
 			        if (Log)
 			            Log->Print("\tACTION_EMPTY_FOLDER(%s)\n", Arg1.Get());
 				}
 			}
 			break;
 		}
 		case ACTION_MARK_AS_SPAM:
 		{
 			m->DeleteAsSpam(App);
 			break;
 		}
 		case ACTION_PRINT:
 		{
 			LPrinter Info;
 
 	        #ifdef _MSC_VER
 			#pragma message ("Warning: ACTION_PRINT not implemented.")
 	        #endif
 			/* FIXME
 			if (Info.Serialize(Arg1, false))
 			{
 				App->ThingPrint(m, &Info);
 			}
 			*/
 			break;
 		}
 		case ACTION_PLAY_SOUND:
 		{
 			LPlaySound(Arg1, true); 
 			break;
 		}
 		case ACTION_EXECUTE:
 		{
 			FilterScribeDom dom(App);
 			dom.Email = m;
 			dom.Fil = F;
 			LAutoString cmd(ScribeInsertFields(Arg1, &dom));
 			if (cmd)
 			{
 				const char *s = cmd;
 				LAutoString exe(LTokStr(s));
 				LExecute(exe, s);
 			}
 			break;
 		}
 		case ACTION_OPEN:
 		{
 			m->DoUI();
 			break;
 		}
 		case ACTION_MARK:
 		{
 			if (_stricmp(Arg1, "false") == 0)
 			{
 				// unmark the item...
 				m->SetMarkColour(0);
 			}
 			else
 			{
 				// parse out RGB
 				LToken T(Arg1, ",");
 				if (T.Length() == 3)
 				{
 					// we have an RGB, so set it baby
 					uint32_t c = Rgb32(atoi(T[0]), atoi(T[1]), atoi(T[2]));
 					m->SetMarkColour(c);
 				}
 				else
 				{
 					uint32_t c = Rgb32(0, 0, 255);
 					m->SetMarkColour(c);
 				}
 			}
 			break;
 		}
 		case ACTION_REPLY:
 		{
 			if (Arg1)
 			{
 				const char *s = Arg1;
 				char *TemplateMsgId = LTokStr(s);
 				SkipSep(s);
 				char *ReplyAll = LTokStr(s);
 				SkipSep(s);
 				char *MarkReplied = LTokStr(s);
 				
 				Mail *Template = GetTemplateMail(App, TemplateMsgId);
 				if (Template)
 				{
 					Thing *t = App->CreateThingOfType(MAGIC_MAIL);
 					if (t)
 					{
 						Mail *n = t->IsMail();
 						if (n)
 						{
 							bool MarkOriginal = MarkReplied && atoi(MarkReplied);
 
 							// Prepare mail...
 							n->OnReply(m, ValidStr(ReplyAll)?atoi(ReplyAll)!=0:false, MarkOriginal);
 							n->SetFlags(m->GetFlags() | MAIL_READY_TO_SEND);
 							
 							if (ValidStr(Template->GetSubject()))
 							{
 								n->SetSubject(Template->GetSubject());
 							}
 							
 							n->SetBody(ScribeInsertFields(Template->GetBody(), F));
 
 							// Save it...
 							n->Save(0);
 							
 							// Send it... if not offline.
 							LVariant Offline;
 							App->GetOptions()->GetValue(OPT_WorkOffline, Offline);
 							if (!Offline.CastInt32())
 							{
 								App->PostEvent(M_COMMAND, IDM_SEND_MAIL, 0);
 							}
 						}
 						else DeleteObj(t);
 					}
 				}
 				
 				DeleteArray(TemplateMsgId);
 				DeleteArray(ReplyAll);
 				DeleteArray(MarkReplied);
 			}
 			break;
 		}
 		case ACTION_FORWARD:
 		{
 			const char *s = Arg1;
 			char *TemplateMsgId = LTokStr(s);
 			SkipSep(s);
 			char *Email = LTokStr(s);
 			SkipSep(s);
 			char *Attach = LTokStr(s);
 			SkipSep(s);
 			char *MarkForwarded = LTokStr(s);
 
 			bool Attachments = Attach ? atoi(Attach)!=0 : true;
 			if (ValidStr(Email))
 			{
 				Thing *t = App->CreateThingOfType(MAGIC_MAIL);
 				if (t)
 				{
 					Mail *n = t->IsMail();
 					if (n)
 					{
 						bool MarkOriginal = MarkForwarded && atoi(MarkForwarded);
 						
 						// Setup email...
 						Mail *Template = TemplateMsgId ? GetTemplateMail(App, TemplateMsgId) : 0;
 						if (Template)
 						{
 							n->SetSubject(Template->GetSubject());
 							if (ValidStr(Template->GetBody()))
 							{
 								n->SetBody(ScribeInsertFields(Template->GetBody(), F));
 							}
 
 							if (Attachments)
 							{
 								List<Attachment> Att;
 								m->GetAttachments(&Att);
 								for (auto a: Att)
 								{
 									n->AttachFile(new Attachment(App, a));
 								}
 							}
 						}
 						else
 						{
 							n->OnForward(m, MarkOriginal, Attachments);
 						}
 
 						n->SetFlags(m->GetFlags() | MAIL_READY_TO_SEND);
 
 						LDataPropI *Addr = n->GetTo()->Create(n->GetObject()->GetStore());
 						if (Addr)
 						{
 							LVariant v;
 							if (F->GetValue(Email, v))
 							{
 								Addr->SetStr(FIELD_EMAIL, v.Str());
 							}
 							else
 							{
 								Addr->SetStr(FIELD_EMAIL, Email);
 							}
 							n->GetTo()->Insert(Addr);
 						}
 						
 						// Save it...
 						n->Save(0);
 						
 						// Send it... if not offline.
 						LVariant Offline;
 						App->GetOptions()->GetValue(OPT_WorkOffline, Offline);
 						if (!Offline.CastInt32())
 						{
 							App->PostEvent(M_COMMAND, IDM_SEND_MAIL, 0);
 						}
 					}
 					else DeleteObj(t);
 				}
 			}
 			
 			DeleteArray(Email);
 			DeleteArray(Attach);
 			DeleteArray(MarkForwarded);			
 			break;
 		}
 		case ACTION_BOUNCE:
 		{
 			const char *s = Arg1;
 			char *Email = LTokStr(s);
 			SkipSep(s);
 			char *Attach = LTokStr(s);
 			SkipSep(s);
 			char *Mark = LTokStr(s);
 
 			if (ValidStr(Email))
 			{
 				Thing *t = App->CreateThingOfType(MAGIC_MAIL);
 				if (t)
 				{
 					Mail *n = t->IsMail();
 					if (n)
 					{
 						bool Attachments = Attach && atoi(Attach);
 						bool MarkOriginal = Mark && atoi(Mark);
 						
 						// Setup email...
 						n->OnBounce(m, MarkOriginal, Attachments);
 						n->SetFlags(m->GetFlags() | MAIL_READY_TO_SEND);
 
 						LDataPropI *Addr = n->GetTo()->Create(n->GetObject()->GetStore());
 						if (Addr)
 						{
 							LVariant v;
 							if (F->GetValue(Email, v))
 							{
 								Addr->SetStr(FIELD_EMAIL, v.Str());
 							}
 							else
 							{
 								Addr->SetStr(FIELD_EMAIL, Email);
 							}
 							n->GetTo()->Insert(Addr);
 						}
 						
 						// Save it...
 						n->Save(0);
 						
 						// Send it... if not offline.
 						LVariant Offline;
 						App->GetOptions()->GetValue(OPT_WorkOffline, Offline);
 						if (!Offline.CastInt32())
 						{
 							App->PostEvent(M_COMMAND, IDM_SEND_MAIL, 0);
 						}
 					}
 					else DeleteObj(t);
 				}
 			}
 			
 			DeleteArray(Email);
 			DeleteArray(Attach);
 			DeleteArray(Mark);
 			break;
 		}
 		case ACTION_SAVE_ATTACHMENTS:
 		{
 			const char *arg = Arg1;
 			char *Dir = LTokStr(arg);
 			SkipSep(arg);
 			char *Types = LTokStr(arg);
 
 			List<Attachment> Files;
 			if (CollectAttachmentsByPattern(m, Types, Files))
 			{
 				for (auto a: Files)
 				{
 					auto d = GetFileName(a->GetName());
 					if (d)
 					{
 						char Path[256];
 						LMakePath(Path, sizeof(Path), Dir, d);
 						a->SaveTo(Path);
 					}
 				}
 			}
 
 			DeleteArray(Dir);
 			DeleteArray(Types);
 			break;
 		}
 		case ACTION_DELETE_ATTACHMENTS:
 		{
 			List<Attachment> Files;
 			if (CollectAttachmentsByPattern(m, Arg1, Files))
 			{
 				for (auto a: Files)
 				{
 					m->DeleteAttachment(a);
 				}
 			}
 			break;
 		}
 		case ACTION_CHANGE_CHARSET:
 		{
 			m->SetBodyCharset(Arg1);
 			break;
 		}
 	}
 
 	return Status;
 }
 
 int CsCmp(LCharset **a, LCharset **b)
 {
 	return _stricmp((*a)->Charset, (*b)->Charset);
 }
 
 void FilterAction::DescribeHtml(Filter *Flt, LStream &s)
 {
 	s.Print("%s ", GetText(0));
 	switch (Type)
 	{
 		case ACTION_MOVE_TO_FOLDER:
 		{
 			ScribeFolder *Folder = Flt->App->GetFolder(Arg1);
 			if (Folder)
 				s.Print("\"%s\"\n", Arg1.Get());
 			else
 				s.Print("\"<span class=error>%s</span>\"\n", Arg1.Get());
 			break;
 		}
 		case ACTION_DELETE:
 			break;
 		case ACTION_PRINT:
 			break;
 		case ACTION_PLAY_SOUND:
 			break;
 		case ACTION_OPEN:
 			break;
 		case ACTION_EXECUTE:
 			break;
 		case ACTION_MARK:
 			break;
 		case ACTION_SET_READ:
 			break;
 		case ACTION_LABEL:
 			break;
 		case ACTION_EMPTY_FOLDER:
 			break;
 		case ACTION_MARK_AS_SPAM:
 			break;
 		case ACTION_REPLY:
 			break;
 		case ACTION_FORWARD:
 			break;
 		case ACTION_BOUNCE:
 			break;
 		case ACTION_SAVE_ATTACHMENTS:
 			break;
 		case ACTION_DELETE_ATTACHMENTS:
 			break;
 		case ACTION_CHANGE_CHARSET:
 			break;
 		case ACTION_COPY:
 			break;
 		case ACTION_EXPORT:
 			break;
 	}
 }
 
 void FilterAction::Browse(ScribeWnd *App, LView *Parent)
 {
 	if (!Parent) return;
 
 	switch (Type)
 	{
 		default:
 			LAssert(0);
 			break;
 		case ACTION_MOVE_TO_FOLDER:
 		case ACTION_COPY:
 		case ACTION_EMPTY_FOLDER:
 		{
 			auto Dlg = new FolderDlg(Parent, App, MAGIC_MAIL);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 					Arg1.Reset(NewStr(Dlg->Get()));
 				delete dlg;
 			});
 			break;
 		}
 		case ACTION_EXPORT:
 		{
 			auto s = new LFileSelect(Parent);
 			s->OpenFolder([&](auto dlg, auto status)
 			{
 				if (status)
 					Arg1.Reset(NewStr(s->Name()));
 				delete dlg;
 			});
 			break;
 		}
 		case ACTION_DELETE:
 		{
 			auto RClick = new LSubMenu;
 			if (RClick)
 			{
 				RClick->AppendItem("Local (default)", IDM_LOCAL, true);
 				RClick->AppendItem("From Server", IDM_SERVER, true);
 				RClick->AppendItem("Local and from Server", IDM_LOCAL_AND_SERVER, true);
 
 				LMouse m;
 				if (Parent->GetMouse(m, true))
 				{
 					switch (RClick->Float(Parent, m.x, m.y))
 					{
 						case IDM_LOCAL:
 						{
 							Arg1.Reset(NewStr("local"));
 							break;
 						}
 						case IDM_SERVER:
 						{
 							Arg1.Reset(NewStr("server"));
 							break;
 						}
 						case IDM_LOCAL_AND_SERVER:
 						{
 							Arg1.Reset(NewStr("local,server"));
 							break;
 						}
 					}
 				}
 
 				DeleteObj(RClick);
 			}
 			break;
 		}
 		case ACTION_OPEN:
 		{
 			// no configuration
 			break;
 		}
 		case ACTION_SET_READ:
 		{
 			auto RClick = new LSubMenu;
 			if (RClick)
 			{
 				RClick->AppendItem("Read", IDM_TRUE, true);
 				RClick->AppendItem("Unread", IDM_FALSE, true);
 				RClick->AppendItem("Unread But Not New", IDM_NOTNEW, true);
 
 				LMouse m;
 				if (Parent->GetMouse(m, true))
 				{
 					switch (RClick->Float(Parent, m.x, m.y))
 					{
 						case IDM_TRUE:
 						{
 							Arg1.Reset(NewStr("true"));
 							break;
 						}
 						case IDM_FALSE:
 						{
 							Arg1.Reset(NewStr("false"));
 							break;
 						}
 						case IDM_NOTNEW:
 						{
 							Arg1.Reset(NewStr("false,notnew"));
 							break;
 						}
 					}
 				}
 
 				DeleteObj(RClick);
 			}
 			break;
 		}
 		case ACTION_MARK:
 		{
 			auto RClick = new LSubMenu;
 			if (RClick)
 			{
 				BuildMarkMenu(RClick, MS_One, 0);
 				LMouse m;
 				if (Parent->GetMouse(m, true))
 				{
 					int Result = RClick->Float(Parent, m.x, m.y);
 					if (Result == IDM_UNMARK)
 					{
 						Arg1.Reset(NewStr("False"));
 					}
 					else if (Result >= IDM_MARK_BASE)
 					{
 						char s[32];
 						sprintf_s(s, sizeof(s),
 								"%i,%i,%i",
 								R32(MarkColours32[Result-IDM_MARK_BASE]),
 								G32(MarkColours32[Result-IDM_MARK_BASE]),
 								B32(MarkColours32[Result-IDM_MARK_BASE]));
 						Arg1.Reset(NewStr(s));
 					}
 				}
 			}
 			break;
 		}
 		case ACTION_PRINT:
 		{
 			LPrinter Info;
 			#ifdef _MSC_VER
 			#pragma message ("Warning: ACTION_PRINT not implemented.")
 			#endif
 			/*
 			Info.Serialize(Arg1, false);
 			if (Info.Browse(Parent))
 			{
 				Info.Serialize(Arg1, true);
 			}
 			*/
 			break;
 		}
 		case ACTION_PLAY_SOUND:
 		case ACTION_EXECUTE:
 		{
 			auto Select = new LFileSelect(Parent);
 
 			Select->Parent(Parent);
 			if (Type == ACTION_PLAY_SOUND)
 			{
 				Select->Type("Wave files", "*.wav");
 			}
 			else
 			{
 				Select->Type("Executables", "*.exe");
 				Select->Type("All Files", LGI_ALL_FILES);
 			}
 			Select->Name(Arg1);
 
 			Select->Open([this](auto dlg, auto id)
 			{
 				if (id)
 					Arg1.Reset(NewStr(dlg->Name()));
 				delete dlg;
 			});
 			break;
 		}
 		case ACTION_REPLY:
 		{
 			auto Dlg = new BrowseReply(App, Parent, Arg1);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 					Arg1.Reset(NewStr(Dlg->Arg));
 				delete dlg;
 			});
 			break;
 		}
 		case ACTION_FORWARD:
 		{
 			auto Dlg = new BrowseForward(App, Parent, Arg1, true);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 					Arg1.Reset(NewStr(Dlg->Arg));
 				delete dlg;
 			});
 			break;
 		}
 		case ACTION_BOUNCE:
 		{
 			auto Dlg = new BrowseForward(App, Parent, Arg1, false);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 					Arg1.Reset(NewStr(Dlg->Arg));
 				delete dlg;
 			});
 			break;
 		}
 		case ACTION_SAVE_ATTACHMENTS:
 		{
 			auto Dlg = new BrowseSaveAttach(App, Parent, Arg1);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id)
 					Arg1.Reset(NewStr(Dlg->Arg));
 				delete dlg;
 			});
 			break;
 		}
 		case ACTION_CHANGE_CHARSET:
 		{
 			auto s = new LSubMenu;
 			if (s)
 			{
 				LArray<LCharset*> Cs;
 				for (LCharset *c = LGetCsList(); c->Charset; c++)
 				{
 					Cs.Add(c);
 				}
 				Cs.Sort(CsCmp);
 				for (unsigned i=0; i<Cs.Length(); i++)
 				{
 					unsigned n = 1;
 					while (i + n < Cs.Length())
 					{
 						if (Cs[i + n]->Charset[0] != Cs[i]->Charset[0])
 							break;
 						n++;
 					}
 					if (n > 1)
 					{
 						char a[64];
 						char *One = LSeekUtf8(Cs[i]->Charset, 1);
 						ssize_t Len = One - Cs[i]->Charset;
 						memcpy(a, Cs[i]->Charset, Len);
 						strcpy_s(a + Len, sizeof(a) - Len, "...");
 
 						auto Sub = s->AppendSub(a);
 						if (Sub)
 						{
 							for (unsigned k=0; k<n; k++)
 							{
 								Sub->AppendItem(Cs[i+k]->Charset, i+k+1, Cs[i+k]->IsAvailable());
 							}
 
 							i += n - 1;
 						}
 					}
 					else
 					{
 						s->AppendItem(Cs[i]->Charset, i+1, Cs[i]->IsAvailable());
 					}
 				}
 
 				LMouse m;
 				Parent->GetMouse(m, true);
 				int Result = s->Float(Parent, m.x, m.y, true);
 				if (Result)
 				{
 					Result--;
 					if (Result >= 0 && Result < (int)Cs.Length())
 					{
 						Arg1.Reset(NewStr(Cs[Result]->Charset));
 					}
 				}
 
 				DeleteObj(s);
 			}
 			break;
 		}
 	}
 }
 
 ///////////////////////////////////////////////////////////////
 int Filter::MaxIndex = -1;
 
 Filter::Filter(ScribeWnd *window, LDataI *object) : Thing(window, object)
 {
 	DefaultObject(object);
 	d = new FilterPrivate;
 	Ui = 0;
 	Current = 0;
 
 	IgnoreCheckEvents = true;
 	ChkIncoming = new LListItemCheckBox(this, 2, GetIncoming()!=0);
 	ChkOutgoing = new LListItemCheckBox(this, 3, GetOutgoing()!=0);
 	ChkInternal = new LListItemCheckBox(this, 4, GetInternal()!=0);
 	IgnoreCheckEvents = false;
 }
 
 Filter::~Filter()
 {
 	Empty();
 	DeleteObj(d);
 }
 
 bool Filter::GetFormats(bool Export, LString::Array &MimeTypes)
 {
 	MimeTypes.Add(sTextXml);
 	return MimeTypes.Length() > 0;
 }
 
 char *Filter::GetDropFileName()
 {
 	if (!DropFileName)
 	{
 		auto Nm = GetName();
 		char f[256];
 		if (Nm)
 		{
 			LUtf8Ptr o(f);
 			for (LUtf8Ptr i(Nm); (uint32_t)i; i++)
 			{
 				if (!strchr(LGI_IllegalFileNameChars, (uint32_t)i))
 					o.Add(i);
 			}
 			o.Add(0);
 		}
 		else strcpy_s(f, sizeof(f), "Filter");
 		strcat_s(f, sizeof(f), ".xml");
 		DropFileName.Reset(NewStr(f));
 	}
 	return DropFileName;
 }
 
 bool Filter::GetDropFiles(LString::Array &Files)
 {
 	char Tmp[MAX_PATH_LEN];
 	LMakePath(Tmp, sizeof(Tmp), ScribeTempPath(), GetDropFileName());
 	LAutoPtr<LFile> Out(new LFile);
 	if (!Out->Open(Tmp, O_WRITE))
 		return false;
 
 	if (!Export(AutoCast(Out), sTextXml))
 		return false;
 
 	Files.Add(Tmp);
 	return true;
 }
 
 Thing::IoProgress Filter::Import(IoProgressImplArgs)
 {
 	if (Stricmp(mimeType, sTextXml) &&
 	    Stricmp(mimeType, sMimeXml))
 	    IoProgressNotImpl();
 
 	LXmlTree Tree;
 	LXmlTag r;
 	if (!Tree.Read(&r, stream))
 		IoProgressError("Xml parse error.");
 
 	if (!r.IsTag("Filter"))
 		IoProgressError("No filter tag.");
 
 	Empty();
 
 	LXmlTag *t = r.GetChildTag("Name");
 	if (t && t->GetContent())
 		SetName(t->GetContent());
 	SetIndex(r.GetAsInt("index"));
 
 	if ((t = r.GetChildTag(ELEMENT_CONDITIONS)))
 	{
 		LStringPipe p;
 		if (Tree.Write(t, &p))
 		{
 			LAutoString s(p.NewStr());
 			ConditionsCache.Reset();
 			SetConditionsXml(s);
 		}
 
 		if ((t = r.GetChildTag("Actions")))
 		{
 			LStringPipe p;
 			if (Tree.Write(t, &p))
 			{
 				LAutoString s(p.NewStr());
 				SetActionsXml(s);
 			}
 			else IoProgressError("Xml write failed.");
 		}
 	}
 	
 	IoProgressSuccess();
 }
 
 Thing::IoProgress Filter::Export(IoProgressImplArgs)
 {
 	if (Stricmp(mimeType, sMimeXml))
-		return Store3NotImpl;
-		
+		IoProgressNotImpl();
 
 	LXmlTag r("Filter");
 	LXmlTag *t;
 	if ((t = r.CreateTag("Name")))
 		t->SetContent(GetName());
 	r.SetAttr("index", GetIndex());
 
 	LAutoPtr<LXmlTag> Cond = Parse(false);
 	r.InsertTag(Cond.Release());
 	LAutoPtr<LXmlTag> Act = Parse(true);
 	r.InsertTag(Act.Release());
 	
 	LXmlTree tree;
 
-	return tree.Write(&r, stream) ? Store3Success : Store3Error;
+	if (!tree.Write(&r, stream))
+		IoProgressError("Failed to write xml.");
+
+	IoProgressSuccess();
 }
 
 /// This filters a list of email. The email will have it's NewEmail state set to
 /// one of three things:
 /// If the email is not filtered then:
 ///		Mail::NewEmailBayes
 /// If the email is filtered but not set to !NEW then:
 ///		Mail::NewEmailGrowl
 /// If the email is filtered AND set to !NEW then:
 ///		Mail::NewMailNone
 int Filter::ApplyFilters(LView *Parent, List<Filter> &Filters, List<Mail> &Email)
 {
 	int Status = 0;
 	ScribeWnd *App = Filters.Length() > 0 ? Filters[0]->App : NULL;
 	if (!App)
 		return 0;
 
 	bool Logging = App->LogFilterActivity();
 	LStream *LogStream = NULL;
 	if (Logging)
 		LogStream = App->ShowScriptingConsole();
 
 	LAutoPtr<LProgressDlg> Prog;
 	if (Parent && Prog.Reset(new LProgressDlg(Parent)))
 	{
 		Prog->SetRange(Email.Length());
 		Prog->SetDescription("Filtering...");
 		Prog->SetType("email");
 	}
 
 	for (auto m: Email)
 	{
 		bool Act = false;
 		bool Stop = false;
 
 		m->IncRef();
 		for (auto f: Filters)
 		{
 			if (Stop)
 				break;
 
 			if (f->Test(m, Stop, LogStream))
 			{
 				f->DoActions(m, Stop, LogStream);
 				Act = true;
 			}
 		}
 		
 		if (Act)
 		{
 			Status++;
 			if (m && m->NewEmail == Mail::NewEmailFilter)
 			{
 				m->NewEmail = Mail::NewEmailGrowl;
 			}
 		}
 		else if (m && m->NewEmail == Mail::NewEmailFilter)
 		{
 			m->NewEmail = Mail::NewEmailBayes;
 		}
 
 		m->DecRef();
 		m = NULL;
 
 		if (Prog)
 		{
 			Prog->Value(Prog->Value() + 1);
 			if (Prog->IsCancelled())
 				break;
 		}
 	}
 
 	return Status;
 }
 
 Filter *Filter::GetFilterAt(int Index)
 {
 	ScribeFolder *f = GetFolder();
 	if (f)
 	{
 		for (auto t: f->Items)
 		{
 			Filter *f = t->IsFilter();
 			if (f && f->GetIndex() == Index)
 			{
 				return f;
 			}
 		}
 	}
 
 	return 0;
 }
 
 enum TermType
 {
 	TermString,
 	TermVariant
 };
 
 class ExpTerm
 {
 public:
 	TermType Type;
 	LVariant Value;
 
 	ExpTerm(TermType t)
 	{
 		Type = t;
 	}
 };
 
 bool Filter::Evaluate(char *str, LVariant &v)
 {
 	char *BufStr = NewStr(str);
 	char *s = BufStr;
 	if (s)
 	{
 		List<ExpTerm> Terms;
 		const char *Ws = " \t\r\n";
 
 		while (s && *s)
 		{
 			while (*s && strchr(Ws, *s)) s++;
 			
 			if (*s && *s == '\"')
 			{
 				char *Start = ++s;
 				char *In = s;
 				char *Out = s;
 				while (*In)
 				{
 					if (In[0] == '\"')
 					{
 						if (In[1] == '\"')
 						{
 							// Quote
 							*Out++ = '\"';
 							In += 2;
 						}
 						else
 						{
 							// End of string
 							In++;
 							break;
 						}
 					}
 					else
 					{
 						*Out++ = *In++;
 					}
 				}
 				*Out++ = 0;
 				s = In;
 				
 				ExpTerm *t;
 				Terms.Insert(t = new ExpTerm(TermString));
 				if (t)
 				{
 					t->Value = Start;
 				}
 			}
 			else
 			{
 				char *Start = s;
 				while (*s && !strchr(Ws, *s)) s++;
 				while (*s && strchr(Ws, *s)) s++;
 				char *Src = NewStr(Start, s-Start);
 				if (Src)
 				{
 					ExpTerm *t;
 					Terms.Insert(t = new ExpTerm(TermVariant));
 					if (t)
 					{
 						if (GetValue(Start, t->Value))
 						{
 							switch (t->Value.Type)
 							{
 								default:
 									break;
 								case GV_BINARY:
 								case GV_LIST:
 								case GV_DOM:
 								case GV_VOID_PTR:
 								{
 									v = t->Value;
 									DeleteArray(BufStr);
 									DeleteArray(Src);
 									Terms.DeleteObjects();
 									return true;
 								}
 							}
 						}
 						else
 						{
 							t->Type = TermString;
 							t->Value = Src;
 						}
 					}
 
 					DeleteArray(Src);
 				}
 			}
 		}
 
 		LStringPipe Out;
 		auto It = Terms.begin();
 		ExpTerm *t = *It;
 		if (t)
 		{
 			if (Terms.Length() > 1)
 			{
 				// Collapse terms
 				for (; t; t=*(++It))
 				{
 					char Buf[128];
 
 					switch (t->Value.Type)
 					{
 						default:
 							break;
 						case GV_INT32:
 						{
 							sprintf_s(Buf, sizeof(Buf), "%i", t->Value.Value.Int);
 							Out.Push(Buf);
 							break;
 						}
 						case GV_INT64:
 						{
 							sprintf_s(Buf, sizeof(Buf), LPrintfInt64, t->Value.Value.Int64);
 							Out.Push(Buf);
 							break;
 						}
 						case GV_BOOL:
 						{
 							sprintf_s(Buf, sizeof(Buf), "%i", (int)t->Value.Value.Bool);
 							Out.Push(Buf);
 							break;
 						}
 						case GV_DOUBLE:
 						{
 							sprintf_s(Buf, sizeof(Buf), "%g", t->Value.Value.Dbl);
 							Out.Push(Buf);
 							break;
 						}
 						case GV_STRING:
 						{
 							if (t->Value.Str())
 								Out.Push(t->Value.Str());
 							break;
 						}
 						case GV_DATETIME:
 						{
 							t->Value.Value.Date->Get(Buf, sizeof(Buf));
 							Out.Push(Buf);
 							break;
 						}
 						case GV_BINARY:
 						case GV_LIST:
 						case GV_DOM:
 						case GV_NULL:
 						case GV_VOID_PTR:
 						{
 							break;
 						}
 					}
 				}
 
 				v.OwnStr(Out.NewStr());
 			}
 			else
 			{
 				v = t->Value;
 			}
 		}
 		
 		Terms.DeleteObjects();
 	}
 
 	DeleteArray(BufStr);
 	return true;
 }
 
 bool Filter::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Field = StrToDom(Name);
 
 	switch (Field)
 	{
 		case SdName:
 			SetName(Value.Str());
 			break;
 		case SdConditionsXml:
 		    ConditionsCache.Reset();
 			SetConditionsXml(Value.Str());
 			break;
 		case SdActionsXml:
 			SetActionsXml(Value.Str());
 			break;
 		default:
 			return false;
 	}
 
 	return true;
 }
 
 bool Filter::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType Method = StrToDom(MethodName);
 	switch (Method)
 	{
 		case SdAddCondition: // Type: (String Feild, String Op, String Value)
 		{
 			if (Args.Length() != 3)
 			{
 				LgiTrace("%s:%i - SdAddCondition: wrong number of parameters %i (expecting 3)\n", _FL, Args.Length());
 				break;
 			}
 			
 			const char *Field = Args[0]->Str();
 			const char *Op = Args[1]->Str();
 			const char *Value = Args[2]->Str();
 			if (!Field || !Op || !Value)
 			{
 				LgiTrace("%s:%i - SdAddCondition: Missing values.\n", _FL);
 				break;
 			}
 
 			LAutoPtr<LXmlTag> t = Parse(false);
 			LXmlTag *Cond;
 			if (!t || !t->IsTag(ELEMENT_CONDITIONS) || (Cond = t->Children[0]) == NULL)
 			{
 				LgiTrace("%s:%i - SdAddCondition: Failed to parse conditions.\n", _FL);
 				break;
 			}
 
 			if (!Cond->IsTag(ELEMENT_AND) && !Cond->IsTag(ELEMENT_OR))
 			{
 				LgiTrace("%s:%i - SdAddCondition: Unexpected root operator.\n", _FL);
 				break;
 			}
 			
 			// Check that the condition doesn't already exist...
 			for (auto c : Cond->Children)
 			{
 				if (c->IsTag(ELEMENT_CONDITION))
 				{
 					char *CFeild = c->GetAttr(ATTR_FIELD);
 					char *COp = c->GetAttr(ATTR_OP);
 					char *CVal = c->GetAttr(ATTR_VALUE);
 					if (!Stricmp(Field, CFeild) &&
 						!Stricmp(Op, COp) &&
 						!Stricmp(Value, CVal))
 					{
 						return true;
 					}
 				}
 			}
 			
 			LXmlTag *n = new LXmlTag(ELEMENT_CONDITION);
 			if (!n)
 			{
 				LgiTrace("%s:%i - SdAddCondition: Alloc failed.\n", _FL);
 				break;
 			}
 
 			n->SetAttr(ATTR_FIELD, Field);
 			n->SetAttr(ATTR_OP, Op);
 			n->SetAttr(ATTR_VALUE, Value);
 			Cond->InsertTag(n);
 			
 			LXmlTree tree;
 			LStringPipe p;
 			if (!tree.Write(t, &p))
 			{
 				LgiTrace("%s:%i - SdAddCondition: Failed to write XML.\n", _FL);
 				break;
 			}
 			
 			LAutoString a(p.NewStr());
 			ConditionsCache.Reset();
 			SetConditionsXml(a);
 			SetDirty(true);
 			
 			return true;
 		}
 		case SdAddAction: // Type: (String ActionName, String Value)
 		{
 			if (Args.Length() != 2)
 			{
 				LgiTrace("%s:%i - SdAddAction: wrong number of parameters %i (expecting 3)\n", _FL, Args.Length());
 				break;
 			}
 			
 			LString Action = Args[0]->CastString();
 			if (!Action)
 			{
 				LgiTrace("%s:%i - SdAddAction: Missing action name.\n", _FL);
 				break;
 			}
 			
 			FilterAction a(GetObject()->GetStore());
 			for (ActionName *an = ActionNames; an->Id; an++)
 			{
 				if (Action.Equals(an->Default))
 				{
 					a.Type = (FilterActionTypes) (an - ActionNames);
 					a.Arg1.Reset(NewStr(Args[1]->CastString()));
 					AddAction(&a);
 					return true;
 				}
 			}
 			
 			LgiTrace("%s:%i - SdAddAction: Action '%s' not found.\n", _FL, Action.Get());
 			return false;
 		}
 		case SdStopFiltering: // Type: ()
 		{
 			if (d->Stop)
 			{
 				*d->Stop = true;
 				return true;
 			}
 			else LgiTrace("%s:%i - No stop parameter to set.\n", _FL);
 			return true;
 		}
 		case SdDoActions: // Type: (Mail Object)
 		{
 			if (Args.Length() == 1)
 			{
 				LDom *d = Args[0]->CastDom();
 				Mail *m = dynamic_cast<Mail*>(d);
 				if (m)
 				{
 					bool Stop = false;
 					return DoActions(m, Stop);
 				}
 				else LgiTrace("%s:%i - DoActions: failed to cast arg1 to Mail object.\n", _FL);
 			}
 			else LgiTrace("%s:%i - DoActions is expecting 1 argument, not %i.\n", _FL, Args.Length());
 			return true;
 		}
 		default:
 			break;
 	}
 
 	return Thing::CallMethod(MethodName, ReturnValue, Args);
 }
 
 bool Filter::GetVariant(const char *Var, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Var);
 	switch (Fld)
 	{
 		case SdMail: // Type: Mail
 		{
 			if (!Current)
 				return false;
 
 			Value = *Current;
 			break;
 		}
 		case SdScribe: // Type: ScribeWnd
 		{
 			Value = (LDom*)App;
 			break;
 		}
 		case SdName: // Type: String
 		{
 			Value = GetName();
 			break;
 		}
 		case SdTestConditions: // Type: Bool
 		{
 			if (Current && *Current)
 			{
 				bool s;
 				bool &Stop = d->Stop ? *d->Stop : s;
 				Value = EvaluateXml(*Current, Stop, d->Log);
 			}
 			else return false;
 			break;
 		}
 		case SdType: // Type: Int32
 		{
 			Value = GetObject()->Type();
 			break;
 		}
 		case SdConditionsXml: // Type: String
 		{
 			Value = GetConditionsXml();
 			break;
 		}
 		case SdActionsXml: // Type: String
 		{
 			Value = GetActionsXml();
 			break;
 		}
 		case SdIndex: // Type: Int32
 		{
 			Value = GetIndex();
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 Thing &Filter::operator =(Thing &t)
 {
 	Filter *f = t.IsFilter();
 	if (f)
 	{
 		if (GetObject() && f->GetObject())
 		{
 			GetObject()->CopyProps(*f->GetObject());
 		}
 	}
 
 	return *this;
 }
 
 int Filter::Compare(LListItem *Arg, ssize_t Field)
 {
 	Filter *a = dynamic_cast<Filter*>(Arg);
 	if (a)
 	{
 		switch (Field)
 		{
 			case FIELD_FILTER_NAME:
 				return a && GetName() ? _stricmp(GetName(), a->GetName()) : -1;
 			case FIELD_FILTER_INDEX:
 				return GetIndex() - a->GetIndex();
 			case FIELD_FILTER_INCOMING:
 				return GetIncoming() - a->GetIncoming();
 			case FIELD_FILTER_OUTGOING:
 				return GetOutgoing() - a->GetOutgoing();
 		}
 	}
 	return 0;
 }
 
 int Filter::GetImage(int Flags)
 {
 	return ICON_FILTER;
 }
 
 void DisplayXml(LStream &s, char *xml)
 {
 	char *start = xml;
 	char *e;
 	for (e = xml; *e; e++)
 	{
 		if (*e == '<')
 		{
 			s.Write(start, e - start);
 			s.Print("&lt;");
 			start = e + 1;
 		}
 	}
 	s.Write(start, e - start);
 }
 
 void DescribeCondition(LStream &s, LXmlTag *t)
 {
 	int i = 0;
 	if (t->IsTag(ELEMENT_AND) || t->IsTag(ELEMENT_OR))
 	{
 		for (auto c: t->Children)
 		{
 			LStringPipe p;
 			DescribeCondition(p, c);
 			LAutoString a(p.NewStr());
 			if (i)
 				s.Print(" <span class=op>%s</span> ", t->GetTag());
 			s.Print("(%s)", a.Get());
 			i++;
 		}
 	}
 	else
 	{
 		// Condition
 		char *f = t->GetAttr(ATTR_FIELD);
 		char *v = t->GetAttr(ATTR_VALUE);
 		int Not = t->GetAsInt(ATTR_NOT) > 0;
 		const char *o = t->GetAttr(ATTR_OP);
 		if (o && IsDigit(*o))
 			o = OpNames[atoi(o)];
 		s.Print("%s<span class=var>%s</span> <span class=op>%s</span> \"%s\"", Not ? "!" : "", f, o, v);		
 	}
 }
 
 LAutoString Filter::DescribeHtml()
 {
 	LStringPipe p(256);
 	p.Print("<html><title><style>\n"
 			".error { color: red; font-weight: bold; }\n"
 			".op { color: blue; }\n"
 			".var { color: #800; }\n"
 			"pre { color: green; }\n"
 			"</style></title>\n"
 			"<body style='background: ThreeDFace;'>\n"
 			"Name: %s<br>\n", GetName());
 	p.Print("Incoming: %i<br>\n", GetIncoming());
 	p.Print("Outgoing: %i<br>\n", GetOutgoing());
 	
 	if (GetConditionsXml())
 	{
 		LAutoPtr<LXmlTag> r = Parse(false);
 		if (r && r->Children.Length())
 		{
 			p.Print("Conditions:<ul>\n");
 			for (auto c: r->Children)
 			{
 				p.Print("<li>");
 				DescribeCondition(p, c);
 			}
 			p.Print("</ul>\n");
 		}
 	}
 	
 	if (GetActionsXml())
 	{
 		LAutoPtr<LXmlTag> r = Parse(true);
 		if (r && r->Children.Length())
 		{
 			p.Print("Actions:<ul>\n");
 			for (auto c: r->Children)
 			{
 				if (!c->IsTag(ELEMENT_ACTION))
 					continue;
 
 				LAutoPtr<FilterAction> a(new FilterAction(GetObject()->GetStore()));
 				if (a->Set(c))
 				{
 					p.Print("<li> ");
 					a->DescribeHtml(this, p);
 				}
 			}
 			p.Print("</ul>\n");
 		}
 	}
 	
 	if (GetScript())
 	{
 		LXmlTree t;
 		LAutoString e(t.EncodeEntities(GetScript(), -1, "<>"));
 		p.Print("Script:<pre>%s</pre>\n", e.Get());
 	}
 	
 	p.Print("</body></html>\n");
 	return LAutoString(p.NewStr());
 }
 
 void Filter::Empty()
 {
 	if (GetObject())
 	{
 	    ConditionsCache.Reset();
 		SetConditionsXml(0);
 		SetName(0);
 	}
 }
 
 bool Filter::EvaluateTree(LXmlTag *n, Mail *m, bool &Stop, LStream *Log)
 {
 	bool Status = false;
 
 	if (n && n->GetTag() && m && m->GetObject())
 	{
 		if (n->IsTag(ELEMENT_AND))
 		{
 			if (Log) Log->Print("\tAnd {\n");
 			for (auto c: n->Children)
 			{
 				if (!EvaluateTree(c, m, Stop, Log))
 				{
 					if (Log) Log->Print("\t} (false)\n");
 					return false;
 				}
 			}
 			if (Log) Log->Print("\t} (true)\n");
 
 			Status = true;
 		}
 		else if (n->IsTag(ELEMENT_OR))
 		{
 			if (Log) Log->Print("\tOr {\n");
 			for (auto c: n->Children)
 			{
 				if (EvaluateTree(c, m, Stop, Log))
 				{
 					if (Log) Log->Print("\t} (true)\n");
 					return true;
 				}
 			}
 			if (Log) Log->Print("\t} (false)\n");
 		}
 		else if (n->IsTag(ELEMENT_CONDITION))
 		{
 			FilterCondition *c = new FilterCondition;
 			if (c)
 			{
 				if (!c->Set(n))
 				{
 					LAssert(0);
 				}
 				else
 				{
 					Status = c->Test(this, m, Log);
 					if (c->Not) Status = !Status;
 					if (Log)
 					{
 						Log->Print("\tResult=%i (not=%i)\n", Status, c->Not);
 					}
 				}
 
 				DeleteObj(c);
 			}
 		}
 		else LAssert(0);
 	}
 	else LAssert(0);
 
 	return Status;
 }
 
 bool FilterCondition::Set(LXmlTag *t)
 {
 	if (!t)
 		return false;
 
 	Source.Reset(NewStr(t->GetAttr(ATTR_FIELD)));
 	Value.Reset(NewStr(t->GetAttr(ATTR_VALUE)));
 	Not = t->GetAsInt(ATTR_NOT) > 0;
 
 	char *o = t->GetAttr(ATTR_OP);
 	if (o)
 	{
 		if (IsDigit(*o))
 			Op = atoi(o);
 		else
 		{
 			for (int i=0; OpNames[i]; i++)
 			{
 				if (!_stricmp(OpNames[i], o))
 				{
 					Op = i;
 					break;
 				}
 			}
 		}
 	}
 
 	return true;
 }
 
 bool Filter::EvaluateXml(Mail *m, bool &Stop, LStream *Log)
 {
 	bool Status = false;
 
 	if (ValidStr(GetConditionsXml()))
 	{
 	    if (!ConditionsCache)
 		    ConditionsCache = Parse(false);
 		if (ConditionsCache &&
 			ConditionsCache->Children.Length())
 			Status = EvaluateTree(ConditionsCache->Children[0], m, Stop, Log);
 	}
 
 	return Status;
 }
 
 bool Filter::Test(Mail *m, bool &Stop, LStream *Log)
 {
 	bool Status = false;
 
 	if (Log) Log->Print("Filter.Test '%s':\n", GetName());
 
 	Current = &m;
 	if (m && m->GetObject())
 	{
 		d->Stop = &Stop;
 		d->Log = Log;
 
 		if (ValidStr(GetScript()))
 		{
 			OnFilterScript(this, m, GetScript());
 		}
 		else if (ValidStr(GetConditionsXml()))
 		{
 			Status = EvaluateXml(m, Stop, Log);
 		}
 		else LAssert(0);
 
 		d->Stop = 0;
 		d->Log = 0;
 	}
 	Current = 0;
 
 	return Status;
 }
 
 bool Filter::DoActions(Mail *&m, bool &Stop, LStream *Log)
 {
 	if (!App || !m)
 		return false;
 
 	Current = &m;
 
 	LAutoPtr<LXmlTag> r = Parse(true);
 	if (r)
 	{
 		LArray<FilterAction*> Act;
 
 		for (auto c: r->Children)
 		{
 			if (c->IsTag(ELEMENT_ACTION))
 			{
 				FilterAction *a = new FilterAction(GetObject()->GetStore());
 				if (a)
 				{
 					if (a->Set(c))
 						Act.Add(a);
 					else
 						LAssert(!"Can't convert xml to action.");
 				}
 			}
 		}
 		
 
 		for (unsigned i=0; i<Act.Length() && m->GetObject(); i++)
 		{
 			FilterAction *a = Act[i];
 			a->Do(this, App, m, Log);
 		}
 
 		Act.DeleteObjects();
 	}
 
 	Current = 0;
 
 	if (GetStopFiltering())
 	{
 		Stop = true;
 	}
 	return true;
 }
 
 ThingUi *Filter::DoUI(MailContainer *c)
 {
 	if (!Ui)
 	{
 		MaxIndex = MAX(MaxIndex, GetIndex());
 		if (GetIndex() < 0)
 		{
 			SetIndex(++MaxIndex);
 		}
 
 		Ui = new FilterUi(this);
 	}
 
 	#if WINNATIVE
 	if (Ui) SetForegroundWindow(Ui->Handle());
 	#endif
 
 	return Ui;
 }
 
 LAutoPtr<LXmlTag> Filter::Parse(bool Actions)
 {
 	LAutoPtr<LXmlTag> Ret;
 	
 	auto RawXml = Actions ? GetActionsXml() : GetConditionsXml();
 	if (!RawXml)
 		return Ret;
 
 	LMemStream Xml(RawXml, strlen(RawXml), false);
 	LXmlTree t;
 	Ret.Reset(new LXmlTag);
 	if (!t.Read(Ret, &Xml))
 		Ret.Reset();
 
 	return Ret;
 }
 
 
 void Filter::AddAction(FilterAction *Action)
 {
 	if (!Action)
 		return;
 
 	LAutoPtr<LXmlTag> a = Parse(true);
 	if (!a)
 		a.Reset(new LXmlTag("Actions"));
 
 	LAutoPtr<LXmlTag> n(new LXmlTag(ELEMENT_ACTION));
 	if (!Action->Get(n))
 		return;
 
 	a->InsertTag(n.Release());
 
 	LXmlTree t;
 	LStringPipe p;
 	if (!t.Write(a, &p))
 		return;
 
 	LAutoString Xml(p.NewStr());
 	SetActionsXml(Xml);
 	SetDirty(true);
 }
 
 
 bool Filter::Save(ScribeFolder *Into)
 {
 	bool Status = false;
 
 	if (!Into)
 	{
 		Into = GetFolder();
 		if (!Into)
 		{
 			Into = App->GetFolder(FOLDER_FILTERS);
 		}
 	}
 	
 	if (Into)
 	{
 		SetParentFolder(Into);
 
 		if (ChkIncoming)
 			SetIncoming(ChkIncoming->Value()!=0);
 		if (ChkOutgoing)
 			SetOutgoing(ChkOutgoing->Value()!=0);
 		if (ChkInternal)
 			SetInternal(ChkInternal->Value()!=0);
 
 		Store3Status s = Into->WriteThing(this);
 		Status = s != Store3Error;
 		if (Status)
 			SetDirty(false);
 	}
 
 	return Status;
 }
 
 void Filter::OnPaint(ItemPaintCtx &Ctx)
 {
 	LListItem::OnPaint(Ctx);
 }
 
 void Filter::OnMouseClick(LMouse &m)
 {
 	LListItem::OnMouseClick(m);
 
 	if (m.Double())
 	{
 		// open the UI for the Item
 		DoUI();
 	}
 	else if (m.Right())
 	{
 		// open the right click menu
 		auto RClick = new LSubMenu;
 		if (RClick)
 		{
 			RClick->AppendItem(LLoadString(IDS_OPEN), IDM_OPEN);
 			RClick->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE);
 			RClick->AppendItem(LLoadString(IDS_EXPORT), IDM_EXPORT);
 
 			if (Parent->GetMouse(m, true))
 			{
 				switch (RClick->Float(Parent, m.x, m.y))
 				{
 					case IDM_OPEN:
 					{
 						DoUI();
 						break;
 					}
 					case IDM_DELETE:
 					{
 						LVariant ConfirmDelete;
 						App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 						if (!ConfirmDelete.CastInt32() ||
 							LgiMsg(GetList(), LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 						{
 							List<LListItem> Del;
 							LList *ParentList = LListItem::Parent;
 							if (ParentList && ParentList->GetSelection(Del))
 							{
 								for (auto m: Del)
 								{
 									auto f = dynamic_cast<Filter*>(m);
 									if (f)
 										f->OnDelete();
 								}
 							}
 						}
 						break;
 					}
 					case IDM_EXPORT:
 					{
 						ExportAll(GetList(), sTextXml, NULL);
 						break;
 					}
 				}
 			}
 
 			DeleteObj(RClick);
 		}
 	}
 }
 
 int *Filter::GetDefaultFields()
 {
 	static int Def[] = { FIELD_FILTER_NAME, 0, 0, 0 };
 	return Def;
 }
 
 const char *Filter::GetFieldText(int Field)
 {
 	switch (Field)
 	{
 		case FIELD_FILTER_NAME:
 			return GetName();
 		case FIELD_FILTER_CONDITIONS_XML:
 			return GetConditionsXml();
 		case FIELD_FILTER_ACTIONS_XML:
 			return GetActionsXml();
 		case FIELD_FILTER_SCRIPT:
 			return GetScript();
 	}
 
 	return NULL;
 }
 
 void Filter::OnColumnNotify(int Col, int64 Data)
 {
 	if (!IgnoreCheckEvents)
 	{
 		switch (Col)
 		{
 			case 2:
 			case 3:
 			case 4:
 			{
 				SetDirty(true);
 				break;
 			}
 		}
 	}
 }
 
 const char *Filter::GetText(int i)
 {
 	int Field = 0;
 	if (FieldArray.Length())
 	{
 		if (i >= 0 && i < (int)FieldArray.Length())
 			Field = FieldArray[i];
 	}
 	else if (i >= 0 && i < CountOf(DefaultFilterFields))
 	{
 		Field = DefaultFilterFields[i];
 	}
 
 	switch (Field)
 	{
 		case FIELD_FILTER_NAME:
 		{
 			return GetName();
 			break;
 		}
 		case FIELD_FILTER_INDEX:
 		{
 			static char i[16];
 			sprintf_s(i, sizeof(i), "%i", GetIndex());
 			return i;
 			break;
 		}
 	}
 
 	return 0;
 }
 
 int FilterIndexCmp(Filter **a, Filter **b)
 {
 	int ai = (*a)->GetIndex();
 	int bi = (*b)->GetIndex();
 	return ai - bi;
 }
 
 void Filter::Reindex(ScribeFolder *Folder)
 {
 	if (!Folder)
 		return;
 
 	LArray<Filter*> Zero;
 	LArray<Filter*> Sort;
 	for (auto t : Folder->Items)
 	{
 		Filter *f = t->IsFilter();
 		if (f)
 		{
 			int Idx = f->GetIndex();
 			if (Idx > 0)
 			{
 				Sort.Add(f);
 			}
 			else
 			{
 				Zero.Add(f);
 			}
 		}
 	}
 
 	Sort.Sort(FilterIndexCmp);
 
 	LArray<Filter*> Map;
 
 	for (unsigned n=0; n<Zero.Length(); n++)
 		Sort.Add(Zero[n]);
 
 	bool Changed = false;
 	for (unsigned i=0; i<Sort.Length(); i++)
 	{
 		int Idx = Sort[i]->GetIndex();
 		if (Idx != i + 1)
 		{
 			Sort[i]->SetIndex(i + 1);
 			Sort[i]->SetDirty();
 			Sort[i]->Update();
 			Changed = true;
 		}
 	}
 
 	if (Changed)
 		Folder->ReSort();
 }
 
 //////////////////////////////////////////////////////////
 enum ConditionOptions
 {
 	FIELD_ANYWHERE = FIELD_MAX
 };
 
 int FilterCallback(	LFilterView *View,
 					LFilterItem *Item,
 					GFilterMenu Menu,
 					LRect &r,
 					LArray<char*> *GetList,
 					void *Data)
 {
 	int Status = -1;
 
 	if (!View)
 		return Status;
 
 	switch (Menu)
 	{
 		case FMENU_FIELD:
 		{
 			LSubMenu s;
 
 			LString::Array Names;
 			ItemFieldDef *FieldDefs = MailFieldDefs;
 			for (ItemFieldDef *i = FieldDefs; i->DisplayText; i++)
 			{
 				const char *Trans = LLoadString(i->FieldId);
 				auto idx = (i - FieldDefs) + 1;
 				Names[idx] = DomToStr(i->Dom);
 				s.AppendItem(Trans ? Trans : i->DisplayText, (int)idx, true);
 			}
 
 			s.AppendItem(LLoadString(IDS_ATTACHMENTS_DATA), FIELD_ATTACHMENTS_DATA, true);
 			s.AppendItem(LLoadString(IDS_ATTACHMENTS_NAME), FIELD_ATTACHMENTS_NAME, true);
 			s.AppendItem(LLoadString(IDS_MEMBER_OF_GROUP), FIELD_MEMBER_OF_GROUP, true);
 			s.AppendItem(LLoadString(IDS_ANYWHERE), FIELD_ANYWHERE, true);
 
 			LPoint p(r.x1, r.y2 + 1);
 			View->PointToScreen(p);
 			int Cmd = s.Float(View, p.x, p.y, true);
 			switch (Cmd)
 			{
 				case FIELD_ATTACHMENTS_DATA:
 					Item->SetField("mail.Attachments");
 					break;
 				case FIELD_ATTACHMENTS_NAME:
 					Item->SetField("mail.AttachmentNames");
 					break;
 				case FIELD_MEMBER_OF_GROUP:
 					Item->SetField("mail.From.Groups");
 					break;
 				case FIELD_ANYWHERE:
 					Item->SetField("mail.*");
 					break;
 				default:
 					if (Cmd > 0 && Cmd < Names.Length())
 						Item->SetField(LString("mail.") + Names[Cmd]);
 					break;
 			}
 			break;
 		}
 		case FMENU_OP:
 		{
 			if (GetList)
 			{
 				for (const char **o = GetOpNames(true); *o; o++)
 				{
 					GetList->Add(NewStr(*o));
 				}
 				Status = true;
 			}
 			/*
 			else
 			{
 				auto s = new LSubMenu;
 				if (s)
 				{
 					int n = 1;
 
 					for (char **o = GetOpNames(true); *o; o++)
 					{
 						s->AppendItem(*o, n++, true);
 					}
 
 					LPoint p(r.x1, r.y2 + 1);
 					View->PointToScreen(p);
 					int Cmd = s->Float(View, p.x, p.y, true);
 
 					if (Cmd > 0)
 					{
 						Item->SetOp(OpNames[Cmd - 1]);
 					}
 					
 					DeleteObj(s);
 				}
 			}
 			*/
 			break;
 		}
 		case FMENU_VALUE:
 		{
 			break;
 		}
 	}
 
 	return Status;
 }
 
 //////////////////////////////////////////////////////////
 struct FilterUiPriv
 {
 };
 
 FilterUi::FilterUi(Filter *item) :
 	ThingUi(item, "Filter")
 {
 	d = new FilterUiPriv;
 	Item = item;
 	if (!(Item && Item->App))
 	{
 		return;
 	}
 
 	Script = 0;
 	Tab = 0;
 	Actions = 0;
 	Conditions = 0;
 
 	LRect r(100, 100, 800, 600);
 	SetPos(r);
 	MoveSameScreen(item->App);
 
 	// Create window
 	#if WINNATIVE
 	CreateClassW32("FilterUi", LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_FILTER)));
 	#endif
 
 	if (Attach(0))
 	{
 		// Setup UI
 		Commands.Toolbar = Item->App->LoadToolbar(this,
 												Item->App->GetResourceFile(ResToolbarFile),
 												Item->App->GetToolbarImgList());
 		if (Commands.Toolbar)
 		{
 			Commands.Toolbar->Attach(this);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE)), IDM_SAVE, TBT_PUSH, true, IMG_SAVE);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE_CLOSE)), IDM_SAVE_CLOSE, TBT_PUSH, true, IMG_SAVE_AND_CLOSE);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_DELETE)), IDM_DELETE, TBT_PUSH, true, IMG_TRASH);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_HELP)), IDM_HELP, TBT_PUSH, true, IMG_HELP);
 			Commands.SetupCallbacks(GetItem()->App, this, GetItem(), LThingUiToolbar);
 		}
 
 		LTabPage *Cond = 0;
 		LTabPage *Act = 0;
 		Tab = new LTabView(91, 0, 0, 1000, 1000, 0);
 		if (Tab)
 		{
 			Tab->Attach(this);
 			Tab->SetPourChildren(true);
 
 			LTabPage *Filter = Tab->Append(LLoadString(IDS_FILTER));
 			if (Filter)
 			{
 				#ifdef _DEBUG
 				auto Status =
 				#endif
 				Filter->LoadFromResource(IDD_FILTER);
 				LAssert(Status);
 				Name(Filter->Name());
 			}
 
 			Cond = Tab->Append(LLoadString(IDS_CONDITIONS));
 			if (Cond)
 			{
 				Conditions = new LFilterView(FilterCallback, Item);
 				if (Conditions)
 				{
 					Cond->Append(Conditions);
 					Conditions->SetPourLargest(true);
 				}
 			}
 
 			Act = Tab->Append(LLoadString(IDS_ACTIONS));
 			if (Act)
 			{
 				#ifdef _DEBUG
 				auto Status =
 				#endif
 				Act->LoadFromResource(IDD_FILTER_ACTION);
 				LAssert(Status);
 				if (GetViewById(IDC_FILTER_ACTIONS, Actions))
 					Actions->MultiSelect(false);
 			}
 
 			LTabPage *ScriptTab = Tab->Append("");
 			if (ScriptTab &&
 				ScriptTab->LoadFromResource(IDD_FILTER_SCRIPT))
 			{
 				if (GetViewById(IDC_SCRIPT, Script))
 				{
 					Script->SetWrapType(TEXTED_WRAP_NONE);
 					Script->Sunken(true);
 					Script->SetPourLargest(true);
 				}
 				else LAssert(0);
 			}
 		}
 
 		// Show window
 		Visible(true);
 
 		if (Cond && Item)
 		{
 			LCombo *Cbo;
 			if (GetViewById(IDC_ACTION, Cbo))
 			{
 				for (ActionName *o = ActionNames; o->Id; o++)
 				{
 					const char *s = LLoadString(o->Id, o->Default);
 					Cbo->Insert(s);
 				}
 			}
 		}
 
 		OnLoad();
 	}
 
 	RegisterHook(this, LKeyEvents);
 }
 
 FilterUi::~FilterUi()
 {
     if (Item)
 	    Item->Ui = 0;
 	DeleteObj(d);
 }
 
 bool FilterUi::OnViewKey(LView *v, LKey &k)
 {
 	if (k.CtrlCmd())
 	{
 		switch (k.c16)
 		{
 			case 's':
 			case 'S':
 			{
 				if (k.Down())
 					OnSave();
 				return true;
 			}
 			case 'w':
 			case 'W':
 			{
 				if (k.Down())
 				{
 					OnSave();
 					Quit();
 				}
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 int FilterUi::OnNotify(LViewI *Col, LNotification n)
 {
 	int Reindex = 0;
 	int InsertOffset = 0;
 	switch (Col->GetId())
 	{
 		case IDC_TYPE_CBO:
 		case IDC_ARG_EDIT:
 		{
 			if (Actions)
 			{
 				List<FilterAction> Sel;
 				if (Actions->GetSelection(Sel))
 				{
 					for (auto a: Sel)
 						a->OnNotify(Col, n);
 				}
 			}
 			break;
 		}
 		case IDC_BROWSE_ARG:
 		{
 			if (Actions)
 			{
 				List<FilterAction> Sel;
 				if (Actions->GetSelection(Sel))
 				{
 					FilterAction *a = Sel[0];
 					if (a)
 					{
 						a->Browse(Item->App, this);
 						a->OnNotify(Col, n);
 					}
 				}
 			}
 			break;			
 		}
         case IDC_UP:
             InsertOffset = -1;
             // fall thru
         case IDC_DOWN:
         {
             if (!InsertOffset)
                 InsertOffset = 1;
             if (!Actions)
                 break;
 			List<FilterAction> Items;
 			if (!Actions->GetSelection(Items) && Items[0])
 			    break;
 
 			int Idx = Actions->IndexOf(Items[0]) + InsertOffset;
 			FilterAction *Last = 0;
 			for (auto a: Items)
 			{
 			    Actions->Remove(a);
 			    Actions->Insert(a, Idx++);
 			    Last = a;
 			}
 			if (Last)
 			{
 			    Actions->Focus(true);
 			    Last->Select(true);
 			}
             break;
         }
 		case IDC_NEW_FILTER_ACTION:
 		{
 			if (Actions)
 			{
 				FilterAction *n = new FilterAction(Item->GetObject()->GetStore());
 				Actions->Insert(n);
 				Actions->Select(n);
 				Actions->Focus(true);
 			}
 			break;
 		}
 		case IDC_DELETE_FILTER_ACTION:
 		{
 			if (Actions)
 			{
 				List<FilterAction> Items;
 				if (Actions->GetSelection(Items) && Items[0])
 				{
 					int Idx = Actions->IndexOf(Items[0]);
 					Items.DeleteObjects();
 
 					if (Idx >= (int)Actions->Length())
 						Idx = (int)Actions->Length() - 1;
 					Actions->Select(Actions->ItemAt(Idx));
 					Actions->Focus(true);
 				}
 			}
 			break;
 		}
 		case IDC_LAUNCH_HELP:
 		{
 			switch (Tab->Value())
 			{
 				case 0: // Name/Index
 				default:
 				{
 					Item->App->LaunchHelp("filters.html");
 					break;
 				}
 				case 1: // Conditions
 				{
 					Item->App->LaunchHelp("filters.html#cond");
 					break;
 				}
 				case 2: // Actions
 				{
 					Item->App->LaunchHelp("filters.html#actions");
 					break;
 				}
 				case 3: // Script
 				{
 					Item->App->LaunchHelp("filters.html#script");
 					break;
 				}
 			}
 			break;
 		}
 		case IDC_FILTER_UP:
 		{
 			Reindex = 1;
 			break;
 		}
 		case IDC_FILTER_DOWN:
 		{
 			Reindex = -1;
 			break;
 		}
 	}
 
 	if (Reindex)
 	{
 		// Remove holes in the indexing
 		ScribeFolder *Folder = Item->GetFolder();
 		if (Folder)
 		{
 			Folder->ReSort();
 		}
 
 		// Swap entries
 		int i = (int)GetCtrlValue(IDC_FILTER_INDEX);
 		if (i >= 0)
 		{
 			Filter *f = Item->GetFilterAt(i - Reindex);
 			if (f)
 			{
 				int n = f->GetIndex();
 				f->SetIndex(Item->GetIndex());
 				f->SetDirty();
 
 				Item->SetIndex(n);
 				Item->SetDirty();
 
 				f->Save();
 				Item->Save();
 
 				SetCtrlValue(IDC_FILTER_INDEX, Item->GetIndex());
 				Item->App->GetItemList()->ReSort();
 
 				Item->Update();
 				f->Update();
 			}
 		}
 	}
 
 	return 0;
 }
 
 LMessage::Result FilterUi::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		#ifdef WIN32
 		case WM_CLOSE:
 		{
 			Quit();
 			return 0;
 		}
 		#endif
 	}
 	return LWindow::OnEvent(Msg);
 }
 
 void LoadTree(LFilterView *v, LXmlTag *t, LTreeNode *i)
 {
 	int idx = 0;
 	for (auto c: t->Children)
 	{
 		if (c->GetTag())
 		{
 			LFilterItem *n = 0;
 			bool Cond = false;
 
 			if (c->IsTag(ELEMENT_AND))
 				n = v->Create(LNODE_AND);
 			else if (c->IsTag(ELEMENT_OR))
 				n = v->Create(LNODE_OR);
 			else if (c->IsTag(ELEMENT_CONDITION))
 			{
 				Cond = true;
 				n = v->Create(LNODE_COND);
 			}
 
 			if (n)
 			{
 				if (Cond)
 				{
 					n->SetNot(c->GetAsInt(ATTR_NOT) > 0);
 					n->SetField(c->GetAttr(ATTR_FIELD));
 					n->SetValue(c->GetAttr(ATTR_VALUE));
 
 					char *o = c->GetAttr(ATTR_OP);
 					if (o)
 					{
 						if (IsDigit(*o))
 							n->SetOp(atoi(o));
 						else
 						{
 							for (int i=0; OpNames[i]; i++)
 							{
 								if (!_stricmp(OpNames[i], o))
 								{
 									n->SetOp(i);
 									break;
 								}
 							}
 						}
 					}
 				}
 				
 				i->Insert(n, idx++);
 
 				LoadTree(v, c, n);
 			}
 		}
 	}
 }
 
 void FilterUi::OnLoad()
 {
 	if (Item)
 	{
 		LAutoPtr<LXmlTag> r = Item->Parse(true);
 		if (r && Actions)
 		{
 			for (auto c: r->Children)
 			{
 				FilterAction *a = new FilterAction(Item->GetObject()->GetStore());
 				if (a)
 				{
 					if (a->Set(c))
 					{
 						Actions->Insert(a);
 					}
 					else LAssert(!"Can't convert xml to action.");
 				}
 			}
 		}
 
 		auto FilterName = Item->GetName();
 		SetCtrlName(IDC_NAME, FilterName);
 		SetCtrlValue(IDC_FILTER_INDEX, Item->GetIndex());
 		SetCtrlName(IDC_SCRIPT, Item->GetScript());
 		SetCtrlValue(IDC_STOP_FILTERING, Item->GetStopFiltering());
 		SetCtrlValue(IDC_INCOMING, Item->GetIncoming());
 		SetCtrlValue(IDC_OUTGOING, Item->GetOutgoing());
 		SetCtrlValue(IDC_INTERNAL_FILTERING, Item->GetInternal());
 
 		auto Xml = Item->GetConditionsXml();
 		if (Conditions && Xml)
 		{
 			LAutoPtr<LXmlTag> x(new LXmlTag);
 			if (x)
 			{
 				LMemStream p(Xml, strlen(Xml));
 				LXmlTree t;
 				if (t.Read(x, &p, 0))
 				{
 					Conditions->Empty();
 					LoadTree(Conditions, x, Conditions->GetRootNode());
 					if (!Conditions->GetRootNode()->GetChild())
 					{
 						Conditions->SetDefault();
 					}
 				}
 			}
 		}
 		
 		if (ValidStr(FilterName))
 		{
 			LString s;
 			s.Printf("%s - %s", LLoadString(IDS_FILTER), FilterName);
 			Name(s);
 		}
 	}
 }
 
 void SaveTree(LXmlTag *t, LTreeNode *i)
 {
 	for (LTreeNode *c = i->GetChild(); c; c = c->GetNext())
 	{
 		LFilterItem *fi = dynamic_cast<LFilterItem*>(c);
 		if (fi)
 		{
 			const char *Tag = 0;
 			bool Cond = false;
 			switch (fi->GetNode())
 			{
 				default: break;
 				case LNODE_AND:
 					Tag = ELEMENT_AND; break;
 				case LNODE_OR:
 					Tag = ELEMENT_OR; break;
 				case LNODE_COND:
 					Cond = true; Tag = ELEMENT_CONDITION; break;
 			}
 
 			if (Tag)
 			{
 				LXmlTag *n = new LXmlTag(Tag);
 				if (n)
 				{
 					if (Cond)
 					{
 						n->SetAttr(ATTR_NOT, fi->GetNot());
 						n->SetAttr(ATTR_FIELD, fi->GetField());
 						n->SetAttr(ATTR_OP, fi->GetOp());
 						n->SetAttr(ATTR_VALUE, fi->GetValue());
 					}
 
 					t->InsertTag(n);
 
 					SaveTree(n, fi);
 				}
 			}
 		}
 	}
 }
 
 void FilterUi::OnSave()
 {
 	if (Item)
 	{
 		Item->SetName(GetCtrlName(IDC_NAME));
 		Item->SetScript(GetCtrlName(IDC_SCRIPT));
 		Item->SetStopFiltering(GetCtrlValue(IDC_STOP_FILTERING)!=0);
 
 		Item->SetIncoming(GetCtrlValue(IDC_INCOMING)!=0);
 		Item->SetOutgoing(GetCtrlValue(IDC_OUTGOING)!=0);
 		Item->ChkIncoming->Value(GetCtrlValue(IDC_INCOMING));
 		Item->ChkOutgoing->Value(GetCtrlValue(IDC_OUTGOING));
 		Item->ChkInternal->Value(GetCtrlValue(IDC_INTERNAL_FILTERING));
 
 		if (Conditions)
 		{
 			LXmlTag *x = new LXmlTag(ELEMENT_CONDITIONS);
 			if (x)
 			{
 				SaveTree(x, Conditions->GetRootNode());
 
 				LXmlTree t;
 				LStringPipe p;
 				if (t.Write(x, &p))
 				{
 				    LAutoString a(p.NewStr());
 				    Item->ConditionsCache.Reset();
 					Item->SetConditionsXml(a);
 				}
 
 				DeleteObj(x);
 			}
 		}
 
 		LXmlTag x("Actions");
 		List<FilterAction> Act;
 		Actions->GetAll(Act);
 		for (size_t i=0; i<Act.Length(); i++)
 		{
 			FilterAction *a = Act[i];
 			LAutoPtr<LXmlTag> c(new LXmlTag("Action"));
 			if (a->Get(c))
 			{
 				x.InsertTag(c.Release());
 			}
 		}
 
 		LXmlTree t;
 		LStringPipe p;
 		t.Write(&x, &p);
 		LAutoString s(p.NewStr());
 		Item->SetActionsXml(s);
 
 		if (Item->Save())
 		{
 			Item->Reindex(Item->GetFolder());
 		}
 	}
 }
 
 int FilterUi::OnCommand(int Cmd, int Event, OsView Window)
 {
 	switch (Cmd)
 	{
 		case IDM_SAVE:
 		{
 			OnSave();
 			break;
 		}
 		case IDM_SAVE_CLOSE:
 		{
 			OnSave();
 			// fall thru
 		}
 		case IDM_CLOSE:
 		{
 			Quit();
 			break;
 		}
 		case IDM_DELETE:
 		{
 		    Item->Ui = 0;
 		    Item->OnDelete();
 		    Item = 0;
 		    Quit();
 		    break;
 		}
 		case IDM_HELP:
 		{
 			App->LaunchHelp("filters.html");
 			break;
 		}
 		case IDC_NEW_FILTER_ACTION:
 		{
 			LList *l;
 			if (GetViewById(IDC_FILTER_ACTIONS, l))
 			{
 				
 			}
 			break;
 		}
 		case IDC_DELETE_FILTER_ACTION:
 		{
 			break;
 		}
 		default:
 		{
 			Commands.ExecuteCallbacks(GetItem()->App, this, GetItem(), Cmd);
 			break;
 		}
 	}
 	return 0;
 }
 
 
diff --git a/Code/ScribeGroup.cpp b/Code/ScribeGroup.cpp
--- a/Code/ScribeGroup.cpp
+++ b/Code/ScribeGroup.cpp
@@ -1,1313 +1,1406 @@
 #include "Scribe.h"
 #include "lgi/common/TextView3.h"
 #include "resdefs.h"
 #include "ScribeListAddr.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 #include "AddressSelect.h"
 
 ItemFieldDef GroupFieldDefs[] = {
 	{ContactGroupName, SdName, GV_STRING, FIELD_GROUP_NAME, IDC_GROUP_NAME},
 	{ContactGroupList, SdList, GV_STRING, FIELD_GROUP_LIST, IDC_GROUP_LIST},
 	{ContactGroupDateModified, SdDateModified, GV_DATETIME, FIELD_DATE_MODIFIED, 0},
 	{0}
 };
 
 int DefaultGroupFields[] =
 {
 	FIELD_GROUP_NAME,
 	FIELD_DATE_MODIFIED,
 	0,
 	0
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////
 class LAddressEdit;
 
 struct AddressMeta
 {
 	int Id;
 	bool Referenced;
 	LAddressEdit *Edit;
 	ListAddr Addr;
 	LString Text;
 
 	AddressMeta(LAddressEdit *edit, int id = -1);
 	~AddressMeta();
 
 	bool Matched()
 	{
 		return Addr.Length() == 1;
 	}
 
 	void Ins();
 	bool IsResolved();
 	bool IsUnique();
 	void OpenContact();
 };
 
 class LAddressEdit : public LTextView3
 {
 	friend struct AddressMeta;
 	LHashTbl<IntKey<int>,AddressMeta*> Map;
 	LArray<BrowseItem*> Items;
 
 	int CreateId()
 	{
 		int Id;
 		while (Map.Find(Id = LRand(1000)))
 			;
 		return Id;
 	}
 
 	AddressMeta *GetMeta(LStyle &s)
 	{
 		return Map.Find(s.Data.CastInt32());
 	}
 
 	bool UpdateMeta(LStyle &Style)
 	{
 		auto m = GetMeta(Style);
 		if (!m)
 			return false;
 
 		m->Addr.SetText(m->Text);
 
 		// LgiTrace("UpdateMeta '%s' -> %i\n", m->Text.Get(), m->Addr.Length());
 
 		if (m->Addr.Length() > 1)
 		{
 			// Matched more than one recip
 			Style.Fore.Rgb(255, 0, 0);
 			Style.Font = Underline;
 		}
 		else if (m->Addr.Length())
 		{
 			// Matched a single recip
 			Style.Fore = LColour(L_BLACK);
 			Style.Font = Underline;
 		}
 		else
 		{
 			// No match
 			Style.Fore.Rgb(0xb0, 0xb0, 0xb0);
 			Style.Font = GetFont();
 			Style.Decor = LCss::TextDecorSquiggle;
 			Style.DecorColour = LColour::Red;
 		}
 
 		return true;
 	}
 
 public:
 	bool AllowPour;
 	ScribeWnd *App;
 
 	LAddressEdit(LRect *p, const char *t);
 
 	void OnPaint(LSurface *pDC);
 	void PourStyle(size_t Start, ssize_t Length);
 	bool Insert(size_t At, const char16 *Data, ssize_t Len);
 	bool Delete(size_t At, ssize_t Len);
 	bool GetStyles(List<AddressMeta> &Styles);
 
 	int WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState);
 	int OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState);
 	bool OnStyleClick(LStyle *style, LMouse *m);
 	bool OnStyleMenu(LStyle *style, LSubMenu *m);
 	void OnStyleMenuClick(LStyle *style, int i);
 };
 
 class GroupUi :
 	public ThingUi,
 	public LResourceLoad
 {
 	ContactGroup *Item;
 	LAddressEdit *Edit;
 
 public:
 	GroupUi(ContactGroup *item);
 	~GroupUi();
 	int OnNotify(LViewI *c, LNotification n);
 
 	void ResolveAll();
 	void OnDirty(bool Dirty) {}
 	void OnLoad();
 	void OnSave();
 	int WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState);
 	int OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState);
 	void Add(char *Email);
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////
 class ContactGroupPrivate
 {
 public:
 };
 
 ContactGroup::ContactGroup(ScribeWnd *app, LDataI *object) : Thing(app, object)
 {
 	DefaultObject(object);
 	d = new ContactGroupPrivate;
 	Ui = 0;
 }
 
 ContactGroup::~ContactGroup()
 {
 	DeleteObj(d);
 }
 
 Thing &ContactGroup::operator =(Thing &c)
 {
 	LAssert(0);
 	return *this;
 }
 
 char *ContactGroup::GetDropFileName()
 {
 	if (!DropFileName)
 	{
-		LAssert(!"FIXME");
+		auto Name = GetName();
+		DropFileName.Reset(MakeFileName(Name ? Name : "group", "xml"));
 	}
+	
 	return DropFileName;
 }
 
 bool ContactGroup::GetDropFiles(LString::Array &Files)
 {
-	LAssert(!"FIXME");
-	return false;
+	auto fn = GetDropFileName();
+	if (!fn)
+		return false;
+
+	if (!LFileExists(fn))
+	{
+		LAutoPtr<LFile> F(new LFile);
+		if (F->Open(fn, O_WRITE))
+		{
+			F->SetSize(0);
+			Export(AutoCast(F), sMimeXml);
+		}
+	}
+
+	if (!LFileExists(DropFileName))
+		return false;
+
+	Files.Add(DropFileName.Get());
+	
+	return true;
+}
+
+bool ContactGroup::GetFormats(bool Export, LString::Array &MimeTypes)
+{
+	MimeTypes.Add(sTextXml);
+	return MimeTypes.Length() > 0;
+}
+
+Thing::IoProgress ContactGroup::Import(IoProgressImplArgs)
+{
+	if (Stricmp(mimeType, sTextXml) &&
+	    Stricmp(mimeType, sMimeXml))
+	    IoProgressNotImpl();
+
+	LXmlTree Tree;
+	LXmlTag r, *t;
+	if (!Tree.Read(&r, stream))
+		IoProgressError("Xml parse error.");
+
+	if (!r.IsTag(ContactGroupObj))
+		IoProgressError("No ContactGroup tag.");
+
+	if (t = r.GetChildTag(ContactGroupName))
+		GetObject()->SetStr(FIELD_GROUP_NAME, t->GetContent());
+	else
+		IoProgressError("No Name tag.");
+
+	if (t = r.GetChildTag(ContactGroupList))
+		GetObject()->SetStr(FIELD_GROUP_LIST, t->GetContent());
+	else
+		IoProgressError("No List tag.");
+
+	if (t = r.GetChildTag(ContactGroupDateModified))
+	{
+		LDateTime dt;
+		if (dt.Set(t->GetContent()))
+			GetObject()->SetDate(FIELD_DATE_MODIFIED, &dt);
+	}
+
+	IoProgressSuccess();
+}
+
+Thing::IoProgress ContactGroup::Export(IoProgressImplArgs)
+{
+	if (Stricmp(mimeType, sMimeXml))
+		IoProgressNotImpl();
+
+	auto Name = GetName();
+	LVariant Addr;
+	GetVariant(ContactGroupList, Addr);
+	auto Modified = GetObject()->GetDate(FIELD_DATE_MODIFIED);
+
+	LXmlTag r(ContactGroupObj), *t;
+
+	if ((t = r.CreateTag(ContactGroupName)))
+		t->SetContent(Name);
+	if ((t = r.CreateTag(ContactGroupList)))
+		t->SetContent(Addr.Str());
+	if (Modified &&
+		Modified->IsValid() &&
+		(t = r.CreateTag(ContactGroupDateModified)))
+		t->SetContent(Modified->Get());
+	
+	LXmlTree tree;
+	if (tree.Write(&r, stream))
+		IoProgressError("Failed to write xml.");
+	
+	IoProgressSuccess();
 }
 
 LString::Array ContactGroup::GetAddresses()
 {
 	LString::Array Addrs;
 	
 	LVariant l;
 	if (GetVariant(ContactGroupList, l))
 	{
 		LToken t(l.Str());
 		for (unsigned i=0; i<t.Length(); i++)
 		{
 			Addrs.Add(t[i]);
 		}
 	}
 	
 	return Addrs;
 }
 
 bool ContactGroup::GetAddresses(List<char> &a)
 {
 	bool Status = false;
 	
 	LVariant l;
 	if (GetVariant(ContactGroupList, l))
 	{
 		LToken t(l.Str());
 		for (unsigned i=0; i<t.Length(); i++)
 		{
 			a.Insert(NewStr(t[i]));
 			Status = true;
 		}
 	}
 	
 	return Status;
 }
 
 bool ContactGroup::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdName: // Type: String
 		{
 			Value = GetObject()->GetStr(FIELD_GROUP_NAME);
 			break;
 		}
 		case SdList: // Type: String[]
 		{
 			if (Array)
 			{
 				LToken t(GetObject()->GetStr(FIELD_GROUP_LIST), ", \r\n");
 				int Idx = atoi(Array);
 				if (Idx >= 0 && Idx < (int)t.Length())
 				{
 					Value = t[Idx];
 				}
 			}
 			else
 			{
 				Value = GetObject()->GetStr(FIELD_GROUP_LIST);
 			}
 			break;
 		}
 		case SdType: // Type: Int32
 		{
 			Value = GetObject()->Type();
 			break;
 		}
 		case SdDateModified:
 		{
 			Value = GetObject()->GetDate(FIELD_DATE_MODIFIED);
 			break;
 		}
 		case SdUsedTs:
 		{
 			Value = &UsedTs;
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool ContactGroup::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	if (GetObject() && !Stricmp((char*)MethodName, (char*)"AddAddress"))
 	{
 		int Added = 0;
 		
 		LString Addrs = GetObject()->GetStr(FIELD_GROUP_LIST);
 		LString::Array a = Addrs.SplitDelimit(WhiteSpace);
 
 		for (unsigned i=0; i<Args.Length(); i++)
 		{
 			char *AddrToAdd = Args[i]->Str();
 			if (AddrToAdd)
 			{
 				bool HasAddr = false;
 				for (unsigned n=0; n<a.Length(); n++)
 				{
 					if (!Stricmp(AddrToAdd, a[n].Get()))
 					{
 						HasAddr = true;
 						break;
 					}
 				}
 				if (!HasAddr)
 				{
 					a.SetFixedLength(false);
 					a.New() = AddrToAdd;
 					Added++;
 				}
 			}
 		}
 		
 		if (Added)
 		{
 			LString Sep = "\n";
 			LString Lst = Sep.Join(a);
 			GetObject()->SetStr(FIELD_GROUP_LIST, Lst);
 			
 			SetDirty();
 			
 			UsedTs.SetNow();
 			if (ReturnValue)
 				*ReturnValue = true;
 		}
 		else if (ReturnValue)
 		{
 			*ReturnValue = false;
 		}
 			
 		return true;
 	}
 
 	return Thing::CallMethod(MethodName, ReturnValue, Args);
 }
 
 bool ConvertList(ContactGroup *g, LArray<ListAddr*> &a)
 {
 	List<char> Addrs;
 	if (g->GetAddresses(Addrs))
 	{
 		for (auto e: Addrs)
 		{
 			ListAddr *la = new ListAddr(g->App, e, (char*)0);
 			if (la)
 			{
 				la->OnFind();
 				a.Add(la);
 			}
 		}
 		Addrs.DeleteArrays();
 	}
 	
 	return a.Length() > 0;
 }
 
 void ContactGroup::OnMouseClick(LMouse &m)
 {
 	LListItem::OnMouseClick(m);
 
 	if (m.IsContextMenu())
 	{
 		// open the right click menu
 		LScriptUi s(new LSubMenu);
 		if (s.Sub)
 		{
 			List<Mail> Templates;
 
 			s.Sub->AppendItem(LLoadString(IDS_OPEN), IDM_OPEN, true);
 			s.Sub->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE, true);
 
 			ScribeFolder *f = App->GetFolder(FOLDER_TEMPLATES);
 			if (f)
 			{
 				auto Merge = s.Sub->AppendSub(LLoadString(IDS_MERGE_TEMPLATE));
 				if (Merge)
 				{
 					int n = 0;
 					for (auto t: f->Items)
 					{
 						Mail *m = t->IsMail();
 						if (m)
 						{
 							Templates.Insert(m);
 							Merge->AppendItem(m->GetSubject()?m->GetSubject():(char*)"(no subject)", IDM_MERGE_TEMPLATE_BASE+n++, true);
 						}
 					}
 				}
 			}
 			else
 			{
 				s.Sub->AppendItem(LLoadString(IDS_MERGE_TEMPLATE), 0, false);
 			}
 
 			s.Sub->AppendItem(LLoadString(IDS_MERGE_FILE), IDM_MERGE_FILE, true);
 
 			if (GetList()->GetMouse(m, true))
 			{
 				LArray<LScriptCallback*> Callbacks;
 				if (App->GetScriptCallbacks(LThingContextMenu, Callbacks))
 				{
 					LScriptArguments Args(NULL);
 					Args[0] = new LVariant(App);
 					Args[1] = new LVariant(this);
 					Args[2] = new LVariant(&s);
 					for (unsigned i=0; i<Callbacks.Length(); i++)
 					{
 						App->ExecuteScriptCallback(*Callbacks[i], Args);
 					}
 				}
 
 				int Msg;
 				switch (Msg = s.Sub->Float(GetList(), m.x, m.y))
 				{
 					case IDM_OPEN:
 					{
 						DoUI();
 						break;
 					}
 					case IDM_DELETE:
 					{
 						LVariant ConfirmDelete;
 						App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 						if (!ConfirmDelete.CastInt32() ||
 							LgiMsg(GetList(), LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 						{
 							List<LListItem> Del;
 							LList *ParentList = LListItem::Parent;
 							if (ParentList && ParentList->GetSelection(Del))
 							{
 								for (auto i: Del)
 								{
-									Filter *m = dynamic_cast<Filter*>(i);
-									if (m)
-										m->OnDelete();
+									auto obj = dynamic_cast<ContactGroup*>(i);
+									if (obj)
+										obj->OnDelete();
+									else
+										LAssert(!"What type of object is this?");
 								}
 							}
 						}
 						break;
 					}
 					case IDM_MERGE_FILE:
 					{
 						auto s = new LFileSelect(App);
 						s->Type("Email Template", "*.txt;*.eml");
 						s->Open([this](auto dlg, auto status)
 						{
 							if (status)
 							{
 								LArray<ListAddr*> Recip;
 								if (ConvertList(this, Recip))
 									App->MailMerge(Recip, dlg->Name(), 0);
 								Recip.DeleteObjects();
 							}
 							delete dlg;
 						});
 						break;
 					}
 					default:
 					{
 						if (Msg >= IDM_MERGE_TEMPLATE_BASE && Msg - IDM_MERGE_TEMPLATE_BASE < (ssize_t)Templates.Length())
 						{
 							Mail *Template = Templates[Msg - IDM_MERGE_TEMPLATE_BASE];
 							if (Template)
 							{
 								LArray<ListAddr*> Recip;
 								if (ConvertList(this, Recip))
 									App->MailMerge(Recip, 0, Template);
 								Recip.DeleteObjects();
 							}
 						}
 						else
 						{
 							// Handle any installed callbacks for menu items
 							for (unsigned i=0; i<s.Callbacks.Length(); i++)
 							{
 								LScriptCallback &Cb = s.Callbacks[i];
 								if (Cb.Param == Msg)
 								{
 									LScriptArguments Args(NULL);
 									Args[0] = new LVariant(App);
 									Args[1] = new LVariant(this);
 									Args[2] = new LVariant(Cb.Param);
 
 									App->ExecuteScriptCallback(Cb, Args);
 								}
 							}
 						}
 						break;
 					}
 				}
 			}
 
 			DeleteObj(s.Sub);
 		}
 	}
 	else if (m.Down() && m.Double())
 	{
 		if (!Ui)
 		{
 			Ui = new GroupUi(this);
 		}
 	}
 
 }
 
 void ContactGroup::OnSerialize(bool Write)
 {
 	if (Write)
 	{
 		UsedTs.SetNow();
 	}
 	else if (!UsedTs.IsValid())
 	{
 		auto m = GetObject()->GetDate(FIELD_DATE_MODIFIED);
 		if (m)
 			UsedTs = *m;
 	}
 }
 
 ThingUi *ContactGroup::DoUI(MailContainer *c)
 {
 	if (!Ui)
 		Ui = new GroupUi(this);
 	else
 		Ui->Visible(true);
 
 	return Ui;
 }
 
 int ContactGroup::Compare(LListItem *Arg, ssize_t Field)
 {
 	ContactGroup *cg = dynamic_cast<ContactGroup*>(Arg);
 	if (!cg)
 		return 0;
 
 	switch (Field)
 	{
 		case FIELD_DATE_MODIFIED:
 		{
 			auto a = GetObject()->GetDate((int)Field);
 			auto b = cg->GetObject()->GetDate((int)Field);
 			if (a && b)
 				return a->Compare(b);
 			break;
 		}
 		default:
 		{
 			auto a = GetFieldText((int)Field);
 			auto b = cg->GetFieldText((int)Field);
 			if (a && b)
 				return _stricmp(a, b);
 			break;
 		}
 	}
 
 	return 0;
 }
 
 bool ContactGroup::Save(ScribeFolder *Into)
 {
-	bool Status = false;
-
-	// Pre save checks
+	if (!GetFolder())
+	{
+		if (Into)
+			SetParentFolder(Into);
+		else if (App)
+			SetParentFolder(App->GetFolder(FOLDER_GROUPS));
+	}
 
-	// Save
-	if (!GetFolder() && App)
-		SetParentFolder(App->GetFolder(FOLDER_GROUPS));
+	if (!GetFolder())
+		return false;
 
-	if (GetFolder())
-	{
-		Status = GetFolder()->WriteThing(this) != Store3Error;
-		if (Status)
-			SetDirty(false);
-	}
+	auto Status = GetFolder()->WriteThing(this) != Store3Error;
+	if (Status)
+		SetDirty(false);
 
 	return Status;
 }
 
 int *ContactGroup::GetDefaultFields()
 {
 	return DefaultGroupFields;
 }
 
 const char *ContactGroup::GetFieldText(int Field)
 {
 	switch (Field)
 	{
 		case FIELD_DATE_MODIFIED:
 		{
 			auto d = GetObject()->GetDate(Field);
 			if (d)
 				DateCache = d->Local().Get();
 			else
 				DateCache = LLoadString(IDS_NONE);
 			return DateCache;
 		}
 	}
 
 	return GetObject() ? GetObject()->GetStr(Field) : 0;
 }
 
 const char *ContactGroup::GetText(int i)
 {
 	if (FieldArray.Length())
 	{
 		if (i >= 0 && i < (int)FieldArray.Length())
 			return GetFieldText(FieldArray[i]);
 	}
 	else if (i < CountOf(DefaultGroupFields))
 	{
 		return GetFieldText(DefaultGroupFields[i]);
 	}
 	
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 GroupUi::GroupUi(ContactGroup *item) : ThingUi(item, "Contact Group")
 {
 	Item = item;
 	Edit = 0;
 
 	LRect p;
 	LAutoString n;
 	if (LoadFromResource(IDD_GROUP, this, &p, &n))
 	{
 		SetPos(p);
 		Name(n);
 		MoveSameScreen(App);
 		if (GetViewById(IDC_GROUP_LIST, Edit))
 		{
 			Edit->App = App;
 		}
 
 		if (Attach(0))
 		{
 			AttachChildren();
 			OnLoad();
 			Visible(true);
 
 			SetWindow(this);
 		}
 	}
 }
 
 GroupUi::~GroupUi()
 {
 	Item->Ui = 0;
 }
 
 extern bool SerializeUi(ItemFieldDef *Defs, LDataI *Object, LViewI *View, bool ToUi);
 
 void GroupUi::OnLoad()
 {
 	SerializeUi(GroupFieldDefs, Item->GetObject(), this, true);
 
 	auto GrpName = Item->GetObject()->GetStr(FIELD_GROUP_NAME);
 	if (ValidStr(GrpName))
 	{
 		LString s;
 		s.Printf("%s - %s", LLoadString(IDD_GROUP), GrpName);
 		Name(s);
 	}
 }
 
 void GroupUi::ResolveAll()
 {
 	// Turn all the references into email addresses
 	List<AddressMeta> Styles;
 	if (Edit && Edit->GetStyles(Styles))
 	{
 		for (auto a: Styles)
 		{
 			if (!a->IsResolved() &&
 				a->IsUnique())
 			{
 				a->Ins();
 			}
 		}
 	}
 }
 
 void GroupUi::OnSave()
 {
 	ResolveAll();
 	
 	// Save the group of contacts
+	LDateTime Now;
+	Now.SetNow();
+
 	Item->SetDirty();
 	SerializeUi(GroupFieldDefs, Item->GetObject(), this, false);
+	Item->GetObject()->SetDate(FIELD_DATE_MODIFIED, &Now);
 	Item->Save();
 	Item->Update();
 }
 
 int GroupUi::OnNotify(LViewI *c, LNotification n)
 {
 	switch (c->GetId())
 	{
 		case IDOK:
 		{
-			OnSave();
-			
-			PostEvent(M_CLOSE);
+			OnSave();			
+			Quit();
 			break;
 		}
 	}
 
 	return 0;
 }
 
 int GroupUi::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	Formats.Supports(ScribeThingList);
 	Formats.SupportsFileDrops();	
 	return Formats.GetSupported().Length() ? DROPEFFECT_COPY : DROPEFFECT_NONE;
 }
 
 void GroupUi::Add(char *Email)
 {
 	ResolveAll();
 	
 	if (Edit)
 	{	
 		List<AddressMeta> Styles;
 		Edit->GetStyles(Styles);
 		for (auto a: Styles)
 		{
 			if (a->Addr.sAddr &&
 				_stricmp(a->Addr.sAddr, Email) == 0)
 			{
 				LgiTrace("%s:%i - '%s' already in group\n", _FL, Email);
 				return;
 			}
 		}
 		
 		char16 NewLine[] = { '\n', 0 };
 		char16 *e = Utf8ToWide(Email);
 		if (e)
 		{
 			auto Len = StrlenW(Edit->NameW());
 			if (Len) Edit->Insert(Len, NewLine, 1);
 			Edit->Insert(Len + 1, e, StrlenW(e));
 		}
 	}	
 }
 
 int GroupUi::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	int Status = DROPEFFECT_NONE;
 
 	for (unsigned n=0; n<Data.Length(); n++)
 	{
 		LDragData &dd = Data[n];
 		if (dd.IsFormat(ScribeThingList))
 		{
 			for (unsigned k=0; k<dd.Data.Length(); k++)
 			{
 				LVariant *Data = &dd.Data[k];
 				if (Data->IsBinary() &&
 					ScribeClipboardFmt::IsThing(Data->Value.Binary.Data, Data->Value.Binary.Length))
 				{
 					ScribeClipboardFmt *Fmt = (ScribeClipboardFmt*)Data->Value.Binary.Data;
 					
 					for (unsigned i=0; i<Fmt->Length(); i++)
 					{
 						Contact *c = Fmt->ThingAt(i) ? Fmt->ThingAt(i)->IsContact() : NULL;
 						if (c)
 						{
 							auto Email = c->GetAddrAt(0);
 							if (Email)
 							{
 								Add(Email);
 								Status = DROPEFFECT_COPY;
 							}
 							else LgiTrace("%s:%i - No addr\n", _FL);
 						}
 						else LgiTrace("%s:%i - Not a contact\n", _FL);
 					}
 				}
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			LgiTrace("%s:%i - Impl file drop here\n", _FL);			
 		}
 	}
 
 	return Status;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 #define EDIT_OPEN_CONTACT		100
 #define EDIT_DELETE				101
 #define EDIT_ADDR_BASE			1000
 
 #define GEDIT 'GEDT'
 
 AddressMeta::AddressMeta(LAddressEdit *edit, int id) :
 	Addr(edit->App)
 {
 	Edit = edit;
 	Id = id < 0 ? edit->CreateId() : id;
 	Referenced = false;
 
 	LAssert(!Edit->Map.Find(Id));
 	Edit->Map.Add(Id, this);
 }
 
 AddressMeta::~AddressMeta()
 {
 	LAssert(Edit->Map.Find(Id));
 	Edit->Map.Delete(Id, true);
 }
 
 bool AddressMeta::IsUnique()
 {
 	return Addr.Length() == 1;
 }
 
 bool AddressMeta::IsResolved()
 {
 	bool Status = false;
 
 	if (IsUnique())
 	{
 		RecipientItem *r = Addr[0];
 		if (r && ValidStr(r->GetEmail()))
 		{
 			Contact *c = r->GetContact();
 			if (c)
 			{
 				auto Emails = c->GetEmails();
 				for (auto e: Emails)
 				{
 					if (e.Equals(Text))
 					{
 						Status = true;
 						break;
 					}
 				}
 			}
 			else
 			{
 				Status = _stricmp(Text, r->GetEmail()) == 0;
 			}
 		}
 	}
 	
 	return Status;
 }
 
 void AddressMeta::Ins()
 {
 	RecipientItem *r = Addr[0];
 	if (r)
 	{
 		const char *n = Addr.sAddr;
 		if (!n)
 			n = r->GetEmail();
 
 		LAutoWString Name(Utf8ToWide(n));
 		if (Name)
 		{
 			/*
 			auto v = Style->View;
 
 			Edit->AllowPour = false;
 			v->Delete(Style->Start, Style->Len);
 			Edit->AllowPour = true;
 
 			Style->Len = StrlenW(Name);
 			auto sl = Style->End();
 				
 			// This may delete this object... so don't use anything local afterwards
 			v->Insert(Style->Start, Name, Style->Len);
 				
 			// No local!
 			v->Invalidate();
 			v->SetCaret(sl, false, false);
 			*/
 		}
 	}
 }
 
 void AddressMeta::OpenContact()
 {
 	if (Addr.Length() == 1)
 	{
 		RecipientItem *r = Addr[0];
 		if (r && r->GetContact())
 		{
 			r->GetContact()->DoUI();
 		}
 	}
 }
 
 LAddressEdit::LAddressEdit(LRect *p, const char *t) : LTextView3(-1, 0, 0, 100, 100, 0)
 {
 	App = NULL;
 	AllowPour = true;
 	if (p) SetPos(*p);
 	Sunken(true);
 }
 
 void LAddressEdit::OnPaint(LSurface *pDC)
 {
 	LTextView3::OnPaint(pDC);
 
 	#if 0// def _DEBUG
 	pDC->ClipRgn(0);
 
 	char s[256];
 	sprintf_s(s, sizeof(s), "%i styles", Style.Length());
 	LSysFont->Colour(Rgb24(0, 0, 255), 24);
 	LSysFont->Transparent(true);
 	LDisplayString ds(LSysFont, s);
 	ds.Draw(pDC, 2, Y()-20);
 	#endif
 }
 
 void LAddressEdit::PourStyle(size_t Start, ssize_t Length)
 {
 	if (AllowPour)
 	{
 		const char *Delim = " \t\r\n,;";
 
 		LUnrolledList<LStyle> Old, New;
 		Old.Swap(Style);
 
 		for (auto i : Map)
 		{
 			i.value->Referenced = false;
 		}
 
 		LHashTbl<IntKey<ssize_t>,LStyle*> Hash;
 		for (auto &i : Old)
 		{
 			LAssert(i.Data.Type != GV_NULL);
 			Hash.Add(i.Start, &i);
 		}
 
 		// Generate the new list...
 		for (int i=0; i<Size;)
 		{
 			// Match word
 			while (i<Size && strchr(Delim, Text[i])) i++;
 			int Start = i;
 			while (i<Size && !strchr(Delim , Text[i])) i++;
 			int Len = i - Start;
 
 			if (Len > 0)
 			{
 				// Insert new style
 				LAssert(App != NULL);
 				auto &s = New.New().Construct(this, STYLE_ADDRESS);
 				s.Start = Start;
 				s.Len = Len;
 			}
 		}
 
 		// Match the old and new lists, merging unchanged entries from
 		// the old list and taking changed entries from the new list.
 		AddressMeta *m;
 		for (auto &n : New)
 		{
 			// Find matching old entry
 			LString s(Text + n.Start, n.Len);
 			auto o = Hash.Find(n.Start);
 			if (o && o->Len == n.Len)
 			{
 				// Carry over the data ref id
 				LAssert(o->Data.Type != GV_NULL);
 				n.Data = o->Data;
 				n.Font = o->Font;
 				n.Fore = o->Fore;
 				n.Back = o->Back;
 				n.Decor = o->Decor;
 				n.DecorColour = o->DecorColour;
 				
 				auto m = GetMeta(n);
 				if (m)
 				{
 					// LgiTrace("Existing meta @ %i '%s'\n", n.Start, m->Text.Get());
 					m->Referenced = true;
 				}
 			}
 			else
 			{
 				// Create a new entry
 				if ((m = new AddressMeta(this)))
 				{
 					n.Data = m->Id;
 					m->Referenced = true;
 					m->Text.SetW(Text + n.Start, n.Len);
 					UpdateMeta(n);
 
 					// LgiTrace("Creating meta @ %i '%s' with id=%i\n", n.Start, m->Text.Get(), m->Id);
 				}
 			}
 
 		}
 
 		// Clear out unreferenced meta objects
 		for (auto i : Map)
 		{
 			if (i.value->Referenced == false)
 			{
 				// LgiTrace("Deleting unreferenced meta '%s'\n", i.value->Text.Get());
 				delete i.value;
 			}
 		}
 
 		#ifdef _DEBUG
 		for (auto &s : New)
 		{
 			LAssert(s.Data.Type != GV_NULL);
 		}
 		#endif
 
 		Style.Swap(New);
 
 		// Update
 		LRect r(0, Y()-20, 100, Y());
 		Invalidate(&r);
 		
 		#if 0
 		printf("Styles:\n");
 		for (GEditAddress *e=(GEditAddress*)Style.First(); e; e=(GEditAddress*)Style.Next())
 		{
 			printf("\tStart=%i Len=%i Text=%.*S\n", e->Start, e->Len, e->Len, Text+e->Start);
 		}
 		#endif
 	}
 }
 
 bool LAddressEdit::Insert(size_t At, const char16 *Data, ssize_t Len)
 {
 	for (auto &s : Style)
 	{
 		LAssert(s.Data.Type != GV_NULL);
 		if (s.Start > (ssize_t)At)
 		{
 			/*auto m =*/ GetMeta(s);
 			// LgiTrace("Insert adding to start: %i->%i '%s'\n", s.Start, s.Start + Len, m ? m->Text.Get() : NULL);
 			s.Start += Len;
 		}
 	}
 
 	return LTextView3::Insert(At, Data, Len);
 }
 
 bool LAddressEdit::Delete(size_t at, ssize_t Len)
 {
 	ssize_t At = (ssize_t)at;
 	for (auto &s : Style)
 	{
 		LAssert(s.Data.Type != GV_NULL);
 		AddressMeta *m = GetMeta(s);
 
 		if (s.Overlap(At, Len) &&
 			m &&
 			m->Matched())
 		{
 			// extend delete region to include the whole styled addr
 			if (At > s.Start)
 			{
 				Len += At - s.Start;
 				At = s.Start;
 			}
 			if (At + Len < s.Start + s.Len)
 			{
 				Len = s.Start + s.Len - At;
 			}
 
 			// LgiTrace("Delete len change: %i:%i '%s'\n", s.Start, s.Len, m ? m->Text.Get() : NULL);
 		}
 
 		if (s.Start > At)
 		{
 			s.Start -= Len;
 			// LgiTrace("Delete start change: %i:%i '%s'\n", s.Start, s.Len, m ? m->Text.Get() : NULL);
 		}
 	}
 
 	return LTextView3::Delete(At, Len);
 }
 
 bool LAddressEdit::GetStyles(List<AddressMeta> &Styles)
 {
 	/*
 	Styles.Empty();
 	for (GEditAddress *s = (GEditAddress*) Style.First(); s; s = (GEditAddress*) Style.Next())
 	{
 		Styles.Insert(s);
 	}
 	return Styles.First() != 0;	
 	*/
 
 	return false;
 }
 
 int LAddressEdit::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	LWindow *w = GetWindow();
 	LDragDropTarget *t = dynamic_cast<LDragDropTarget*>(w);
 	if (t)
 	{
 		return t->WillAccept(Formats, Pt, KeyState);
 	}
 	return DROPEFFECT_NONE;
 }
 
 bool LAddressEdit::OnStyleClick(LStyle *style, LMouse *ms)
 {
 	auto m = GetMeta(*style);
 	if (!m)
 		return false;
 
 	if (ms->Double() && ms->Left())
 	{
 		m->OpenContact();
 		return true;
 	}
 	
 	return false;
 }
 
 bool LAddressEdit::OnStyleMenu(LStyle *style, LSubMenu *sub)
 {
 	auto m = GetMeta(*style);
 	if (!m)
 		return false;
 
 	if (m->Addr.Length() == 1)
 	{
 		sub->AppendItem("Open Contact", EDIT_OPEN_CONTACT, true);
 		sub->AppendItem("Delete", EDIT_DELETE, true);
 	}
 	else
 	{
 		Items.DeleteObjects();
 		AddressBrowseLookup(App, Items, m->Text);
 
 		if (Items.Length())
 		{
 			int Idx = 0;
 			for (auto i : Items)
 			{
 				LString n;
 				n.Printf("%s %s <%s>", i->First.Get(), i->Last.Get(), i->Email.Get());
 				sub->AppendItem(n, EDIT_ADDR_BASE + Idx++);
 			}
 		}
 		else
 		{
 			sub->AppendItem("No results", -1, false);
 		}
 	}
 
 	sub->AppendSeparator();
 
 	/*
 	if (IsOk() && Addr.Length() > 0)
 	{
 		if (Addr.Length() == 1)
 		{
 			m->AppendItem("Open Contact", EDIT_OPEN_CONTACT, true);
 			m->AppendItem("Delete", EDIT_DELETE, true);
 			m->AppendSeparator();
 		}
 
 		char s[256];
 		for (int i=0; i<Addr.Length(); i++)
 		{
 			Contact *c = Addr[i]->GetContact();
 			if (c)
 			{
 				LAutoString Email;
 				for (int n=0; (Email = c->GetAddrAt(n)); n++)
 				{
 					char *First = 0, *Last = 0;
 
 					s[0] = 0;
 					c->Get(OPT_First, First);
 					c->Get(OPT_Last, Last);
 					
 					if (First)
 					{
 						if (*s) strcat(s, " ");
 						strcat(s, First);
 					}
 					if (Last)
 					{
 						if (*s) strcat(s, " ");
 						strcat(s, Last);
 					}
 					int len = (int)strlen(s);
 					sprintf_s(s+len, sizeof(s)-len, " <%s>", (char*)Email);
 					int k = (i << 8) + n;
 					m->AppendItem(	s,
 									EDIT_ADDR_BASE + k,
 									ValidStr(Email));
 					LgiTrace("Adding contact '%s' %i:%i (%k)\n", s, i, n, k);
 				}
 			}
 			else
 			{
 				char *Name = Addr[i]->GetName();
 				char *Email = Addr[i]->GetEmail();
 				sprintf_s(s, sizeof(s), "%s <%s>", Name, Email);
 				m->AppendItem(	s,
 								EDIT_ADDR_BASE + (i << 8),
 								ValidStr(Email));
 			}
 		}
 
 		return true;
 	}
 	*/
 
 	return false;
 }
 
 void LAddressEdit::OnStyleMenuClick(LStyle *style, int i)
 {
 	auto m = GetMeta(*style);
 	if (!m)
 		return;
 
 	switch (i)
 	{
 		case EDIT_OPEN_CONTACT:
 		{
 			m->OpenContact();
 			break;
 		}
 		case EDIT_DELETE:
 		{
 			// This will delete us, don't access anything local afterwards
 			Delete(style->Start, style->Len);
 				
 			// Update the edit and get outta here
 			Invalidate();
 			return;
 			break;
 		}
 		default:
 		{
 			BrowseItem *r = Items[i - EDIT_ADDR_BASE];
 			if (r)
 			{
 				Contact *c = Contact::LookupEmail(r->Email);
 				if (c)
 				{
 					style->Fore = LColour(L_TEXT);
 					m->Addr.SetWho(new RecipientItem(c), -1);
 					
 					LAutoWString wEmail(Utf8ToWide(r->Email));
 
 					auto Start = style->Start;
 					auto Len = style->Len;
 					Delete(Start, Len);
 					Insert(Start, wEmail, Strlen(wEmail.Get()));
 				}
 			}
 		}
 	}
 }
 
 int LAddressEdit::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	LWindow *w = GetWindow();
 	LDragDropTarget *t = dynamic_cast<LDragDropTarget*>(w);
 	if (t)
 	{
 		return t->OnDrop(Data, Pt, KeyState);
 	}
 	return DROPEFFECT_NONE;
 }
 
 class LAddressEditFactory : public LViewFactory
 {
 public:
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (strcmp(Class, "LAddressEdit") == 0)
 		{
 			return new LAddressEdit(Pos, Text);
 		}
 
 		return 0;
 	}
 }	AddressEditFactory;
 
 //////////////////////////////////////////////////////////////////////////////
 LGroupMap::LGroupMap(ScribeWnd *app) : App(app)
 {
 	auto srcs = App->GetThingSources(MAGIC_GROUP);
 	for (auto s: srcs)
 	{
 		s->LoadThings();
 		for (auto i: s->Items)
 			Index(i->IsGroup());
 	}		
 }
 
 LGroupMap::~LGroupMap()
 {
 	DeleteObjects();
 }
 
 void LGroupMap::Index(ContactGroup *grp)
 {
 	if (!grp)
 		return;
 
 	for (auto email: grp->GetAddresses())
 	{
 		auto a = Find(email);
 		if (!a)
 		{
 			a = new LGroupMapArray;
 			Add(email, a);
 		}
 		a->Add(grp);
 	}
 }
diff --git a/Resources/PreviewGroup.html b/Resources/PreviewGroup.html
--- a/Resources/PreviewGroup.html
+++ b/Resources/PreviewGroup.html
@@ -1,49 +1,53 @@
 <html>
 <head>
 	<meta name="charset" content="utf-8">
 	<style>
 	.field {
 		text-align: right;
 		color: #888;
 	}
 	.name {
 		font-weight: bold;
 	}
 	body {
 		background: ThreeDFace;
 	}
 	</style>
 	<script type="text/javascript" language="JavaScript">
 		function init()
 		{
 			Txt = getElementById("email");
 			if (Txt)
 			{
 			    Email = Thing.List.Split("\n");
 			    s = "";
 			    for (i=0; i<Email.Length; i++)
 			    {
 			        e = Email[i];
 			        if (i)
 			            s += "<br>\n";
 			        s += "<a href='" + e + "'>" + e + "</a>";
 			    }
 			    Txt.innerHTML = s;
 			    Print(s + "\n");
 		    }
 		}
 	</script>
 </head>
 <body onload="init();">
 	<table>
 		<tr>
 			<td class=field>Name:
 			<td><? contactgroup.Name ?>
 		</tr>
 		<tr>
 			<td class=field>Members:
 			<td id="email">
 		</tr>
+		<tr>
+			<td class=field>DateModified:
+			<td><? contactgroup.DateModified ?>
+</tr>
 	</table>
 </body>
 </html>
\ No newline at end of file
diff --git a/Windows/Scribe_vs2019.vcxproj b/Windows/Scribe_vs2019.vcxproj
--- a/Windows/Scribe_vs2019.vcxproj
+++ b/Windows/Scribe_vs2019.vcxproj
@@ -1,729 +1,730 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Debug|x64">
       <Configuration>Debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="ReleaseNoOptimize|Win32">
       <Configuration>ReleaseNoOptimize</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="ReleaseNoOptimize|x64">
       <Configuration>ReleaseNoOptimize</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|Win32">
       <Configuration>Release</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|x64">
       <Configuration>Release</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectName>Scribe</ProjectName>
     <ProjectGuid>{540DDE64-0927-4E67-B927-2E3BE7ECB029}</ProjectGuid>
     <RootNamespace>Scribe_vc8</RootNamespace>
     <Keyword>Win32Proj</Keyword>
     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
     <_ProjectFileVersion>12.0.30501.0</_ProjectFileVersion>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <PreLinkEventUseInBuild>false</PreLinkEventUseInBuild>
     <LinkIncremental>true</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;C:\Office 2010 Developer Resources\include;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">
     <OutDir>$(Platform)$(Configuration)19\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>C:\Program Files\OpenSSL-Win64\include;P:\CodeLib\libpng-1.6.26;P:\CodeLib\zlib-1.2.8;P:\CodeLib\libjpeg-9a;$(IncludePath)</IncludePath>
     <TargetName>$(ProjectName)</TargetName>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\Code;..\Resources;..\Code\Sqlite;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\include;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\private\common;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\libpng\build32;..\..\..\..\CodeLib\libpng\build32\zlib_dir;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;..\..\libs\mapi;..\..\libs\libchardet\src;..\..\libs\libchardet\include;c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\mapi;c:\Program Files (x86)\OpenSSL\include;%(AdditionalIncludeDirectories);Utils\Tables</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN32;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <PrecompiledHeader />
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <ShowIncludes>false</ShowIncludes>
     </ClCompile>
     <PreLinkEvent>
       <Message>Update version</Message>
       <Command>cd Code\Py
 "C:\Program Files\Python36\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat"
 rc Resource.rc
 cd ..
 copy Code\Resource.res $(OutDir)
 </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet14x32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x32;..\..\..\Lgi\trunk\lib;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX86</TargetMachine>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\Code;..\Code\Sqlite;..\Resources;..\Utils\Tables;..\..\libs\mapi;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\build-x64\libiconv-1.17\include;..\..\libs\build-x64\libpng\zlib_dir;..\..\libs\build-x64\libpng;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\private\common;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\include;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;c:\Program Files\OpenSSL\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN64;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <PreLinkEvent>
       <Command>
       </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet19x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x64;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;..\..\..\Lgi\trunk\lib;..\..\..\CodeLib\protobuf-3.9.1\cmake\build\solution\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX64</TargetMachine>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
       <VerboseOutput>true</VerboseOutput>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\Code;..\Resources;..\Code\Sqlite;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\include;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\private\common;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\libpng\build32;..\..\..\..\CodeLib\libpng\build32\zlib_dir;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;..\..\libs\mapi;c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\mapi;c:\Program Files (x86)\OpenSSL\include;%(AdditionalIncludeDirectories);Utils\Tables;..\crashpad-release-x86-64-stable\include;..\crashpad-release-x86-64-stable\include\mini_chromium</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN32;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader />
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <PreLinkEvent>
       <Command>cd Code\Py
 "C:\Python37\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat"
 rc Resource.rc
 cd ..
 copy Code\Resource.res $(OutDir)
 </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet14x32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x32;..\..\..\Lgi\trunk\lib;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX86</TargetMachine>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <AdditionalIncludeDirectories>..\Code;..\Code\Sqlite;..\Resources;..\Utils\Tables;..\..\libs\mapi;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\build-x64\libiconv-1.17\include;..\..\libs\build-x64\libpng\zlib_dir;..\..\libs\build-x64\libpng;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\private\common;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\include;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;c:\Program Files\OpenSSL\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN64;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level1</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <Optimization>MinSpace</Optimization>
     </ClCompile>
     <PreLinkEvent>
       <Command>cd ..\Code\Py
 "C:\Program Files\Python39\python.exe"  win32_pre_build_step.py
 cd ..
 call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\amd64\vcvars64.bat"
 rc Resource.rc
 copy Resource.res ..\Windows\$(OutDir)</Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet19x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x64;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;..\..\..\Lgi\trunk\lib;..\..\..\CodeLib\protobuf-3.9.1\cmake\build\solution\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX64</TargetMachine>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>..\Code;..\Resources;..\Code\Sqlite;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\include;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\private\common;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\libpng\build32;..\..\..\..\CodeLib\libpng\build32\zlib_dir;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;..\..\libs\mapi;c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\mapi;c:\Program Files (x86)\OpenSSL\include;%(AdditionalIncludeDirectories);Utils\Tables;..\crashpad-release-x86-64-stable\include;..\crashpad-release-x86-64-stable\include\mini_chromium</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN32;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader />
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <PreLinkEvent>
       <Message>Update Version</Message>
       <Command>cd Code\Py
 "C:\Python37\python.exe"  win32_pre_build_step.py
 cd ..
 call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat"
 rc Resource.rc
 cd ..
 copy Code\Resource.res $(OutDir)
 </Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet14x32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x32;..\..\..\Lgi\trunk\lib;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX86</TargetMachine>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <AdditionalIncludeDirectories>..\Code;..\Code\Sqlite;..\Resources;..\Utils\Tables;..\..\libs\mapi;..\..\libs\libchardet\include;..\..\libs\libchardet\src;..\..\libs\build-x64\libiconv-1.17\include;..\..\libs\build-x64\libpng\zlib_dir;..\..\libs\build-x64\libpng;..\..\libs\aspell-0.60.6.1\interfaces\cc;..\..\..\Lgi\trunk\private\common;..\..\..\Lgi\trunk\include\lgi\win;..\..\..\Lgi\trunk\include;..\..\..\..\CodeLib\libpng;..\..\..\..\CodeLib\zlib;..\..\..\..\CodeLib\libjpeg-9a;c:\Program Files\OpenSSL\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>SCRIBE_APP;WIN64;HAVE_STRING_H;WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <WarningLevel>Level1</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <Optimization>MinSpace</Optimization>
     </ClCompile>
     <PreLinkEvent>
       <Command>cd ..\Code\Py
 "C:\Program Files\Python39\python.exe"  win32_pre_build_step.py
 cd ..
 call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\amd64\vcvars64.bat"
 rc Resource.rc
 copy Resource.res ..\Windows\$(OutDir)</Command>
     </PreLinkEvent>
     <Link>
       <AdditionalDependencies>imm32.lib;Ws2_32.lib;libchardet\Release\chardet19x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <AdditionalLibraryDirectories>..\..\libs\build-x64;..\bzip2-1.0.6\windows\$(Platform)$(Configuration)14;..\aspell-0.60.6.1\win32\dist\$(Platform)$(Configuration)14;..\..\..\Lgi\trunk\lib;..\..\..\CodeLib\protobuf-3.9.1\cmake\build\solution\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <TargetMachine>MachineX64</TargetMachine>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <Manifest>
       <AdditionalManifestFiles>..\Resources\ScribeWindows.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\LexCpp.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptCompiler.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptLibrary.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptVM.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\Db-Csv.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\DbTable.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Gif.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Jpeg.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Lzw.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Png.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Tiff.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Font\EmojiFont.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\DrawListSurface.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Tools\GdcTools.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SegmentTree.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SharedMemory.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SoftwareUpdate.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\TimeZone.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\Tnef.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mime.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\HttpTools.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Ftp.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Http.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OAuth2.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\WebDav.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mail.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailHttp.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailImap.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OpenSSLSocket.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\Browser.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\LgiMain.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Storage\3\Store3.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiMap.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiTools.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\Homoglyphs.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\HomoglyphsTable.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Html.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlCommon.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlParser.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\SpellCheckAspell.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\XmlTreeUi.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\RtfHtml.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\TextConvert.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\vCard-vCal.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\BlockCursor.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEdit.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\HorzRuleBlock.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\ImageBlock.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\TextBlock.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ColourSelect.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ControlTree.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\DatePopup.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\FilterUi.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Graph.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\TimePopup.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ZoomView.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\MonthView.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\YearView.cpp" />
     <ClCompile Include="..\..\..\Lgi\trunk\src\win\Lgi\SpellCheckWindows.cpp" />
     <ClCompile Include="..\..\libs\Btree\btree.c" />
     <ClCompile Include="..\..\libs\Btree\btree_delete.c" />
     <ClCompile Include="..\..\libs\Btree\btree_header.c" />
     <ClCompile Include="..\..\libs\Btree\btree_insert.c" />
     <ClCompile Include="..\..\libs\Btree\btree_lock.c" />
     <ClCompile Include="..\..\libs\Btree\btree_node.c" />
     <ClCompile Include="..\..\libs\Btree\btree_search.c" />
     <ClCompile Include="..\..\libs\Btree\btree_traverse.c" />
     <ClCompile Include="..\..\libs\Btree\config.c" />
     <ClCompile Include="..\..\libs\Btree\db.c" />
     <ClCompile Include="..\..\libs\Btree\db_blocklist.c" />
     <ClCompile Include="..\..\libs\Btree\db_blocks.c" />
     <ClCompile Include="..\..\libs\Btree\db_cache.c" />
     <ClCompile Include="..\..\libs\Btree\db_header.c" />
     <ClCompile Include="..\..\libs\Btree\db_lock.c" />
     <ClCompile Include="..\..\libs\Btree\db_utils.c" />
     <ClCompile Include="..\..\libs\Btree\gbtree.cpp" />
     <ClCompile Include="..\..\libs\Btree\hashtable.c" />
     <ClCompile Include="..\..\libs\Btree\offsetlist.c" />
     <ClCompile Include="..\Code\AddressSelect.cpp" />
     <ClCompile Include="..\Code\BayesDlg.cpp" />
     <ClCompile Include="..\Code\BayesianFilter.cpp" />
     <ClCompile Include="..\Code\Calendar.cpp" />
     <ClCompile Include="..\Code\CalendarView.cpp" />
     <ClCompile Include="..\Code\Components.cpp" />
     <ClCompile Include="..\Code\Encryption\GnuPG.cpp" />
     <ClCompile Include="..\Code\Exp_Scribe.cpp" />
     <ClCompile Include="..\Code\FolderCalendarSource.cpp" />
     <ClCompile Include="..\Code\GBTreeWordStore.cpp" />
     <ClCompile Include="..\Code\NewMailDlg.cpp" />
     <ClCompile Include="..\Code\RemoteCalendarSource.cpp" />
     <ClCompile Include="..\Code\SearchView.cpp" />
     <ClCompile Include="..\Code\HtmlToText.cpp" />
     <ClCompile Include="..\Code\ImpExp_Mbox.cpp" />
     <ClCompile Include="..\Code\ImpExp_Outlook.cpp" />
     <ClCompile Include="..\Code\Imp_CsvContacts.cpp" />
     <ClCompile Include="..\Code\Imp_Eml.cpp" />
     <ClCompile Include="..\Code\Imp_Eudora.cpp" />
     <ClCompile Include="..\Code\Imp_Mozilla.cpp" />
     <ClCompile Include="..\Code\Imp_NetscapeContacts.cpp" />
     <ClCompile Include="..\Code\Imp_OutlookExpress.cpp" />
     <ClCompile Include="..\Code\ManageMailStores.cpp" />
     <ClCompile Include="..\Code\MContainer.cpp" />
     <ClCompile Include="..\Code\ObjectInspector.cpp" />
     <ClCompile Include="..\Code\OptionsDlg.cpp" />
     <ClCompile Include="..\Code\PreviewPanel.cpp" />
     <ClCompile Include="..\Code\PrintContext.cpp" />
     <ClCompile Include="..\Code\PrintPreview.cpp" />
     <ClCompile Include="..\Code\ReplicateDlg.cpp" />
     <ClCompile Include="..\Code\ScribeAbout.cpp" />
     <ClCompile Include="..\Code\ScribeAccount.cpp" />
     <ClCompile Include="..\Code\ScribeAccountPreview.cpp" />
     <ClCompile Include="..\Code\ScribeAccountUI.cpp" />
     <ClCompile Include="..\Code\ScribeApp.cpp" />
     <ClCompile Include="..\Code\ScribeAttachment.cpp" />
     <ClCompile Include="..\Code\ScribeContact.cpp" />
     <ClCompile Include="..\Code\ScribeFilter.cpp" />
     <ClCompile Include="..\Code\ScribeFinder.cpp" />
     <ClCompile Include="..\Code\ScribeFolder.cpp" />
     <ClCompile Include="..\Code\ScribeFolderDlg.cpp" />
     <ClCompile Include="..\Code\ScribeFolderProp.cpp" />
     <ClCompile Include="..\Code\ScribeFolderSelect.cpp" />
     <ClCompile Include="..\Code\ScribeFolderTree.cpp" />
     <ClCompile Include="..\Code\ScribeGroup.cpp" />
     <ClCompile Include="..\Code\ScribeItemList.cpp" />
     <ClCompile Include="..\Code\ScribeLangDlg.cpp" />
     <ClCompile Include="..\Code\ScribeListAddr.cpp" />
     <ClCompile Include="..\Code\ScribeMail.cpp" />
     <ClCompile Include="..\Code\ScribeMain.cpp" />
     <ClCompile Include="..\Code\ScribePageSetup.cpp" />
     <ClCompile Include="..\Code\ScribePassword.cpp" />
     <ClCompile Include="..\Code\ScribeSendReceive.cpp" />
     <ClCompile Include="..\Code\ScribeSockets.cpp" />
     <ClCompile Include="..\Code\ScribeStatusPanel.cpp" />
     <ClCompile Include="..\Code\ScribeThing.cpp" />
     <ClCompile Include="..\Code\ScribeUi.cpp" />
     <ClCompile Include="..\Code\ScribeUtils.cpp" />
     <ClCompile Include="..\Code\Scripting.cpp" />
     <ClCompile Include="..\Code\SecurityDlg.cpp" />
     <ClCompile Include="..\Code\Sqlite\v3.6.14\sqlite3.c" />
     <ClCompile Include="..\Code\Store3Common.cpp" />
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Attachment.cpp" />
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Folder.cpp" />
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Mail.cpp" />
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Store.cpp" />
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Thread.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Attachment.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Calendar.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Contact.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Filter.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Folder.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Group.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Mail.cpp" />
     <ClCompile Include="..\Code\Store3Mail3\Mail3Store.cpp" />
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Attachment.cpp" />
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Calendar.cpp" />
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Contact.cpp" />
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Folder.cpp" />
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Mail.cpp" />
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Store.cpp" />
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Thing.cpp" />
     <ClCompile Include="..\Code\Store3Webdav\WebdavCalendar.cpp" />
     <ClCompile Include="..\Code\Store3Webdav\WebdavContact.cpp" />
     <ClCompile Include="..\Code\Store3Webdav\WebdavFolder.cpp" />
     <ClCompile Include="..\Code\Store3Webdav\WebdavStore.cpp" />
     <ClCompile Include="..\Code\Store3Webdav\WebdavThread.cpp" />
     <ClCompile Include="..\Code\TitlePage.cpp" />
     <ClCompile Include="..\Utils\Tables\MailFlags.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LDbTable.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LWebDav.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\OpenSSLSocket.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\ZlibWrapper.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Browser.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ColourSelect.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ControlTree.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DateTimeCtrls.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Db.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DrawListSurface.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Emoji.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\EmojiFont.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\FilterUi.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Ftp.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\GdcTools.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Graph.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Homoglyphs.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Html.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlCommon.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlParser.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Http.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HttpTools.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mail.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mime.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OAuth2.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OpenSSLSocket.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\RichTextEdit.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Scripting.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SegmentTree.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SharedMemory.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SoftwareUpdate.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SpellCheck.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3Defs.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3MimeTree.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\StoreCommon.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\TextConvert.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Tnef.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\WebDav.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\XmlTreeUi.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ZoomView.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\Instructions.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptingPriv.h" />
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.h" />
     <ClInclude Include="..\..\libs\Btree\btree.h" />
     <ClInclude Include="..\..\libs\Btree\btree_header.h" />
     <ClInclude Include="..\..\libs\Btree\btree_lock.h" />
     <ClInclude Include="..\..\libs\Btree\btree_node.h" />
     <ClInclude Include="..\..\libs\Btree\config.h" />
     <ClInclude Include="..\..\libs\Btree\db.h" />
     <ClInclude Include="..\..\libs\Btree\db_blocklist.h" />
     <ClInclude Include="..\..\libs\Btree\db_blocks.h" />
     <ClInclude Include="..\..\libs\Btree\db_cache.h" />
     <ClInclude Include="..\..\libs\Btree\db_header.h" />
     <ClInclude Include="..\..\libs\Btree\db_internal.h" />
     <ClInclude Include="..\..\libs\Btree\db_lock.h" />
     <ClInclude Include="..\..\libs\Btree\db_types.h" />
     <ClInclude Include="..\..\libs\Btree\db_utils.h" />
     <ClInclude Include="..\..\libs\Btree\gbtree.h" />
     <ClInclude Include="..\..\libs\Btree\hashtable.h" />
     <ClInclude Include="..\..\libs\Btree\offsetlist.h" />
     <ClInclude Include="..\Code\BayesianFilter.h" />
     <ClInclude Include="..\Code\Calendar.h" />
     <ClInclude Include="..\Code\CalendarView.h" />
     <ClInclude Include="..\Code\Components.h" />
     <ClInclude Include="..\Code\DomFields.h" />
     <ClInclude Include="..\Code\DomType.h" />
     <ClInclude Include="..\Code\DomTypeValues.h" />
     <ClInclude Include="..\Code\Encryption\GnuPG.h" />
     <ClInclude Include="..\Code\Imp_Outlook.h" />
     <ClInclude Include="..\Code\ManageMailStores.h" />
     <ClInclude Include="..\Code\ObjectInspector.h" />
     <ClInclude Include="..\Code\PreviewPanel.h" />
     <ClInclude Include="..\Code\PrintContext.h" />
     <ClInclude Include="..\Code\PrintPreview.h" />
     <ClInclude Include="..\Code\ReplicateDlg.h" />
     <ClInclude Include="..\Code\Scribe.h" />
     <ClInclude Include="..\Code\ScribeAccountPreview.h" />
     <ClInclude Include="..\Code\ScribeAccountUI.h" />
     <ClInclude Include="..\Code\ScribeDefs.h" />
     <ClInclude Include="..\Code\ScribeFolderDlg.h" />
     <ClInclude Include="..\Code\ScribeFolderSelect.h" />
     <ClInclude Include="..\Code\ScribeInc.h" />
     <ClInclude Include="..\Code\ScribeListAddr.h" />
     <ClInclude Include="..\Code\ScribePageSetup.h" />
     <ClInclude Include="..\Code\ScribePrivate.h" />
     <ClInclude Include="..\Code\ScribeStatusPanel.h" />
     <ClInclude Include="..\Code\ScribeUtils.h" />
     <ClInclude Include="..\Code\Sqlite\v3.6.14\sqlite3.h" />
     <ClInclude Include="..\Code\Sqlite\v3.6.14\sqlite3ext.h" />
     <ClInclude Include="..\Code\Store3Imap\include\Scribe.pb.h" />
     <ClInclude Include="..\Code\Store3Imap\ScribeImap.h" />
     <ClInclude Include="..\Code\Store3Mail3\Mail3.h" />
     <ClInclude Include="..\Code\Store3Mapi\ScribeMapi.h" />
     <ClInclude Include="..\Code\Store3Webdav\WebdavStore.h" />
     <ClInclude Include="..\Code\Store3Webdav\WebdavStorePriv.h" />
     <ClInclude Include="..\Scripts\ScribeScripts.h" />
     <ClInclude Include="..\Utils\Tables\Tables.h" />
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="..\..\..\Lgi\trunk\src\common\Coding\ExternCall.asm">
       <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">cd $(IntDir)
 "c:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\x86_amd64\ml64.exe" %(FullPath) /c</Command>
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(IntDir)%(Filename).obj;%(Outputs)</Outputs>
       <Command Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">cd $(IntDir)
 "c:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\x86_amd64\ml64.exe" %(FullPath) /c</Command>
       <Outputs Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">$(IntDir)%(Filename).obj;%(Outputs)</Outputs>
       <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">cd $(IntDir)
 "c:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\x86_amd64\ml64.exe" %(FullPath) /c</Command>
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(IntDir)%(Filename).obj;%(Outputs)</Outputs>
     </CustomBuild>
     <None Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\gen.py" />
     <None Include="..\..\libs\build.py" />
     <None Include="..\Code\Encryption\Examples\encrypted+attach.eml" />
     <None Include="..\Code\Encryption\Examples\encrypted+html+attach+key.eml" />
     <None Include="..\Code\Encryption\Examples\encrypted.eml" />
     <None Include="..\Code\Encryption\Examples\signed+attach.eml" />
     <None Include="..\Code\Encryption\Examples\signed+encrypted.eml" />
     <None Include="..\Code\Encryption\Examples\signed+HTML+attach+key.eml" />
     <None Include="..\Code\Encryption\Examples\signed+html.eml" />
     <None Include="..\Code\Encryption\Examples\signed.eml" />
     <None Include="..\Code\Py\DomScan.py" />
     <None Include="..\Code\Py\win32_pre_build_step.py" />
     <None Include="..\Code\Store3Imap\Scribe.proto" />
     <None Include="..\Help\calendar.html" />
     <None Include="..\Help\contacts.html" />
     <None Include="..\Help\email.html" />
     <None Include="..\Help\features.html" />
     <None Include="..\Help\filters.html" />
     <None Include="..\Help\help.css" />
     <None Include="..\Help\import.html" />
     <None Include="..\Help\index.html" />
     <None Include="..\Help\install.html" />
     <None Include="..\Help\intro.html" />
     <None Include="..\Help\menu.html" />
     <None Include="..\Help\plugins.html" />
     <None Include="..\Help\print.html" />
     <None Include="..\Help\scripting.html" />
     <None Include="..\Help\ui.html" />
     <None Include="..\Resources\About.html" />
     <None Include="..\Resources\PreviewContact.html" />
+    <None Include="..\Resources\PreviewGroup.html" />
     <None Include="..\Resources\PreviewMail.html" />
     <None Include="..\Resources\Themes\Dark\colours.json" />
     <None Include="..\Resources\Themes\Dark\styles.css" />
     <None Include="..\Resources\Title.html" />
     <None Include="..\Scripts\Add Senders To Contacts.script" />
     <None Include="..\Scripts\CovieRender.script" />
     <None Include="..\Scripts\DecrementAll.script" />
     <None Include="..\Scripts\Delete Attachments.script" />
     <None Include="..\Scripts\Delete Duplicate Messages.script" />
     <None Include="..\Scripts\LdapPlugin.script" />
     <None Include="..\Scripts\Mail Filters Menu.script" />
     <None Include="..\Utils\Store\check-build.py" />
     <None Include="..\Utils\Store\store.py" />
     <None Include="Installer-64bit.nsi" />
     <None Include="Installer-64bit.nsi.in" />
   </ItemGroup>
   <ItemGroup>
     <Image Include="..\Resources\Icons\app.ico" />
     <Image Include="..\Resources\Icons\Blank.ico" />
     <Image Include="..\Resources\Icons\calender.ico" />
     <Image Include="..\Resources\Icons\contact.ico" />
     <Image Include="..\Resources\Icons\error.ico" />
     <Image Include="..\Resources\Icons\event.ico" />
     <Image Include="..\Resources\Icons\filter.ico" />
     <Image Include="..\Resources\Icons\Mail.ico" />
     <Image Include="..\Resources\Icons\Small.ico" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="..\Code\Resource.rc" />
   </ItemGroup>
   <ItemGroup>
     <Manifest Include="..\Resources\ScribeWindows.manifest" />
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\Utils\Tables\MailFlags.txt" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\Lgi\trunk\Lgi_vs2019.vcxproj">
       <Project>{95df9ca4-6d37-4a85-a648-80c2712e0da1}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\..\lgi\trunk\src\common\Net\libntlm-0.4.2\build-win32\libntlm_vs2019.vcxproj">
       <Project>{f97aaaca-bf41-46b8-b534-a1639589a1a3}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\..\Lgi\trunk\Updater\Updater_vs2015.vcxproj">
       <Project>{11e9238b-921e-44e5-a3d2-61c5bfa7cc6c}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\libs\aspell-0.60.6.1\win32\dist\aspell-dist-0.60-vs2019.vcxproj">
       <Project>{1509fe6d-0b3a-422a-99d1-e26a26ce8da5}</Project>
     </ProjectReference>
     <ProjectReference Include="..\..\libs\bzip2-1.0.6\windows\bzip2-1.0.6-vs2019.vcxproj">
       <Project>{e5575141-c1a2-4997-badb-7584cf546e1f}</Project>
     </ProjectReference>
     <ProjectReference Include="..\ScribeMapi\ScribeMapi_vs2019.vcxproj">
       <Project>{148574ce-4da6-4b8a-9ec6-ff68adc2a046}</Project>
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/Windows/Scribe_vs2019.vcxproj.filters b/Windows/Scribe_vs2019.vcxproj.filters
--- a/Windows/Scribe_vs2019.vcxproj.filters
+++ b/Windows/Scribe_vs2019.vcxproj.filters
@@ -1,1071 +1,1077 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <ClCompile Include="..\..\libs\Btree\btree_traverse.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_delete.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_header.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_insert.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_lock.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_node.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\btree_search.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_blocklist.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_blocks.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_cache.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_header.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_lock.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\db_utils.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Calendar.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\CalendarView.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\GBTreeWordStore.cpp">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\gbtree.cpp">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiMap.cpp">
       <Filter>Emoji</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Emoji\EmojiTools.cpp">
       <Filter>Emoji</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Font\EmojiFont.cpp">
       <Filter>Emoji</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\AddressSelect.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\BayesDlg.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\BayesianFilter.cpp">
       <Filter>Filtering</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\BlockCursor.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ColourSelect.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ControlTree.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\DatePopup.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\DrawListSurface.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\FilterUi.cpp">
       <Filter>Filtering</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Ftp.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Exp_Scribe.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\FolderCalendarSource.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Tools\GdcTools.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Gif.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Graph.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Encryption\GnuPG.cpp">
       <Filter>Encryption</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\hashtable.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Imp_OutlookExpress.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Imp_NetscapeContacts.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Imp_Mozilla.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Imp_Eudora.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Imp_Eml.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Imp_CsvContacts.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\HorzRuleBlock.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mime.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ImpExp_Outlook.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ImpExp_Mbox.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\LexCpp.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\offsetlist.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\ImageBlock.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\LgiMain.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OpenSSLSocket.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailHttp.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\MailImap.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ManageMailStores.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
-    <ClCompile Include="..\Code\PreviewPanel.cpp">
-      <Filter>Controls/UI</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\OAuth2.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ObjectInspector.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\PrintContext.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Png.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\OptionsDlg.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ReplicateDlg.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeAbout.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\RemoteCalendarSource.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEdit.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Common.cpp">
       <Filter>Store3</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Storage\3\Store3.cpp">
       <Filter>Store3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Attachment.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Calendar.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Contact.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Filter.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Folder.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Group.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Mail.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mail3\Mail3Store.cpp">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Attachment.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Folder.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Mail.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Store.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Imap\ScribeImap_Thread.cpp">
       <Filter>Store3\Imap</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Attachment.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Calendar.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Contact.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Folder.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Mail.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Store.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Mapi\ScribeMapi_Thing.cpp">
       <Filter>Store3\Mapi</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Sqlite\v3.6.14\sqlite3.c">
       <Filter>Store3\Mail3</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Jpeg.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Lzw.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\PrintPreview.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Components.cpp">
       <Filter>Install</Filter>
     </ClCompile>
     <ClCompile Include="..\..\libs\Btree\config.c">
       <Filter>BTree</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\Db-Csv.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Db\DbTable.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\Homoglyphs.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\HomoglyphsTable.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Mail.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\Utils\Tables\MailFlags.c">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\MContainer.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeAccount.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeAccountPreview.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeAccountUI.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\RtfHtml.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeApp.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeAttachment.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeContact.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeFilter.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeFinder.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeFolder.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeFolderDlg.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeFolderProp.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeFolderSelect.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeFolderTree.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeGroup.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeItemList.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeLangDlg.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeListAddr.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeMail.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeMain.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribePageSetup.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribePassword.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeSendReceive.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeSockets.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeStatusPanel.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeThing.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeUi.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\ScribeUtils.cpp">
       <Filter>Application</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptCompiler.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Scripting.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptLibrary.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptVM.cpp">
       <Filter>Scripting</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\SearchView.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\SecurityDlg.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SegmentTree.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SharedMemory.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\SoftwareUpdate.cpp">
       <Filter>Install</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\win\Lgi\SpellCheckWindows.cpp">
       <Filter>SpellCheck</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\TextBlock.cpp">
       <Filter>RichTextEdit</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\TextConvert.cpp">
       <Filter>Mail</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Gdc2\Filters\Tiff.cpp">
       <Filter>Graphics</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\Tnef.cpp">
       <Filter>Lgi</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\TimePopup.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Webdav\WebdavThread.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Webdav\WebdavCalendar.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Webdav\WebdavContact.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Webdav\WebdavFolder.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\Store3Webdav\WebdavStore.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\ZoomView.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\XmlTreeUi.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\WebDav.cpp">
       <Filter>Store3\WebDav</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\vCard-vCal.cpp">
       <Filter>Import/Export</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\TitlePage.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\General\TimeZone.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\YearView.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Widgets\MonthView.cpp">
       <Filter>Calendar</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\Html.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlCommon.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\HtmlParser.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\HtmlToText.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Lgi\Browser.cpp">
       <Filter>Controls/UI\Html</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\HttpTools.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Net\Http.cpp">
       <Filter>Network</Filter>
     </ClCompile>
     <ClCompile Include="..\..\..\Lgi\trunk\src\common\Text\SpellCheckAspell.cpp">
       <Filter>SpellCheck</Filter>
     </ClCompile>
     <ClCompile Include="..\Code\NewMailDlg.cpp">
       <Filter>Controls/UI</Filter>
     </ClCompile>
+    <ClCompile Include="..\Code\PreviewPanel.cpp">
+      <Filter>Controls/UI\PreviewPanel</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\libs\Btree\btree.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\btree_header.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\btree_lock.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\btree_node.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_utils.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Db.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_blocklist.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_blocks.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_cache.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_header.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_internal.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_lock.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\db_types.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Calendar.h">
       <Filter>Calendar</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\CalendarView.h">
       <Filter>Calendar</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\gbtree.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\EmojiFont.h">
       <Filter>Emoji</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Emoji.h">
       <Filter>Emoji</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\BayesianFilter.h">
       <Filter>Filtering</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ColourSelect.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ControlTree.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DateTimeCtrls.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\DrawListSurface.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\FilterUi.h">
       <Filter>Filtering</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Ftp.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\GdcTools.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Graph.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Encryption\GnuPG.h">
       <Filter>Encryption</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\hashtable.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Imp_Outlook.h">
       <Filter>Import/Export</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mime.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LDbTable.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\offsetlist.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\OpenSSLSocket.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OpenSSLSocket.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ManageMailStores.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
-    <ClInclude Include="..\Code\PreviewPanel.h">
-      <Filter>Controls/UI</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\OAuth2.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\PrintContext.h">
       <Filter>Graphics</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ReplicateDlg.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\RichTextEdit.h">
       <Filter>RichTextEdit</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Widgets\Editor\RichTextEditPriv.h">
       <Filter>RichTextEdit</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Scripting.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\StoreCommon.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3MimeTree.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3Defs.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Store3.h">
       <Filter>Store3</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Store3Mail3\Mail3.h">
       <Filter>Store3\Mail3</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Store3Imap\ScribeImap.h">
       <Filter>Store3\Imap</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Store3Mapi\ScribeMapi.h">
       <Filter>Store3\Mapi</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Sqlite\v3.6.14\sqlite3.h">
       <Filter>Store3\Mail3</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Sqlite\v3.6.14\sqlite3ext.h">
       <Filter>Store3\Mail3</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\LWebDav.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ObjectInspector.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\PrintPreview.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Components.h">
       <Filter>Install</Filter>
     </ClInclude>
     <ClInclude Include="..\..\libs\Btree\config.h">
       <Filter>BTree</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\DomFields.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\DomTypeValues.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\DomType.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Homoglyphs.h">
       <Filter>Mail</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Mail.h">
       <Filter>Mail</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\Instructions.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeAccountPreview.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeAccountUI.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Scribe.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Store3Imap\include\Scribe.pb.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeDefs.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeFolderDlg.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeFolderSelect.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeInc.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeListAddr.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribePageSetup.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribePrivate.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\Scripts\ScribeScripts.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeStatusPanel.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\ScribeUtils.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\src\common\Coding\ScriptingPriv.h">
       <Filter>Scripting</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SegmentTree.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SharedMemory.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SoftwareUpdate.h">
       <Filter>Install</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\SpellCheck.h">
       <Filter>SpellCheck</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\TextConvert.h">
       <Filter>Mail</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Tnef.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\WebDav.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Store3Webdav\WebdavStore.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\Code\Store3Webdav\WebdavStorePriv.h">
       <Filter>Store3\WebDav</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\ZoomView.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\XmlTreeUi.h">
       <Filter>Controls/UI</Filter>
     </ClInclude>
     <ClInclude Include="..\Utils\Tables\Tables.h">
       <Filter>Application</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\common\ZlibWrapper.h">
       <Filter>Lgi</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Html.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlCommon.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HtmlParser.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Browser.h">
       <Filter>Controls/UI\Html</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\HttpTools.h">
       <Filter>Network</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\Lgi\trunk\include\lgi\common\Http.h">
       <Filter>Network</Filter>
     </ClInclude>
+    <ClInclude Include="..\Code\PreviewPanel.h">
+      <Filter>Controls/UI\PreviewPanel</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Image Include="..\Resources\Icons\app.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\Blank.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\event.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\error.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\Small.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\calender.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\contact.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\filter.ico">
       <Filter>Resources</Filter>
     </Image>
     <Image Include="..\Resources\Icons\Mail.ico">
       <Filter>Resources</Filter>
     </Image>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\Resources\About.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\email.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\features.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\filters.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\intro.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\install.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\index.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\import.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\calendar.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\contacts.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\encrypted+html+attach+key.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\encrypted+attach.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\encrypted.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\signed+HTML+attach+key.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\signed.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\signed+attach.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\signed+encrypted.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Code\Encryption\Examples\signed+html.eml">
       <Filter>TestCases</Filter>
     </None>
     <None Include="..\Help\ui.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Resources\Themes\Dark\styles.css">
       <Filter>Help</Filter>
     </None>
     <None Include="..\..\..\Lgi\trunk\src\common\Text\Homoglyphs\gen.py">
       <Filter>Scripting</Filter>
     </None>
     <None Include="..\Resources\Themes\Dark\colours.json">
       <Filter>Resources</Filter>
     </None>
     <None Include="..\Help\menu.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\plugins.html">
       <Filter>Help</Filter>
     </None>
-    <None Include="..\Resources\PreviewContact.html">
-      <Filter>Help</Filter>
-    </None>
-    <None Include="..\Resources\PreviewMail.html">
-      <Filter>Help</Filter>
-    </None>
     <None Include="..\Help\help.css">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\print.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Help\scripting.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Resources\Title.html">
       <Filter>Help</Filter>
     </None>
     <None Include="..\Code\Store3Imap\Scribe.proto">
       <Filter>Application</Filter>
     </None>
     <None Include="..\Utils\Store\check-build.py">
       <Filter>Install</Filter>
     </None>
     <None Include="..\Code\Py\win32_pre_build_step.py">
       <Filter>Install</Filter>
     </None>
     <None Include="..\Utils\Store\store.py">
       <Filter>Install</Filter>
     </None>
     <None Include="..\Code\Py\DomScan.py">
       <Filter>Install</Filter>
     </None>
     <None Include="..\..\libs\build.py">
       <Filter>Install</Filter>
     </None>
     <None Include="Installer-64bit.nsi">
       <Filter>Install</Filter>
     </None>
     <None Include="..\Scripts\Add Senders To Contacts.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\CovieRender.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\Delete Attachments.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\DecrementAll.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\Delete Duplicate Messages.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\LdapPlugin.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="..\Scripts\Mail Filters Menu.script">
       <Filter>Scripting\Scripts</Filter>
     </None>
     <None Include="Installer-64bit.nsi.in">
       <Filter>Install</Filter>
     </None>
+    <None Include="..\Resources\PreviewContact.html">
+      <Filter>Controls/UI\PreviewPanel</Filter>
+    </None>
+    <None Include="..\Resources\PreviewMail.html">
+      <Filter>Controls/UI\PreviewPanel</Filter>
+    </None>
+    <None Include="..\Resources\PreviewGroup.html">
+      <Filter>Controls/UI\PreviewPanel</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Text Include="..\Utils\Tables\MailFlags.txt">
       <Filter>Scripting</Filter>
     </Text>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="BTree">
       <UniqueIdentifier>{28943112-0c58-468a-b315-7696092c8778}</UniqueIdentifier>
     </Filter>
     <Filter Include="Help">
       <UniqueIdentifier>{f16baf81-af69-4eb1-9faf-6f448a36a13b}</UniqueIdentifier>
     </Filter>
     <Filter Include="Scripting">
       <UniqueIdentifier>{ffd46a02-1aed-411d-a961-754cfaf46299}</UniqueIdentifier>
     </Filter>
     <Filter Include="Resources">
       <UniqueIdentifier>{cac512da-cfa7-4bbe-b5be-14a1d31848fb}</UniqueIdentifier>
     </Filter>
     <Filter Include="Calendar">
       <UniqueIdentifier>{15bf5500-86f7-4217-ad50-dfc441b2fb89}</UniqueIdentifier>
     </Filter>
     <Filter Include="TestCases">
       <UniqueIdentifier>{c8868eeb-fe8d-42a2-a647-9df3bff160c4}</UniqueIdentifier>
     </Filter>
     <Filter Include="Emoji">
       <UniqueIdentifier>{111097d8-3c3a-4fb4-a418-548f08670ade}</UniqueIdentifier>
     </Filter>
     <Filter Include="Lgi">
       <UniqueIdentifier>{3347deb8-7d16-4010-9dff-676bafee8413}</UniqueIdentifier>
     </Filter>
     <Filter Include="Controls/UI">
       <UniqueIdentifier>{84e29f91-6e12-481b-8d4c-18e499c9a501}</UniqueIdentifier>
     </Filter>
     <Filter Include="Filtering">
       <UniqueIdentifier>{1d79521d-1efc-4656-bec1-13973241c432}</UniqueIdentifier>
     </Filter>
     <Filter Include="RichTextEdit">
       <UniqueIdentifier>{90145701-794d-4956-af76-5cc116600a6e}</UniqueIdentifier>
     </Filter>
     <Filter Include="Import/Export">
       <UniqueIdentifier>{963cf563-311f-4292-8aef-947945b63c15}</UniqueIdentifier>
     </Filter>
     <Filter Include="Encryption">
       <UniqueIdentifier>{762f00ae-b360-4e54-b181-857af25a6490}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3">
       <UniqueIdentifier>{98c796a3-d418-4adb-b8f8-1a51e8349d96}</UniqueIdentifier>
     </Filter>
     <Filter Include="Network">
       <UniqueIdentifier>{9f3b229f-b2f8-4bbb-897c-f048d35571d4}</UniqueIdentifier>
     </Filter>
     <Filter Include="Graphics">
       <UniqueIdentifier>{2c79f6d5-53c2-454d-b897-0a6779024c02}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\Mail3">
       <UniqueIdentifier>{8139c7b4-9593-48c3-98af-a0db78c410aa}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\Imap">
       <UniqueIdentifier>{d7ace5ac-018a-4ae6-882e-652cf33d3f50}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\Mapi">
       <UniqueIdentifier>{2431021b-92a9-444c-9796-2b1e7d81bd5a}</UniqueIdentifier>
     </Filter>
     <Filter Include="Store3\WebDav">
       <UniqueIdentifier>{b63a6ed6-bb9e-4538-95f8-2f7782e199eb}</UniqueIdentifier>
     </Filter>
     <Filter Include="Install">
       <UniqueIdentifier>{7b5dbea7-b971-4a65-a5f5-e12726480450}</UniqueIdentifier>
     </Filter>
     <Filter Include="Mail">
       <UniqueIdentifier>{432fd674-ec47-4cfc-afdf-d60b633feb48}</UniqueIdentifier>
     </Filter>
     <Filter Include="Application">
       <UniqueIdentifier>{dbfbd2a8-e411-4b43-a188-bde8cd1ac292}</UniqueIdentifier>
     </Filter>
     <Filter Include="SpellCheck">
       <UniqueIdentifier>{cc8997f1-f092-4b82-a5e5-a3bcc92846ce}</UniqueIdentifier>
     </Filter>
     <Filter Include="Controls/UI\Html">
       <UniqueIdentifier>{6fbe15c0-133a-4ae9-a441-03a9dcafe050}</UniqueIdentifier>
     </Filter>
     <Filter Include="Scripting\Scripts">
       <UniqueIdentifier>{4fd600f1-77c6-4b58-b9a8-85d436233d52}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Controls/UI\PreviewPanel">
+      <UniqueIdentifier>{22d7ec0d-a127-4b05-b6f0-937c3255224a}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="..\..\..\Lgi\trunk\src\common\Coding\ExternCall.asm">
       <Filter>Scripting</Filter>
     </CustomBuild>
   </ItemGroup>
   <ItemGroup>
     <Manifest Include="..\Resources\ScribeWindows.manifest">
       <Filter>Scripting</Filter>
     </Manifest>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="..\Code\Resource.rc">
       <Filter>Resources</Filter>
     </ResourceCompile>
   </ItemGroup>
 </Project>
\ No newline at end of file