diff --git a/Code/Calendar.cpp b/Code/Calendar.cpp
--- a/Code/Calendar.cpp
+++ b/Code/Calendar.cpp
@@ -1,3314 +1,3317 @@
 /*hdr
 **      FILE:           Calendar.cpp
 **      AUTHOR:         Matthew Allen
 **      DATE:           23/11/2001
 **      DESCRIPTION:    Scribe calender support
 **
 **      Copyright (C) 2001 Matthew Allen
 **              fret@memecode.com
 */
 
 #include "Scribe.h"
 
 #include "lgi/common/vCard-vCal.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/DateTimeCtrls.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/ColourSelect.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Json.h"
 
 #include "CalendarView.h"
 #include "PrintContext.h"
 #include "../Resources/resdefs.h"
 #include "resource.h"
 #include "AddressSelect.h"
 #include "ObjectInspector.h"
 
 #define MAX_RECUR			1024
 #define DEBUG_REMINDER		0
 #define DEBUG_DATES			0
 
 //////////////////////////////////////////////////////////////////////////////
 ItemFieldDef CalendarFields[] = {
 	{"Start", SdStart, 					GV_DATETIME,	FIELD_CAL_START_UTC,		IDC_START_DATE,			0, true},
 	{"End", SdEnd, 						GV_DATETIME,	FIELD_CAL_END_UTC,			IDC_END_DATE,			0, true},
 	{"Subject", SdSubject, 				GV_STRING,		FIELD_CAL_SUBJECT,			IDC_SUBJECT},
 	{"Location", SdLocation, 			GV_STRING,		FIELD_CAL_LOCATION,			IDC_LOCATION},
 	{"Show Time As", SdShowTimeAs,		GV_INT32,		FIELD_CAL_SHOW_TIME_AS,		IDC_AVAILABLE_TYPE},
 	{"All Day", SdAllDay,				GV_BOOL,		FIELD_CAL_ALL_DAY,			IDC_ALL_DAY},
 
 	// TRUE if the calendar event recurs
 	{"Recur", SdRecur, 					GV_INT32,		FIELD_CAL_RECUR,			-1},
 	
 	// Base time unit of recurring event. See enum CalRecurFreq: days, weeks, months, years.
 	{"Recur Freq", SdRecurFreq, 		GV_INT32,		FIELD_CAL_RECUR_FREQ,		-1},
 
 	// Number of FIELD_CAL_RECUR_FREQ units of time between recurring events. (Minimum is '1')
 	{"Recur Interval", SdRecurInterval, GV_INT32,		FIELD_CAL_RECUR_INTERVAL,	-1},
 
 	// Bitfield of days, Bit 0 = Sunday, Bit 1 = Monday, Bit 2 = Teusday etc.
 	{"Filter Days", SdFilterDays, 		GV_INT32,		FIELD_CAL_RECUR_FILTER_DAYS, -1},
 
 	// Bitfield of months, Bit 0 = Janurary, Bit 1 = feburary, Bit 2 = March etc.
 	{"Filter Months", SdFilterMonths,	GV_INT32,		FIELD_CAL_RECUR_FILTER_MONTHS, -1},
 
 	// String of year numbers separated by commas: "2010,2014,2018"
 	{"Filter Years", SdFilterYears,		GV_STRING,		FIELD_CAL_RECUR_FILTER_YEARS, -1},
 	
 	// Position in month, "1" means the first matching day of the month. Multiple indexes can be joined with ','
 	// like: "1,3"
 	{"Filter Pos", SdFilterPos, 		GV_STRING,		FIELD_CAL_RECUR_FILTER_POS, -1},
 
 	// See the CalRecurEndType enumeration
 	{"Recur End Type", SdRecurEndType,	GV_INT32,		FIELD_CAL_RECUR_END_TYPE,	-1},
 	
 	// If FIELD_CAL_RECUR_END_TYPE==CalEndOnDate then this specifies the date to end
 	{"Recur End Date", SdRecurEndDate,	GV_DATETIME,	FIELD_CAL_RECUR_END_DATE,	-1},
 	
 	// If FIELD_CAL_RECUR_END_TYPE==CalEndOnCount then this specifies the count of events
 	{"Recur End Count", SdRecurEndCount, GV_INT32,		FIELD_CAL_RECUR_END_COUNT,	-1},
 
 	// The timezone the start and end are referencing
 	{"Timezone", SdTimeZone, 			GV_STRING,		FIELD_CAL_TIMEZONE,			IDC_TIMEZONE},
 
 	// User defined notes for the object
 	{"Notes", SdNotes, 					GV_STRING,		FIELD_CAL_NOTES,			IDC_DESCRIPTION},
 
 	// See the CalendarType enumeration
 	{"Type", SdType, 					GV_INT32,		FIELD_CAL_TYPE,				-1},
 	
 	{"Reminders", SdReminders,			GV_STRING,		FIELD_CAL_REMINDERS,		-1},
 	{"LastCheck", SdLastCheck,			GV_DATETIME,	FIELD_CAL_LAST_CHECK,		-1},
 
 	{0}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 const char *sReminderType[] = { "Email", "Popup", "ScriptCallback" };
 const char *sReminderUnits[] = { "Minutes", "Hours", "Days", "Weeks" };
 
 class ReminderItem : public LListItem
 {
 	CalendarReminderType Type;
 	float Value;
 	CalendarReminderUnits Units;
 	LString Param;
 
 public:
 	ReminderItem(CalendarReminderType type, float value, CalendarReminderUnits units, LString param)
 	{
 		Type = type;
 		Value = value;
 		Units = units;
 		Param = param;
 		
 		Update();
 		SetText("x", 1);
 	}
 	
 	ReminderItem(LString s)
 	{
 		if (!SetString(s))
 		{
 			// Default
 			Type = CalPopup;
 			Value = 1.0;
 			Units = CalMinutes;
 			Param.Empty();
 		}
 		
 		Update();
 		SetText("x", 1);
 	}
 	
 	CalendarReminderType GetType() { return Type; }
 	float GetValue() { return Value; }
 	CalendarReminderUnits GetUnits() { return Units; }
 	LString GetParam() { return Param; }
 	
 	LString GetString()
 	{
 		// See also FIELD_CAL_REMINDERS
 		LString s;
 		s.Printf("%g,%i,%i,%s", Value, Units, Type, Param?LUrlEncode(Param, ",\r\n").Get():"");
 		return s;
 	}
 	
 	bool SetString(LString s)
 	{
 		// See also FIELD_CAL_REMINDERS
 		LString::Array a = s.Split(",");
 		if (a.Length() < 3)
 			return false;
 		
 		Value = (float) a[0].Float();
 		Units = (CalendarReminderUnits) a[1].Int();
 		Type = (CalendarReminderType) a[2].Int();
 		if (a.Length() > 3)
 			Param = LUrlDecode(a[3]);
 		
 		return true;		
 	}
 	
 	void Update()
 	{
 		char s[300];
 		if (Param)
 			sprintf_s(s, sizeof(s), "%s '%s' @ %g %s", sReminderType[Type], Param.Get(), Value, sReminderUnits[Units]);
 		else
 			sprintf_s(s, sizeof(s), "%s @ %g %s", sReminderType[Type], Value, sReminderUnits[Units]);
 		SetText(s);
 	}
 	
 	void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c)
 	{
 		LColour old = Ctx.Fore;
 		if (i == 1)
 			Ctx.Fore.Rgb(255, 0, 0);
 		LListItem::OnPaintColumn(Ctx, i, c);
 		Ctx.Fore = old;
 	}
 	
 	void OnMouseClick(LMouse &m)
 	{
 		if (m.Down() && m.Left())
 		{
 			if (GetList()->ColumnAtX(m.x) == 1)
 			{
 				delete this;
 				return;
 			}
 		}
 		LListItem::OnMouseClick(m);
 	}
 };
 
 ////////////////////////////////////////////////////////////////////////////////////
 static int DefaultCalenderFields[] = 
 {
 	FIELD_CAL_SUBJECT,
 	FIELD_CAL_START_UTC,
 	FIELD_CAL_END_UTC,
 	0,
 };
 	
 #define MINUTE		1 // we're in minutes...
 #define HOUR		(60 * MINUTE)
 #define DAY			(24 * HOUR)
 
 int ReminderOffsets[] =
 {
 	0,
 	15	* MINUTE,
 	30	* MINUTE,
 	1	* HOUR,
 	2	* HOUR,
 	3	* HOUR,
 	4	* HOUR,
 	5	* HOUR,
 	6	* HOUR,
 	7	* HOUR,
 	8	* HOUR,
 	9	* HOUR,
 	10	* HOUR,
 	11	* HOUR,
 	12	* HOUR,
 	1	* DAY,
 	2	* DAY
 };
 
 //////////////////////////////////////////////////////////////////////////////
 List<Calendar> Calendar::Reminders;
 
 int Calendar::DayStart = -1;
 int Calendar::DayEnd = -1;
 int Calendar::WorkDayStart = -1;
 int Calendar::WorkDayEnd = -1;
 int Calendar::WorkWeekStart = -1;
 int Calendar::WorkWeekEnd = -1;
 
 void InitCalendarView()
 {
 	Calendar::DayStart = 6;
 	Calendar::DayEnd = 23;
 
 	Calendar::WorkDayStart = -1;
 	Calendar::WorkDayEnd = -1;
 	Calendar::WorkWeekStart = -1;
 	Calendar::WorkWeekEnd = -1;
 
 	auto s = LAppInst->GetConfig("Scribe.Calendar.WorkDayStart");
 	if (s) Calendar::WorkDayStart = (int)s.Int();
 
 	s = LAppInst->GetConfig("Scribe.Calendar.WorkDayEnd");
 	if (s) Calendar::WorkDayEnd = (int)s.Int();
 
 	s = LAppInst->GetConfig("Scribe.Calendar.WorkWeekStart");
 	if (s) Calendar::WorkWeekStart = (int)s.Int() + 1;
 	
 	s = LAppInst->GetConfig("Scribe.Calendar.WorkWeekEnd");
 	if (s) Calendar::WorkWeekEnd = (int)s.Int() + 1;
 
 	if (Calendar::WorkDayStart < 0)
 		Calendar::WorkDayStart = 9;
 	if (Calendar::WorkDayEnd < 0)
 		Calendar::WorkDayEnd = 18;
 	if (Calendar::WorkWeekStart < 0)
 		Calendar::WorkWeekStart = 1;
 	if (Calendar::WorkWeekEnd < 0)
 		Calendar::WorkWeekEnd = 5;
 }
 
 void Calendar::CheckReminders()
 {
 	LDateTime Now;
 	Now.SetNow();
 	LDateTime Then;
 	Then = Now;
 	Then.AddDays(1);
 
 	#if DEBUG_REMINDER
 	LgiTrace("%s:%i - Reminders.Len=%i, Now=%s, Then=%s\n", _FL, Reminders.Length(), Now.Get().Get(), Then.Get().Get());
 	#endif
 	for (auto c: Reminders)
 	{
 		auto App = c->App;
 		LHashTbl<StrKey<char>,bool> Added;
 		Thing *ReminderThing = NULL;
 		Mail *ReminderEmail = NULL;
 
 		// Is a reminder on the entry?
 		if (!c->GetObject())
 			continue;
 		
 		LString Rem = c->GetObject()->GetStr(FIELD_CAL_REMINDERS);
 		if (!Rem)
 			continue;
 	
 		const char *Subj = NULL, *Notes = NULL;
 		c->GetField(FIELD_CAL_SUBJECT, Subj);
 		c->GetField(FIELD_CAL_NOTES, Notes);
 
 		LArray<TimePeriod> Times;
 		if (!c->GetTimes(Now, Then, Times))
 		{
 			#if DEBUG_REMINDER
 			LgiTrace("    No times for '%s'\n", Subj);
 			#endif
 			continue;
 		}
 		
 		LDataI *Obj = c->GetObject();
 		LDateTime LastCheck = *Obj->GetDate(FIELD_CAL_LAST_CHECK);
 		if (LastCheck.IsValid())
 			LastCheck.ToLocal();
 
 		LString::Array r = Rem.SplitDelimit("\n");
 		for (unsigned i=0; i<r.Length(); i++)
 		{
 			ReminderItem ri(r[i]);
 			for (unsigned n=0; n<Times.Length(); n++)
 			{
 				TimePeriod &t = Times[n];
 				LDateTime ts = t.s;
 				
 				#if DEBUG_REMINDER
 				LgiTrace("    ts init = %s\n", ts.Get().Get());
 				#endif
 				
 				switch (ri.GetUnits())
 				{
 					case CalMinutes:
 						ts.AddMinutes((int64) -ri.GetValue());
 						break;
 					case CalHours:
 						ts.AddHours((int64) -ri.GetValue());
 						break;
 					case CalDays:
 						ts.AddDays((int64) -ri.GetValue());
 						break;
 					case CalWeeks:
 						ts.AddDays((int64) -(ri.GetValue()*7));
 						break;
 					default:
 						ts.Empty();
 						break;
 				}
 
 				#if DEBUG_REMINDER
 				LgiTrace("    ts after = %s\n", ts.Get().Get());
 				#endif
 				
 				if (ts.IsValid())
 				{
 					#if DEBUG_REMINDER
 					bool a = !LastCheck.IsValid()
 							||
 							ts > LastCheck;
 					bool b = ts <= Now;
 
 					LgiTrace("    last check = %s\n", LastCheck.Get().Get());
 					LgiTrace("    now = %s\n", Now.Get().Get());
 					LgiTrace("    %i %i\n", a, b);
 					#endif
 
 					if
 					(
 						(
 							!LastCheck.IsValid()
 							||
 							ts > LastCheck
 						)
 						&&
 						ts <= Now
 					)
 					{
 						// Save the last check field now
 						auto NowUtc = Now.Utc();
 						Obj->SetDate(FIELD_CAL_LAST_CHECK, &NowUtc);
 						c->SetDirty();
 
 						// Fire the event
 						switch (ri.GetType())
 						{
 							case CalEmail:
 							{
 								ScribeAccount *Acc = App->GetCurrentAccount();
 								if (!Acc || !Acc->Identity.IsValid())
 								{
 									LView *Ui = c->GetUI();
 									LgiMsg(Ui ? Ui : c->App, "No from account to use for sending event notifications.", AppName, MB_OK);
 									break;
 								}
 
 								auto Email = Acc->Identity.Email();
 								auto Name = Acc->Identity.Name();
 								LgiTrace("%s:%i - Using account ('%s' '%s') for the event reminder 'from' address.\n", _FL, Email.Str(), Name.Str());
 
 								if (!ReminderThing)
 									ReminderThing = App->CreateThingOfType(MAGIC_MAIL);
 								
 								if (!ReminderEmail)
 								{
 									ReminderEmail = ReminderThing ? ReminderThing->IsMail() : NULL;
 									if (ReminderEmail)
 									{
 										LString s;
 										s.Printf("Calendar Notification: %s", Subj);
 										ReminderEmail->SetSubject(s);
 
 										s.Printf("The event '%s' is due at: %s\n"
 												"\n"
 												"%s\n"
 												"\n"
 												"(This email was generated by Scribe)",
 												Subj,
 												t.s.Get().Get(),
 												Notes ? Notes : "");
 										ReminderEmail->SetBody(s);
 
 										auto Frm = ReminderEmail->GetFrom();
 										Frm->SetStr(FIELD_EMAIL, Email.Str());
 										Frm->SetStr(FIELD_NAME, Name.Str());
 									}
 								}
 
 								if (ReminderEmail)
 								{
 									auto To = ReminderEmail->GetTo();
 
 									// Add any custom parameter email address:
 									LString Param = ri.GetParam();
 									if (LIsValidEmail(Param))
 									{
 										auto Recip = To->Create(c->GetObject()->GetStore());
 										if (Recip)
 										{
 											Added.Add(Param, true);
 											Recip->SetStr(FIELD_EMAIL, Param);
 											To->Insert(Recip);
 										}
 									}
 
 									// Add all the guests
 									LString sGuests = c->GetObject()->GetStr(FIELD_TO);
 									LString::Array Guests = sGuests.SplitDelimit(",");
 									for (auto Guest: Guests)
 									{
 										LAutoString e, n;
 										DecodeAddrName(Guest, n, e, NULL);
 
 										#if DEBUG_REMINDER
 										LgiTrace("Attendee=%s,%s\n", n.Get(), e.Get());
 										#endif
 
 										if (LIsValidEmail(e.Get()) &&
 											!Added.Find(e))
 										{
 											auto Recip = To->Create(c->GetObject()->GetStore());
 											if (Recip)
 											{
 												if (n) Recip->SetStr(FIELD_NAME, n);
 												Recip->SetStr(FIELD_EMAIL, e);
 												To->Insert(Recip);
 												Added.Add(e, true);
 											}
 										}
 										else
 										{
 											#if DEBUG_REMINDER
 											LgiTrace("Attendee not valid or added already: %s\n", e.Get());
 											#endif
 										}
 									}
 								}
 								break;
 							}
 							case CalPopup:
 							{
 								if (LgiMsg(	0, // this causes the dialog to be ontop of everything else
 											LLoadString(IDS_EVENT_DUE),
 											AppName,
 											MB_YESNO | MB_SYSTEMMODAL,
 											Subj) == IDYES)
 								{
 									// Open the calendar entry
 									c->DoUI();
 								}
 								break;
 							}
 							case CalScriptCallback:
 							{
 								break;
 							}
 							default:
 							{
 								LgiTrace("%s:%i - Unknown reminder type.\n", _FL);
 								break;
 							}
 						}
 					}
 				}
 			}
 		}
 
 		if (ReminderEmail)
 		{
 			ReminderEmail->CreateMailHeaders();
 			ReminderEmail->Update();
 			ReminderEmail->Send(true);
 		}
 	}
 }
 
 #define MIN_1		((int64)LDateTime::Second64Bit * 60)
 #define HOUR_1		(MIN_1 * 60)
 #define DAY_1		(HOUR_1 * 24)
 #define YEAR_1		(DAY_1 * 365)
 
 const char *RelativeTime(LDateTime &Then)
 {
 	static char s[256];
 	static const int Id[] =
 	{
 		IDS_CAL_LDAY_SUN,
 		IDS_CAL_LDAY_MON,
 		IDS_CAL_LDAY_TUE,
 		IDS_CAL_LDAY_WED,
 		IDS_CAL_LDAY_THU,
 		IDS_CAL_LDAY_FRI,
 		IDS_CAL_LDAY_SAT,
 	};
 	
 	LDateTime Now;
 	Now.SetNow();
 
 	char Val[64];
 	uint64 n, t;
 	Now.Get(n);
 	Then.Get(t);
 	int64_t Diff = (int64)t - (int64)n;
 
 	int Yrs = 0;
 	int Months = 0;
 	int Days = 0;
 	int Hrs = 0;
 	int Mins = 0;
 	LDateTime i = Now;
 	int Inc = Then > Now ? 1 : -1;
 	char DirIndcator = Then > Now ? '+' : '-';
 	while (ABS(Diff) >= YEAR_1)
 	{
 		Yrs++;
 		i.Year(i.Year()+Inc);
 		i.Get(n);
 		Diff = (int64)t - (int64)n;
 	}
 
 	int TotalDays = 0;
 	if (ABS(Diff) > DAY_1)
 	{
 		TotalDays = Days = (int) (Diff / DAY_1);
 
 		while (true)
 		{
 			LDateTime first = i;
 			first.AddMonths(Inc);
 			if (	
 				(Inc < 0 && first > Then) // Tracking back in time..
 				||
 				(Inc > 0 && Then > first) // Forward in time..
 			)
 			{
 				Months += Inc;
 				i = first;
 			}
 			else break;
 		}
 
 		if (Months)
 		{
 			uint64 remaining;
 			i.Get(remaining);
 			Diff = (int64_t)t - (int64_t)remaining;
 			Days = (int) (Diff / DAY_1);
 		}
 
 		Diff -= (int64) Days * DAY_1;
 	}
 	if (ABS(Diff) > HOUR_1)
 	{
 		Hrs = (int) (Diff / HOUR_1);
 		Diff -= (int64) Hrs * HOUR_1;
 	}
 	if (ABS(Diff) > MIN_1)
 	{
 		Mins = (int) (Diff / MIN_1);
 		Diff -= (int64) Mins * MIN_1;
 	}
 		
 	if (Yrs)
 	{
 		// Years + months
 		sprintf_s(Val, sizeof(Val), "%c%iy %im", DirIndcator, abs(Yrs), abs(Months));
 	}
 	else if (Months)
 	{
 		// Months + days
 		sprintf_s(Val, sizeof(Val), "%c%im %id", DirIndcator, abs(Months), abs(Days));
 	}
 	else if (Days)
 	{
 		if (abs(Days) >= 7)
 		{
 			// Weeks + days...
 			sprintf_s(Val, sizeof(Val), "%c%iw %id", DirIndcator, abs(Days)/7, abs(Days)%7);
 		}
 		else
 		{
 			// Days + hours...
 			sprintf_s(Val, sizeof(Val), "%c%id %ih", DirIndcator, abs(Days), abs(Hrs));
 		}
 	}
 	else if (Hrs)
 	{
 		// Hours + min
 		sprintf_s(Val, sizeof(Val), "%c%ih %im", DirIndcator, abs(Hrs), abs(Mins));
 	}
 	else
 	{
 		// Mins
 		sprintf_s(Val, sizeof(Val), "%c%im", DirIndcator, abs(Mins));
 	}
 
 	if (Yrs != 0 || Months != 0)
 	{
 		sprintf_s(s, sizeof(s), "%s", Val);
 		return s;
 	}
 
 	auto NowDay = n / DAY_1;
 	auto ThenDay = t / DAY_1;
 	auto DaysDiff = (int64_t)ThenDay - (int64_t)NowDay;
 
 	int Ch = 0;
 	if (NowDay == ThenDay)
 		Ch = sprintf_s(s, sizeof(s), "%s", LLoadString(IDS_TODAY));
 	else if (DaysDiff == -1)
 		Ch = sprintf_s(s, sizeof(s), "%s", LLoadString(IDS_YESTERDAY));
 	else if (DaysDiff == 1)
 		Ch = sprintf_s(s, sizeof(s), "%s", LLoadString(IDS_TOMORROW));
 	else if (DaysDiff > 1 && DaysDiff < 7)
 		Ch = sprintf_s(s, sizeof(s), LLoadString(IDS_THIS_WEEK), LLoadString(Id[Then.DayOfWeek()]));
 	else if (DaysDiff >= 7 && DaysDiff < 14)
 		Ch = sprintf_s(s, sizeof(s), LLoadString(IDS_NEXT_WEEK), LLoadString(Id[Then.DayOfWeek()]));
 	else
 	{
 		sprintf_s(s, sizeof(s), "%s", Val);
 		return s;
 	}
 	
 	sprintf_s(s+Ch, sizeof(s)-Ch, ", %s", Val);	
 	return s;	
 }
 
 int CalSorter(TimePeriod *a, TimePeriod *b)
 {
 	return a->s.Compare(&b->s);
 }
 
 bool Calendar::SummaryOfToday(ScribeWnd *App, LVariant &v)
 {
 	bool Status = false;
 
     LArray<CalendarSource*> Sources;
 	if (App && App->GetCalendarSources(Sources))
 	{
 		LDateTime Now;
 		Now.SetNow();
 		LDateTime Next = Now;
 		Next.AddMonths(1);
 
 		LArray<TimePeriod> e;
 		for (unsigned i=0; i<Sources.Length(); i++)
 		{
 			Sources[i]->GetEvents(Now, Next, e);
 		}
 		
 		if (e.Length())
 		{
 			e.Sort(CalSorter);
 
 			LStringPipe p;
 
 			p.Print("<table cellspacing=3 style='background:white;'>\n");
 			for (unsigned n=0; n<e.Length() && n < 3; n++)
 			{
 				TimePeriod &tp = e[n];
 				Calendar *c = tp.c;
 
 				char Fore[32] = "black";
 				char Back[32] = "#c0c0c0";
 				const char *Subject = "...";
 
 				c->GetField(FIELD_CAL_SUBJECT, Subject);
 
 				LColour Base32 = c->GetColour();
 				auto Edge = Base32.Mix(LColour(L_WORKSPACE), 0.85f);
 				sprintf_s(Back, sizeof(Back), "#%2.2x%2.2x%2.2x", Edge.r(), Edge.g(), Edge.b());
 				sprintf_s(Fore, sizeof(Fore), "#%2.2x%2.2x%2.2x", Base32.r(), Base32.g(), Base32.b());
 
 				p.Print("\t<tr><td style='padding:2px;color:%s;background:%s;border:1px solid %s;'>\n"
 						"\t\t<a style='color:%s;font-size:13px;' href='thing://%p'>%s</a>\n",
 						Fore,
 						Back,
 						Fore,
 						Fore,
 						(Thing*)c,
 						Subject);
 
 				char Str[256];
 				const char *Rel = RelativeTime(tp.s);
 				if (Rel)
 				{
 					p.Print("\t\t<br/>%s\n", Rel);
 				}
 
 				tp.s.Get(Str, sizeof(Str));
 				p.Print("\t\t<br/>%s\n", Str);
 
 				tp.e.Get(Str, sizeof(Str));
 				p.Print("\t\t-<br/>%s\n", Str);
 			}
 			p.Print("</table>\n");
 
 			char *Str = p.NewStr();
 			if (Str)
 			{
 				v = Str;
 				DeleteArray(Str);
 				Status = true;
 			}
 		}
 		else
 		{
 			char s[256];
 			sprintf_s(s, sizeof(s), "<font color='#808080'>%s</font>", LLoadString(IDS_NO_EVENTS));
 			v = s;
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 void Calendar::OnSerialize(bool Write)
 {
 	// Update reminder list..
 	Reminders.Delete(this);
 
 	const char *Rem = NULL;
 	if (GetField(FIELD_CAL_REMINDERS, Rem) && ValidStr(Rem))
 	{
 		Reminders.Insert(this);
 	}
 
 	SetImage(GetCalType() == CalTodo ? ICON_TODO : ICON_CALENDAR);
 
 	if (Write && TodoView)
 	{
 		TodoView->Update();
 		TodoView->Resort();
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 Calendar::Calendar(ScribeWnd *app, LDataI *object) : Thing(app, object)
 {
 	DefaultObject(object);
 	Ui = 0;
 	TodoView = 0;
 	Source = 0;
 	SetImage(ICON_CALENDAR);
 }
 
 Calendar::~Calendar()
 {
 	DeleteObj(TodoView);
 	Reminders.Delete(this);
 }
 
 bool Calendar::GetTimes(LDateTime StartLocal, LDateTime EndLocal, LArray<TimePeriod> &Times)
 {
 	if (Calendar::DayStart < 0)
 		InitCalendarView();
 
 	ssize_t StartLen = Times.Length();
 	LDateTime StartUtc = StartLocal;
 	LDateTime EndUtc = EndLocal;
 	StartUtc.ToUtc();
 	EndUtc.ToUtc();
 	// int StartTz = StartLocal.GetTimeZone();
 
 	TimePeriod w;
 	w.s = StartUtc;
 	w.e = EndUtc;
 
 	const char *Subj = NULL;
 	GetField(FIELD_CAL_SUBJECT, Subj);
 
 	TimePeriod BaseUtc;
 	LArray<TimePeriod> Periods;
 	if (GetField(FIELD_CAL_START_UTC, BaseUtc.s))
 	{
 		if (!GetField(FIELD_CAL_END_UTC, BaseUtc.e))
 		{
 			BaseUtc.e = BaseUtc.s;
 			BaseUtc.e.AddHours(1);
 		}
 
 		LArray<LDateTime::GDstInfo> Dst;
 		LDateTime::GetDaylightSavingsInfo(Dst, BaseUtc.s, &EndUtc);
 		LAssert(Dst.Length() > 0);
 
 		Periods.Add(BaseUtc);
 
 		LDateTime BaseS = BaseUtc.s;
 		LDateTime::DstToLocal(Dst, BaseS);
 		auto BaseTz = BaseS.GetTimeZone();
 
 		// Process recur rules
 		int Recur = 0;
 		if (GetField(FIELD_CAL_RECUR, Recur) &&
 			Recur)
 		{
 			LDateTime Diff = BaseUtc.e - BaseUtc.s;
 
 			int FilterFreq = -1;
 			int FilterInterval = 0;
 			int FilterDay = 0;
 			int FilterMonth = 0;
 			const char *FilterYear = 0;
 			const char *FilterPos = 0;
 			int EndType = 0;
 			LDateTime EndDate;
 			int EndCount = 0;
 			
 			GetField(FIELD_CAL_RECUR_FREQ, FilterFreq);
 			GetField(FIELD_CAL_RECUR_INTERVAL, FilterInterval);
 			GetField(FIELD_CAL_RECUR_FILTER_DAYS, FilterDay);
 			GetField(FIELD_CAL_RECUR_FILTER_MONTHS, FilterMonth);
 			GetField(FIELD_CAL_RECUR_FILTER_YEARS, FilterYear);
 			GetField(FIELD_CAL_RECUR_FILTER_POS, FilterPos);
 			GetField(FIELD_CAL_RECUR_END_TYPE, EndType);
 			GetField(FIELD_CAL_RECUR_END_DATE, EndDate);
 			GetField(FIELD_CAL_RECUR_END_COUNT, EndCount);
 
 			LDateTime CurUtc = BaseUtc.s;
 			const char *Error = 0;
 			int Count = 0;
 			while (!Error)
 			{
 				// Advance the current date by interval * freq
 				switch (FilterFreq)
 				{
 					case CalFreqDays:
 						CurUtc.AddDays(FilterInterval);
 						break;
 					case CalFreqWeeks:
 						CurUtc.AddDays(FilterInterval * 7);
 						break;
 					case CalFreqMonths:
 						CurUtc.AddMonths(FilterInterval);
 						break;
 					case CalFreqYears:
 						CurUtc.Year(CurUtc.Year() + FilterInterval);
 						break;
 					default:
 						Error = "Invalid freq.";
 						break;
 				}
 				
 				if (Error || CurUtc > EndUtc) break;
 				
 				// Check against end conditions
 				bool IsEnded = CurUtc > EndUtc;
 
 				switch (EndType)
 				{
 					case CalEndNever:
 						break;
 					case CalEndOnCount: // count
 						IsEnded = Count >= EndCount - 1;
 						break;
 					case CalEndOnDate: // date
 						IsEnded = CurUtc > EndDate;
 						break;
 					default: // error
 						IsEnded = true;
 						break;
 				}
 
 				if (IsEnded) break;
 
 				// Check against filters
 				LDateTime CurLocal = CurUtc;
 				LDateTime::DstToLocal(Dst, CurLocal);
 				
 				// This fixes the current time when it's in a different daylight saves zone.
 				// Otherwise you get events one hour or whatever out of position after DST starts
 				// or ends during the recurring set.
 				int DiffMins = BaseTz - CurLocal.GetTimeZone();
 				CurLocal.AddMinutes(DiffMins);
 
 				bool Show = true;
 				if (FilterDay)
 				{
 					int Day = CurLocal.DayOfWeek();
 					for (int i=0; i<7; i++)
 					{
 						int Bit = 1 << i;
 						if (Day == i &&
 							(FilterDay & Bit) == 0)
 						{
 							Show = false;
 							break;
 						}
 					}
 				}
 
 				if (Show && FilterMonth)
 				{
 					for (int i=0; i<12; i++)
 					{
 						int Bit = 1 << i;
 						if ((CurLocal.Month() == i + 1) &&
 							(FilterMonth & Bit) == 0)
 						{
 							Show = false;
 							break;
 						}
 					}
 				}
 
 				if (Show && ValidStr(FilterYear))
 				{
 					LToken t(FilterYear, " ,;:");
 					Show = false;
 					for (unsigned i=0; i<t.Length(); i++)
 					{
 						if (atoi(t[i]) == CurLocal.Year())
 						{
 							Show = true;
 							break;
 						}
 					}
 				}
 
 				if (Show && ValidStr(FilterPos))
 				{
 					LDateTime Sm = CurLocal;
 					Sm.Day(1);
 					int Off = Sm.DayOfWeek();
 					int Idx = (CurLocal.Day() + Off) / 7;
 
 					LToken t(FilterPos, " ,;:");
 					Show = false;
 					for (unsigned i=0; i<t.Length(); i++)
 					{
 						if (atoi(t[i]) == Idx)
 						{
 							Show = true;
 							break;
 						}
 					}
 				}
 
 				// Add to the periods to output
 				if (Show)
 				{
 					if (Periods.Length() >= MAX_RECUR)
 						break;
 
 					TimePeriod &p = Periods.New();
 					p.s = CurLocal;
 					p.e = CurLocal;
 					p.e.AddHours(Diff.Hours());
 					p.e.AddMinutes(Diff.Minutes());
 				}
 
 				Count++;
 			}
 		}
 
 		// Now process periods into multiday segments if needed
 		for (unsigned k=0; k<Periods.Length(); k++)
 		{
 			TimePeriod &n = Periods[k];
 			
 			if (!n.s.IsSameDay(n.e))
 			{
 				for (LDateTime i = n.s; true; i.AddDays(1))
 				{
 					if (i.IsSameDay(n.s))
 					{
 						// Start day
 						TimePeriod t;
 						t.s = n.s;
 						t.e = n.s;
 						int h = t.e.Hours();
 						if (h > Calendar::WorkDayEnd)
 						{
 							t.e.Hours(23);
 							t.e.Minutes(59);
 							t.e.Seconds(59);
 						}
 						else
 						{
 							t.e.Hours(Calendar::WorkDayEnd);
 						}
 
 						if (t.Overlap(w))
 						{
 							t.c = this;
 							Times.Add(t);
 						}
 					}
 					else if (i.IsSameDay(n.e))
 					{
 						// End day
 						TimePeriod t;
 						t.s = n.e;
 						t.e = n.e;
 						int h = t.s.Hours();
 						if (h < Calendar::WorkDayStart)
 						{
 							t.s.Hours(0);
 							t.s.Minutes(0);
 							t.s.Seconds(0);
 						}
 						else
 						{
 							t.s.Hours(Calendar::WorkDayStart);
 						}
 
 						if (t.Overlap(w))
 						{
 							t.c = this;
 							Times.Add(t);
 						}
 						break;
 					}
 					else
 					{
 						// Middle day
 						TimePeriod t;
 						t.s = i;
 						t.s.Hours(Calendar::WorkDayStart);
 						t.s.Minutes(0);
 						t.s.Seconds(0);
 						t.e = i;
 						t.e.Hours(Calendar::WorkDayEnd);
 						t.e.Minutes(0);
 						t.e.Seconds(0);
 
 						if (t.Overlap(w))
 						{
 							t.c = this;
 							Times.Add(t);
 						}
 					}
 				}
 			}
 			else if (n.Overlap(w))
 			{
 				n.c = this;
 				Times.Add(n);
 			}
 		}
 	}
 
 	return (int)Times.Length() > StartLen;
 }
 
 CalendarType Calendar::GetCalType()
 {
 	CalendarType Type = CalEvent;
 	GetField(FIELD_CAL_TYPE, (int&)Type);
 	return Type;
 }
 
 void Calendar::SetCalType(CalendarType Type)
 {
 	SetField(FIELD_CAL_TYPE, (int)Type);
 	SetImage(Type == CalTodo ? ICON_TODO : ICON_CALENDAR);
 }
 
 LColour Calendar::GetColour()
 {
 	if (GetObject())
 	{
 		int64 c = GetObject()->GetInt(FIELD_COLOUR);
 		if (c >= 0)
 		{
 			return LColour((uint32_t)c, 32);
 		}
 	}
 
 	if (Source)
 		return Source->GetColour();
 
 	return LColour(L_LOW);
 }
 
 void Calendar::OnPaintView(LSurface *pDC, LFont *Font, LRect *Pos, TimePeriod *Period)
 {
 	LRect p = *Pos;
 	const char *Title = "...";
 	LDateTime Now;
 
 	float Sx = 1.0;
 	float Sy = 1.0;
 	if (pDC->IsPrint())
 	{
 		auto DcDpi = pDC->GetDpi();
 		auto SrcDpi = LScreenDpi();
 		Sx = (float)DcDpi.x / SrcDpi.x;
 		Sy = (float)DcDpi.y / SrcDpi.y;
 	}
 	float Scale = Sx < Sy ? Sx : Sy;
 
 	Now.SetNow();
 	GetField(FIELD_CAL_SUBJECT, Title);
 	bool Delayed = GetObject() ? GetObject()->GetInt(FIELD_STATUS) == Store3Delayed : false;
 
 	LColour Grey(192, 192, 192);
 	auto View = GetView();
 	if (View && View->Selection.HasItem(this))
 	{
 		// selected
 		LColour f = L_FOCUS_SEL_FORE;
 		LColour b = L_FOCUS_SEL_BACK;
 		if (Delayed)
 		{
 			f = f.Mix(Grey);
 			b = b.Mix(Grey);
 		}
 
 		pDC->Colour(f);
 		pDC->Box(&p);
 		p.Inset(1, 1);
 		pDC->Colour(b);
 		Font->Colour(f, b);
 	}
 	else
 	{
 		LColour Text(0x80, 0x80, 0x80);
 		LColour Base = GetColour();
 		LColour Qtr = GdcMixColour(Base, LColour(L_WORKSPACE), 0.1f);
 		LColour Half = GdcMixColour(Base, LColour(L_WORKSPACE), 0.4f);
 
 		// not selected
 		LColour f, b;
 
 		if (Period && Now < Period->s)
 		{
 			// future entry (full colour)
 			f = Base;
 			b = Half;
 		}
 		else
 		{
 			// historical entry (half strength colour)
 			f = Half;
 			b = Qtr;
 		}
 
 		if (Delayed)
 		{
 			f = f.Mix(Grey);
 			b = b.Mix(Grey);
 		}
 
 		pDC->Colour(f);
 		pDC->Box(&p);
 		p.Inset(1, 1);
 		pDC->Colour(b);
 		Font->Colour(Text, b);
 	}
 
 	pDC->Rectangle(&p);
 	p.Inset((int)SX(1), (int)SY(1));
 
 	Font->Transparent(false);
 	LDisplayString ds(Font, Title);
 	float Ht = p.Y() > 0 ? (float)ds.Y() / p.Y() : 1.0f;
 	if (Ht < 0.75f)
 		p.Inset((int)SX(3), (int)SY(3));
 	else if (Ht < 0.95f)
 		p.Inset((int)SX(1), (int)SY(1));
 	ds.Draw(pDC, p.x1, p.y1, &p);
 
 	ViewPos.Union(Pos);
 }
 
 Thing &Calendar::operator =(Thing &Obj)
 {
 	if (Obj.GetObject() &&
 		GetObject())
 	{
 		GetObject()->CopyProps(*Obj.GetObject());
 	}
 
 	return *this;
 }
 
 bool Calendar::operator ==(Thing &t)
 {
 	Calendar *c = t.IsCalendar();
 	if (!c)
 		return false;
 
 	{
 		LDateTime a, b;
 		if (GetField(FIELD_CAL_START_UTC, a) && c->GetField(FIELD_CAL_START_UTC, b) && a != b)
 			return false;
 
 		if (GetField(FIELD_CAL_END_UTC, a) && c->GetField(FIELD_CAL_END_UTC, b) && a != b)
 			return false;
 	}
 
 	{
 		const char *a, *b;
 		if (GetField(FIELD_CAL_SUBJECT, a) && c->GetField(FIELD_CAL_SUBJECT, b) && Stricmp(a, b))
 			return false;
 
 		if (GetField(FIELD_CAL_LOCATION, a) && c->GetField(FIELD_CAL_LOCATION, b) && Stricmp(a, b))
 			return false;
 	}
 
 	return true;
 }
 
 int Calendar::Compare(LListItem *Arg, ssize_t FieldId)
 {
 	Calendar *c1 = this;
 	Calendar *c2 = dynamic_cast<Calendar*>(Arg);
 	if (c1 && c2)
 	{
 		switch (FieldId)
 		{
 			case FIELD_CAL_START_UTC:
 			case FIELD_CAL_END_UTC:
 			{
 				LDateTime d1, d2;
 				if (!c1->GetField((int)FieldId, d1))
 					d1.SetNow();
 
 				if (!c2->GetField((int)FieldId, d2))
 					d2.SetNow();
 
 				return d1.Compare(&d2);
 				break;
 			}
 			case FIELD_CAL_SUBJECT:
 			case FIELD_CAL_LOCATION:
 			{
 				const char *s1 = "", *s2 = "";
 				if (c1->GetField((int)FieldId, s1) &&
 					c2->GetField((int)FieldId, s2))
 				{
 					return _stricmp(s1, s2);
 				}
 				break;
 			}
 		}
 	}
 
 	return 0;
 }
 
 uint32_t Calendar::GetFlags()
 {
 	return 0;
 }
 
 ThingUi *Calendar::DoUI(MailContainer *c)
 {
 	if (!Ui)
 	{
 		Ui = new CalendarUi(this);
 	}
 	return Ui;
 }
 
 ThingUi *Calendar::GetUI()
 {
 	return Ui;
 }
 
 bool Calendar::SetUI(ThingUi *ui)
 {
 	if (Ui)
 		Ui->Item = NULL;
 	Ui = dynamic_cast<CalendarUi*>(ui);
 	if (Ui)
 		Ui->Item = this;
 	return true;
 }
 
 void Calendar::OnMouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		if (m.Left())
 		{
 			if (m.Double())
 			{
 				DoUI();
 			}
 		}
 		else if (m.Right())
 		{
 			auto View = GetView();
 			DoContextMenu(m, View ? (LView*)View : (LView*)App);
 		}
 	}
 }
 
 void Calendar::OnCreate()
 {
 	for (auto v: CalendarView::CalendarViews)
 		v->OnContentsChanged();
 }
 
 bool Calendar::OnDelete()
 {
 	bool IsTodo = GetCalType() == CalTodo;
 	bool Status = Thing::OnDelete();
 	
 	if (IsTodo)
 		DeleteObj(TodoView);
 
 	for (auto v: CalendarView::CalendarViews)
 		v->OnContentsChanged();
 	
 	return Status;
 }
 
 bool Calendar::GetParentSelection(LList *Lst, List<LListItem> &s)
 {
 	if (Lst)
 	{
 		return Lst->GetSelection(s);
 	}
 
 	if (auto View = GetView())
 	{
 		LArray<Calendar*> &a = View->GetSelection();
 		for (unsigned i=0; i<a.Length(); i++)
 		{
 			s.Insert(dynamic_cast<LListItem*>(a[i]));
 		}
 		return true;
 	}
 
 	return false;
 }
 
 #define IDM_MOVE_TO 4000
 
 void Calendar::DoContextMenu(LMouse &m, LView *Parent)
 {
     LSubMenu Sub;
 	LScriptUi s(&Sub);
 	if (s.Sub)
 	{
 		s.Sub->AppendItem(LLoadString(IDS_OPEN), IDM_OPEN);
 		s.Sub->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE);
 		s.Sub->AppendItem(LLoadString(IDS_EXPORT), IDM_EXPORT);
 		s.Sub->AppendSeparator();
 		s.Sub->AppendItem(LLoadString(IDS_INSPECT), IDM_INSPECT);
 
 		CalendarView *Cv = dynamic_cast<CalendarView*>(Parent);
 		if (Cv)
 		{
 			s.Sub->AppendSeparator();
 
 			for (unsigned n = 0; n<CalendarSource::GetSources().Length(); n++)
 			{
 				char m[256];
 				CalendarSource *Cs = CalendarSource::GetSources().ItemAt(n);
 				sprintf_s(m, sizeof(m), "Move to '%s'\n", Cs->GetName());
 				s.Sub->AppendItem(m, IDM_MOVE_TO + n++, Source != Cs);
 			}
 		}
 
 		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);
 
 			Args.DeleteObjects();
 		}
 
 		m.ToScreen();
 		int Result = s.Sub->Float(App, m.x, m.y);
 		switch (Result)
 		{
 			default:
 			{
 				if (Cv)
 				{
 					int Idx = Result - IDM_MOVE_TO;
 					if (Idx >= 0 && Idx < (int)CalendarSource::GetSources().Length())
 					{
 						CalendarSource *Dst = CalendarSource::GetSources().ItemAt(Idx);
 						if (Dst)
 						{
 							FolderCalendarSource *Fsrc = dynamic_cast<FolderCalendarSource*>(Dst);
 							if (Fsrc)
 							{
 								const char *Path = Fsrc->GetPath();
 								ScribeFolder *DstFolder = App->GetFolder(Path);
 								if (DstFolder)
 								{
 									LArray<Thing*> Items;
 									Items.Add(this);
 									DstFolder->MoveTo(Items);
 									if (Items[0] != (Thing*)this)
 										return;
 
 									Source = Dst;
 									Cv->Invalidate();
 								}
 							}
 							else LAssert(!"Impl me.");
 						}
 					}
 				}
 
 				// Handle any installed callbacks for menu items
 				for (unsigned i=0; i<s.Callbacks.Length(); i++)
 				{
 					LScriptCallback &Cb = s.Callbacks[i];
 					if (Cb.Param == Result)
 					{
 						LScriptArguments Args(NULL);
 						Args[0] = new LVariant(App);
 						Args[1] = new LVariant(this);
 						Args[2] = new LVariant(Cb.Param);
 						
 						App->ExecuteScriptCallback(Cb, Args);
 					}
 				}
 				break;
 			}
 			case IDM_OPEN:
 			{
 				DoUI();
 				break;
 			}
 			case IDM_DELETE:
 			{
 				LVariant ConfirmDelete;
 				App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 				if (!ConfirmDelete.CastInt32() ||
 					LgiMsg(Parent, LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 				{
 					List<LListItem> Del;
 
 					LList *PList = dynamic_cast<LList*>(Parent);
 					if (GetParentSelection(PList ? PList : GetList(), Del))
 					{
 						for (auto i: Del)
 						{
 							Thing *t = dynamic_cast<Thing*>(i);
 							if (t)
 							{
 								t->OnDelete();
 							}
 							else
 							{
 								CalendarTodoItem *Todo = dynamic_cast<CalendarTodoItem*>(i);
 								if (Todo)
 								{
 									Calendar *c = Todo->GetTodo();
 									c->OnDelete();
 								}
 							}
 						}
 					}
 					else
 					{
 						Thing *t = this;
 						t->OnDelete();
 					}
 				}
 				break;
 			}
 			case IDM_EXPORT:
 			{
 				ExportAll(GetList(), sMimeVCalendar, NULL);
 				break;
 			}
 			case IDM_INSPECT:
 			{
 				new ObjectInspector(App, this);
 				break;
 			}
 		}
 	}
 }
 
 const char *Calendar::GetText(int i)
 {
 	static char s[64];
 	
 	if (!GetObject())
 	{
 		LAssert(!"No storage object");
 		return 0;
 	}
 	
 	int Field = 0;
 	if (FieldArray.Length())
 	{
 		if (i >= 0 && i < (int) FieldArray.Length())
 			Field = FieldArray[i];
 	}
 	else if (i >= 0 && i < CountOf(DefaultCalenderFields))
 	{
 		Field = DefaultCalenderFields[i];
 	}
 
 	if (!Field)
 		return 0;
 
 	ItemFieldDef *Def = GetFieldDefById(Field);
 	if (!Def)
 	{
 		LAssert(!"Where is the field def?");
 		return 0;
 	}
 
 	switch (Def->Type)
 	{
 		case GV_STRING:
 		{
 			return GetObject()->GetStr(Field);
 			break;
 		}
 		case GV_INT32:
 		{
 			sprintf_s(s, sizeof(s), LPrintfInt64, GetObject()->GetInt(Field));
 			return s;
 			break;
 		}
 		case GV_DATETIME:
 		{
 			// Get any effective timezone for this event.
 			LString Tz = GetObject()->GetStr(FIELD_CAL_TIMEZONE);
 
 			auto dt = GetObject()->GetDate(Field);
 			if (dt && dt->IsValid())
 			{
 				LDateTime tmp = *dt;
 				
 				#if DEBUG_DATES
 				printf("GetText.UTC %i = %s\n", i, tmp.Get().Get());
 				#endif
 				
 				bool UseLocal = true;
 				tmp.SetTimeZone(0, false);
 
 				if (Tz.Get())
 				{
 					bool HasPt = false, HasDigit = false;
 					char *e = Tz.Get();
 					while (strchr(" \t\r\n-.+", *e) || IsDigit(*e))
 					{
 						if (*e == '.') HasPt = true;
 						if (IsDigit(*e)) HasDigit = true;
 						e++;
 					}
 					if (HasDigit)
 					{
 						if (HasPt)
 						{
 							double TzHrs = Tz.Float();
 							double i, f = modf(TzHrs, &i);
 							int Mins = (int) ((i * 60) + (f * 60));
 							tmp.AddMinutes(Mins);
 						}
 						else
 						{
 							int64 i = Tz.Int();
 							int a = (int)ABS(i);
 							int Mins = (int) (((a / 100) * 60) + (a % 100));
 							tmp.AddMinutes(i < 0 ? -Mins : Mins);
 						}
 						UseLocal = false;
 					}
 				}
 
 				if (UseLocal)
 					tmp.ToLocal();
 
 				#if DEBUG_DATES
 				printf("GetText.Local %i = %s\n", i, tmp.Get().Get());
 				#endif
 
 				tmp.Get(s, sizeof(s));
 				return s;
 			}
 			break;
 		}
 		default:
 		{
 			LAssert(0);
 			break;
 		}
 	}
 
 	return 0;
 }
 
 int *Calendar::GetDefaultFields()
 {
 	return DefaultCalenderFields;
 }
 
 const char *Calendar::GetFieldText(int Field)
 {
 	return 0;
 }
 
 bool Calendar::Overlap(Calendar *c)
 {
 	if (c)
 	{
 		LDateTime Ts, Te, Cs, Ce;
 		if (GetField(FIELD_CAL_START_UTC, Ts) &&
 			c->GetField(FIELD_CAL_START_UTC, Cs))
 		{
 			if (!GetField(FIELD_CAL_END_UTC, Te))
 			{
 				Te = Ts;
 				Te.AddHours(1);
 			}
 
 			if (!c->GetField(FIELD_CAL_END_UTC, Ce))
 			{
 				Ce = Cs;
 				Ce.AddHours(1);
 			}
 			
 			if ((Ce <= Ts) || (Cs >= Te))
 			{
 				return false;
 			}
 			
 			return true;			
 		}
 	}
 	
 	return false;
 }
 
 bool Calendar::Save(ScribeFolder *Folder)
 {
 	bool Status = false;
 
 	// Check the dates are the right way around
 	LDateTime Start, End;
 	if (GetField(FIELD_CAL_START_UTC, Start) &&
 		GetField(FIELD_CAL_END_UTC, End))
 	{
 		if (End < Start)
 		{
 			SetField(FIELD_CAL_START_UTC, End);
 			SetField(FIELD_CAL_END_UTC, Start);
 		}
 	}
 
 	auto ChangeEvent = [this](bool Status)
 	{
 		auto View = GetView();
 		if (View && Status)
 		{
 			View->OnContentsChanged(Source);
 			OnSerialize(true);
 		}
 	};
 
 	if (GetObject() &&
 		GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Webdav)
 	{
 		auto ParentObj = Folder ? Folder->GetObject() : NULL;
 		Store3Status s = GetObject()->Save(ParentObj);
 		Status = s > Store3Error;
 		if (Status)
 			SetDirty(false);
 
 		ChangeEvent(Status);
 	}
 	else
 	{
 		if (!Folder)
 		{
 			Folder = GetFolder();
 		}
 		if (!Folder && App)
 		{
 			Folder = App->GetFolder(FOLDER_CALENDAR);
 		}
 
 		// FIXME: This can't wait for WriteThing to finish it's call back...
 		Status = true;
 		if (Folder)
 		{
+			LDateTime Now;
+			GetObject()->SetDate(FIELD_DATE_MODIFIED, &Now.SetNow());
+
 			Folder->WriteThing(this, [this, ChangeEvent](auto Status)
 			{
 				if (Status > Store3Error)
 					SetDirty(false);
 				ChangeEvent(Status);
 			});
 		}
 		else ChangeEvent(Status);
 	}
 
 	return Status;
 }
 
 // Import/Export
 bool Calendar::GetFormats(bool Export, LString::Array &MimeTypes)
 {
 	MimeTypes.Add(sMimeVCalendar);
 	return MimeTypes.Length() > 0;
 }
 
 Thing::IoProgress Calendar::Import(IoProgressImplArgs)
 {
 	if (Stricmp(mimeType, sMimeVCalendar) &&
 		Stricmp(mimeType, sMimeICalendar))
 		IoProgressNotImpl();
 
 
 	VCal vCal;
 	if (!vCal.Import(GetObject(), stream))
 		IoProgressError("vCal import failed.");
 
 	IoProgressSuccess();
 }
 
 Thing::IoProgress Calendar::Export(IoProgressImplArgs)
 {
 	if (Stricmp(mimeType, sMimeVCalendar))
 		IoProgressNotImpl();
 
 	VCal vCal;
 	if (!vCal.Export(GetObject(), stream))
 		IoProgressError("vCal export failed.");
 
 	IoProgressSuccess();
 }
 
 char *Calendar::GetDropFileName()
 {
 	if (!DropFileName)
 	{
 		const char *Name = 0;
 		GetField(FIELD_CAL_SUBJECT, Name);
 		DropFileName.Reset(MakeFileName(Name ? Name : "Cal", "ics"));
 	}
 	return DropFileName;
 }
 
 bool Calendar::GetDropFiles(LString::Array &Files)
 {
 	bool Status = false;
 
 	if (GetDropFileName())
 	{
 		if (!LFileExists(DropFileName))
 		{
 			LAutoPtr<LFile> F(new LFile);
 			if (F->Open(DropFileName, O_WRITE))
 			{
 				F->SetSize(0);
 				Export(AutoCast(F), sMimeVCalendar);
 			}
 		}
 
 		if (LFileExists(DropFileName))
 		{
 			Files.Add(DropFileName.Get());
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 void Calendar::OnPrintHeaders(ScribePrintContext &Context)
 {
 	LDisplayString *ds = Context.Text(LLoadString(IDS_CAL_EVENT));
 	LRect &r = Context.MarginPx;
 	int Line = ds->Y();
 	LDrawListSurface *Page = Context.Pages.Last();
 	Page->Rectangle(r.x1, Context.CurrentY + (Line * 5 / 10), r.x2, Context.CurrentY + (Line * 6 / 10));
 	Context.CurrentY += Line;
 }
 
 void Calendar::OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages)
 {
 	// Print document
 	for (ItemFieldDef *Fld = CalendarFields; Fld->FieldId; Fld++)
 	{
 		LString Value;
 		switch (Fld->Type)
 		{
 			case GV_STRING:
 			{
 				Value = GetObject()->GetStr(Fld->FieldId);
 				break;
 			}
 			case GV_DATETIME:
 			{
 				auto Dt = GetObject()->GetDate(Fld->FieldId);
 				if (Dt)
 				{
 					char s[64] = "<error>";
 					Dt->Get(s, sizeof(s));
 					Value = s;					
 				}
 				break;
 			}
 			default:
 				break;
 		}
 		
 		if (Value)
 		{
 			LString f;
 			const char *Name = LLoadString(Fld->FieldId);
 			f.Printf("%s: %s", Name ? Name : Fld->DisplayText, Value.Get());
 			// LDisplayString *ds = Context.Text(f);
 		}
 	}
 }
 
 bool Calendar::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		// String variables
 		case SdSubject: // Type: String
 			Value = GetObject()->GetStr(FIELD_CAL_SUBJECT);
 			break;
 		case SdTo: // Type: String
 			Value = GetObject()->GetStr(FIELD_TO);
 			break;
 		case SdLocation: // Type: String
 			Value = GetObject()->GetStr(FIELD_CAL_LOCATION);
 			break;
 		case SdUid: // Type: String
 			Value = GetObject()->GetStr(FIELD_UID);
 			break;
 		case SdReminders: // Type: String
 			Value = GetObject()->GetStr(FIELD_CAL_REMINDERS);
 			break;
 		case SdNotes: // Type: String
 			Value = GetObject()->GetStr(FIELD_CAL_NOTES);
 			break;
 		case SdStatus: // Type: String
 			Value = GetObject()->GetStr(FIELD_CAL_STATUS);
 			break;
 
 		// Int variables
 		case SdType: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_TYPE);
 			break;
 		case SdCompleted: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_COMPLETED);
 			break;
 		case SdShowTimeAs: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_SHOW_TIME_AS);
 			break;
 		case SdRecur: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_RECUR);
 			break;
 		case SdRecurFreq: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_RECUR_FREQ);
 			break;
 		case SdRecurInterval: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_RECUR_INTERVAL);
 			break;
 		case SdRecurEndCount: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_RECUR_END_COUNT);
 			break;
 		case SdRecurEndType: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_RECUR_END_TYPE);
 			break;
 		case SdRecurFilterDays: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_RECUR_FILTER_DAYS);
 			break;
 		case SdRecurFilterMonths: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_RECUR_FILTER_MONTHS);
 			break;
 		case SdPrivacy: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_PRIVACY);
 			break;
 		case SdAllDay: // Type: Int32
 			Value = GetObject()->GetInt(FIELD_CAL_ALL_DAY);
 			break;
 		case SdColour: // Type: Int64
 			Value = GetObject()->GetInt(FIELD_COLOUR);
 			break;
 
 		// Date time fields
 		case SdStart: // Type: DateTime
 			Value = GetObject()->GetDate(FIELD_CAL_START_UTC);
 			break;
 		case SdEnd: // Type: DateTime
 			Value = GetObject()->GetDate(FIELD_CAL_END_UTC);
 			break;
 
 		default:
 			return false;
 	}
 
 	return true;
 }
 
 bool Calendar::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		// String variables
 		case SdSubject:
 			Value = GetObject()->SetStr(FIELD_CAL_SUBJECT, Value.Str());
 			break;
 		case SdTo:
 			Value = GetObject()->SetStr(FIELD_TO, Value.Str());
 			break;
 		case SdLocation:
 			Value = GetObject()->SetStr(FIELD_CAL_LOCATION, Value.Str());
 			break;
 		case SdUid:
 			Value = GetObject()->SetStr(FIELD_UID, Value.Str());
 			break;
 		case SdReminders:
 			Value = GetObject()->SetStr(FIELD_CAL_REMINDERS, Value.Str());
 			break;
 		case SdNotes:
 			Value = GetObject()->SetStr(FIELD_CAL_NOTES, Value.Str());
 			break;
 		case SdStatus:
 			Value = GetObject()->SetStr(FIELD_CAL_STATUS, Value.Str());
 			break;
 
 		// Int variables
 		case SdType:
 			Value = GetObject()->SetInt(FIELD_CAL_TYPE, Value.CastInt32());
 			break;
 		case SdCompleted:
 			Value = GetObject()->SetInt(FIELD_CAL_COMPLETED, Value.CastInt32());
 			break;
 		case SdShowTimeAs:
 			Value = GetObject()->SetInt(FIELD_CAL_SHOW_TIME_AS, Value.CastInt32());
 			break;
 		case SdRecur:
 			Value = GetObject()->SetInt(FIELD_CAL_RECUR, Value.CastInt32());
 			break;
 		case SdRecurFreq:
 			Value = GetObject()->SetInt(FIELD_CAL_RECUR_FREQ, Value.CastInt32());
 			break;
 		case SdRecurInterval:
 			Value = GetObject()->SetInt(FIELD_CAL_RECUR_INTERVAL, Value.CastInt32());
 			break;
 		case SdRecurEndCount:
 			Value = GetObject()->SetInt(FIELD_CAL_RECUR_END_COUNT, Value.CastInt32());
 			break;
 		case SdRecurEndType:
 			Value = GetObject()->SetInt(FIELD_CAL_RECUR_END_TYPE, Value.CastInt32());
 			break;
 		case SdRecurFilterDays:
 			Value = GetObject()->SetInt(FIELD_CAL_RECUR_FILTER_DAYS, Value.CastInt32());
 			break;
 		case SdRecurFilterMonths:
 			Value = GetObject()->SetInt(FIELD_CAL_RECUR_FILTER_MONTHS, Value.CastInt32());
 			break;
 		case SdPrivacy:
 			Value = GetObject()->SetInt(FIELD_CAL_PRIVACY, Value.CastInt32());
 			break;
 		case SdColour:
 			Value = GetObject()->SetInt(FIELD_COLOUR, Value.CastInt32());
 			break;
 		case SdAllDay:
 			Value = GetObject()->SetInt(FIELD_CAL_ALL_DAY, Value.CastInt32());
 			break;
 
 		// Date time fields
 		case SdStart:
 			if (Value.Type == GV_DATETIME)
 				Value = GetObject()->SetDate(FIELD_CAL_START_UTC, Value.Value.Date);
 			else if (Value.Str())
 			{
 				LDateTime dt;
 				dt.Set(Value.Str());
 				GetObject()->SetDate(FIELD_CAL_START_UTC, &dt);
 			}
 			break;
 		case SdEnd:
 			if (Value.Type == GV_DATETIME)
 				Value = GetObject()->SetDate(FIELD_CAL_END_UTC, Value.Value.Date);
 			else if (Value.Str())
 			{
 				LDateTime dt;
 				dt.Set(Value.Str());
 				GetObject()->SetDate(FIELD_CAL_END_UTC, &dt);
 			}
 			break;
 
 		default:
 			return false;
 	}
 
 	return true;
 }
 
 bool Calendar::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	// ScribeDomType Fld = StrToDom(MethodName);
 	
 	return Thing::CallMethod(MethodName, ReturnValue, Args);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 bool SerializeUi(ItemFieldDef *Defs, LDataI *Object, LViewI *View, bool ToUi)
 {
 	if (!Object || !Defs || !View)
 		return false;
 
 	if (ToUi)
 	{
 		for (ItemFieldDef *d = Defs; d->FieldId; d++)
 		{
 			if (d->CtrlId <= 0)
 				continue;
 
 			switch (d->Type)
 			{
 				case GV_STRING:
 				{
 					auto s = Object->GetStr(d->FieldId);
 					View->SetCtrlName(d->CtrlId, s);
 					break;
 				}
 				case GV_INT32:
 				{
 					int64 i = Object->GetInt(d->FieldId);
 					View->SetCtrlValue(d->CtrlId, i);
 					break;
 				}
 				case GV_DATETIME:
 				{
 					char s[64] = "";
 					auto dt = Object->GetDate(d->FieldId);
 					if (dt && dt->Year())
 						dt->Get(s, sizeof(s));
 					View->SetCtrlName(d->CtrlId, s);
 					break;
 				}
 				default:
 				{
 					LAssert(0);
 					break;
 				}
 			}
 		}
 	}
 	else
 	{
 		for (ItemFieldDef *d = Defs; d->FieldId; d++)
 		{
 			if (d->CtrlId <= 0)
 				continue;
 
 			switch (d->Type)
 			{
 				case GV_STRING:
 				{
 					const char *s = View->GetCtrlName(d->CtrlId);
 					Object->SetStr(d->FieldId, s);
 					break;
 				}
 				case GV_INT32:
 				{
 					int i = (int)View->GetCtrlValue(d->CtrlId);
 					Object->SetInt(d->FieldId, i);
 					break;
 				}
 				case GV_DATETIME:
 				{
 					const char *s = View->GetCtrlName(d->CtrlId);
 					LDateTime dt;
 					dt.Set(s);
 					Object->SetDate(d->FieldId, &dt);
 					break;
 				}
 				default:
 				{
 					LAssert(0);
 					break;
 				}
 			}
 		}
 	}
 
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 class LEditDropDown : public LEdit
 {
 public:
 	enum DropType
 	{
 		DropNone,
 		DropDate,
 		DropTime,
 	};
 
 protected:
 	DropType Type;
 	LAutoPtr<LPopup> Popup;
 
 public:
 	LEditDropDown(int id) : LEdit(id, 0, 0, 60, 20, NULL)
 	{
 		Type = DropNone;
 		SetObjectName(Res_Custom);
 	}
 	
 	void SetType(DropType type) { Type = type; }
 	const char *GetClass() { return "LEditDropDown"; }
 	
 	void OnMouseClick(LMouse &m)
 	{
 		LEdit::OnMouseClick(m);
 		
 		if (Focus() && Popup && !Popup->Visible())
 		{
 			Popup->Visible(true);
 		}
 	}
 	
 	void OnFocus(bool f)
 	{
 		if (f)
 		{
 			if (!Popup)
 			{
 				if (Type == DropDate)
 					Popup.Reset(new LDatePopup(this));
 				else if (Type == DropTime)
 					Popup.Reset(new LTimePopup(this));
 				
 				if (Popup)
 				{
 					Popup->TakeFocus(false);
 					
 					LPoint p(0, Y());
 					PointToScreen(p);
 					LRect r = Popup->GetPos();
 					r.Offset(p.x - r.x1, p.y - r.y1);
 					Popup->SetPos(r);
 				}
 			}
 			
 			if (Popup)
 				Popup->Visible(true);
 		}
 	}
 
 	int OnNotify(LViewI *Wnd, LNotification n)
 	{
 		/*
 		LgiTrace("OnNotify %s, %i\n", Wnd->GetClass(), Flags);
 		if (Wnd == (LViewI*)Popup)
 		{
 			GDatePopup *Date;
 			if ((Date = dynamic_cast<GDatePopup*>(Popup.Get())))
 			{
 				LDateTime Ts = Date->Get();
 				char s[256];
 				Ts.GetDate(s, sizeof(s));
 				Name(s);
 			}
 			else LgiTrace("%s:%i - Incorrect pop up type.\n", _FL);
 		}
 		*/
 		
 		return 0;
 	}
 
 	void OnChildrenChanged(LViewI *Wnd, bool Attaching)
 	{
 		if (Wnd == (LViewI*)Popup.Get() && !Attaching)
 		{
 			// This gets called in the destructor of the Popup, so we should
 			// lose the pointer to it.
 			Popup.Release();
 		}
 	}
 };
 
 struct LEditDropDownFactory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (!_stricmp(Class, "LEditDropDown"))
 		{
 			return new LEditDropDown(-1);
 		}
 		return NULL;
 	}
 }	EditDropDownFactory;
 
 //////////////////////////////////////////////////////////////////////////////
 class LRecurDlg : public LDialog
 {
 	CalendarUi *Ui;
 	LEditDropDown *EndOnDate;
 	LCombo *Repeats;
 	bool AcceptNotify;
 	
 public:
 	LRecurDlg(CalendarUi *ui)
 	{
 		EndOnDate = NULL;
 		Repeats = NULL;
 		AcceptNotify = true;
 		Ui = ui;
 		SetParent(ui);		
 		if (LoadFromResource(IDD_CAL_RECUR))
 		{
 			if (GetViewById(IDC_ON_DATE, EndOnDate))
 			{
 				EndOnDate->SetType(LEditDropDown::DropDate);
 				
 				LDateTime dt;
 				dt.SetNow();
 				char s[64];
 				dt.GetDate(s, sizeof(s));
 				EndOnDate->Name(s);
 			}
 			
 			if (GetViewById(IDC_REPEATS, Repeats))
 			{
 				Repeats->Insert(LLoadString(IDS_DAY));
 				Repeats->Insert(LLoadString(IDS_WEEK));
 				Repeats->Insert(LLoadString(IDS_MONTH));
 				Repeats->Insert(LLoadString(IDS_YEAR));
 				Repeats->Value(1);
 			}
 			
 			Radio(IDC_NEVER);
 			SetCtrlValue(IDC_EVERY, 1);
 			Serialize(false);
 		}
 	}
 	
 	~LRecurDlg()
 	{
 	}
 	
 	void Serialize(bool Write)
 	{
 		int DayCtrls[] = {
 			IDC_SUNDAY,
 			IDC_MONDAY,
 			IDC_TUESDAY,
 			IDC_WEDNESDAY,
 			IDC_THURSDAY,
 			IDC_FRIDAY,
 			IDC_SATURDAY
 		};
 		
 		Calendar *c = Ui->GetCal();
 		LDataI *o = c->GetObject();
 		if (Write)
 		{
 			// Dlg -> Object
 			int64 v = Repeats->Value();
 			o->SetInt(FIELD_CAL_RECUR_FREQ, v);
 			v = GetCtrlValue(IDC_EVERY);
 			o->SetInt(FIELD_CAL_RECUR_INTERVAL, v);
 			
 			int DayFilter = 0;
 			for (int i=0; i<7; i++)
 			{
 				if (GetCtrlValue(DayCtrls[i]))
 					DayFilter |= 1 << i;
 			}
 			o->SetInt(FIELD_CAL_RECUR_FILTER_DAYS, DayFilter);
 			
 			if (GetCtrlValue(IDC_NEVER))
 			{
 				o->SetInt(FIELD_CAL_RECUR_END_TYPE, CalEndNever);
 			}
 			else if (GetCtrlValue(IDC_AFTER))
 			{
 				o->SetInt(FIELD_CAL_RECUR_END_TYPE, CalEndOnCount);
 				o->SetInt(FIELD_CAL_RECUR_END_COUNT, GetCtrlValue(IDC_AFTER_COUNT));
 			}
 			else if (GetCtrlValue(IDC_ON))
 			{
 				o->SetInt(FIELD_CAL_RECUR_END_TYPE, CalEndOnDate);
 				
 				LDateTime e;
 				e.SetDate(GetCtrlName(IDC_ON_DATE));
 				e.SetTime("11:59:59");
 				o->SetDate(FIELD_CAL_RECUR_END_DATE, &e);
 			}
 			else LAssert(0);
 		}
 		else
 		{
 			// Object -> Dlg
 			int64 v = o->GetInt(FIELD_CAL_RECUR_FREQ);
 			Repeats->Value(v);
 			OnRepeat(v);
 			v = o->GetInt(FIELD_CAL_RECUR_INTERVAL);
 			SetCtrlValue(IDC_EVERY, MAX(v, 1));
 
 			int DayFilter = (int)o->GetInt(FIELD_CAL_RECUR_FILTER_DAYS);
 			for (int i=0; i<7; i++)
 			{
 				SetCtrlValue(DayCtrls[i], (DayFilter & (1 << i)) ? 1 : 0);
 			}
 
 			CalRecurEndType EndType = (CalRecurEndType) o->GetInt(FIELD_CAL_RECUR_END_TYPE);
 			if (EndType == CalEndOnCount)
 			{
 				Radio(IDC_AFTER);
 				SetCtrlValue(IDC_AFTER_COUNT, o->GetInt(FIELD_CAL_RECUR_END_COUNT));
 			}
 			else if (EndType == CalEndOnDate)
 			{
 				Radio(IDC_ON);
 				
 				auto e = o->GetDate(FIELD_CAL_RECUR_END_DATE);
 				if (e)
 					SetCtrlName(IDC_ON_DATE, e->GetDate());
 			}
 			else // Default to never...
 			{
 				Radio(IDC_NEVER);
 			}			
 		}
 	}
 
 	void Radio(int Id)
 	{
 		AcceptNotify = false;
 		SetCtrlValue(IDC_NEVER, Id == IDC_NEVER);
 
 		SetCtrlValue(IDC_AFTER, Id == IDC_AFTER);
 		SetCtrlEnabled(IDC_AFTER_COUNT, Id == IDC_AFTER);
 		SetCtrlEnabled(IDC_OCCURRENCES, Id == IDC_AFTER);
 
 		SetCtrlValue(IDC_ON, Id == IDC_ON);
 		SetCtrlEnabled(IDC_ON_DATE, Id == IDC_ON);
 		AcceptNotify = true;
 	}
 	
 	void OnRepeat(int64 Val)
 	{
 		LViewI *v;
 		if (!GetViewById(IDC_TIME_TYPE, v))
 			return;
 		switch (Val)
 		{
 			case 0:
 				v->Name(LLoadString(IDS_DAYS));
 				break;
 			case 1:
 				v->Name(LLoadString(IDS_WEEKS));
 				break;
 			case 2:
 				v->Name(LLoadString(IDS_MONTHS));
 				break;
 			case 3:
 				v->Name(LLoadString(IDS_YEARS));
 				break;
 		}
 		v->SendNotify(LNotifyTableLayoutRefresh);
 	}
 	
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (!AcceptNotify)
 			return 0;
 			
 		switch (Ctrl->GetId())
 		{
 			case IDC_NEVER:
 			case IDC_AFTER:
 			case IDC_ON:
 				Radio(Ctrl->GetId());
 				break;
 			
 			case IDC_REPEATS:
 				OnRepeat(Ctrl->Value());
 				break;
 			
 			case IDOK:
 				Serialize(true);
 				// Fall through
 			case IDCANCEL:
 				EndModal(Ctrl->GetId() == IDOK);
 				break;
 		}
 		
 		return 0;
 	}
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 struct CalendarUiPriv
 {
 	CalendarUi *Ui;
 	LEditDropDown *StartDate, *StartTime;
 	LEditDropDown *EndDate, *EndTime;
 	LEdit *Entry;
 	AddressBrowse *Browse;
 	LList *Guests;
 	LList *Reminders;
 	LCombo *ReminderType;
 	LCombo *ReminderUnit;
 	LCombo *CalSelect;
 	LColourSelect *Colour;
 	
 	CalendarUiPriv(CalendarUi *ui)
 	{
 		Ui = ui;
 		StartDate = StartTime = NULL;
 		EndDate = EndTime = NULL;
 		CalSelect = NULL;
 		Entry = NULL;
 		Browse = NULL;
 		Guests = NULL;
 		Colour = NULL;
 		Reminders = NULL;
 		ReminderType = NULL;
 		ReminderUnit = NULL;
 	}
 	
 	void OnGuest()
 	{
 		const char *g = Ui->GetCtrlName(IDC_GUEST_ENTRY);
 		if (!g)
 			return;
 		
 		Mailto mt(Ui->App, g);
 		for (auto a: mt.To)
 		{
 			ListAddr *la = new ListAddr(Ui->App, a);
 			if (la)
 			{
 				Guests->Insert(la);
 			}
 		}
 		
 		Ui->SetCtrlName(IDC_GUEST_ENTRY, "");
 	}
 };
 
 CalendarUi::CalendarUi(Calendar *item) : ThingUi(item, LLoadString(IDS_CAL_EVENT))
 {
 	NotifyOn = false;
 	Item = item;
 	d = new CalendarUiPriv(this);
 	#if WINNATIVE
 	CreateClassW32("Event", LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_EVENT)));
 	#endif
 	if (!Attach(NULL))
 		LAssert(0);
 	else
 	{
 		LoadFromResource(IDD_CAL, this);
 		AttachChildren();
 
 		if (!SerializeState(Item->App->GetOptions(), OPT_CalendarEventPos, true))
 		{
 			LRect p(100, 100, 900, 700);
 			SetPos(p);
 			MoveToCenter();
 		}
 		
 		if (GetViewById(IDC_START_DATE, d->StartDate))
 		{
 			d->StartDate->SetType(LEditDropDown::DropDate);
 		}
 		if (GetViewById(IDC_START_TIME, d->StartTime))
 		{
 			d->StartTime->SetType(LEditDropDown::DropTime);
 		}
 		if (GetViewById(IDC_END_DATE, d->EndDate))
 		{
 			d->EndDate->SetType(LEditDropDown::DropDate);
 		}
 		if (GetViewById(IDC_END_TIME, d->EndTime))
 		{
 			d->EndTime->SetType(LEditDropDown::DropTime);
 		}
 		
 		GetViewById(IDC_GUEST_ENTRY, d->Entry);
 		if (GetViewById(IDC_GUESTS, d->Guests))
 		{
 			d->Guests->AddColumn(LLoadString(IDS_ADDRESS), 120);
 			d->Guests->AddColumn(LLoadString(IDS_NAME), 120);
 			d->Guests->ShowColumnHeader(false);
 		}
 		if (GetViewById(IDC_REMINDERS, d->Reminders))
 		{
 			d->Reminders->AddColumn(LLoadString(FIELD_CAL_REMINDER_TIME), 200);
 			d->Reminders->AddColumn(LLoadString(IDC_DELETE), 20);
 			d->Reminders->ShowColumnHeader(false);
 		}
 		if (GetViewById(IDC_REMINDER_TYPE, d->ReminderType))
 		{
 			d->ReminderType->Insert(LLoadString(IDS_EMAIL));
 			d->ReminderType->Insert(LLoadString(IDS_POPUP));
 			d->ReminderType->Insert("Script");
 			d->ReminderType->Value(1);
 		}
 		SetCtrlValue(IDC_REMINDER_VALUE, 10);
 		if (GetViewById(IDC_REMINDER_UNIT, d->ReminderUnit))
 		{
 			d->ReminderUnit->Insert(LLoadString(IDS_MINUTES));
 			d->ReminderUnit->Insert(LLoadString(IDS_HOURS));
 			d->ReminderUnit->Insert(LLoadString(IDS_DAYS));
 			d->ReminderUnit->Insert(LLoadString(IDS_WEEKS));
 			d->ReminderUnit->Value(0);
 		}
 		SetCtrlValue(IDC_AVAILABLE_TYPE, 1);
 		if (GetViewById(IDC_COLOUR, d->Colour))
 		{
 			LArray<LColour> Colours;
 			Colours.Add(LColour(84, 132, 237, 255));
 			Colours.Add(LColour(164, 189, 252, 255));
 			Colours.Add(LColour(70, 214, 219, 255));
 			Colours.Add(LColour(122, 231, 191, 255));
 			Colours.Add(LColour(81, 183, 73, 255));
 			Colours.Add(LColour(251, 215, 91, 255));
 			Colours.Add(LColour(255, 184, 120, 255));
 			Colours.Add(LColour(255, 136, 124, 255));
 			Colours.Add(LColour(220, 33, 39, 255));
 			Colours.Add(LColour(219, 173, 255, 255));
 			Colours.Add(LColour(225, 225, 225, 255));
 			d->Colour->SetColourList(&Colours);
 			d->Colour->Value(0);
 		}
 		if (GetViewById(IDC_CALENDAR, d->CalSelect))
 		{
 			LArray<CalendarSource*> Sources;
 			if (Item->App->GetCalendarSources(Sources))
 			{
 				for (unsigned i=0; i<Sources.Length(); i++)
 				{
 					CalendarSource *cs = Sources[i];
 					d->CalSelect->Insert(cs->GetName());					
 				}
 			}
 		}
 		
 		LView *s;
 		if (GetViewById(IDC_SUBJECT, s))
 			s->Focus(true);
 		LButton *btn;
 		if (GetViewById(IDC_SAVE, btn))
 			btn->Default(true);
 		
 		OnLoad();
 		
 		Visible(true);
 		NotifyOn = true;
 	}
 
 	LViewI *v;
 	if (GetViewById(IDC_REMINDER_TYPE, v))
 	{
 		LNotification note;
 		OnNotify(v, note);
 	}
 
 	RegisterHook(this, LKeyEvents);
 }
 
 CalendarUi::~CalendarUi()
 {
 	if (Item)
 	{
 		if (Item->App)
 			SerializeState(Item->App->GetOptions(), OPT_CalendarEventPos, false);
 		Item->SetUI(NULL);
 	}
 }
 
 bool CalendarUi::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;
 			}
 		}
 
 		if (k.vkey == LK_RETURN)
 		{
 			if (!k.Down())
 			{
 				OnSave();
 				Quit();
 			}
 
 			return true;
 		}
 	}
 
 	return false;
 }
 
 int CalendarUi::OnCommand(int Cmd, int Event, OsView Window)
 {
 	return 0;
 }
 
 void CalendarUi::OnPosChange()
 {
 	LWindow::OnPosChange();
 }
 
 void CalendarUi::CheckConsistancy()
 {
 	auto St = CurrentStart();
 	auto En = CurrentEnd();
 	if (En < St)
 	{
 		En = St;
 		En.AddMinutes(30);
 
 		SetCtrlName(IDC_END_DATE, En.GetDate().Get());
 		SetCtrlName(IDC_END_TIME, En.GetTime().Get());
 	}
 }
 
 LDateTime CalendarUi::CurrentStart()
 {
 	LDateTime dt;
 	dt.SetDate(GetCtrlName(IDC_START_DATE));
 	dt.SetTime(GetCtrlName(IDC_START_TIME));
 	return dt;
 }
 
 LDateTime CalendarUi::CurrentEnd()
 {
 	LDateTime dt;
 	dt.SetDate(GetCtrlName(IDC_END_DATE));
 	dt.SetTime(GetCtrlName(IDC_END_TIME));
 	return dt;
 }
 
 void CalendarUi::UpdateStartRelative()
 {
 	LDateTime dt = CurrentStart();
 	if (dt.IsValid())
 	{
 		const char *s = RelativeTime(dt);
 		SetCtrlName(IDC_START_REL, s);
 	}
 }
 
 void CalendarUi::UpdateEndRelative()
 {
 	LDateTime dt = CurrentEnd();
 	if (dt.IsValid())
 	{
 		const char *s = RelativeTime(dt);
 		SetCtrlName(IDC_END_REL, s);
 	}
 }
 
 void CalendarUi::UpdateRelative()
 {
 	CheckConsistancy();
 	UpdateStartRelative();
 	UpdateEndRelative();
 }
 
 int CalendarUi::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (!NotifyOn)
 		return false;
 
 	switch (Ctrl->GetId())
 	{
 		case IDC_START_DATE:
 		case IDC_START_TIME:
 		{
 			CheckConsistancy();
 			UpdateStartRelative();
 			break;
 		}
 		case IDC_END_DATE:
 		case IDC_END_TIME:
 		{
 			CheckConsistancy();
 			UpdateEndRelative();
 			break;
 		}
 		case IDC_REMINDER_TYPE:
 		{
 			LViewI *Label, *Param;
 			if (GetViewById(IDC_PARAM_LABEL, Label) &&
 				GetViewById(IDC_REMINDER_PARAM, Param))
 			{
 				Param->Name(NULL);
 				switch (Ctrl->Value())
 				{
 					case CalEmail:
 						Label->Name("optional email:");
 						Param->Enabled(true);
 						break;
 					default:
 					case CalPopup:
 						Label->Name(NULL);
 						Param->Enabled(false);
 						break;
 					case CalScriptCallback:
 						Label->Name("callback fn:");
 						Param->Enabled(true);
 						break;
 				}
 			}
 			break;
 		}
 		case IDC_ALL_DAY:
 		{
 			int64 AllDay = Ctrl->Value();
 			LDataI *o = Item->GetObject();
 
 			char s[256] = "";
 			auto dt = o->GetDate(FIELD_CAL_START_UTC);
 			if (dt)
 			{
 				LDateTime tmp = *dt;
 				tmp.ToLocal(true);
 
 				tmp.GetTime(s, sizeof(s));
 				SetCtrlName(IDC_START_TIME, AllDay ? "" : s);
 				SetCtrlEnabled(IDC_START_TIME, !AllDay);
 			}
 
 			dt = o->GetDate(FIELD_CAL_END_UTC);
 			if (dt)
 			{
 				LDateTime tmp = *dt;
 				tmp.ToLocal(true);
 
 				tmp.GetTime(s, sizeof(s));
 				SetCtrlName(IDC_END_TIME, AllDay ? "" : s);
 				SetCtrlEnabled(IDC_END_TIME, !AllDay);
 			}
 			break;
 		}
 		case IDC_SUBJECT:
 		{
 			SetCtrlEnabled(IDC_SAVE, ValidStr(Ctrl->Name()));
 			break;
 		}
 		case IDC_SHOW_LOCATION:
 		{
 			LString Loc = GetCtrlName(IDC_LOCATION);
 			if (ValidStr(Loc))
 			{
 				for (char *c = Loc; *c; c++)
 				{
 					if (Strchr(WhiteSpace, *c))
 						*c = '+';
 				}
 			
 				LString Uri;
 				Uri.Printf("http://maps.google.com/?q=%s", Loc.Get());
 				LExecute(Uri);
 			}
 			break;
 		}
 		case IDC_GUESTS:
 		{
 			if (n.Type == LNotifyItemInsert)
 			{
 				d->Guests->ResizeColumnsToContent();
 			}
 			else if (n.Type == LNotifyDeleteKey)
 			{
 				List<ListAddr> la;
 				d->Guests->GetSelection(la);
 				la.DeleteObjects();
 			}
 			break;
 		}
 		case IDC_GUEST_ENTRY:
 		{
 			if (d->Entry)
 			{
 				if (ValidStr(d->Entry->Name()))
 				{
 					if (!d->Browse)
 					{
 						d->Browse = new AddressBrowse(Item->App, d->Entry, d->Guests, NULL);
 					}
 				}
 				if (d->Browse)
 				{
 					d->Browse->OnNotify(d->Entry, n);
 				}
 				if (n.Type == LNotifyReturnKey)
 				{
 					d->OnGuest();
 				}
 			}
 			break;
 		}
 		case IDC_REPEAT:
 		{
 			if (!Ctrl->Value())
 				break;
 
 			auto Dlg = new LRecurDlg(this);
 			Dlg->DoModal([this, Dlg](auto dlg, auto ctrlId)
 			{
 				if (ctrlId)
 					SetCtrlValue(IDC_REPEAT, 0);
 				delete dlg;
 			});
 			break;
 		}
 		case IDC_TIMEZONE:
 		{
 			auto Tz = Item->GetObject()->GetStr(FIELD_CAL_TIMEZONE);
 			auto Dlg = new LInput(this, Tz, "Time zone:", "Calendar Event Timezone");
 			Dlg->DoModal([this, Dlg](auto dlg, auto Result)
 			{
 				if (Result)
 				{
 					Item->GetObject()->SetStr(FIELD_CAL_TIMEZONE, Dlg->GetStr());
 					Item->SetDirty();
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDC_REMINDER_ADD:
 		{
 			const char *v = GetCtrlName(IDC_REMINDER_VALUE);
 			const char *param = GetCtrlName(IDC_REMINDER_PARAM);
 			d->Reminders->Insert
 			(
 				new ReminderItem
 				(
 					(CalendarReminderType) d->ReminderType->Value(),
 					v ? (float)atof(v) : 1.0f,
 					(CalendarReminderUnits) d->ReminderUnit->Value(),
 					param
 				)
 			);
 			d->Reminders->ResizeColumnsToContent();
 			break;
 		}
 		case IDC_ADD_GUEST:
 		{
 			d->OnGuest();
 			break;
 		}
 		case IDC_SAVE:
 		{
 			LViewI *v;
 			if (GetViewById(IDC_GUEST_ENTRY, v) &&
 				v->Focus())
 			{
 				d->OnGuest();
 				break;
 			}
 			else
 			{
 				OnSave();
 				// Fall through
 			}
 		}
 		case IDCANCEL:
 		{
 			Quit();
 			break;
 		}
 	}
 	
 	return 0;
 }
 
 void CalendarUi::OnLoad()
 {
 	// Sanity check
 	if (!Item) { LAssert(!"No item."); return; }
 	LDataI *o = Item->GetObject();
 	if (!o) { LAssert(!"No object."); return; }
 	
 	// Copy object values into UI
 	int64 AllDay = false;
 	auto CalSubject = o->GetStr(FIELD_CAL_SUBJECT);
 	SetCtrlName(IDC_SUBJECT, CalSubject);
 	SetCtrlName(IDC_LOCATION, o->GetStr(FIELD_CAL_LOCATION));
 	SetCtrlName(IDC_DESCRIPTION, o->GetStr(FIELD_CAL_NOTES));
 	SetCtrlValue(IDC_ALL_DAY, AllDay = o->GetInt(FIELD_CAL_ALL_DAY));
 
 	if (d->Guests)
 	{
 		LJson j(o->GetStr(FIELD_ATTENDEE_JSON));
 		for (auto g: j.GetArray(NULL))
 		{
 			LAutoPtr<ListAddr> la(new ListAddr(App));
 			if (la)
 			{
 				la->sAddr = g.Get("email");
 				la->sName = g.Get("name");
 				d->Guests->Insert(la.Release());
 			}
 		}
 		d->Guests->ResizeColumnsToContent();
 	}
 	
 	if (d->Reminders)
 	{
 		d->Reminders->Empty();
 		
 		LString Rem = o->GetStr(FIELD_CAL_REMINDERS);
 		LString::Array a = Rem.SplitDelimit("\n");
 		for (unsigned i=0; i<a.Length(); i++)
 		{
 			ReminderItem *ri = new ReminderItem(CalPopup, 0, CalMinutes, NULL);
 			if (ri)
 			{
 				if (ri->SetString(a[i]))
 					d->Reminders->Insert(ri);
 				else
 					delete ri;
 			}
 		}
 
 		d->Reminders->ResizeColumnsToContent();
 	}
 
 	CalendarShowTimeAs Show = (CalendarShowTimeAs)o->GetInt(FIELD_CAL_SHOW_TIME_AS);
 	switch (Show)
 	{
 		case CalFree:
 			SetCtrlValue(IDC_AVAILABLE_TYPE, 0);
 			break;
 		case CalTentative:
 			SetCtrlValue(IDC_AVAILABLE_TYPE, 1);
 			break;
 		default:
 		case CalBusy:
 			SetCtrlValue(IDC_AVAILABLE_TYPE, 2);
 			break;
 	}
 	CalendarPrivacyType Priv = (CalendarPrivacyType)o->GetInt(FIELD_CAL_PRIVACY);
 	switch (Priv)
 	{
 		default:
 			SetCtrlValue(IDC_PRIVACY_TYPE, 0);
 			break;
 		case CalPublic:
 			SetCtrlValue(IDC_PRIVACY_TYPE, 1);
 			break;
 		case CalPrivate:
 			SetCtrlValue(IDC_PRIVACY_TYPE, 2);
 			break;
 	}
 	int64 Col = o->GetInt(FIELD_COLOUR);
 	if (Col >= 0)
 		d->Colour->Value(Col);
 
 	for (unsigned i=0; i<CalendarSource::GetSources().Length(); i++)
 	{
 		CalendarSource *src = CalendarSource::GetSources().ItemAt(i);
 		LString s_path = src->GetName();
 		LString i_path;
 		if (Item->GetFolder())
 			i_path = Item->GetFolder()->GetPath();
 		
 		if (s_path &&
 			i_path &&
 			_stricmp(s_path, i_path) == 0)
 		{
 			SetCtrlValue(IDC_CALENDAR, i);
 			break;
 		}
 	}
 	
 	char s[256] = "";
 	auto dt = o->GetDate(FIELD_CAL_START_UTC);
 	if (dt)
 	{
 		#if DEBUG_DATES
 		printf("Load.Start.UTC=%s\n", dt->Get().Get());
 		#endif
 		LDateTime tmp = *dt;
 		tmp.SetTimeZone(0, false);
 		tmp.ToLocal(true);
 		#if DEBUG_DATES
 		printf("Load.Start.Local=%s\n", tmp.Get().Get());
 		#endif
 
 		tmp.GetDate(s, sizeof(s));
 		SetCtrlName(IDC_START_DATE, s);
 		
 		tmp.GetTime(s, sizeof(s));
 		SetCtrlName(IDC_START_TIME, AllDay ? "" : s);
 		SetCtrlEnabled(IDC_START_TIME, !AllDay);
 	}
 
 	dt = o->GetDate(FIELD_CAL_END_UTC);
 	if (dt)
 	{
 		#if DEBUG_DATES
 		printf("Load.End.UTC=%s\n", dt->Get().Get());
 		#endif
 		LDateTime tmp = *dt;
 		tmp.SetTimeZone(0, false);
 		tmp.ToLocal(true);
 		#if DEBUG_DATES
 		printf("Load.End.Local=%s\n", tmp.Get().Get());
 		#endif
 
 		tmp.GetDate(s, sizeof(s));
 		SetCtrlName(IDC_END_DATE, s);
 
 		tmp.GetTime(s, sizeof(s));
 		SetCtrlName(IDC_END_TIME, AllDay ? "" : s);
 		SetCtrlEnabled(IDC_END_TIME, !AllDay);
 	}
 
 	SetCtrlValue(IDC_REPEAT, o->GetInt(FIELD_CAL_RECUR));
 
 	LViewI *ctrl;
 	if (GetViewById(IDC_SUBJECT, ctrl))
 	{
 		LNotification note(LNotifyValueChanged);
 		OnNotify(ctrl, note);
 	}
 	
 	if (ValidStr(CalSubject))
 	{
 		LString s;
 		s.Printf("%s - %s", LLoadString(IDS_CAL_EVENT), CalSubject);
 		Name(s);
 	}
 
 	UpdateRelative();
 }
 
 void CalendarUi::OnSave()
 {
 	// Sanity check
 	if (!Item) { LAssert(!"No item."); return; }
 	LDataI *o = Item->GetObject();
 	if (!o) { LAssert(!"No object."); return; }
 	
 	// Save UI values into object
 	bool AllDay = false;
 	o->SetStr(FIELD_CAL_SUBJECT, GetCtrlName(IDC_SUBJECT));
 	o->SetStr(FIELD_CAL_LOCATION, GetCtrlName(IDC_LOCATION));
 	o->SetStr(FIELD_CAL_NOTES, GetCtrlName(IDC_DESCRIPTION));
 	o->SetInt(FIELD_CAL_ALL_DAY, AllDay = (GetCtrlValue(IDC_ALL_DAY) != 0));
 	
 	if (d->Guests)
 	{
 		List<ListAddr> All;
 		if (d->Guests->GetAll(All))
 		{
 			LString::Array a;
 			LString Sep(", ");
 			for (auto la: All)
 			{
 				LString e;
 				if (la->Serialize(e, true))
 					a.Add(e);
 			}
 			
 			LString Guests = Sep.Join(a);
 			o->SetStr(FIELD_TO, Guests);
 		}
 	}
 	
 	if (d->Reminders)
 	{
 		List<ReminderItem> All;
 		if (d->Reminders->GetAll(All))
 		{
 			LString::Array a;
 			LString Sep("\n");
 			for (auto ri: All)
 			{
 				a.Add(ri->GetString());
 			}
 			
 			LString Reminders = Sep.Join(a);
 			o->SetStr(FIELD_CAL_REMINDERS, Reminders);
 		}
 		else
 		{
 			o->SetStr(FIELD_CAL_REMINDERS, "");
 		}
 	}
 	
 	int64 Show = GetCtrlValue(IDC_AVAILABLE_TYPE);
 	switch (Show)
 	{
 		case 0:
 			o->SetInt(FIELD_CAL_SHOW_TIME_AS, CalFree);
 			break;
 		case 1:
 			o->SetInt(FIELD_CAL_SHOW_TIME_AS, CalTentative);
 			break;
 		default:
 		case 2:
 			o->SetInt(FIELD_CAL_SHOW_TIME_AS, CalBusy);
 			break;
 	}
 
 	int64 Priv = GetCtrlValue(IDC_PRIVACY_TYPE);
 	switch (Priv)
 	{
 		default:
 		case 0:
 			o->SetInt(FIELD_CAL_PRIVACY, CalDefaultPriv);
 			break;
 		case 1:
 			o->SetInt(FIELD_CAL_PRIVACY, CalPublic);
 			break;
 		case 2:
 			o->SetInt(FIELD_CAL_PRIVACY, CalPrivate);
 			break;
 	}
 
 	auto Col = d->Colour->Value();
 	o->SetInt(FIELD_COLOUR, Col > 0 ? Col : -1);
 
 	/* FIXME: change calendar item location if the user selects a different cal
 	for (unsigned i=0; i<d->Sources.Length(); i++)
 	{
 		CalendarSource *src = d->Sources[i];
 		LAutoString s_path(src->GetPath());
 		LAutoString i_path;
 		if (Item->GetFolder())
 			i_path = Item->GetFolder()->GetPath();
 		
 		if (s_path &&
 			i_path &&
 			_stricmp(s_path, i_path) == 0)
 		{
 			SetCtrlValue(IDC_CALENDAR, i);
 			break;
 		}
 	}
 	*/
 	
 	LDateTime dt;
 	dt.SetDate(GetCtrlName(IDC_START_DATE));
 	dt.SetTime(AllDay ? "0:0:0" : GetCtrlName(IDC_START_TIME));
 	#if DEBUG_DATES
 	printf("Start.Local=%s\n", dt.Get().Get());
 	#endif
 	dt.ToUtc(true);
 	#if DEBUG_DATES
 	printf("Start.UTC=%s\n", dt.Get().Get());
 	#endif
 	o->SetDate(FIELD_CAL_START_UTC, &dt);
 
 	dt.Empty();
 	dt.SetDate(GetCtrlName(IDC_END_DATE));
 	dt.SetTime(AllDay ? "11:59:59" : GetCtrlName(IDC_END_TIME));
 	#if DEBUG_DATES
 	printf("End.Local=%s\n", dt.Get().Get());
 	#endif
 	dt.ToUtc(true);
 	#if DEBUG_DATES
 	printf("End.UTC=%s\n", dt.Get().Get());
 	#endif
 	o->SetDate(FIELD_CAL_END_UTC, &dt);
 
 	o->SetInt(FIELD_CAL_RECUR, GetCtrlValue(IDC_REPEAT));
 
 	Item->Update();
 	Item->Save();
 }
 
 //////////////////////////////////////////////////////////////
 int LDateTimeViewBase = 1000;
 class LDateTimeView : public LLayout, public ResObject
 {
     LEdit *Edit;
     LDateDropDown *Date;
     LTimeDropDown *Time;
     
 public:
     LDateTimeView() : ResObject(Res_Custom)
     {
         AddView(Edit = new LEdit(10, 0, 0, 60, 20, NULL));
         AddView(Date = new LDateDropDown());
         AddView(Time = new LTimeDropDown());
 
         Edit->SetId(LDateTimeViewBase++);
 
         Date->SetNotify(Edit);
         Date->SetId(LDateTimeViewBase++);
 
         Time->SetNotify(Edit);
         Time->SetId(LDateTimeViewBase++);
     }
     
     bool OnLayout(LViewLayoutInfo &Inf)
     {
         if (!Inf.Width.Max)
         {
             Inf.Width.Max = 220;
             Inf.Width.Min = 150;
         }
         else if (!Inf.Height.Max)
         {
             Inf.Height.Max = Inf.Height.Min = LSysFont->GetHeight() + 6;
         }
         else return false;
         return true;
     }
     
     void OnCreate()
     {
         AttachChildren();
     }
     
     void OnPosChange()
     {
         LRect c = GetClient();
         // int cy = c.Y();
         // int py = Y();
         
         LRect tc = c;
         tc.x1 = tc.x2 - 20;
         LRect dc = c;
         dc.x2 = tc.x1 - 1;
         dc.x1 = dc.x2 - 20;
         Date->SetPos(dc);
         Time->SetPos(tc);
         c.x2 = dc.x1 - 1;
         Edit->SetPos(c);
     }
     
     const char *Name()
     {
 		return Edit->Name();
     }
     
     bool Name(const char *s)
     {
 		return Edit->Name(s);
     }
 };
 
 class LDateTimeViewFactory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 	    if (!_stricmp(Class, "LDateTimeView"))
 	        return new LDateTimeView;
 	    return NULL;
 	}
 
 public:
 } DateTimeViewFactory;
diff --git a/Code/Exp_Scribe.cpp b/Code/Exp_Scribe.cpp
--- a/Code/Exp_Scribe.cpp
+++ b/Code/Exp_Scribe.cpp
@@ -1,881 +1,905 @@
 
 #include "Scribe.h"
 
 #include "lgi/common/List.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/Store3.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 
 #include "ScribeFolderSelect.h"
 #include "../Resources/resdefs.h"
 #include "FolderTask.h"
 
 #define OnError(...) \
 { \
 	Errors.Add(in->Type(), Errors.Find(in->Type()) + 1); \
 	LgiTrace(__VA_ARGS__); \
 	break; \
 }
 #define OnSkip() \
 { \
 	Skipped.Add(in->Type(), Skipped.Find(in->Type()) + 1); \
 	break; \
 }
 #define OnCreate() \
 { \
 	Created.Add(in->Type(), Created.Find(in->Type()) + 1); \
 }
 
 struct ExportParams
 {
 	bool AllFolders = false;
 	bool ExceptTrashSpam = false;
 	LString DestFolders; // Mail3 path for dest folders;
 	LString DestPath; // Sub folder path for export
 	LString::Array SrcPaths;
 };
 
 struct Mail3Folders
 {
 	ScribeWnd *App = NULL;
 	LAutoPtr<LDataStoreI> Store;
 	LAutoPtr<ScribeFolder> Root;
 
 	Mail3Folders(ScribeWnd *app) : App(app)
 	{
 	}
 
 	Mail3Folders(Mail3Folders &src)
 	{
 		App = src.App;
 
 		if (src)
 		{
 			Store = src.Store;
 			Root = src.Root;
 		}
 		else LAssert(!"Src not loaded.");
 	}
 
 	operator bool()
 	{
 		return Store != NULL && Root != NULL;
 	}
 
 	void LoadFolders(const char *FilePath)
 	{
 		if (!Store)
 			Store.Reset(App->CreateDataStore(FilePath, true));
 
 		if (Store && !Root)
 		{
 			if (Root.Reset(new ScribeFolder))
 			{
 				Root->App = App;
 				Root->SetObject(Store->GetRoot(), false, _FL);
 			}
 		}
 	}
 
 	void Unload()
 	{
 		Root.Reset();
 		Store.Reset();
 	}
 
 	bool CheckDirty(ScribeFolder *f)
 	{
 		if (f->GetDirty())
 			return true;
 		for (auto c = f->GetChildFolder(); c; c = c->GetNextFolder())
 			if (CheckDirty(c))
 				return true;
 		return false;
 	}
 
 	bool IsDirty()
 	{
 		if (!Root)
 			return false;
 		return CheckDirty(Root);
 	}
 };
 
 struct ScribeExportTask : public FolderTask
 {
 	int FolderLoadErrors = 0;
 
 	LHashTbl<IntKey<int>,int> Created, Errors, Skipped;
 
 	LMailStore *SrcStore = NULL; // Source data store
 	Mail3Folders Dst;
 	ScribeFolder *Spam = NULL;
 	ScribeFolder *Trash = NULL;
 	ExportParams Params;
 
 	// Working state, used to iterate over the exporting process while
 	// being able to yield to the OS at regular intervals.
 	enum ExportState
 	{
 		ExpNone,
 		ExpGetNext,
 		ExpLoadFolders,
 		ExpItems,
 		ExpFinished,
 		ExpCleanup
 	}	State = ExpNone;
 
 	LString::Array InputPaths;
 	ScribeFolder *SrcFolder = NULL;
 	LArray<LDataI*> SrcItems;
 	ScribeFolder *DstFolder = NULL;
 	LDataFolderI *DstObj = NULL;
 	LDataStoreI *DstStore = NULL;
 	LHashTbl<ConstStrKey<char>,LDataI*> DstObjMap;
 
 	ScribeExportTask(struct ScribeExportDlg *dlg);
 
 	LString ContactKey(Contact *c);	
 	bool TimeSlice();
 	bool CopyAttachments(LDataI *outMail, LDataPropI *outSeg, LDataPropI *inSeg, LString &err);
 
 	LString MakePath(LString path)
 	{
 		LString sep = "/";
 		auto p = Params.DestPath.SplitDelimit(sep);
 		p += path.Strip(sep).SplitDelimit(sep).Slice(1);
 		return sep + sep.Join(p);
 	}
 
 	void CollectPaths(ScribeFolder *f, LString::Array &paths)
 	{
 		paths.Add(f->GetPath());
 		for (auto c = f->GetChildFolder(); c; c = c->GetNextFolder())
 			CollectPaths(c, paths);
 	}
 
 	ScribeFolder *GetFolder(LString Path, Store3ItemTypes CreateItemType = MAGIC_NONE)
 	{
 		if (!Dst.Root)
 		{
 			LAssert(!"No root loaded.");
 			return NULL;
 		}
 
 		Dst.Root->LoadFolders();
 
 		bool Create = false;
 		auto parts = Path.SplitDelimit("/");
 		ScribeFolder *f = Dst.Root;
 		for (auto p: parts)
 		{
 			auto c = f->GetSubFolder(p);
 			if (!c)
 			{
 				if (CreateItemType != MAGIC_NONE)
 				{
 					c = f->CreateSubDirectory(p, CreateItemType);
 					if (!c)
 					{
 						Errors.Add(MAGIC_FOLDER, Errors.Find(MAGIC_FOLDER)+1);
 						return NULL;
 					}
 
 					Create = true;
 				}
 				else return NULL;
 			}
 
 			f = c;
 		}
 
 		if (Create)
 			Created.Add(MAGIC_FOLDER, Created.Find(MAGIC_FOLDER)+1);
 		else
 			Skipped.Add(MAGIC_FOLDER, Skipped.Find(MAGIC_FOLDER)+1);
 
 		return f;
 	}
 
 	void OnComplete()
 	{
 		Store3ItemTypes types[] = { MAGIC_FOLDER, MAGIC_MAIL, MAGIC_CONTACT, MAGIC_CALENDAR, MAGIC_GROUP, MAGIC_FILTER };
 		LStringPipe html;
 
 		html.Print("<style> td{background:ThreeDFace; padding:3px;}</style>\n"
 					"<body style='background:ThreeDFace;'><div>Mail export complete.</div>\n"
 					"<br>\n"
 					"<table style='border-spacing: 1px; background:#aaa;'>\n"
 					"<tr><th>Type <th>Created <th>Errors <th>Skipped </tr>\n");
 		for (int i=0; i<CountOf(types); i++)
 		{
 			auto type    = types[i];
 			auto name    = LString(Store3ItemTypeName(type)).Replace("MAGIC_");
 			StrLwr(name.Get() + 1);
 			auto created = Created.Find(type);
 			auto errors  = Errors.Find(type);
 			auto skipped = Skipped.Find(type);
 			auto errStyle = errors ? " style='color:red'" : "";
 
 			html.Print("<tr><td>%s <td>%i <td%s>%i <td>%i </tr>\n",
 				name.Get(), created, errStyle, errors, skipped);
 		}
 
 		html.Print("</table>\n"
 					"<br>\n"
 					"<b>Created:</b> new item created in destination store.<br>\n"
 					"<b>Error:</b> there was an error replicating item.<br>\n"
 					"<b>Skipped:</b> the item already existed in the destination store.<br>\n"
 					);
 
 		LHtmlMsg(NULL, App, html.NewLStr(), "Export", MB_OK);
 	}
 
 	LString GetOrCreateMessageId(LDataI &obj)
 	{
 		auto msgId = obj.GetStr(FIELD_MESSAGE_ID);
 		if (msgId)
 			return msgId;
 
 		// Check the headers:
 		auto hdrs = obj.GetStr(FIELD_INTERNET_HEADER);
 		if (hdrs)
 		{
 			LAutoString Header(InetGetHeaderField(hdrs, "Message-ID"));
 			if (Header)
 			{
 				auto ids = ParseIdList(Header);
 				auto id = ids[0];
 				obj.SetStr(FIELD_MESSAGE_ID, id);
 				obj.Save();
 				return id;
 			}
 		}
 
 		// Msg has no ID and no header... create one.
 		auto from = obj.GetObj(FIELD_FROM);
 		if (!from)
 		{
 			LgiTrace("%s:%i - No from for email: %p\n", _FL, &obj);
 			return LString();
 		}
 
 		auto fromEmail = from->GetStr(FIELD_EMAIL);
 		LVariant Email;
 		const char *At = fromEmail ? strchr(fromEmail, '@') : NULL;
 		if (!At)
 		{
 			if (App->GetOptions()->GetValue(OPT_Email, Email) && Email.Str())
 				At = strchr(Email.Str(), '@');
 			else
 				At = "@domain.com";
 		}
 		if (!At)
 		{
 			LgiTrace("%s:%i - No at in email: %p\n", _FL, &obj);
 			return LString();
 		}
 
 		char m[96], a[32], b[32];
 		Base36(a, LCurrentTime());
 		Base36(b, LRand(RAND_MAX));
 		sprintf_s(m, sizeof(m), "<%s.%i%s%s>", a, LRand(RAND_MAX), b, At);
 		obj.SetStr(FIELD_MESSAGE_ID, m);
 		obj.Save();
 		return m;
 	}
 
 	LString ObjToId(LDataI &obj)
 	{
 		switch (obj.Type())
 		{
 			case MAGIC_MAIL:
 			{
 				return obj.GetStr(FIELD_MESSAGE_ID);
 			}
 			case MAGIC_CONTACT:
 			{
 				auto fn = obj.GetStr(FIELD_FIRST_NAME);
 				auto ln = obj.GetStr(FIELD_LAST_NAME);
 				auto em = obj.GetStr(FIELD_EMAIL);
 				LString s;
 				s.Printf("%s,%s,%s", fn, ln, em);
 				return s;
 			}
 			case MAGIC_CALENDAR:
 			{
 				auto sub = obj.GetStr(FIELD_CAL_SUBJECT);
 				auto start = obj.GetDate(FIELD_CAL_START_UTC);
 				LString s;
 				s.Printf("%s," LPrintfInt64, sub, start?start->Ts():0);
 				return s;
 				break;
 			}
 			case MAGIC_GROUP:
 			{
 				return obj.GetStr(FIELD_GROUP_NAME);
 			}
 			case MAGIC_FILTER:
 			{
 				return obj.GetStr(FIELD_FILTER_NAME);
 			}
 			default:
 			{
 				LAssert(!"Impl me.");
 				break;
 			}
 		}
 
 		return LString();
 	}
 
+	bool CheckModified(LDataI *in, LDataI *out)
+	{
+		if (!out)
+			// No existing object
+			return true;
+
+		auto inMod = in->GetDate(FIELD_DATE_MODIFIED);
+		auto outMod = in->GetDate(FIELD_DATE_MODIFIED);
+		if (!inMod ||
+			!outMod ||
+			!inMod->IsValid() ||
+			!outMod->IsValid())
+			return true; // Can't tell... no dates stored.
+	
+		bool mod = *inMod > *outMod;
+		if (mod)
+		{
+			int asd=0;
+		}
+
+		return mod;
+	}
+
 	void MakeDstObjMap()
 	{
 		DstObjMap.Empty();
 
 		if (!DstFolder || !DstObj)
 			return;
 
 		auto &c = DstObj->Children();
 		for (auto t = c.First(); t; t = c.Next())
 		{
 			auto Id = ObjToId(*t);
 			if (Id)
 				DstObjMap.Add(Id, t);
 		}
 	}
 };
 
 struct ScribeExportDlg : public LDialog, public LDataEventsI
 {
 	ScribeWnd *App = NULL;
 	LMailStore *SrcStore = NULL;
 	LList *Lst = NULL;
 	ExportParams Params;
 	Mail3Folders Dst;
 
 	ScribeExportDlg(ScribeWnd *app, LMailStore *srcStore) :
 		SrcStore(srcStore),
 		Dst(app)
 	{
 		SetParent(App = app);
 
 		if (!SrcStore)
 			SrcStore = App->GetDefaultMailStore();
 
 		if (LoadFromResource(IDD_SCRIBE_EXPORT))
 		{
 			MoveToCenter();
 			// EnableCtrls(false);
 			GetViewById(IDC_SRC_FOLDERS, Lst);
 
 			LVariant s;
 			if (Lst && App->GetOptions()->GetValue(OPT_ScribeExpSrcPaths, s) && s.Str())
 			{
 				Params.SrcPaths = LString(s.Str()).SplitDelimit(":");
 				for (auto p: Params.SrcPaths)
 					Lst->Insert(new LListItem(p));
 
 				Lst->ResizeColumnsToContent();
 			}
 
 			if (App->GetOptions()->GetValue(OPT_ScribeExpDstPath, s) &&
 				ValidStr(s.Str()))
 				SetCtrlName(IDC_FOLDER, s.Str());
 			else
 				SetCtrlName(IDC_FOLDER, "/");
 
 			LVariant n;
 			if (App->GetOptions()->GetValue(OPT_ScribeExpAll, n))
 				SetCtrlValue(IDC_ALL, n.CastInt32());
 
 			if (App->GetOptions()->GetValue(OPT_ScribeExpExclude, n))
 				SetCtrlValue(IDC_NO_SPAM_TRASH, n.CastInt32());
 			else
 				SetCtrlValue(IDC_NO_SPAM_TRASH, true);
 
 			if (App->GetOptions()->GetValue(OPT_ScribeExpFolders, s) && s.Str())
 				SetCtrlName(IDC_DEST, s.Str());
 
 			OnAll();
 		}
 	}
 
 	void OnNew(LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new)
 	{
 	}
 
 	bool OnDelete(LDataFolderI *parent, LArray<LDataI*> &items)
 	{
 		return true;
 	}
 	
 	bool OnMove(LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items)
 	{
 		return true;
 	}
 
 	bool OnChange(LArray<LDataI*> &items, int FieldHint)
 	{
 		return true;
 	}
 
 	void OnAll()
 	{
 		SetCtrlEnabled(IDC_SRC_FOLDERS, !GetCtrlValue(IDC_ALL));
 		SetCtrlEnabled(IDC_ADD_SRC_FOLDER, !GetCtrlValue(IDC_ALL));
 		SetCtrlEnabled(IDC_DEL_SRC_FOLDER, !GetCtrlValue(IDC_ALL));
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_ALL:
 			{
 				OnAll();
 				break;
 			}
 			case IDC_SET_DEST:
 			{
 				auto s = new LFileSelect(this);
 				s->Type("Scribe Folders", "*.mail3");
 				s->Type("All Files", LGI_ALL_FILES);
 				s->Open([this](auto dlg, auto status)
 				{
 					if (status)
 						SetCtrlName(IDC_DEST, dlg->Name());
 					delete dlg;
 				});
 				break;
 			}
 			case IDC_ADD_SRC_FOLDER:
 			{
 				if (!Lst)
 					break;
 
 				auto s = new FolderDlg(this, App);
 				s->DoModal([this, s](auto dlg, auto status)
 				{
 					if (status && ValidStr(s->Get()))
 					{
 						bool Has = false;
 
 						for (auto n: *Lst)
 						{
 							if (Stricmp(n->GetText(), s->Get()) == 0)
 							{
 								Has = true;
 								break;
 							}
 						}
 
 						if (!Has)
 						{
 							Lst->Insert(new LListItem(s->Get()));
 							Lst->ResizeColumnsToContent();
 						}
 					}
 
 					delete dlg;
 				});
 				break;
 			}
 			case IDC_DEL_SRC_FOLDER:
 			{
 				if (Lst)
 				{
 					List<LListItem> i;
 					if (Lst->GetSelection(i))
 					{
 						i.DeleteObjects();
 					}
 				}
 				break;
 			}
 			case IDC_SET_FOLDER:
 			{
 				if (!Dst)
 					Dst.LoadFolders(GetCtrlName(IDC_DEST));
 
 				if (Dst.Root)
 				{
 					auto s = new FolderDlg(this, App, MAGIC_NONE, Dst.Root);
 					s->DoModal([this, s](auto dlg, auto ctrlId)
 					{
 						if (ctrlId)
 							SetCtrlName(IDC_FOLDER, s->Get());
 						delete dlg;
 					});
 				}
 				else LgiMsg(this, "Couldn't load mail3 store.", AppName);
 				break;
 			}
 			case IDOK:
 			{
 				Params.AllFolders = GetCtrlValue(IDC_ALL) != 0;
 				Params.ExceptTrashSpam = GetCtrlValue(IDC_NO_SPAM_TRASH) != 0;
 				Params.DestPath = GetCtrlName(IDC_FOLDER);
 				Params.DestFolders = GetCtrlName(IDC_DEST);
 
 				if (Lst)
 				{
 					Params.SrcPaths.Empty();
 					Params.SrcPaths.SetFixedLength(false);
 					for (auto i: *Lst)
 						Params.SrcPaths.Add(i->GetText());
 				}
 
 				if (!Dst)
 					Dst.LoadFolders(Params.DestFolders);
 
 				// fall through
 			}
 			case IDCANCEL:
 			{
 				LVariant v;
 				if (Lst)
 				{
 					LStringPipe p;
 					int n=0;
 					for (auto i : *Lst)
 					{
 						p.Print("%s%s", n ? (char*)":" : (char*) "", i->GetText(0));
 					}
 					char *s = p.NewStr();
 					if (s)
 					{
 						App->GetOptions()->SetValue(OPT_ScribeExpSrcPaths, v = s);
 						DeleteArray(s);
 					}
 				}
 
 				App->GetOptions()->SetValue(OPT_ScribeExpDstPath, v = GetCtrlName(IDC_FOLDER));
 				App->GetOptions()->SetValue(OPT_ScribeExpAll,     v = (int)GetCtrlValue(IDC_ALL));
 				App->GetOptions()->SetValue(OPT_ScribeExpExclude, v = (int)GetCtrlValue(IDC_NO_SPAM_TRASH));
 				App->GetOptions()->SetValue(OPT_ScribeExpFolders, v = GetCtrlName(IDC_DEST));
 
 				EndModal(c->GetId() == IDOK);
 			}
 		}
 
 		return 0;
 	}
 };
 
 ScribeExportTask::ScribeExportTask(ScribeExportDlg *dlg) :
 	FolderTask(dlg->Dst.Root, LAutoPtr<LStreamI>(NULL), NULL, NULL),
 	Dst(dlg->Dst),
 	SrcStore(dlg->SrcStore)
 {
 	SetDescription("Initializing...");
 	SetType("Folders");
 
 	LAssert(SrcStore);
 
 	Params = dlg->Params;
 	if (Params.ExceptTrashSpam)
 	{
 		Spam = App->GetFolder("/Spam");
 		Trash = App->GetFolder(FOLDER_TRASH);
 	}
 
 	// Work out the folders we need to operate on:
 	if (Params.AllFolders)
 		CollectPaths(SrcStore->Root, InputPaths);
 	else
 		InputPaths = Params.SrcPaths;
 	SetRange(InputPaths.Length());
 
 	// Kick off the processing...
 	State = ExpGetNext;
 	SetPulse(PULSE_MS);
 	SetAlwaysOnTop(true);
 }
 
 LString ScribeExportTask::ContactKey(Contact *c)
 {
 	LString p;
 	const char *f = 0, *l = 0;
 	auto e = c->GetAddrAt(0);
 	c->Get(OPT_First, f);
 	c->Get(OPT_Last, l);
 	p.Printf("%s,%s,%s", e.Get(), f, l);
 	return p;
 }
 
 #define ExportFolderStatus(b) \
 	{ if (onStatus) onStatus(b); \
 	return; }
 
 bool ScribeExportTask::TimeSlice()
 {
 	if (IsCancelled())
 		return false;
 
 	switch (State)
 	{
 		case ExpGetNext:
 		{
 			if (InputPaths.Length() == 0)
 			{
 				State = ExpFinished;
 				break;
 			}
 
 			// Load up the next SrcFolder...
 			auto src = InputPaths[0];
 			InputPaths.DeleteAt(0, true);
 
 			auto dst = MakePath(src);
 			SrcFolder = App->GetFolder(src, SrcStore);
 			if (!SrcFolder)
 			{
 				FolderLoadErrors++;
 				return true;
 			}
 
 			DstStore = NULL;
 			DstFolder = GetFolder(dst, SrcFolder->GetItemType());
 			if (!DstFolder)
 			{
 				return true;
 			}
 
 			State = ExpLoadFolders;
 			SrcFolder->LoadThings(this, [this](auto status)
 			{
 				if (status == Store3Success)
 				{
 					// Load a list of things to process...
 					SrcItems.Empty();
 					auto SrcObj = dynamic_cast<LDataFolderI*>(SrcFolder->GetObject());
 					if (SrcObj)
 					{
 						auto &c = SrcObj->Children();
 						for (auto t = c.First(); t; t = c.Next())
 							SrcItems.Add(t);
 					}
 
 					DstFolder->LoadThings(this, [this](auto status)
 					{
 						if (status == Store3Success)
 						{
 							State = ExpItems;
 							SetDescription(SrcFolder->GetPath());
 
 							if (DstFolder->GetObject())
 								DstObj = dynamic_cast<LDataFolderI*>(DstFolder->GetObject());
 							else
 								LAssert(!"No object?");
 
 							if (DstObj)
 								DstStore = DstObj->GetStore();
 							else
 								LAssert(!"No object?");
 
 							MakeDstObjMap();
 						}
 						else
 							State = ExpGetNext;
 					});
 				}
 				else
 				{
 					State = ExpGetNext;
 				}					
 			});
 			break;
 		}
 		case ExpLoadFolders:
 		{
 			// No-op, but we should probably time out...
 			break;
 		}
 		case ExpItems:
 		{
 			if (!SrcFolder || !DstFolder || !DstStore)
 			{
 				State = ExpGetNext;
 				break;
 			}
 
 			auto Trans = DstStore->StartTransaction();
 
 			auto StartTs = LCurrentTime();
 			int Processed = 0;
 			while (	SrcItems.Length() > 0 &&
 					LCurrentTime() - StartTs < WORK_SLICE_MS)
 			{
 				auto in = SrcItems[0];
 				SrcItems.DeleteAt(0);
 
 				switch (in->Type())
 				{
 					case MAGIC_MAIL:
 					{
 						auto Id = GetOrCreateMessageId(*in);
 						if (!Id)
 							OnError("%s:%i - Email %p has no MsgId\n", _FL, in)
 
 						if (DstObjMap.Find(Id))
 							OnSkip()
 
 						// Create new mail...
 						auto outMail = DstStore->Create(MAGIC_MAIL);
 						outMail->CopyProps(*in);
 
 						// Now create all the attachments
 						auto inSeg = dynamic_cast<LDataI*>(in->GetObj(FIELD_MIME_SEG));
 						LDataI *outSeg = NULL;
 						if (inSeg)
 						{
 							outSeg = DstStore->Create(MAGIC_ATTACHMENT);
 							if (!outSeg)
 								OnError("%s:%i - Failed to create attachment\n", _FL)
 							else
 							{
 								outSeg->CopyProps(*inSeg);
 
 								auto outMime = outSeg->GetStr(FIELD_MIME_TYPE);
 								if (!outMime)
 								{
 									auto hdrs = outSeg->GetStr(FIELD_INTERNET_HEADER);
 									if (!hdrs)
 									{
 										// This is going to cause an assert later
 										outSeg->SetStr(FIELD_MIME_TYPE, sAppOctetStream);
 										// LgiTrace("%s:%i - Setting default mime on %p\n", _FL, outSeg);
 									}
 								}
 
 								if (outMail->SetObj(FIELD_MIME_SEG, outSeg) < Store3Delayed)
 									OnError("%s:%i - Failed to attach seg to mail.\n", _FL)
 								else
 								{
 									LString err;
 									if (!CopyAttachments(outMail, outSeg, inSeg, err))
 										OnError("%s:%i - CopyAttachments failed\n", _FL)
 									else
 										OnCreate()
 								}
 							}
 						}
 						else
 							OnCreate()
 
 						outMail->Save(DstFolder->GetObject());
 						break;
 					}
 					default:
 					{
 						// Is the object already in the dst map?
 						auto Id = ObjToId(*in);
-						if (DstObjMap.Find(Id))
+						auto existing = DstObjMap.Find(Id);
+						if (!CheckModified(in, existing))
 							OnSkip();
 
 						auto outObj = DstStore->Create(in->Type());
 						if (!outObj)
 						{
 							OnError("%s:%i - %s failed to create %s\n", _FL,
 								DstStore->GetStr(FIELD_STORE_TYPE),
 								Store3ItemTypeName((Store3ItemTypes)in->Type()))
 						}
 
 						if (!outObj->CopyProps(*in))
 							OnError("%s:%i - CopyProps failed.\n", _FL)
 
 						if (outObj->Save(DstFolder->GetObject()) < Store3Delayed)
 							OnError("%s:%i - Save failed\n", _FL)
 
 						OnCreate();
 						break;
 					}
 				}
 
 				Processed++;
 			}
 
 			if (SrcItems.Length() == 0)
 			{
 				SrcFolder = NULL;
 				DstFolder = NULL;
 				DstStore = NULL;
 				State = ExpGetNext;
 				(*this)++; // move progress...
 			}
 
 			// LgiTrace("Processed: %i\n", Processed);
 			break;
 		}
 		case ExpFinished:
 		{
 			OnComplete();
 			State = ExpCleanup;
 			return true;
 		}
 		case ExpCleanup:
 		{
 			if (Dst.IsDirty())
 				return true;
 
 			// We're done...
 			return false;
 		}
 	}
 
 	return true;
 }
 
 // This should copy all the child objects of 'inSeg' to new child objects of 'outSeg'
 bool ScribeExportTask::CopyAttachments(LDataI *outMail, LDataPropI *outSeg, LDataPropI *inSeg, LString &err)
 {
 	#define ERR(str) \
 		{ err = str; return false; }
 	if (!outMail || !outSeg || !inSeg)
 		ERR("param error");
 
 	auto children = inSeg->GetList(FIELD_MIME_SEG);
 	if (!children)
 		return true; // Nothing to copy...
 
 	for (auto i = children->First(); i; i = children->Next())
 	{
 		auto inMime = i->GetStr(FIELD_MIME_TYPE);
 		if (!inMime)
 			continue;
 
 		auto o = outMail->GetStore()->Create(MAGIC_ATTACHMENT);
 		if (!o)
 			ERR("couldn't create attachment");
 
 		if (!o->CopyProps(*i))
 			ERR("copy attachment properties failed");
 
 		auto outData = dynamic_cast<LDataI*>(outSeg);
 		if (!outData)
 			ERR("outSeg isn't a LDataI object");
 
 		if (!o->Save(outData))
 			ERR("failed to save attachment to output mail");
 
 		if (!CopyAttachments(outMail, o, i, err))
 			return false; // but leave the error message untouched.
 	}
 
 	return true;
 }
 
 void ExportScribe(ScribeWnd *App, LMailStore *Store)
 {
 	auto Dlg = new ScribeExportDlg(App, Store);
 	Dlg->DoModal([Dlg, App](auto dlg, auto ctrlId)
 	{
 		if (ctrlId && Dlg->Dst)
 		{
 			new ScribeExportTask(Dlg);
 		}
 		delete dlg;
 	});
 }
diff --git a/Code/ScribeContact.cpp b/Code/ScribeContact.cpp
--- a/Code/ScribeContact.cpp
+++ b/Code/ScribeContact.cpp
@@ -1,2395 +1,2398 @@
 /*
 **	FILE:		ScribeContact.cpp
 **	AUTHOR:		Matthew Allen
 **	DATE:		11/11/98
 **	DESCRIPTION:	Scribe contact object and UI
 **
 **	Copyright (C) 1998, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 
 #include "Scribe.h"
 #include "ScribePageSetup.h"
 #include "lgi/common/Map.h"
 #include "lgi/common/vCard-vCal.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/GdcTools.h"
 #include "lgi/common/DropFiles.h"
 #include "lgi/common/Http.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/List.h"
 #include "lgi/common/Json.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/FileSelect.h"
 #include "PrintContext.h"
 #include "resdefs.h"
 #include "resource.h"
 
 bool ConvertImageToContactSize(LAutoPtr<LSurface> &Img, int Px, LSurface *Raw)
 {
 	if (!Raw)
 	{
 		LAssert(!"No raw image?");
 		return false;
 	}
 		
 	if (!Img.Reset(new LMemDC(Px, Px, Raw->GetColourSpace())))
 	{
 		LAssert(!"Failed to create image?");
 		return false;
 	}
 
 	LRect Src;
 	if (Raw->X() > Raw->Y())
 	{
 		// Wider than high
 		Src.ZOff(Raw->Y()-1, Raw->Y()-1);
 		Src.Offset((Raw->X()-Raw->Y())>>1, 0);
 	}
 	else if (Raw->X() < Raw->Y())
 	{
 		Src.ZOff(Raw->X()-1, Raw->X()-1);
 		Src.Offset(0, (Raw->Y()-Raw->X())>>1);
 	}
 	else
 	{
 		Src = Raw->Bounds();
 	}
 	
 	ResampleDC(Img, Raw, &Src);
 
 	return true;
 }
 
 
 class ContactPriv
 {
 public:
 	Contact *Item;
 	char *Scratch;
 	List<char> Plugins;
 	LAutoPtr<LSurface> Image;
 	LString ImagePath;
 	LString DateCache;
 	LAutoPtr<LJson> CustomCache;
 
 	ContactPriv(Contact *c) : Item(c)
 	{
 		Scratch = 0;
 	}
 
 	~ContactPriv()
 	{
 		DeleteArray(Scratch);
 		Plugins.DeleteArrays();
 	}
 
 	LJson *GetJson()
 	{
 		auto Obj = Item->GetObject();
 		if (!Obj)
 			return NULL;
 
 		if (!CustomCache)
 		{
 			auto json = Obj->GetStr(FIELD_CONTACT_JSON);
 			CustomCache.Reset(new LJson(json));
 		}
 
 		return CustomCache;
 	}
 };
 
 ItemFieldDef ContactFieldDefs[] = {
 
 	// Standard fields
 	{"Title", SdTitle,					GV_STRING, FIELD_TITLE,				IDC_TITLE,			OPT_Title},
 	{"First", SdFirst,					GV_STRING, FIELD_FIRST_NAME,		IDC_FIRST,			OPT_First},
 	{"Last", SdSurname,					GV_STRING, FIELD_LAST_NAME,			IDC_LAST,			OPT_Last},
 	{"Email", SdEmail,					GV_STRING, FIELD_EMAIL,				IDC_EMAIL,			OPT_Email},
 	{"Nickname", SdNickname,			GV_STRING, FIELD_NICK,				IDC_NICK,			OPT_Nick},
 	{"Spouse", SdSpouse,				GV_STRING, FIELD_SPOUSE,			IDC_SPOUSE,			OPT_Spouse},
 	{"Notes", SdNotes,					GV_STRING, FIELD_NOTE,				IDC_NOTE,			OPT_Note},
 	{"Uid", SdUid,						GV_INT32,  FIELD_UID,				-1,					OPT_Uid},
 	{"TimeZone", SdTimeZone,			GV_STRING, FIELD_TIMEZONE,			IDC_TIMEZONE,		OPT_TimeZone},
 
 	// Home fields
 	{"Home Street", SdHomeStreet,		GV_STRING, FIELD_HOME_STREET,		IDC_HOME_STREET,	OPT_HomeStreet},
 	{"Home Suburb", SdHomeSuburb,		GV_STRING, FIELD_HOME_SUBURB,		IDC_HOME_SUBURB,	OPT_HomeSuburb},
 	{"Home Postcode", SdHomePostcode,	GV_STRING, FIELD_HOME_POSTCODE,		IDC_HOME_POSTCODE,	OPT_HomePostcode},
 	{"Home State", SdHomeState,			GV_STRING, FIELD_HOME_STATE,		IDC_HOME_STATE,		OPT_HomeState},
 	{"Home Country", SdHomeCountry,		GV_STRING, FIELD_HOME_COUNTRY,		IDC_HOME_COUNTRY,	OPT_HomeCountry},
 	{"Home Phone", SdHomePhone,			GV_STRING, FIELD_HOME_PHONE,		IDC_HOME_PHONE,		OPT_HomePhone},
 	{"Home Mobile", SdHomeMobile,		GV_STRING, FIELD_HOME_MOBILE,		IDC_HOME_MOBILE,	OPT_HomeMobile},
 	{"Home IM#", SdHomeIM,				GV_STRING, FIELD_HOME_IM,			IDC_HOME_IM,		OPT_HomeIM},
 	{"Home Fax", SdHomeFax,				GV_STRING, FIELD_HOME_FAX,			IDC_HOME_FAX,		OPT_HomeFax},
 	{"Home Webpage", SdHomeWebpage,		GV_STRING, FIELD_HOME_WEBPAGE,		IDC_HOME_WEBPAGE,	OPT_HomeWebPage},
 
 	// Work fields
 	{"Work Street", SdWorkStreet,		GV_STRING, FIELD_WORK_STREET,		IDC_WORK_STREET,	OPT_WorkStreet},
 	{"Work Suburb", SdWorkSuburb,		GV_STRING, FIELD_WORK_SUBURB,		IDC_WORK_SUBURB,	OPT_WorkSuburb},
 	{"Work Postcode", SdWorkPostcode,	GV_STRING, FIELD_WORK_POSTCODE,		IDC_WORK_POSTCODE,	OPT_WorkPostcode},
 	{"Work State", SdWorkState,			GV_STRING, FIELD_WORK_STATE,		IDC_WORK_STATE,		OPT_WorkState},
 	{"Work Country", SdWorkCountry,		GV_STRING, FIELD_WORK_COUNTRY,		IDC_WORK_COUNTRY,	OPT_WorkCountry},
 	{"Work Phone", SdWorkPhone,			GV_STRING, FIELD_WORK_PHONE,		IDC_WORK_PHONE,		OPT_WorkPhone},
 	{"Work Mobile", SdWorkMobile,		GV_STRING, FIELD_WORK_MOBILE,		IDC_WORK_MOBILE,	OPT_WorkMobile},
 	{"Work IM#", SdWorkIM,				GV_STRING, FIELD_WORK_IM,			IDC_WORK_IM,		OPT_WorkIM},
 	{"Work Fax", SdWorkFax,				GV_STRING, FIELD_WORK_FAX,			IDC_WORK_FAX,		OPT_WorkFax},
 	{"Company", SdCompany,				GV_STRING, FIELD_COMPANY,			IDC_COMPANY,		OPT_Company},
 	{"Work Webpage", SdWorkWebpage,		GV_STRING, FIELD_WORK_WEBPAGE,		IDC_WORK_WEBPAGE,	OPT_WorkWebPage},
 
 	{"CustomFields", SdCustomFields,	GV_STRING, FIELD_CONTACT_JSON,		IDC_CUSTOM_FIELDS,	OPT_CustomFields},
 	{"DateModified", SdDateModified,	GV_DATETIME, FIELD_DATE_MODIFIED,	-1,					NULL},
 	{0}
 };
 
 #define ForAllContactFields(var) ItemFieldDef *var = 0; for (var = ContactFieldDefs; var->Option && var->FieldId; var++)
 
 #define MacroAllFields(Macro)							\
 	Macro(FIELD_TITLE, OPT_Title);						\
 	Macro(FIELD_FIRST_NAME, OPT_First);					\
 	Macro(FIELD_LAST_NAME, OPT_Last);					\
 	Macro(FIELD_EMAIL, OPT_Email);						\
 	Macro(FIELD_NICK, OPT_Nick);						\
 	Macro(FIELD_SPOUSE, OPT_Spouse);					\
 	Macro(FIELD_NOTE, OPT_Note);						\
 	Macro(FIELD_TIMEZONE, OPT_TimeZone);				\
 	Macro(FIELD_HOME_STREET, OPT_HomeStreet);			\
 	Macro(FIELD_HOME_SUBURB, OPT_HomeSuburb);			\
 	Macro(FIELD_HOME_POSTCODE, OPT_HomePostcode);		\
 	Macro(FIELD_HOME_STATE, OPT_HomeState);				\
 	Macro(FIELD_HOME_COUNTRY, OPT_HomeCountry);			\
 	Macro(FIELD_HOME_PHONE, OPT_HomePhone);				\
 	Macro(FIELD_HOME_MOBILE, OPT_HomeMobile);			\
 	Macro(FIELD_HOME_IM, OPT_HomeIM);					\
 	Macro(FIELD_HOME_FAX, OPT_HomeFax);					\
 	Macro(FIELD_HOME_WEBPAGE, OPT_HomeWebPage);			\
 	Macro(FIELD_WORK_STREET, OPT_WorkStreet);			\
 	Macro(FIELD_WORK_SUBURB, OPT_WorkSuburb);			\
 	Macro(FIELD_WORK_POSTCODE, OPT_WorkPostcode);		\
 	Macro(FIELD_WORK_STATE, OPT_WorkState);				\
 	Macro(FIELD_WORK_COUNTRY, OPT_WorkCountry);			\
 	Macro(FIELD_WORK_PHONE, OPT_WorkPhone);				\
 	Macro(FIELD_WORK_MOBILE, OPT_WorkMobile);			\
 	Macro(FIELD_WORK_IM, OPT_WorkIM);					\
 	Macro(FIELD_WORK_FAX, OPT_WorkFax);					\
 	Macro(FIELD_WORK_WEBPAGE, OPT_WorkWebPage);			\
 	Macro(FIELD_COMPANY, OPT_Company);					\
 	Macro(FIELD_CONTACT_JSON, OPT_CustomFields);
 
 
 //////////////////////////////////////////////////////////////////////////////
 const char *WinFmtUrl = "UniformResourceLocatorW";
 const char *FmtUrlList = "text/uri-list";
 #include "lgi/common/SkinEngine.h"
 
 class LContactBtn : public LView
 {
 	bool Down;
 	bool Over;
 
 public:
 	LContactBtn(int id)
 	{
 		SetId(id);
 		Over = false;
 		Down = false;
 
 		LRect r(0, 0, 23, 23);
 		SetPos(r);
 	}
 	
 	~LContactBtn()
 	{
 	}
 	
 	void OnMouseClick(LMouse &m)
 	{
 		Capture(Down = m.Down());
 		Invalidate();
 		if (m.Down())
 			Over = true;
 		else if (Over)
 			SendNotify();
 	}
 	
 	void OnMouseMove(LMouse &m)
 	{
 		if (IsCapturing())
 		{
 			bool o = GetClient().Overlap(m.x, m.y);
 			if (o ^ Over)
 			{
 				Down = Over = o;
 				Invalidate();
 			}
 		}
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		LRect c = GetClient();
 		if (LApp::SkinEngine &&
 			c.X() &&
 			c.Y())
 		{
 			LCssTools Tools(this);
 			LColour Base = Tools.GetBack();
 			LMemDC Mem(c.X(), c.Y(), System32BitColourSpace);
 			Mem.Colour(0, 32);
 			Mem.Rectangle();
 			LRect r(0, 0, X()-1, Y()-1);
 			LApp::SkinEngine->DrawBtn(&Mem, r, Base, Down, true);
 
 			int Dot = 2;
 			int Gap = 3;
 			int Sz = (Dot * 3) + (Gap * 2);
 			int x = ((X()-Sz) >> 1) + Down;
 			int y = (Y() / 2) + Down;
 			Mem.Colour(L_TEXT);
 			for (int i=0; i<3; i++)
 			{
 				Mem.Rectangle(x, y, x + 1, y + 1);
 				x += Dot + Gap;
 			}
 			
 			pDC->Op(GDC_ALPHA);
 			pDC->Blt(0, 0, &Mem);
 		}
 	}
 };
 
 class LContactImage :
 	public LView,
 	public ResObject,
 	public LDragDropTarget
 {
 	friend class ContactUi;
 	constexpr static int M_IMAGE_LOADED = M_USER + 100;
 
 	ScribeWnd *App = NULL;
 	Contact *c = NULL;
 	LContactBtn *Btn = NULL;
 	bool IsNoFace = false;
 
 	// This is the uncompressed bitmap which is not saved.
 	LAutoPtr<LSurface> Img;
 
 	// This is a compressed version that is saved.
 	LVariant CompressedImg;
 	
 	class UriLoader : public LThread, public LCancel
 	{
 		LContactImage *Ci;
 		LString Uri;
 	
 	public:
 		bool Status;
 		LMemStream Data;
 		LString Error;
 	
 		UriLoader(LContactImage *ci, LString uri) :
 			LThread("LContactImage"),
 			Data(1024)
 		{
 			Ci = ci;
 			Uri = uri;
 			Status = false;
 			Run();
 		}
 		
 		~UriLoader()
 		{
 			while (!IsExited())
 				LSleep(1);
 		}
 		
 		int Main()
 		{
 			Status = LgiGetUri(this, &Data, &Error, Uri, NULL, NULL);
 			Ci->PostEvent(M_IMAGE_LOADED);
 			return 0;
 		}
 	};
 	LAutoPtr<UriLoader> Worker;
 	
 public:
 	LContactImage() : ResObject(Res_Custom)
 	{
 		SetTabStop(true);
 	}
 	
 	LVariant &GetImage()
 	{
 		if (!IsNoFace && CompressedImg.Type != GV_BINARY)
 		{
 			LMemStream m(4 << 10);
 			if (GdcD->Save(&m, Img, "icon.jpg"))
 			{
 				CompressedImg.Type = GV_BINARY;
 				auto &Bin = CompressedImg.Value.Binary;
 				Bin.Length = (ssize_t) m.GetSize();
 				Bin.Data = new char[Bin.Length];
 				m.SetPos(0);
 				m.Read(Bin.Data, Bin.Length);
 			}
 		}
 
 		return CompressedImg;
 	}
 
 	bool OnKey(LKey &k)
 	{
 		switch (k.vkey)
 		{
 			case 'v':
 			case 'V':
 			{
 				if (k.Ctrl())
 				{
 					if (k.Down())
 					{
 						CompressedImg.Empty();
 
 						LClipBoard c(this);
 						IsNoFace = false;
 
 						c.Bitmap([this](auto bmp, auto str)
 						{
 							SetImage(bmp);
 						});
 					}
 					return true;
 				}
 				break;
 			}
 			case LK_DELETE:
 			{
 				// Delete the image...
 				CompressedImg.Empty();
 				SetDefaultNoFace();
 				break;
 			}
 		}
 
 		return false;
 	}
 
 	void OnMouseClick(LMouse &m)
 	{
 		if (m.Down())
 			Focus(true);
 	}
 	
 	void SetImage(LAutoPtr<LSurface> Raw)
 	{
 		if (Raw && (Raw->X() > 160 || Raw->Y() > 160))
 			ConvertImageToContactSize(Img, 160, Raw);
 		else
 			Img = Raw;
 
 		Invalidate();
 	}
 	
 	void OnCreate()
 	{
 		SetWindow(this);
 	}
 	
 	bool OnLayout(LViewLayoutInfo &Inf)
 	{
 		if (!Inf.Width.Min)
 			Inf.Width.Min = Inf.Width.Max = 160;
 		else
 			Inf.Height.Min = Inf.Height.Max = 160;
 		
 		return true;
 	}
 	
 	void OnPaint(LSurface *pDC)
 	{
 		LRegion rgn(GetClient());
 		if (Img)
 		{
 			pDC->Blt(0, 0, Img);
 			LRect Bnds = Img->Bounds();
 			rgn.Subtract(&Bnds);
 		}
 		for (int i=0; i<rgn.Length(); i++)
 		{
 			pDC->Colour(L_LOW);
 			pDC->Rectangle(rgn[i]);
 		}
 		
 		if (Btn)
 		{
 			LRect c = GetClient();
 			c.Inset(6, 6);
 			LRect p = Btn->GetPos();
 			p.Offset(c.x2 - p.X() - p.x1 + 1,
 					 c.y1 - p.y1);
 			Btn->SetPos(p);
 		}
 
 		if (Focus())
 		{
 			auto c = GetClient();
 			PatternBox(pDC, LRect(c.x1, c.y1, c.x1+1, c.y2));
 			PatternBox(pDC, LRect(c.x2-1, c.y1, c.x2, c.y2));
 			PatternBox(pDC, LRect(c.x1+2, c.y1, c.x2-2, c.y1+1));
 			PatternBox(pDC, LRect(c.x1+2, c.y2-1, c.x2-2, c.y2));
 		}
 	}
 
 	void SetDefaultNoFace()
 	{
 		if (App)
 		{
 			LVariant NoFace;
 			if (App->GetValue("NoContact.Image[160]", NoFace))
 			{
 				if (NoFace.Str())
 				{
 					IsNoFace = Img.Reset(GdcD->Load(NoFace.Str()));
 					Invalidate();
 				}
 			}
 		}
 	}
 
 	void SetContact(Contact *contact)
 	{
 		c = contact;
 		if (c)
 		{
 			App = c->App;
 			SetDefaultNoFace();
 			
 			if (!Btn)
 			{
 				Btn = new LContactBtn(100);
 			}
 			if (Btn)
 			{
 				#if 0
 				Btn->GetCss(true)->NoPaintColor(LCss::ColorDef(LCss::ColorRgb, Rgb32(0xcb,0xcb,0xcb)));
 				#else
 				Btn->GetCss(true)->NoPaintColor(LCss::ColorDef(LCss::ColorTransparent));
 				#endif
 				
 				AddView(Btn);
 			}
 		}
 	}
 	
 	bool SetImage(const LVariant &v, const char *FileHint = NULL)
 	{
 		if (v.Type != GV_BINARY)
 			return false;
 
 		CompressedImg = v;
 		LMemStream mem(	CompressedImg.Value.Binary.Data,
 						CompressedImg.Value.Binary.Length,
 						false);
 		LAutoPtr<LSurface> i(GdcD->Load(&mem, FileHint));
 		if (!i)
 		{
 			CompressedImg.Empty();
 			return false;
 		}
 
 		SetImage(i);
 		IsNoFace = false;
 		return true;
 	}
 	
 	bool Load(const char *File)
 	{
 		LFile f;
 		if (!f.Open(File, O_READ))
 		{
 			LgiMsg(this, "Couldn't open image file.", AppName, MB_OK);
 			return false;
 		}
 
 		int Sz = (int)f.GetSize();
 		LAutoPtr<uint8_t> p(new uint8_t[Sz]);
 		if (!p)
 		{
 			LgiMsg(this, "Couldn't alloc mem for image.", AppName, MB_OK);
 			return false;
 		}
 
 		ssize_t rd = f.Read(p, Sz);
 		if (rd <= 0)
 		{
 			LgiMsg(this, "Couldn't read from image file.", AppName, MB_OK);
 			return false;
 		}
 
 		LVariant v;
 		v.SetBinary(rd, p.Release(), true);
 		if (!SetImage(v, File))
 		{
 			LgiMsg(this, "Couldn't decompress image.", AppName, MB_OK);
 			return false;
 		}
 
 		IsNoFace = false;
 		return true;
 	}
 
 	LMessage::Param OnEvent(LMessage *Msg)
 	{
 		if (Msg->Msg() == M_IMAGE_LOADED)
 		{
 			if (Worker &&
 				Worker->Status)
 			{
 				LAutoPtr<LSurface> pDC(GdcD->Load(&Worker->Data, NULL));
 				if (pDC)
 				{
 					IsNoFace = false;
 					SetImage(pDC);
 				}
 			}
 			Worker.Reset();
 			return 0;
 		}
 		return LView::OnEvent(Msg);
 	}
 	
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (Ctrl->GetId() == 100)
 		{
 			auto s = new LFileSelect(this);
 			s->Open([this](auto dlg, auto status)
 			{
 				if (status)
 					Load(dlg->Name());
 				delete dlg;
 			});
 		}
 		
 		return 0;
 	}
 
 	int WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 	{
 		if (Formats.HasFormat(LGI_FileDropFormat))
 			Formats.SupportsFileDrops();
 		else
 		{
 			#if WINDOWS
 			Formats.Supports(WinFmtUrl);
 			#endif
 			Formats.Supports(FmtUrlList);
 		}
 
 		return Formats.GetSupported().Length() ? DROPEFFECT_COPY : DROPEFFECT_NONE;
 	}
 	
 	int OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 	{
 		for (unsigned i=0; i<Data.Length(); i++)
 		{
 			LDragData &dd = Data[i];
 			if (dd.IsFileDrop())
 			{
 				LDropFiles files(dd);
 				if (files.Length() > 0)
 				{
 					Load(files[0]);
 					return DROPEFFECT_COPY;
 				}
 			}
 			else if (dd.IsFormat(FmtUrlList) ||
 					 dd.IsFormat(WinFmtUrl))
 			{
 				auto &v = dd.Data[0];
 				if (v.Type == GV_BINARY)
 				{
 					LString uri = (char16*)v.Value.Binary.Data;
 					if (uri)
 						Worker.Reset(new UriLoader(this, uri));
 				}
 				else if (v.Type == GV_STRING)
 				{
 					Worker.Reset(new UriLoader(this, v.Str()));
 				}
 				else LAssert(!"Unexpected type.");
 			}
 		}
 		return DROPEFFECT_NONE;
 	}
 };
 
 class LContactImageFactory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (Class && !_stricmp(Class, "LContactImage"))
 			return new LContactImage;
 		return NULL;
 	}
 }	ContactImageFactory;
 
 //////////////////////////////////////////////////////////////////////////////
 class LFieldItem : public LListItem
 {
 public:
 	LString Field, Value;
 
 	const char *GetText(int i)
 	{
 		switch (i)
 		{
 			case 0: return Field;
 			case 1: return Value;
 		}
 		return NULL;
 	}
 
 	bool SetText(const char *s, int i=0)
 	{
 		switch (i)
 		{
 			case 0: Field = s; break;
 			case 1: Value = s; break;
 			default: return false;
 		}
 		LListItem::SetText(s, i);
 		auto Lst = GetList();
 		Lst->ResizeColumnsToContent();
 		Lst->OnNotify(Lst, LNotifyItemChange);
 		return true;
 	}
 
 	void OnMouseClick(LMouse &m)
 	{
 		if (m.Down() && m.Double())
 		{
 			int Col = GetList()->ColumnAtX(m.x);
 			if (Col >= 0 && Col <= 1)
 				EditLabel(Col);
 		}
 	}
 };
 
 class LFieldEditor : public LList
 {
 	LString u;
 	LAutoWString w;
 
 public:
 	LFieldEditor() : LList(IDC_STATIC)
 	{
 		SetObjectName(Res_Custom);
 		DrawGridLines(true);
 		AllowEditLabels(true);
 		SetNotify(this);
 		AddColumn("Field", 110);
 		AddColumn("Value", 110);
 		OnChange();
 	}
 
 	void OnChange()
 	{
 		LArray<LFieldItem*> a;
 		GetAll(a);
 		for (auto i: a)
 			if (!i->Field && !i->Value)
 				return;
 		Insert(new LFieldItem);
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (Ctrl->GetId() == GetId())
 		{
 			switch (Flags)
 			{
 				case LNotifyItemChange:
 				{
 					OnChange();
 					break;
 				}
 				case LNotifyDeleteKey:
 				{
 					LArray<LListItem*> a;
 					GetSelection(a);
 					a.DeleteObjects();
 					OnChange();
 					break;
 				}
 			}
 		}
 
 		return LList::OnNotify(Ctrl, n);
 	}
 
 	bool NameW(const char16 *n)
 	{
 		LAutoString a(WideToUtf8(n));
 		return Name(a);
 	}
 
 	const char16 *NameW()
 	{
 		w.Reset(Utf8ToWide(Name()));
 		return w;
 	}
 
 	bool Name(const char *n)
 	{
 		Empty();
 
 		LJson j(n);
 		LArray<LString> keys = j.GetKeys();
 		for (auto k: keys)
 		{
 			LFieldItem *i = new LFieldItem;
 			i->Field = k;
 			i->Value = j.Get(k);
 			Insert(i);
 		}
 
 		OnChange();
 		// LgiTrace("SetText: %s\n", n);
 		return true;
 	}
 
 	const char *Name()
 	{
 		LJson j;
 		LArray<LFieldItem*> items;
 		GetAll(items);
 		for (auto i: items)
 		{
 			if (i->Field)
 				j.Set(i->Field, i->Value);
 		}
 		u = j.GetJson();
 		// LgiTrace("GetText: %s\n", u.Get());
 		return u;
 	}
 };
 
 class LFieldEditorFactory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (Class && !_stricmp(Class, "LFieldEditor"))
 			return new LFieldEditor;
 		return NULL;
 	}
 }	FieldEditorFactory;
 
 //////////////////////////////////////////////////////////////////////////////
 List<Contact> Contact::Everyone;
 LHashTbl<ConstStrKey<char,false>, int> Contact::PropMap;
 
 Contact::Contact(ScribeWnd *app, LDataI *object) : Thing(app, object)
 {
 	if (!PropMap.Length())
 	{
 		PropMap.Add("Type", FIELD_TYPE);
 		ForAllContactFields(Fld)
 		{
 			LAssert(Fld->FieldId > 0 && Fld->FieldId < FIELD_MAX);
 			// LgiTrace("AddProp %i, %s\n", Fld->FieldId, Fld->Option);
 			PropMap.Add(Fld->Option, Fld->FieldId);
 		}
 	}
 
 	DefaultObject(object);
 	d = new ContactPriv(this);
 	Everyone.Insert(this);
 }
 
 Contact::~Contact()
 {
 	Everyone.Delete(this);
 	DeleteObj(Ui);
 	DeleteObj(d);
 }
 
 Contact *Contact::LookupEmail(const char *Email)
 {
 	if (!Email)
 		return NULL;
 
 	for (auto c : Everyone)
 		if (c->HasEmail(Email))
 			return c;
 	
 	return NULL;
 }
 
 bool Contact::Get(const char *Opt, int &Value)
 {
 	if (GetObject())
 	{
 		int Id = PropMap.Find(Opt);
 		if (Id)
 		{
 			int i = (int)GetObject()->GetInt(Id);
 			if (i >= 0)
 			{
 				Value = i;
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 bool Contact::Get(const char *Opt, const char *&Value)
 {
 	if (GetObject())
 	{
 		int Id = PropMap.Find(Opt);
 		if (Id)
 		{
 			Value = GetObject()->GetStr(Id);
 			return Value != 0;
 		}
 	}
 
 	return false;
 }
 
 bool Contact::Set(const char *Opt, int Value)
 {
 	if (GetObject())
 	{
 		int Id = PropMap.Find(Opt);
 		if (Id)
 		{
 			return GetObject()->SetInt(Id, Value) > Store3Error;
 		}
 	}
 
 	return false;
 }
 
 bool Contact::Set(const char *Opt, const char *Value)
 {
 	auto o = GetObject();
 	if (!o)
 		return false;
 
 	auto Id = PropMap.Find(Opt);
 	if (Id <= 0 || Id >= FIELD_MAX)
 	{
 		LAssert(!"Invalid ID.");
 		return false;
 	}
 
 	return o->SetStr(Id, Value) > Store3Error;
 }
 
 int Contact::GetAddrCount()
 {
 	if (!GetObject())
 		return 0;
 
 	auto DefEmail = GetObject()->GetStr(FIELD_EMAIL);
 	auto AltEmail = GetObject()->GetStr(FIELD_ALT_EMAIL);
 	int c = ValidStr(DefEmail) ? 1 : 0;
 	if (AltEmail)
 	{
 		c++;
 		for (auto s = AltEmail; s && *s; s++)
 		{
 			if (*s == ',') c++;
 		}
 	}
 	return c;
 }
 
 LString::Array Contact::GetEmails()
 {
 	LString::Array e;
 	const char *s;
 	if (Get(OPT_Email, s) && s)
 		e.New() = s;
 	if (GetObject())
 	{
 		auto alt = LString(GetObject()->GetStr(FIELD_ALT_EMAIL)).Split(",");
 		if (alt.Length())
 			e += alt;
 	}
 	return e;
 }
 
 bool Contact::HasEmail(LString email)
 {
 	auto Emails = GetEmails();
 	for (auto e: Emails)
 		if (e.Equals(email))
 			return true;
 	return false;
 }
 
 LString Contact::GetAddrAt(int i)
 {
 	if (i == 0)
 	{
 		const char *e;
 		if (Get(OPT_Email, e))
 			return e;
 	}
 	else if (i > 0)
 	{
 		auto t = LString(GetObject()->GetStr(FIELD_ALT_EMAIL)).SplitDelimit(",");
 		if (i <= (int)t.Length())
 			return t[i-1];
 	}
 	
 	return NULL;
 }
 
 bool Contact::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	auto Obj = GetObject();
 	if (!Name || !Obj)
 		return false;
 
 	// Check normal fields..
 	int Id = PropMap.Find(Name);
 	if (Id)
 	{
 		// Pre-defined field
 		auto r = Obj->SetStr(Id, Value.CastString());
 		if (r > Store3Error)
 		{
 			SetDirty();
 			return true;
 		}
 	}
 	else
 	{
 		// Custom field...
 		auto j = d->GetJson();
 		if (!j)
 			return false;
 		
 		if (!j->Set(Name, Value.CastString()))
 			return false;
 		
 		if (!Obj->SetStr(FIELD_CONTACT_JSON, j->GetJson()))
 			return false;
 
 		SetDirty();
 		return true;
 	}
 
 	return false;
 }
 
 bool Contact::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	// Check scribe level fields...
 	ScribeDomType Fld = StrToDom(Name);
 
 	switch (Fld)
 	{
 		case SdScribe: // Type: ScribeWnd
 		{
 			Value = (LDom*)App;
 			return true;
 		}
 		case SdFolder: // Type: ScribeFolder
 		{
 			ScribeFolder *f = GetFolder();
 			if (!f)
 				return false;
 			Value = (LDom*)f;
 			return true;
 		}
 		default:
 			break;
 	}
 
 	auto Obj = GetObject();
 	if (!Obj)
 		return false;
 
 	switch (Fld)
 	{
 		case SdEmail: // Type: String[]
 		{
 			if (!Value.SetList())
 				return false;
 
 			int c = GetAddrCount();				
 			for (int i=0; i<c; i++)
 			{
 				auto e = GetAddrAt(i);
 				Value.Value.Lst->Insert(new LVariant(e));
 			}
 			return true;
 		}
 		case SdType: // Type: Int32
 		{
 			Value = Obj->Type();
 			return true;
 		}
 		case SdGroups: // Type: String[]
 		{
 			LHashTbl<StrKey<char,false>,bool> Emails;
 
 			for (int i=0; i<GetAddrCount(); i++)
 			{
 				auto e = GetAddrAt(i);
 				Emails.Add(e, true);
 			}
 
 			List<LVariant> Grps;
 
 			auto Srcs = App->GetThingSources(MAGIC_GROUP);
 			for (auto g: Srcs)
 			{
 				for (auto t: g->Items)
 				{
 					ContactGroup *Grp = t->IsGroup();
 					if (Grp)
 					{
 						List<char> Addr;
 						if (Grp->GetAddresses(Addr))
 						{
 							for (auto a: Addr)
 							{
 								if (Emails.Find(a))
 								{
 									auto Name = Grp->GetFieldText(FIELD_GROUP_NAME);
 									if (Name)
 									{
 										Grps.Insert(new LVariant(Name));
 									}
 								}
 							}
 
 							Addr.DeleteArrays();
 						}						
 					}
 				}
 			}
 
 			Value.SetList(&Grps);
 			return true;
 		}
 		case SdImage: // Type: Image
 		{
 			LAssert(!"Impl.");
 			return false;
 		}
 		case SdImageHtml: // Type: String
 		{
 			if (!d->ImagePath)
 			{
 				int Px = 80;
 				if (Array)
 				{
 					int i = atoi(Array);
 					if (i > 0)
 						Px = i;
 				}
 				
 				// Check to see if the contact has an image...
 				const LVariant *Bin = Obj->GetVar(FIELD_CONTACT_IMAGE);
 				if (Bin && Bin->Type != GV_NULL)
 				{
 					if (Bin->Type == GV_BINARY)
 					{
 						auto Png = LFilterFactory::New("name.png", O_WRITE, NULL);
 						if (Png)
 						{
 							if (!d->Image)
 							{
 								LMemStream Mem(Bin->Value.Binary.Data, Bin->Value.Binary.Length, false);
 								LAutoPtr<LSurface> Raw(GdcD->Load(&Mem));
 								if (Raw)
 								{
 									ConvertImageToContactSize(d->Image, Px, Raw);
 								}
 							}
 							if (d->Image)
 							{
 								LFile::Path p(ScribeTempPath());
 								const char *First = Obj->GetStr(FIELD_FIRST_NAME);
 								const char *Last = Obj->GetStr(FIELD_LAST_NAME);
 								LString leaf;
 								leaf.Printf("%s%sContact.png", First, Last);
 								p += leaf;
 
 								LFile f;
 								if (f.Open(p, O_WRITE))
 								{
 									if (Png->WriteImage(&f, d->Image))
 									{
 										#if 0
 										// We could save the resized version here?
 										int64 NewSize = f.GetSize();
 										if (Bin->Length() > (50 << 10))
 										{
 											int asd=0;
 										}
 										#endif
 										
 										d->ImagePath = p.GetFull();
 									}
 								}
 							}
 						}
 					}
 					else LAssert(0);
 				}
 			}
 			
 			if (d->ImagePath)
 			{
 				LString html;
 				html.Printf("<img src='file://%s'>\n", d->ImagePath.Get());
 				Value = html;
 				return true;
 			}
 			
 			return App->GetValue("NoContact.ImageHtml", Value);
 		}
 		case SdTitle: // Type: String
 			Value = Obj->GetStr(FIELD_TITLE);
 			return true;
 		case SdFirst: // Type: String
 			Value = Obj->GetStr(FIELD_FIRST_NAME);
 			return true;
 		case SdSurname: // Type: String
 			Value = Obj->GetStr(FIELD_LAST_NAME);
 			return true;
 		case SdNickname: // Type: String
 			Value = Obj->GetStr(FIELD_NICK);
 			return true;
 		case SdSpouse: // Type: String
 			Value = Obj->GetStr(FIELD_SPOUSE);
 			return true;
 		case SdNotes: // Type: String
 			Value = Obj->GetStr(FIELD_NOTE);
 			return true;
 		case SdUid: // Type: Int64
 			Value = Obj->GetInt(FIELD_UID);
 			return true;
 		case SdTimeZone: // Type: String
 			Value = Obj->GetStr(FIELD_TIMEZONE);
 			return true;
 		case SdHomeStreet: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_STREET);
 			return true;
 		case SdHomeSuburb: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_SUBURB);
 			return true;
 		case SdHomePostcode: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_POSTCODE);
 			return true;
 		case SdHomeState: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_STATE);
 			return true;
 		case SdHomeCountry: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_COUNTRY);
 			return true;
 		case SdHomePhone: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_PHONE);
 			return true;
 		case SdHomeMobile: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_MOBILE);
 			return true;
 		case SdHomeIM: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_IM);
 			return true;
 		case SdHomeFax: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_FAX);
 			return true;
 		case SdHomeWebpage: // Type: String
 			Value = Obj->GetStr(FIELD_HOME_WEBPAGE);
 			return true;
 		case SdWorkStreet: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_STREET);
 			return true;
 		case SdWorkSuburb: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_SUBURB);
 			return true;
 		case SdWorkPostcode: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_POSTCODE);
 			return true;
 		case SdWorkState: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_STATE);
 			return true;
 		case SdWorkCountry: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_COUNTRY);
 			return true;
 		case SdWorkPhone: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_POSTCODE);
 			return true;
 		case SdWorkMobile: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_MOBILE);
 			return true;
 		case SdWorkIM: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_IM);
 			return true;
 		case SdWorkFax: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_FAX);
 			return true;
 		case SdCompany: // Type: String
 			Value = Obj->GetStr(FIELD_COMPANY);
 			return true;
 		case SdWorkWebpage: // Type: String
 			Value = Obj->GetStr(FIELD_WORK_WEBPAGE);
 			return true;
 		default:
 		{
 			// Check custom fields..
 			if (!d->CustomCache)
 			{
 				auto json = Obj->GetStr(FIELD_CONTACT_JSON);
 				d->CustomCache.Reset(new LJson(json));
 			}
 			if (!d->CustomCache)
 				return false;
 
 			Value = d->CustomCache->Get(Name);
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool Contact::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	// ScribeDomType Fld = StrToDom(MethodName);
 	
 	return Thing::CallMethod(MethodName, ReturnValue, Args);
 }
 
 Thing &Contact::operator =(Thing &c)
 {
 	Contact *Arg = c.IsContact();
 	if (GetObject() && Arg && Arg->GetObject())
 	{
 		GetObject()->CopyProps(*Arg->GetObject());
 	}
 
 	return *this;
 }
 
 bool Contact::IsAssociatedWith(char *PluginName)
 {
 	if (PluginName)
 	{
 		for (auto p: d->Plugins)
 		{
 			if (_stricmp(p, PluginName) == 0)
 			{
 				return true;
 			}
 		}
 	}
 
 	return false;
 
 }
 
 int Contact::Compare(LListItem *Arg, ssize_t FieldId)
 {
 	Contact *c1 = this;
 	Contact *c2 = dynamic_cast<Contact*>(Arg);
 	if (c1 && c2)
 	{
 		static int Fields[] = {FIELD_FIRST_NAME, FIELD_LAST_NAME, FIELD_EMAIL};
 		if (FieldId < 0)
 		{
 			int i = -(int)FieldId - 1;
 			if (i >= 0 && i < CountOf(Fields))
 			{
 				FieldId = Fields[i];
 			}
 		}		
 		
 		auto s1 = c1->GetObject()->GetStr((int)FieldId);
 		auto s2 = c2->GetObject()->GetStr((int)FieldId);
 		const char *Empty = "";
 		return _stricmp(s1?s1:Empty, s2?s2:Empty);
 	}
 
 	return 0;
 }
 
 ThingUi *Contact::DoUI(MailContainer *c)
 {
 	if (!Ui)
 	{
 		Ui = new ContactUi(this);
 	}
 
 	return Ui;
 }
 
 size_t Contact::SizeofField(const char *Name)
 {
 	LAssert(0);
 	return 0;
 }
 
 size_t Contact::Sizeof()
 {
 	LAssert(0);
 	return 0;
 }
 
 bool Contact::Serialize(LFile &f, bool Write)
 {
 	LAssert(0);
 	return false;
 }
 
 int Contact::DefaultContactFields[] = { FIELD_FIRST_NAME, FIELD_LAST_NAME, FIELD_EMAIL, 0 };
 
 int *Contact::GetDefaultFields()
 {
 	return DefaultContactFields;
 }
 
 const char *Contact::GetFieldText(int Field)
 {
 	const char *Status = NULL;
 
 	#define GetFldText(Id, Opt) \
 		case Id: Get(Opt, Status); break;
 
 	switch (Field)
 	{
 		MacroAllFields(GetFldText);
 
 		case FIELD_DATE_MODIFIED:
 		{
 			auto Dt = GetObject()->GetDate(Field);
 			if (Dt)
 				d->DateCache = Dt->Local().Get();
 			else
 				d->DateCache = LLoadString(IDS_NONE);
 			return d->DateCache;
 			break;
 		}
 		case FIELD_PLUGIN_ASSOC:
 		{
 			static char Str[256];
 			Str[0] = 0;
 			for (auto p: d->Plugins)
 			{
 				if (Str[0]) strcat(Str, ", ");
 				strcat(Str, p);
 			}
 			return Str;
 			break;
 		}
 	}
 
 	return Status;
 }
 
 const char *Contact::GetText(int i)
 {
 	if (FieldArray.Length())
 		return GetFieldText(FieldArray[i]);
 	
 	return GetFieldText(DefaultContactFields[i]);
 }
 
 void Contact::OnMouseClick(LMouse &m)
 {
 	if (m.IsContextMenu())
 	{
 		LScriptUi s(new LSubMenu);
 		if (s.Sub)
 		{
 			bool Sep = false;
 			const char *Email;
 			if (Get(OPT_Email, Email) &&
 				ValidStr(Email))
 			{
 				char Str[256];
 				const char *First = 0, *Last = 0;
 
 				Get(OPT_First, First);
 				Get(OPT_Last, Last);
 
 				char *LiteralEmail = NewStr(AddAmp(LLoadString(IDS_EMAIL), 'e'));
 				if (First || Last)
 				{
 					sprintf_s(Str, sizeof(Str), "%s %s %s", LiteralEmail, (First) ? First : "", (Last) ? Last : "");
 				}
 				else
 				{
 					sprintf_s(Str, sizeof(Str), "%s %s", LiteralEmail, Email);
 				}
 				DeleteArray(LiteralEmail);
 
 				s.Sub->AppendItem(Str, IDM_NEW_EMAIL, true);
 				Sep = true;
 			}
 
 			const char *Web = 0;
 			if (Get(OPT_HomeWebPage, Web) &&
 				ValidStr(Web))
 			{
 				s.Sub->AppendItem(Web, IDM_LOAD, true);
 				Sep = true;
 			}
 
 			if (Sep)
 			{
 				s.Sub->AppendSeparator();
 			}
 
 			s.Sub->AppendItem(LLoadString(IDS_OPEN), IDM_OPEN);
 			s.Sub->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE);
 			s.Sub->AppendItem(LLoadString(IDS_EXPORT), IDM_EXPORT);
 
 			LArray<LScriptCallback*> Callbacks;
 			if (App->GetScriptCallbacks(LThingContextMenu, Callbacks))
 			{
 				LScriptArguments Args(NULL);
 				Args[0] = new LVariant(App);
 				Args[1] = new LVariant(this);
 				Args[2] = new LVariant(&s);
 				for (auto c: Callbacks)
 				{
 					App->ExecuteScriptCallback(*c, Args);
 				}
 				Args.DeleteObjects();
 			}
 
 			if (GetList()->GetMouse(m, true))
 			{
 				int Result; 
 				switch (Result = s.Sub->Float(GetList(), m.x, m.y))
 				{
 					case IDM_NEW_EMAIL:
 					{
 						App->CreateMail(this);
 						break;
 					}
 					case IDM_LOAD:
 					{
 						if (Web)
 							LExecute(Web, 0, 0);
 						break;
 					}
 					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 It = Del.rbegin(); It != Del.end(); It--)
 								{
 									auto c = dynamic_cast<Contact*>(*It);
 									if (c)
 										c->OnDelete();
 								}
 
 								ParentList->Invalidate();
 							}
 						}
 						break;
 					}
 					case IDM_EXPORT:
 					{
 						ExportAll(GetList(), sMimeVCard, NULL);
 						break;
 					}
 					default:
 					{
 						// Handle any installed callbacks for menu items
 						for (unsigned i=0; i<s.Callbacks.Length(); i++)
 						{
 							LScriptCallback &Cb = s.Callbacks[i];
 							if (Cb.Param == Result)
 							{
 								LScriptArguments Args(NULL);
 								Args[0] = new LVariant(App);
 								Args[1] = new LVariant(this);
 								Args[2] = new LVariant(Cb.Param);
 								
 								App->ExecuteScriptCallback(Cb, Args);
 							}
 						}
 						break;
 					}
 				}
 			}
 
 			DeleteObj(s.Sub);
 		}
 	}
 	else if (m.Left())
 	{
 		if (m.Double())
 		{
 			DoUI();
 		}
 	}
 }
 
 bool Contact::Save(ScribeFolder *Folder)
 {
 	bool Status = false;
 
 	if (!Folder)
 	{
 		Folder = GetFolder();
 	}
 	if (!Folder && App)
 	{
 		Folder = App->GetFolder(FOLDER_CONTACTS);
 	}
 
 	if (Folder)
 	{
+		LDateTime Now;
+		GetObject()->SetDate(FIELD_DATE_MODIFIED, &Now.SetNow());
+
 		Status = Folder->WriteThing(this) != Store3Error;
 		if (Status)
 			SetDirty(false);
 	}
 
 	return Status;
 }
 
 bool Contact::GetFormats(bool Export, LString::Array &MimeTypes)
 {
 	if (!Export)
 		MimeTypes.Add(sMimeVCard);
 
 	return MimeTypes.Length() > 0;
 }
 
 Thing::IoProgress Contact::Import(IoProgressImplArgs)
 {
 	if (Stricmp(mimeType, sMimeVCard))
 		IoProgressNotImpl();
 	
 	VCard vCard;
 	if (!vCard.Import(GetObject(), stream))
 		IoProgressError("vCard import failed.");
 
 	IoProgressSuccess();
 }
 
 Thing::IoProgress Contact::Export(IoProgressImplArgs)
 {
 	if (Stricmp(mimeType, sMimeVCard))
 		IoProgressNotImpl();
 
 	VCard vCard;
 	if (!vCard.Export(GetObject(), stream))
 		IoProgressError("vCard export failed.");
 
 	IoProgressSuccess();
 }
 
 char *Contact::GetDropFileName()
 {
 	if (!DropFileName)
 	{
 		char File[64] = "Contact";
 		const char *First = 0, *Last = 0;
 
 		Get(OPT_First, First);
 		Get(OPT_Last, Last);
 		if (First && Last)
 			sprintf_s(File, sizeof(File), "%s-%s", First, Last);
 		else if (First)
 			strcpy_s(File, sizeof(File), First);
 		else if (Last)
 			strcpy_s(File, sizeof(File), Last);
 
 		DropFileName.Reset(MakeFileName(File, "vcf"));
 	}
 	return DropFileName;
 }
 
 bool Contact::GetDropFiles(LString::Array &Files)
 {
 	bool Status = false;
 
 	if (GetDropFileName())
 	{
 		if (!LFileExists(DropFileName))
 		{
 			LAutoPtr<LFile> F(new LFile);
 			if (F->Open(DropFileName, O_WRITE))
 			{
 				F->SetSize(0);
 				Export(AutoCast(F), sMimeVCard);
 			}
 		}
 
 		if (LFileExists(DropFileName))
 		{
 			Files.Add(DropFileName.Get());
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 void Contact::OnPrintHeaders(struct ScribePrintContext &Context)
 {
 	LDisplayString *ds = Context.Text(LLoadString(IDS_CONTACT));
 	LRect &r = Context.MarginPx;
 	int Line = ds->Y();
 	LDrawListSurface *Page = Context.Pages.Last();
 	Page->Rectangle(r.x1, Context.CurrentY + (Line * 5 / 10), r.x2, Context.CurrentY + (Line * 6 / 10));
 	Context.CurrentY += Line;
 }
 
 void Contact::OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages)
 {
 	// Print document
 	ForAllContactFields(Fld)
 	{
 		const char *Value = 0;
 		if (Get(Fld->Option, Value))
 		{
 			LString v = Value;
 			LString::Array Lines = v.SplitDelimit("\n");
 			int x = 0;
 			for (unsigned i=0; i<Lines.Length(); i++)
 			{
 				if (i)
 				{
 					Context.Text(Lines[i], x);
 				}
 				else
 				{
 					LString f;
 					const char *Name = LLoadString(Fld->FieldId);
 					f.Printf("%s: ", Name ? Name : Fld->DisplayText);
 					LDisplayString *ds = Context.Text(f);
 					if (ds)
 					{
 						x = ds->X();
 						Context.CurrentY -= ds->Y();
 						Context.Text(Lines[i], x);
 					}
 				}
 			}
 		}
 	}
 }
 
 const char *ToField(int f)
 {
 	ForAllContactFields(Fld)
 	{
 		if (Fld->FieldId == f)
 		{
 			return Fld->Option;
 		}
 	}
 
 	if (f == FIELD_PERMISSIONS)
 	{
 		return "Perms";
 	}
 
 	LAssert(0);
 
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 #define M_REMOVE_EMAIL_ADDR			(M_USER+0x400)
 
 class EmailAddr : public LListItem
 {
 	Contact *c;
 	LAutoString Email;
 	bool EditOneShot;
 	bool Default;
 	const char *ClickToAdd;
 
 public:
 	EmailAddr(Contact *contact, const char *email = 0, bool def = false)
 	{
 		c = contact;
 		EditOneShot = false;
 		Default = def;
 		Email.Reset(NewStr(email));
 		ClickToAdd = LLoadString(IDS_CLICK_TO_ADD);
 	}
 
 	bool GetDefault()
 	{
 		return Default;
 	}
 
 	char *GetEmail()
 	{
 		return Email;
 	}
 
 	LFont *GetFont()
 	{
 		return Default ? c->App->GetBoldFont() : 0;
 	}
 
 	const char *GetText(int Col=0)
 	{
 		if (EditOneShot)
 		{
 			EditOneShot = false;
 			return (char*)"";
 		}
 
 		return Email ? Email : (char*)ClickToAdd;
 	}
 
 	void Delete()
 	{
 		if (Parent->Length() > 1)
 		{
             Parent->GetWindow()->PostEvent(M_REMOVE_EMAIL_ADDR, (LMessage::Param)this);
 
 			if (Default)
 			{
 				// Set one of the other's to the default
 				List<EmailAddr> All;
 				Parent->GetAll(All);
 				for (auto a: All)
 				{
 					if (a != this && a->Email)
 					{
 						a->Default = true;
 						a->Update();
 						break;
 					}
 				}
 			}
 		}
 		else
 		{
 			Email.Reset();
 		}
 	}
 
 	bool SetText(const char *s, int Col=0)
 	{
 		if (s && Col == 0)
 		{
 			if (ValidStr(s))
 			{
 				if (!Email)
 				{
 					Parent->Insert(new EmailAddr(c));
 				}
 
 				Email.Reset(NewStr(s));
 				
 				if (GetCss())
 					GetCss()->DeleteProp(LCss::PropColor);
 				
 				Update();
 			}
 			else
 			{
 				Delete();
 			}
 		}
 
 		return false;
 	}
 
 	/*
 	void OnPaint(LItem::ItemPaintCtx &Ctx)
 	{
 		if (!Email)
 		{
 			LColour Back;
 			if (Select())
 				Back.Set(LC_FOCUS_SEL_BACK, 24);
 			else
 				Back.Set(LC_WORKSPACE, 24);
 
 			COLOUR Fore24 = LC_LOW;
 			COLOUR BackGrey = GdcGreyScale(Back.c24(), 24);
 			COLOUR ForeGrey = GdcGreyScale(Fore24, 24);
 			int Diff = abs((int)(BackGrey - ForeGrey));
 
 			if (Diff < 94)
 				Fore24 = LC_FOCUS_SEL_FORE;
 			// LgiTrace("Fore=%i Back=%i Diff=%i Fore=%x\n", BackGrey, ForeGrey, Diff, Fore24);
 
 			SetForegroundFill(new GViewFill(Fore24, 24));
 		}
 		else SetForegroundFill(0);
 
 		LListItem::OnPaint(Ctx);
 	}
 	*/
 
 	bool OnKey(LKey &k)
 	{
 		if (k.Down())
 		{
 			switch (k.c16)
 			{
 				default:
 				{
 					if
 					(
 						k.Down() &&
 						(
 							IsAlpha(k.c16) ||
 							k.c16 == ' ' ||
 							k.c16 == LK_F2
 						)
 					)
 					{
 						EditOneShot = !Email;
 
 						LViewI *v = EditLabel(0);
 						if (v && k.IsChar && IsAlpha(k.c16))
 						{
 							v->IterateViews().DeleteObjects();
 							if (v)
 							{
 								LEdit *e = dynamic_cast<LEdit*>(v);
 								if (e && !ValidStr(v->Name()))
 								{
 									LAutoString u(WideToUtf8(&k.c16, 1));
 									if (u)
 									{
 										e->Name(u);
 										e->SetCaret(1);
 									}
 								}
 
 								v->Focus(true);
 							}
 							else
 							{
 								LgiTrace("%s:%i - no edit.\n", __FILE__, __LINE__);
 							}
 						}
 
 						return true;
 					}
 					break;
 				}
 				case LK_DELETE:
 				{
 					Parent->Delete(this);
 					return true;
 					break;
 				}
 			}
 		}
 		
 		return false;
 	}
 
 	void OnMouseClick(LMouse &m)
 	{
 		if (m.Down())
 		{
 			if (m.IsContextMenu())
 			{
 				auto RClick = new LSubMenu;
 				if (RClick)
 				{
 					#define IDM_SET_DEFAULT 200
 					RClick->AppendItem(LLoadString(IDS_SET_DEFAULT), IDM_SET_DEFAULT, !Default);
 					RClick->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE, true);
 
 					// RClick->AppendSeparator();
 
 					if (LListItem::Parent->GetMouse(m, true))
 					{
 						switch (RClick->Float(LListItem::Parent, m.x, m.y))
 						{
 							case IDM_SET_DEFAULT:
 							{
 								// Clear the old default
 								List<EmailAddr> All;
 								Parent->GetAll(All);
 								for (auto a: All)
 								{
 									if (a->Default)
 									{
 										a->Default = false;
 										a->Update();
 										break;
 									}
 								}
 
 								// Set the new default
 								Default = true;
 								Update();
 								break;
 							}
 							case IDM_DELETE:
 							{
 								Delete();
 								break;
 							}
 						}
 					}
 
 					DeleteObj(RClick);
 				}				
 			}
 			else if (m.Left())
 			{
 				int c = Parent->ColumnAtX(m.x);
 				if (c >= 0)
 				{
 					EditOneShot = !Email;
 					EditLabel(c);
 				}
 			}
 		}
 	}
 };
 
 ContactUi::ContactUi(Contact *item) :
 	ThingUi(item, "Contact")
 {
 	Lst = 0;
 	ImgView = NULL;
 	Item = item;
 	if (!(Item && Item->App))
 	{
 		return;
 	}
 
 	#if WINNATIVE
 	SetStyle(GetStyle() & ~WS_VISIBLE);
 	CreateClassW32("Scribe::ContactUi", LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_CONTACT)));
 	#endif
 
 	if (Attach(0))
 	{
 		LRect p;
 		LAutoString s(NewStr("Contact"));		
 		if (LoadFromResource(IDD_CONTACT, this, &p, &s))
 		{
 			// size/position
 			Name(s);
 			SetPos(p);
 
 			MoveSameScreen(App);
 			// MoveToCenter();
 			
 			// list setup
 			if (GetViewById(IDC_EMAIL, Lst))
 			{
 				Lst->ShowColumnHeader(false);
 				Lst->AddColumn("Email", Lst->X());
 				Lst->Insert(new EmailAddr(Item));
 			}
 
 			// Tz setup
 			LCombo *c;
 			if (GetViewById(IDC_PICK_TZ, c))
 			{
 				c->Sort(true);
 				c->Sub(GV_DOUBLE);
 
 				GTimeZone *Tz = GTimeZones;
 				while (Tz->Text)
 				{
 					char s[256];
 					sprintf_s(s, sizeof(s), "%.1f  %s", Tz->Offset, Tz->Text);
 					c->Insert(s);
 					Tz++;
 				}
 			}
 			
 			// Show buttons to toggle mode...
 			LButton *Show;
 			if (GetViewById(IDC_SHOW_ADDR, Show))
 			{
 				Show->SetIsToggle(true);
 				Show->Value(1);
 			}
 			if (GetViewById(IDC_SHOW_EXTRA, Show))
 				Show->SetIsToggle(true);
 
 			// controls
 			AttachChildren();
 
 			// Image setup
 			if (GetViewById(IDC_IMAGE, ImgView))
 			{
 				ImgView->SetContact(Item);
 			}
 			
 			OnLoad();
 
 			// show the window
 			Visible(true);
 
 			// set default button
 			_Default = FindControl(IDOK);
 			LViewI *f = FindControl(IDC_FIRST);
 			if (f) f->Focus(true);
 		}
 	}
 
 	SetPulse(1000);
 }
 
 ContactUi::~ContactUi()
 {
 	Item->Ui = 0;
 }
 
 void ContactUi::OnDestroy()
 {
 	if (Item)
 	{
 		Item->Ui = 0;
 	}
 }
 
 bool ContactUi::InitField(int Id, const char *Name)
 {
 	if (Item)
 	{
 		const char *s;
 		if (Item->Get(Name, s))
 		{
 			SetCtrlName(Id, s);
 			return true;
 		}
 
 		int i;
 		if (Item->Get(Name, i))
 		{
 			SetCtrlValue(Id, i);
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool ContactUi::SaveField(int Id, const char *Name)
 {
 	if (Item)
 	{
 		if (Id == FIELD_UID)
 		{
 			Item->Set(Name, (int)GetCtrlValue(Id));
 			return true;
 		}
 		else
 		{
 			Item->Set(Name, GetCtrlName(Id));
 			return true;
 		}
 	}
 	return false;
 }
 
 void ContactUi::OnLoad()
 {
 	int Insert = 0;
 	ForAllContactFields(f)
 	{
 		if (f->FieldId == FIELD_EMAIL)
 		{
 			const char *e;
 			if (Item->Get(f->Option, e))
 			{
 				Lst->Insert(new EmailAddr(Item, e, true), Insert++);
 			}
 		}
 		else if (f->CtrlId > 0)
 		{
 			InitField(f->CtrlId, f->Option);
 		}
 	}
 
 	auto AltEmail = LString(Item->GetObject()->GetStr(FIELD_ALT_EMAIL)).SplitDelimit(",");
 	for (auto e: AltEmail)
 		Lst->Insert(new EmailAddr(Item, e), Insert++);
 	
 	if (ImgView)
 	{
 		const LVariant *v = Item->GetObject()->GetVar(FIELD_CONTACT_IMAGE);
 		if (v && v->Type == GV_BINARY)
 		{
 			ImgView->IsNoFace = false;
 			ImgView->SetImage(*v);
 		}
 	}
 
 	auto FirstName = Item->GetObject()->GetStr(FIELD_FIRST_NAME);
 	auto LastName = Item->GetObject()->GetStr(FIELD_LAST_NAME);
 	if (ValidStr(FirstName)||ValidStr(LastName))
 	{
 		LString s;
 		s.Printf("%s - %s%s%s", LLoadString(IDS_CONTACT), FirstName?FirstName:"", FirstName?" ":"", LastName?LastName:"");
 		Name(s);
 	}
 
 	LViewI *c;
 	if (GetViewById(IDC_TIMEZONE, c))
 	{
 		LNotification note(LNotifyValueChanged);
 		OnNotify(c, note);
 	}
 }
 
 void ContactUi::OnSave()
 {
 	auto Obj = Item->GetObject();
 	EmailAddr *Def = NULL;
 	List<EmailAddr> All;
 	Lst->GetAll(All);
 
 	ForAllContactFields(f)
 	{
 		if (f->FieldId == FIELD_EMAIL)
 		{
 			for (auto a: All)
 			{
 				if (a->GetDefault())
 				{
 					Def = a;
 					break;
 				}
 			}
 
 			if (!Def)
 				Def = All[0];
 
 			if (Def)
 				Item->Set(f->Option, Def->GetEmail());
 		}
 		else if (f->CtrlId > 0)
 		{
 			SaveField(f->CtrlId, f->Option);
 		}
 	}
 
 	LString::Array AltEmails;
 	for (auto a: All)
 	{
 		if (a != Def && a->GetEmail())
 			AltEmails.New() = a->GetEmail();
 	}
 	LString AltEmail = LString(",").Join(AltEmails);
 	Obj->SetStr(FIELD_ALT_EMAIL, AltEmail);
 
 	if (ImgView)
 	{
 		// Reset the cache...
 		Item->d->Image.Reset();
 		Item->d->ImagePath.Empty();
 
 		// Set the image in the back end store...
 		LVariant *Img = &ImgView->GetImage();
 		Obj->SetVar(FIELD_CONTACT_IMAGE, Img);
 	}
 	
 	if (Item && Item->App)
 	{
 		Item->Save();
 		
 		LArray<LDataI*> c;
 		c.Add(Obj);
 		Item->App->SetContext(_FL);
 		Item->App->OnChange(c, 0);
 	}
 }
 
 void ContactUi::OnPosChange()
 {
 }
 
 LMessage::Result ContactUi::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_REMOVE_EMAIL_ADDR:
 		{
 			EmailAddr *Addr = (EmailAddr*)Msg->A();
 			if (Addr)
 			{
 				Lst->Delete(Addr);
 			}
 			break;
 		}
 	}
 
 	return ThingUi::OnEvent(Msg);
 }
 
 int ContactUi::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDOK:
 		{
 			OnSave();
 			// fall thru
 		}
 		case IDCANCEL:
 		{
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDC_TIMEZONE:
 		{
 			LString v = Ctrl->Name();
 			if (!v)
 				break;
 			
 			auto dv = v.Float();
 			
 			LCombo *c;
 			if (GetViewById(IDC_PICK_TZ, c))
 			{
 				for (size_t i=0; i<c->Length(); i++)
 				{
 					auto s = (*c)[i];
 					if (s)
 					{
 						auto sval = atof(s);
 						if (ABS(sval-dv) < 0.0001)
 						{
 							c->Value(i);
 							return true;
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDC_PICK_TZ:
 		{
 			if (Ctrl->Value() >= 0 &&
 				Ctrl->Name())
 			{
 				double Tz = atof(Ctrl->Name());
 				char s[32];
 				sprintf_s(s, sizeof(s), "%.1f", Tz);
 				SetCtrlName(IDC_TIMEZONE, s);
 			}
 			break;
 		}
 		case IDC_SHOW_ADDR:
 		{
 			LTableLayout *Tbl;
 			if (GetViewById(IDC_TABLE, Tbl))
 			{
 				int64 Shown = Ctrl->Value();
 				Ctrl->Name(Shown ? "-" : "+");
 				int y = 2;
 				
 				auto *c = Tbl->GetCell(0, y);
 				if (c) c->Display(Shown ? LCss::DispBlock : LCss::DispNone);
 				
 				c = Tbl->GetCell(1, y);
 				if (c) c->Display(Shown ? LCss::DispBlock : LCss::DispNone);
 				
 				Tbl->InvalidateLayout();
 			}
 			break;
 		}
 		case IDC_SHOW_EXTRA:
 		{
 			LTableLayout *Tbl;
 			if (GetViewById(IDC_TABLE, Tbl))
 			{
 				int64 Shown = Ctrl->Value();
 				Ctrl->Name(Shown ? "-" : "+");
 				int y = 4;
 				
 				auto *c = Tbl->GetCell(0, y);
 				if (c) c->Display(Shown ? LCss::DispBlock : LCss::DispNone);
 				
 				c = Tbl->GetCell(1, y);
 				if (c) c->Display(Shown ? LCss::DispBlock : LCss::DispNone);
 				
 				Tbl->InvalidateLayout();
 			}
 			break;
 		}
 	}
 
 	return 0;
 }
 
 char *Contact::GetLocalTime(const char *TimeZone)
 {
 	char *Status = 0;
 
 	if (!ValidStr(TimeZone))
 	{
 		Get(OPT_TimeZone, TimeZone);
 	}
 
 	if (ValidStr(TimeZone))
 	{
 		double TheirTz = atof(TimeZone);
 		LDateTime d;
 		d.SetNow();
 		d.SetTimeZone((int)(TheirTz * 60), true);
 
 		char s[256];
 		d.Get(s, sizeof(s));
 		Status = NewStr(s);
 	}
 
 	return Status;
 }
 
 void ContactUi::OnPulse()
 {
 	char *Local = Item->GetLocalTime(GetCtrlName(IDC_TIMEZONE));
 	if (Local)
 	{
 		SetCtrlName(IDC_LOCALTIME, Local);
 		DeleteArray(Local);
 	}
 }
 
 
diff --git a/Code/ScribeFilter.cpp b/Code/ScribeFilter.cpp
--- a/Code/ScribeFilter.cpp
+++ b/Code/ScribeFilter.cpp
@@ -1,4203 +1,4206 @@
 /*
 **	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))
 		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;
 
 	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);
 
+		LDateTime Now;
+		GetObject()->SetDate(FIELD_DATE_MODIFIED, &Now.SetNow());
+
 		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,1406 +1,1405 @@
 #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)
 	{
 		auto Name = GetName();
 		DropFileName.Reset(MakeFileName(Name ? Name : "group", "xml"));
 	}
 	
 	return DropFileName;
 }
 
 bool ContactGroup::GetDropFiles(LString::Array &Files)
 {
 	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)
 								{
 									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)
 {
 	if (!GetFolder())
 	{
 		if (Into)
 			SetParentFolder(Into);
 		else if (App)
 			SetParentFolder(App->GetFolder(FOLDER_GROUPS));
 	}
 
 	if (!GetFolder())
 		return false;
 
+	LDateTime Now;
+	GetObject()->SetDate(FIELD_DATE_MODIFIED, &Now.SetNow());
+
 	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();			
 			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/Code/ScribeMail.cpp b/Code/ScribeMail.cpp
--- a/Code/ScribeMail.cpp
+++ b/Code/ScribeMail.cpp
@@ -1,10255 +1,10254 @@
 /*
 **	FILE:			ScribeMail.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			11/11/98
 **	DESCRIPTION:	Scribe Mail Object and UI
 **
 **	Copyright (C) 1998-2003, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdio.h>
 #include <time.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/timeb.h>
 #include <math.h>
 
 #include "Scribe.h"
 #include "ScribePageSetup.h"
 #include "lgi/common/NetTools.h"
 #include "lgi/common/Popup.h"
 #include "lgi/common/ColourSelect.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/Html.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/ThreadEvent.h"
 #include "lgi/common/GdcTools.h"
 #include "lgi/common/Charset.h"
 
 #include "../src/common/Coding/ScriptingPriv.h"
 #include "PrintPreview.h"
 #include "ScribeListAddr.h"
 #include "PrintContext.h"
 #include "lgi/common/LgiRes.h"
 #include "Encryption/GnuPG.h"
 #include "ObjectInspector.h"
 #include "lgi/common/EventTargetThread.h"
 #include "Store3Common.h"
 #include "Tables.h"
 #include "Calendar.h"
 #include "CalendarView.h"
 #include "AddressSelect.h"
 #include "Store3Imap/ScribeImap.h"
 #include "lgi/common/TextConvert.h"
 #include "lgi/common/FileSelect.h"
 
 #include "resdefs.h"
 #include "resource.h"
 #include "lgi/common/Printer.h"
 #include "lgi/common/SubProcess.h"
 
 #define SAVE_HEADERS					0
 
 static char MsgIdEncodeChars[] = "%/";
 static char ScribeReplyClass[] = "scribe_reply";
 static char ScribeReplyStyles[] =	"margin-left: 0.5em;\n"
 									"padding-left: 0.5em;\n"
 									"border-left: 1px solid #ccc;";
 
 char DefaultTextReplyTemplate[] =
 {
 	"---------- Original Message ----------\n"
 	"To: <mail.to[0].name> &lt;<mail.to[0].email>&gt;\n"
 	"From: <mail.from.name> &lt;<mail.from.email>&gt;\n"
 	"Subject: <mail.subject>\n"
 	"Date: <mail.datesent>\n"
 	"\n"
 	"<mail.bodyastext quote=scribe.quote>\n"
 	"<cursor>\n"
 	"<mail.sig>\n"
 };
 
 char DefaultHtmlReplyTemplate[] =
 {
 	"<html>\n"
 	"<head>\n"
 	"<style>\n"
 	"	.Style1 {\n"
 	"		color: #919191;\n"
 	"	}\n"
 	"	.Style2 {\n"
 	"		font-weight: bold;\n"
 	"	}\n"
 	"	.Style3 {\n"
 	"		color: #ae0000;\n"
 	"	}\n"
 	"	</style>\n"
 	"</head>\n"
 	"<body>\n"
 	"	<p><span class='Style1'>---------- Original Message ----------</span><br>\n"
 	"	<b>To:</b> &lt;?mail.tohtml?&gt;<br>\n"
 	"	<b>From:</b> &lt;?mail.fromhtml?&gt;<br>\n"
 	"	<b>Subject:</b> &lt;?mail.subject?&gt;<br>\n"
 	"	<b>Date:</b> &lt;?mail.datesent?&gt;<br>\n"
 	"	<br>\n"
 	"	<span class='Style3'>&lt;?mail.bodyastext quote=scribe.quote?&gt;</span><br>\n"
 	"	&lt;?cursor?&gt;<br>\n"
 	"	&lt;?mail.sig[html]?&gt;</p>\n"
 	"</body>\n"
 	"</html>\n"
 };
 
 class DepthCheck
 {
 	int &i;
 
 public:
 	constexpr static int MaxDepth = 5;
 
 	DepthCheck(int &val) : i(val)
 	{
 		i++;
 		if (!*this)
 			LAssert(!"Recursion?");
 	}
 
 	~DepthCheck()
 	{
 		i--;
 	}
 
 	operator bool() const
 	{
 		return i < MaxDepth;
 	}
 };
 
 void CollectAttachments(LArray<LDataI*> *Attachments,
 						LArray<LDataI*> *Related,
 						LDataI **Text,
 						LDataI **Html,
 						LDataPropI *d,
 						Store3MimeType *ParentMime = NULL)
 {
 	if (!d)
 		return;
 
 	Store3MimeType Mt(d->GetStr(FIELD_MIME_TYPE));
 	auto FileName = d->GetStr(FIELD_NAME);
 	if (!Mt)
 		Mt = "text/plain";
 	
 	// printf("Collect %s %s\n", (char*)Mt, FileName);
 	
 	auto Att = dynamic_cast<LDataI*>(d);
 	if (ParentMime && Att && ParentMime->IsRelated() && Related)
 	{
 		auto Id = d->GetStr(FIELD_CONTENT_ID);
 		if (ValidStr(Id))
 		{
 			if (Related)
 				Related->Add(Att);
 			Att = NULL;
 		}
 		else if (Mt.IsHtml() && Html)
 		{
 			*Html = Att;
 			Att = NULL;
 		}
 	}
 
 	if (Att)
 	{
 		if (ValidStr(FileName))
 		{
 			if (Attachments)
 				Attachments->Add(Att);
 		}
 		else if (Mt.IsHtml())
 		{
 			if (Html)
 				*Html = Att;
 		}
 		else if (Mt.IsPlainText())
 		{
 			if (Text)
 				*Text = Att;
 		}
 		else if (!Mt.IsMultipart())
 		{
 			if (Attachments)
 				Attachments->Add(Att);
 		}
 
 		/*
 		if (d->GetInt(FIELD_SIZE) < (512 << 10))
 			a.Add(dynamic_cast<LDataI*>(d));
 		*/
 	}
 
 	auto It = d->GetList(FIELD_MIME_SEG);
 	if (It)
 	{
 		for (auto i = It->First(); i; i = It->Next())
 			CollectAttachments(Attachments, Related, Text, Html, i, Mt.IsMultipart() ? &Mt : NULL);
 	}
 }
 
 void RemoveReturns(char *s)
 {
 	// Delete out the '\r' chars.
 	char *In = s;
 	char *Out = s;
 	while (*In)
 	{
 		if (*In != '\r')
 		{
 			*Out++ = *In;
 		}
 		In++;
 	}
 	*Out++ = 0;
 }
 
 class XmlSaveStyles : public LXmlTree
 {
 	void OnParseComment(LXmlTag *Ref, const char *Comment, ssize_t Bytes)
 	{
 		if (Ref && Ref->IsTag("style"))
 		{
 			Ref->SetContent(Comment, Bytes);
 		}
 	}
 
 public:
 	XmlSaveStyles(int flags) : LXmlTree(flags)
 	{
 	}
 };
 
 bool ExtractHtmlContent(LString &OutHtml,
 						LString &Charset,
 						LString &Styles,
 						const char *InHtml)
 {
 	if (!InHtml)
 		return false;
 
 	XmlSaveStyles t(GXT_NO_ENTITIES | GXT_NO_DOM | GXT_NO_HEADER);
 	LXmlTag r;
 	LMemStream mem(InHtml, strlen(InHtml), false);
 	if (!t.Read(&r, &mem))
 		return false;
 
 	bool InHead = false;
 	LStringPipe Style;
 
 	r.Children.SetFixedLength(false);
 	for (auto It = r.Children.begin(); It != r.Children.end(); )
 	{
 		LXmlTag *c = *It;
 
 		if (c->IsTag("style"))
 		{
 			if (ValidStr(c->GetContent()))
 				Style.Print("%s\n", c->GetContent());
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("/head"))
 		{
 			InHead = false;
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("body"))
 		{
 			// We remove this tag, but KEEP the content... if any
 			if (ValidStr(c->GetContent()))
 			{
 				c->SetTag(NULL);
 				It++;
 			}
 			else
 			{
 				// No content, remove entirely.
 				c->Parent = NULL;
 				r.Children.Delete(It);
 				DeleteObj(c);
 			}
 		}
 		else if (InHead || 
 				c->IsTag("html") ||
 				c->IsTag("/html") ||
 				c->IsTag("/body") ||
 				c->IsTag("/style"))
 		{
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else if (c->IsTag("head"))
 		{
 			InHead = true;
 			c->Parent = NULL;
 			r.Children.Delete(It);
 			DeleteObj(c);
 		}
 		else
 			It++;
 	}
 
 	LStringPipe p;
 	t.Write(&r, &p);
 	OutHtml = p.NewLStr();
 	Styles = Style.NewLStr();
 
 	#if 0
 	LgiTrace("InHtml=%s\n", InHtml);
 	LgiTrace("OutHtml=%s\n", OutHtml.Get());
 	LgiTrace("Styles=%s\n", Styles.Get());
 	#endif
 	
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 char MailToStr[] = "mailto:";
 char SubjectStr[] = "subject=";
 char ContentTypeDefault[] = "Content-type: text/plain; charset=us-ascii";
 
 extern LString HtmlToText(const char *Html, const char *InitialCharSet);
 extern LString TextToHtml(const char *Txt, const char *Charset);
 
 class ImageResizeThread : public LEventTargetThread
 {
 	LOptionsFile *Opts;
 
 public:
 	class Job
 	{
 		#ifdef __GTK_H__
 		/* This object may not exist when the worker is finished.
 			However LAppInst->PostEvent can handle that so we'll allow
 			it, so long as it's never used in the Sink->PostEvent form.	*/
 		LViewI *Sink;
 		#else
 		OsView Sink;
 		#endif
 
 	public:
 		LString FileName;
 		LAutoStreamI Data;
 
 		void SetSink(LViewI *v)
 		{
 			#if !LGI_VIEW_HANDLE
 			Sink = v;
 			#else
 			Sink = v->Handle();
 			#endif
 		}
 
 		bool PostEvent(int Msg, LMessage::Param a = 0, LMessage::Param b = 0)
 		{
 			#ifdef __GTK_H__
 			return LAppInst->PostEvent(Sink, Msg, a, b);
 			#else
 			return LPostEvent(Sink, Msg, a, b);
 			#endif
 		}
 	};
 
 	ImageResizeThread(LOptionsFile *opts) : LEventTargetThread("ImageResize")
 	{
 		Opts = opts;
 	}
 
 	void Resize(LAutoPtr<ImageResizeThread::Job> &Job)
 	{
 		LVariant Qual = 80, Px = 1024, SizeLimit = 200, v;
 		Opts->GetValue(OPT_ResizeJpegQual, Qual);
 		Opts->GetValue(OPT_ResizeMaxPx, Px);
 		Opts->GetValue(OPT_ResizeMaxKb, SizeLimit);
 
 		LAutoStreamI Input = Job->Data;
 		LAutoStreamI MemBuf(new LMemFile(4 << 10));
 		int64 FileSize = Input->GetSize();
 
 		LStream *sImg = dynamic_cast<LStream*>(Input.Get());
 		LAutoPtr<LSurface> Img(GdcD->Load(sImg, Job->FileName));
 		if (Img)
 		{
 			int iPx = Px.CastInt32();
 			int iKb = SizeLimit.CastInt32();
 			
 			if (Img->X() > iPx ||
 				Img->Y() > iPx ||
 				FileSize >= iKb << 10)
 			{
 				// Create a JPEG filter
 				auto Jpeg = LFilterFactory::New(".jpg", FILTER_CAP_WRITE, NULL);
 				if (Jpeg)
 				{
 					// Re-sample the image...
 					double XScale = (double) Img->X() / iPx;
 					double YScale = (double) Img->Y() / iPx;
 					// double Aspect = (double) Img->X() / Img->Y();
 					double Scale = XScale > YScale ? XScale : YScale;
 					if (Scale > 1.0)
 					{
 						int Nx = (int)(Img->X() / Scale + 0.001);
 						int Ny = (int)(Img->Y() / Scale + 0.001);
 						
 						LAutoPtr<LSurface> ResizedImg(new LMemDC(Nx, Ny, Img->GetColourSpace()));
 						if (ResizedImg)
 						{
 							if (ResampleDC(ResizedImg, Img))
 							{
 								Img = ResizedImg;
 							}
 						}
 					}
 																
 					// Compress the image..
 					LXmlTag Props;
 					Props.SetValue(LGI_FILTER_QUALITY, Qual);
 					Props.SetValue(LGI_FILTER_SUBSAMPLE, v = 1); // 2x2
 					Jpeg->Props = &Props;
 					if (Jpeg->WriteImage(dynamic_cast<LStream*>(MemBuf.Get()), Img) == LFilter::IoSuccess)
 					{
 						Job->Data = MemBuf;
 					}
 				}
 			}
 		}
 		
 		Job->PostEvent(M_RESIZE_IMAGE, (LMessage::Param)Job.Get());
 		Job.Release(); // Do this after the post event... so the deref doesn't crash.
 	}
 	
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		switch (Msg->Msg())
 		{
 			case M_RESIZE_IMAGE:
 			{
 				LAutoPtr<Job> j((Job*)Msg->A());
 				if (j)
 					Resize(j);
 				break;
 			}
 		}
 		
 		return 0;
 	}	
 };
 
 #include "lgi/common/RichTextEdit.h"
 #include "../src/common/Widgets/Editor/RichTextEditPriv.h"
 
 class MailRendererScript : public LThread, public LCancel, public LDom
 {
 	Mail *m;
 	LScriptCallback *cb;
 
 public:
 	MailRendererScript(Mail *ml, LScriptCallback *script) : m(ml), cb(script), LThread("MailRendererScript")
 	{
 		Run();
 	}
 
 	~MailRendererScript()
 	{
 		Cancel(true);
 		while (!IsExited())
 			LSleep(1);
 	}
 
 	int Main()
 	{
 		LVirtualMachine Vm;				
 		LScriptArguments Args(&Vm);
 		Args.New() = new LVariant(m->App);
 		Args.New() = new LVariant(m);
 		Args.New() = new LVariant((LDom*)this);
 		m->App->ExecuteScriptCallback(*cb, Args);
 		Args.DeleteObjects();
 		return 0;
 	}
 
 	bool CallMethod(const char *MethodName, LVariant *Ret, LArray<LVariant*> &Args)
 	{
 		ScribeDomType Method = StrToDom(MethodName);
 
 		*Ret = false;
 		switch (Method)
 		{		
 			case SdGetTemp:
 			{
 				*Ret = ScribeTempPath();
 				break;
 			}
 			case SdExecute:
 			{
 				*Ret = false;
 				if (Args.Length() >= 3)
 				{
 					auto Dir = Args[0]->Str();
 					auto Exe = Args[1]->Str();
 					auto Arg = Args[2]->Str();
 					if (Dir && Exe && Arg)
 					{
 						LSubProcess p(Exe, Arg);
 						p.SetInitFolder(Dir);
 						if (p.Start())
 						{
 							char Buf[256];
 							LStringPipe Out;
 							Out.Print("%s %s\n", Exe, Arg);
 
 							ssize_t Rd;
 							while (p.IsRunning() && !IsCancelled())
 							{
 								Rd = p.Read(Buf, sizeof(Buf));
 								if (Rd < 0)
 									break;
 								if (Rd == 0)
 									LSleep(1);
 								else
 									Out.Write(Buf, Rd);
 							}
 
 							while (!IsCancelled() && (Rd = p.Read(Buf, sizeof(Buf))) > 0)
 								Out.Write(Buf, Rd);
 
 							// LgiTrace("%s:%i - Process:\n%s\n", _FL, Out.NewLStr().Get());
 							if (p.IsRunning())
 								p.Kill();
 							else
 								*Ret = true;
 						}
 					}
 				}
 				break;
 			}
 			case SdSetHtml:
 			{
 				if (!IsCancelled() && Args.Length() > 0)
 				{
 					LView *Ui = m->GetUI();
 					if (!Ui)
 					{
 						// Maybe hasn't finished opening the UI?
 						LSleep(100);
 						Ui = m->GetUI();
 					}
 					if (!Ui)
 						Ui = m->App;
 					if (Ui)
 						Ui->PostEvent(M_SET_HTML, (LMessage::Param)new LString(Args[0]->Str()));
 				}
 				break;
 			}
 			default:
 				LAssert(!"Unsupported call.");
 				return false;
 		}
 
 		return true;
 	}
 };
 
 class MailPrivate
 {
 	LAutoPtr<ImageResizeThread> Resizer;
 	Mail *m;
 
 public:
 	struct HtmlBody
 	{
 		LString Html, Charset, Styles;
 	};
 	LAutoPtr<HtmlBody> Body;
 	LAutoPtr<MailRendererScript> Renderer;
 	LString MsgIdCache;
 	LString DomainCache;
 	int InSetFlags = 0;
 	int InSetFlagsCache = 0;
 	
 	MailPrivate(Mail *mail)
 	{
 		m = mail;
 	}
 	
 	void OnSave()
 	{
 		Resizer.Reset();
 	}
 
 	HtmlBody *GetBody()
 	{
 		if (!Body && !Body.Reset(new HtmlBody))
 			return NULL;
 		
 		if (ValidStr(m->GetHtml()))
 		{
 			ExtractHtmlContent(	Body->Html,
 								Body->Charset,
 								Body->Styles,
 								m->GetHtml());
 		}
 		else if (ValidStr(m->GetBody()))
 		{
 		    Body->Charset = m->GetCharSet();
 			Body->Html = TextToHtml(m->GetBody(), Body->Charset);
 		}
 		
 		return Body;
 	}
 
 	bool AddResizeImage(Attachment *File)
 	{
 		if (!File || !m->GetUI())
 			return false;
 		
 		if (!Resizer)
 			Resizer.Reset(new ImageResizeThread(m->App->GetOptions()));
 		
 		if (!Resizer)
 			return false;
 
 		LAutoStreamI Obj = File->GetObject()->GetStream(_FL);
 		if (!Obj)
 			return false;
 
 		ImageResizeThread::Job *j = new ImageResizeThread::Job;
 		if (!j)
 			return false;
 
 		// The user interface will handle the response...				
 		j->SetSink(m->GetUI());
 		j->FileName = File->GetName();					
 
 		// Make a complete copy of the stream...
 		j->Data.Reset(new LMemStream(Obj, 0, -1));
 	
 		// Post the work over to the thread...
 		Resizer->PostEvent(M_RESIZE_IMAGE, (LMessage::Param)j);
 
 		// Mark the image resizing						
 		File->SetIsResizing(true);
 		
 		return true;
 	}	
 };
 
 bool Mail::ResizeImage(Attachment *a)
 {
 	return d->AddResizeImage(a);
 }
 
 AttachmentList::AttachmentList(int id, int x, int y, int cx, int cy, MailUi *ui)
 	: LList(id, x, y, cx, cy, 0)
 {
 	Ui = ui;
 }
 
 AttachmentList::~AttachmentList()
 {
 	RemoveAll();
 }
 
 void AttachmentList::OnItemClick(LListItem *Item, LMouse &m)
 {
 	LList::OnItemClick(Item, m);
 
 	if (!Item &&
 		m.IsContextMenu() &&
 		Ui)
 	{
 		LSubMenu RClick;
 		RClick.AppendItem(LLoadString(IDS_ATTACH_FILE), IDM_OPEN, true);
 		switch (RClick.Float(this, m))
 		{
 			case IDM_OPEN:
 			{
 				Ui->PostEvent(M_COMMAND, IDM_ATTACH_FILE, 0);
 				break;
 			}
 		}
 	}
 }
 
 bool AttachmentList::OnKey(LKey &k)
 {
 	if (k.vkey == LK_DELETE)
 	{
 		if (k.Down())
 		{
 			List<LListItem> s;
 			if (GetSelection(s))
 			{
 				Attachment *a = dynamic_cast<Attachment*>(s[0]);
 				if (a)
 				{
 					a->OnDeleteAttachment(this, true);
 				}
 			}
 		}
 		
 		return true;
 	}
 	
 	return LList::OnKey(k);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 int Strnlen(const char *s, int n)
 {
 	int i = 0;
 	if (s)
 	{
 		if (n < 0)
 		{
 			while (*s++)
 			{
 				i++;
 			}
 		}
 		else
 		{
 			while (*s++ && n-- > 0)
 			{
 				i++;
 			}
 		}
 	}
 
 	return i;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 MailContainer::~MailContainer()
 {
 	MailContainerIter *i;
 	while ((i = Iters[0]))
 	{
 		Iters.Delete(i);
 		if (i->Container)
 		{
 			i->Container = 0;
 		}
 	}
 }
 
 MailContainerIter::MailContainerIter()
 {
 	Container = 0;
 }
 
 MailContainerIter::~MailContainerIter()
 {
 	if (Container)
 	{
 		Container->Iters.Delete(this);
 	}
 }
 
 void MailContainerIter::SetContainer(MailContainer *c)
 {
 	Container = c;
 	if (Container)
 	{
 		Container->Iters.Insert(this);
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 uint32_t MarkColours32[IDM_MARK_MAX] =
 {
 	Rgb32(255, 0, 0),	// red
 	Rgb32(255, 166, 0),	// orange
 	Rgb32(255, 222, 0),	// yellow
 	Rgb32(0, 0xa0, 0),	// green
 	Rgb32(0, 0xc0, 255),// cyan
 	Rgb32(0, 0, 255),	// blue
 	Rgb32(192, 0, 255),	// purple
 	Rgb32(0, 0, 0)		// black
 };
 
 ItemFieldDef MailFieldDefs[] =
 {
 	{"To", SdTo,							GV_STRING,		FIELD_TO},
 	{"From", SdFrom,						GV_STRING,		FIELD_FROM},
 	{"Subject", SdSubject,					GV_STRING,		FIELD_SUBJECT},
 	{"Size", SdSize,						GV_INT64,		FIELD_SIZE},
 	{"Received Date", SdReceivedDate,		GV_DATETIME,	FIELD_DATE_RECEIVED},
 	{"Send Date", SdSendDate,				GV_DATETIME,	FIELD_DATE_SENT},
 	{"Body", SdBody,						GV_STRING,		FIELD_TEXT},
 	{"Internet Header", SdInternetHeader,	GV_STRING,		FIELD_INTERNET_HEADER, IDC_INTERNET_HEADER},
 	{"Message ID", SdMessageID, 			GV_STRING,		FIELD_MESSAGE_ID},
 	{"Priority", SdPriority, 				GV_INT32,		FIELD_PRIORITY},
 	{"Flags", SdFlags, 						GV_INT32,		FIELD_FLAGS},
 	{"Html", SdHtml, 						GV_STRING,		FIELD_ALTERNATE_HTML},
 	{"Label", SdLabel, 						GV_STRING,		FIELD_LABEL},
 	{"From Contact", SdContact,				GV_STRING,		FIELD_FROM_CONTACT_NAME},
 	
 	{"File", SdFile, 						GV_STRING,		FIELD_CACHE_FILENAME},
 	{"ImapFlags", SdImapFlags, 				GV_STRING,		FIELD_CACHE_FLAGS},
 	{"ImapSeq", SdFile, 					GV_INT32,		FIELD_IMAP_SEQ},
 	{"ImapUid", SdImapFlags, 				GV_INT32,		FIELD_SERVER_UID},
 	{"ReceivedDomain", SdReceivedDomain,	GV_STRING,		FIELD_RECEIVED_DOMAIN},
 	{"MessageId", SdMessageId,				GV_STRING,		FIELD_MESSAGE_ID},
 	
 	{0}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 class LIdentityItem : public LListItem
 {
 	ScribeWnd *App;
 	ScribeAccount *Acc;
 	char *Txt;
 
 public:
 	LIdentityItem(ScribeWnd *app, ScribeAccount *acc)
 	{
 		App = app;
 		Acc = acc;
 		Txt = 0;
 
 		LVariant e, n;
 		if (Acc)
 		{
 			n = Acc->Identity.Name();
 			e = Acc->Identity.Email();
 		}
 		else
 		{
 			LAssert(!"No account specified");
 		}
 
 		if (e.Str() && n.Str())
 		{
 			char t[256];
 			sprintf_s(t, sizeof(t), "%s <%s>", n.Str(), e.Str());
 			Txt = NewStr(t);
 		}
 		else if (e.Str())
 		{
 			Txt = NewStr(e.Str());
 		}
 		else if (n.Str())
 		{
 			Txt = NewStr(n.Str());
 		}
 		else
 		{
 			Txt = NewStr("(error)");
 		}
 	}
 	
 	~LIdentityItem()
 	{
 		DeleteArray(Txt);
 	}
 
 	ScribeAccount *GetAccount()
 	{
 		return Acc;
 	}
 
 	const char *GetText(int i)
 	{
 		switch (i)
 		{
 			case 0:
 			{
 				return Txt;
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 class LIdentityDropDrop : public LPopup
 {
 	ScribeWnd *App;
 	Mail *Email;
 	LList *Lst;
 
 public:
 	LIdentityDropDrop(ScribeWnd *app, Mail *mail, LView *owner) :
 		LPopup(owner)
 	{
 		App = app;
 		Email = mail;
 		LRect r(0, 0, 300, 100);
 		SetPos(r);
 		Children.Insert(Lst = new LList(IDC_LIST, 2, 2, X()-4, Y()-4));
 		if (Lst)
 		{
 			Lst->SetParent(this);
 			Lst->AddColumn("Identity", Lst->GetClient().X());
 			Lst->MultiSelect(false);
 
 			if (App)
 			{
 				Lst->Insert(new LIdentityItem(App, 0));
 
 				for (auto a : *App->GetAccounts())
 				{
 					if (a->Identity.Name().Str())
 					{
 						Lst->Insert(new LIdentityItem(App, a));
 					}
 				}
 				
 				/*
 				for (LListItem *i = List->First(); i; i = List->Next())
 				{
 					LIdentityItem *Item = dynamic_cast<LIdentityItem*>(i);
 					if (Item)
 					{
 						char *IdEmail = a->Send.IdentityEmail();
 						if (Email &&
 							IdEmail &&
 							Email->From->Addr &&
 							_stricmp(Email->From->Addr, IdEmail) == 0)
 						{
 							Item->Select(true);
 						}
 					}
 				}
 				*/
 			}
 		}
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		LRect r(GetClient());
 		LWideBorder(pDC, r, DefaultRaisedEdge);
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_LIST:
 			{
 				if (n.Type == LNotifyItemClick)
 				{
 					Visible(false);
 
 					LIdentityItem *NewFrom = dynamic_cast<LIdentityItem*>(Lst->GetSelected());
 					if (Email && NewFrom)
 					{
 						// ScribeAccount *a = NewFrom->GetAccount();
 						if (Email->GetUI())
 						{
 							LList *FromList;
 							if (GetViewById(IDC_FROM, FromList))
 							{
 								// Change item data
 
 								/* FIXME
 								DeleteArray(Email->From->Name);
 								DeleteArray(Email->From->Addr);
 								DeleteArray(Email->Reply->Name);
 								DeleteArray(Email->Reply->Addr);
 								
 								if (a)
 								{
 									Email->From->Addr = NewStr(a->Send.IdentityEmail().Str());
 									Email->From->Name = NewStr(a->Send.IdentityName().Str());
 									Email->Reply->Addr = NewStr(a->Send.IdentityReplyTo().Str());
 									if (Email->Reply->Addr)
 									{
 										Email->Reply->Name = NewStr(Email->From->Name);
 									}
 								}
 								else
 								{
 									LVariant e, n, r;
 									App->GetOptions()->GetValue(OPT_EmailAddr, e);
 									App->GetOptions()->GetValue(OPT_UserName, n);
 									App->GetOptions()->GetValue(OPT_ReplyToEmail, n);
 									Email->From->Addr = NewStr(e.Str());
 									Email->From->Name = NewStr(n.Str());
 									Email->Reply->Addr = NewStr(r.Str());
 									if (Email->Reply->Addr)
 									{
 										Email->Reply->Name = NewStr(Email->From->Name);
 									}
 								}
 
 								// Change UI
 								FromList->Empty();
 								LDataPropI *na = new LDataPropI(Email->From);
 								if (na)
 								{
 									na->CC = MAIL_ADDR_FROM;
 									FromList->Insert(na);
 								}
 								*/
 							}
 						}
 					}
 				}
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 LSubMenu*
 BuildMarkMenu(	LSubMenu *MarkMenu,
 				MarkedState MarkState,
 				uint32_t SelectedMark,
 				bool None,
 				bool All,
 				bool Select)
 {
 	int SelectedIndex = -1;
 
 	// Build image list
 	LImageList *ImgLst = new LImageList(16, 16);
 	if (ImgLst &&
 		ImgLst->Create(16 * CountOf(MarkColours32), 16, System32BitColourSpace))
 	{
 		// ImgLst->Colour(1);
 		ImgLst->Colour(L_MED);
 		ImgLst->Rectangle();
 
 		for (int i=0; i<CountOf(MarkColours32); i++)
 		{
 			if (MarkState == MS_One &&
 				MarkColours32[i] == SelectedMark)
 			{
 				ImgLst->Colour(L_LOW);
 				ImgLst->Box(i*16+1, 0, i*16+15, 14);
 				SelectedIndex = i;
 			}
 
 			ImgLst->Colour(MarkColours32[i], 32);
 			ImgLst->Rectangle(i*16+3, 2, i*16+13, 12);
 		}
 	}
 
 	// Build Submenu
 	if (MarkMenu && ImgLst)
 	{
 		ImgLst->Update(-1);
 		MarkMenu->SetImageList(ImgLst);
 
 		LMenuItem *Item = NULL;
 		if (None)
 		{
 			Item = MarkMenu->AppendItem(LLoadString(IDS_NONE), Select ? IDM_SELECT_NONE : IDM_UNMARK, MarkState != MS_None);
 		}
 		if (All)
 		{
 			Item = MarkMenu->AppendItem(LLoadString(IDS_ALL), Select ? IDM_SELECT_ALL : IDM_MARK_ALL, true);
 		}
 		if (Item)
 		{
 			MarkMenu->AppendSeparator();
 		}
 
 		for (int i=0; i<CountOf(MarkColours32); i++)
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), " (%i, %i, %i)", R32(MarkColours32[i]), G32(MarkColours32[i]), B32(MarkColours32[i]));
 			Item = MarkMenu->AppendItem(s,
 										((Select) ? IDM_MARK_SELECT_BASE : IDM_MARK_BASE) + i,
 										(MarkState != 1) || (i != SelectedIndex));
 			if (Item)
 			{
 				Item->Icon(i);
 			}
 		}
 	}
 
 	return MarkMenu;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 char *WrapLines(char *Str, int Len, int WrapColumn)
 {
 	if (Str &&
 		Len > 0 &&
 		WrapColumn > 0)
 	{
 		LMemQueue Temp;
 		int LastWhite = -1;
 		int StartLine = 0;
 		int XPos = 0;
 		int i;
 
 		for (i=0; Str[i] && i<Len; i++)
 		{
 			if (Str[i] == ' ')
 			{
 				int Len = LastWhite - StartLine;
 				if (XPos >= WrapColumn && Len > 0)
 				{
 					Temp.Write((uchar*) Str+StartLine, Len);
 					Temp.Write((uchar*) "\n", 1);
 					XPos = 0;
 					StartLine = StartLine + Len + 1;
 					LastWhite = -1;
 				}
 				else
 				{
 					LastWhite = i;
 					XPos++;
 				}
 			}
 			else if (Str[i] == '\t')
 			{
 				XPos = ((XPos + 7) / 8) * 8;
 			}
 			else if (Str[i] == '\n')
 			{
 				Temp.Write((uchar*) Str+StartLine, i - StartLine + 1);
 				XPos = 0;
 				StartLine = i+1;
 			}
 			else
 			{
 				XPos++;
 			}
 		}
 
 		Temp.Write((uchar*) Str+StartLine, i - StartLine + 1);
 
 		int WrapLen = (int)Temp.GetSize();
 		char *Wrapped = new char[WrapLen+1];
 		if (Wrapped)
 		{
 			Temp.Read((uchar*) Wrapped, WrapLen);
 			Wrapped[WrapLen] = 0;
 
 			return Wrapped;
 		}
 	}
 
 	return Str;
 }
 
 char *DeHtml(const char *Str)
 {
 	char *r = 0;
 	if (Str)
 	{
 		LMemQueue Buf;
 		char Buffer[256];
 
 		auto s = Str;
 		while (s && *s)
 		{
 			// Search for start of next tag
 			const char *Start = s;
 			const char *End = Start;
 			for (; *End && *End != '<'; End++);
 			
 			// Push pre-tag data onto pipe
 			size_t Len = End-Start;
 			for (size_t i=0; i<Len; )
 			{
 				size_t n;
 				for (n=0; n<sizeof(Buffer) && i<Len; i++)
 				{
 					if (Start[i] != '\n' &&
 						Start[i] != '\r' &&
 						Start[i] != '\t')
 					{
 						if (_strnicmp(Start+i, "&nbsp", 5) == 0)
 						{
 							Buffer[n++] = ' ';
 							i += 5;
 							if (Start[i] != ';') i--;
 						}
 						else if (_strnicmp(Start+i, "&copy", 4) == 0)
 						{
 							Buffer[n++] = 'c';
 							i += 5;
 							if (Start[i] != ';') i--;
 						}
 						else
 						{
 							Buffer[n++] = Start[i];
 						}
 					}
 					else if (Start[i] == '\n')
 					{
 						Buffer[n++] = ' ';
 					}
 				}
 
 				Buf.Write((uchar*)Buffer, n);
 			}
 
 			if (*End == '<')
 			{
 				char Temp[32];
 				int n;
 				End++;
 				for (n=0;
 					n<sizeof(Temp)-1 &&
 					End[n] &&
 					End[n] != ' ' &&
 					End[n] != '>';
 					n++)
 				{
 					Temp[n] = End[n];
 				}
 				Temp[n] = 0;
 
 				if (_stricmp(Temp, "br") == 0 ||
 					_stricmp(Temp, "li") == 0)
 				{
 					Buf.Write((uchar*) "\n", 1);
 				}
 				else if (_stricmp(Temp, "p") == 0 ||
 						 _stricmp(Temp, "/tr") == 0 ||
 						 _stricmp(Temp, "/ul") == 0)
 				{
 					Buf.Write((uchar*) "\n\n", 2);
 				}
 			}
 
 			// Start to end of tag
 			for (; *End && *End != '>'; End++);
 			s = End + 1;
 		}
 
 		int Len = (int)Buf.GetSize();
 		r = new char[Len+1];
 		if (r)
 		{
 			Buf.Read((uchar*)r, Len);
 			r[Len] = 0;
 		}
 	}
 
 	return r;
 }
 
 char *ExtractCodePage(char *ContentType)
 {
 	// int Status = -1;
 
 	if (ContentType)
 	{
 		const char *Match = "charset=";
 		char *Charset = stristr(ContentType, Match);
 		if (Charset)
 		{
 			Charset += strlen(Match);
 			char Delim = ' ';
 			if (*Charset == '\'' ||
 				*Charset == '\"')
 			{
 				Delim = *Charset++;
 			}
 
 			char Str[256];
 			char *Out = Str;
 			while (	*Charset &&
 					*Charset != Delim &&
 					*Charset != ';')
 			{
 				*Out++ = *Charset++;
 			}
 			*Out++ = 0;
 
 			return ValidStr(Str) ? NewStr(Str) : 0;
 		}
 	}
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 extern ItemFieldDef CalendarFields[];
 extern ItemFieldDef FilterFieldDefs[];
 extern ItemFieldDef GroupFieldDefs[];
 
 ItemFieldDef *FieldLists[] =
 {
 	MailFieldDefs,
 	ContactFieldDefs,
 	CalendarFields,
 	FilterFieldDefs,
 	GroupFieldDefs,
 	0
 };
 
 ItemFieldDef *GetFieldDefByName(char *Name)
 {
 	if (Name)
 	{
 		static LHashTbl<ConstStrKey<char,false>, ItemFieldDef*> Lut(256);
 		if (Lut.Length() == 0)
 		{
 			for (ItemFieldDef **l=FieldLists; *l; l++)
 			{
 				for (ItemFieldDef *i = *l; i->FieldId; i++)
 				{
 					if (i->Option)
 						Lut.Add(i->Option, i);
 				}
 			}
 		}
 
 		return (ItemFieldDef*) Lut.Find(Name);
 	}
 
 	return 0;
 }
 
 static bool FieldLutInit = false;
 static LArray<ItemFieldDef*> IdToFieldLut;
 
 ItemFieldDef *GetFieldDefById(int Id)
 {
 	if (!FieldLutInit)
 	{
 		FieldLutInit = true;
 
 		for (ItemFieldDef **l=FieldLists; *l; l++)
 		{
 			for (ItemFieldDef *i = *l; i->FieldId; i++)
 			{
 				IdToFieldLut[i->FieldId] = i;
 			}
 		}
 	}
 
 	if (Id >= 0 && Id < (int)IdToFieldLut.Length())
 		return IdToFieldLut[Id];
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 void Log(char *File, char *Str, ...)
 {
 	#if defined WIN32
 	const char *DefFile = "c:\\temp\\list.txt";
 	#else
 	const char *DefFile = "/home/list.txt";
 	#endif
 
 	if (Str)
 	{
 		LFile f;
 		if (f.Open((File) ? File : DefFile, O_WRITE))
 		{
 			char Buf[1024];
 			va_list Arg;
 
 			va_start(Arg, Str);
 			vsprintf_s(Buf, sizeof(Buf), Str, Arg);
 			va_end(Arg);
 
 			f.Seek(0, SEEK_END);
 			f.Write(Buf, (int)strlen(Buf));
 		}
 	}
 	else
 	{
 		LFile f;
 		if (f.Open((File) ? File : DefFile, O_WRITE))
 		{
 			f.SetSize(0);
 		}
 	}
 }
 
 char *NewPropStr(LOptionsFile *Options, char *Name)
 {
 	LVariant n;
 	if (Options->GetValue(Name, n) && n.Str() && strlen(n.Str()) > 0)
 	{
 		return NewStr(n.Str());
 	}
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Columns of controls
 #define MAILUI_Y						0
 
 #define	IDM_REMOVE_GRTH					1000
 #define IDM_REMOVE_GRTH_SP				1001
 #define IDM_REMOVE_HTML					1002
 #define IDM_CONVERT_B64_TO_BIN			1003
 #define IDM_CONVERT_BIN_TO_B64			1004
 
 #define RECIP_SX						500
 #define ADD_X							(RECIP_X + RECIP_SX + 10)
 #ifdef MAC
 #define	ADD_RECIP_BTN_X					36
 #else
 #define	ADD_RECIP_BTN_X					20
 #endif
 
 #define CONTENT_BORDER					3
 
 #if defined WIN32
 
 	#define DLG_X						15
 	#define DLG_Y						30
 
 #else
 
 	#define DLG_X						6
 	#define DLG_Y						6
 
 #endif
 
 MailUi::MailUi(Mail *item, MailContainer *container) :
 	ThingUi(item, LLoadString(IDS_MAIL_MESSAGE)), WorkingDlg(NULL),
 	Sx(0), Sy(0),
 	CmdAfterResize(NULL), MissingCaps(NULL),
 	BtnPrev(NULL), BtnNext(NULL), BtnSend(NULL), BtnSave(NULL), BtnSaveClose(NULL),
 	BtnAttach(NULL), BtnReply(NULL), BtnReplyAll(NULL), BtnForward(NULL), BtnBounce(NULL),
 	GpgUi(NULL), ToPanel(NULL), Entry(NULL), Browse(NULL), SetTo(NULL),
 	To(NULL), Remove(NULL), FromPanel(NULL), FromList(NULL), FromCbo(NULL),
 	ReplyToPanel(NULL), ReplyToChk(NULL), ReplyToCbo(NULL),
 	SubjectPanel(NULL), Subject(NULL), CalendarPanel(NULL), CalPanelStatus(NULL),
 	Tab(NULL), TabText(NULL), TextView(NULL), TabHtml(NULL), HtmlView(NULL),
 	TabAttachments(NULL), Attachments(NULL), TabHeader(NULL), Header(NULL)
 {
 	// Init everything to 0
 	Container = container;
 	if (!item || !item->App)
 	{
 		LAssert(!"Invalid ptrs");
 		return;
 	}
 
 	AddMode = MAIL_ADDR_TO;
 	CurrentEditCtrl = -1;
 	MetaFieldsDirty = IgnoreShowImgNotify = HtmlCtrlDirty = TextCtrlDirty = TextLoaded = HtmlLoaded = false;
 
     // This allows us to hook iconv conversion events
     LFontSystem::Inst()->Register(this);
     
     // This allows us to hook missing image library events
     GdcD->Register(this);
 
 	// Read/Write access
 	bool ReadOnly = !TestFlag(GetItem()->GetFlags(), MAIL_CREATED | MAIL_BOUNCE);
 	int MinButY = 0;
 
 	// Get position
 	LRect r(150, 150, 800, 750);
 	SetPos(r);
 	int FontHeight = GetFont()->GetHeight();
 
 	LVariant v;
 	LOptionsFile *Options = App ? App->GetOptions() : 0;
 	if (Options)
 	{
 		if (Options->GetValue("MailUI.Pos", v))
 		{
 			r.SetStr(v.Str());
 		}
 	}
 	SetPos(r);
 	MoveSameScreen(App);
 
 	Name(LLoadString(IDS_MAIL_MESSAGE));
 
 	#if WINNATIVE
 	CreateClassW32("Scribe::MailUi", LoadIcon(LProcessInst(), MAKEINTRESOURCE(IDI_MAIL)));
 	#endif
 	bool IsCreated = TestFlag(GetItem()->GetFlags(), MAIL_CREATED);
 
 	if (Attach(0))
 	{
 		DropTarget(true);
 
 		// Setup main toolbar
 		Commands.Toolbar = App->LoadToolbar(this,
 											App->GetResourceFile(ResToolbarFile),
 											App->GetToolbarImgList());
 		if (Commands.Toolbar)
 		{
 			Commands.Toolbar->Raised(false);
 			Commands.Toolbar->Attach(this);
 
 			BtnSend = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SEND)), IDM_SEND_MSG, TBT_PUSH, !ReadOnly, IMG_SEND);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnSave = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE)), IDM_SAVE, TBT_PUSH, !ReadOnly, IMG_SAVE);
 			BtnSaveClose = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SAVE_CLOSE)), IDM_SAVE_CLOSE, TBT_PUSH, !ReadOnly, IMG_SAVE_AND_CLOSE);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_DELETE)), IDM_DELETE_MSG, TBT_PUSH, true, IMG_TRASH);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_SPAM)), IDM_DELETE_AS_SPAM, TBT_PUSH, true, IMG_DELETE_SPAM);
 			BtnAttach = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_ATTACH_FILE)), IDM_ATTACH_FILE, TBT_PUSH, !ReadOnly, IMG_ATTACH_FILE);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnReply = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_REPLY)), IDM_REPLY, TBT_PUSH, ReadOnly, IMG_REPLY);
 			BtnReplyAll = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_REPLYALL)), IDM_REPLY_ALL, TBT_PUSH, ReadOnly, IMG_REPLY_ALL);
 			BtnForward = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_FORWARD)), IDM_FORWARD, TBT_PUSH, ReadOnly, IMG_FORWARD);
 			BtnBounce = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_BOUNCE)), IDM_BOUNCE, TBT_PUSH, ReadOnly, IMG_BOUNCE);
 			Commands.Toolbar->AppendSeparator();
 
 			BtnPrev = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_PREV_MSG)), IDM_PREV_MSG, TBT_PUSH, true, IMG_PREV_ITEM);
 			BtnNext = Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_NEXT_MSG)), IDM_NEXT_MSG, TBT_PUSH, true, IMG_NEXT_ITEM);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_HIGH_PRIORITY)), IDM_HIGH_PRIORITY, TBT_TOGGLE, true, IMG_HIGH_PRIORITY);
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_LOW_PRIORITY)), IDM_LOW_PRIORITY, TBT_TOGGLE, true, IMG_LOW_PRIORITY);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_READ_RECEIPT)), IDM_READ_RECEIPT, TBT_TOGGLE, true, IMG_READ_RECEIPT);
 			Commands.Toolbar->AppendSeparator();
 
 			Commands.Toolbar->AppendButton(RemoveAmp(LLoadString(IDS_PRINT)), IDM_PRINT, TBT_PUSH, true, IMG_PRINT);
 
 			for (LViewI *w: Commands.Toolbar->IterateViews())
 				MinButY = MAX(MinButY, w->Y());
 
 			Commands.Toolbar->Customizable(App->GetOptions(), "MailWindowToolbar");
 			Commands.SetupCallbacks(App, this, GetItem(), LThingUiToolbar);
 		}
 
 		// Setup to/from panels
 		LVariant AlwaysShowFrom;
 		if (IsCreated)
 			App->GetOptions()->GetValue(OPT_MailShowFrom, AlwaysShowFrom);
 
 		bool ShowFrom = !IsCreated &&
 						!TestFlag(GetItem()->GetFlags(), MAIL_BOUNCE);
 
 		LDisplayString Recip(LSysFont, LLoadString(IDS_RECIPIENTS));
 		LAutoPtr<LCheckBox> ReplyChk(new LCheckBox(IDC_USE_REPLY_TO, 21,
 													#ifdef MAC
 													1,
 													#else
 													6,
 													#endif
 													-1, -1, "Reply To"));
 		int ReplyChkPx = ReplyChk ? ReplyChk->X() : 0;
 		int RECIP_X = 20 + MAX(ReplyChkPx, Recip.X()) + 10;
 		int EditHeight = FontHeight + 6;
 
 		LVariant HideGpg;
 		if (!item->App->GetOptions()->GetValue(OPT_HideGnuPG, HideGpg) ||
 			HideGpg.CastInt32() == 0)
 		{
 			GpgUi = new MailUiGpg(	App,
 									this,
 									21,
 									RECIP_X,
 									!ReadOnly && !TestFlag(GetItem()->GetFlags(), MAIL_SENT));
 			if (GpgUi)
 				GpgUi->Attach(this);
 		}
 		
 		ToPanel = new LPanel(LLoadString(IDS_TO), FontHeight * 8, !ShowFrom);
 		if (ToPanel)
 		{
 		    int Cy = 4;
 			ToPanel->AddView(SetTo = new LCombo(IDC_SET_TO, 20, Cy, 60, EditHeight, 0));
 			if (SetTo)
 			{
 				SetTo->Insert(LLoadString(IDS_TO));
 				SetTo->Insert(LLoadString(IDS_CC));
 				SetTo->Insert(LLoadString(IDS_BCC));
 				
 				if (SetTo->GetPos().x2 + 10 > RECIP_X)
 				    RECIP_X = SetTo->GetPos().x2 + 10;
 			}
 			
 			ToPanel->AddView(Entry = new LEdit(IDC_ENTRY, RECIP_X, Cy, RECIP_SX, EditHeight, ""));
 			
 			Cy = SetTo->GetPos().y2 + 5;
 
 			ToPanel->AddView(To = new AddressList(App, IDC_TO, RECIP_X, Cy, RECIP_SX, ToPanel->GetOpenSize() - Cy - 6));
 			if (To)
 				To->SetImageList(App->GetIconImgList(), false);
 			ToPanel->AddView(new LTextLabel(IDC_STATIC, 20, Cy, -1, -1, LLoadString(IDS_RECIPIENTS)));
 			
 			ToPanel->Raised(false);
 			ToPanel->Attach(this);
 		}
 
 		FromPanel = new LPanel(LLoadString(IDS_FROM), FontHeight + 13, AlwaysShowFrom.CastInt32() || ShowFrom);
 		if (FromPanel)
 		{
 			FromPanel->AddView(new LTextLabel(IDC_STATIC, 21,
 										#ifdef MAC
 										8,
 										#else
 										4,
 										#endif
 										-1, -1, LLoadString(IDS_FROM)));
 
 			if (ShowFrom)
 			{
 				FromPanel->AddView(FromList = new AddressList(App, IDC_FROM, RECIP_X, 2, RECIP_SX, EditHeight));
 			}
 			else
 			{
 				FromPanel->AddView(FromCbo = new LCombo(IDC_FROM, RECIP_X, 2, RECIP_SX, EditHeight, 0));
 			}
 
 			if (IsCreated)
 			{
 				LCheckBox *Chk;
 				auto Label = LLoadString(IDS_ALWAYS_SHOW);
 				FromPanel->AddView(Chk = new LCheckBox(IDC_SHOW_FROM, ADD_X,
 														#ifdef MAC
 														1,
 														#else
 														6,
 														#endif
 														-1, -1, Label));
 				if (Chk) Chk->Value(AlwaysShowFrom.CastInt32());
 			}
 
 			FromPanel->Raised(false);
 			FromPanel->Attach(this);
 		}
 
 		ReplyToPanel = new LPanel("Reply To:", FontHeight + 13, false);
 		if (ReplyToPanel)
 		{
 			ReplyToPanel->Raised(false);
 			ReplyToPanel->AddView(ReplyToChk = ReplyChk.Release());
 			ReplyToPanel->AddView(ReplyToCbo = new LCombo(IDC_REPLY_TO_ADDR, RECIP_X, 2, RECIP_SX, EditHeight, 0));
 			ReplyToPanel->Attach(this);
 		}
 
 		SubjectPanel = new LPanel(LLoadString(IDS_SUBJECT), -(LSysFont->GetHeight() + 16));
 		if (SubjectPanel)
 		{
 			SubjectPanel->Raised(false);
 			SubjectPanel->AddView(			new LTextLabel(IDC_STATIC, 21, 8, -1, -1, LLoadString(IDS_SUBJECT)));
 			SubjectPanel->AddView(Subject = new LEdit(IDC_SUBJECT, RECIP_X, 4, RECIP_SX, EditHeight, ""));
 			SubjectPanel->Attach(this);
 		}
 
 		CalendarPanel = new LPanel(LLoadString(IDC_CALENDAR), -(LSysFont->GetHeight() + 16), false);
 		if (CalendarPanel)
 		{
 			CalendarPanel->Raised(false);
 			LTableLayout *t = new LTableLayout(IDC_TABLE);
 			if (t)
 			{
 				t->GetCss(true)->Margin(LCss::Len(LCss::LenPx, LTableLayout::CellSpacing));
 				t->GetCss()->Width(LCss::LenAuto);
 				t->GetCss()->Height(LCss::LenAuto);
 
 				CalendarPanel->AddView(t);
 				auto c = t->GetCell(0, 0);
 				
 				c->Width(LCss::Len(LCss::LenPx, RECIP_X - (LTableLayout::CellSpacing * 2)));
 				c->PaddingLeft(LCss::Len(LCss::LenPx, 21 - LTableLayout::CellSpacing));
 				c->Debug = true;
 
 				c->Add(new LTextLabel(IDC_STATIC, 0, 0, -1, -1, LLoadString(IDS_CALENDAR)));
 				c = t->GetCell(1, 0);
 				c->Add(new LButton(IDC_ADD_CAL_EVENT, 0, 0, -1, -1, LLoadString(IDS_ADD_CAL)));
 				c = t->GetCell(2, 0);
 				c->Add(new LButton(IDC_ADD_CAL_EVENT_POPUP, 0, 0, -1, -1, LLoadString(IDS_ADD_CAL_POPUP)));
 				c = t->GetCell(3, 0);
 				c->Add(CalPanelStatus = new LTextLabel(IDC_STATIC, 0, 0, -1, -1, NULL));
 			}
 
 			CalendarPanel->Attach(this);
 		}
 
 		Tab = new LTabView(IDC_MAIL_UI_TABS, 0, 0, 1000, 1000, 0);
 		if (Tab)
 		{
 			Tab->GetCss(true)->PaddingTop("3px");
 
 			// Don't attach text and html controls here, because OnLoad will do it later...
 			TabText = Tab->Append(LLoadString(IDS_TEXT));
 			TabHtml = Tab->Append("HTML");
 
 			TabAttachments = Tab->Append(LLoadString(IDS_ATTACHMENTS));
 			TabHeader = Tab->Append(LLoadString(IDS_INTERNETHEADER));
 
 			if (TabAttachments)
 			{
 				TabAttachments->Append(Attachments = new AttachmentList(IDC_ATTACHMENTS,
 																		CONTENT_BORDER,
 																		CONTENT_BORDER,
 																		200,
 																		200,
 																		this));
 
 				if (Attachments)
 				{
 					Attachments->AddColumn(LLoadString(IDS_FILE_NAME), 160);
 					Attachments->AddColumn(LLoadString(IDS_SIZE), 80);
 					Attachments->AddColumn(LLoadString(IDS_MIME_TYPE), 100);
 					Attachments->AddColumn(LLoadString(IDS_CONTENT_ID), 250);
 				}
 			}
 
 			if (TabHeader)
 			{
 				TabHeader->Append(Header = new LTextView3(	IDC_INTERNET_HEADER,
 															CONTENT_BORDER,
 															CONTENT_BORDER,
 															100,
 															20));
 				if (Header)
 				{
 					Header->Sunken(true);
 				}
 			}
 
 			LTabPage *Fields = Tab->Append(LLoadString(IDS_FIELDS));
 			if (Fields)
 			{
 				Fields->LoadFromResource(IDD_MAIL_FIELDS);
 				
 				LTableLayout *l;
 				if (GetViewById(IDC_TABLE, l))
 				{
 				    l->SetPourLargest(false);
 				}
 			}
 
 			Tab->Attach(this);
 
 			// Colours
 			LColourSelect *Colour;
 			if (GetViewById(IDC_COLOUR, Colour))
 			{
 				LArray<LColour> c32;
 				for (int i=0; i<CountOf(MarkColours32); i++)
 					c32.New().Set(MarkColours32[i], 32);
 				Colour->SetColourList(&c32);
 			}
 			else LAssert(!"No colour control?");
 		}
 
 		PourAll();
 
 		if (Commands.Toolbar)
 		{
 			if (ToPanel)
 				ToPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 			if (FromPanel)
 				FromPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 			if (ReplyToPanel)
 				ReplyToPanel->SetClosedSize(Commands.Toolbar->Y()-1);
 		}
 
 		SetIcon("About64px.png");
 		OnLoad();
 		_Running = true;
 		Visible(true);
 		RegisterHook(this, LKeyEvents);
 		LResources::StyleElement(this);
 	}
 }
 
 MailUi::~MailUi()
 {
 	DeleteObj(TextView);
 
 	if (Attachments)
 	{
 		Attachments->RemoveAll();
 	}
 	LOptionsFile *Options = (GetItem() && App) ? App->GetOptions() : 0;
 	if (Options)
 	{
 		LRect p = GetPos();
 		if (p.x1 >= 0 &&
 			p.y1 >= 0)
 		{
 			LVariant v = p.GetStr();
 			Options->SetValue("MailUI.Pos", v);
 		}
 	}
 
 	Tab = 0;
 	if (GetItem())
 	{
 		GetItem()->Ui = NULL;
 	}
 	else LgiTrace("%s:%i - Error: no item to clear UI ptr?\n", _FL);
 
 	// We delete the LView here because objects
 	// need to have their virtual tables intact
 	_Delete();
 }
 
 Mail *MailUi::GetItem()
 {
 	return _Item ? _Item->IsMail() : 0;
 }
 
 void MailUi::SetItem(Mail *m)
 {
 	if (_Item)
 	{
 		Mail *old = _Item->IsMail();
 		if (old)
 			old->Ui = NULL;
 		else
 			LAssert(0);
 		_Item = NULL;
 	}
 
 	if (m)
 	{
 		_Item = m;
 		m->Ui = this;
 	}
 }
 
 bool MailUi::SetDirty(bool Dirty, bool Ui)
 {
 	bool b = ThingUi::SetDirty(Dirty, Ui);
 	
 	if (MetaFieldsDirty && !Dirty)
 	{
 		Mail *m = GetItem();
 		if (m)
 		{
 			LColourSelect *Colour;
 			if (GetViewById(IDC_COLOUR, Colour))
 			{
 				uint32_t Col = (uint32_t)Colour->Value();
 				m->SetMarkColour(Col);
 			}
 			else LgiTrace("%s:%i - Can't find IDC_COLOUR\n", _FL);
 
 			auto s = GetCtrlName(IDC_LABEL);
 			m->SetLabel(s);
 			
 			if (m->GetObject()->GetInt(FIELD_STORE_TYPE) != Store3Imap) // Imap knows to save itself.
 				m->SetDirty();
 			m->Update();
 		}
 		
 		MetaFieldsDirty = false;
 	}
 	
 	return b;
 }
 
 #define IDM_FILTER_BASE		2000
 #define IDM_CHARSET_BASE	3000
 void AddActions(LSubMenu *Menu, List<Filter> &Filters, LArray<ScribeFolder*> Folders)
 {
 	if (!Menu)
 		return;
 
 	auto StartLen = Menu->Length();
 
 	for (auto Folder: Folders)
 	{
 		for (ScribeFolder *f=Folder->GetChildFolder(); f; f=f->GetNextFolder())
 		{
 			auto Sub = Menu->AppendSub(f->GetName(true));
 			if (Sub)
 			{
 				auto Item = Sub->GetParent();
 				if (Item) Item->Icon(ICON_CLOSED_FOLDER);
 				Sub->SetImageList(Menu->GetImageList(), false);
 				f->LoadThings();
 				AddActions(Sub, Filters, {f});
 			}
 		}
 
 		List<Filter> a;
 		Folder->LoadThings();
 		for (auto t: Folder->Items)
 		{
 			a.Insert(t->IsFilter());
 		}
 
 		a.Sort(FilterCompare);
 
 		for (auto i: a)
 		{
 			LVariant Name;
 			if (i->GetVariant("Name", Name) && Name.Str())
 			{
 				char n[256];
 				strcpy_s(n, sizeof(n), Name.Str());
 				for (char *s=n; *s; s++)
 				{
 					if (*s == '&')
 					{
 						memmove(s + 1, s, strlen(s)+1);
 						s++;
 					}
 				}
 
 				auto Item = Menu->AppendItem(n, (int) (IDM_FILTER_BASE + Filters.Length()), true);
 				if (Item)
 				{
 					Item->Icon(ICON_FILTER);
 					Filters.Insert(i);
 				}
 			}
 		}
 	}
 
 	if (StartLen == Menu->Length())
 	{
 		char s[64];
 		sprintf_s(s, sizeof(s), "(%s)", LLoadString(IDS_EMPTY));
 		Menu->AppendItem(s, 0, false);
 	}
 }
 
 bool MailUi::OnViewKey(LView *v, LKey &k)
 {
 	if (k.Down() && k.CtrlCmd() && !k.Alt())
 	{
 		switch (k.vkey)
 		{
 			case LK_RETURN:
 			{
 				PostEvent(M_COMMAND, IDM_SEND_MSG);
 				return true;
 			}
 			case LK_UP:
 			{
 				SeekMsg(-1);
 				return true;
 			}
 			case LK_DOWN:
 			{
 				SeekMsg(1);
 				return true;
 			}
 		}
 		switch (k.c16)
 		{
 			case 'p':
 			case 'P':
 			{
 				App->ThingPrint(NULL, GetItem(), NULL, this);
 				break;
 			}
 			case 'f':
 			case 'F':
 			{
 				if (Tab->Value() == 0)
 				{
 					if (TextView)
 						TextView->DoFind(NULL);
 				}
 				else if (Tab->Value() == 1)
 				{
 					if (HtmlView)
 						HtmlView->DoFind(NULL);
 				}
 				break;
 			}
 			case 'r':
 			case 'R':
 			{
 				OnCommand(IDM_REPLY, 0, NULL);
 				return true;
 			}
 			case 'w':
 			case 'W':
 			{
 				if (OnRequestClose(false))
 					Quit();
 				return true;
 			}
 			case 's':
 			case 'S':
 			{
 				if (IsDirty())
 				{
 					SetDirty(false);
 				}
 				return true;
 			}
 			case 't':
 			case 'T':
 			{
 				Tab->Value(0);
 				if (TextView) TextView->Focus(true);
 				return true;
 			}
 			case 'h':
 			case 'H':
 			{
 				Tab->Value(1);
 				if (HtmlView) HtmlView->Focus(true);
 				return true;
 			}
 		}
 	}
 
 	return ThingUi::OnViewKey(v, k);
 }
 
 void MailUi::SerializeText(bool FromCtrl)
 {
 	if (GetItem() && TextView)
 	{
 		if (FromCtrl)
 		{
 			GetItem()->SetBody(TextView->Name());
 		}
 		else
 		{
 			TextView->Name(GetItem()->GetBody());
 		}
 	}
 }
 
 const char *FilePart(const char *Uri)
 {
 	const char *Dir = Uri + strlen(Uri) - 1;
 	while (Dir > Uri &&
 		Dir[-1] != '/' &&
 		Dir[-1] != '\\')
 	{
 		Dir--;
 	}
 	
 	return Dir;
 }
 
 void MailUi::OnAttachmentsChange()
 {
 	Attachments->ResizeColumnsToContent();
 
 	if (GetItem())
 	{
 		TabAttachments->GetCss(true)->FontBold(GetItem()->Attachments.Length() > 0);
 		TabAttachments->OnStyleChange();
 	}
 }
 
 bool MailUi::NeedsCapability(const char *Name, const char *Param)
 {
     if (!InThread())
     {
         PostEvent(M_NEEDS_CAP, (LMessage::Param)NewStr(Name));
     }
     else
     {
         if (!Name)
             return false;
             
         if (Caps.Find(Name))
             return true;
 
         Caps.Add(Name, true);
 
 	    char msg[256];
 		LArray<const char *> Actions;
 		LAutoPtr<LColour> Back;
 	    
 	    if (!_stricmp(Name, "RemoteContent"))
 	    {
 			Actions.Add(LLoadString(IDS_ALWAYS_SHOW_REMOTE_CONTENT));
 			Actions.Add(LLoadString(IDS_SHOW_REMOTE_CONTENT));
 
 			Back.Reset(new LColour(L_LOW));
 			strcpy_s(msg, sizeof(msg),
 					LLoadString
 					(
 						IDS_REMOTE_CONTENT_MSG,
 						"To protect your privacy Scribe has blocked the remote content in this message."
 					));
 	    }
 	    else
 	    {
 			Actions.Add(LLoadString(IDS_INSTALL));
 			int ch = 0;
 			for (auto k : Caps)
 				ch += sprintf_s(msg+ch, sizeof(msg)-ch, "%s%s", ch?", ":"", k.key);
 			ch += sprintf_s(msg+ch, sizeof(msg)-ch, " is required to display this content.");
 		}
     		
         if (!MissingCaps)
         {
             MissingCaps = new MissingCapsBar(this, &Caps, msg, App, Actions, Back);
 
 			auto c = IterateViews();
 			auto Idx = c.IndexOf(GpgUi);
 			AddView(MissingCaps, (int)Idx+1);
             AttachChildren();
             OnPosChange();
         }
         else
         {
 		    MissingCaps->SetMsg(msg);
         }
     }
 
     return true;
 }
 
 void MailUi::OnCloseInstaller()
 {
 	if (MissingCaps)
 	{
 		DeleteObj(MissingCaps);
 		PourAll();
 	}
 }
 
 void MailUi::OnInstall(LCapabilityTarget::CapsHash *Caps, bool Status)
 {
 }
 
 void MailUi::OnChildrenChanged(LViewI *Wnd, bool Attaching)
 {
 	if (Wnd == (LViewI*)MissingCaps &&
 		!Attaching)
 	{
 		MissingCaps = NULL;
 		PourAll();
 	}
 }
 
 LDocView *MailUi::GetDoc(const char *MimeType)
 {
 	if (!MimeType)
 	{
 		MimeType = sTextPlain;
 		LVariant v;
 		if (App->GetOptions()->GetValue(OPT_DefaultAlternative, v) &&
 			v.CastInt32() > 0)
 			MimeType = sTextHtml;
 	}
 	
 	LAssert(MimeType != NULL);
 	
 	if (!_stricmp(MimeType, sTextPlain))
 		return TextView;
 	else if (!_stricmp(MimeType, sTextHtml))
 		return HtmlView;
 	else
 		LAssert(!"Invalid mime type.");
 	
 	return NULL;
 }
 
 bool MailUi::SetDoc(LDocView *v, const char *MimeType)
 {
 	if (!MimeType)
 	{
 		MimeType = sTextPlain;
 		LVariant v;
 		if (App->GetOptions()->GetValue(OPT_DefaultAlternative, v) &&
 			v.CastInt32() > 0)
 			MimeType = sTextHtml;
 	}
 	
 	LAssert(MimeType != NULL);
 
 	if (!_stricmp(MimeType, sTextPlain))
 	{
 		LTextView3 *Txt = static_cast<LTextView3*>(v);
 		if (Txt)
 		{
 			if (Txt != TextView)
 			{
 				DeleteObj(TextView);
 				TextView = Txt;
 				if (TabText && !TextView->IsAttached())
 					TabText->Append(TextView);
 			}
 			TextLoaded = true;
 			if (_Running)
 				TabText->Select();
 		}
 		else
 		{
 			LAssert(!"Invalid ctrl.");
 			return false;
 		}
 	}
 	else if (!_stricmp(MimeType, sTextHtml))		
 	{
 		LDocView *Html = dynamic_cast<LDocView*>(v);
 		if (Html)
 		{
 			if (Html != HtmlView)
 			{
 				DeleteObj(HtmlView);
 				HtmlView = Html;
 
 				LCapabilityClient *cc = dynamic_cast<LCapabilityClient*>(v);
 				if (cc)
 					cc->Register(this);
 
 				if (TabHtml && !HtmlView->IsAttached())
 					TabHtml->Append(HtmlView);
 			}
 			HtmlLoaded = true;
 			if (_Running)
 				TabHtml->Select();
 		}
 		else
 		{
 			LAssert(!"Invalid ctrl.");
 			return false;
 		}
 	}
 	else
 	{
 		LAssert(!"Invalid mime type.");
 		return false;
 	}
 
     return true;
 }
 
 bool MailUi::IsWorking(int Set)
 {
 	if (!GetItem())
 		return false;
 
 	// Are any of the attachments busy doing something?
 	LDataI *AttachPoint = GetItem() && Set >= 0 ? GetItem()->GetFileAttachPoint() : NULL;
 
 	List<Attachment> Attachments;
 	if (GetItem()->GetAttachments(&Attachments))
 	{
 		// Attachment *Match = NULL;
 		for (auto a: Attachments)
 		{
 			if (Set >= 0)
 			{
 				a->SetIsResizing(Set != 0);
 				if (AttachPoint)
 				{
 					a->GetObject()->Save(AttachPoint);
 				}
 			}
 			else if (a->GetIsResizing())
 			{
 				return true;
 			}
 		}
 	}
 	
 	// Check rich text control as well...
 	auto Rte = dynamic_cast<LRichTextEdit*>(HtmlView);
 	if (Rte)
 	{
 		if (Rte->IsBusy())
 		{
 			return true;
 		}
 	}
 
 	return false;
 }
 
 class BusyPanel : public LPanel
 {
 public:
 	BusyPanel() : LPanel("Working...", LSysFont->GetHeight() << 1)
 	{
 		LViewI *v;
 		LCss::ColorDef Bk(LColour(255, 128, 0));
 		GetCss(true)->BackgroundColor(Bk);
 
 		AddView(v = new LTextLabel(IDC_STATIC, 30, 5, -1, -1, "Still resizing images..."));
 		v->GetCss(true)->BackgroundColor(Bk);
 
 		AddView(v = new LButton(IDCANCEL, 200, 3, -1, -1, LLoadString(IDS_CANCEL)));
 		v->GetCss(true)->NoPaintColor(Bk);
 	}
 };
 
 void MailUi::SetCmdAfterResize(int Cmd)
 {
 	if (CmdAfterResize == 0)
 	{
 		CmdAfterResize = Cmd;
 		if (!WorkingDlg)
 		{
 			WorkingDlg = new BusyPanel;
 			if (WorkingDlg)
 			{
 				AddView(WorkingDlg, 1);
 				AttachChildren();
 				OnPosChange();
 			}
 		}
 	}
 }
 
 bool MailUi::OnRequestClose(bool OsClose)
 {
 	bool Working = IsWorking();
 	if (Working)
 	{
 		SetCmdAfterResize(IDM_SAVE_CLOSE);
 		return false;
 	}
 	
 	return ThingUi::OnRequestClose(OsClose);
 }
 
 void MailUi::OnChange()
 {
 	if (!IsDirty())
 		OnLoad();
 }
 
 struct MailUiNameAddr
 {
 	LString Name, Addr;
 	
 	MailUiNameAddr(const char *name = 0, const char *addr = 0)
 	{
 		Name = name;
 		Addr = addr;
 	}
 };
 
 void MailUi::OnLoad()
 {
 	bool Edit = false;
 	bool ReadOnly = true;
 	Mail *Item = GetItem();
 
 	_Running = false;
 
 	if (Item &&
 		Item->App)
 	{
 		Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 		ReadOnly = !TestFlag(Item->GetFlags(), MAIL_CREATED | MAIL_BOUNCE);
 
 		if (Entry)
 		{
 			Entry->Name("");
 		}
 
 		if (To)
 		{
 			To->OnInit(Item->GetTo());
 		}
 
 		if (FromCbo)
 		{
 			LHashTbl<StrKey<char,false>, MailUiNameAddr*> ReplyToAddrs;
 			const char *Template = "%s <%s>";
 			FromCbo->Empty();
 
 			int Idx = -1;
 			LVariant DefName, DefAddr;
 
 			// LOptionsFile *Opts = Item->Window->GetOptions();
 			for (auto a : *Item->App->GetAccounts())
 			{
 				LVariant Name = a->Identity.Name();
 				LVariant Addr = a->Identity.Email();
 				LVariant ReplyTo = a->Identity.ReplyTo();
 				
 				if (!a->IsValid() || a->Send.Disabled())
 					continue;
 				
 				if (ReplyTo.Str())
 				{
 					if (!ReplyToAddrs.Find(ReplyTo.Str()))
 						ReplyToAddrs.Add(ReplyTo.Str(), new MailUiNameAddr(Name.Str(), ReplyTo.Str()));
 				}
 				else if (Addr.Str())
 				{
 					if (!ReplyToAddrs.Find(Addr.Str()))
 						ReplyToAddrs.Add(Addr.Str(), new MailUiNameAddr(Name.Str(), Addr.Str()));
 				}
 
 				if (Name.Str() && Addr.Str())
 				{
 					if (!DefAddr.Str() ||
 						_stricmp(DefAddr.Str(), Addr.Str()))
 					{
 						auto FromAddr = Item->GetFromStr(FIELD_EMAIL);
 						if (FromAddr && _stricmp(Addr.Str(), FromAddr) == 0)
 						{
 							Idx = (int)FromCbo->Length();
 						}
 
 						LString p;
 						p.Printf(Template, Name.Str(), Addr.Str());
 						
 						int Id = a->Receive.Id();
 						int CurLen = (int)FromCbo->Length();
 						
 						LAssert(Id != 0);
 						
 						FromAccountId[CurLen] = Id;
 						
 						FromCbo->Insert(p);
 					}
 				}
 			}
 			
 			if (Idx < 0)
 			{
 				auto FromName = Item->GetFromStr(FIELD_NAME);
 				auto FromAddr = Item->GetFromStr(FIELD_EMAIL);
 				if (FromAddr)
 				{
 					LStringPipe p;
 					if (FromName)
 						p.Print(Template, FromName, FromAddr);
 					else
 						p.Print("<%s>", FromAddr);
 					LAutoString s(p.NewStr());
 					FromAccountId[FromCbo->Length()] = -1;
 					Idx = (int)FromCbo->Length();
 					FromCbo->Insert(s);
 					FromCbo->Value(Idx);
 				}
 			}
 			else
 			{
 				FromCbo->Value(Idx);
 			}
 
 			if (ReplyToAddrs.Length() > 0 && ReplyToCbo)
 			{
 				auto CurAddr = Item->GetReply() ? Item->GetReply()->GetStr(FIELD_EMAIL) : NULL;
 				int CurIdx = -1;
 				// for (MailUiNameAddr *na = ReplyToAddrs.First(); na; na = ReplyToAddrs.Next())
 				for (auto na : ReplyToAddrs)
 				{
 					char s[256];
 					sprintf_s(s, sizeof(s), Template, na.value->Name.Get(), na.value->Addr.Get());
 					if (CurAddr && !_stricmp(na.value->Addr, CurAddr))
 						CurIdx = (int)ReplyToCbo->Length();
 					
 					ReplyToCbo->Insert(s);
 				}
 				if (CurIdx >= 0)
 				{
 					ReplyToCbo->Value(CurIdx);
 					ReplyToChk->Value(true);
 				}
 				else
 				{
 					ReplyToChk->Value(false);
 				}
 			}
 			ReplyToAddrs.DeleteObjects();
 		}
 		else if (FromList)
 		{
 			FromList->Empty();
 			ListAddr *na = new ListAddr(App, Item->GetFrom());
 			if (na)
 			{
 				na->CC = MAIL_ADDR_FROM;
 				na->OnFind();
 				FromList->Insert(na);
 			}
 		}
 
 		if (Subject)
 		{
 			Subject->Name(Item->GetSubject());
 			
 			char Title[140];
 			auto Subj = Item->GetSubject();
 			if (Subj)
 				sprintf_s(Title, sizeof(Title), "%s - %.100s", LLoadString(IDS_MAIL_MESSAGE), Subj);
 			else
 				sprintf_s(Title, sizeof(Title), "%s", LLoadString(IDS_MAIL_MESSAGE));
 			Title[sizeof(Title)-1] = 0;
 			for (char *s = Title; *s; s++)
 				if (*s == '\n' || *s == '\r') *s = ' ';
 			Name(Title);
 		}
 
 		int64_t Rgb32 = Item->GetMarkColour();
 		SetCtrlValue(IDC_COLOUR, Rgb32 > 0 ? Rgb32 : -1);
 		SetCtrlName(IDC_LABEL, Item->GetLabel());
 
 		char Date[256];
 		Item->GetDateReceived()->Get(Date, sizeof(Date));
 		SetCtrlName(IDC_RECEIVED_DATE, Date);
 		Item->GetDateSent()->Get(Date, sizeof(Date));
 		SetCtrlName(IDC_SENT_DATE, Date);
 
 		TextLoaded = false;
 		HtmlLoaded = false;
 
 		auto TextContent = Item->GetBody();
 		auto HtmlContent = Item->GetHtml();
 
 		Sx = Sy = -1;
 
 		LDocView *DocView = NULL;
 		if (TabText &&
 			(DocView = Item->CreateView(this, sTextPlain, true, -1, !Edit)))
 		{
 			if (DocView == HtmlView)
 			{
 				// CreateView converted the text to HTML to embed Emojis. If we have
 				// actual HTML content it'll overwrite the text portion, so we need
 				// to move the HTML control to the text tab to leave room for actual HTML.
 				DeleteObj(TextView);
 				TextView = HtmlView;
 				HtmlView = NULL;
 				TextView->Detach();
 				TabText->Append(TextView);
 				TextLoaded = true;
 				HtmlLoaded = false;
 			}
 			
 			if (!TextView && Edit)
 			{
 				// What the? Force creation of control...
 				LAssert(!"Must have an edit control.");
 				LDocView *Dv = App->CreateTextControl(IDC_TEXT_VIEW, sTextPlain, Edit, GetItem());
 				if (Dv)
 					SetDoc(Dv, sTextPlain);
 				LAssert(TextView != NULL);
 			}
 			
 			if (TextView)
 			{
 				TextView->Visible(true);
 				
 				// This needs to be below the resize of the control so that
 				// any wrapping has already been done and thus the scroll
 				// bar is laid out already.
 				if (Item->Cursor > 0)
 					TextView->SetCaret(Item->Cursor, false);
 
 				TabText->GetCss(true)->FontBold(ValidStr(TextContent));
 				TabText->OnStyleChange();
 			}
 		}
 
 		bool ValidHtml = ValidStr(HtmlContent);
 		if (TabHtml &&
 			Item->CreateView(this, sTextHtml, true, -1, !Edit) &&
 			HtmlView)
 		{
 			HtmlView->Visible(true);
 			if (Item->Cursor > 0)
 				HtmlView->SetCaret(Item->Cursor, false);
 
 			TabHtml->GetCss(true)->FontBold(ValidHtml);
 			TabHtml->OnStyleChange();
 		}
 		
 		LVariant DefTab;
 		Item->App->GetOptions()->GetValue(Edit ? OPT_EditControl : OPT_DefaultAlternative, DefTab);
 		CurrentEditCtrl = (Edit || ValidHtml) && DefTab.CastInt32();
 		Tab->Value(CurrentEditCtrl);
 		HtmlCtrlDirty = !ValidHtml;
 		TextCtrlDirty = !ValidStr(TextContent);
 
 		if (CalendarPanel)
 		{
 			auto CalEvents = GetItem()->GetCalendarAttachments();
 			CalendarPanel->Open(CalEvents.Length() > 0);
 		}
 
 		OnPosChange();
 
 		if (Attachments)
 		{
 			Attachments->RemoveAll();
 			
 			List<Attachment> Files;
 			if (Item->GetAttachments(&Files))
 			{
 				for (auto a: Files)
 					Attachments->Insert(a);
 			}
 
 			OnAttachmentsChange();
 		}
 
 		if (Header)
 		{
 			LAutoString Utf((char*)LNewConvertCp("utf-8", Item->GetInternetHeader(), "iso-8859-1"));
 			Header->Name(Utf);
 			Header->SetEnv(Item);
 		}
 
 		bool Update =	(Item->GetFlags() & MAIL_READ) == 0 &&
 						(Item->GetFlags() & MAIL_CREATED) == 0;
 		if (Update)
 		{
 			Item->SetFlags(Item->GetFlags() | MAIL_READ);
 		}
 
 		if (Commands.Toolbar)
 		{
 			int p = Item->GetPriority();
 			Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, p < MAIL_PRIORITY_NORMAL);
 			Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, p > MAIL_PRIORITY_NORMAL);
 			Commands.Toolbar->SetCtrlValue(IDM_READ_RECEIPT, TestFlag(Item->GetFlags(), MAIL_READ_RECEIPT));
 		}
 	}
 
 	if (Item->GetFlags() & (MAIL_CREATED | MAIL_BOUNCE))
 	{
 		if (Entry)
 			Entry->Focus(true);
 	}
 	else
 	{
 		if (TextView)
 			TextView->Focus(true);
 	}
 
 	if (BtnPrev && BtnNext)
 	{
 		if (Item && Container)
 		{
 			/*
 			int Items = Item->GetList()->Length();
 			int i = Item->GetList()->IndexOf(Item);
 			*/
 
 			auto Items = Container->Length();
 			auto i = Container->IndexOf(Item);
 
 			BtnPrev->Enabled(i < (ssize_t)Items - 1);
 			BtnNext->Enabled(i > 0);
 		}
 		else
 		{
 			BtnPrev->Enabled(false);
 			BtnNext->Enabled(false);
 		}
 	}
 
 	if (BtnSend) BtnSend->Enabled(!ReadOnly);
 	if (BtnSave) BtnSave->Enabled(!ReadOnly);
 	if (BtnSaveClose) BtnSaveClose->Enabled(!ReadOnly);
 	if (BtnAttach) BtnAttach->Enabled(!ReadOnly);
 
 	if (BtnReply) BtnReply->Enabled(ReadOnly);
 	if (BtnReplyAll) BtnReplyAll->Enabled(ReadOnly);
 	if (BtnForward) BtnForward->Enabled(true);
 	if (BtnBounce) BtnBounce->Enabled(ReadOnly);
 
 	if (Commands.Toolbar)
 	{
 		Commands.Toolbar->SetCtrlEnabled(IDM_HIGH_PRIORITY, Edit);
 		Commands.Toolbar->SetCtrlEnabled(IDM_LOW_PRIORITY, Edit);
 		Commands.Toolbar->SetCtrlEnabled(IDM_READ_RECEIPT, Edit);
 	}
 
 	_Running = true;
 }
 
 void MailUi::OnSave()
 {
 	if (!GetItem())
 		return;
 
 	if (GetItem()->GetFlags() & MAIL_SENT)
 	{
 		// Save a copy instead of over writing the original sent email
 		Mail *Copy = new Mail(App, GetItem()->GetObject()->GetStore()->Create(MAGIC_MAIL));
 		if (Copy)
 		{
 			*Copy = *_Item;
 			Copy->SetFlags(MAIL_READ | MAIL_CREATED, true);
 			Copy->SetFolder(GetItem()->GetFolder());				
 			Copy->SetDateSent(0);
 			SetItem(Copy);
 		}
 	}
 
 	Mail *Item = GetItem();
 	if (To)
 	{
 		To->OnSave(Item->GetObject()->GetStore(), Item->GetTo());
 	}
 	
 	LMailStore *AccountMailStore = NULL;
 	
 	if (FromCbo && Item->GetFrom() && FromAccountId.Length() > 0)
 	{
 		int64 CboVal = FromCbo->Value();
 		LAssert(CboVal < (ssize_t)FromAccountId.Length());
 		int AccountId = FromAccountId[(int)CboVal];
 		
 		LDataPropI *Frm = Item->GetFrom();
 		if (AccountId < 0)
 		{
 			// From is a literal address, not an account ID. This can happen when bouncing email.
 			Mailto mt(App, FromCbo->Name());
 			if (mt.To.Length() == 1)
 			{
 				AddressDescriptor *a = mt.To[0];
 				if (a)
 				{
 					Frm->SetStr(FIELD_NAME, a->sName);
 					Frm->SetStr(FIELD_EMAIL, a->sAddr);
 				}
 			}
 			else LAssert(0);
 		}
 		else if (AccountId > 0)
 		{
 			ScribeAccount *a = Item->App->GetAccountById(AccountId);
 			if (a)
 			{
 				Frm->SetStr(FIELD_NAME, a->Identity.Name().Str());
 				Frm->SetStr(FIELD_EMAIL, a->Identity.Email().Str());
 			}
 			else LAssert(!"From account missing.");
 			
 			// Find the associated mail store for this account. Hopefully we can put any new
 			// mail into the mail store that the account is using.
 			// 
 			// Check for IMAP mail store?
 			AccountMailStore = a->Receive.GetMailStore();
 			if (!AccountMailStore)
 			{
 				// Nope... what about a receive path?
 				LVariant DestFolder = a->Receive.DestinationFolder();
 				if (ValidStr(DestFolder.Str()))
 				{
 					AccountMailStore = Item->App->GetMailStoreForPath(DestFolder.Str());
 				}
 			}
 		}
 		else LAssert(!"No account id.");
 	}
 	
 	LDataPropI *ReplyObj = Item->GetReply();
 	if (ReplyToCbo != NULL &&
 		ReplyObj != NULL   &&
 		ReplyToChk != NULL &&
 		ReplyToChk->Value())
 	{		
 		Mailto mt(App, ReplyToCbo->Name());
 		if (mt.To.Length() == 1)
 		{
 			AddressDescriptor *a = mt.To[0];
 			if (a && a->sAddr)
 			{
 				if (a->sName)
 					ReplyObj->SetStr(FIELD_NAME, a->sName);
 				ReplyObj->SetStr(FIELD_EMAIL, a->sAddr);
 			}			
 		}
 	}
 
 	Item->SetSubject(Subject->Name());
 
 	Item->SetLabel(GetCtrlName(IDC_LABEL));
 	
 	auto c32 = GetCtrlValue(IDC_COLOUR);
 	Item->SetMarkColour(c32);
 
 	LDocView *Ctrl = CurrentEditCtrl ? HtmlView : TextView;
 	if (Ctrl)
 	{
 		// Delete all existing data...
 		Item->SetBody(0);
 		Item->SetBodyCharset(0);
 		Item->SetHtml(0);
 		Item->SetHtmlCharset(0);
 
 		const char *MimeType = Ctrl->GetMimeType();
 		const char *Charset = Ctrl->GetCharset();
 		if (!_stricmp(MimeType, sTextHtml))
 		{
 			LArray<LDocView::ContentMedia> Media;
 
 			// Set the HTML part
 			LString HtmlFormat;
 			if (!Ctrl->GetFormattedContent("text/html", HtmlFormat, &Media))
 				HtmlFormat = Ctrl->Name();
 			Item->SetHtml(HtmlFormat);
 			Item->SetHtmlCharset(Charset);
 
 			// Also set a text version for the alternate
 			LString TxtFormat;
 			if (!Ctrl->GetFormattedContent(sTextPlain, TxtFormat))
 			{
 				TxtFormat = HtmlToText(Item->GetHtml(), Charset);
 			}
 			if (TxtFormat)
 			{
 				Item->SetBody(TxtFormat);
 				Item->SetBodyCharset(Charset);
 			}
 
 			auto Obj = Item->GetObject();
 
 			// This clears any existing multipart/related objects...
 			Obj->SetObj(FIELD_HTML_RELATED, NULL);
 
 			if (Media.Length() > 0)
 			{
 				// Make a table of existing attachments so that we don't duplicate
 				// these new ones.
 				LArray<LDataI*> Objs;
 				LHashTbl<ConstStrKey<char,false>,LDataI*> Map;
 				if (GetItem()->GetAttachmentObjs(Objs))
 				{
 					for (auto i : Objs)
 					{
 						auto Cid = i->GetStr(FIELD_CONTENT_ID);
 						if (Cid)
 							Map.Add(Cid, i);
 					}
 				}
 
 				// If there are media attachments, splice them into the MIME tree.
 				// This should go after setting the text part so that the right
 				// MIME alternative structure is generated.
 				auto Store = Obj->GetStore();
 				for (auto &Cm : Media)
 				{
 					LDataI *a = Store->Create(MAGIC_ATTACHMENT);
 					if (a)
 					{
 						LAssert(Cm.Valid());
 						
 						auto Existing = Map.Find(Cm.Id);
 						if (Existing)
 						{
 							// Delete the existing attachment
 							Thing *t = CastThing(Existing);
 							Attachment *a = t ? t->IsAttachment() : NULL;
 							if (a)
 							{
 								// Delete both the Attachment and it's store object...
 								auto it = GetItem();
 								it->DeleteAttachment(a);
 							}
 							else
 							{
 								// There is Attachment object for the LDataI.... but we can
 								// still delete it from the store.
 								LArray<LDataI*> del;
 								del.Add(Existing);
 								Existing->GetStore()->Delete(del, false);
 							}
 						}
 
 						LgiTrace("Adding related: %s %s " LPrintfInt64 "\n",
 							Cm.FileName.Get(),
 							Cm.MimeType.Get(),
 							Cm.Stream->GetSize());
 
 						a->SetStr(FIELD_CONTENT_ID, Cm.Id);
 						a->SetStr(FIELD_NAME, Cm.FileName);
 						a->SetStr(FIELD_MIME_TYPE, Cm.MimeType);
 						a->SetStream(Cm.Stream);
 						
 						Obj->SetObj(FIELD_HTML_RELATED, a);
 					}
 				}
 			}
 		}
 		else
 		{
 			auto Text = Ctrl->Name();
 			Item->SetBody(Text);
 			Item->SetBodyCharset(Charset);
 		}
 	}
 
 	#if SAVE_HEADERS
 	char *Headers = Header ? Header->Name() : 0;
 	if (Headers)
 	{
 		DeleteArray(Item->InternetHeader);
 		Item->InternetHeader = NewStr(Headers);
 	}
 	#endif
 
 	Item->GetMessageId(true);
 	Item->CreateMailHeaders();
 	Item->Update();
 	
 	ScribeFolder *Folder = Item->GetFolder();
 
 	// Now get the associated outbox for this mail
 	ScribeFolder *Outbox = Item->App->GetFolder(FOLDER_OUTBOX, AccountMailStore);
 	
 	auto Fld = Folder ? Folder : Outbox;
 	LAssert(Fld != NULL);
 	bool Status = Fld ? Item->Save(Fld) : false;
 	if (Status)
 	{
 		LArray<LDataI*> c;
 		c.Add(Item->GetObject());
 
 		Item->App->SetContext(_FL);
 		Item->App->OnChange(c, 0);
 	}
 }
 
 bool MailUi::AddRecipient(AddressDescriptor *Addr)
 {
 	if (Addr && To)
 	{
 		ListAddr *La = dynamic_cast<ListAddr *>(Addr);
 		if (La)
 		{
 			To->Insert(La);
 			return true;
 		}
 	}
 	return false;
 }
 
 bool MailUi::AddRecipient(Contact *c)
 {
 	ListAddr *La = new ListAddr(c);
 	if (La)
 	{
 		To->Insert(La);
 		return true;
 	}
 
 	return false;
 }
 
 bool MailUi::AddRecipient(const char *Email, const char *Name)
 {
 	ListAddr *La = new ListAddr(App, Email, Name);
 	if (La)
 	{
 		To->Insert(La);
 		return true;
 	}
 
 	return false;
 }
 
 bool MailUi::SeekMsg(int delta)
 {
 	bool Status = false;
 
 	if (Container)
 	{
 		Mail *Item = GetItem();
 		auto Index = Container->IndexOf(Item);
 		Mail *Next = Index >= 0 ? (*Container)[Index + delta] : 0;
 		if (Next)
 		{
 			SetDirty(false); // called OnSave() if necessary
 			_Running = false;
 
 			if (Item->Ui)
 			{
 				// close any existing user interface
 				if (Item->Ui != this)
 				{
 					Item->Ui->Quit();
 				}
 				else
 				{
 					Item->Ui = 0;
 				}
 			}
 			if (Header)
 				Header->SetEnv(0);
 
 			Caps.Empty();
 			SetItem(Next);
 			Item = GetItem();
 
 			// select this item in the list
 			if (Item->GetList())
 			{
 				Item->GetList()->Select(Item);
 				Item->ScrollTo();
 			}
 
 			Status = true;
 
 			OnLoad();
 			_Running = true;
 		}
 	}
 
 	return Status;
 }
 
 int MailUi::HandleCmd(int Cmd)
 {
 	switch (Cmd)
 	{
 		case IDM_READ_RECEIPT:
 		{
 			if (Commands.Toolbar)
 			{
 				int f = GetItem()->GetFlags();
 				if (Commands.Toolbar->GetCtrlValue(IDM_READ_RECEIPT))
 				{
 					SetFlag(f, MAIL_READ_RECEIPT);
 				}
 				else
 				{
 					ClearFlag(f, MAIL_READ_RECEIPT);
 				}
 				GetItem()->SetFlags(f);
 			}
 			break;
 		}
 		case IDM_HIGH_PRIORITY:
 		{
 			if (Commands.Toolbar)
 			{
 				GetItem()->SetPriority(Commands.Toolbar->GetCtrlValue(IDM_HIGH_PRIORITY) ? MAIL_PRIORITY_HIGH : MAIL_PRIORITY_NORMAL);
 				SetDirty(true);
 
 				Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, GetItem()->GetPriority() < MAIL_PRIORITY_NORMAL);
 				Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, GetItem()->GetPriority() > MAIL_PRIORITY_NORMAL);
 			}
 			break;
 		}
 		case IDM_LOW_PRIORITY:
 		{
 			if (Commands.Toolbar)
 			{
 				GetItem()->SetPriority(Commands.Toolbar->GetCtrlValue(IDM_LOW_PRIORITY) ? MAIL_PRIORITY_LOW : MAIL_PRIORITY_NORMAL);
 				SetDirty(true);
 
 				Commands.Toolbar->SetCtrlValue(IDM_HIGH_PRIORITY, GetItem()->GetPriority() < MAIL_PRIORITY_NORMAL);
 				Commands.Toolbar->SetCtrlValue(IDM_LOW_PRIORITY, GetItem()->GetPriority() > MAIL_PRIORITY_NORMAL);
 			}
 			break;
 		}
 		case IDM_PREV_MSG:
 		{
 			SeekMsg(1);
 			break;
 		}
 		case IDM_NEXT_MSG:
 		{
 			SeekMsg(-1);
 			break;
 		}
 		case IDM_SEND_MSG:
 		{
 			bool Working = IsWorking();
 			if (Working)
 			{
 				SetCmdAfterResize(Cmd);
 				break;
 			}
 
 			if (!GetItem() || !App)
 			{
 				LAssert(!"Missing item or window ptr.");
 				break;
 			}
 			
 			// Normal save
 			bool IsInPublicFolder = GetItem()->GetFolder() && GetItem()->GetFolder()->IsPublicFolders();
 			if (IsInPublicFolder)
 			{
 				auto i = GetItem();
 				LDateTime n;
 				n.SetNow();
 				i->SetDateSent(&n);
 				i->Update();
 			}
 
 			OnDataEntered();
 			OnSave();
 			SetDirty(false, false);
 			GetItem()->Send(true);
 			Quit();
 			return 0;
 		}
 		case IDM_DELETE_MSG:
 		{
 			LVariant ConfirmDelete, DelDirection;
 			App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 			App->GetOptions()->GetValue(OPT_DelDirection, DelDirection);
 			int WinAction = DelDirection.CastInt32() - 1; // -1 == Next, 0 == Close, 1 == Prev
 
 			if (!ConfirmDelete.CastInt32() ||
 				LgiMsg(this, LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 			{
 				Mail *Del = GetItem()->GetObject() ? GetItem() : 0;
 				if (Del)
 				{
 					if (!Del->GetObject()->IsOnDisk())
 						Del = 0;
 				}
 				
 				if (!WinAction || !SeekMsg(WinAction))
 				{
 					SetItem(0);
 					PostEvent(M_CLOSE);
 				}
 				
 				if (Del && Del->GetObject())
 				{
 					Del->OnDelete();
 				}
 			}
 			break;
 		}
 		case IDM_DELETE_AS_SPAM:
 		{
 			LVariant DelDirection;
 			App->GetOptions()->GetValue(OPT_DelDirection, DelDirection);
 			int WinAction = DelDirection.CastInt32() - 1; // -1 == Next, 0 == Close, 1 == Prev
 			
 			if (GetItem())
 			{
 				Mail *Del = GetItem()->GetObject() ? GetItem() : 0;
 
 				if (!WinAction || !SeekMsg(WinAction))
 				{
 					SetItem(0);
 					PostEvent(M_CLOSE);
 				}
 
 				if (Del)
 				{
 					Del->DeleteAsSpam(this);
 				}
 			}
 			break;
 		}
 		case IDM_SAVE:
 		{
 			OnDataEntered();
 			SetDirty(false, false);
 			break;
 		}
 		case IDM_SAVE_CLOSE:
 		{
 			bool Working = IsWorking();
 			if (Working)
 			{
 				SetCmdAfterResize(Cmd);
 				break;
 			}
 
 			OnDataEntered();
 			SetDirty(false, false);
 			// fall thru
 		}
 		case IDM_CLOSE:
 		{
 			Quit();
 			return 0;
 		}
 		case IDM_REPLY:
 		case IDM_REPLY_ALL:
 		{
 			App->MailReplyTo(GetItem(), Cmd == IDM_REPLY_ALL);
 			SetDirty(false);
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_FORWARD:
 		{
 			App->MailForward(GetItem());
 			if (IsDirty())
 				OnSave();
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_BOUNCE:
 		{
 			App->MailBounce(GetItem());
 			OnSave();
 			PostEvent(M_CLOSE);
 			break;
 		}
 		case IDM_PRINT:
 		{
 			if (GetItem() && App)
 			{
 				if (IsDirty())
 				{
 					OnDataEntered();
 					OnSave();
 				}
 				App->ThingPrint(NULL, GetItem(), 0, this);
 			}
 			break;
 		}
 		case IDM_ATTACH_FILE:
 		{
 			auto Select = new LFileSelect(this);
 			Select->MultiSelect(true);
 			Select->Type("All files", LGI_ALL_FILES);
 			Select->Open([this](auto dlg, auto status)
 			{
 				if (status)
 				{
 					Mail *m = GetItem();
 					if (m)
 					{
 						for (size_t i=0; i<dlg->Length(); i++)
 						{
 							char File[MAX_PATH_LEN];
 							if (!LResolveShortcut((*dlg)[i], File, sizeof(File)))
 							{
 								strcpy_s(File, sizeof(File), (*dlg)[i]);
 							}
 
 							Attachment *a = m->AttachFile(this, File);
 							if (a && Attachments)
 							{
 								Attachments->Insert(a);
 								Attachments->ResizeColumnsToContent();
 							}
 						}
 					}
 				}
 				delete dlg;
 			});
 			break;
 		}
 		default:
 		{
 			if (Commands.ExecuteCallbacks(App, this, GetItem(), Cmd))
 				return true;
 			
 			return false;
 		}
 	}
 
 	return true;
 }
 
 int MailUi::OnCommand(int Cmd, int Event, OsView From)
 {
 	if (GpgUi)
 	{
 		GpgUi->DoCommand(Cmd, [this, Cmd](auto r)
 		{
 			if (!r)
 				HandleCmd(Cmd);
 		});
 	}
 	else
 	{
 		HandleCmd(Cmd);
 	}
 
 	return LWindow::OnCommand(Cmd, Event, From);
 }
 
 LArray<Attachment*> Mail::GetCalendarAttachments()
 {
 	List<Attachment> Attachments;
 	if (!GetAttachments(&Attachments))
 		return false;
 
 	LArray<Attachment*> Cal;
 	for (auto a: Attachments)
 	{
 		LString Mt = a->GetMimeType();
 		if (Mt.Equals("text/calendar"))
 			Cal.Add(a);
 	}
 
 	return Cal;
 }
 
 bool MailUi::AddCalendarEvent(bool AddPopupReminder)
 {
 	LString Msg;
 	auto Result = GetItem()->AddCalendarEvent(this, AddPopupReminder, &Msg);
 
 	auto css = CalPanelStatus->GetCss(true);
 	if (Result) css->Color(LCss::ColorInherit);
 	else css->Color(LColour::Red);
 	CalPanelStatus->Name(Msg);
 
 	return Result;
 }
 
 
 bool Mail::AddCalendarEvent(LViewI *Parent, bool AddPopupReminder, LString *Msg)
 {
 	LString Err, s;
 	auto Cal = GetCalendarAttachments();
 	int NewEvents = 0, DupeEvents = 0, Processed = 0, Cancelled = 0, NotMatched = 0;
 	ScribeFolder *Folder = NULL;
 	if (Cal.Length() == 0)
 	{
 		Err = "There are no attached events to add.";
 		goto OnError;
 	}
 
 	Folder = App->GetFolder(FOLDER_CALENDAR);
 	if (!Folder)
 	{
 		Err = "There no calendar folder to save to.";
 		goto OnError;
 	}
 
 	for (auto a: Cal)
 	{
 		auto Event = App->CreateThingOfType(MAGIC_CALENDAR);
 		if (Event)
 		{
 			LString Mt = a->GetMimeType();
 			LAutoPtr<LStreamI> Data(a->GotoObject(_FL));
 			if (Data)
 			{
 				if (Event->Import(AutoCast(Data), Mt))
 				{
 					auto c = Event->IsCalendar();
 					auto obj = c ? c->GetObject() : NULL;
 					if (!obj)
 						continue;
 					
 					if (AddPopupReminder)
 					{
 						LString s;
 						s.Printf("%g,%i,%i,", 10.0, CalMinutes, CalPopup);
 						obj->SetStr(FIELD_CAL_REMINDERS, s);
 					}
 					
 					// Is it a cancellation?
 					auto Status = obj->GetStr(FIELD_CAL_STATUS);
 					auto IsCancel = Stristr(Status, "CANCELLED") != NULL;
 					if (!IsCancel)
 					{
 						// Does the folder already have a copy of this event?
 						bool AlreadyAdded = false;
 						for (auto t: Folder->Items)
 						{
 							auto Obj = t->IsCalendar();
 							if (Obj && *Obj == *c)
 							{
 								AlreadyAdded = true;
 								break;
 							}
 						}
 
 						if (AlreadyAdded)
 						{
 							DupeEvents++;
 						}
 						else
 						{
 							// Write the event to the folder
 							auto Status = Folder->WriteThing(Event);
 							if (Status > Store3Error)
 							{
 								NewEvents++;
 								Event = NULL;
 							}
 						}
 					}
 					else
 					{
 						// Cancellation processing
 						auto Uid = obj->GetStr(FIELD_UID);
 						Thing *Match = NULL;
 						for (auto t: Folder->Items)
 						{
 							auto tCal = t->IsCalendar();
 							if (tCal && tCal->GetObject())
 							{
 								auto tUid = tCal->GetObject()->GetStr(FIELD_UID);
 								if (!Stricmp(Uid, tUid))
 								{
 									Match = t;
 									break;
 								}
 							}
 						}
 						if (Match)
 						{
 							if (!Parent || LgiMsg(Parent, "Delete cancelled event?", "Calendar", MB_YESNO) == IDYES)
 							{
 								auto f = Match->GetFolder();
 								LArray<Thing*> items;
 								items.Add(Match);
 								f->Delete(items, true);
 								Cancelled++;
 							}
 						}
 						else NotMatched++;
 					}
 				}
 				else LgiTrace("%s:%i - vCal event import failed.\n", _FL);
 			}
 			else LgiTrace("%s:%i - GotoObject failed.\n", _FL);
 
 			if (Event)
 				Event->DecRef();
 		}
 		else LgiTrace("%s:%i - CreateThingOfType failed.\n", _FL);
 	}
 
 	Processed = NewEvents + DupeEvents;
 	if (Processed != Cal.Length())
 	{
 		Err.Printf("There were errors processing %i events, check the console.", (int)Cal.Length() - Processed);
 		goto OnError;
 	}
 
 	if (NewEvents || DupeEvents)
 		s.Printf("%i new events, %i duplicates.", NewEvents, DupeEvents);
 	else
 		s.Printf("%i events cancelled, %i not matched.", Cancelled, NotMatched);
 
 	if (Msg)
 		*Msg = s;
 
 	if (Processed > 0)
 	{
 		for (auto v: CalendarView::CalendarViews)
 			v->OnContentsChanged();
 	}
 
 	return true;
 
 OnError:
 	if (Msg)
 		*Msg = Err;
 	return false;
 }
 
 int MailUi::OnNotify(LViewI *Col, LNotification n)
 {
 	if (dynamic_cast<LPanel*>(Col))
 	{
 		Sx = Sy = -1;
 		OnPosChange();
 		return 0;
 	}
 
 	if (GpgUi)
 	{
 		if (n.Type == LNotifyItemDelete &&
 			Col == (LViewI*)GpgUi)
 		{
 			GpgUi = NULL;			
 		}
 		else
 		{
 			int r = GpgUi->OnNotify(Col, n);
 			if (r)
 				return r;
 		}
 	}	
 
 	int CtrlId = Col->GetId();
 	switch (CtrlId)
 	{
 		case IDC_MAIL_UI_TABS:
 		{
 			Mail *Item = GetItem();
 			if (!Item)
 				break;
 			// bool Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 			
 			if (n.Type == LNotifyValueChanged)
 			{
 				switch (Col->Value())
 				{
 					case 0: // Text tab
 					{
 						if (!TextLoaded)
 						{
 							Item->CreateView(this, sTextPlain, true, -1);
 							OnPosChange();
 						}
 						
 						if (CurrentEditCtrl == 1)
 						{
 							if (HtmlView &&
 								TextView &&
 								TextCtrlDirty)
 							{
 								// Convert HTML to Text here...
 								TextCtrlDirty = false;
 								auto Html = HtmlView->Name();
 								if (Html)
 								{
 									LString Txt = HtmlToText(Html, HtmlView->GetCharset());
 									if (Txt)
 										TextView->Name(Txt);
 								}
 							}
 
 							CurrentEditCtrl = 0;
 						}
 						break;
 					}
 					case 1: // Html tab
 					{
 						if (!HtmlLoaded)
 						{
 							Item->CreateView(this, sTextHtml, true, -1);
 							OnPosChange();
 						}
 
 						if (CurrentEditCtrl == 0)
 						{
 							if (HtmlView &&
 								TextView &&
 								HtmlCtrlDirty)
 							{
 								// Convert Text to HTML here...
 								HtmlCtrlDirty = false;
 								auto Text = TextView->Name();
 								if (Text)
 								{
 									LString Html = TextToHtml(Text, TextView->GetCharset());
 									if (Html)
 										HtmlView->Name(Html);
 								}
 							}
 
 							CurrentEditCtrl = 1;
 						}
 						break;
 					}
 					default: // Do nothing on other tabs..
 						break;
 				}
 			}
 			else if (n.Type == LNotifyItemClick)
 			{
 				LMouse m;
 				if (!Col->GetMouse(m))
 					break;
 				
 				int TabIdx = Tab->HitTest(m);
 				if (TabIdx == 0 || TabIdx == 1)
 				{
 					if (Item && m.IsContextMenu())
 					{
 						LSubMenu s;
 						s.AppendItem(LLoadString(IDS_DELETE), IDM_DELETE);
 						
 						m.ToScreen();
 						int Cmd = s.Float(this, m.x, m.y, false);
 						if (Cmd == IDM_DELETE)
 						{
 							if (TabIdx == 0) // Txt
 							{
 								Item->SetBody(NULL);
 								Item->SetBodyCharset(NULL);
 								TextView->Name(NULL);
 
 								if (TabText)
 								{
 									TabText->GetCss(true)->FontBold(false);
 									TabText->OnStyleChange();
 								}
 								TextCtrlDirty = false;
 							}
 							else // HTML
 							{
 								Item->SetHtml(NULL);
 								Item->SetHtmlCharset(NULL);
 								HtmlView->Name(NULL);
 
 								if (TabHtml)
 								{
 									TabHtml->GetCss(true)->FontBold(false);
 									TabHtml->OnStyleChange();
 								}
 								HtmlCtrlDirty = false;
 							}
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDC_FROM:
 		{
 			if (_Running &&
 				FromCbo &&
 				n.Type == LNotifyValueChanged)
 				SetDirty(true);
 			break;
 		}
 		case IDC_SHOW_FROM:
 		{
 			LVariant Show = Col->Value();;
 			App->GetOptions()->SetValue(OPT_MailShowFrom, Show);
 			break;
 		}
 		case IDC_LAUNCH_HTML:
 		{
 			char File[MAX_PATH_LEN];
 			if (GetItem() &&
 				GetItem()->WriteAlternateHtml(File))
 			{
 				LExecute(File);
 			}
 			break;
 		}
 		case IDC_ENTRY:
 		{
 			if (Entry)
 			{
 				if (ValidStr(Entry->Name()))
 				{
 					if (!Browse)
 					{
 						Browse = new AddressBrowse(App, Entry, To, SetTo);
 					}
 				}
 				if (Browse)
 				{
 					Browse->OnNotify(Entry, n);
 				}
 				
 				if (n.Type == LNotifyReturnKey)
 				{
 					OnDataEntered();
 				}
 			}
 			break;
 		}
 		case IDC_SET_TO:
 		{
 			if (SetTo)
 			{
 				AddMode = (int)SetTo->Value();
 			}
 			break;
 		}
 		case IDC_SEND:
 		{
 			OnCommand(IDM_SEND_MSG, 0,
 				#if LGI_VIEW_HANDLE
 				Col->Handle()
 				#else
 				(OsView)NULL
 				#endif
 				);
 			break;
 		}
 		#if SAVE_HEADERS
 		case IDC_INTERNET_HEADER: 
 		#endif
 		case IDC_TEXT_VIEW:
 		case IDC_HTML_VIEW:
 		{
 			Mail *Item = GetItem();
 			if (!Item)
 				break;
 			bool Edit = TestFlag(Item->GetFlags(), MAIL_CREATED);
 
 			if
 			(
 				(
 					n.Type == LNotifyDocChanged
 					||
 					n.Type == LNotifyCharsetChanged
 					||
 					n.Type == LNotifyFixedWidthChanged
 					||
 					(!IgnoreShowImgNotify && n.Type == LNotifyShowImagesChanged)
 				)
 				&&
 				_Running
 			)
 			{
 				if (GetItem())
 					GetItem()->OnNotify(Col, n);
 				SetDirty(true);
 				
 				if (Edit)
 				{
 					if (CtrlId == IDC_TEXT_VIEW)
 					{
 						CurrentEditCtrl = 0;
 						HtmlCtrlDirty = true;						
 						TabText->GetCss(true)->FontBold(true);
 						TabText->OnStyleChange();
 					}
 					else if (CtrlId == IDC_HTML_VIEW)
 					{
 						CurrentEditCtrl = 1;
 						TextCtrlDirty = true;						
 						TabHtml->GetCss(true)->FontBold(true);
 						TabHtml->OnStyleChange();
 					}
 
 					// LgiTrace("%s:%i - OnNotify: TextLoaded=%i, HtmlLoaded=%i\n", _FL, TextLoaded, HtmlLoaded);
 				}
 			}
 			break;
 		}
 		case IDC_ATTACHMENTS:
 		{
 			if (n.Type == LNotifyItemInsert ||
 				n.Type == LNotifyItemDelete)
 			{
 				// fall thru
 			}
 			else
 			{
 				break;
 			}
 		}
 		case IDC_TO:
 		{
 			if
 			(
 				_Running
 				&&
 				(
 					n.Type == LNotifyItemInsert
 					||
 					n.Type == LNotifyItemDelete
 					||
 					n.Type == LNotifyItemChange
 				)
 			)
 			{
 				SetDirty(true);
 			}
 			break;
 		}
 		case IDC_COLOUR:
 		{
 			if (_Running && GetItem())
 			{
 				MetaFieldsDirty = true;
 				OnDirty(true);
 			}
 			break;
 		}
 		case IDC_LABEL:
 		{
 			if (_Running)
 			{
 				MetaFieldsDirty = true;
 				OnDirty(true);
 			}
 			break;
 		}
 		case IDC_SUBJECT:
 		{
 			if (_Running)
 			{
 				SetDirty(true);
 			}
 			break;
 		}
 		case IDCANCEL:
 		{
 			if (CmdAfterResize)
 			{
 				int Cmd = CmdAfterResize;
 				CmdAfterResize = 0;
 				IsWorking(false);		
 				
 				OnCommand(Cmd, 0, NULL);
 			}
 			break;
 		}
 		case IDC_ADD_CAL_EVENT:
 		{
 			AddCalendarEvent(false);
 			break;
 		}
 		case IDC_ADD_CAL_EVENT_POPUP:
 		{
 			AddCalendarEvent(true);
 			break;
 		}
 	}
 	return 0;
 }
 
 void MailUi::OnDataEntered()
 {
 	auto Name = Entry->Name();
 	if (ValidStr(Name))
 	{
 		List<AddressDescriptor> New;
 		
 		// Decode the entries
 		Mailto mt(App, Name);
 		New = mt.To;
 		mt.To.Empty();
 		
 		if (mt.Subject &&
 			!ValidStr(GetCtrlName(IDC_SUBJECT)))
 		{
 			SetCtrlName(IDC_SUBJECT, mt.Subject);
 		}
 
 		// Add the new entries
 		List<Contact> Cache;
 		App->GetContacts(Cache);
 		AddressDescriptor *ad;
 		while ((ad = New[0]))
 		{
 			New.Delete(ad);
 
 			ListAddr *t = dynamic_cast<ListAddr*>(ad);
 			if (t)
 			{
 				t->CC = (EmailAddressType)GetCtrlValue(IDC_SET_TO);
 				t->OnFind(&Cache);
 				To->Insert(t, 0);
 			}
 			else
 			{
 				DeleteObj(ad);
 			}
 		}
 
 		// Clear the entry box for the next one
 		Entry->Name("");
 		Entry->Select(-1, -1);
 	}
 }
 
 void MailUi::OnPosChange()
 {	
 	LWindow::OnPosChange();
 
 	if (Tab && (Sx != X() || Sy != Y()))
 	{
 		Sx = X();
 		Sy = Y();
 
 		LRect r = Tab->GetCurrent()->GetClient();
 		r.Inset(CONTENT_BORDER, CONTENT_BORDER);
 
 		if (TextView)
 			TextView->SetPos(r, true);
 
 		if (HtmlView)
 			HtmlView->SetPos(r, true);
 
 		if (Attachments)
 			Attachments->SetPos(r, true);
 
 		if (Header)
 			Header->SetPos(r, true);
 	}
 }
 
 void MailUi::OnPaint(LSurface *pDC)
 {
 	LCssTools Tools(this);
 	Tools.PaintContent(pDC, GetClient());
 }
 
 void MailUi::OnPulse()
 {
 	if (IsDirty() && TextView && GetItem())
 	{
 		// Ui -> Object
 		OnSave();
 		
 		// Object -> Disk
 		GetItem()->Save(0);
 	}
 	else
 	{
 		SetPulse();
 	}
 }
 
 void MailUi::OnDirty(bool Dirty)
 {
 	SetCtrlEnabled(IDM_SAVE, Dirty);
 	SetCtrlEnabled(IDM_SAVE_CLOSE, Dirty);
 	
 	if (Dirty)
 	{
 		SetPulse(60 * 1000); // every minute
 	}
 	else
 	{
 		SetPulse();
 	}
 }
 
 bool MailUi::CallMethod(const char *Name, LVariant *Dst, LArray<LVariant*> &Arg)
 {
 	ScribeDomType Method = StrToDom(Name);
 
 	*Dst = false;
 	switch (Method)
 	{
 		case SdShowRemoteContent: // Type: ()
 			if (HtmlView)
 			{
 				bool Always = Arg.Length() > 0 ? Arg[0]->CastBool() : false;
 				if (Always && GetItem())
 				{
 					auto From = GetItem()->GetFrom();
 					if (From)
 						App->RemoteContent_AddSender(From->GetStr(FIELD_EMAIL), true);
 					else
 						LgiTrace("%s:%i - No from address.\n", _FL);
 				}
 
 				IgnoreShowImgNotify = true;
 				HtmlView->SetLoadImages(true);
 				IgnoreShowImgNotify = false;
 				PostEvent(M_UPDATE);
 				*Dst = true;
 			}
 			break;
 		case SdSetHtml: // Type: (String Html)
 			if (HtmlView)
 			{
 				if (Arg.Length() > 0)
 				{
 					HtmlView->Name(Arg[0]->Str());
 					*Dst = true;
 				}
 			}
 			break;
 		default:
 			return false;
 	}
 	
 	return true;	
 }
 
 LMessage::Result MailUi::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_SET_HTML:
 		{
 			LAutoPtr<LString> s((LString*)Msg->A());
 			if (s && HtmlView)
 				HtmlView->Name(*s);
 			break;
 		}
 		case M_NEEDS_CAP:
 		{
 			LAutoString c((char*)Msg->A());
 			NeedsCapability(c);
 			return 0;
 		}
 		case M_RESIZE_IMAGE:
 		{
 			LAutoPtr<ImageResizeThread::Job> Job((ImageResizeThread::Job*)Msg->A());
 			if (Job && GetItem())
 			{
 				// Find the right attachment...
 				List<Attachment> Attachments;
 				if (GetItem()->GetAttachments(&Attachments))
 				{
 					Attachment *Match = NULL;
 					for (auto a: Attachments)
 					{
 						LString Nm = a->GetName();
 						if (Nm.Equals(Job->FileName))
 						{
 							Match = a;
 							break;
 						}
 					}
 					if (Match)
 					{
 						if (Job->Data)
 							Match->Set(Job->Data);
 						
 						auto Mt = Match->GetMimeType();
 						if (_stricmp(Mt, "image/jpeg"))
 						{
 							auto Name = Match->GetName();
 							char *Ext = LGetExtension(Name);
 							if (Ext)
 								*Ext = 0;
 							LString NewName = Name;
 							NewName += "jpg";
 							Match->SetName(NewName);
 							Match->SetMimeType("image/jpeg");
 						}
 						
 						Match->SetIsResizing(false);
 						
 						LDataI *AttachPoint = GetItem()->GetFileAttachPoint();
 						if (AttachPoint)
 						{
 							// Do final save to the mail store...
 							Match->GetObject()->Save(AttachPoint);
 						}
 						else
 						{
 							LAssert(0);
 							Match->DecRef();
 							Match = NULL;
 						}
 						
 						if (CmdAfterResize)
 						{
 							bool Working = IsWorking();
 							if (!Working)
 							{
 								// All resizing work is done...
 								OnCommand(CmdAfterResize, 0, NULL);
 								return 0;
 							}
 						}
 					}
 					else LAssert(!"No matching attachment image to store resized image in.");
 				}
 			}
 			break;
 		}
 		#if WINNATIVE
 		case WM_COMMAND:
 		{
 			LAssert((NativeInt)Commands.Toolbar != 0xdddddddd);
 
 			if (Commands.Toolbar && Commands.Toolbar->Handle() == (HWND)Msg->b)
 			{
 				return LWindow::OnEvent(Msg);
 			}
 			break;
 		}
 		#endif
 	}
 
 	return LWindow::OnEvent(Msg);
 }
 
 void MailUi::OnReceiveFiles(LArray<const char*> &Files)
 {
 	List<Attachment> Att;
 	GetItem()->GetAttachments(&Att);
 
 	for (unsigned i=0; i<Files.Length(); i++)
 	{
 		auto FileName = Files[i];
 		bool Add = true;
 		char Path[MAX_PATH_LEN];
 
 		if (!LResolveShortcut(FileName, Path, strlen(Path)))
 		{
 			strcpy_s(Path, sizeof(Path), FileName);
 		}
 
 		for (auto a: Att)
 		{
 			char *f = Path;
 			while (strchr(f, '\\'))
 			{
 				f = strchr(f, '\\') + 1;
 			}
 
 			if (_stricmp(a->GetName(), f) == 0)
 			{
 				int Result = LgiMsg(this, LLoadString(IDS_ATTACH_WARNING_DLG), LLoadString(IDS_ATTACHMENTS), MB_YESNO);
 				if (Result == IDNO)
 				{
 					Add = false;
 					break;
 				}
 			}
 		}
 
 		if (Add)
 		{
 			Attachment *a = GetItem()->AttachFile(this, Path);
 			if (a)
 			{
 				Attachments->Insert(a);
 				Attachments->ResizeColumnsToContent();
 			}
 		}
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 bool Mail::PreviewLines = false;
 bool Mail::RunMailPipes = true;
 List<Mail> Mail::NewMailLst;
 bool Mail::AdjustDateTz = true;
 LHashTbl<ConstStrKey<char>,Mail*> Mail::MessageIdMap;
 
 Mail::Mail(ScribeWnd *app, LDataI *object) : Thing(app, object)
 {
 	DefaultObject(object);
 	d = new MailPrivate(this);
 	_New();
 }
 
 Mail::~Mail()
 {
     if (GetObject())
     {
         auto Id = GetObject()->GetStr(FIELD_MESSAGE_ID);
         if (Id)
             MessageIdMap.Delete(Id);
     }
 
 	NewMailLst.Delete(this);
 	_Delete();
 	DeleteObj(d);
 }
 
 void Mail::_New()
 {
 	SendAttempts = 0;
 	Container = 0;
 	FlagsCache = -1;
 	PreviewCacheX = 0;
 	Cursor = 0;
 	ParentFile = 0;
 	PreviousMail = 0;
 	NewEmail = NewEmailNone;
 	
 	Ui = 0;
 	TotalSizeCache = -1;
 }
 
 void Mail::_Delete()
 {
 	if (ParentFile)
 	{
 		ParentFile->SetMsg(0);
 	}
 
 	UnloadAttachments();
 	PreviewCache.DeleteObjects();
 	DeleteObj(Container);
 
 	if (Ui)
 		Ui->PostEvent(M_CLOSE);
 	if (Ui)
 		Ui->SetItem(0);
 }
 
 bool Mail::AppendItems(LSubMenu *Menu, const char *Param, int Base)
 {
 	auto Remove = Menu->AppendSub(LLoadString(IDS_REMOVE));
 	if (Remove)
 	{
 		Remove->AppendItem("'>'", IDM_REMOVE_GRTH, true);
 		Remove->AppendItem("'> '", IDM_REMOVE_GRTH_SP, true);
 		Remove->AppendItem(LLoadString(IDS_HTML_TAGS), IDM_REMOVE_HTML, true);
 	}
 
 	auto FilterMenu = Menu->AppendSub(LLoadString(IDS_FILTER));
 	if (FilterMenu)
 	{
 		FilterMenu->SetImageList(App->GetIconImgList(), false);
 		Actions.Empty();
 		AddActions(FilterMenu, Actions, App->GetThingSources(MAGIC_FILTER));
 	}
 
 	auto Convert = Menu->AppendSub(LLoadString(IDS_CONVERT_SELECTION));
 	if (Convert)
 	{
 		Convert->AppendItem("To Base64", IDM_CONVERT_BIN_TO_B64, true);
 		Convert->AppendItem("To Binary", IDM_CONVERT_B64_TO_BIN, true);
 	}
 	
 	if (!TestFlag(GetFlags(), MAIL_CREATED))
 	{
 		auto Charset = Menu->AppendSub(LLoadString(L_CHANGE_CHARSET));
 		if (Charset)
 		{
 			int n=0;
 			for (LCharset *c = LGetCsList(); c->Charset; c++, n++)
 				Charset->AppendItem(c->Charset, IDM_CHARSET_BASE + n, c->IsAvailable());
 		}
 	}
 
 	return true;
 }
 
 bool Mail::OnMenu(LDocView *View, int Id, void *Context)
 {
 	const char *RemoveStr = 0;
 
 	switch (Id)
 	{
 		case IDM_REMOVE_GRTH:
 		{
 			RemoveStr = ">";
 			break;
 		}
 		case IDM_REMOVE_GRTH_SP:
 		{
 			RemoveStr = "> ";
 			break;
 		}
 		case IDM_REMOVE_HTML:
 		{
 			auto s = View ? View->Name() : 0;
 			if (s)
 			{
 				auto n = DeHtml(s);
 				if (n)
 				{
 					View->Name(n);
 					DeleteArray(n);
 				}
 			}
 			break;
 		}
 		default:
 		{
 			if (Id >= IDM_CHARSET_BASE)
 			{
 				int n=0;
 				LCharset *c;
 				for (c = LGetCsList(); c->Charset; c++, n++)
 				{
 					if (Id - IDM_CHARSET_BASE == n)
 					{
 						break;
 					}
 				}
 				if (c->Charset)
 				{
 					SetBodyCharset((char*)c->Charset);
 					SetDirty();
 					if (GetBodyCharset() && Ui)
 					{
 						Ui->OnLoad();
 					}
 				}
 			}
 			else if (Id >= IDM_FILTER_BASE)
 			{
 				Filter *Action = Actions[Id-IDM_FILTER_BASE];
 				if (Action)
 				{
 					// Save the message...
 					SetDirty(false);
 
 					// Hide the mail window...
 					if (Ui) Ui->Visible(false);
 
 					// Do the action
 					bool Stop;
 					Mail *This = this;
 					Action->DoActions(This, Stop);
 					if (This != this)
 						break;
 
 					if (Ui) DeleteObj(Ui);
 
 					return true;
 				}
 			}
 			break;
 		}
 		#ifdef _DEBUG
 		case IDM_CONVERT_BIN_TO_B64:
 		{
 			char *t = View->GetSelection();
 			if (t)
 			{
 				size_t In = strlen(t);
 				size_t Len = BufferLen_BinTo64(In);
 				char *B64 = new char[Len+1];
 				if (B64)
 				{
 					ConvertBinaryToBase64(B64, Len, (uchar*)t, In);
 					B64[Len] = 0;
 
 					char Temp[256];
 					ConvertBase64ToBinary((uchar*)Temp, sizeof(Temp), B64, Len);
 
 					char16 *Str = Utf8ToWide(B64);
 					if (Str)
 					{
 						LTextView3 *Tv = dynamic_cast<LTextView3*>(View);
 						if (Tv)
 						{
 							Tv->DeleteSelection();
 							Tv->Insert(Tv->GetCaret(), Str, Len);
 						}
 						DeleteArray(Str);
 					}
 					DeleteArray(B64);
 				}
 			}
 			break;
 		}
 		case IDM_CONVERT_B64_TO_BIN:
 		{
 			char *t = View->GetSelection();
 			if (t)
 			{
 				size_t In = strlen(t);
 				size_t Len = BufferLen_64ToBin(In);
 				char *Bin = new char[Len+1];
 				if (Bin)
 				{
 					ssize_t Out = ConvertBase64ToBinary((uchar*)Bin, Len, t, In);
 					Bin[Out] = 0;
 
 					char16 *Str = Utf8ToWide(Bin, Out);
 					if (Str)
 					{
 						LTextView3 *Tv = dynamic_cast<LTextView3*>(View);
 						if (Tv)
 						{
 							Tv->DeleteSelection();
 							Tv->Insert(Tv->GetCaret(), Str, Out);
 						}
 						DeleteArray(Str);
 					}
 					DeleteArray(Bin);
 				}
 			}
 			break;
 		}
 		#endif
 	}
 
 	if (RemoveStr)
 	{
 		size_t TokenLen = strlen(RemoveStr);
 		auto s = View ? View->Name() : 0;
 		if (s)
 		{
 			LMemQueue Temp;
 			auto Start = s;
 			const char *End;
 
 			while (*Start)
 			{
 				// seek to EOL
 				for (End = Start; *End && *End != '\n'; End++);
 				End++;
 				ssize_t Len = End - Start;
 
 				if (_strnicmp(Start, RemoveStr, TokenLen) == 0)
 				{
 					Temp.Write((uchar*)Start + TokenLen, Len - TokenLen);
 				}
 				else
 				{
 					Temp.Write((uchar*)Start, Len);
 				}
 
 
 				Start = End;
 			}
 
 			int Size = (int)Temp.GetSize();
 			char *Buf = new char[Size+1];
 			if (Buf)
 			{
 				Temp.Read((uchar*) Buf, Size);
 				Buf[Size] = 0;
 				View->Name(Buf);
 				DeleteArray(Buf);
 			}
 
 		}
 	}
 
 	return true;
 }
 
 LDocumentEnv::LoadType Mail::GetContent(LoadJob *&j)
 {
 	if (!j)
 		return LoadError;
 
 	LUri Uri(j->Uri);
 	if
 	(
 		Uri.sProtocol &&
 		(
 			!_stricmp(Uri.sProtocol, "http") ||
 			!_stricmp(Uri.sProtocol, "https") ||
 			!_stricmp(Uri.sProtocol, "ftp")
 		)
 	)
 	{
 		// We don't check OPT_HtmlLoadImages here because it's done elsewhere:
 		// - ScribeWnd::CreateTextControl calls LHtml::SetLoadImages with the value from OPT_HtmlLoadImages
 		// - LTag::LoadImage checks LHtml::GetLoadImages
 		//
 		// If there is a remote job here, it's because it's probably whitelisted.			
 		if (!Worker)		
 			Worker = App->GetImageLoader();
 		if (!Worker)
 			return LoadError;
 
 		Worker->AddJob(j);
 		j = 0;
 		return LoadDeferred;
 	}
 	else if (Uri.sProtocol && !_stricmp(Uri.sProtocol, "file"))
 	{
 		if (!_strnicmp(Uri.sPath, "//", 2))
 		{
 			// This seems to hang the windows CreateFile function...
 		}
 		else
 		{
 			// Is it a local file then?
 			if (j->pDC.Reset(GdcD->Load(Uri.sPath)))
 			{
 				return LoadImmediate;
 			}
 		}
 	}
 	else
 	{
 		List<Attachment> Files;
 		if (GetAttachments(&Files))
 		{
 			auto Dir = FilePart(j->Uri);
 			
 			Attachment *a = NULL;
 			for (auto It = Files.begin(); It != Files.end(); It++)
 			{
 				a = *It;
 
 				if (_strnicmp(j->Uri, "cid:", 4) == 0)
 				{
 					char *ContentId = j->Uri + 4;
 					auto AttachmentId = a->GetContentId();
 					if (AttachmentId)
 					{
 						if (AttachmentId[0] == '<')
 						{
 							auto s = AttachmentId + 1;
 							auto e = strrchr(s, '>');
 							if (e)
 							{
 								ssize_t len = e - s;
 								if (strlen(ContentId) == len &&
 									!strncmp(s, ContentId, len))
 									break;
 							}
 						}
 						else if (!strcmp(AttachmentId, ContentId))
 						{
 							break;
 						}
 					}
 				}
 				else
 				{
 					auto Name = a->GetName();
 					if (Name)
 					{
 						auto NameDir = FilePart(Name);
 						if (_stricmp(NameDir, Dir) == 0)
 						{
 							break;
 						}
 					}
 				}
 			}
 
 			if (a)
 			{
 				j->MimeType = a->GetMimeType();
 				j->ContentId = a->GetContentId();
 
 				if (j->Pref == LoadJob::FmtStream)
 				{
 					j->Filename = a->GetName();
 					j->Stream = a->GetObject()->GetStream(_FL);
 					return LoadImmediate;
 				}
 				else
 				{
 					char *Tmp = ScribeTempPath();
 					if (Tmp)
 					{
 						auto File = a->GetName();
 						auto Ext = LGetExtension(File);
 						char s[MAX_PATH_LEN] = "";
 						LString part;
 						do
 						{
 							if (part.Printf("%x.%s", LRand(), Ext) < 0)
 								return LoadError;
 							if (!LMakePath(s, sizeof(s), Tmp, part))
 								return LoadError;
 						}
 						while (LFileExists(s));
 
 						if (a->SaveTo(s, true))
 						{
 							if (j->Pref == LoadJob::FmtFilename)
 							{
 								j->Filename = s;
 								return LoadImmediate;
 							}
 							else
 							{
 								int Promote = GdcD->SetOption(GDC_PROMOTE_ON_LOAD, 0);
 								j->pDC.Reset(GdcD->Load(s));
 								j->Filename = a->GetName();
 								GdcD->SetOption(GDC_PROMOTE_ON_LOAD, Promote);
 								FileDev->Delete(s, false);
 								return LoadImmediate;
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	return LoadError;
 }
 
 class MailCapabilities : public LLayout
 {
     LArray<LAutoString> MissingCaps;
     LDocView *Doc;
     LButton *Install;
 
 public:
     MailCapabilities(LDocView *d)
     {
         Doc = d;
         Install = 0;
     }
     
 	const char *GetClass() { return "MailCapabilities"; }
 	
     void OnPosChange()
     {
         LRect c = GetClient();
         if (MissingCaps.Length())
         {
             if (!Install)
             {
                 if ((Install = new LButton(IDOK, 0, 0, -1, -1, "Install")))
                     Install->Attach(this);
             }
             
             LRect r = c;
             r.x1 = r.x2 - Install->X();
             r.y2 -= 7;
             Install->SetPos(r);
         }
     }
     
     void OnPaint(LSurface *pDC)
     {
         LRect cli = GetClient();
         if (MissingCaps.Length())
         {
             char Msg[256];
             int c = sprintf_s(Msg, sizeof(Msg), "This content requires ");
             for (unsigned i=0; i<MissingCaps.Length(); i++)
                 c += sprintf_s(Msg+c, sizeof(Msg)-c, "%s%s", i ? ", " : "", MissingCaps[i].Get());
             c += sprintf_s(Msg+c, sizeof(Msg)-c, " to display correctly");
             
             LDisplayString ds(LSysFont, Msg);
             LSysFont->Transparent(false);
             LSysFont->Colour(L_TEXT, L_MED);
             ds.Draw(pDC, cli.x1, cli.y1, &cli);
         }
         else
         {
             pDC->Colour(L_MED);
             pDC->Rectangle();
         }
     }
 };
 
 LDocView *Mail::CreateView(	MailViewOwner *Owner,
 							LString MimeType,
 							bool Sunken,
 							size_t MaxBytes,
 							bool NoEdit)
 {
 	bool Created = TestFlag(GetFlags(), MAIL_CREATED);
 	bool Edit = NoEdit ? false : Created;
 	bool ReadOnly = !Created;
 	LAutoString Mem;
 	LVariant DefAlt;
 	App->GetOptions()->GetValue(OPT_DefaultAlternative, DefAlt);
 
 	auto TextBody = GetBody();
 	auto TextCharset = GetBodyCharset();
 	
 	auto HtmlBody = GetHtml();
 	auto HtmlCharset = GetHtmlCharset();
 
 	const char *CtrlType = NULL;
 
 	if (!MimeType)
 	{
 		bool TextValid = TextBody != NULL;
 		bool HtmlValid = HtmlBody != NULL;
 
 		if (TextValid && HtmlValid)
 			MimeType = DefAlt.CastInt32() ? sTextHtml : sTextPlain;
 		else if (TextValid)
 			MimeType = sTextPlain;
 		else if (HtmlValid)
 			MimeType = sTextHtml;
 		else
 			return NULL;
 	}
 	
 	#ifdef WINDOWS
 	if (DefAlt.CastInt32() == 2 && MimeType == sTextHtml)
 		CtrlType = sApplicationInternetExplorer;
 	else
 	#endif
 		CtrlType = MimeType;
 
 	const char *Content, *Charset;
 	if (MimeType == sTextHtml)
 	{
 		Content = HtmlBody;
 		Charset = HtmlCharset;
 	}
 	else
 	{
 		Content = TextBody;
 		Charset = TextCharset;
 	}
 
 	// Emoji check
 	LVariant NoEmoji;
 	App->GetOptions()->GetValue(OPT_NoEmoji, NoEmoji);
 
 	// Check if the control needs changing
 	LDocView *View = Owner->GetDoc(MimeType);
 	if (View)
 	{
 		const char *ViewMimeType = View->GetMimeType();
 		if (MimeType != ViewMimeType)
 		{
 			Owner->SetDoc(NULL, ViewMimeType);
 			View = NULL;
 		}
 	}
 
 	if (!View)
 	{
 		View = App->CreateTextControl(	MimeType == sTextHtml ? IDC_HTML_VIEW : IDC_TEXT_VIEW,
 										MimeType,
 										Edit,
 										this);
 	}
 
 	if (View)
 	{
 		// Control setup
 		View->Sunken(Sunken);
 		View->SetReadOnly(ReadOnly);
 		View->SetEnv(this);
 		
 		LVariant UseCid = true;
 		View->SetValue(LDomPropToString(HtmlImagesLinkCid), UseCid);
 		
 		LVariant LoadImages;
 		App->GetOptions()->GetValue(OPT_HtmlLoadImages, LoadImages);
 		bool AppLoadImages = LoadImages.CastInt32() != 0;
 		bool MailLoadImages = TestFlag(GetFlags(), MAIL_SHOW_IMAGES);
 		const char *SenderAddr = GetFrom() ? GetFrom()->GetStr(FIELD_EMAIL) : NULL;
 		auto SenderStatus = App->RemoteContent_GetSenderStatus(SenderAddr);
 		
 		View->SetLoadImages
 		(
 			SenderStatus != RemoteNeverLoad
 			&&
 			(
 				AppLoadImages ||
 				MailLoadImages ||
 				SenderStatus == RemoteAlwaysLoad
 			)
 		);
 
         // Attach control
 		Owner->SetDoc(View, MimeType);
 		LCharset *CsInfo = LGetCsInfo(Charset);
 
 		// Check for render scripts
 		LArray<LScriptCallback*> Renderers;
 		LString RenderMsg = "Rendering...";
 		if (App->GetScriptCallbacks(LRenderMail, Renderers))
 		{
 			for (auto r: Renderers)
 			{
 				LVirtualMachine Vm;
 				
 				LScriptArguments Args(&Vm);
 				Args.New() = new LVariant(App);
 				Args.New() = new LVariant(this);
 				Args.New() = new LVariant((void*)NULL);
 				bool Status = App->ExecuteScriptCallback(*r, Args);
 				Args.DeleteObjects();
 				if (Status)
 				{
 					auto Ret = Args.GetReturn();
 					if (Ret->IsString() || Ret->CastInt32())
 					{
 						if (Ret->IsString())
 							RenderMsg = Ret->Str();
 						d->Renderer.Reset(new MailRendererScript(this, r));
 						break;
 					}
 				}
 			}
 		}
 
 		if (d->Renderer)
 		{
 			LString Nm;
 			if (MimeType.Equals(sTextHtml))
 				Nm.Printf("<html><body>%s</body></html>", RenderMsg.Get());
 			else
 				Nm = RenderMsg;
 			View->Name(Nm);
 		}
 		else
 		{
 			// Send the data to the control
 			size_t ContentLen = Content ? strlen(Content) : 0;
 			Html1::LHtml *Html = dynamic_cast<Html1::LHtml*>(View);
 			if (MimeType.Equals(sTextHtml))
 			{
 				if (CsInfo)
 				{
 					int OverideDocCharset = *Charset == '>' ? 1 : 0;
 					View->SetCharset(Charset + OverideDocCharset);
 					if (Html)
 						Html->SetOverideDocCharset(OverideDocCharset != 0);
 				}
 				else
 				{
 					View->SetCharset(0);
 					if (Html)
 						Html->SetOverideDocCharset(0);
 				}
 
 				View->Name(Content);
 			}
 			else
 			{
 				LAutoPtr<uint32_t,true> Utf32((uint32_t*)LNewConvertCp("utf-32",
             															Content,
             															Charset ? Charset : (char*)"utf-8",
             															MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
 				if (Utf32)
 				{
 					int Len = 0;
 					while (Utf32[Len])
 						Len++;
 					
 					#if 0
 					LFile f;
 					if (f.Open("c:\\temp\\utf32.txt", O_WRITE))
 					{
 						uchar bom[4] = { 0xff, 0xfe, 0, 0 };
 						f.Write(bom, 4);
 						f.Write(Utf32, Len * sizeof(uint32));
 						f.Close();
 					}
 					#endif
 				}
 			
 				LAutoWString Wide;
 				Wide.Reset((char16*)LNewConvertCp(LGI_WideCharset,
 													Content,
 													Charset ? Charset : (char*)"utf-8",
 													MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
 				if (Wide)
 				{
 					View->NameW(Wide);
 				}
 				else
 				{
 					// Fallback... try and show something at least
 					LAutoString t(NewStr(Content, MaxBytes > 0 ? MIN(ContentLen, MaxBytes) : ContentLen));
 					if (t)
 					{
 						uint8_t *i = (uint8_t*)t.Get();
 						while (*i)
 						{
 							if (*i & 0x80)
 								*i &= 0x7f;
 							i++;
 						}
 					
 						View->Name(t);
 					}
 					else
 						View->NameW(0);
 				}
 
 				View->SetFixedWidthFont(TestFlag(GetFlags(), MAIL_FIXED_WIDTH_FONT));
 			}
 		}
 	}
 
 	return View;
 }
 
 bool Mail::OnNavigate(LDocView *Parent, const char *Uri)
 {
 	if (Uri)
 	{
 		if
 		(
 			_strnicmp(Uri, "mailto:", 7) == 0
 			||
 			(
 				strchr(Uri, '@')
 				&&
 				!strchr(Uri, '/')
 			)
 		)
 		{
 			// Mail address
 			return App->CreateMail(0, Uri, 0) != 0;
 		}
 		else
 		{
 			return LDefaultDocumentEnv::OnNavigate(Parent, Uri);
 		}
 	}
 
 	return false;
 }
 
 void Mail::Update()
 {
 	TotalSizeCache = -1;
 	LListItem::Update();
 }
 
 LString::Array ParseIdList(const char *In)
 {
 	LString::Array result;
 
     if (!In)
         return result;
         
     while (*In && strchr(WhiteSpace, *In))
         In++;
 
     if (*In == '<')
     {
         // Standard msg-id list..
 	    for (auto s = In; s && *s; )
 	    {
 		    s = strchr(s, '<');
 		    if (!s)
 				break;
 		    while (*s == '<') s++;
 
             char *e = strchr(s, '>');
             if (e)
             {
 	            result.New().Set(s, e-s);
 	            s = e + 1;
             }
             else break;
 	    }
     }
     else
     {
         // Non compliant msg-id list...
         const char Delim[] = ", \t\r\n";
 	    for (auto s = In; s && *s; )
 	    {
 	        if (strchr(Delim, *s))
 	            s++;
 		    else
 		    {
 	            auto Start = s;
 
 	            while (*s && !strchr(Delim, *s))
 	                s++;
 	            
 				result.New().Set(Start, s - Start);
 		    }
 	    }
 	}
 
 	return result;
 }
 
 void Base36(char *Out, uint64 In)
 {
 	while (In)
 	{
 		int p = (int)(In % 36);
 		if (p < 10)
 		{
 			*Out++ = '0' + p;
 		}
 		else
 		{
 			*Out++ = 'A' + p - 10;
 		}
 		In /= 36;
 	}
 
 	*Out++ = 0;
 }
 
 void Mail::ClearCachedItems()
 {
 	TotalSizeCache = -1;
 	PreviewCacheX = -1;
 	PreviewCache.DeleteObjects();
 
 	Attachment *a;
 	int i = 0;
 	while ((a = Attachments[i]))
 	{
 		if (!a->DecRef())
 			i++;
 	}
 }
 
 void Mail::NewRecipient(char *Email, char *Name)
 {
 	LDataPropI *a = GetTo()->Create(GetObject()->GetStore());
 	if (a)
 	{
 		a->SetStr(FIELD_EMAIL, Email);
 		a->SetStr(FIELD_NAME, Name);
 		GetTo()->Insert(a);
 	}
 }
 
 void Mail::PrepSend()
 {
 	// Set flags and other data
 	SetDirty();
 
 	int OldFlags = GetFlags();
 	SetFlags((OldFlags | MAIL_READY_TO_SEND) & ~MAIL_SENT); // we want to send now...
 
 	// Check we're in the Outbox
 	ScribeFolder *OutBox = App->GetFolder(FOLDER_OUTBOX, GetObject());
 	if (OutBox)
 	{
 		ScribeFolder *f = GetFolder();
 		if (!f || f != OutBox)
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			OutBox->MoveTo(Items);
 		}
 	}
 }
 
 bool Mail::Send(bool Now)
 {
 	// Check for any "on before send" callbacks:
 	bool AllowSend = true;
 	LArray<LScriptCallback*> Callbacks;
 	if (App->GetScriptCallbacks(LMailOnBeforeSend, Callbacks))
 	{
 		for (unsigned i=0; AllowSend && i<Callbacks.Length(); i++)
 		{
 			LScriptCallback &c = *Callbacks[i];
 			if (c.Func)
 			{
 				LVirtualMachine Vm;
 				
 				LScriptArguments Args(&Vm);
 				Args.New() = new LVariant(App);
 				Args.New() = new LVariant(this);
 				if (App->ExecuteScriptCallback(c, Args))
 				{
 					if (!Args.GetReturn()->CastInt32())
 						AllowSend = false;
 				}
 
 				Args.DeleteObjects();
 			}
 		}
 	}
 	
 	if (!AllowSend)
 		return false;
 
 	// Set the ready to send flag..
 	bool IsInPublicFolder = GetFolder() && GetFolder()->IsPublicFolders();
 	if (!IsInPublicFolder)
 	{
 		PrepSend();
 
 		if (Now)
 		{
 			// Kick off send thread if relevant
 			LVariant Offline;
 			App->GetOptions()->GetValue(OPT_WorkOffline, Offline);
 			if (!Offline.CastInt32() && !IsInPublicFolder)
 			{
 				App->PostEvent(M_COMMAND, IDM_SEND_MAIL, (LMessage::Param)Handle());
 			}
 		}
 	}
 
 	return true;
 }
 
 bool Mail::MailMessageIdMap(bool Add)
 {
     if (Add)
     {
 		auto LoadState = GetLoaded();
 		if (LoadState < Store3Headers)
 		{
 			LAssert(!"Not loaded yet.");
 			LStackTrace("MailMessageIdMap msg not loaded yet: %i\n", LoadState);
 			return false;
 		}
 
 		// char *ObjId = GetObject()->GetStr(FIELD_MESSAGE_ID);
 		auto Id = GetMessageId(true);
 		if (!Id)
 		{
 			LAssert(!"No message ID? Impossible!");
 			GetMessageId(true);
 			return false;
 		}
 
 		#if 0
 		LgiTrace("MailMessageIdMap(%i) Old=%s Id=%s Mail=%p\n", Add, ObjId, Id, this);
 		#endif
 		return MessageIdMap.Add(Id, this);
     }
     else
     {
         auto Id = GetMessageId();
     	#if 0
         LgiTrace("MailMessageIdMap(%i) Id=%s Mail=%p\n", Add, Id, this);
         #endif
         return MessageIdMap.Delete(Id);
     }
 }
 
 Mail *Mail::GetMailFromId(const char *Id)
 {
     Mail *m = MessageIdMap.Find(Id);
     // LgiTrace("GetMailFromId(%s)=%p\n", Id, m);
     return m;
 }
 
 bool Mail::SetMessageId(const char *MsgId)
 {
 	if (LAppInst->InThread())
 	{
         LAssert(GetObject() != NULL);
         
         auto OldId = GetObject()->GetStr(FIELD_MESSAGE_ID);
 		if (OldId)
 		    MessageIdMap.Delete(OldId);
 
 		LAutoString m(NewStr(MsgId));
 		LAutoString s(TrimStr(m, "<>"));
 		if (GetObject()->SetStr(FIELD_MESSAGE_ID, s))
 			SetDirty();
 			
 		return s != 0;
 	}
 	else
 	{
 		// No no no NO NON NOT NADA.
 		LAssert(0);
 	}
 
 	return false;
 }
 
 LAutoString Mail::GetThreadIndex(int TruncateChars)
 {
     LAutoString Id;
     LAutoString Raw(InetGetHeaderField(GetInternetHeader(), "Thread-Index"));
     if (Raw)
     {
         Id = ConvertThreadIndex(Raw, TruncateChars);
     }
     
     return Id;
 }
 
 const char *Mail::GetMessageId(bool Create)
 {
     LAssert(GetObject() != NULL);
  	
  	d->MsgIdCache = GetObject()->GetStr(FIELD_MESSAGE_ID);
  	if (!d->MsgIdCache)
 	{
 		bool InThread = GetCurrentThreadId() == LAppInst->GetGuiThreadId();
 
 		LAutoString Header(InetGetHeaderField(GetInternetHeader(), "Message-ID"));
 		if (Header)
 		{
 			LAssert(InThread);
 			if (InThread)
 			{
 				auto Ids = ParseIdList(Header);
 				SetMessageId(d->MsgIdCache = Ids[0]);
 			}
 		}
 
 		if (!d->MsgIdCache && Create)
 		{
 			LAssert(InThread);
 			
 			if (InThread)
 			{
 				auto FromEmail = GetFromStr(FIELD_EMAIL);
 				const char *At = FromEmail ? strchr(FromEmail, '@') : 0;
 				LVariant Email;
 				if (!At)
 				{
 					if (App->GetOptions()->GetValue(OPT_Email, Email) && Email.Str())
 					{
 						At = strchr(Email.Str(), '@');
 					}
 					else
 					{
 						At = "@domain.com";
 					}
 				}
 				
 				if (At)
 				{
 					char m[96], a[32], b[32];
 					Base36(a, LCurrentTime());
 					Base36(b, LRand(RAND_MAX));
 					sprintf_s(m, sizeof(m), "<%s.%i%s%s>", a, LRand(RAND_MAX), b, At);
 					if (GetObject()->SetStr(FIELD_MESSAGE_ID, m))
 						SetDirty();
 					
 				 	d->MsgIdCache = GetObject()->GetStr(FIELD_MESSAGE_ID);
 				}
 				else LgiTrace("%s:%i - Error, no '@' in %s.\n", _FL, FromEmail);
 			}
 			else LgiTrace("%s:%i - Error, not in thread.\n", _FL);
 		}
 	}
 	else
 	{
 		d->MsgIdCache = d->MsgIdCache.Strip("<>").Strip();
 	}
 
 	LAssert
 	(
 		(!d->MsgIdCache && !Create)
 		||
 		(d->MsgIdCache && !strchr(d->MsgIdCache, '\n'))
 	);
 
 	return d->MsgIdCache;
 }
 
 bool Mail::GetReferences(LString::Array &Ids)
 {
 	LAutoString References(InetGetHeaderField(GetInternetHeader(), "References"));
 	if (References)
 	{
 		Ids = ParseIdList(References);
 	}
 
 	LAutoString InReplyTo(InetGetHeaderField(GetInternetHeader(), "In-Reply-To"));
 	if (InReplyTo)
 	{
 		auto To = ParseIdList(InReplyTo);
 		
 		bool Has = false;
 		auto &r = To[0];
 		if (r)
 		{
 		    for (auto h: Ids)
 		    {
 		        if (!strcmp(h, r))
 		            Has = true;
 		    }
     		
 		    if (!Has)
 		    {
 			    To.Delete(r);
 			    Ids.New() = r;
 		    }
 		}
 		
 		To.DeleteArrays();
 	}
 	
 	if (Ids.Length() == 0)
 	{
 	    LAutoString Id = GetThreadIndex(5);
         if (Id)
         {
             size_t Len = strlen(Id);
             size_t Bytes = Len >> 1;
             if (Bytes >= 22)
             {
                 Ids.New() = Id.Get();
             }
         }
 	}
 	
 	return Ids.Length() > 0;
 }
 
 LString AddrToHtml(LDataPropI *a)
 {
 	LString s;
 	if (a)
 	{
 		auto Name = a->GetStr(FIELD_NAME);
 		auto Addr = a->GetStr(FIELD_EMAIL);
 		LXmlTree t;
 		LAutoString eName(t.EncodeEntities(Name));
 		LAutoString eAddr(t.EncodeEntities(Addr));
 
 		if (Name && Addr)
 			s.Printf("<a href=\"mailto:%s\">%s</a>", eAddr.Get(), eName.Get());
 		else if (Name)
 			s = eName.Get();
 		else if (Addr)
 			s.Printf("<a href=\"mailto:%s\">%s</a>", eAddr.Get(), eAddr.Get());
 	}
 
 	return s;
 }
 
 LDataPropI *FindMimeSeg(LDataPropI *s, char *Type)
 {
 	if (!s)
 		return 0;
 
 	const char *Mt = s->GetStr(FIELD_MIME_TYPE);
 	if (!Mt) Mt = "text/plain";
 	if (!_stricmp(Type, Mt))
 		return s;
 
 	LDataIt c = s->GetList(FIELD_MIME_SEG);
 	if (!c)
 		return 0;
 
 	for (LDataPropI *i=c->First(); i; i=c->Next())
 	{
 		LDataPropI *Child = FindMimeSeg(i, Type);
 		if (Child)
 			return Child;
 	}
 
 	return 0;
 }
 
 bool Mail::GetAttachmentObjs(LArray<LDataI*> &Objs)
 {
 	if (!GetObject())
 		return false;
 
 	CollectAttachments(&Objs, NULL, NULL, NULL, GetObject()->GetObj(FIELD_MIME_SEG));
 	return Objs.Length() > 0;
 }
 
 void DescribeMime(LStream &p, LDataI *Seg)
 {
 	auto Mt = Seg->GetStr(FIELD_MIME_TYPE);
 	p.Print("%s", Mt);
 	auto Cs = Seg->GetStr(FIELD_CHARSET);
 	if (Cs) p.Print("&nbsp;-&nbsp;%s", Cs);
 	p.Print("<br>\n");
 
 	LDataIt c = Seg->GetList(FIELD_MIME_SEG);
 	if (c && c->First())
 	{
 		p.Print("<div style='padding-left:1em;'>\n");
 		for (LDataPropI *i=c->First(); i; i=c->Next())
 		{
 			LDataI *a = dynamic_cast<LDataI*>(i);
 			if (a)
 				DescribeMime(p, a);
 		}
 		p.Print("</div>\n");
 	}
 }
 
 bool Mail::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		case SdFrom: // Type: ListAddr
 		{
 			Value = GetFrom();
 			break;
 		}
 		case SdFromHtml: // Type: String
 		{
 			LString s = AddrToHtml(GetFrom());
 			if (s.Length() == 0)
 				return false;
 			Value = s;
 			break;
 		}
 		case SdContact: // Type: Contact
 		{
 			if (!GetFrom())
 				return false;
 
 			auto Addr = GetFrom()->GetStr(FIELD_EMAIL);
 			if (!Addr)
 				return false;
 			
 			Contact *c = Contact::LookupEmail(Addr);
 			if (!c)
 				return App->GetVariant("NoContact", Value);
 
 			Value = (LDom*)c;
 			break;
 		}
 		case SdTo: // Type: ListAddr[]
 		{
 			if (Array)
 			{
 				LDataIt To = GetTo();
 
 				int Idx = atoi(Array);
 				bool Create = false;
 				if (Idx < 0)			
 				{
 					Create = true;
 					Idx = -Idx;
 				}
 
 				LDataPropI *a = Idx < (int)To->Length() ? (*To)[Idx] : 0;
 				if (!a && Create)
 				{
 					if ((a = To->Create(GetObject()->GetStore())))
 					{
 						To->Insert(a);
 					}
 				}
 
 				Value = a;
 			}
 			else if (Value.SetList())
 			{
 				LDataIt To = GetTo();
 				for (LDataPropI *a=To->First(); a; a=To->Next())
 				{
 					LVariant *Recip = new LVariant;
 					if (Recip)
 					{
 						*Recip = a;
 						Value.Value.Lst->Insert(Recip);
 					}
 				}
 			}
 			else return false;
 			break;
 		}
 		case SdToHtml: // Type: String
 		{
 			if (GetTo())
 			{
 				LStringPipe p;
 				for (LDataPropI *t=GetTo()->First(); t; t=GetTo()->Next())
 				{
 					if (p.GetSize())
 						p.Write((char*)", ", 2);
 					LString s = AddrToHtml(t); 
 					if (s)
 						p.Write(s, s.Length());
 				}
 				Value.Type = GV_STRING;
 				Value.Value.String = p.NewStr();
 			}
 			break;
 		}
 		case SdSubject: // Type: String
 		{
 			Value = GetSubject();
 			break;
 		}
 		case SdBody: // Type: String
 		{
 			if (Array)
 			{
 				auto Body = GetBody();
 				LAutoString h;
 
 				for (auto c = Body; c && *c; )
 				{
 					while (*c && strchr(WhiteSpace, *c)) c++;
 					auto Start = c;
 					while (*c && *c != ':' && *c != '\n') c++;
 					if (*c == ':')
 					{
 						if (Start[0] == '\"' && c[1] == '\"')
 							c++;
 
 						LString s(Start, c - Start);
 						s = s.Strip("\'\" \t[]<>{}:");
 						if (s.Equals(Array))
 						{
 							// Match...
 							c++;
 							while (*c && strchr(WhiteSpace, *c)) c++;
 							Start = c;
 							while (*c && *c != '\n') c++;
 							while (c > Start && strchr(WhiteSpace, c[-1])) c--;
 
 							h.Reset(NewStr(Start, c - Start));
 							break;
 						}
 						else
 						{
 							while (*c && *c != '\n')
 								c++;
 						}
 					}
 
 					if (*c == '\n')
 						c++;
 				}
 
 				if (h)
 				{
 					if (GetBodyCharset())
 					{
 						char *u = (char*)LNewConvertCp("utf-8", h, GetBodyCharset());
 						if (u)
 						{
 							Value.OwnStr(u);
 						}
 						else
 						{
 							Value.OwnStr(h.Release());
 						}
 					}
 					else
 					{
 						Value.OwnStr(h.Release());
 					}
 				}
 			}
 			else
 			{
 				Value = GetBody();
 			}
 			break;
 		}
 		case SdBodyAsText: // Type: String
 		{
 			size_t MaxSize = ValidStr(Array) ? atoi(Array) : -1;
 			
 			if (ValidStr(GetBody()) && ValidStr(GetHtml()))
 			{
 				LVariant Def;
 				App->GetOptions()->GetValue(OPT_DefaultAlternative, Def);			
 				if (Def.CastInt32())
 				{
 					goto DoHtml;
 				}
 				goto DoText;
 			}
 			else if (ValidStr(GetBody()))
 			{
 				DoText:
 				LAutoString CharSet = GetCharSet();
 				auto Txt = GetBody();
 				if (CharSet)
 				{
 					size_t TxtLen = strlen(Txt);
 					Value.OwnStr((char*)LNewConvertCp("utf-8", Txt, CharSet, MIN(TxtLen, MaxSize)));
 				}
 				else
 					Value = Txt;
 			}
 			else if (ValidStr(GetHtml()))
 			{
 				DoHtml:
 				auto v = HtmlToText(GetHtml(), GetHtmlCharset());
 				Value = v.Get();
 			}
 			else return false;
 			break;
 		}
 		case SdBodyAsHtml: // Type: String
 		{
 			// int MaxSize = ValidStr(Array) ? atoi(Array) : -1;
 
 			MailPrivate::HtmlBody *b = d->GetBody();
 			if (!b)
 				return false;
 			
 			LStringPipe p;
 			p.Print("<div class='%s'>\n%s\n</div>\n", ScribeReplyClass, b->Html.Get());
 			Value.OwnStr(p.NewStr());
 			LgiTrace("Value=%s\n", Value.Str());
 			break;
 		}
 		case SdHtmlHeadFields: // Type: String
 		{
 			MailPrivate::HtmlBody *b = d->GetBody();
 			if (!b)
 				return false;
 			
 			LStringPipe p;
 			if (ValidStr(b->Charset))
 				p.Print("\t<meta charset=\"%s\">\n", b->Charset.Get());
 
 			p.Print("\t<style>\n");
 			if (ValidStr(b->Styles))
 			{
 				// rewrite the style rules to change 'body' to 'div.scribe_reply'.
 				// Otherwise the source document's styles spill over into the edit
 				// section of the reply
 				const char *s = b->Styles;
 				LCss::Store Store;
 				if (Store.Parse(s))
 				{
 					LCss::SelArray *Body = Store.TypeMap.Find("body");
 					if (Body)
 					{
 						for (unsigned i=0; i<Body->Length(); i++)
 						{
 							LCss::Selector *Sel = (*Body)[i];
 							if (Sel)
 							{
 								for (unsigned p=0; p<Sel->Parts.Length(); p++)
 								{
 									LCss::Selector::Part &Part = Sel->Parts[p];
 									const char *sBody = "body";
 									if (Part.Type == LCss::Selector::SelType &&
 										Part.Value &&
 										!_stricmp(Part.Value, sBody))
 									{
 										Part.Value.Reset(NewStr("div"));
 										
 										LCss::Selector::Part cls;
 										cls.Type = LCss::Selector::SelClass;
 										cls.Value.Reset(NewStr(ScribeReplyClass));
 										Sel->Parts.AddAt(p + 1, cls);
 										break;
 									}
 								}
 							}
 						}
 					}
 					
 					// Output modified styles to the string buffer
 					Store.ToString(p);
 				}
 			}
 			
 			// Add our own styles at the end, overwriting source doc styles...
 			p.Print("\tdiv.%s { %s }\n",
 					ScribeReplyClass,
 					ScribeReplyStyles);
 					
 			p.Print("\t</style>");
 		
 			Value.OwnStr(p.NewStr());
 			break;
 		}
 		case SdMessageID: // Type: String
 		{
 			Value = GetMessageId();
 			return true;
 		}
 		case SdInternetHeaders: // Type: String
 		{
 			Value = GetInternetHeader();
 			break;
 		}
 		case SdInternetHeader: // Type: String[]
 		{
 			if (!Array || !GetInternetHeader())
 				return false;
 
 			LAutoString s(InetGetHeaderField(GetInternetHeader(), Array));
 			if (s)
 				Value = s;
 			else
 				Value.Empty();
 			break;
 		}
 		case SdPriority: // Type: Int32
 		{
 			Value = (int)GetPriority();
 			break;
 		}
 		case SdHtml: // Type: String
 		{
 			Value = GetHtml();
 			break;
 		}
 		case SdFlags: // Type: Int32
 		{
 			if (Array)
 			{
 				int Flag = StringToMailFlag(Array);
 				Value = (GetFlags() & Flag) != 0;
 			}
 			else
 			{
 				Value = (int)GetFlags();
 			}
 			break;
 		}
 		case SdFolder: // Type: ScribeFolder
 		{
 			ScribeFolder *f = GetFolder();
 			if (!f)
 				return false;
 			Value = (LDom*)f;
 			break;
 		}
 		case SdScribe: // Type: ScribeWnd
 		{
 			Value = (LDom*)App;
 			break;
 		}
 		case SdMail: // Type: Mail
 		{
 			Value = PreviousMail;
 			break;
 		}
 		case SdDateSent: // Type: DateTime
 		{
 			Value = GetDateSent();
 			break;
 		}
 		case SdDateReceived: // Type: DateTime
 		{
 			Value = GetDateReceived();
 			break;
 		}
 		case SdSig: // Type: String
 		{
 			bool Type = false;
 			if (Array && stristr(Array, "html"))
 				Type = true;
 			Value = GetSig(Type);
 			break;
 		}
 		case SdSize: // Type: Int64
 		{
 			Value = TotalSizeof();
 			break;
 		}
 		case SdLabel: // Type: String
 		{
 			Value = GetLabel();
 			break;
 		}
 		case SdAttachments: // Type: Int32
 		{
 			LArray<LDataI*> Lst;
 			GetAttachmentObjs(Lst);
 			Value = (int)Lst.Length();
 			break;
 		}
 		case SdAttachment: // Type: Attachment[]
 		{
 			List<Attachment> Files;
 			if (GetAttachments(&Files) && Array)
 			{
 				int i = atoi(Array);
 				Value = Files[i];
 				if (Value.Type == GV_DOM)
 					return true;
 			}
 			
 			LAssert(!"Not a valid attachment?");
 			return false;
 		}
 		case SdMimeTree: // Type: String
 		{
 			LDataI *Root = dynamic_cast<LDataI*>(GetObject()->GetObj(FIELD_MIME_SEG));
 			if (!Root)
 				return false;
 			
 			LStringPipe p(256);
 			DescribeMime(p, Root);
 			Value.OwnStr(p.NewStr());
 			break;
 		}
 		case SdUi: // Type: LView
 		{
 			Value = Ui;
 			break;
 		}
 		case SdType: // Type: Int32
 		{
 			Value = GetObject()->Type();
 			break;
 		}
 		case SdSelected: // Type: Bool
 		{
 			Value = Select();
 			break;
 		}
 		case SdRead: // Type: Bool
 		{
 			Value = (GetFlags() & MAIL_READ) != 0;
 			break;
 		}
 		case SdShowImages: // Type: Bool
 		{
 			Value = (GetFlags() & MAIL_SHOW_IMAGES) != 0;
 			break;
 		}
 		case SdColour: // Type: Int32
 		{
 			Value = GetMarkColour();
 			break;
 		}
 		case SdReceivedDomain: // Type: String
 		{
 			Value = GetFieldText(FIELD_RECEIVED_DOMAIN);
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 #define DomSetStr(Dom, Fld)							\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_STRING)		\
 			GetObject()->SetStr(Fld, Value.Str());		\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 #define DomSetInt(Dom, Fld)							\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_INT32)		\
 			GetObject()->SetInt(Fld, Value.Value.Int);	\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 #define DomSetDate(Dom, Fld)						\
 	case Dom:										\
 		if (GetObject() && Value.Type == GV_DATETIME)	\
 			GetObject()->SetDate(Fld, Value.Value.Date);	\
 		else										\
 			LAssert(!"Missing object or type err"); \
 		break;
 
 bool Mail::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	ScribeDomType Fld = StrToDom(Name);
 	switch (Fld)
 	{
 		DomSetStr(SdSubject, FIELD_SUBJECT)
 		DomSetStr(SdMessageID, FIELD_MESSAGE_ID)
 		DomSetStr(SdInternetHeaders, FIELD_INTERNET_HEADER)
 		DomSetInt(SdPriority, FIELD_PRIORITY)
 		DomSetDate(SdDateSent, FIELD_DATE_SENT)
 		DomSetDate(SdDateReceived, FIELD_DATE_RECEIVED)
 		case SdBody:
 		{
 			if (!SetBody(Value.Str()))
 				return false;
 			break;
 		}
 		case SdHtml:
 		{
 			if (!SetHtml(Value.Str()))
 				return false;
 			break;
 		}
 		case SdRead:
 		{
 			if (Value.CastInt32())
 				SetFlags(GetFlags() | MAIL_READ);
 			else
 				SetFlags(GetFlags() & ~MAIL_READ);
 			break;
 		}
 		case SdColour:
 		{
 			auto u32 = Value.IsNull() ? 0 : (uint32_t)Value.CastInt32();
 			if (!SetMarkColour(u32))
 				return false;
 			break;
 		}
 		case SdShowImages:
 		{
 			if (Value.CastInt32())
 				SetFlags(GetFlags() | MAIL_SHOW_IMAGES);
 			else
 				SetFlags(GetFlags() & ~MAIL_SHOW_IMAGES);
 			break;
 		}
 		case SdSelected:
 		{
 			Select(Value.CastInt32() != 0);
 			break;
 		}
 		case SdLabel:
 		{
 			if (!SetLabel(Value.Str()))
 				return false;
 			break;
 		}
 		case SdFlags:
 		{
 			if (Array)
 			{
 				int Flag = StringToMailFlag(Array);
 				if (Value.CastInt32())
 					// Set
 					SetFlags(GetFlags() | Flag);
 				else
 					SetFlags(GetFlags() & ~Flag);
 			}
 			else
 			{
 				SetFlags(Value.CastInt32());
 			}
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	SetDirty();
 	Update();
 	return true;
 }
 
 bool Mail::CallMethod(const char *MethodName, LVariant *ReturnValue, LArray<LVariant*> &Args)
 {
 	ScribeDomType Fld = StrToDom(MethodName);
 	switch (Fld)
 	{
 		default:
 			break;
 		case SdSend: // Type: ([Bool SendNow = true])
 		{
 			bool Now = Args.Length() > 0 ? Args[0]->CastInt32() != 0 : true;
 			bool Result = Send(Now);
 			if (ReturnValue)
 				*ReturnValue = Result;
 			return true;
 		}
 		case SdAddCalendarEvent: // Type: ([Bool AddPopupReminder])
 		{
 			bool AddPopupReminder = Args.Length() > 0 ? Args[0]->CastInt32() != 0 : true;
 			bool Result = AddCalendarEvent(NULL, AddPopupReminder, NULL);
 			if (ReturnValue)
 				*ReturnValue = Result;
 			return true;
 		}
 		case SdGetRead: // Type: ()
 		{
 			*ReturnValue = (GetFlags() & MAIL_READ) != 0;
 			return true;
 		}
 		case SdSetRead: // Type: (Bool IsRead = true)
 		{
 			bool Rd = Args.Length() ? Args[0]->CastInt32() != 0 : true;
 			auto Flags = GetFlags();
 			if (Rd) SetFlags(Flags | MAIL_READ);
 			else SetFlags(Flags & ~MAIL_READ);
 			*ReturnValue = true;
 			return true;
 		}
 		case SdBayesianChange: // Type: (int SpamWordOffset, int HamWordOffset)
 		{
 			if (Args.Length() != 2)
 			{
 				LgiTrace("%s:%i - Invalid arg count, expecting (int SpamWordOffset, int HamWordOffset)\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto SpamWordOffset = Args[0]->CastInt32();
 			auto HamWordOffset = Args[1]->CastInt32();
 
 			if (SpamWordOffset > 1)
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailSpam);
 			else if (SpamWordOffset < 0)
 				App->OnBayesianMailEvent(this, BayesMailSpam, BayesMailUnknown);
 			
 			if (HamWordOffset > 1)
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailHam);
 			else if (HamWordOffset < 1)
 				App->OnBayesianMailEvent(this, BayesMailHam, BayesMailUnknown);
 			break;
 		}
 		case SdBayesianScore: // Type: ()
 		{
 			double Result;
 			if (App->IsSpam(Result, this))
 			{
 				*ReturnValue = Result;
 				return true;
 			}
 			break;
 		}
 		case SdSearchHtml: // Type: (String SearchExpression)
 		{
 			if (Args.Length() != 2)
 			{
 				LgiTrace("%s:%i - Method needs 1 argument.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 
 			auto Html = GetHtml();
 			if (!Html)
 			{
 				LgiTrace("%s:%i - No HTML to parse.\n", _FL);
 				*ReturnValue = false;
 				return true;
 			}
 				
 			// auto Cs = GetHtmlCharset();
 			SearchHtml(ReturnValue, Html, Args[0]->Str(), Args[1]->Str());
 			return true;
 		}
 		case SdDeleteAsSpam: // Type: ()
 		{
 			DeleteAsSpam(App);
 			return true;
 		}
 	}
 	
 	return Thing::CallMethod(MethodName, ReturnValue, Args);
 }
 
 char *Mail::GetDropFileName()
 {
 	if (!DropFileName)
 	{
 		LString Subj = GetSubject();
 		Subj = Subj.Strip(" \t\r\n.");
 		DropFileName.Reset(MakeFileName(ValidStr(Subj) ? Subj.Get() : (char*)"Untitled", "eml"));
 	}
 	return DropFileName;
 }
 
 bool Mail::GetDropFiles(LString::Array &Files)
 {
 	if (!GetDropFileName())
 		return false;
 
 	if (!LFileExists(DropFileName))
 	{
 		LAutoPtr<LFile> F(new LFile);
 		if (F->Open(DropFileName, O_WRITE))
 		{
 			F->SetSize(0);
 			if (!Export(AutoCast(F), sMimeMessage))
 				return false;
 		}
 		else return false;
 	}
 
 	if (!LFileExists(DropFileName))
 		return false;
 
 	Files.Add(DropFileName.Get());
 	return true;
 }
 
 OsView Mail::Handle()
 {
 	return
 		#if LGI_VIEW_HANDLE
 		(Ui) ? Ui->Handle() :
 		#endif
 		NULL;
 }
 
 Thing &Mail::operator =(Thing &t)
 {
 	Mail *m = t.IsMail();
 	if (m)
 	{
 		#define CopyStr(dst, src) \
 			{ DeleteArray(dst); dst = NewStr(src); }
 			
 		/*
 		for (LDataPropI *a = m->GetTo()->First(); a; a = m->GetTo()->Next())
 		{
 			LDataPropI *NewA = GetTo()->Create(Object->GetStore());
 			if (NewA)
 			{
 				*NewA = *a;
 				GetTo()->Insert(NewA);
 			}
 		}
 		*/
 
 		if (GetObject() && m->GetObject())
 		{
 			GetObject()->CopyProps(*m->GetObject());
 		}
 		else LAssert(!"This shouldn't happen right?");
 
 		Update();
 	}
 
 	return *this;
 }
 
 bool Mail::HasAlternateHtml(Attachment **Attach)
 {
 	// New system of storing alternate HTML in a Mail object field.
 	if (GetHtml()) return true;
 
 	// Old way of storing alternate HTML, in an attachment.
 	// pre v1.53
 	List<Attachment> Files;
 	if (GetAttachments(&Files))
 	{
 		for (auto a: Files)
 		{
 			if ((_stricmp(a->GetText(0), "attachment.html") == 0 ||
 				_stricmp(a->GetText(0), "index.html") == 0) &&
 				(a->GetMimeType() ? _stricmp(a->GetMimeType(), "text/html") == 0 : 1))
 			{
 				if (Attach)
 				{
 					*Attach = a;
 				}
 
 				return true;
 			}
 		}
 	}
 
 	// None found
 	return false;
 }
 
 char *Mail::GetAlternateHtml(List<Attachment> *Refs)
 {
 	char *Status = 0;
 	Attachment *Attach = 0;
 	if (HasAlternateHtml(&Attach))
 	{
 		if (GetHtml())
 		{
 			// New system of storing alternate HTML in a Mail object field.
 			Status = NewStr(GetHtml());
 		}
 		else if (Attach)
 		{
 			// Old way of storing alternate HTML, in an attachment.
 			// pre v1.53
 			char *Ptr;
 			ssize_t Size;
 			if (Attach->Get(&Ptr, &Size))
 			{
 				Status = NewStr((char*)Ptr, Size);
 			}
 		}
 
 		if (Status && Refs)
 		{
 			// Turn all the cid: references into file names...
 			LStringPipe Out;
 			
 			char *n;
 			for (char *s=Status; *s; s=n)
 			{
 				n = stristr(s, "\"cid:");
 				if (n)
 				{
 					// Extract cid
 					n++;
 					Out.Push(s, n-s);
 					s = n += 4;
 					while (*n && !strchr("\"\' >", *n)) n++;
 					char *Cid = NewStr(s, n-s);
 					if (Cid)
 					{
 						// Find attachment
 						List<Attachment> Files;
 						if (GetAttachments(&Files))
 						{
 							for (auto a: Files)
 							{
 								if (a->GetContentId() &&
 									strcmp(a->GetContentId(), Cid) == 0)
 								{
 									Refs->Insert(a);
 									Out.Push(a->GetName());
 								}
 							}
 						}
 					}					
 				}
 				else
 				{
 					Out.Push(s);
 					break;
 				}
 			}
 
 			DeleteArray(Status);
 			Status = Out.NewStr();
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::WriteAlternateHtml(char *DstFile, int DstFileLen)
 {
 	bool Status = false;
 	char *Tmp = ScribeTempPath();
 
 	List<Attachment> Refs;
 	char *Html;
 	if (Tmp &&
 		(Html = GetAlternateHtml(&Refs)))
 	{
 		char FileName[256];
 
 		LMakePath(FileName, sizeof(FileName), Tmp, "Alt.html");
 		if (DstFile)
 		{
 			strcpy_s(DstFile, DstFileLen, FileName);
 		}
 
 		LFile f;
 		if (f.Open(FileName, O_WRITE))
 		{
 			size_t Len = strlen(Html);
 			Status = f.Write(Html, Len) == Len;
 			f.Close();
 		}
 
 		DeleteArray(Html);
 
 		for (auto a: Refs)
 		{
 			LMakePath(FileName, sizeof(FileName), Tmp, a->GetName());
 			FileDev->Delete(FileName, false);
 			a->SaveTo(FileName);
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::DeleteAttachment(Attachment *File)
 {
 	bool Status = false;
 	if (File)
 	{
 		if (Attachments.HasItem(File))
 		{
 			Attachments.Delete(File);
 			if (File->GetObject())
 			{
 				auto r = File->GetObject()->Delete();
 				if (r > Store3Error)
 				{
 					auto o = File->GetObject();
 					if (o->IsOrphan())
 						o = NULL; // SetObject will delete...
 					File->SetObject(NULL, false, _FL);
 					DeleteObj(o);
 				}
 			}
 
 			File->DecRef();
 			File = NULL;
 
 			if (Attachments.Length() == 0)
 			{
 				// Remove attachments flag
 				SetFlags(GetFlags() & (~MAIL_ATTACHMENTS));
 			}
 
 			Update();
 
 			if (Ui)
 			{
 				Ui->OnAttachmentsChange();
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool Mail::UnloadAttachments()
 {
 	for (auto it = Attachments.begin(); it != Attachments.end(); )
 	{
 		Attachment *a = *it;
 		if (!a->DecRef())
 			it++;
 	}
 
 	return true;
 }
 
 LArray<Attachment*> Mail::GetAttachments()
 {
 	LArray<Attachment*> result;
 
 	LArray<LDataI*> Lst;
 	if (GetAttachmentObjs(Lst))
 	{
 		LHashTbl<PtrKey<LDataI*>, bool> Loaded;
 		for (size_t i=0; i<Attachments.Length(); i++)
 		{
 			Loaded.Add(Attachments[i]->GetObject(), true);
 		}
 
 		// Load attachments
 		for (unsigned i=0; i<Lst.Length(); i++)
 		{
 			LDataI *Att = Lst[i];
 			if (!Loaded.Find(Att))
 			{
 				Attachment *k = new Attachment(App, Att);
 				if (k)
 				{
 					k->SetOwner(this);
 					Attachments.Insert(k);
 				}
 			}
 		}
 	}
 
 	for (auto a: Attachments)
 	{
 		if (a->GetObject()->UserData != a)
 			LAssert(!"Wut?");
 		else
 			result.Add(a);
 	}
 	
 	return result;
 }
 
 bool Mail::GetAttachments(List<Attachment> *Files)
 {
 	if (!Files)
 		return false;
 	auto files = GetAttachments();
 	for (auto a: files)
 		Files->Add(a);
 	return true;
 }
 
 int64 Mail::TotalSizeof()
 {
 	if (TotalSizeCache < 0)
 	{
 		int Size = GetObject() ? (int)GetObject()->GetInt(FIELD_SIZE) : -1;
 		if (Size >= 0)
 		{
 			TotalSizeCache = Size;
 		}
 		else
 		{
 			TotalSizeCache =	((GetBody()) ? strlen(GetBody()) : 0) +
 								((GetHtml()) ? strlen(GetHtml()) : 0);
 
 			List<Attachment> Attachments;
 			if (GetAttachments(&Attachments))
 			{
 				for (auto a: Attachments)
 				{
 					TotalSizeCache += a->GetSize();
 				}
 			}
 		}
 	}
 
 	return TotalSizeCache;
 }
 
 bool Mail::_GetListItems(List<LListItem> &l, bool All)
 {
 	LList *ParentList = LListItem::Parent;
 
 	l.Empty();
 
 	if (All)
 	{
 		if (ParentList)
 		{
 			ParentList->GetAll(l);
 		}
 		else
 		{
 			l.Insert(this);
 		}
 	}
 	else
 	{
 		if (ParentList)
 		{
 			ParentList->GetSelection(l);
 		}
 		else if (Select())
 		{
 			l.Insert(this);
 		}
 	}
 
 	return l.Length() > 0;
 }
 
 void Mail::GetThread(List<Mail> &Thread)
 {
 	MContainer *c;
 	for (c=Container; c->Parent; c=c->Parent);
 	List<MContainer> Stack;
 	Stack.Insert(c);
 	while ((c=Stack[0]))
 	{
 		Stack.Delete(c);
 		
 		for (unsigned i=0; i<c->Children.Length(); i++)
 		    Stack.Insert(c->Children[i]);
 		
 		if (c->Message && !Thread.HasItem(c->Message))
 		{
 			Thread.Insert(c->Message);
 		}
 	}
 }
 
 void Mail::SetListRead(bool Read)
 {
 	List<LListItem> Sel;
 	if (!_GetListItems(Sel, false))
 		return;
 
 	LArray<LDataI*> a;
 	for (auto t: Sel)
 	{
 		auto m = dynamic_cast<Mail*>(t);
 		if (!m)
 			continue;
 
 		bool isRead = (m->GetFlags() & MAIL_READ) != 0;
 		if (Read ^ isRead)
 			a.Add(m->GetObject());
 	}
 
 	if (!a.Length())
 		return;
 
 	auto Store = a[0]->GetStore();
 	if (!Store)
 	{
 		LAssert(0);
 		return;
 	}
 
 	LVariant read = MAIL_READ;
 	Store->Change(a, FIELD_FLAGS, read, Read ? OpPlusEquals : OpMinusEquals);
 }
 
 void SetFolderCallback(LInput *Dlg, LViewI *EditCtrl, void *Param)
 {
 	ScribeWnd *App = (ScribeWnd*) Param;
 	auto Str = EditCtrl->Name();
 	auto Select = new FolderDlg(Dlg, App, MAGIC_MAIL, 0, Str);
 	Select->DoModal([&](auto dlg, auto id)
 	{
 		if (id)
 			EditCtrl->Name(Select->Get());
 		delete dlg;
 	});
 }
 
 void Mail::DoContextMenu(LMouse &m, LView *p)
 {
 	#ifdef _DEBUG
 	LAutoPtr<LProfile> Prof(new LProfile("Mail::DoContextMenu"));
 	Prof->HideResultsIfBelow(100);
 	#endif
 	
 	if (!p)
 		p = Parent;
 
 	// open the right click menu
 	MarkedState MarkState = MS_None;
 	
 	// Pre-processing for marks
 	List<LListItem> Sel;
 	if (_GetListItems(Sel, false))
 	{
 		int Marked = 0;
 		for (auto t: Sel)
 		{
 			Mail *m = dynamic_cast<Mail*>(t);
 			if (m)
 			{
 				if (m->GetMarkColour())
 				{
 					Marked++;
 				}
 			}
 		}
 
 		if (Marked == 1)
 		{
 			MarkState = MS_One;
 		}
 		else if (Marked)
 		{
 			MarkState = MS_Multiple;
 		}
 	}
 
 	#ifdef _DEBUG
 	Prof->Add("CreateMenu");
 	#endif
 
 	// Create menu
 	LScriptUi s(new LSubMenu);
 	if (s.Sub)
 	{
 		/*
 		Keyboard shortcuts:
 
 		o - Open
 		d - Delete
 		x - Export
 		e - Set read
 		u - Set unread
 		r - Reply
 		a - Reply all
 		f - Forward
 		b - Bounce
 		m - Mark
 		s - Select marked
 		c - Create filter
 		i - Inspect
 		p - Properties
 		
 		*/
 		LMenuItem *i;
 		s.Sub->SetImageList(App->GetIconImgList(), false);
 
 		s.Sub->AppendItem(LLoadString(IDS_OPEN), IDM_OPEN, true);
 		i = s.Sub->AppendItem(LLoadString(IDS_DELETE), IDM_DELETE, true);
 		i->Icon(ICON_TRASH);
 		s.Sub->AppendItem(LLoadString(IDS_EXPORT), IDM_EXPORT, true);
 		int AttachBaseMsg = 10000;
 
 		#ifdef _DEBUG
 		Prof->Add("GetAttachments");
 		#endif
 
 		List<Attachment> AttachLst;
 		if (GetAttachments(&AttachLst) &&
 			AttachLst[0])
 		{
 			LSubMenu *Attachments = s.Sub->AppendSub(LLoadString(IDS_SAVE_ATTACHMENT_AS));
 			if (Attachments)
 			{
 				int n=0;
 				for (auto a: AttachLst)
 				{
 					auto Name = a->GetName();
 					Attachments->AppendItem(Name?Name:(char*)"Attachment.txt", AttachBaseMsg+(n++), true);
 				}
 			}
 		}
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Read/Unread");
 		#endif
 
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_SET_READ), 'e'), IDM_SET_READ, true);
 		i->Icon(ICON_READ_MAIL);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_SET_UNREAD), 'u'), IDM_SET_UNREAD, true);
 		i->Icon(ICON_UNREAD_MAIL);
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Reply/Bounce");
 		#endif
 
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_REPLY), 'r'), IDM_REPLY, true);
 		i->Icon(ICON_FLAGS_REPLY);
 		s.Sub->AppendItem(AddAmp(LLoadString(IDS_REPLYALL), 'a'), IDM_REPLY_ALL, true);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_FORWARD), 'f'), IDM_FORWARD, true);
 		i->Icon(ICON_FLAGS_FORWARD);
 		i = s.Sub->AppendItem(AddAmp(LLoadString(IDS_BOUNCE), 'b'), IDM_BOUNCE, true);
 		i->Icon(ICON_FLAGS_BOUNCE);
 		s.Sub->AppendSeparator();
 
 		#ifdef _DEBUG
 		Prof->Add("Thread");
 		#endif
 
 		if (App->GetCtrlValue(IDM_THREAD))
 		{
 			auto Thread = s.Sub->AppendSub(LLoadString(IDS_THREAD));
 			if (Thread)
 			{
 				Thread->AppendItem(LLoadString(IDS_THREAD_SELECT), IDM_SELECT_THREAD, true);
 				Thread->AppendItem(LLoadString(IDS_THREAD_DELETE), IDM_DELETE_THREAD, true);
 				Thread->AppendItem(LLoadString(IDS_THREAD_IGNORE), IDM_IGNORE_THREAD, true);
 				s.Sub->AppendSeparator();
 			}
 		}
 
 		#ifdef _DEBUG
 		Prof->Add("Mark");
 		#endif
 
 		auto MarkMenu = s.Sub->AppendSub(AddAmp(LLoadString(IDS_MARK), 'm'));
 		if (MarkMenu)
 		{
 			BuildMarkMenu(MarkMenu, MarkState, (uint32_t)GetMarkColour(), true);
 		}
 
 		MarkMenu = s.Sub->AppendSub(AddAmp(LLoadString(IDS_SELECT_MARKED), 's'));
 		if (MarkMenu)
 		{
 			BuildMarkMenu(MarkMenu, MS_Multiple, 0, true, true, true);
 		}
 
 		s.Sub->AppendSeparator();
 		s.Sub->AppendItem(AddAmp(LLoadString(IDS_INSPECT), 'i'), IDM_INSPECT, true);
 		s.Sub->AppendItem(LLoadString(IDS_PROPERTIES), IDM_PROPERTIES, true);
 
 		#ifdef _DEBUG
 		Prof->Add("ScriptCallbacks");
 		#endif
 
 		LArray<LScriptCallback*> Callbacks;
 		if (App->GetScriptCallbacks(LThingContextMenu, Callbacks))
 		{
 			LScriptArguments Args(NULL);
 			Args[0] = new LVariant(App);
 			Args[1] = new LVariant(this);
 			Args[2] = new LVariant(&s);
 			
 			for (auto c: Callbacks)
 				App->ExecuteScriptCallback(*c, Args);
 			
 			Args.DeleteObjects();
 		}
 
 		m.ToScreen();
 		int Result;
 
 		#ifdef _DEBUG
 		Prof.Reset();
 		#endif
 
 		int Btn = 0;
 		if (m.Left())
 			Btn = LSubMenu::BtnLeft;
 		else if (m.Right())
 			Btn = LSubMenu::BtnRight;
 
 		Result = s.Sub->Float(p, m.x, m.y);
 		switch (Result)
 		{
 			case IDM_OPEN:
 			{
 				DoUI();
 				break;
 			}
 			case IDM_DELETE:
 			{
 				LVariant ConfirmDelete = false;
 				App->GetOptions()->GetValue(OPT_ConfirmDelete, ConfirmDelete);
 
 				if (!ConfirmDelete.CastInt32() ||
 					LgiMsg(GetList(), LLoadString(IDS_DELETE_ASK), AppName, MB_YESNO) == IDYES)
 				{
 					if (_GetListItems(Sel, false))
 					{
 						int Index = -1;
 						LList *TheList = LListItem::Parent;
 						LArray<Thing*> Items;
 
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (m)
 							{
 								if (Index < 0) Index = TheList->IndexOf(m);
 								Items.Add(m);
 							}
 						}
 						
 						GetFolder()->Delete(Items, true);
 
 						if (Index >= 0)
 						{
 							LListItem *i = TheList->ItemAt(Index);
 							if (i) i->Select(true);
 						}
 					}
 				}
 				break;
 			}
 			case IDM_EXPORT:
 			{
 				ExportAll(Parent, sMimeMessage, NULL);
 				break;
 			}
 			case IDM_REPLY:
 			case IDM_REPLY_ALL:
 			{
 				App->MailReplyTo(this, Result == IDM_REPLY_ALL);
 				SetDirty(false);
 				break;
 			}
 			case IDM_FORWARD:
 			{
 				App->MailForward(this);
 				SetDirty(false);
 				break;
 			}
 			case IDM_BOUNCE:
 			{
 				App->MailBounce(this);
 				SetDirty(false);
 				break;
 			}
 			case IDM_SET_READ:
 			{
 				SetListRead(true);
 				break;
 			}
 			case IDM_SET_UNREAD:
 			{
 				SetListRead(false);
 				break;
 			}
 			case IDM_INSPECT:
 			{
 				OnInspect();
 				break;
 			}
 			case IDM_PROPERTIES:
 			{
 				OnProperties();
 				break;
 			}
 			case IDM_SELECT_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->Select(true);
 					}
 				}
 				break;
 			}
 			case IDM_DELETE_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->OnDelete();
 					}
 				}
 				break;
 			}
 			case IDM_IGNORE_THREAD:
 			{
 				if (_GetListItems(Sel, false))
 				{
 					List<Mail> Thread;
 					for (auto s: Sel)
 					{
 						Mail *m = dynamic_cast<Mail*>(s);
 						if (m)
 							m->GetThread(Thread);
 					}
 					for (auto m: Thread)
 					{
 						m->SetFlags(m->GetFlags() | MAIL_IGNORE | MAIL_READ);
 					}
 				}
 				break;
 			}
 			case IDM_UNMARK:
 			case IDM_SELECT_NONE:
 			case IDM_SELECT_ALL:
 			default:
 			{
 				if (Result == IDM_UNMARK ||
 					(Result >= IDM_MARK_BASE && Result < IDM_MARK_BASE+CountOf(MarkColours32)))
 				{
 					bool Marked = Result != IDM_UNMARK;
 
 					if (_GetListItems(Sel, false))
 					{
 						COLOUR Col32 = Marked ? MarkColours32[Result - IDM_MARK_BASE] : 0;
 
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (m)
 							{
 								if (m->SetMarkColour(Col32))
 								{
 									if (m->GetObject()->GetInt(FIELD_STORE_TYPE) != Store3Imap) // Imap knows to save itself.
 										m->SetDirty();
 								}
 								m->Update();
 							}
 						}
 					}
 				}
 				else if (Result == IDM_SELECT_NONE ||
 						 Result == IDM_SELECT_ALL ||
 						(Result >= IDM_MARK_SELECT_BASE && Result < IDM_MARK_SELECT_BASE+CountOf(MarkColours32)))
 				{
 					bool None = Result == IDM_SELECT_NONE;
 					bool All = Result == IDM_SELECT_ALL;
 					uint32_t c32 = MarkColours32[Result - IDM_MARK_SELECT_BASE];
 
 					if (_GetListItems(Sel, true))
 					{
 						for (auto s: Sel)
 						{
 							Mail *m = dynamic_cast<Mail*>(s);
 							if (!m)
 								break;
 
 							auto CurCol = m->GetMarkColour();
 							if (None)
 							{
 								m->Select(CurCol <= 0);
 							}
 							else
 							{
 								if (CurCol > 0)
 								{
 									if (All)
 									{
 										m->Select(true);
 									}
 									else
 									{
 										m->Select(CurCol && CurCol == c32);
 									}
 								}
 								else
 								{
 									m->Select(false);
 								}
 							}
 						}
 					}
 				}
 				else if (Result >= AttachBaseMsg &&
 						 Result < AttachBaseMsg + (ssize_t)AttachLst.Length())
 				{
 					// save attachment as...
 					Attachment *a = AttachLst.ItemAt(Result - AttachBaseMsg);
 					if (a)
 					{
 						a->OnSaveAs(Parent);
 					}
 				}
 				else
 				{
 					// Handle any installed callbacks for menu items
 					for (unsigned i=0; i<s.Callbacks.Length(); i++)
 					{
 						LScriptCallback &Cb = s.Callbacks[i];
 						if (Cb.Param == Result)
 						{
 							LScriptArguments Args(NULL);
 							Args[0] = new LVariant(App);
 							Args[1] = new LVariant(this);
 							Args[2] = new LVariant(Cb.Param);
 							
 							App->ExecuteScriptCallback(Cb, Args);
 						}
 					}
 				}
 				break;
 			}
 		}
 
 		DeleteObj(s.Sub);
 	}
 }
 
 void Mail::OnMouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		if (!m.IsContextMenu())
 		{
 			if (m.Double())
 			{
 				// open the UI for the Item
 				DoUI();
 			}
 		}
 		else
 		{
 			DoContextMenu(m);
 		}
 	}
 }
 
 void Mail::OnCreate()
 {
 	LOptionsFile *Options = App->GetOptions();
 	LVariant v;
 	if (GetObject()) GetObject()->SetInt(FIELD_FLAGS, MAIL_CREATED);
 
 	// Get identity and set from info
 	ScribeAccount *Ident = App->GetCurrentAccount();
 	if (Ident)
 	{
 		v = Ident->Identity.Name();
 		GetFrom()->SetStr(FIELD_NAME, v.Str());
 		v = Ident->Identity.Email();
 		GetFrom()->SetStr(FIELD_EMAIL, v.Str());
 		
 		v = Ident->Identity.ReplyTo();
 		if (v.Str())
 			GetReply()->SetStr(FIELD_REPLY, v.Str());
 	}
 	else
 	{
 		LAssert(!"No identity selected");
 	}
 
 	LVariant EditCtrl;
 	App->GetOptions()->GetValue(OPT_EditControl, EditCtrl);
 	LAutoString Sig = GetSig(EditCtrl.CastInt32() != 0, Ident);
 	if (!Sig && EditCtrl.CastInt32())
 	{
 		Sig = GetSig(false, Ident);
 		SetBody(Sig);
 	}
 	else if (EditCtrl.CastInt32())
 		SetHtml(Sig);
 	else
 		SetBody(Sig);
 
 	LVariant ClipRecip;
 	if (Options->GetValue(OPT_RecipientFromClipboard, ClipRecip) &&
 		ClipRecip.CastInt32())
 	{
 		LClipBoard Clip(App);
 		char *Txt = Clip.Text();
 		if (Txt && strchr(Txt, '@') && strlen(Txt) < 100)
 		{
 			for (char *s=Txt; *s; s++)
 			{
 				if (*s == '\n' || *s == '\r')
 				{
 					*s = 0;
 				}
 			}
 
 			Mailto mt(App, Txt);
 
 			for (auto a: mt.To)
 			{
 				LDataPropI *OldA = dynamic_cast<LDataPropI*>(a);
 				if (OldA)
 				{
 					LDataPropI *NewA = GetTo()->Create(GetObject()->GetStore());
 					if (NewA)
 					{
 						NewA->CopyProps(*OldA);
 						GetTo()->Insert(NewA);
 					}
 				}
 			}
 			mt.To.Empty();
 			
 			if (mt.Subject && !ValidStr(GetSubject()))
 			{
 				SetSubject(mt.Subject);
 			}
 
 			/*
 			if (_strnicmp(Txt, MailToStr, 7) == 0)
 			{
 				char *Question = strchr(Txt + 7, '?');
 				if (Question)
 				{
 					*Question = 0;
 					Question++;
 
 					int Len = strlen(SubjectStr);
 					if (_strnicmp(Question, SubjectStr, Len) == 0)
 					{
 						Subject = NewStr(Question + Len);
 					}
 				}
 
 				La->Addr = NewStr(Txt + 7);
 			}
 			else
 			{
 				La->Addr = NewStr(Txt);
 			}
 
 			To.Insert(La);
 			*/
 		}
 	}
 
 	Update();
 }
 
 void Mail::CreateMailHeaders()
 {
 	LStringPipe Hdrs(256);
 	MailProtocol Protocol;
 	LVariant HideId;
     App->GetOptions()->GetValue(OPT_HideId, HideId);
 	Protocol.ProgramName = GetFullAppName(!HideId.CastInt32());
 		
 	LDataI *Obj = GetObject();
 	if (Obj && ::CreateMailHeaders(App, Hdrs, Obj, &Protocol))
 	{
 		LAutoString FullHdrs(Hdrs.NewStr());
 		Obj->SetStr(FIELD_INTERNET_HEADER, FullHdrs);
 	}
 	else LAssert(!"CreateMailHeaders failed.");
 }
 
 bool Mail::OnBeforeSend(ScribeEnvelope *Out)
 {
 	if (!Out)
 	{
 		LAssert(!"No output envelope.");
 		return false;
 	}
 	
 	// First check the email from address...
 	if (!ValidStr(GetFrom()->GetStr(FIELD_EMAIL)))
 	{
 		LOptionsFile *Options = App->GetOptions();
 		if (Options)
 		{
 			ScribeAccount *Ident = App->GetAccounts()->ItemAt(App->GetCurrentIdentity());
 			if (Ident)
 			{
 				LVariant v = Ident->Identity.Email();
 				GetFrom()->SetStr(FIELD_EMAIL, v.Str());
 				v = Ident->Identity.Name();
 				GetFrom()->SetStr(FIELD_NAME, v.Str());
 			}
 		}
 	}
 
 	Out->From = GetFromStr(FIELD_EMAIL);
 	LDataIt To = GetTo();
 	ContactGroup *Group = NULL;
 	for (LDataPropI *t = To->First(); t; t = To->Next())
 	{
 		LString Addr = t->GetStr(FIELD_EMAIL);
 		if (LIsValidEmail(Addr))
 			Out->To.New() = Addr;
 		else if ((Group = LookupContactGroup(App, Addr)))
 		{
 			LString::Array a = Group->GetAddresses();
 			Out->To.Add(a);
 		}
 	}
 
 	LDataPropI *Root = GetObject()->GetObj(FIELD_MIME_SEG);
 	if (!Root)
 	{
 		LAssert(!"No root element.");
 		return false;
 	}
 
 	// Check the headers have been created..
 	if (!Root->GetStr(FIELD_INTERNET_HEADER))
 		CreateMailHeaders();
 
 	Out->MsgId = GetMessageId(true);
 	
 	// Convert the mime stream
 	LMime Mime(ScribeTempPath());
 	LTempStream Buf(ScribeTempPath());
 	
 	Store3ToGMime(&Mime, Root);
 	
 	// Do the encode
 	if (!Mime.Text.Encode.Push(&Buf))
 	{
 		LAssert(!"Mime encode failed.");
 		return false;
 	}
 
 	Out->References = GetReferences();
 	Out->FwdMsgId = GetFwdMsgId();
 	Out->BounceMsgId = GetBounceMsgId();
 	
 	// Read the resulting string into the output envelope
 	int Sz = (int)Buf.GetSize();
 	Out->Rfc822.Length(Sz);
 	Buf.SetPos(0);
 	Buf.Read(Out->Rfc822.Get(), Sz);
 	Out->Rfc822.Get()[Sz] = 0;
 
 	return true;
 }
 
 void Mail::OnAfterSend()
 {
 	int f = GetFlags();
 	f |= MAIL_SENT | MAIL_READ;	// set sent flag
 	f &= ~MAIL_READY_TO_SEND;	// clear read to send flag
 
 	// LgiTrace("Setting flags: %x\n", f);
 	SetFlags(f);
 
 	LDateTime n;
 	n.SetNow();
 	SetDateSent(&n);
 	// LString s = GetDateSent()->Get();
 	// LgiTrace("Setting sent date: %s\n", s.Get());
 
 	Update();
 	SetDirty();
 
 	if (App)
 	{
 		ScribeFolder *Sent = App->GetFolder(FOLDER_SENT, GetObject());
 		if (Sent)
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			Sent->MoveTo(Items);
 		}
 	}
 }
 
 bool Mail::OnBeforeReceive()
 {
 	return true;
 }
 
 enum MimeDecodeMode
 {
 	MODE_FIELDS,
 	MODE_WAIT_MSG,
 	MODE_SEGMENT,
 	MODE_WAIT_TYPE,
 	MODE_WAIT_BOUNDRY
 };
 
 #define MF_UNKNOWN						1
 #define MF_SUBJECT						2
 #define MF_TO							3
 #define MF_FROM							4
 #define MF_REPLY_TO						5
 #define MF_CONTENT_TYPE					6
 #define MF_CC							7
 #define MF_CONTENT_TRANSFER_ENCODING	9
 #define MF_DATE_SENT					10
 #define MF_PRIORITY						11
 #define MF_COLOUR						12
 #define MF_DISPOSITIONNOTIFICATIONTO	13
 
 void MungCharset(Mail *Msg, bool &HasRealCs, ScribeAccount *Acc)
 {
 	if (ValidStr(Msg->GetBodyCharset()))
 	{
 		HasRealCs = true;
 	}
 
 	if (Acc)
 	{
 		// LCharset *Cs = 0;
 		if (Msg->GetBodyCharset() &&
 			stristr(Msg->GetBodyCharset(), "ascii") &&
 			Acc->Receive.AssumeAsciiCharset().Str())
 		{
 			Msg->SetBodyCharset(Acc->Receive.AssumeAsciiCharset().Str());
 			HasRealCs = false;
 		}
 		else if (!ValidStr(Msg->GetBodyCharset()) ||
 				!LGetCsInfo(Msg->GetBodyCharset()))
 		{
 			Msg->SetBodyCharset(Acc->Receive.Assume8BitCharset().Str());
 			HasRealCs = false;
 		}
 	}
 }
 
 bool Mail::OnAfterReceive(LStreamI *Msg)
 {
 	if (!Msg)
 		return false;
 
 	// Clear the codepage setting here so that we can
 	// check later, down the bottom we must set it to
 	// the default if it's not set anywhere along the
 	// way.
 	SetBodyCharset(0);
 
 	if (GetObject() &&
 		!GetObject()->SetRfc822(Msg))
 	{
 		LAssert(!"Failed to set mime content.");
 		return false;
 	}
 
 	// Now parse them into the meta fields...
 	GetObject()->ParseHeaders();
 	
 	ScribeAccount *Acc = GetAccountSentTo();
 	LAutoString ContentType;
 	
 	// Fill out any Contact's TimeZone if missing
 	LAutoString DateStr(InetGetHeaderField(GetInternetHeader(), "Date"));
 	LDateTime DateObj;
 	if (DateStr &&
 		DateObj.Decode(DateStr))
 	{
 	    double SenderTz = DateObj.GetTimeZoneHours();
 	    if (SenderTz != 0.0)
 	    {
 		    ListAddr *Sender = dynamic_cast<ListAddr*>(GetFrom());
 		    if (Sender)
 		    {
 				auto It = Sender->begin();
 				if (*It)
 				{
 					Contact *c = (*It)->GetContact();
 					if (c)
 					{
 						const char *Tz = "";
 						if (!c->Get(OPT_TimeZone, Tz) ||
 							atof(Tz) != SenderTz)
 						{
 							char s[32];
 							sprintf_s(s, sizeof(s), "%.1f", SenderTz);
 							c->Set(OPT_TimeZone, s);
 							c->SetDirty(true);
 						}
 					}
 				}
 		    }
 	    }
 	}
 
 	auto BodyText = GetBody();
 	if (BodyText)
 	{
 		if (!GetBodyCharset())
 		{
 			if (Acc && Acc->Receive.Assume8BitCharset().Str())
 			{
 				SetBodyCharset(Acc->Receive.Assume8BitCharset().Str());
 			}
 			else
 			{
 				SetBodyCharset("us-ascii");
 			}
 		}
 
 		LStringPipe NewBody;
 		LArray<LDataI*> Files;
 		if (DecodeUuencodedAttachment(GetObject()->GetStore(), Files, &NewBody, BodyText))
 		{
 			LDataI *AttachPoint = GetFileAttachPoint();
 			if (AttachPoint)
 			{
 				for (unsigned i=0; i<Files.Length(); i++)
 				{
 					Files[i]->SetStr(FIELD_MIME_TYPE, sAppOctetStream);
 					Files[i]->Save(AttachPoint);
 				}
 
 				SetDirty(!TestFlag(GetFlags(), MAIL_ATTACHMENTS));
 				SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 
 				LAutoString n(NewBody.NewStr());
 				SetBody(n);
 
 				Update();
 				if (Ui) Ui->OnAttachmentsChange();
 			}
 		}
 	}
 
 	LDateTime n;
 	n.SetNow();
 	SetDateReceived(&n);
 
 	Update();
 	SetDirty();
 
 	// Call any 'after receive' callbacks
 	LArray<LScriptCallback*> Callbacks;
 	if (App->GetScriptCallbacks(LMailOnAfterReceive, Callbacks))
 	{
 		for (auto c: Callbacks)
 		{
 			if (!c->Func)
 				continue;
 
 			LVirtualMachine Vm;				
 			LScriptArguments Args(&Vm);
 			Args.New() = new LVariant(App);
 			Args.New() = new LVariant(this);
 			App->ExecuteScriptCallback(*c, Args);
 			Args.DeleteObjects();
 		}
 	}
 
 	return true;
 }
 
 ThingUi *Mail::GetUI()
 {
 	return Ui;
 }
 
 LVariant Mail::GetServerUid()
 {
 	LVariant v;
 	
 	if (GetObject())
 	{
 		auto Type = (Store3Backend)GetObject()->GetInt(FIELD_STORE_TYPE);
 		if (Type == Store3Imap)
 			v = GetObject()->GetInt(FIELD_SERVER_UID);
 		else
 			v = GetObject()->GetStr(FIELD_SERVER_UID);
 	}
 	else LAssert(!"No object.");
 
 	return v;
 }
 
 bool Mail::SetServerUid(LVariant &v)
 {
 	if (!GetObject())
 		return false;
 	
 	Store3Status s;
 	if (GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 		s = GetObject()->SetInt(FIELD_SERVER_UID, v.CastInt32());
 	else
 		s = GetObject()->SetStr(FIELD_SERVER_UID, v.Str());
 
 	return s > Store3Error;
 }
 
 bool Mail::SetObject(LDataI *o, bool IsDestructor, const char *File, int Line)
 {
 	bool b = LDataUserI::SetObject(o, IsDestructor, File, Line);
 	if (b)
 	{
 		// Clear out stale attachment objects...
 		UnloadAttachments();
 	}
 	return b;
 }
 
 bool Mail::SetUI(ThingUi *new_ui)
 {
 	MailUi *NewMailUi = dynamic_cast<MailUi*>(new_ui);
 	if (NewMailUi == Ui)
 		return true;
 
 	if (Ui)
 	{
 		LWindow *w = Ui;
 		Ui->SetItem(0);
 		w->Quit();
 		LAssert(Ui == NULL);
 	}
 	
 	if (new_ui)
 	{
 		Ui = dynamic_cast<MailUi*>(new_ui);
 		if (Ui)
 			Ui->SetItem(this);
 		else
 			LAssert(!"Incorrect object.");
 	}
 	
 	return true;
 }
 
 ThingUi *Mail::DoUI(MailContainer *c)
 {
 	if (App &&
 		!Ui)
 	{
 		if (App->InThread())
 		{
 			Ui = new MailUi(this, c ? c : GetFolder());
 		}
 		else
 		{
             App->PostEvent(M_SCRIBE_OPEN_THING, (LMessage::Param)this, 0);
 		}
 	}
 
 	if (Ui)
 	{
 		#if WINNATIVE
 		SetActiveWindow(Ui->Handle());
 		#endif
 	}
 
 	return Ui;
 }
 
 int Mail::Compare(LListItem *t, ssize_t Field)
 {
 	Thing *T = (Thing*)t->_UserPtr;
 	Mail *m = T ? T->IsMail() : 0;
 	if (m)
 	{
 		static int Fields[] = {FIELD_FROM, FIELD_SUBJECT, FIELD_SIZE, FIELD_DATE_RECEIVED};
 		if (Field < 0)
 		{
 			auto i = -Field - 1;
 			if (i >= 0 && i < CountOf(Fields))
 			{
 				Field = Fields[i];
 			}
 		}
 
 		LVariant v1, v2;
 		const char *s1 = "", *s2 = "";
 		switch (Field)
 		{
 			case 0:
 			{
 				break;
 			}
 			case FIELD_TO:
 			{
 				LDataPropI *a1 = GetTo()->First();
 				if (a1)
 				{
 					if (a1->GetStr(FIELD_NAME)) s1 = a1->GetStr(FIELD_NAME);
 					else if (a1->GetStr(FIELD_EMAIL)) s1 = a1->GetStr(FIELD_EMAIL);
 				}
 
 				LDataPropI *a2 = m->GetTo()->First();
 				if (a2)
 				{
 					if (a2->GetStr(FIELD_NAME)) s2 = a2->GetStr(FIELD_NAME);
 					else if (a2->GetStr(FIELD_EMAIL)) s2 = a2->GetStr(FIELD_EMAIL);
 				}
 				break;
 			}
 			case FIELD_FROM:
 			{
 				LDataPropI *f1 = GetFrom();
 				LDataPropI *f2 = m->GetFrom();
 
 				if (f1->GetStr(FIELD_NAME)) s1 = f1->GetStr(FIELD_NAME);
 				else if (f1->GetStr(FIELD_EMAIL)) s1 = f1->GetStr(FIELD_EMAIL);
 
 				if (f2->GetStr(FIELD_NAME)) s2 = f2->GetStr(FIELD_NAME);
 				else if (f2->GetStr(FIELD_EMAIL)) s2 = f2->GetStr(FIELD_EMAIL);
 				break;
 			}
 			case FIELD_SUBJECT:
 			{
 				s1 = GetSubject();
 				s2 = m->GetSubject();
 				break;
 			}
 			case FIELD_SIZE:
 			{
 				return (int) (TotalSizeof() - m->TotalSizeof());
 				break;
 			}
 			case FIELD_DATE_SENT:
 			{
 			    auto Sent1 = GetDateSent();
 			    auto Sent2 = m->GetDateSent();
 			    if (!Sent1 || !Sent2)
 			        break;
 				return Sent1->Compare(Sent2);
 				break;
 			}
 			case FIELD_DATE_RECEIVED:
 			{
 				return GetDateReceived()->Compare(m->GetDateReceived());
 				break;
 			}
 			case FIELD_PRIORITY:
 			{
 				return GetPriority() - m->GetPriority();
 				break;
 			}
 			case FIELD_FLAGS:
 			{
 				int Mask = MAIL_FORWARDED | MAIL_REPLIED | MAIL_READ;
 				return (GetFlags() & Mask) - (m->GetFlags() & Mask);
 				break;
 			}
 			case FIELD_LABEL:
 			{
 				if (GetLabel()) s1 = GetLabel();
 				if (m->GetLabel()) s2 = m->GetLabel();
 				break;
 			}
 			case FIELD_MESSAGE_ID:
 			{
 				s1 = GetMessageId();
 				s2 = m->GetMessageId();
 				break;
 			}
 			case FIELD_FROM_CONTACT_NAME:
 			{
 				s1 = GetFieldText(FIELD_FROM_CONTACT_NAME);
 				s2 = m->GetFieldText(FIELD_FROM_CONTACT_NAME);
 				break;
 			}
 			case FIELD_SERVER_UID:
 			{
 				v1 = GetServerUid();
 				v2 = m->GetServerUid();
 				if (v1.Str() && v2.Str())
 				{
 					s1 = v1.Str();
 					s2 = v2.Str();					
 				}
 				else
 				{
 					auto diff = v1.CastInt64() - v2.CastInt64();
 					if (diff < 0) return -1;
 					return diff > 1;
 				}
 			}
 			default:
 			{
 				s1 = GetObject() ? GetObject()->GetStr((int)Field) : 0;
 				s2 = m->GetObject() ? m->GetObject()->GetStr((int)Field) : 0;
 				break;
 			}
 		}
 
 		const char *Empty = "";
 		return _stricmp(s1?s1:Empty, s2?s2:Empty);
 	}
 
 	return -1;
 }
 
 class MailPropDlg : public LDialog
 {
 	List<Mail> Lst;
 	LViewI *Table = NULL;
 
 	struct FlagInfo
 	{
 		int Flag = 0, Ctrl = 0;
 
 		void Set(int f, int c)
 		{
 			Flag = f;
 			Ctrl = c;
 		}
 	};
 	LArray<FlagInfo> Flags;
 
 public:
 	MailPropDlg(LView *Parent, List<Mail> &lst)
 	{
 		SetParent(Parent);
 		
 		Lst = lst;
 
 		Flags.New().Set(MAIL_SENT, IDC_SENT);
 		Flags.New().Set(MAIL_RECEIVED, IDC_RECEIVED);
 		Flags.New().Set(MAIL_CREATED, IDC_CREATED);
 		Flags.New().Set(MAIL_FORWARDED, IDC_FORWARDED);
 		Flags.New().Set(MAIL_REPLIED, IDC_REPLIED);
 		Flags.New().Set(MAIL_ATTACHMENTS, IDC_HAS_ATTACH);
 		Flags.New().Set(MAIL_READ, IDC_READ);
 		Flags.New().Set(MAIL_READY_TO_SEND, IDC_READY_SEND);
 
 		if (LoadFromResource(IDD_MAIL_PROPERTIES))
 		{
 			GetViewById(IDC_TABLE, Table);
 			LAssert(Table != NULL);
 			SetCtrlEnabled(IDC_OPEN_INSPECTOR, Lst.Length() == 1);
 			
 			for (auto &i: Flags)
 			{
 				int Set = 0;
 				for (auto m: Lst)
 				{
 					if (m->GetFlags() & i.Flag)
 						Set++;
 				}
 				
 				if (Set == Lst.Length())
 				{
 					SetCtrlValue(i.Ctrl, LCheckBox::CheckOn);
 				}
 				else if (Set)
 				{
 					LCheckBox *Cb;
 					if (GetViewById(i.Ctrl, Cb))
 						Cb->ThreeState(true);
 
 					SetCtrlValue(i.Ctrl, LCheckBox::CheckPartial);
 				}
 			}
 
 			SetCtrlEnabled(IDC_HAS_ATTACH, false);
 
 			char Msg[512] = "";
 			if (Lst.Length() == 1)
 			{
 				Mail *m = Lst[0];
 				auto mObj = m->GetObject();
 				if (mObj)
 				{
 					auto dt = mObj->GetDate(FIELD_DATE_RECEIVED);
 					sprintf_s(	Msg, sizeof(Msg),
 								LLoadString(IDS_MAIL_PROPS_DLG),
 								LFormatSize(mObj->GetInt(FIELD_SIZE)).Get(),
 								dt ? dt->Get().Get() : LLoadString(IDS_NONE),
 								mObj->GetStr(FIELD_DEBUG));
 
 					SetCtrlName(IDC_MSG_ID, mObj->GetStr(FIELD_MESSAGE_ID));
 				}
 			}
 			else
 			{
 				sprintf_s(Msg, sizeof(Msg), LLoadString(IDS_MULTIPLE_ITEMS), Lst.Length());
 				SetCtrlEnabled(IDC_MSG_ID, false);
 			}
 			SetCtrlName(IDC_MAIL_DESCRIPTION, Msg);
 
 			MoveSameScreen(Parent);
 		}
 	}
 	
 	void OnPosChange()
 	{
 		if (Table)
 		{
 			LRect r = GetClient();
 			r.Inset(LTableLayout::CellSpacing, LTableLayout::CellSpacing);
 			Table->SetPos(r);
 		}
 	}
 
 	int OnNotify(LViewI *Ctr, LNotification n)
 	{
 		switch (Ctr->GetId())
 		{
 			case IDC_OPEN_INSPECTOR:
 			{
 				if (Lst.Length())
 					Lst[0]->OnInspect();
 				break;
 			}
 			case IDOK:
 			{
 				for (auto &i: Flags)
 				{
 					auto v = GetCtrlValue(i.Ctrl);
 					LAssert(v >= 0); // the control couldn't be found... check the .lr8 file
 					
 					for (auto m: Lst)
 					{
 						if (v == 1)
 							m->SetFlags(m->GetFlags() | i.Flag);
 						else if (v == 0)
 							m->SetFlags(m->GetFlags() & ~i.Flag);
 					}
 				}
 				// fall thru
 			}
 			case IDCANCEL:
 			{
 				EndModal(Ctr->GetId());
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 void Mail::OnInspect()
 {
 	new ObjectInspector(App, this);
 }
 
 void Mail::OnProperties(int Tab)
 {
 	List<LListItem> Sel;
 	if (GetList()->GetSelection(Sel))
 	{
 		List<Mail> Lst;
 		for (auto i: Sel)
 		{
 			Lst.Insert(dynamic_cast<Mail*>(i));
 		}
 		
 		if (Lst[0])
 		{
 			auto Dlg = new MailPropDlg(GetList(), Lst);
 			Dlg->DoModal([this, Dlg](auto dlg, auto id)
 			{
 				if (id == IDOK)
 				{
 					SetDirty();
 					Update();
 				}
 				delete dlg;
 			});
 		}
 	}
 }
 
 int Mail::GetImage(int SelFlags)
 {
 	if (TestFlag(GetFlags(), MAIL_READY_TO_SEND) &&
 		!TestFlag(GetFlags(), MAIL_SENT))
 	{
 		return ICON_UNSENT_MAIL;
 	}
 		
 	if (GetFlags() & MAIL_READ)
 	{
 		return (GetFlags() & MAIL_ATTACHMENTS) ? ICON_READ_ATT_MAIL : ICON_READ_MAIL;
 	}
 	else
 	{
 		return (GetFlags() & MAIL_ATTACHMENTS) ? ICON_UNREAD_ATT_MAIL : ICON_UNREAD_MAIL;
 	}
 
 	return ICON_READ_MAIL;
 }
 
 int *Mail::GetDefaultFields()
 {
 	return DefaultMailFields;
 }
 
 void Mail::DeleteAsSpam(LView *View)
 {
 	// Set read..
 	SetFlags(GetFlags() | MAIL_READ | MAIL_BAYES_SPAM, true);
 
 	// Remove from NewMail
 	NewMailLst.Delete(this);
 
 	LVariant DeleteOnServer, DeleteAttachments, SetRead;
 	auto Opts = App->GetOptions();
 	if (!Opts->GetValue(OPT_BayesDeleteOnServer, DeleteOnServer))
 		DeleteOnServer = false;
 	if (!Opts->GetValue(OPT_BayesDeleteAttachments, DeleteAttachments))
 		DeleteAttachments = false;
 	if (!Opts->GetValue(OPT_BayesSetRead, SetRead))
 		SetRead = false;
 
 	if (DeleteOnServer.CastBool())
 	{
 		// Tell the account it's spam... so that any further connects can
 		// delete it off the server.
 		ScribeAccount *a = GetAccountSentTo();
 		if (a)
 		{
 			auto ServerUid = GetServerUid();
 			if (ServerUid.Str())
 			{
 				a->Receive.DeleteAsSpam(ServerUid.Str());
 				SetServerUid(ServerUid = NULL);
 			}
 			else
 			{
 				LAutoString Uid(InetGetHeaderField(GetInternetHeader(), "X-UIDL"));
 				if (Uid)
 					a->Receive.DeleteAsSpam(Uid);
 			}
 		}
 		else
 		{
 			#if 0 // def _DEBUG
 			if (LgiMsg(Ui?(LView*)Ui:(LView*)App, "Debug: GetAccountSentTo failed. Debug?", AppName, MB_YESNO) == IDYES)
 			{
 				LAssert(0);
 			}
 			#endif
 		}
 	}
 
 	if (DeleteAttachments.CastBool())
 	{
 		// Delete all attachments... they're useless and more than likely
 		// just virii anyway.
 		List<Attachment> Files;
 		if (GetAttachments(&Files))
 		{
 			for (auto a: Files)
 			{
 				DeleteAttachment(a);
 			}
 			Files.Empty();
 		}
 	}
 
 	if (SetRead.CastInt32() != 0)
 	{
 		SetFlags(GetFlags() | MAIL_READ);
 	}
 
 	// Move it to the spam folder if it exists.
 	auto FolderPath = GetFolder()->GetPath();
 	LToken Parts(FolderPath, "/");
 	
 	if (Parts.Length() == 0)
 		LgiMsg(View, "Error: No folder path?", AppName);
 	else
 	{
 		LString SpamPath;
 		LString SpamLeaf = "Spam";
 		SpamPath.Printf("/%s/%s", Parts[0], SpamLeaf.Get());
 
 		ScribeFolder *Spam = App->GetFolder(SpamPath);
 		if (!Spam)
 		{
 			LMailStore *Ms = App->GetMailStoreForPath(FolderPath);
 			if (!Ms)
 			{
 				if (GetFolder()->GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 				{
 					Ms = App->GetDefaultMailStore();
 					if (Ms && Ms->Root)
 					{
 						Spam = Ms->Root->GetSubFolder(SpamLeaf);
 						if (!Spam)
 							Spam = Ms->Root->CreateSubDirectory(SpamLeaf, MAGIC_MAIL);
 					}
 				}
 				else
 					LgiMsg(View, "Error: Couldn't get mail store for '%s'.", AppName, MB_OK, FolderPath.Get());
 			}
 			else
 				Spam = Ms->Root->CreateSubDirectory("Spam", MAGIC_MAIL);
 		}
 
 		if (Spam && Spam != GetFolder())
 		{
 			LArray<Thing*> Items;
 			Items.Add(this);
 			if (!Spam->MoveTo(Items))
 			{
 				LgiMsg(View, "Error: Couldn't move email to spam folder.", AppName);
 			}
 		}
 	}
 }
 
 void Mail::SetFlagsCache(int64_t NewFlags, bool IgnoreReceipt, bool UpdateScreen)
 {
 	if (FlagsCache == NewFlags)
 		return;
 
 	DepthCheck Depth(d->InSetFlagsCache);
 		
 	bool Read1 = TestFlag(FlagsCache, MAIL_READ);
 	bool Read2 = TestFlag(NewFlags, MAIL_READ);
 	bool ChangeRead = Read1 ^ Read2;
 
 	// LgiTrace("%p::SetFlagsCache: %s -> %s\n", this, EmailFlagsToStr(FlagsCache).Get(), EmailFlagsToStr(StoreFlags).Get());
 	FlagsCache = NewFlags;
 
 	if (ChangeRead && App)
 	{
 		if (Read2)
 		{
 			// Becoming read
 			List<Mail> Objs;
 			Objs.Insert(this);
 			App->OnNewMail(&Objs, false);
 			PreviewCache.DeleteObjects();
 
 			// Read receipt
 			if (!IgnoreReceipt &&
 				!TestFlag(NewFlags, MAIL_CREATED) &&
 				TestFlag(NewFlags, MAIL_READ_RECEIPT))
 			{
 				LAutoString Header(InetGetHeaderField(GetInternetHeader(), "Disposition-Notification-To"));
 				if (Header)
 				{
 					LAutoString Name, Addr;
 					DecodeAddrName(Header, Name, Addr, 0);
 					if (Addr)
 					{
 						if (LgiMsg(	Ui != 0 ? (LView*)Ui : (LView*)App,
 									LLoadString(IDS_RECEIPT_ASK),
 									AppName,
 									MB_YESNO,
 									GetSubject(),
 									GetFrom()->GetStr(FIELD_NAME),
 									GetFrom()->GetStr(FIELD_EMAIL),
 									(char*)Name,
 									(char*)Addr) == IDYES)
 						{
 							Mail *m = new Mail(App);
 							if (m)
 							{
 								m->App = App;
 
 								LDataPropI *ToAddr = m->GetTo()->Create(m->GetObject()->GetStore());
 								if (ToAddr)
 								{
 									ToAddr->SetStr(FIELD_NAME, Name);
 									ToAddr->SetStr(FIELD_EMAIL, Addr);
 									m->GetTo()->Insert(ToAddr);
 								}
 									
 								m->OnReceipt(this);
 								m->Save();
 								App->Send();
 							}
 						}
 					}
 				}
 			}
 
 			LVariant Inc;
 			if (App->GetOptions()->GetValue(OPT_BayesIncremental, Inc) &&
 				Inc.CastInt32())
 			{
 				// Incremental bayesian update
 				App->OnBayesianMailEvent(this, BayesMailUnknown, BayesMailHam);
 			}
 		}
 
 		if (UpdateScreen)
 		{
 			// Changing read status
 			ScribeFolder *t = GetFolder();
 			if (t)
 				t->OnUpdateUnRead(0, true);
 		}
 	}
 
 	if (UpdateScreen || ChangeRead)
 	{
 		Update();
 	}
 }
 
 
 uint32_t Mail::GetFlags()
 {
 	if (GetObject())
 	{
 		// Make sure the objects are in sync...
 		auto StoreFlags = GetObject()->GetInt(FIELD_FLAGS);
 		if (FlagsCache < 0)
 			FlagsCache = StoreFlags;
 		else if (FlagsCache != StoreFlags)
 			SetFlagsCache(StoreFlags, false, true);
 	}
 
 	return (uint32_t)FlagsCache;
 }
 
 void Mail::SetFlags(ulong NewFlags, bool IgnoreReceipt, bool UpdateScreen)
 {
 	if (FlagsCache == NewFlags)
 		return;
 
 	DepthCheck SetFlagsDepth(d->InSetFlags);
 
 	if (GetObject())
 	{
 		Store3Status Result = GetObject()->SetInt(FIELD_FLAGS, NewFlags);
 		if (Result == Store3Success &&
 			GetObject()->IsOnDisk())
 		{
 			// Imap mail shouldn't fall in here.
 			SetDirty();
 		}
 	}
 	else
 	{
 		LAssert(0);
 		return;
 	}
 
 	SetFlagsCache(NewFlags, IgnoreReceipt, UpdateScreen);
 }
 
 const char *Mail::GetFieldText(int Field)
 {
 	static char Buf[512];
 
 	switch (Field)
 	{
 		case FIELD_TO:
 		{
 			size_t ch = 0;
 			Buf[0] = 0;
 			
 			LDataIt To = GetTo();
 			for (LDataPropI *a=To->First(); a; a=To->Next())
 			{
 				if (ch > 0)
 					ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, ", ");
 				
 				auto Name = a->GetStr(FIELD_NAME);
 				auto Addr = a->GetStr(FIELD_EMAIL);
 				auto n = Name ? Name : Addr;
 				if (!n)
 					continue;
 
 				// Is the buffer too small?
 				size_t n_len = strlen(n);
 				if (ch + n_len + 8 >= sizeof(Buf))
 				{
 					// Yes... just truncate it with "..." and bail.
 					ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, "...");
 					break;
 				}
 				ch += sprintf_s(Buf+ch, sizeof(Buf)-ch, "%s", n);
 				
 				LAssert(ch < sizeof(Buf) - 1);
 			}
 			return Buf;
 			break;
 		}
 		case FIELD_FROM_CONTACT_NAME:
 		{
 			static bool InMethod = false;
 			if (!InMethod)
 			{
 				InMethod = true;
 				
 				LDataPropI *la = GetFrom();
 				if (la)
 				{
 					auto Email = la->GetStr(FIELD_EMAIL);
 					Contact *c = Contact::LookupEmail(Email);
 					if (c)
 					{
 						const char *f = 0, *l = 0;
 						c->Get(OPT_First, f);
 						c->Get(OPT_Last, l);
 						
 						if (f && l)
 							sprintf_s(Buf, sizeof(Buf), "%s %s", f, l);
 						else if (f)
 							strcpy_s(Buf, sizeof(Buf), f);
 						else if (l)
 							strcpy_s(Buf, sizeof(Buf), l);
 						else
 							Buf[0] = 0;
 
 						InMethod = false;
 						return Buf;
 					}
 				}
 				
 				InMethod = false;
 			}
 			else
 			{
 				LAssert(0);
 			}
 			
 			// fall through
 		}
 		case FIELD_FROM:
 		{
 		    LDataPropI *f = GetFrom();
 			auto n = f->GetStr(FIELD_NAME);
 		    if (n)
 		        return n;
 
 			auto e = f->GetStr(FIELD_EMAIL);
 			if (e)
 			    return e;
 			break;
 		}
 		case FIELD_SUBJECT:
 			return GetSubject();
 		case FIELD_SIZE:
 		{
 			if (TotalSizeCache < 0)
 				TotalSizeof();
 				
 			if (OptionSizeInKiB)
 			{
 				int ch = sprintf_s(Buf, sizeof(Buf), "%.0f KiB", (double)TotalSizeCache/1024.0);
 				if (ch > 4 + 3)
 				{
 					int digits = ch - 4;
 					char *s = Buf + ((digits % 3) ? digits % 3 : 3);
 					char *e = Buf + ch - 4;
 					while (s < e)
 					{
 						memmove(s + 1, s, strlen(s)+1);
 						*s = ',';
 						s += 3;
 					}
 				}
 			}
 			else
 				LFormatSize(Buf, sizeof(Buf), TotalSizeCache);
 			return Buf;
 		}
 		case FIELD_DATE_SENT:
 		{
 			auto DateSent = GetDateSent();
 			if (DateSent->Year())
 			{
 				LDateTime dt = *DateSent;
 				if (GetObject() &&
 					GetObject()->GetInt(FIELD_STORE_TYPE) == Store3Imap)
 				{
 					ValidateImapDate(dt);
 				}
 
 			    if (AdjustDateTz)
 			    {
                     if (dt.GetTimeZone() != LDateTime::SystemTimeZone())
     			        dt.SetTimeZone(LDateTime::SystemTimeZone(), true);
 				}
 
 				if (ShowRelativeDates)
 				{
 					auto rel = RelativeTime(dt);
 					strcpy_s(Buf, sizeof(Buf), rel ? rel : "#error:RelativeTime");
 				}
 				else
 				{
 					dt.Get(Buf, sizeof(Buf));
 				}
 			}
 			else
 			{
 				sprintf_s(Buf, sizeof(Buf), "(%s)", LLoadString(IDS_NONE, "None"));
 			}			
 			return Buf;
 		}
 		case FIELD_DATE_RECEIVED:
 		{
 			auto DateReceived = GetDateReceived();
 			if (DateReceived->Year())
 			{
 		        LDateTime dt = *DateReceived;
 			    if (AdjustDateTz)
 			    {
                     if (dt.GetTimeZone() != LDateTime::SystemTimeZone())
     			        dt.SetTimeZone(LDateTime::SystemTimeZone(), true);
 			    }
 
 				dt.Get(Buf, sizeof(Buf));
 				if (ShowRelativeDates)
 				{
 					auto rel = RelativeTime(dt);
 					strcpy_s(Buf, sizeof(Buf), rel ? rel : "#error:RelativeTime");
 				}
 				else
 				{
 				    dt.Get(Buf, sizeof(Buf));
 				}
 			}
 			else
 			{
 				sprintf_s(Buf, sizeof(Buf), "(%s)", LLoadString(IDS_NONE, "None"));
 			}			
 			return Buf;
 		}
 		case FIELD_TEXT:
 			return GetBody();
 		case FIELD_MESSAGE_ID:
 			return GetMessageId();
 		case FIELD_INTERNET_HEADER:
 			return GetInternetHeader();
 		case FIELD_ALTERNATE_HTML:
 			return GetHtml();
 		case FIELD_LABEL:
 			return GetLabel();
 		case FIELD_PRIORITY:
 		case FIELD_FLAGS:
 			return 0;
 		case FIELD_SERVER_UID:
 			sprintf_s(Buf, sizeof(Buf), "%i", GetObject() ? (int)GetObject()->GetInt(Field) : -1);
 			return Buf;
 		case FIELD_RECEIVED_DOMAIN:
 		{
 			if (!d->DomainCache)
 			{
 				if (!GetObject())
 					return NULL;
 
 				auto hdr = GetObject()->GetStr(FIELD_INTERNET_HEADER);
 				if (!hdr)
 					return NULL;
 
 				for (auto ln: LString(hdr).SplitDelimit("\n"))
 				{
 					if (ln.Find("Received: from") == 0)
 					{
 						auto p = ln.SplitDelimit();
 						if (p.Length() > 2)
 						{
 							auto t = p[2];
 							if (t.Find(".") > 0)
 								d->DomainCache = t.Strip("[]");
 						}
 					}
 				}
 			}
 
 			return d->DomainCache;
 		}
 		default:
 			return GetObject() ? GetObject()->GetStr(Field) : NULL;
 	}
 
 	return 0;
 }
 
 int Mail::DefaultMailFields[] =
 {
 	/*
 	FIELD_FLAGS,
 	FIELD_PRIORITY,
 	*/
 	FIELD_FROM,
 	FIELD_SUBJECT,
 	FIELD_SIZE,
 	FIELD_DATE_SENT
 };
 
 const char *Mail::GetText(int i)
 {
 	if (FieldArray.Length())
 	{
 		if (i >= 0 && i < (int)FieldArray.Length())
 			return GetFieldText(FieldArray[i]);
 	}
 	else if (i < CountOf(DefaultMailFields))
 	{
 		return GetFieldText(DefaultMailFields[i]);
 	}
 	
 	return NULL;
 }
 
 LDataI *Mail::GetFileAttachPoint()
 {
 	if (!GetObject())
 	{
 		LAssert(!"No object ptr.");
 		return 0;
 	}
 
 	auto Store = GetObject()->GetStore();
 	
 	// Check existing root node for "multipart/mixed"?
 	auto r = dynamic_cast<LDataI*>(GetObject()->GetObj(FIELD_MIME_SEG));
 	if (!r)
 	{
 		// Create one...
 		r = Store->Create(MAGIC_ATTACHMENT);
 		if (!r)
 		{		
 			LAssert(!"No MIME segment ptr.");
 			return NULL;
 		}
 		
 		r->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 		if (!GetObject()->SetObj(FIELD_MIME_SEG, r))
 		{
 			LAssert(!"Can't set MIME segment.");
 			return NULL;
 		}
 	}
 
 	auto Mt = r->GetStr(FIELD_MIME_TYPE);
 	if (!Stricmp(Mt, sMultipartMixed))
 	{
 		// Yes is it mixed... return that...
 		return r;
 	}
 
 	// No, a different type of segment, make the parent segment a "mixed", and attach the old segment to the mixed
 	auto Mixed = Store->Create(MAGIC_ATTACHMENT);
 	if (!Mixed)
 	{
 		LAssert(!"Failed to create MAGIC_ATTACHMENT.");
 		return NULL;
 	}
 
 	// Set the type...
 	Mixed->SetStr(FIELD_MIME_TYPE, sMultipartMixed);
 
 	// Re-parent the content to the mixed
 	if (!r->Save(Mixed))
 	{
 		LAssert(!"Can't reparent the content into the mixed seg.");
 		return NULL;
 	}
 
 	// Re-parent the mixed to the mail object
 	if (!Mixed->Save(GetObject()))
 	{
 		LAssert(!"Can't reparent the mixed seg into the mail object.");
 		return NULL;
 	}
 
 	return Mixed;
 }
 
 bool Mail::AttachFile(Attachment *File)
 {
 	bool Status = false;
 
 	if (File && !Attachments.HasItem(File))
 	{
 		LDataI *AttachPoint = GetFileAttachPoint();
 		if (AttachPoint)
 		{
 			if (File->GetObject()->Save(AttachPoint))
 			{
 				File->App = App;
 				File->SetOwner(this);
 				Attachments.Insert(File);
 
 				Status = true;
 
 				SetDirty(!TestFlag(GetFlags(), MAIL_ATTACHMENTS));
 				SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 
 				Update();
 
 				if (Ui)
 				{
 					Ui->OnAttachmentsChange();
 				}
 			}
 		}
 		else
 		{
 			File->DecRef();
 		}
 	}
 
 	return Status;
 }
 
 Attachment *Mail::AttachFile(LView *Parent, const char *FileName)
 {
 	LString MimeType = ScribeGetFileMimeType(FileName);
 	LVariant Resize = false;
 	if (!Strnicmp(MimeType.Get(), "image/", 6))
 	{
 		// Check if we have to do a image resize
 		App->GetOptions()->GetValue(OPT_ResizeImgAttachments, Resize);
 	}
 
 	auto AttachPoint = GetFileAttachPoint();
 	if (!AttachPoint)
 	{
 		LAssert(!"No attachment point in MIME heirarchy for file");
 		return NULL;
 	}
 	
 	auto File = new Attachment(	App,
 								GetObject()->GetStore()->Create(MAGIC_ATTACHMENT),
 								FileName);
 	if (File)
 	{
 		File->App = App;
 		if (Resize.CastInt32() || File->GetSize() > 0)
 		{
 			File->SetOwner(this);
 			Attachments.Insert(File);
 			if (Resize.CastInt32())
 				d->AddResizeImage(File);
 			else
 				File->GetObject()->Save(AttachPoint);
 			SetFlags(GetFlags() | MAIL_ATTACHMENTS);
 			Update();
 
 			if (Ui)
 				Ui->OnAttachmentsChange();
 		}
 		else
 		{
 			LgiMsg(Parent, LLoadString(IDS_ERROR_FILE_EMPTY), AppName);
 			File->DecRef();
 			File = NULL;
 		}
 	}
 
 	return File;
 }
 
 bool Mail::Save(ScribeFolder *Into)
 {
 	bool Status = false;
 
 	if (!Into)
 	{
 	    if (GetFolder())
 		    Into = GetFolder();
 		else
 			Into = App->GetFolder(FOLDER_OUTBOX);
 	}
 
 	if (Into)
 	{
 		ScribeFolder *Old = GetFolder();
 
         if (!GetFolder())
         {
 	        SetParentFolder(Into);
 	    }
 	    else if (GetFolder() != Into)
 	    {
             // If this fails, you should really by using ScribeFolder::MoveTo to move
             // the item from it's existing location to the new folder...
             LAssert(!"Use MoveTo instead.");
             return false;
 	    }
 
 		Store3Status Result = Into->WriteThing(this);
 		if (Result != Store3Error)
 		{
 			Status = true;
 			SetDirty(false);
 			
 			if (Into &&
 				Into == App->GetFolder(FOLDER_TEMPLATES, NULL, true))
 			{
 				// saving into the templates folder... update the menu
 				App->BuildDynMenus();
 			}
 
 			if (Status && DropFileName)
 			{
 				FileDev->Delete(DropFileName, false);
 				DropFileName.Reset();
 			}
 		}
 		else
 		{
 			SetParentFolder(Old);
 		}
 	}
 	
 	// This frees the resizer thread... 
 	// so they aren't hanging around pointlessly
-	d->OnSave();
-	
+	d->OnSave();	
 	
 	return Status;
 }
 
 struct WrapQuoteBlock
 {
 	int Depth;
 	LArray<char*> Text;
 };
 
 void WrapAndQuote(	LStream &Pipe,
 					const char *Quote,
 					int Wrap,
 					const char *Text,
 					const char *Cp,
 					const char *MimeType)
 {
 	int IsHtml = MimeType && !_stricmp(MimeType, sTextHtml);
 	LAutoString In((char*) LNewConvertCp("utf-8", Text, Cp ? Cp : (char*)"utf-8"));
 	const char *QuoteStr = Quote;
 	if (In)
 	{
 		size_t QuoteChars = Strlen(QuoteStr);
 		char NewLine[8];
 		int NewLineLen = sprintf_s(NewLine, sizeof(NewLine), "%s", IsHtml ? "<br>\n" : "\n");
 
 		// Two step process, parse all the input into an array of paragraph blocks and then output each block
 		// in wrapped form
 		LArray<WrapQuoteBlock> Para;
 		
 		// 1) Parse all input into paragraphs
 		char *i = In;
 		while (*i)
 		{
 			// Parse out the next line...
 			char *e = i;
 			while (*e && *e != '\n')
 				e++;
 			ssize_t len = e - i;
 			int depth = 0;
 			for (int n=0; n<len; n++)
 			{
 				if (i[n] == '>')
 					depth++;
 				else if (i[n] != ' ' || i[n] != '\t')
 					break;
 			}
 			
 			if (Para.Length())
 			{
 				// Can this be added to the previous paragraph?
 				WrapQuoteBlock &Prev = Para[Para.Length()-1];
 				if (Prev.Depth == depth)
 				{
 					// Yes?!
 					Prev.Text.Add(NewStr(i, len));
 					i = *e ? e + 1 : e;
 					continue;
 				}
 			}
 
 			// Create a new paragraph
 			WrapQuoteBlock &New = Para.New();
 			New.Depth = depth;
 			New.Text.Add(NewStr(i, len));
 			
 			// Move current position to next line
 			i = *e ? e + 1 : e;
 		}
 		
 		// 2) Output all paragraphs
 		const char *PrefixCharacters = "> \t";
 		for (unsigned n=0; n<Para.Length(); n++)
 		{
 			WrapQuoteBlock &p = Para[n];
 			ssize_t CharPos = 0;
 			
 			if (QuoteStr)
 			{
 				Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 				CharPos += QuoteChars;
 			}
 			
 			// Each line has the format:
 			//		[QuoteStr][Prefix][TextWords][NewLine]
 			
 			LAutoString Prefix;
 			ssize_t PrefixChars = 0;
 			for (unsigned l=0; l<p.Text.Length(); l++)
 			{
 				char *Line = p.Text[l];
 				// int LineLen = strlen(Line);
 				bool HardNewLine = true; // LineLen < Wrap;
 				char *Start = Line;
 				while (*Start && strchr(PrefixCharacters, *Start))
 					Start++;
 
 				if (!l)
 				{
 					// Create the prefix string
 					PrefixChars = Start - Line;
 					Prefix.Reset(NewStr(Line, PrefixChars));
 					
 					// Write the prefix string for the current line...
 					Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 					CharPos += PrefixChars;
 				}
 				
 				// Output [Start:EndOfLine] unless we run out of space on this line
 				while (*Start)
 				{
 					// Find end of the word.
 					char *End = Start;
 					while (*End && strchr(WhiteSpace, *End))
 						End++;
 					while (*End && !strchr(WhiteSpace, *End))
 						End++;
 					ssize_t WordLen = End - Start;
 					LAssert(WordLen > 0);
 					if (WordLen == 0)
 						break; // This won't end well...
 					
 					if (Wrap > 0)
 					{
 						// Check if we can put this word on the current line without making it longer than 'Wrap'
 						if (CharPos + WordLen > Wrap)
 						{
 							// No it won't fit... so emit [NewLine][QuoteStr][Prefix]
 							Pipe.Write(NewLine, NewLineLen);
 							if (QuoteStr)
 								Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 							Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 							
 							// Now we are ready to write more words...
 							CharPos = QuoteChars + PrefixChars;
 						}
 						// else Yes it fits...
 					}
 					
 					// Write out the word...
 					if (IsHtml && Strnchr(Start, '<', WordLen))
 					{
 						for (auto *c = Start; c < Start + WordLen; c++)
 							if (*c == '<')
 								Pipe.Print("&lt;");
 							else if (*c == '>')
 								Pipe.Print("&gt;");
 							else
 								Pipe.Write(c, sizeof(*c));
 					}
 					else
 						Pipe.Write(Start, WordLen * sizeof(*Start));
 					CharPos += WordLen;
 					
 					Start = End;
 				}
 				
 				if (HardNewLine)
 				{
 					Pipe.Write(NewLine, NewLineLen);
 					if (QuoteStr)
 						Pipe.Write(QuoteStr, QuoteChars * sizeof(*QuoteStr));
 					Pipe.Write(Prefix, PrefixChars * sizeof(*Prefix));
 					CharPos = QuoteChars + PrefixChars;
 				}
 			}
 
 			// Finish the paragraph
 			Pipe.Write(NewLine, NewLineLen);
 		}		
 	}
 }
 
 void Mail::WrapAndQuote(LStringPipe &p, const char *Quote, int WrapAt)
 {
 	LString Mem;
 	LAutoString Cp;
 	if (!ValidStr(GetBody()))
 		Mem = HtmlToText(GetHtml(), GetHtmlCharset());
 	else
 		Cp = GetCharSet();
 	
 	::WrapAndQuote(p, Quote, WrapAt > 0 ? WrapAt : 76, Mem ? Mem.Get() : GetBody(), Cp);
 }
 
 LAutoString Mail::GetSig(bool HtmlVersion, ScribeAccount *Account)
 {
 	LAutoString r;
 	LVariant Xml;
 		
 	if (!Account)
 		Account = GetAccountSentTo();
 
 	if (Account)
 	{
 		if (HtmlVersion)
 			Xml = Account->Identity.HtmlSig();
 		else
 			Xml = Account->Identity.TextSig();
 	}
 	
 	if (Xml.Str())
 	{
 		r = App->ProcessSig(this, Xml.Str(), HtmlVersion ? sTextHtml : sTextPlain);
 	}
 
 	return r;
 }
 
 void Mail::ProcessTextForResponse(Mail *From, LOptionsFile *Options, ScribeAccount *Account)
 {
 	LStringPipe Temp;
 	LVariant QuoteStr, Quote, WrapAt;
 	Options->GetValue(OPT_QuoteReply, Quote);
 	Options->GetValue(OPT_WrapAtColumn, WrapAt);
 	Options->GetValue(OPT_QuoteReplyStr, QuoteStr);
 
 	From->WrapAndQuote(Temp, Quote.CastInt32() ? QuoteStr.Str() : NULL, WrapAt.CastInt32());
 	
 	LAutoString s = From->GetSig(false, Account);
 	if (s)
 		Temp.Write(s, strlen(s));
 
 	s.Reset(Temp.NewStr());
 	SetBody(s);
 	SetBodyCharset("utf-8");
 }
 
 ScribeAccount *Mail::GetAccountSentTo()
 {
 	ScribeAccount *Account = App->GetAccountById(GetAccountId());
 	if (!Account)
 	{
 		// Older style lookup based on to address...
 		for (auto a : *App->GetAccounts())
 		{
 			LVariant e = a->Identity.Email();
 			if (ValidStr(e.Str()))
 			{
 				for (LDataPropI *t=GetTo()->First(); t; t=GetTo()->Next())
 				{
 					auto Addr = t->GetStr(FIELD_EMAIL);
 					if (ValidStr(Addr))
 					{
 						if (_stricmp(Addr, e.Str()) == 0)
 						{
 							Account = a;
 							break;
 						}
 					}
 				}
 			}
 		}
 	}
 	return Account;
 }
 
 void Mail::OnReceipt(Mail *m)
 {
 	if (m)
 	{
 		SetFlags(MAIL_CREATED | MAIL_READY_TO_SEND);
 
 		ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 		if (!MatchedAccount)
 		{
 			MatchedAccount = App->GetAccounts()->ItemAt(App->GetCurrentIdentity());
 		}
 		if (MatchedAccount)
 		{
 			GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		}
 
 		char Sent[64];
 		m->GetDateReceived()->Get(Sent, sizeof(Sent));
 
 		char Read[64];
 		LDateTime t;
 		t.SetNow();
 		t.Get(Read, sizeof(Read));
 
 		char s[256];
 		sprintf_s(s, sizeof(s), 
 				LLoadString(IDS_RECEIPT_BODY),
 				GetFrom()->GetStr(FIELD_NAME),
 				GetFrom()->GetStr(FIELD_EMAIL),
 				Sent,
 				m->GetSubject(),
 				Read);
 		SetBody(s);
 
 		sprintf_s(s, sizeof(s), "Read: %s", m->GetSubject() ? m->GetSubject() : (char*)"");
 		SetSubject(s);
 	}
 }
 
 LString Mail::GetMailRef()
 {
 	LString Ret;
 
 	if (auto MsgId = GetMessageId(true))
 	{
 	    LAssert(!strchr(MsgId, '\n'));
 	    
 		ScribeFolder *Fld = GetFolder();
 		LString FldPath;
 		if (Fld)
 		    FldPath = Fld->GetPath();
 
 		if (FldPath)
 		{
 			LUri u;
 			auto a = u.EncodeStr(MsgId, MsgIdEncodeChars);
 			if (a)
 				Ret.Printf("%s/%s", FldPath.Get(), a.Get());
 		}
 		else
 		{
 			Ret = MsgId;
 		}
 	}
 	
 	return Ret;
 }
 
 void Mail::OnReply(Mail *m, bool All, bool MarkOriginal)
 {
 	if (!m)
 	    return;
 
 	SetWillDirty(false);
 
 	LVariant ReplyAllSetting = MAIL_ADDR_TO;
 	if (All)
 	{
 		App->GetOptions()->GetValue(OPT_DefaultReplyAllSetting, ReplyAllSetting);
 	}
 		
 	if (MarkOriginal)
 	{
 		// source email has been replyed to
 		m->SetFlags(m->GetFlags() | MAIL_READ);
 	}
 
 	// this email is ready to send
 	SetFlags(GetFlags() | MAIL_READ | MAIL_CREATED);
 
 	LDataPropI *ToAddr = GetTo()->Create(GetObject()->GetStore());
 	if (ToAddr)
 	{
 		bool CopyStatus;
 		auto From = m->GetFrom();
 		auto Reply = m->GetReply();
 		auto ReplyTo = Reply->GetStr(FIELD_EMAIL);
 		if (ReplyTo)
 			CopyStatus = ToAddr->CopyProps(*Reply);
 		else
 			CopyStatus = ToAddr->CopyProps(*From);
 		LAssert(CopyStatus);
 
 		ToAddr->SetInt(FIELD_CC, ReplyAllSetting.CastInt32());
 		GetTo()->Insert(ToAddr);
 	}
 
 	LVariant UserName, EmailAddr, ReplyTo;
 
 	ScribeAccount *a = App->GetCurrentAccount();
 	if (a)
 	{
 		UserName = a->Identity.Name();
 		EmailAddr = a->Identity.Email();
 		ReplyTo = a->Identity.ReplyTo();
 	}
 	else LAssert(!"No current account.");
 
 	if (All)
 	{
 		for (LDataPropI *a = m->GetTo()->First(); a; a = m->GetTo()->Next())
 		{
 			bool Same = App->IsMyEmail(a->GetStr(FIELD_EMAIL));
 			
 			bool AlreadyThere = false;
 			for (LDataPropI *r = GetTo()->First(); r; r=GetTo()->Next())
 			{
 				if (_stricmp(r->GetStr(FIELD_EMAIL), a->GetStr(FIELD_EMAIL)) == 0)
 				{
 					AlreadyThere = true;
 					break;
 				}
 			}
 
 			if (!Same && !AlreadyThere)
 			{
 				LDataPropI *New = GetTo()->Create(GetObject()->GetStore());
 				if (New)
 				{
 					New->SetInt(FIELD_CC, ReplyAllSetting.CastInt32());
 					New->SetStr(FIELD_EMAIL, a->GetStr(FIELD_EMAIL));
 					New->SetStr(FIELD_NAME, a->GetStr(FIELD_NAME));
 					GetTo()->Insert(New);
 				}
 			}
 		}
 	}
 
 	ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 	if (MatchedAccount &&
 		MatchedAccount->Identity.Email().Str())
 	{
 		GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 		GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		
 		ReplyTo = MatchedAccount->Identity.ReplyTo();
 		if (ReplyTo.Str())
 		{
 			GetReply()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 	else
 	{
 		GetFrom()->SetStr(FIELD_NAME, UserName.Str());
 		GetFrom()->SetStr(FIELD_EMAIL, EmailAddr.Str());
 
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, UserName.Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 
 	char Re[32];
 	sprintf_s(Re, sizeof(Re), "%s:", LLoadString(IDS_REPLY_PREFIX));
 
 	auto SrcSubject = (m->GetSubject()) ? m->GetSubject() : "";
 	if (_strnicmp(SrcSubject, Re, strlen(Re)) != 0)
 	{
 		size_t Len = strlen(SrcSubject) + strlen(Re) + 2;
 		char *s = new char[Len];
 		if (s)
 		{
 			sprintf_s(s, Len, "%s %s", Re, SrcSubject);
 			SetSubject(s);
 			DeleteArray(s);
 		}
 	}
 	else
 	{
 		SetSubject(m->GetSubject());
 	}
 
 	const char *EditMimeType = App->EditCtrlMimeType();
 	LAutoString Xml = App->GetReplyXml(EditMimeType);
 	if (ValidStr(Xml))
 	{
 		RemoveReturns(Xml);
 		PreviousMail = m;
 
 		LString Body = App->ProcessReplyForwardTemplate(m, this, Xml, Cursor, EditMimeType);
 		
 		LVariant EditCtrl;
 		if (App->GetOptions()->GetValue(OPT_EditControl, EditCtrl) &&
 			EditCtrl.CastInt32())
 		{
 			SetHtml(Body);
 		}
 		else
 		{			
 			SetBody(Body);
 			SetBodyCharset("utf-8");
 		}
 
 		PreviousMail = 0;
 	}
 	else
 	{
 		ProcessTextForResponse(m, App->GetOptions(), MatchedAccount);
 	}
 
 	// Reference
 	SetReferences(0);
 	auto MailRef = m->GetMailRef();
 	if (MailRef)
 		SetReferences(MailRef);
 
 	GetMessageId(true);
 	SetWillDirty(true);
 
 	ScribeFolder *Folder = m->GetFolder();
 	if (Folder && Folder->IsPublicFolders())
 	{
 		SetParentFolder(Folder);
 	}
 }
 
 bool Mail::OnForward(Mail *m, bool MarkOriginal, int WithAttachments)
 {
 	if (!m)
 	{
 		LAssert(!"No mail object.");
 		LgiTrace("%s:%i - No mail object.\n", _FL);
 		return false;
 	}
 
 	// ask about attachments?
 	List<Attachment> Attach;
 	if (m->GetAttachments(&Attach) &&
 		Attach.Length() > 0)
 	{
 		if (WithAttachments < 0)
 		{
 			LView *p = (m->Ui)?(LView*)m->Ui:(LView*)App;
 			int Result = LgiMsg(p, LLoadString(IDS_ASK_FORWARD_ATTACHMENTS), AppName, MB_YESNOCANCEL);
 			if (Result == IDYES)
 			{
 				WithAttachments = 1;
 			}
 			else if (Result == IDCANCEL)
 			{
 				return false;
 			}
 		}
 	}
 
 	if (MarkOriginal)
 	{
 		// source email has been forwarded
 		auto MailRef = m->GetMailRef();
 		if (MailRef)
 			SetFwdMsgId(MailRef);
 	}
 
 	// this email is ready to send
 	SetFlags(GetFlags() | MAIL_CREATED);
 	SetDirty();
 
 	LVariant UserName, EmailAddr, ReplyTo;
 	ScribeAccount *a = App->GetCurrentAccount();
 	if (a)
 	{
 		UserName = a->Identity.Name();
 		EmailAddr = a->Identity.Email();
 		ReplyTo = a->Identity.ReplyTo();
 	}
 	else LAssert(!"No current account.");
 
 	ScribeAccount *MatchedAccount = m->GetAccountSentTo();
 	if (MatchedAccount &&
 		MatchedAccount->Identity.Email().Str())
 	{
 		GetFrom()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 		GetFrom()->SetStr(FIELD_EMAIL, MatchedAccount->Identity.Email().Str());
 		
 		ReplyTo = MatchedAccount->Identity.ReplyTo();
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, MatchedAccount->Identity.Name().Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 	else
 	{
 		GetFrom()->SetStr(FIELD_NAME, UserName.Str());
 		GetFrom()->SetStr(FIELD_EMAIL, EmailAddr.Str());
 
 		if (ValidStr(ReplyTo.Str()))
 		{
 			GetReply()->SetStr(FIELD_NAME, UserName.Str());
 			GetReply()->SetStr(FIELD_EMAIL, ReplyTo.Str());
 		}
 	}
 
 	SetBodyCharset(0);
 
 	char PostFix[32];
 	sprintf_s(PostFix, sizeof(PostFix), "%s:", LLoadString(IDS_FORWARD_PREFIX));
 
 	auto SrcSubject = (m->GetSubject()) ? m->GetSubject() : "";
 	if (_strnicmp(SrcSubject, PostFix, strlen(PostFix)) != 0)
 	{
 		size_t Len = strlen(SrcSubject) + strlen(PostFix) + 2;
 		char *s = new char[Len];
 		if (s)
 		{
 			sprintf_s(s, Len, "%s %s", PostFix, SrcSubject);
 			SetSubject(s);
 			DeleteArray(s);
 		}
 	}
 	else
 	{
 		SetSubject(m->GetSubject());
 	}
 
 	// Wrap/Quote/Sig the text...
 	const char *EditMimeType = App->EditCtrlMimeType();
 	LAutoString Xml = App->GetForwardXml(EditMimeType);
 	if (ValidStr(Xml))
 	{
 		RemoveReturns(Xml);
 		PreviousMail = m;
 		
 		LString Body = App->ProcessReplyForwardTemplate(m, this, Xml, Cursor, EditMimeType);
 		
 		LVariant EditCtrl;
 		if (App->GetOptions()->GetValue(OPT_EditControl, EditCtrl) &&
 			EditCtrl.CastInt32())
 		{
 			SetHtml(Body);
 		}
 		else
 		{			
 			SetBody(Body);
 			SetBodyCharset("utf-8");
 		}
 
 		PreviousMail = 0;
 	}
 	else
 	{
 		ProcessTextForResponse(m, App->GetOptions(), MatchedAccount);
 	}
 
 	// Attachments
 	if (WithAttachments > 0)
 		for (auto From: Attach)
 			AttachFile(new Attachment(App, From));
 
 	// Set MsgId
 	GetMessageId(true);
 
 	// Unless the user edits the message it shouldn't be made dirty.
 	SetDirty(false);
 
 	return true;
 }
 
 bool Mail::OnBounce(Mail *m, bool MarkOriginal, int WithAttachments)
 {
 	if (m)
 	{
 		if (MarkOriginal)
 		{
 			// source email has been forwarded
 			auto MsgId = m->GetMessageId(true);
 			if (MsgId)
 			{
 				ScribeFolder *Fld = m->GetFolder();
 				LString FldPath;
 				if (Fld)
 				    FldPath = Fld->GetPath();
 
 				if (FldPath)
 				{
 					LUri u;
 					LString a = u.EncodeStr(MsgId, MsgIdEncodeChars);
 					if (a)
 					{
 						LString p;
 						p.Printf("%s/%s", FldPath.Get(), a.Get());
 						SetBounceMsgId(p);
 					}
 				}
 				else
 				{
 					SetBounceMsgId(MsgId);
 				}
 			}
 			else m->SetFlags(m->GetFlags() | MAIL_BOUNCED);
 		}
 		
 		*this = (Thing&)*m;
 
 		GetTo()->DeleteObjects();
 		SetFlags(MAIL_READ | MAIL_BOUNCE);
 		return true;
 	}
 	
 	return false;
 }
 
 void Mail::OnMeasure(LPoint *Info)
 {
 	LListItem::OnMeasure(Info);
 
 	if (PreviewLines &&
 		!(GetFlags() & MAIL_READ) &&
 		(!GetObject() || !GetObject()->GetInt(FIELD_DONT_SHOW_PREVIEW)))
 	{
     	LFont *PreviewFont = App->GetPreviewFont();
 		Info->y += PreviewFont ? PreviewFont->GetHeight() << 1 : 28;
 	}
 }
 
 void Mail::OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c)
 {
 	int Field = 0;
 	if (FieldArray.Length())
 	{
 		Field = i >= 0 && i < (int)FieldArray.Length() ? FieldArray[i] : 0;
 	}
 	else if (i >= 0 && i < CountOf(DefaultMailFields))
 	{
 		Field = DefaultMailFields[i];
 	}
 
 	if (Container &&
 		i >= 0 &&
 		Field == FIELD_SUBJECT)
 	{
 		LFont *f = Parent->GetFont();
 		auto Subj = GetSubject();
 
 		if (Container)
 		{
 			// Container needs to paint the subject...
 			Container->OnPaint(Ctx.pDC, Ctx, c, Ctx.Fore, Ctx.Back, f?f:LSysFont, Subj);
 		}
 	}
 	else
 	{
 		LListItem::OnPaintColumn(Ctx, i, c);
 
 		if (i >= 0 && App->GetIconImgList())
 		{
 			int Icon = -1;
 			
 			switch (Field)
 			{
 				case FIELD_PRIORITY:
 				{
 					switch (GetPriority())
 					{
 						case MAIL_PRIORITY_HIGH:
 						{
 							Icon = ICON_PRIORITY_HIGH;
 							break;
 						}
 						case MAIL_PRIORITY_LOW:
 						{
 							Icon = ICON_PRIORITY_LOW;
 							break;
 						}
 						default:
 							break;
 					}
 
 					break;
 				}
 				case FIELD_FLAGS:
 				{
 					if (GetFlags() & MAIL_BOUNCED)
 					{
 						Icon = ICON_FLAGS_BOUNCE;
 					}
 					else if (GetFlags() & MAIL_REPLIED)
 					{
 						Icon = ICON_FLAGS_REPLY;
 					}
 					else if (GetFlags() & MAIL_FORWARDED)
 					{
 						Icon = ICON_FLAGS_FORWARD;
 					}
 					break;
 				}
 				default:
 					break;
 			}
 
 			if (Icon >= 0)
 			{
 				LRect *b = App->GetIconImgList()->GetBounds();
 				if (b)
 				{
 					b += Icon;
 					int x = Ctx.x1 + ((Ctx.X()-b->X())/2) - b->x1;
 					int y = Ctx.y1 + ((MIN(Ctx.Y(), 16)-b->Y())/2) - b->y1;
 
 					LColour Back(Ctx.Back);
 					App->GetIconImgList()->Draw(Ctx.pDC, x, y, Icon, Back);
 				}
 			}
 		}
 	}
 }
 
 void Mail::OnPaint(LItem::ItemPaintCtx &InCtx)
 {
 	LItem::ItemPaintCtx Ctx = InCtx;
 	
 	int64_t MarkCol = GetMarkColour();
 	if (MarkCol > 0)
 	{
         LColour Col((uint32_t)MarkCol, 32);
         LColour CtxBack(Ctx.Back);
 		LColour Mixed = Col.Mix(CtxBack, MarkColourMix);
         Ctx.Back = Mixed;
 	}
 
 	if (Parent) ((ThingList*)Parent)->CurrentMail = this;
 	LListItem::OnPaint(Ctx);
 	if (Parent) ((ThingList*)Parent)->CurrentMail = 0;
 	LFont *PreviewFont = App->GetPreviewFont();
 	LFont *ColumnFont = Parent && Parent->GetFont() ? Parent->GetFont() : LSysFont;
 
 	if (Parent &&
 		PreviewLines &&
 		PreviewFont &&
 		ColumnFont &&
 		GetObject() &&
 		!GetObject()->GetInt(FIELD_DONT_SHOW_PREVIEW) &&
 		!(GetFlags() & MAIL_READ))
 	{
 		int y = ColumnFont->GetHeight() + 2;
 		int Space = (Ctx.Y() - y) >> 1;
 		int Line = MAX(PreviewFont->GetHeight(), Space);
 		PreviewFont->Transparent(true);
 
 		// Setup
 		if (!PreviewCache[0] || abs(PreviewCacheX-Ctx.X()) > 20)
 		{
 			PreviewCache.DeleteObjects();
 			PreviewCacheX = Ctx.X();
 
 			LVariant v;
 			if (GetValue("BodyAsText[1024]", v) &&
 				v.Str())
 			{
 				char16 *Base = Utf8ToWide(v.Str());
 				char16 *Txt = Base;
 				int i;
 				for (i=0; Txt[i]; i++)
 				{
 					if (Txt[i] < ' ')
 					{
 						Txt[i] = ' ';
 					}
 				}
 
 				auto TxtLen = StrlenW(Txt);
 				for (i=0; Txt && *Txt && i<2; i++)
 				{
 					LDisplayString *Temp = new LDisplayString(PreviewFont, Txt, MIN(1024, TxtLen));
 					if (Temp)
 					{
 						int W = Ctx.X()-18;
 						ssize_t Cx = Temp->CharAt(W);
 						if (Cx > 0 && Cx <= TxtLen)
 						{
 							LDisplayString *d = new LDisplayString(PreviewFont, Txt, Cx);
 							if (d)
 							{
 								PreviewCache.Insert(d);
 							}
 							DeleteObj(Temp);
 							Txt += Cx; // LSeekUtf8
 							TxtLen -= Cx;
 						}
 						else break;
 					}
 				}
 				DeleteArray(Base);
 			}
 		}
 
 		// Display
 		LColour PreviewCol(App->GetColour(L_MAIL_PREVIEW));
 		if (Select())
 		{
 			int GreyPrev = PreviewCol.GetGray();
 			int GreyBack = Ctx.Back.GetGray();
 			
 			int d = GreyPrev - GreyBack;
 			if (d < 0) d = -d;
 			if (d < 128)
 			{
 				// too near
 				PreviewFont->Colour(Ctx.Fore, Ctx.Back);
 			}
 			else
 			{
 				// ok
 				PreviewFont->Colour(PreviewCol, Ctx.Back);
 			}
 		}
 		else
 		{
 			PreviewFont->Colour(PreviewCol, Ctx.Back);
 		}
 
 		for (auto p: PreviewCache)
 		{
 			p->Draw(Ctx.pDC, Ctx.x1+16, Ctx.y1+y, 0);
 			y += Line;
 		}
 	}
 }
 
 bool Mail::GetFormats(bool Export, LString::Array &MimeTypes)
 {
 	if (Export)
 	{
 		MimeTypes.Add("text/plain");
 		MimeTypes.Add(sMimeMbox);
 	}
 
 	MimeTypes.Add(sMimeMessage);
 	return MimeTypes.Length() > 0;
 }
 
 Thing::IoProgress Mail::Import(IoProgressImplArgs)
 {
 	if (!mimeType)
 		IoProgressError("No mime type.");
 
 	if (Stricmp(mimeType, sMimeMessage))
 		IoProgressNotImpl();
 
 	// Single email..
 	OnAfterReceive(stream);
 
 	int Flags = GetFlags();
 	Flags &= ~MAIL_CREATED;
 	Flags |= MAIL_READ;
 	SetFlags(Flags);
 
 	Update();
 
 	IoProgressSuccess();
 }
 
 #define TIMEOUT_OBJECT_LOAD		20000
 
 Thing::IoProgress Mail::Export(IoProgressImplArgs)
 {
 	if (!mimeType)	
 		IoProgressError("No mimetype.");
 
 	if (!Stricmp(mimeType, "text/plain"))
 	{
 		LStringPipe Buf;
 		char Str[256];
 		char Eol[] = EOL_SEQUENCE;
 
 		// Addressee
 		if (GetFlags() & MAIL_CREATED)
 		{
 			Buf.Push("To:");
 			for (LDataPropI *a=GetTo()->First(); a; a=GetTo()->Next())
 			{
 				sprintf_s(Str, sizeof(Str), "\t%s <%s>%s", a->GetStr(FIELD_NAME), a->GetStr(FIELD_EMAIL), Eol);
 				Buf.Push(Str);
 			}
 		}
 		else
 		{
 			sprintf_s(Str, sizeof(Str), "From: %s <%s>%s", GetFrom()->GetStr(FIELD_NAME), GetFrom()->GetStr(FIELD_EMAIL), Eol);
 			Buf.Push(Str);
 		}
 
 		// Subject
 		sprintf_s(Str, sizeof(Str), "Subject: %s%s", GetSubject(), Eol);
 		Buf.Push(Str);
 
 		// Sent date
 		if (GetDateSent()->Year())
 		{
 			int ch = sprintf_s(Str, sizeof(Str), "Sent Date: ");
 			GetDateSent()->Get(Str+ch, sizeof(Str)-ch);
 		}
 		else
 		{
 			int ch = sprintf_s(Str, sizeof(Str), "Date Received: ");
 			GetDateReceived()->Get(Str+ch, sizeof(Str)-ch);
 		}
 		strcat(Str, Eol);
 		Buf.Push(Str);
 
 		// Body
 		Buf.Push(Eol);
 		Buf.Push(GetBody());
 
 		// Write the output
 		auto s = Buf.NewLStr();
 		if (!s)
 			IoProgressError("No data to output.");
 		stream->Write(s.Get(), s.Length());
 
 		IoProgressSuccess();
 	}
 	else if (!Stricmp(mimeType, sMimeMbox))
 	{
 		char Temp[256];
 		
 		// generate from header
 		sprintf_s(Temp, sizeof(Temp), "From %s ", GetFrom()->GetStr(FIELD_EMAIL));
 		struct tm Ft;
 		
 		ZeroObj(Ft);
 		LDateTime Rec = *GetDateReceived();
 		if (!Rec.Year())
 		    Rec.SetNow();
 		Ft.tm_sec = Rec.Seconds();			/* seconds after the minute - [0,59] */
 		Ft.tm_min = Rec.Minutes();			/* minutes after the hour - [0,59] */
 		Ft.tm_hour = Rec.Hours();			/* hours since midnight - [0,23] */
 		Ft.tm_mday = Rec.Day();			/* day of the month - [1,31] */
 		Ft.tm_mon = Rec.Month() - 1;		/* months since January - [0,11] */
 		Ft.tm_year = Rec.Year() - 1900;    /* years since 1900 */
 		Ft.tm_wday = Rec.DayOfWeek();
 
 		strftime(Temp+strlen(Temp), MAX_NAME_SIZE, "%a %b %d %H:%M:%S %Y", &Ft);
 		strcat(Temp, "\r\n");
 		
 		// write mail
 		stream->Write(Temp, strlen(Temp));
 		auto Status = Export(stream, sMimeMessage, [cb](auto io, auto stream)
 		{
 			if (io->status == Store3Success)
 				stream->Write((char*)"\r\n.\r\n", 2);
 			else if (io->status == Store3Delayed)
 				LAssert(!"We should never get delayed here... it's the callback!");
 
 			if (cb)
 				cb(io, stream);
 		});
 
 		return Status;
 	}
 	else if (!Stricmp(mimeType, sMimeMessage))
 	{
 		// This function can't be asynchronous, it must complete with UI or waiting for a callback.
 		// Because it is used by the drag and drop system. Which won't wait.
 		auto state = GetLoaded();
 		if (state != Store3Loaded)
 			IoProgressError("Mail not loaded.");
 
 		if (!GetObject())
 			IoProgressError("No store object.");
 		
 		auto Data = GetObject()->GetStream(_FL);
 		if (!Data)
 			IoProgressError("Mail for export has no data.");
 		
 		Data->SetPos(0);
 		LCopyStreamer Cp(512<<10);
 		if (Cp.Copy(Data, stream) <= 0)
 			IoProgressError("Mail copy stream failed.");
 
 		IoProgressSuccess();
 	}
 
 	IoProgressNotImpl();
 }
 
 char *Mail::GetNewText(int Max, const char *AsCp)
 {
 	LAutoString CharSet = GetCharSet();
 	char *Txt = 0;
 
 	// This limits the preview of the text to
 	// the first 64kb, which is reasonable.
 	int Len = Max > 0 ? Strnlen(GetBody(), Max) : -1;
 
 	// Convert or allocate the text.
 	if (CharSet)
 	{
 		Txt = (char*)LNewConvertCp(AsCp, GetBody(), GetBodyCharset(), Len);
 	}
 	else
 	{
 		Txt = NewStr(GetBody(), Len);
 	}
 
 	return Txt;
 }
 
 LAutoString Mail::GetCharSet()
 {
 	LAutoString Status;
 	LAutoString ContentType;
 
 	if (GetBodyCharset())
 	{
 		// If the charset has a stray colon...
 		char *Colon = strchr(GetBodyCharset(), ';');
 		// Kill it.
 		if (Colon) *Colon = 0;
 		
 		// Copy the string..
 		Status.Reset(NewStr(GetBodyCharset()));
 	}
 
 	if (!GetBodyCharset())
 	{
 		ContentType.Reset(InetGetHeaderField(GetInternetHeader(), "Content-Type"));
 		if (ContentType)
 		{
 			char *CharSet = stristr(ContentType, "charset=");
 			if (CharSet)
 			{
 				CharSet += 8;
 				if (*CharSet)
 				{
 					if (strchr("\"\'", *CharSet))
 					{
 						char Delim = *CharSet++;
 						char *e = CharSet;
 						
 						while (*e && *e != Delim)
 						{
 							e++;
 						}
 						Status.Reset(NewStr(CharSet, e - CharSet));
 					}
 					else
 					{
 						char *e = CharSet;
 						while (*e && (IsDigit(*e) || IsAlpha(*e) || strchr("-_", *e)))
 						{
 							e++;
 						}
 						Status.Reset(NewStr(CharSet, e - CharSet));
 					}
 				}
 			}
 		}
 
 		/*
 		// If it's not a valid charset...
 		if (!LGetCsInfo(Status))
 		{
 			// Then kill it.
 			Status.Reset();
 			if (GetBodyCharset())
 			{
 				SetBodyCharset(0);
 				SetDirty();
 			}
 		}
 		*/
 	}
 
 	return Status;
 }
 
 /* Old Body Printing Code
 
 	int Lines = 0;
 	char *n;
 	for (n=Body.Str(); n && *n; n++)
 	{
 		if (*n == '\n') Lines++;
 	}
 
 	char *c = Body.Str();
 	if (c)
 	{
 		c = WrapLines(c, c ? strlen(c) : 0, 76);
 
 		Lines = 0;
 		for (n=c; *n; n++)
 		{
 			if (*n == '\n') Lines++;
 		}
 
 		while (c && *c)
 		{
 			if (Cy + Line > r.y2)
 			{
 				pDC->EndPage();
 
 				if (Window->GetMaxPages() > 0 &&
 					++Page >= Window->GetMaxPages())
 				{
 					break;
 				}
 
 				pDC->StartPage();
 				Cy = 0;
 			}
 
 			char *Eol = strchr(c, '\n');
 			int Len = 0;
 			int Ret = 0;
 			if (Eol)
 			{
 				Len = (int) Eol - (int) c;
 				if (Len > 0 && c[Len-1] == '\r')
 				{
 					Len--;
 					Ret = 1;
 				}
 			}
 			else
 			{
 				Len = strlen(c);
 			}
 
 			MailFont->Text(pDC, r.x1, Cy, c, Len);
 			Cy += Line;
 			c += Len + Ret;
 			if (*c == '\n') c++;
 		}
 	}
 */
 
 int Mail::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_TEXT:
 		{
 			LDocView *Doc = dynamic_cast<LDocView*>(Ctrl);
 			if (Doc)
 			{
 				if (n.Type == LNotifyShowImagesChanged)
 				{
 					if (Doc->GetLoadImages() ^ TestFlag(GetFlags(), MAIL_SHOW_IMAGES))
 					{
 						if (Doc->GetLoadImages())
 						{
 							SetFlags(GetFlags() | MAIL_SHOW_IMAGES);
 						}
 						else
 						{
 							SetFlags(GetFlags() & ~MAIL_SHOW_IMAGES);
 						}
 					}
 				}
 
 				if (n.Type == LNotifyFixedWidthChanged)
 				{
 					bool DocFixed = Doc->GetFixedWidthFont();
 					bool MailFixed = TestFlag(GetFlags(), MAIL_FIXED_WIDTH_FONT);
 
 					if (DocFixed ^ MailFixed)
 					{
 						if (Doc->GetFixedWidthFont())
 						{
 							SetFlags(GetFlags() | MAIL_FIXED_WIDTH_FONT);
 						}
 						else
 						{
 							SetFlags(GetFlags() & ~MAIL_FIXED_WIDTH_FONT);
 						}
 					}
 				}
 
 				if (n.Type == LNotifyCharsetChanged &&
 					dynamic_cast<Html1::LHtml*>(Doc))
 				{
 					char s[256];
 					sprintf_s(s, sizeof(s), ">%s", Doc->GetCharset());
 					SetHtmlCharset(s);
 				}
 			}
 			break;
 		}
 	}
 
 	return 0;
 }
 
 void Mail::OnPrintHeaders(ScribePrintContext &Context)
 {
 	char Str[256];
 
 	// print document
 	LDrawListSurface *Page = Context.Pages.Last();
 	
 	int Line = Context.AppFont->GetHeight();
 	Page->SetFont(Context.AppFont);
     LDisplayString *Ds = Context.Text(LLoadString(IDS_MAIL_MESSAGE));
 	Context.CurrentY += Line;
 
 	LDataPropI *Ad = GetTo()->First();
 	if (Ad)
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(FIELD_TO));
 
         Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		for (; Ad; Ad = GetTo()->Next())
 		{
 			if (Ad->GetStr(FIELD_EMAIL) && Ad->GetStr(FIELD_NAME))
 			{
 				sprintf_s(Str, sizeof(Str), "%s <%s>", Ad->GetStr(FIELD_NAME), Ad->GetStr(FIELD_EMAIL));
 			}
 			else if (Ad->GetStr(FIELD_EMAIL))
 			{
 				strcpy_s(Str, sizeof(Str), Ad->GetStr(FIELD_EMAIL));
 			}
 			else if (Ad->GetStr(FIELD_EMAIL))
 			{
 				strcpy_s(Str, sizeof(Str), Ad->GetStr(FIELD_EMAIL));
 			}
 			else continue;
 
 			Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 			Context.CurrentY += Ds->Y();
 		}
 	}
 
 	if (GetFrom()->GetStr(FIELD_EMAIL) || GetFrom()->GetStr(FIELD_NAME))
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(FIELD_FROM));
 
         Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		if (GetFrom()->GetStr(FIELD_EMAIL) && GetFrom()->GetStr(FIELD_NAME))
 		{
 			sprintf_s(Str, sizeof(Str), "%s <%s>", GetFrom()->GetStr(FIELD_NAME), GetFrom()->GetStr(FIELD_EMAIL));
 		}
 		else if (GetFrom()->GetStr(FIELD_EMAIL))
 		{
 			strcpy_s(Str, sizeof(Str), GetFrom()->GetStr(FIELD_EMAIL));
 		}
 		else if (GetFrom()->GetStr(FIELD_NAME))
 		{
 			strcpy_s(Str, sizeof(Str), GetFrom()->GetStr(FIELD_NAME));
 		}
 		else Str[0] = 0;
 
 		Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 		Context.CurrentY += Ds->Y();
 	}
 	
 	{
 		// Subject
 		LString s;
 		const char *Subj = GetSubject();
 		s.Printf("%s: %s", LLoadString(FIELD_SUBJECT), Subj?Subj:"");
 		Context.Text(s);
 	}
 
 	{
 		// Date
 		LString s;
 		GetDateSent()->Get(Str, sizeof(Str));
 		s.Printf("%s: %s", LLoadString(IDS_DATE), Str);
 		Context.Text(s);
 	}
 
 	// attachment list...
 	List<Attachment> Attached;
 	if (GetAttachments(&Attached) &&
 		Attached.Length() > 0)
 	{
 		sprintf_s(Str, sizeof(Str), "%s: ", LLoadString(IDS_ATTACHMENTS));
 		Ds = Page->Text(Context.MarginPx.x1, Context.CurrentY, Str);
 		int x = Ds->X();
 
 		for (auto a: Attached)
 		{
 			char Size[32];
 			LFormatSize(Size, sizeof(Size), a->GetSize());
 			sprintf_s(Str, sizeof(Str), "%s (%s)", a->GetName(), Size);
 			Ds = Page->Text(Context.MarginPx.x1 + x, Context.CurrentY, Str);
 			Context.CurrentY += Ds->Y();
 		}
 	}
 
 	// separator line
 	LRect Sep(Context.MarginPx.x1, Context.CurrentY + (Line * 5 / 10), Context.MarginPx.x2, Context.CurrentY + (Line * 6 / 10));
 	Page->Rectangle(&Sep);
 	Context.CurrentY += Line;
 }
 
 void Mail::OnPrintText(ScribePrintContext &Context, LPrintPageRanges &Pages)
 {
 	// Text printing
 	LDrawListSurface *Page = Context.Pages.Last();
 	LVariant Body;
 	if (!GetVariant("BodyAsText", Body) || !Body.Str())
 	{
 		LgiTrace("%s:%i - No content to print.\n", _FL);
 		return;
 	}
 
 	LAutoWString w(Utf8ToWide(Body.Str()));
 	if (!w)
 	{
 		LgiTrace("%s:%i - Utf8ToWide failed.\n", _FL);
 		return;
 	}
 
 	Page->SetFont(Context.MailFont);
 	
 	for (char16 *s = w; s && *s; )
 	{
 		// Find end of line..
 		char16 *n = StrchrW(s, '\n');
 		if (!n) n = s + StrlenW(s);
 		ssize_t LineLen = n - s;
 
 		// Find how many characters will fit on the page
 		ssize_t Fit = 0;
 		if (n > s)
 		{
 			LDisplayString a(Context.MailFont, s, MIN(LineLen, 1024));
 			Fit = a.CharAt(Context.MarginPx.X());
 		}
 		if (Fit < 0)
 		{
 			break;
 		}
 
 		char16 *e = s + Fit;
 
 		if (e < n)
 		{
 			// The whole line doesn't fit on the page...
 			// Find the best breaking opportunity before that...
 			#define ExtraBreak(c) (	( (c) >= 0x3040 && (c) <= 0x30FF ) ||	\
 									( (c) >= 0x3300 && (c) <= 0x9FAF )		\
 								)
 			char16 *StartE = e;
 			while (e > s)
 			{
 				if (e[-1] == ' ' || ExtraBreak(e[-1]))
 				{
 					break;
 				}
 				e--;
 			}
 			if (e == s)
 			{
 				e = StartE;
 			}
 		}
 
 		// Output the segment of text
 		bool HasRet = e > s ? e[-1] == '\r' : false;
 		LString Str(s, (e - s) - (HasRet ? 1 : 0));
 		Context.Text(Str);
 
 		// Update the pointers
 		s = e;
 		if (*s == '\n') s++;
 	}
 }
 
 /// \returns the number of pages printed
 int Mail::OnPrintHtml(ScribePrintContext &Context, LPrintPageRanges &Pages, LSurface *RenderedHtml)
 {
 	// HTML printing...
 	LDrawListSurface *Page = Context.Pages.Last();
 
 	// Work out the scaling from memory bitmap to page..
 	double MemScale = (double) Context.pDC->X() / (double) RenderedHtml->X();
 	
 	// Now paint the bitmap onto the existing page
 	int PageIdx = 0, Printed = 0;
 	for (int y = 0; y < RenderedHtml->Y(); PageIdx++)
 	{
 		if (Pages.InRanges(PageIdx))
 		{
 			// Work out how much bitmap we can paint onto the current page...
 			int PageRemaining = Context.MarginPx.Y() - Context.CurrentY;
 			int MemPaint = (int) (PageRemaining / MemScale);
 
 			// This is how much of the memory context we can fit on the page
 			LRect MemRect(0, y, RenderedHtml->X()-1, y + MemPaint - 1);
 			LRect Bnds = RenderedHtml->Bounds();
 			MemRect.Bound(&Bnds);
 		
 			// Work out how much page that is take up
 			int PageHeight = (int) (MemRect.Y() * MemScale);
 		
 			// This is the position on the page we are blting to
 			LRect PageRect(Context.MarginPx.x1, Context.CurrentY, Context.MarginPx.x2, Context.CurrentY + PageHeight - 1);
 		
 			// Do the blt
 			Page->StretchBlt(&PageRect, RenderedHtml, &MemRect);
 			Printed++;
 		
 			// Now move our position down the page..
 			Context.CurrentY += PageHeight;
 			if ((Context.MarginPx.Y() - Context.CurrentY) * 100 / Context.MarginPx.Y() < 5)
 			{
 				// Ok we hit the end of the page and need to go to the next page
 				Context.CurrentY = Context.MarginPx.y1;
 				Page = Context.NewPage();
 			}
 
 			y += MemRect.Y();
 		}
 	}
 
 	return Printed;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 size_t Mail::Length()
 {
 	size_t Status = 0;
 
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			Status++;
 		}
 	}
 
 	return Status;
 }
 
 ssize_t Mail::IndexOf(Mail *m)
 {
 	ssize_t Status = -1;
 
 	ssize_t n = 0;
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			if (a->GetMsg() == m)
 			{
 				Status = n;
 				break;
 			}
 			n++;
 		}
 	}
 
 	return Status;
 }
 
 Mail *Mail::operator [](size_t i)
 {
 	size_t n = 0;
 	for (auto a: Attachments)
 	{
 		if (a->GetMimeType() &&
 			_stricmp(a->GetMimeType(), sMimeMessage) == 0)
 		{
 			if (n == i)
 				return a->GetMsg();
 			n++;
 		}
 	}
 
 	return NULL;
 }
 
 bool Mail::LoadFromFile(char *File)
 {
 	if (File)
 	{
 		LAutoPtr<LFile> f(new LFile);
 		if (f->Open(File, O_READ))
 		{
 			return Import(AutoCast(f), sMimeMessage);
 		}
 	}
 
 	return false;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 bool CreateMailAddress(LStream &Out, LDataPropI *Addr, MailProtocol *Protocol)
 {
     if (!Addr)
         return false;
 
     auto Name = Addr->GetStr(FIELD_NAME);
     auto Email = Addr->GetStr(FIELD_EMAIL);
     if (!Email)
         return false;
     
 	Name = EncodeRfc2047(NewStr(Name), 0, &Protocol->CharsetPrefs);
 	if (Name)
 	{
 		if (strchr(Name, '\"'))
 			Out.Print("'%s' ", Name);
 		else
 			Out.Print("\"%s\" ", Name);
 		DeleteArray(Name);
 	}
 
 	Out.Print("<%s>", Email);
 	return true;
 }
 
 bool CreateMailHeaders(ScribeWnd *App, LStream &Out, LDataI *Mail, MailProtocol *Protocol)
 {
 	bool Status = true;
 
 	// Setup
 	char Buffer[1025];
 
 	// Construct date
 	LDateTime Dt;
 	int TimeZone = Dt.SystemTimeZone();
 	Dt.SetNow();
 	sprintf_s(Buffer, sizeof(Buffer),
 			"Date: %s, %i %s %i %i:%2.2i:%2.2i %s%2.2d%2.2d\r\n",
 			LDateTime::WeekdaysShort[Dt.DayOfWeek()],
 			Dt.Day(),
 			LDateTime::MonthsShort[Dt.Month()-1],
 			Dt.Year(),
 			Dt.Hours(),
 			Dt.Minutes(),
 			Dt.Seconds(),
 			(TimeZone >= 0) ? "+" : "",
 			TimeZone / 60,
 			abs(TimeZone) % 60);
 	Status &= Out.Write(Buffer, strlen(Buffer)) > 0;
 
 	if (Protocol && Protocol->ProgramName)
 	{
 		// X-Mailer:
 		Status &= Out.Print("X-Mailer: %s\r\n", Protocol->ProgramName.Get()) > 0;
 	}
 
 	if (Protocol && Protocol->ExtraOutgoingHeaders)
 	{
 		for (char *s=Protocol->ExtraOutgoingHeaders; s && *s; )
 		{
 			char *e = s;
 			while (*e && *e != '\r' && *e != '\n') e++;
 			ssize_t l = e-s;
 			if (l > 0)
 			{
 				Status &= Out.Write(s, l) > 0;
 				Status &= Out.Write((char*)"\r\n", 2) > 0;
 			}
 			while (*e && (*e == '\r' || *e == '\n')) e++;
 			s = e;
 		}
 	}
 
 	int Priority = (int)Mail->GetInt(FIELD_PRIORITY);
 	if (Priority != MAIL_PRIORITY_NORMAL)
 	{
 		// X-Priority:
 		Status &= Out.Print("X-Priority: %i\r\n", Priority) > 0;
 	}
 
     uint32_t MarkColour = (uint32_t)Mail->GetInt(FIELD_COLOUR);
 	if (MarkColour)
 	{
 		// X-Color (HTML Colour Ref for email marking)
 		Status &= Out.Print("X-Color: #%2.2X%2.2X%2.2X\r\n",
 			                R24(MarkColour),
 			                G24(MarkColour),
 			                B24(MarkColour)) > 0;
 	}
 
 	// Message-ID:
 	auto MessageID = Mail->GetStr(FIELD_MESSAGE_ID);
 	if (MessageID)
 	{
 		for (auto m=MessageID; *m; m++)
 		{
 			if (*m <= ' ')
 			{
 				printf("%s:%i - Bad message ID '%s'\n", _FL, MessageID);
 				return false;
 			}			
 		}
 		
 		Status &= Out.Print("Message-ID: %s\r\n", MessageID) > 0;
 	}
 
 	// References:
 	auto References = Mail->GetStr(FIELD_REFERENCES);
 	if (ValidStr(References))
 	{
 		auto Dir = strrchr(References, '/');
 		LString Ref;
 		if (Dir)
 		{
 			LUri u;
 			Ref = u.DecodeStr(Dir + 1);
 		}
 		else
 			Ref = References;
 
 		if (*Ref == '<')
     		Status &= Out.Print("References: %s\r\n", Ref.Get()) > 0;
     	else
 	    	Status &= Out.Print("References: <%s>\r\n", Ref.Get()) > 0;
 	}
 
 	// To:
 	LDataIt Addr = Mail->GetList(FIELD_TO);
 	LArray<Store3Addr*> Objs;
 	LArray<LDataPropI*> To, Cc;
 	ContactGroup *Group;
 	for (unsigned i=0; i<Addr->Length(); i++)
 	{
 	    LDataPropI *a = (*Addr)[i];
 	    EmailAddressType AddrType = (EmailAddressType)a->GetInt(FIELD_CC);
 
 		LString Addr = a->GetStr(FIELD_EMAIL);
 		if (LIsValidEmail(Addr))
 		{
 			if (AddrType == MAIL_ADDR_CC)
 				Cc.Add(a);
 			else if (AddrType == MAIL_ADDR_TO)
 				To.Add(a);
 		}
 		else if ((Group = LookupContactGroup(App, Addr)))
 		{
 			Group->UsedTs.SetNow();
 
 			LString::Array Addrs = Group->GetAddresses();
 			for (unsigned n=0; n<Addrs.Length(); n++)
 			{
 				Store3Addr *sa = new Store3Addr(Group->GetObject()->GetStore(), NULL);
 				if (sa)
 				{
 					sa->Addr = Addrs[n];
 					Objs.Add(sa);
 
 					if (AddrType == MAIL_ADDR_CC)
 						Cc.Add(sa);
 					else if (AddrType == MAIL_ADDR_TO)
 						To.Add(sa);
 				}
 			}
 		}
 	}
 	if (To.Length())
 	{
 	    for (unsigned i=0; i<To.Length(); i++)
 	    {
 	        if (i)
 	            Out.Print(",\r\n\t");
 	        else
     	        Out.Print("To: ");
             
             if (!CreateMailAddress(Out, To[i], Protocol))
                 return false;
 	    }
 	    Out.Print("\r\n");
 	}
 	if (Cc.Length())
 	{
 	    for (unsigned i=0; i<Cc.Length(); i++)
 	    {
 	        if (i)
 	            Out.Print(",\r\n\t");
 	        else
     	        Out.Print("Cc: ");
             
             if (!CreateMailAddress(Out, Cc[i], Protocol))
                 return false;
 	    }
 	    Out.Print("\r\n");
 	}
 
 	// From:
 	LDataPropI *From = Mail->GetObj(FIELD_FROM);
 	if (From && From->GetStr(FIELD_EMAIL))
 	{
 		Out.Print("From: ");
 		if (!CreateMailAddress(Out, From, Protocol))
 		    return false;
 		Out.Print("\r\n");
 	}
 	else
 	{
 		LgiTrace("%s:%i - No from address.\n", _FL);
 		return false;
 	}
 
 	// Reply-To:
 	LDataPropI *Reply = Mail->GetObj(FIELD_REPLY);
 	if (Reply && ValidStr(Reply->GetStr(FIELD_EMAIL)))
 	{
 		Out.Print("Reply-To: ");
 		if (!CreateMailAddress(Out, Reply, Protocol))
 		    return false;
 		Out.Print("\r\n");
 	}
 
 	// Subject:
 	char *Subj = EncodeRfc2047(NewStr(Mail->GetStr(FIELD_SUBJECT)), 0, &Protocol->CharsetPrefs, 9);
 	sprintf_s(Buffer, sizeof(Buffer), "Subject: %s\r\n", (Subj) ? Subj : "");
 	Status &= Out.Write(Buffer, strlen(Buffer)) > 0;
 	DeleteArray(Subj);
 
 	// DispositionNotificationTo
 	uint8_t DispositionNotificationTo = TestFlag(Mail->GetInt(FIELD_FLAGS), MAIL_READ_RECEIPT);
 	if (DispositionNotificationTo && From)
 	{
 		int ch = sprintf_s(Buffer, sizeof(Buffer), "Disposition-Notification-To:");
 		char *Nme = EncodeRfc2047(NewStr(From->GetStr(FIELD_NAME)), 0, &Protocol->CharsetPrefs);
 		if (Nme)
 		{
 			ch += sprintf_s(Buffer+ch, sizeof(Buffer)-ch, " \"%s\"", Nme);
 			DeleteArray(Nme);
 		}
 		ch += sprintf_s(Buffer+ch, sizeof(Buffer)-ch, " <%s>\r\n", From->GetStr(FIELD_EMAIL));
 		Status &= Out.Write(Buffer, ch) > 0;
 	}
 	
 	// Content-Type
 	LDataPropI *Root = Mail->GetObj(FIELD_MIME_SEG);
 	if (Root)
 	{
 		auto MimeType = Root->GetStr(FIELD_MIME_TYPE);
 		auto Charset = Root->GetStr(FIELD_CHARSET);
 		if (MimeType)
 		{
 			LString s;
 			s.Printf("Content-Type: %s%s%s\r\n", MimeType, Charset?"; charset=":"", Charset?Charset:"");
 			Status &= Out.Write(s, s.Length()) == s.Length();
 		}
 	}
 	else LAssert(0);
 	
 	Objs.DeleteObjects();
 	return Status;
 }
diff --git a/Code/Store3Mail3/Mail3.h b/Code/Store3Mail3/Mail3.h
--- a/Code/Store3Mail3/Mail3.h
+++ b/Code/Store3Mail3/Mail3.h
@@ -1,775 +1,779 @@
 #ifndef _MAIL3_H_
 #define _MAIL3_H_
 
 #include "lgi/common/Lgi.h"
 #include "Store3Common.h"
 #include "v3.6.14/sqlite3.h"
 
 // Debugging stuff
 #define MAIL3_TRACK_OBJS		0
 
 #define MAIL3_DB_FILE			"Database.sqlite"
 #define MAIL3_TBL_FOLDER		"Folder"
 #define MAIL3_TBL_FOLDER_FLDS	"FolderFields"
 #define MAIL3_TBL_MAIL			"Mail"
 #define MAIL3_TBL_MAILSEGS		"MailSegs"
 #define MAIL3_TBL_CONTACT		"Contact"
 #define MAIL3_TBL_GROUP			"ContactGroup"
 #define MAIL3_TBL_FILTER		"Filter"
 #define MAIL3_TBL_CALENDAR		"Calendar"
 
 class LMail3Store;
 class LMail3Mail;
 
 enum Mail3SubFormat
 {
 	Mail3v1, // All the mail and segs in a single tables.
 	Mail3v2, // All the mail and segs in per folders tables.
 };
 
 struct GMail3Def
 {
 	const char *Name;
 	const char *Type;
 };
 
 struct GMail3Idx
 {
 	const char *IdxName;
 	const char *Table;
 	const char *Column;
 };
 
 class Mail3BlobStream : public LStream
 {
 	LMail3Store *Store;
 	sqlite3_blob *b;
 	int64 Pos, Size;
 	int SegId;
 	bool WriteAccess;
 	
 	bool OpenBlob();
 	bool CloseBlob();
 
 public:
 	const char *File;
 	int Line;
 
 	Mail3BlobStream(LMail3Store *Store, int segId, int size, const char *file, int line, bool Write = false);
 	~Mail3BlobStream();
 	
 	int64 GetPos();
 	int64 SetPos(int64 p);
 	int64 GetSize();
 	int64 SetSize(int64 sz);
 	
 	ssize_t Read(void *Buf, ssize_t Len, int Flags = 0);
 	ssize_t Write(const void *Buf, ssize_t Len, int Flags = 0);
 };
 
 
 extern GMail3Def TblFolder[];
 extern GMail3Def TblFolderFlds[];
 extern GMail3Def TblMail[];
 extern GMail3Def TblMailSegs[];
 extern GMail3Def TblContact[];
 extern GMail3Def TblFilter[];
 extern GMail3Def TblGroup[];
 extern GMail3Def TblCalendar[];
 
 #define SERIALIZE_STR(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetStr(Col, Var.Str())) \
 			return false; \
 	} \
 	else \
 		Var = s.GetStr(Col);
 
 #define SERIALIZE_DATE(Var, Col) \
 	if (Write) \
 	{ \
 		if (Var.IsValid()) Var.ToUtc(); \
 		if (!s.SetDate(Col, Var)) \
 			return false; \
 	} \
 	else \
 	{ \
 		int Fmt = Var.GetFormat(); \
 		Var.SetFormat(GDTF_YEAR_MONTH_DAY|GDTF_24HOUR); \
 		Var.Set(s.GetStr(Col)); \
 		Var.SetFormat(Fmt); \
 		Var.SetTimeZone(0, false); \
 	}
 
 #define SERIALIZE_BOOL(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetBool(Col);
 
 #define SERIALIZE_INT(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetInt(Col);
 
 
 #define SERIALIZE_INT64(Var, Col) \
 	if (Write) \
 	{ \
 		if (!s.SetInt64(Col, Var)) \
 			return false; \
 	} \
 	else \
 		Var = s.GetInt64(Col);
 
 #define SERIALIZE_COLOUR(Colour, Col) \
 	if (Write) \
 	{ \
 		int64_t c = Colour.IsValid() ? Colour.c32() : 0; \
 		if (!s.SetInt64(Col, c)) \
 			return false; \
 	} \
 	else \
 	{ \
 		int64_t c = s.GetInt64(Col); \
 		if (c > 0) Colour.c32((uint32_t)c); \
 		else Colour.Empty(); \
 	}
 
 #define SERIALIZE_AUTOSTR(var, Col) \
 	{ \
 		if (Write) \
 		{ \
 			if (!s.SetStr(Col, var)) \
 				return false; \
 		} \
 		else \
 		{ \
 			var.Reset(NewStr(s.GetStr(Col))); \
 		} \
 	}
 
-#define SERIALIZE_GSTR(var, Col) \
+#define SERIALIZE_LSTR(var, Col) \
 	{ \
 		if (Write) \
 		{ \
 			if (!s.SetStr(Col, var)) \
 				return false; \
 		} \
 		else \
 		{ \
 			var = s.GetStr(Col); \
 		} \
 	}
 	
 struct LMail3StoreMsg
 {
 	enum Type
 	{
 		MsgNone,
 		MsgCompactComplete,
 		MsgRepairComplete,
 	}	Msg;
 
 	int64_t Int;
 	LString Str;
 
 	LMail3StoreMsg(Type type)
 	{
 		Msg = type;
 	}
 };
 
 class LMail3Store : public LDataStoreI
 {
 	friend class LMail3Obj;
 	friend class LMail3Mail;
 	friend class Mail3Trans;
 	friend class CompactThread;
 
 	LDataEventsI *Callback;
 	sqlite3 *Db;
 	LString Folder;
 	LString DbFile;
 	class LMail3Folder *Root;
 	LHashTbl<ConstStrKey<char,false>, GMail3Def*> Fields;
 	LHashTbl<StrKey<char,false>, GMail3Idx*> Indexes;
 	Store3Status OpenStatus;
 	LHashTbl<ConstStrKey<char,true>, Store3Status> TableStatus;
 	LString ErrorMsg;
 	LString StatusMsg;
 	LString TempPath;
 
 	std::function<void(bool)> CompactOnStatus;
 	std::function<void(bool)> RepairOnStatus;
 
 	struct TableDefn : LArray<GMail3Def>
 	{
 		LString::Array t;
 	};
 
 	bool ParseTableFormat(const char *Name, TableDefn &Defs);
 	Store3Status CheckTable(const char *Name, GMail3Def *Flds);
 	bool UpdateTable(const char *Name, GMail3Def *Flds, Store3Status Check);
 	bool DeleteMailById(int64 Id);
 	bool OpenDb();
 	bool CloseDb();
 	LMail3Folder *GetSystemFolder(int Type);
 
 public:
 	Mail3SubFormat Format;
 
 	class LStatement
 	{
 		struct PostBlob
 		{
 			int64 Size;
 			LVariant ColName;
 			LStreamI *Data;
 		};
 
 		LArray<PostBlob> Post;
 
 	protected:
 		LMail3Store *Store;
 		sqlite3_stmt *s;
 		LVariant Table;
 		LAutoString TempSql;
 		
 	public:
 		LStatement(LMail3Store *store, const char *sql = 0);
 		virtual ~LStatement();
 
 		operator sqlite3_stmt *() { return s; }
 
 		bool IsOk()
 		{
 			return
 				#ifndef __llvm__
 				this != 0 &&
 				#endif
 				Store != 0 &&
 				s != 0;
 		}
 		bool Prepare(const char *Sql);
 		bool Row();
 		bool Exec();
 		bool Reset();
 		bool Finalize();
 		int64 LastInsertId();
 		
 		int GetSize(int Col);
 
 		bool GetBool(int Col);
 		int GetInt(int Col);
 		bool SetInt(int Col, int n);
 		int64 GetInt64(int Col);
 		bool SetInt64(int Col, int64 n);
 		char *GetStr(int Col);
 		bool GetBinary(int Col, LVariant *v);
 
 		bool SetStr(int Col, char *s);
 		bool SetDate(int Col, LDateTime &d);
 		bool SetStream(int Col, const char *ColName, LStreamI *s);
 		bool SetBinary(int Col, const char *ColName, LVariant *v);
 
 		virtual int64 GetRowId() { LAssert(0); return -1; }
 	};
 
 	class LInsert : public LStatement
 	{
 	public:
 		LInsert(LMail3Store *store, const char *Tbl);
 
 		int64 GetRowId() { return LastInsertId(); }
 	};
 
 	class LUpdate : public LStatement
 	{
 		int64 RowId;
 
 	public:
 		LUpdate(LMail3Store *store, const char *Tbl, int64 rowId, char *ExcludeField = 0);
 
 		int64 GetRowId() { return RowId; }
 	};
 
 	class LTransaction
 	{
 		LMail3Store *Store;
 		bool Open;
 
 	public:
 		LTransaction(LMail3Store *store);
 		~LTransaction();
 		
 		bool RollBack();
 	};
 
 	#if MAIL3_TRACK_OBJS
 	struct SqliteObjs
 	{
 		LStatement *Stat;
 		Mail3BlobStream *Stream;
 		SqliteObjs()
 		{
 			Stat = 0;
 			Stream = 0;
 		}
 	};
 	LArray<SqliteObjs> All;
 	template<typename T>
 	bool RemoveFromAll(T *p)
 	{
 		for (int i=0; i<All.Length(); i++)
 		{
 			SqliteObjs &d = All[i];
 			if ((d.Stream && (void*)d.Stream == (void*)p)
 				||
 				(d.Stat && (void*)d.Stat == (void*)p))
 			{
 				All.DeleteAt(i);
 				return true;
 			}
 		}
 		LAssert(0);
 		return false;
 	}
 	#endif
 
 	LMail3Store(const char *Mail3Folder, LDataEventsI *Callback, bool Create);
 	~LMail3Store();
 
 	int64 GetFolderId(char *Path);
 	LDataEventsI *GetEvents() { return Callback; }
 	bool OnIdle() { return false; }
 	sqlite3 *GetDb() { return Db; }
 	bool IsOk();
 	int64 GetInt(int id);
 	Store3Status SetInt(int id, int64 i);
 	const char *GetStr(int id);
 	Store3Status SetStr(int id, const char *s);
 	LDataPropI *GetObj(int id);
 	uint64 Size();
 	LDataI *Create(int Type);
 	LDataFolderI *GetRoot(bool create = false);
 	Store3Status Move(LDataFolderI *NewFolder, LArray<LDataI*> &Items);
 	Store3Status Delete(LArray<LDataI*> &Items, bool ToTrash);
 	Store3Status Change(LArray<LDataI*> &Items, int PropId, LVariant &Value, LOperator Operator);
 	void Compact(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	void Upgrade(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	void Repair(LViewI *Parent, LDataPropI *Props, std::function<void(bool)> OnStatus);
 	bool SetFormat(LViewI *Parent, LDataPropI *Props);
 	void PostStore(LMail3StoreMsg *m) { Callback->Post(this, m); }
 	void OnEvent(void *Param);
 	bool Check(int Code, const char *Sql);
 	GMail3Def *GetFields(const char *t) { return Fields.Find(t); }
 
 	StoreTrans StartTransaction();
 
 	// LDataEventsI wrappers
 	void OnNew(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &new_items, int pos, bool is_new);
 	bool OnMove(const char *File, int Line, LDataFolderI *new_parent, LDataFolderI *old_parent, LArray<LDataI*> &items);
 	bool OnChange(const char *File, int Line, LArray<LDataI*> &items, int FieldHint);
 	bool OnDelete(const char *File, int Line, LDataFolderI *parent, LArray<LDataI*> &items);
 
 private:
 	class Mail3Trans : public LDataStoreI::LDsTransaction
 	{
 		Mail3Trans **Ptr;
 		LTransaction Trans;
 
 	public:
 		Mail3Trans(LMail3Store *s, Mail3Trans **ptr);
 		~Mail3Trans();
 	} *Transaction;
 };
 
 class LMail3Obj
 {
 protected:
 	bool Check(int r, char *sql);
 
 public:
 	LMail3Store *Store;
 	int64 Id;
 	int64 ParentId;
 
 	LMail3Obj(LMail3Store *store)
 	{
 		Id = ParentId = -1;
 		Store = store;
 	}
 
 	bool Write(const char *Table, bool Insert);
 
 	virtual const char *GetClass() { return "LMail3Obj"; }
 	virtual bool Serialize(LMail3Store::LStatement &s, bool Write) = 0;
 	virtual void SetStore(LMail3Store *s) { Store = s; }
 };
 
 class LMail3Thing : public LDataI, public LMail3Obj 
 {
 	friend class LMail3Store;
 	LMail3Thing &operator =(LMail3Thing &p) = delete;
 
 protected:
     bool NewMail = false;
 
 	virtual const char *GetTable() { LAssert(0); return  0; }
 	virtual void OnSave() {};
 
 public:
 	LMail3Folder *Parent = NULL;
 
 	LMail3Thing(LMail3Store *store) : LMail3Obj(store)
 	{
 	}
 
 	~LMail3Thing();
 
 	const char *GetClass() { return "LMail3Thing"; }
 	bool IsOnDisk() { return Id > 0; }
 	bool IsOrphan() { return false; }
 	uint64 Size() { return sizeof(*this); }
 	uint32_t Type() { LAssert(0); return 0; }
 	Store3Status Delete(bool ToTrash);
 	LDataStoreI *GetStore() { return Store; }
 	LAutoStreamI GetStream(const char *file, int line) { LAssert(0); return LAutoStreamI(0); }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) { LAssert(0); return false; }
 
 	Store3Status Save(LDataI *Folder = 0);
 	virtual bool DbDelete() { LAssert(0); return false; }
 };
 
 class LMail3Folder : public LDataFolderI, public LMail3Obj
 {
 public:
 	LVariant Name;
 	int Unread;
 	int Open;
 	int ItemType;
 	int Sort; // Which field to sort contents on
 	int Threaded;
 	int SiblingIndex; // The index of this folder when sorting amongst other sibling folders
 	union {
 		int AccessPerms;
 		struct {
 			int16_t ReadPerm;
 			int16_t WritePerm;
 		};
 	};
 	Store3SystemFolder System;
 
 	LMail3Folder *Parent;
 	DIterator<LDataFolderI, LMail3Folder, LMail3Store> Sub;
 	DIterator<LDataI, LMail3Thing, LMail3Store> Items;
 	DIterator<LDataPropI, Store3Field, LMail3Store> Flds;
 
 	LMail3Folder(LMail3Store *store);
 	~LMail3Folder();
 
 	Store3CopyDecl;
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	const char *GetClass() override { return "LMail3Folder"; }
 
 	uint32_t Type() override;
 	bool IsOnDisk() override;
 	bool IsOrphan() override;
 	uint64 Size() override;
 	Store3Status Save(LDataI *Folder) override;
 	Store3Status Delete(bool ToTrash) override;
 	LDataStoreI *GetStore() override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI stream) override;
 	LDataIterator<LDataFolderI*> &SubFolders() override;
 	LDataIterator<LDataI*> &Children() override;
 	LDataIterator<LDataPropI*> &Fields() override;
 	Store3Status DeleteAllChildren() override;
 	Store3Status FreeChildren() override;
 	LMail3Folder *FindSub(char *Name);
 	bool DbDelete();
 	bool GenSizes();
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 };
 
 class LMail3Attachment : public Store3Attachment<LMail3Store, LMail3Mail, LMail3Attachment>
 {
 	int64 SegId;
 	int64 BlobSize;
 
 	LAutoString Headers;
 
 	LString Name;
 	LString MimeType;
 	LString ContentId;
 	LString Charset;
 	
 	/// This is set when the segment is not to be stored on disk.
 	/// When signed and/or encrypted messages are stored, the original
 	/// rfc822 image is maintained by not MIME decoding into separate
 	/// segments but leaving it MIME encoded in one seg (headers and body).
 	/// At runtime the segment is loaded and parsed into a temporary tree
 	/// of LMail3Attachment objects. This flag is set for those temporary
 	/// nodes.
 	bool InMemoryOnly;
 
 public:
 	LMail3Attachment(LMail3Store *store);
 	~LMail3Attachment();
 
 	void SetInMemoryOnly(bool b);
 	int64 GetId() { return SegId; }
 	LMail3Attachment *Find(int64 Id);
 	bool Load(LMail3Store::LStatement &s, int64 &ParentId);
 	bool ParseHeaders() override;
 	char *GetHeaders();
 	bool HasHeaders() { return ValidStr(Headers); }
 
 	Store3CopyDecl;
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 	Store3Status Delete(bool ToTrash = false) override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI stream) override;
 
 	uint32_t Type() override { return MAGIC_ATTACHMENT; }
 	bool IsOnDisk() override { return SegId > 0; }
 	bool IsOrphan() override { return false; }
 	uint64 Size() override;
 	uint64 SizeChildren();
 	Store3Status Save(LDataI *Folder = 0) override;
 	void OnSave() override;
 };
 
 class LMail3Mail : public LMail3Thing
 {
 	LAutoString TextCache;
 	LAutoString HtmlCache;
 	LString IdCache;
 	LAutoPtr<uint64> SizeCache;
 	LString InferredCharset;
 
 	void LoadSegs();
 	void OnSave() override;
 
 	const char *GetTable() override { return MAIL3_TBL_MAIL; }
 	void ParseAddresses(char *Str, int CC);
 	const char *InferCharset();
 	bool Utf8Check(LVariant &v);
 	bool Utf8Check(LAutoString &v);
 
 public:
 	int Priority = MAIL_PRIORITY_NORMAL;
 	int Flags = 0;
 	int AccountId = 0;
 	int64 MailSize = 0;
 	uint32_t MarkColour = Rgba32(0, 0, 0, 0); // FIELD_MARK_COLOUR, 32bit rgba colour
 
 	LVariant Subject;
 	DIterator<LDataPropI, Store3Addr, LMail3Store> To;
 	LMail3Attachment *Seg = NULL;
 	Store3Addr From;
 	Store3Addr Reply;
 	LVariant Label;
 	LVariant MessageID;
 	LVariant References;
 	LVariant FwdMsgId;
 	LVariant BounceMsgId;
 	LVariant ServerUid;
 
 	LDateTime DateReceived;
 	LDateTime DateSent;
 
 	LMail3Mail(LMail3Store *store);
 	~LMail3Mail();
 
 	Store3CopyDecl;
 	void SetStore(LMail3Store *s) override;
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	const char *GetClass() override { return "LMail3Mail"; }
 	LMail3Attachment *GetAttachment(int64 Id);
 	bool FindSegs(const char *MimeType, LArray<LMail3Attachment*> &Segs, bool Create = false);
 	int GetAttachments(LArray<LMail3Attachment*> *Lst = 0);
     bool ParseHeaders() override;
     void ResetCaches();
 
 	uint32_t Type() override;
 	uint64 Size() override;
 	bool DbDelete() override;
 	LDataStoreI *GetStore() override;
 	LAutoStreamI GetStream(const char *file, int line) override;
 	bool SetStream(LAutoStreamI  stream) override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int id, int64 i) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *t) override;
 	LDataPropI *GetObj(int id) override;
 	Store3Status SetObj(int id, LDataPropI *i) override;
 	LDataIt GetList(int id) override;
 	Store3Status SetRfc822(LStreamI *m) override;
 };
 
 class LMail3Contact : public LMail3Thing
 {
 	const char *GetTable() override { return MAIL3_TBL_CONTACT; }
 	LHashTbl<IntKey<int64>, LString*> f;
 
 public:
 	LVariant Image;
 	LDateTime DateMod;
 
 	LMail3Contact(LMail3Store *store);
 	~LMail3Contact();
 
 	uint32_t Type() override { return MAGIC_CONTACT; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Contact"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 
 	int64 GetInt(int id) override { return -1; }
 
 	LVariant *GetVar(int id) override;
 	Store3Status SetVar(int id, LVariant *i) override;
 
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Group : public LMail3Thing
 {
 	const char *GetTable() override { return MAIL3_TBL_GROUP; }
 
 	LString Name;
 	LString Group;
 	LDateTime DateMod;
 
 public:
 	LMail3Group(LMail3Store *store);
 	~LMail3Group();
 
 	uint32_t Type() override { return MAGIC_GROUP; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Group"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 
 	int64 GetInt(int id) override { return -1; }
 
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Filter : public LMail3Thing
 {
 	int Index;
 	int StopFiltering;
 	int Direction;
-	LAutoString Name;
-	LAutoString ConditionsXml;
-	LAutoString ActionsXml;
-	LAutoString Script;
+	LString Name;
+	LString ConditionsXml;
+	LString ActionsXml;
+	LString Script;
+	LDateTime Modified;
 
 	const char *GetTable() override { return MAIL3_TBL_FILTER; }
 
 public:
 	LMail3Filter(LMail3Store *store);
 	~LMail3Filter();
 
 	uint32_t Type() override { return MAGIC_FILTER; }
 	LDataStoreI *GetStore() override { return Store; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Filter"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
-	Store3Status SetStr(int id, const char *str) override;
+	Store3Status SetStr(int id, const char *str) override;	
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int Col, int64 n) override;
+	const LDateTime *GetDate(int id) override;
+	Store3Status SetDate(int id, const LDateTime *i) override;
 };
 
 class LMail3Calendar : public LMail3Thing
 {
 	LString ToCache;
 
 private:
 	int CalType; // FIELD_CAL_TYPE
 	LString To; // FIELD_TO
 	CalendarPrivacyType CalPriv; // FIELD_CAL_PRIVACY
 	int Completed; // FIELD_CAL_COMPLETED
 	LDateTime Start; // FIELD_CAL_START_UTC
 	LDateTime  End; // FIELD_CAL_END_UTC
 	LString TimeZone; // FIELD_CAL_TIMEZONE
 	LString Subject; // FIELD_CAL_SUBJECT
 	LString Location; // FIELD_CAL_LOCATION
 	LString Uid; // FIELD_UID
 	bool AllDay; // FIELD_CAL_ALL_DAY
 	int64 StoreStatus; // FIELD_STATUS - ie the current Store3Status
 	LString EventStatus; // FIELD_CAL_STATUS
+	LDateTime Modified; // FIELD_DATE_MODIFIED
 
 	LString Reminders; // FIELD_CAL_REMINDERS
 	LDateTime LastCheck; // FIELD_CAL_LAST_CHECK
 	int ShowTimeAs; // FIELD_CAL_SHOW_TIME_AS
 
 	int Recur; // FIELD_CAL_RECUR
 	int RecurFreq; // FIELD_CAL_RECUR_FREQ
 	int RecurInterval; // FIELD_CAL_RECUR_INTERVAL
 	LDateTime RecurEnd; // FIELD_CAL_RECUR_END_DATE
 	int RecurCount; // FIELD_CAL_RECUR_END_COUNT
 	int RecurEndType; // FIELD_CAL_RECUR_END_TYPE
 	LString RecurPos; // FIELD_CAL_RECUR_FILTER_POS
 	
 	int FilterDays; // FIELD_CAL_RECUR_FILTER_DAYS
 	int FilterMonths; // FIELD_CAL_RECUR_FILTER_MONTHS
 	LString FilterYears; // FIELD_CAL_RECUR_FILTER_YEARS
 	LString Notes; // FIELD_CAL_NOTES
 	
 	LColour Colour;
 
 	const char *GetTable() override { return MAIL3_TBL_CALENDAR; }
 
 public:
 	LMail3Calendar(LMail3Store *store);
 	~LMail3Calendar();
 
 	uint32_t Type() override { return MAGIC_CALENDAR; }
 	LDataStoreI *GetStore() override { return Store; }
 	bool Serialize(LMail3Store::LStatement &s, bool Write) override;
 	Store3CopyDecl;
 	const char *GetClass() override { return "LMail3Filter"; }
 	bool DbDelete() override;
 
 	const char *GetStr(int id) override;
 	Store3Status SetStr(int id, const char *str) override;
 	int64 GetInt(int id) override;
 	Store3Status SetInt(int Col, int64 n) override;
 	const LDateTime *GetDate(int id) override;
 	Store3Status SetDate(int id, const LDateTime *t) override;
 };
 
 #endif
diff --git a/Code/Store3Mail3/Mail3Calendar.cpp b/Code/Store3Mail3/Mail3Calendar.cpp
--- a/Code/Store3Mail3/Mail3Calendar.cpp
+++ b/Code/Store3Mail3/Mail3Calendar.cpp
@@ -1,434 +1,434 @@
 #include "Mail3.h"
 #include "lgi/common/Json.h"
 
 GMail3Def TblCalendar[] =
 {
 	{"Id",				"INTEGER PRIMARY KEY AUTOINCREMENT"},
 	{"ParentId",		"INTEGER"},
 
 	{"CalType",			"INTEGER"}, // FIELD_CAL_TYPE
 	{"Completed",		"INTEGER"}, // FIELD_CAL_COMPLETED
 	{"Start",			"TEXT"},	// FIELD_CAL_START_UTC
 	{"End",				"TEXT"},	// FIELD_CAL_END_UTC
 	{"TimeZone",		"TEXT"},	// FIELD_CAL_TIMEZONE
 	{"Subject",			"TEXT"},	// FIELD_CAL_SUBJECT
 	{"Location",		"TEXT"},	// FIELD_CAL_LOCATION
 	{"Uid",				"TEXT"},	// FIELD_UID
 	{"ShowTimeAs",		"INTEGER"}, // FIELD_CAL_SHOW_TIME_AS
 	{"Recur",			"INTEGER"}, // FIELD_CAL_RECUR
 	{"RecurFreq",		"INTEGER"}, // FIELD_CAL_RECUR_FREQ
 	{"RecurInterval",	"INTEGER"}, // FIELD_CAL_RECUR_INTERVAL
 	{"RecurEnd",		"TEXT"},	// FIELD_CAL_RECUR_END_DATE
 	{"RecurCount",		"INTEGER"}, // FIELD_CAL_RECUR_END_COUNT
 	{"RecurEndType",	"INTEGER"}, // FIELD_CAL_RECUR_END_TYPE
 	{"RecurPos",		"TEXT"},	// FIELD_CAL_RECUR_FILTER_POS
 	{"FilterDays",		"INTEGER"}, // FIELD_CAL_RECUR_FILTER_DAYS
 	{"FilterMonths",	"INTEGER"}, // FIELD_CAL_RECUR_FILTER_MONTHS
 	{"FilterYears",		"TEXT"},	// FIELD_CAL_RECUR_FILTER_YEARS
 	{"Notes",			"TEXT"},	// FIELD_CAL_NOTES
 	{"Colour",			"INTEGER"},	// FIELD_COLOUR
 	{"Guests",			"TEXT"},	// FIELD_TO
 	{"Reminders",		"TEXT"},	// FIELD_CAL_REMINDERS
 	{"LastCheck",		"TEXT"},	// FIELD_CAL_LAST_CHECK
 	{"AllDay",			"INTEGER"},	// FIELD_CAL_ALL_DAY
 	{"Status",			"STATUS"},	// FIELD_CAL_STATUS
+	{"DateModified",	"TEXT"},	// FIELD_DATE_MODIFIED
 
 	{0, 0}
 };
 
 LMail3Calendar::LMail3Calendar(LMail3Store *store) : LMail3Thing(store)
 {
 	CalType = 0;
 	CalPriv = CalDefaultPriv;
 	Completed = 0;
 	ShowTimeAs = 0;
 	Recur = 0;
 	RecurFreq = 0;
 	RecurInterval = 0;
 	RecurCount = 0;
 	RecurEndType = 0;
 	FilterDays = 0;
 	FilterMonths = 0;
 	AllDay = false;
 	StoreStatus = Store3Success;
 }
 
 LMail3Calendar::~LMail3Calendar()
 {
 }
 
 bool LMail3Calendar::DbDelete()
 {
 	char s[256];
 
 	// Delete the calendar itself
 	sprintf_s(s, sizeof(s), "delete from " MAIL3_TBL_CALENDAR " where Id=" LPrintfInt64, Id);
 	LMail3Store::LStatement Del(Store, s);
 	if (!Del.Exec())
 		return false;
 
 	return true;
 }
 
 bool LMail3Calendar::Serialize(LMail3Store::LStatement &s, bool Write)
 {
 	int i = 0;
 
 	SERIALIZE_INT64(Id, i++);
 	SERIALIZE_INT64(ParentId, i++);
 
 	SERIALIZE_INT(CalType, i++); // FIELD_CAL_TYPE
 	SERIALIZE_INT(Completed, i++); // FIELD_CAL_COMPLETED
 	SERIALIZE_DATE(Start, i++); // FIELD_CAL_START_UTC
 	SERIALIZE_DATE(End, i++); // FIELD_CAL_END_UTC
-	SERIALIZE_GSTR(TimeZone, i++); // FIELD_CAL_TIMEZONE
-	SERIALIZE_GSTR(Subject, i++); // FIELD_CAL_SUBJECT
-	SERIALIZE_GSTR(Location, i++); // FIELD_CAL_LOCATION
-	SERIALIZE_GSTR(Uid, i++); // FIELD_UID
+	SERIALIZE_LSTR(TimeZone, i++); // FIELD_CAL_TIMEZONE
+	SERIALIZE_LSTR(Subject, i++); // FIELD_CAL_SUBJECT
+	SERIALIZE_LSTR(Location, i++); // FIELD_CAL_LOCATION
+	SERIALIZE_LSTR(Uid, i++); // FIELD_UID
 	SERIALIZE_INT(ShowTimeAs, i++); // FIELD_CAL_SHOW_TIME_AS
 	SERIALIZE_INT(Recur, i++); // FIELD_CAL_RECUR
 	SERIALIZE_INT(RecurFreq, i++); // FIELD_CAL_RECUR_FREQ
 	SERIALIZE_INT(RecurInterval, i++); // FIELD_CAL_RECUR_INTERVAL
 	SERIALIZE_DATE(RecurEnd, i++); // FIELD_CAL_RECUR_END_DATE
 	SERIALIZE_INT(RecurCount, i++); // FIELD_CAL_RECUR_END_COUNT
 	SERIALIZE_INT(RecurEndType, i++); // FIELD_CAL_RECUR_END_TYPE
-	SERIALIZE_GSTR(RecurPos, i++); // FIELD_CAL_RECUR_FILTER_POS
+	SERIALIZE_LSTR(RecurPos, i++); // FIELD_CAL_RECUR_FILTER_POS
 	SERIALIZE_INT(FilterDays, i++); // FIELD_CAL_RECUR_FILTER_DAYS
 	SERIALIZE_INT(FilterMonths, i++); // FIELD_CAL_RECUR_FILTER_MONTHS
-	SERIALIZE_GSTR(FilterYears, i++); // FIELD_CAL_RECUR_FILTER_YEARS
-	SERIALIZE_GSTR(Notes, i++); // FIELD_CAL_NOTES
+	SERIALIZE_LSTR(FilterYears, i++); // FIELD_CAL_RECUR_FILTER_YEARS
+	SERIALIZE_LSTR(Notes, i++); // FIELD_CAL_NOTES
 	SERIALIZE_COLOUR(Colour, i++); // FIELD_COLOUR
-	SERIALIZE_GSTR(To, i++); // FIELD_TO
-	SERIALIZE_GSTR(Reminders, i++); // FIELD_CAL_REMINDER_TIME
+	SERIALIZE_LSTR(To, i++); // FIELD_TO
+	SERIALIZE_LSTR(Reminders, i++); // FIELD_CAL_REMINDER_TIME
 	SERIALIZE_DATE(LastCheck, i++); // FIELD_CAL_LAST_CHECK
 	SERIALIZE_BOOL(AllDay, i++); // FIELD_CAL_ALL_DAY
-	SERIALIZE_GSTR(EventStatus, i++); // FIELD_CAL_STATUS
+	SERIALIZE_LSTR(EventStatus, i++); // FIELD_CAL_STATUS
 
 	if (Write)
 	{
 		StoreStatus = Store3Success;
 	}
 	else if (To.Get())
 	{
 		char c = To.Get()[0];
 		if (c != '[' && c != '{')
 		{
 			// Convert old style comma separated field to JSON
 			LString s = To;
 			To.Empty();
 			SetStr(FIELD_TO, s);
 		}
 	}
 
 	
 	return true;
 }
 
 Store3CopyImpl(LMail3Calendar)
 {
 	SetInt(FIELD_CAL_TYPE, p.GetInt(FIELD_CAL_TYPE));
 	SetInt(FIELD_CAL_COMPLETED, p.GetInt(FIELD_CAL_COMPLETED));
 	SetDate(FIELD_CAL_START_UTC, p.GetDate(FIELD_CAL_START_UTC));
 	SetDate(FIELD_CAL_END_UTC, p.GetDate(FIELD_CAL_END_UTC));
 	SetStr(FIELD_CAL_TIMEZONE, p.GetStr(FIELD_CAL_TIMEZONE));
 	SetStr(FIELD_CAL_SUBJECT, p.GetStr(FIELD_CAL_SUBJECT));
 	SetStr(FIELD_CAL_LOCATION, p.GetStr(FIELD_CAL_LOCATION));
 	SetStr(FIELD_UID, p.GetStr(FIELD_UID));
 	SetStr(FIELD_CAL_REMINDERS, p.GetStr(FIELD_CAL_REMINDERS));
 	SetInt(FIELD_CAL_SHOW_TIME_AS, p.GetInt(FIELD_CAL_SHOW_TIME_AS));
 	SetInt(FIELD_CAL_RECUR, p.GetInt(FIELD_CAL_RECUR));
 	SetInt(FIELD_CAL_RECUR_FREQ, p.GetInt(FIELD_CAL_RECUR_FREQ));
 	SetInt(FIELD_CAL_RECUR_INTERVAL, p.GetInt(FIELD_CAL_RECUR_INTERVAL));
 	SetDate(FIELD_CAL_RECUR_END_DATE, p.GetDate(FIELD_CAL_RECUR_END_DATE));
 	SetInt(FIELD_CAL_RECUR_END_COUNT, p.GetInt(FIELD_CAL_RECUR_END_COUNT));
 	SetInt(FIELD_CAL_RECUR_END_TYPE, p.GetInt(FIELD_CAL_RECUR_END_TYPE));
 	SetStr(FIELD_CAL_RECUR_FILTER_POS, p.GetStr(FIELD_CAL_RECUR_FILTER_POS));
 	SetInt(FIELD_CAL_RECUR_FILTER_DAYS, p.GetInt(FIELD_CAL_RECUR_FILTER_DAYS));
 	SetInt(FIELD_CAL_RECUR_FILTER_MONTHS, p.GetInt(FIELD_CAL_RECUR_FILTER_MONTHS));
 	SetStr(FIELD_CAL_RECUR_FILTER_YEARS, p.GetStr(FIELD_CAL_RECUR_FILTER_YEARS));
 	SetStr(FIELD_CAL_NOTES, p.GetStr(FIELD_CAL_NOTES));
 	SetDate(FIELD_CAL_LAST_CHECK, p.GetDate(FIELD_CAL_LAST_CHECK));
+	SetDate(FIELD_DATE_MODIFIED, p.GetDate(FIELD_DATE_MODIFIED));
 
 	return true;
 }
 
 const char *LMail3Calendar::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_TO:
 		{
 			if (!ToCache)
 			{
 				LJson j(To);
 				LString::Array Out;
 				Out.SetFixedLength(false);
 				for (auto i: j.GetArray(NULL))
 				{
 					auto Nm = i.Get("name");
 					auto Em = i.Get("email");
 					Out.New().Printf("\'%s\' <%s>", Nm.Get(), Em.Get());
 				}
 				ToCache = LString(",").Join(Out);
 			}
 			return ToCache;
 		}
 		case FIELD_ATTENDEE_JSON:
 			return To;
 		case FIELD_CAL_TIMEZONE:
 			return TimeZone;
 		case FIELD_CAL_SUBJECT:
 			return Subject;
 		case FIELD_CAL_LOCATION:
 			return Location;
 		case FIELD_UID:
 			return Uid;
 		case FIELD_CAL_REMINDERS:
 			return Reminders;
 		case FIELD_CAL_RECUR_FILTER_POS:
 			return RecurPos;
 		case FIELD_CAL_RECUR_FILTER_YEARS:
 			return FilterYears;
 		case FIELD_CAL_NOTES:
 			return Notes;
 		case FIELD_CAL_STATUS:
 			return EventStatus;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 Store3Status LMail3Calendar::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_TO:
 		{
 			LJson j;
 			auto In = LString(str).SplitDelimit(",");
 			int i = 0;
 			for (auto s: In)
 			{
 				LAutoString Name, Addr;
 				DecodeAddrName(s, Name, Addr, NULL);
 				if (Addr)
 				{
 					LString a;
 					a.Printf("[%i].email", i);
 					j.Set(a, Addr);
 
 					a.Printf("[%i].name", i);
 					if (Name)
 						j.Set(a, Name);
 					i++;
 				}				
 			}
 			To = j.GetJson();
 			ToCache = str;
 			break;
 		}
 		case FIELD_ATTENDEE_JSON:
 			To = str;
 			ToCache.Empty();
 			break;
 		case FIELD_CAL_TIMEZONE:
 			TimeZone = str;
 			break;
 		case FIELD_CAL_SUBJECT:
 			Subject = str;
 			break;
 		case FIELD_CAL_LOCATION:
 			Location = str;
 			break;
 		case FIELD_UID:
 			Uid = str;
 			break;
 		case FIELD_CAL_REMINDERS:
 			Reminders = str;
 			break;
 		case FIELD_CAL_RECUR_FILTER_POS:
 			RecurPos = str;
 			break;
 		case FIELD_CAL_RECUR_FILTER_YEARS:
 			FilterYears = str;
 			break;
 		case FIELD_CAL_NOTES:
 			Notes = str;
 			break;
 		case FIELD_CAL_STATUS:
 			EventStatus = str;
 			break;
 		default:
 			LAssert(0);
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 int64 LMail3Calendar::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_STORE_TYPE:
 			return Store3Sqlite;
 		case FIELD_CAL_TYPE:
 			return CalType;
 		case FIELD_CAL_COMPLETED:
 			return Completed;
 		case FIELD_CAL_SHOW_TIME_AS:
 			return ShowTimeAs;
 		case FIELD_CAL_RECUR:
 			return Recur;
 		case FIELD_CAL_RECUR_FREQ:
 			return RecurFreq;
 		case FIELD_CAL_RECUR_INTERVAL:
 			return RecurInterval;
 		case FIELD_CAL_RECUR_END_COUNT:
 			return RecurCount;
 		case FIELD_CAL_RECUR_END_TYPE:
 			return RecurEndType;
 		case FIELD_CAL_RECUR_FILTER_DAYS:
 			return FilterDays;
 		case FIELD_CAL_RECUR_FILTER_MONTHS:
 			return FilterMonths;
 		case FIELD_CAL_PRIVACY:
 			return CalPriv;
 		case FIELD_COLOUR:
 			if (Colour.IsValid())
 				return Colour.c32();
 			return -1;
 		case FIELD_CAL_ALL_DAY:
 			return AllDay;
 		case FIELD_STATUS:
 			return StoreStatus;
 	}
 
 	LAssert(0);
 	return -1;
 }
 
 Store3Status LMail3Calendar::SetInt(int id, int64 val)
 {
 	int n = (int)val;
 	switch (id)
 	{
 		case FIELD_CAL_TYPE:
 			CalType = n;
 			break;
 		case FIELD_CAL_COMPLETED:
 			Completed = n;
 			break;
 		case FIELD_CAL_SHOW_TIME_AS:
 			ShowTimeAs = n;
 			break;
 		case FIELD_CAL_RECUR:
 			Recur = n;
 			break;
 		case FIELD_CAL_RECUR_FREQ:
 			RecurFreq = n;
 			break;
 		case FIELD_CAL_RECUR_INTERVAL:
 			RecurInterval = n;
 			break;
 		case FIELD_CAL_RECUR_END_COUNT:
 			RecurCount = n;
 			break;
 		case FIELD_CAL_RECUR_END_TYPE:
 			RecurEndType = n;
 			break;
 		case FIELD_CAL_RECUR_FILTER_DAYS:
 			FilterDays = n;
 			break;
 		case FIELD_CAL_RECUR_FILTER_MONTHS:
 			FilterMonths = n;
 			break;
 		case FIELD_CAL_PRIVACY:
 			CalPriv = (CalendarPrivacyType)n;
 			break;
 		case FIELD_COLOUR:
 			if (n > 0)
 				Colour.Set(n, 32);
 			else
 				Colour.Empty();
 			break;
 		case FIELD_CAL_ALL_DAY:
 			AllDay = val != 0;
 			break;
 		case FIELD_STATUS:
 			StoreStatus = val;
 			break;
 		default:
 			LAssert(0);
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
 
 const LDateTime *LMail3Calendar::GetDate(int id)
 {
 	switch (id)
 	{
 		case FIELD_CAL_START_UTC:
 			return &Start;
 		case FIELD_CAL_END_UTC:
 			return &End;
 		case FIELD_CAL_RECUR_END_DATE:
 			return &RecurEnd;
 		case FIELD_CAL_LAST_CHECK:
 			return &LastCheck;
+		case FIELD_DATE_MODIFIED:
+			return &Modified;
 	}
 
-	LAssert(0);
-	return 0;
+	return NULL;
 }
 
 Store3Status LMail3Calendar::SetDate(int id, const LDateTime *t)
 {
+	if (t)
+		LAssert(t->GetTimeZone()==0);
+
 	switch (id)
 	{
 		case FIELD_CAL_START_UTC:
 			if (t)
-			{
-				LAssert(t->GetTimeZone()==0);
 				Start = *t;
-			}
 			else
 				Start.Year(0);
 			break;
 		case FIELD_CAL_END_UTC:
 			if (t)
-			{
-				LAssert(t->GetTimeZone()==0);
 				End = *t;
-			}
 			else
 				End.Year(0);
 			break;
 		case FIELD_CAL_RECUR_END_DATE:
 			if (t)
-			{
-				LAssert(t->GetTimeZone()==0);
 				RecurEnd = *t;
-			}
 			else
 				RecurEnd.Year(0);
 			break;
 		case FIELD_CAL_LAST_CHECK:
 			if (t)
-			{
-				LAssert(t->GetTimeZone()==0);
 				LastCheck = *t;
-			}
 			else
 				LastCheck.Empty();
 			break;
+		case FIELD_DATE_MODIFIED:
+			if (t)
+				Modified = *t;
+			else
+				Modified.Empty();
+			break;
 		default:
-			return Store3Error;
+			return Store3NotImpl;
 	}
 
 	return Store3Success;
 }
 
diff --git a/Code/Store3Mail3/Mail3Filter.cpp b/Code/Store3Mail3/Mail3Filter.cpp
--- a/Code/Store3Mail3/Mail3Filter.cpp
+++ b/Code/Store3Mail3/Mail3Filter.cpp
@@ -1,193 +1,215 @@
 #include "Mail3.h"
 
 enum Dir
 {
 	FilterIn = 0x1,
 	FilterOut = 0x2,
 	FilterInternal = 0x4,
 };
 
 GMail3Def TblFilter[] =
 {
 	{"Id",				"INTEGER PRIMARY KEY AUTOINCREMENT"},
 	{"ParentId",		"INTEGER"},
 	{"FilterSort",		"INTEGER"},
 	{"StopFiltering",	"INTEGER"},
 	{"Name",			"TEXT"},
 	{"Conditions",		"TEXT"},
 	{"Actions",			"TEXT"},
 	{"Script",			"TEXT"},
 	{"Direction",		"INTEGER"},
+	{"DateModifed",		"TEXT"},
 
 	{0, 0}
 };
 
 LMail3Filter::LMail3Filter(LMail3Store *store) : LMail3Thing(store)
 {
 	Index = 0;
 	StopFiltering = 0;
 	Direction = FilterIn | FilterInternal;
 }
 
 LMail3Filter::~LMail3Filter()
 {
 }
 
 bool LMail3Filter::DbDelete()
 {
 	char s[256];
 
 	// Delete the filter
 	sprintf_s(s, sizeof(s), "delete from " MAIL3_TBL_FILTER " where Id=" LPrintfInt64, Id);
 	LMail3Store::LStatement Del(Store, s);
 	if (!Del.Exec())
 		return false;
 
 	return true;
 }
 
 bool LMail3Filter::Serialize(LMail3Store::LStatement &s, bool Write)
 {
 	int i = 0;
 
-	#undef SERIALIZE_AUTOSTR
-	#define SERIALIZE_AUTOSTR(var, idx) \
-		{ \
-			if (Write) { if (!s.SetStr(idx, var)) return false; } \
-			else { var.Reset(NewStr(s.GetStr(idx))); } \
-			idx++; \
-		}
-
 	SERIALIZE_INT64(Id, i++);
 	SERIALIZE_INT64(ParentId, i++);
 	SERIALIZE_INT(Index, i++);
 	SERIALIZE_INT(StopFiltering, i++);
-	SERIALIZE_AUTOSTR(Name, i);
-	SERIALIZE_AUTOSTR(ConditionsXml, i);
-	SERIALIZE_AUTOSTR(ActionsXml, i);
-	SERIALIZE_AUTOSTR(Script, i);
+	SERIALIZE_LSTR(Name, i++);
+	SERIALIZE_LSTR(ConditionsXml, i++);
+	SERIALIZE_LSTR(ActionsXml, i++);
+	SERIALIZE_LSTR(Script, i++);
 	SERIALIZE_INT(Direction, i++);
+	SERIALIZE_DATE(Modified, i++);
 
 	return true;
 }
 
 Store3CopyImpl(LMail3Filter)
 {
 	Index = (int) p.GetInt(FIELD_FILTER_INDEX);
 	StopFiltering = (int) p.GetInt(FIELD_STOP_FILTERING);
-	Direction = (int) ((p.GetInt(FIELD_FILTER_INCOMING) ? FilterIn : 0) |
-				(p.GetInt(FIELD_FILTER_OUTGOING) ? FilterOut : 0) |
-				(p.GetInt(FIELD_FILTER_INTERNAL) ? FilterInternal : 0));
+	Direction = (int) (	(p.GetInt(FIELD_FILTER_INCOMING) ? FilterIn : 0) |
+						(p.GetInt(FIELD_FILTER_OUTGOING) ? FilterOut : 0) |
+						(p.GetInt(FIELD_FILTER_INTERNAL) ? FilterInternal : 0));
 	SetStr(FIELD_FILTER_NAME, p.GetStr(FIELD_FILTER_NAME));
 	SetStr(FIELD_FILTER_CONDITIONS_XML, p.GetStr(FIELD_FILTER_CONDITIONS_XML));
 	SetStr(FIELD_FILTER_ACTIONS_XML, p.GetStr(FIELD_FILTER_ACTIONS_XML));
 	SetStr(FIELD_FILTER_SCRIPT, p.GetStr(FIELD_FILTER_SCRIPT));
+	SetDate(FIELD_DATE_MODIFIED, p.GetDate(FIELD_DATE_MODIFIED));
 
 	return true;
 }
 
 const char *LMail3Filter::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_FILTER_NAME:
 			return Name;
 		case FIELD_FILTER_CONDITIONS_XML:
 			return ConditionsXml;
 		case FIELD_FILTER_ACTIONS_XML:
 			return ActionsXml;
 		case FIELD_FILTER_SCRIPT:
 			return Script;
 	}
 
 	LAssert(0);
 	return 0;
 }
 
 Store3Status LMail3Filter::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_FILTER_NAME:
-			Name.Reset(NewStr(str));
+			Name = str;
 			return Store3Success;
 		case FIELD_FILTER_CONDITIONS_XML:
-			ConditionsXml.Reset(NewStr(str));
+			ConditionsXml = str;
 			return Store3Success;
 		case FIELD_FILTER_ACTIONS_XML:
-			ActionsXml.Reset(NewStr(str));
+			ActionsXml = str;
 			return Store3Success;
 		case FIELD_FILTER_SCRIPT:
-			Script.Reset(NewStr(str));
+			Script = str;
 			return Store3Success;
 	}
 
 	LAssert(0);
 	return Store3Error;
 }
 
 int64 LMail3Filter::GetInt(int id)
 {
 	switch (id)
 	{
 		case FIELD_STORE_TYPE:
 			return Store3Sqlite;
 		case FIELD_FLAGS:
 			return 0;
 		case FIELD_FILTER_INDEX:
 			return Index;
 		case FIELD_STOP_FILTERING:
 			return StopFiltering;
 		case FIELD_FILTER_INCOMING:
 			return (Direction & FilterIn) != 0;
 		case FIELD_FILTER_OUTGOING:
 			return (Direction & FilterOut) != 0;
 		case FIELD_FILTER_INTERNAL:
 			return (Direction & FilterInternal) != 0;
 		case FIELD_LOADED:
 			return Store3Loaded;
 	}
 
 	LAssert(0);
 	return -1;
 }
 
 Store3Status LMail3Filter::SetInt(int id, int64 n)
 {
 	switch (id)
 	{
 		case FIELD_FLAGS:
 			return Store3Error;
 		case FIELD_FILTER_INDEX:
 			Index = (int) n;
 			return Store3Success;
 		case FIELD_STOP_FILTERING:
 			StopFiltering = (int) n;
 			return Store3Success;
 		case FIELD_FILTER_INCOMING:
 			if (n)
 				Direction |= FilterIn;
 			else
 				Direction &= ~FilterIn;
 			Direction &= FilterIn | FilterOut | FilterInternal;
 			return Store3Success;
 		case FIELD_FILTER_OUTGOING:
 			if (n)
 				Direction |= FilterOut;
 			else
 				Direction &= ~FilterOut;
 			Direction &= FilterIn | FilterOut | FilterInternal;
 			return Store3Success;
 		case FIELD_FILTER_INTERNAL:
 			if (n)
 				Direction |= FilterInternal;
 			else
 				Direction &= ~FilterInternal;
 			Direction &= FilterIn | FilterOut | FilterInternal;
 			return Store3Success;
 	}
 
 	LAssert(0);
 	return Store3Error;
 }
 
+const LDateTime *LMail3Filter::GetDate(int id)
+{
+	switch (id)
+	{
+		case FIELD_DATE_MODIFIED:
+			return &Modified;
+	}
+
+	return NULL;
+}
+
+Store3Status LMail3Filter::SetDate(int id, const LDateTime *i)
+{
+	switch (id)
+	{
+		case FIELD_DATE_MODIFIED:
+		{
+			if (!i)
+				return Store3Error;
+			Modified = *i;
+			return Store3Success;
+		}
+	}
+
+	return Store3NotImpl;
+}
+
diff --git a/Code/Store3Mail3/Mail3Group.cpp b/Code/Store3Mail3/Mail3Group.cpp
--- a/Code/Store3Mail3/Mail3Group.cpp
+++ b/Code/Store3Mail3/Mail3Group.cpp
@@ -1,113 +1,113 @@
 #include "lgi/common/Lgi.h"
 #include "Mail3.h"
 
 GMail3Def TblGroup[] =
 {
 	{"Id",				"INTEGER PRIMARY KEY AUTOINCREMENT"},
 	{"ParentId",		"INTEGER"},
 	{"Name",			"TEXT"},
 	{"Addresses",		"TEXT"},
 	{"DateModified",	"TEXT"}, // UTC
 	{0, 0}
 };
 
 LMail3Group::LMail3Group(LMail3Store *store) : LMail3Thing(store)
 {	
 }
 
 LMail3Group::~LMail3Group()
 {
 }
 
 bool LMail3Group::DbDelete()
 {
 	char s[256];
 
 	// Delete the contact
 	sprintf_s(s, sizeof(s), "delete from " MAIL3_TBL_GROUP " where Id=" LPrintfInt64, Id);
 	LMail3Store::LStatement Del(Store, s);
 	if (!Del.Exec())
 		return false;
 
 	return true;
 }
 
 Store3CopyImpl(LMail3Group)
 {
 	Name = p.GetStr(FIELD_GROUP_NAME);
 	Group = p.GetStr(FIELD_GROUP_LIST);
 	DateMod = p.GetDate(FIELD_DATE_MODIFIED);
 	return true;
 }
 
 bool LMail3Group::Serialize(LMail3Store::LStatement &s, bool Write)
 {
 	int i = 0;
 
 	if (Write)
 	{
 		DateMod.SetNow();
 		DateMod.ToUtc();
 	}
 
 	SERIALIZE_INT64(Id, i++);
 	SERIALIZE_INT64(ParentId, i++);
-	SERIALIZE_GSTR(Name, i++);
-	SERIALIZE_GSTR(Group, i++);
+	SERIALIZE_LSTR(Name, i++);
+	SERIALIZE_LSTR(Group, i++);
 	SERIALIZE_DATE(DateMod, i++);
 
 	return true;
 }
 
 const char *LMail3Group::GetStr(int id)
 {
 	switch (id)
 	{
 		case FIELD_GROUP_NAME:
 			return Name;
 		case FIELD_GROUP_LIST:
 			return Group;
 	}
 	
 	return 0;
 }
 
 Store3Status LMail3Group::SetStr(int id, const char *str)
 {
 	switch (id)
 	{
 		case FIELD_GROUP_NAME:
 			return Name.Set(str) ? Store3Success : Store3Error;
 		case FIELD_GROUP_LIST:
 			return Group.Set(str) ? Store3Success : Store3Error;
 	}
 	
 	return Store3Error;
 }
 
 const LDateTime *LMail3Group::GetDate(int id)
 {
 	switch (id)
 	{
 		case FIELD_DATE_MODIFIED:
 			return &DateMod;
 	}
 
 	return NULL;
 }
 
 Store3Status LMail3Group::SetDate(int id, const LDateTime *i)
 {
 	switch (id)
 	{
 		case FIELD_DATE_MODIFIED:
 			if (!i)
 				return Store3Error;
 			DateMod = i;
 			break;
 		default:
 			return Store3Error;
 	}
 
 	return Store3Success;
 }
\ No newline at end of file