diff --git a/src/common/Text/TextView3.cpp b/src/common/Text/TextView3.cpp
--- a/src/common/Text/TextView3.cpp
+++ b/src/common/Text/TextView3.cpp
@@ -1,5443 +1,5442 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <algorithm>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ScrollBar.h"
 #ifdef WIN32
 #include <imm.h>
 #endif
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Mail.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/DropFiles.h"
 #include "ViewPriv.h"
 
 #undef max
 #ifdef _DEBUG
 #define FEATURE_HILIGHT_ALL_MATCHES	1
 #else
 #define FEATURE_HILIGHT_ALL_MATCHES	0
 #endif
 
 #define DefaultCharset              "utf-8"
 #define SubtractPtr(a, b)			((a) - (b))
 
 #define GDCF_UTF8					-1
 #define POUR_DEBUG					0
 #define PROFILE_POUR				0
 #define PROFILE_PAINT				0
 #define DRAW_LINE_BOXES				0
 #define WRAP_POUR_TIMEOUT			90 // ms
 #define PULSE_TIMEOUT				500 // ms
 #define CURSOR_BLINK				1000 // ms
 
 #define ALLOC_BLOCK					64
 #define IDC_VS						1000
 
 #ifdef WINDOWS
 #define	DOUBLE_BUFFER_PAINT			1
 #endif
 
 enum Cmds
 {
 	IDM_COPY_URL = 100,
 	IDM_AUTO_INDENT,
 	IDM_UTF8,
 	IDM_PASTE_NO_CONVERT,
 	IDM_FIXED,
 	IDM_SHOW_WHITE,
 	IDM_HARD_TABS,
 	IDM_INDENT_SIZE,
 	IDM_TAB_SIZE,
 	IDM_DUMP,
 	IDM_RTL,
 	IDM_COPY_ALL,
 	IDM_SELECT_ALL,
 	#ifndef IDM_OPEN
 		IDM_OPEN,
 	#endif
 	#ifndef IDM_NEW
 		IDM_NEW,
 	#endif
 	#ifndef IDM_COPY
 		IDM_COPY,
 	#endif
 	#ifndef IDM_CUT
 		IDM_CUT,
 	#endif
 	#ifndef IDM_PASTE
 		IDM_PASTE,
 	#endif
 	#ifndef IDM_UNDO
 		IDM_UNDO,
 	#endif
 	#ifndef IDM_REDO
 		IDM_REDO,
 	#endif
 };
 
 #define PAINT_BORDER				Back
 #if DRAW_LINE_BOXES
 	#define PAINT_AFTER_LINE			LColour(240, 240, 240)
 #else
 	#define PAINT_AFTER_LINE			Back
 #endif
 
 #define CODEPAGE_BASE				100
 #define CONVERT_CODEPAGE_BASE		200
 
 #if !defined(WIN32) && !defined(toupper)
 #define toupper(c)					(((c)>='a'&&(c)<='z') ? (c)-'a'+'A' : (c))
 #endif
 
 #define THREAD_CHECK() \
 	if (!InThread()) \
 	{ \
 		LgiTrace("%s:%i - %s called out of thread.\n", _FL, __FUNCTION__); \
 		return false; \
 	}
 
 static char SelectWordDelim[] = " \t\n.,()[]<>=?/\\{}\"\';:+=-|!@#$%^&*";
 #ifndef WINDOWS
 static LArray<LTextView3*> Ctrls;
 #endif
 
 //////////////////////////////////////////////////////////////////////
 class LDocFindReplaceParams3 :
 	public LDocFindReplaceParams,
 	public LMutex
 {
 public:
 	// Find/Replace History
 	LAutoWString LastFind;
 	LAutoWString LastReplace;
 	bool MatchCase;
 	bool MatchWord;
 	bool SelectionOnly;
 	bool SearchUpwards;
 	
 	LDocFindReplaceParams3() : LMutex("LDocFindReplaceParams3")
 	{
 		MatchCase = false;
 		MatchWord = false;
 		SelectionOnly = false;
 		SearchUpwards = false;
 	}
 };
 
 class LTextView3Private : public LCss, public LMutex
 {
 public:
 	LTextView3 *View;
 	LRect rPadding;
 	int PourX;
 	bool LayoutDirty;
 	ssize_t DirtyStart, DirtyLen;
 	LColour UrlColour;
 	bool CenterCursor;
 	ssize_t WordSelectMode;
 	LString Eol;
 	LString LastError;
 	
 	// If the scroll position is set before we get a scroll bar, store the index
 	// here and set it when the LNotifyScrollBarCreate arrives.
 	ssize_t VScrollCache;
 
 	// Find/Replace Params
 	bool OwnFindReplaceParams;
 	LDocFindReplaceParams3 *FindReplaceParams;
 
 	// Map buffer
 	ssize_t MapLen;
 	char16 *MapBuf;
 
 	// <RequiresLocking>
 		// Thread safe Name(char*) impl
 		LString SetName;
 	// </RequiresLocking>
 
 	#ifdef _DEBUG
 	LString PourLog;
 	#endif
 
 	LTextView3Private(LTextView3 *view) : LMutex("LTextView3Private")
 	{
 		View = view;
 		WordSelectMode = -1;
 		PourX = -1;
 		VScrollCache = -1;
 		DirtyStart = DirtyLen = 0;
 		UrlColour.Rgb(0, 0, 255);		
 		LColour::GetConfigColour("colour.L_URL", UrlColour);
 
 		CenterCursor = false;
 		
 		LayoutDirty = true;
 		rPadding.ZOff(0, 0);
 		MapBuf = 0;
 		MapLen = 0;
 		
 		OwnFindReplaceParams = true;
 		FindReplaceParams = new LDocFindReplaceParams3;
 	}
 	
 	~LTextView3Private()
 	{
 		if (OwnFindReplaceParams)
 		{
 			DeleteObj(FindReplaceParams);
 		}
 		
 		DeleteArray(MapBuf);
 	}
 	
 	void SetDirty(ssize_t Start, ssize_t Len = 0)
 	{
 		LayoutDirty = true;
 		DirtyStart = Start;
 		DirtyLen = Len;
 	}
 
 	void OnChange(PropType Prop)
 	{
 		if (Prop == LCss::PropPadding ||
 			Prop == LCss::PropPaddingLeft ||
 			Prop == LCss::PropPaddingRight ||
 			Prop == LCss::PropPaddingTop ||
 			Prop == LCss::PropPaddingBottom)
 		{
 			LCssTools t(this, View->GetFont());
 			rPadding.ZOff(0, 0);
 			rPadding = t.ApplyPadding(rPadding);
 		}
 	}
 };
 
 //////////////////////////////////////////////////////////////////////
 enum UndoType
 {
 	UndoDelete, UndoInsert, UndoChange
 };
 
 struct Change : public LRange
 {
 	UndoType Type;
 	LArray<char16> Txt;
 };
 
 struct LTextView3Undo : public LUndoEvent
 {
 	LTextView3 *View;
 	LArray<Change> Changes;
 
 	LTextView3Undo(LTextView3 *view)
 	{
 		View = view;
 	}
 
 	void AddChange(ssize_t At, ssize_t Len, UndoType Type)
 	{
 		Change &c = Changes.New();
 		c.Start = At;
 		c.Len = Len;
 		c.Txt.Add(View->Text + At, Len);
 		c.Type = Type;
 	}
 
 	void OnChange()
 	{
 		for (auto &c : Changes)
 		{
 			size_t Len = c.Len;
 			if (View->Text)
 			{
 				char16 *t = View->Text + c.Start;
 				for (size_t i=0; i<Len; i++)
 				{
 					char16 n = c.Txt[i];
 					c.Txt[i] = t[i];
 					t[i] = n;
 				}
 			}
 
 			View->d->SetDirty(c.Start, c.Len);
 		}
 	}
 
 	// LUndoEvent
     void ApplyChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					View->Cursor = c.Start + c.Len;
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Delete(c.Start, c.Len);
 					View->Cursor = c.Start;
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();
 					break;
 				}
 			}
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 
     void RemoveChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Delete(c.Start, c.Len);
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();				
 					break;
 				}
 			}
 
 			View->Cursor = c.Start;
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 };
 
 void LTextView3::LStyle::RefreshLayout(size_t Start, ssize_t Len)
 {
 	View->PourText(Start, Len);
 	View->PourStyle(Start, Len);
 }
 
 //////////////////////////////////////////////////////////////////////
 LTextView3::LTextView3(	int Id,
 						int x, int y, int cx, int cy,
 						LFontType *FontType)
 	: ResObject(Res_Custom)
 {
 	// init vars
 	LView::d->Css.Reset(d = new LTextView3Private(this));
 	
 	TabSize = TAB_SIZE;
 	IndentSize = TAB_SIZE;
 	
 	// setup window
 	SetId(Id);
 
 	// default options
 	#if WINNATIVE
 	CrLf = true;
 	SetDlgCode(DLGC_WANTALLKEYS);
 	#else
 	#endif
 	d->Padding(LCss::Len(LCss::LenPx, 2));
 
 	#ifdef _DEBUG
 	// debug times
 	_PourTime = 0;
 	_StyleTime = 0;
 	_PaintTime = 0;
 	#endif
 
 	// Data
 	Alloc = ALLOC_BLOCK;
 	Text = new char16[Alloc];
 	if (Text) *Text = 0;
 	Cursor = 0;
 	Size = 0;
 
 	// Display
 	if (FontType)
 		Font = FontType->Create();
 	else
 	{
 		LFontType Type;
 		if (Type.GetSystemFont("Fixed"))
 			Font = Type.Create();
 		else
 			printf("%s:%i - failed to create font.\n", _FL);
 	}
 
 	if (Font)
 	{
 		SetTabStop(true);
 
 		Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 			Underline->Create();
 		}
 		Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 
 		OnFontChange();
 	}
 	else
 	{
 		LgiTrace("%s:%i - Failed to create font, FontType=%p\n", _FL, FontType);
 		Font = LSysFont;
 	}
 
 	CursorPos.ZOff(1, LineY-1);
 	CursorPos.Offset(d->rPadding.x1, d->rPadding.y1);
 
 	LRect r;
 	r.ZOff(cx-1, cy-1);
 	r.Offset(x, y);
 	SetPos(r);
 	LResources::StyleElement(this);
 }
 
 LTextView3::~LTextView3()
 {
 	#ifndef WINDOWS
 	Ctrls.Delete(this);
 	#endif
 	Line.DeleteObjects();
 	Style.Empty();
 
 	DeleteArray(TextCache);
 	DeleteArray(Text);
 
 	if (Font != LSysFont) DeleteObj(Font);
 	DeleteObj(FixedFont);
 	DeleteObj(Underline);
 	DeleteObj(Bold);
 	// 'd' is owned by the LView::Css auto ptr
 }
 
 char16 *LTextView3::MapText(char16 *Str, ssize_t Len, bool RtlTrailingSpace)
 {
 	if (ObscurePassword /*|| ShowWhiteSpace*/ || RtlTrailingSpace)
 	{
 		if (Len > d->MapLen)
 		{
 			DeleteArray(d->MapBuf);
 			d->MapBuf = new char16[Len + RtlTrailingSpace];
 			d->MapLen = Len;
 		}
 
 		if (d->MapBuf)
 		{
 			int n = 0;
 
 			if (RtlTrailingSpace)
 			{
 				d->MapBuf[n++] = ' ';
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = Str[i];
 				}
 			}
 			else if (ObscurePassword)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = '*';
 				}
 			}
 			/*
 			else if (ShowWhiteSpace)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					if (Str[i] == ' ')
 					{
 						d->MapBuf[n++] = 0xb7;
 					}
 					else if (Str[i] == '\t')
 					{
 						d->MapBuf[n++] = 0x2192;
 					}
 					else
 					{
 						d->MapBuf[n++] = Str[i];
 					}
 				}
 			}
 			*/			
 
 			return d->MapBuf;
 		}
 	}
 
 	return Str;
 }
 
 void LTextView3::SetFixedWidthFont(bool i)
 {
 	if (FixedWidthFont ^ i)
 	{
 		if (i)
 		{
 			LFontType Type;
 			if (Type.GetSystemFont("Fixed"))
 			{
 				LFont *f = FixedFont;
 				FixedFont = Font;
 				Font = f;
 
 				if (!Font)
 				{
 					Font = Type.Create();
 					if (Font)
 					{
 						Font->PointSize(FixedFont->PointSize());
 					}
 				}
 
 				LDocView::SetFixedWidthFont(i);
 			}
 		}
 		else if (FixedFont)
 		{
 			LFont *f = FixedFont;
 			FixedFont = Font;
 			Font = f;
 			LDocView::SetFixedWidthFont(i);
 		}
 
 		OnFontChange();
 		Invalidate();
 	}
 }
 
 void LTextView3::SetReadOnly(bool i)
 {
 	LDocView::SetReadOnly(i);
 
 	#if WINNATIVE
 	SetDlgCode(i ? DLGC_WANTARROWS : DLGC_WANTALLKEYS);
 	#endif
 }
 
 void LTextView3::SetCrLf(bool crlf)
 {
 	CrLf = crlf;
 }
 
 
 void LTextView3::SetTabSize(uint8_t i)
 {
 	TabSize = limit(i, 2, 32);
 	OnFontChange();
 	OnPosChange();
 	Invalidate();
 }
 
 void LTextView3::SetWrapType(LDocWrapType i)
 {
 	LDocView::SetWrapType(i);
 	CanScrollX = i != TEXTED_WRAP_REFLOW;
 
 	OnPosChange();
 	Invalidate();
 }
 
 LFont *LTextView3::GetFont()
 {
 	return Font;
 }
 
 LFont *LTextView3::GetBold()
 {
 	return Bold;
 }
 
 void LTextView3::SetFont(LFont *f, bool OwnIt)
 {
 	if (!f)
 		return;
 	
 	if (OwnIt)
 	{
 		if (Font != LSysFont)
 			DeleteObj(Font);
 		Font = f;
 	}
 	else if (!Font || Font == LSysFont)
 	{
 		Font = new LFont(*f);
 	}
 	else
 	{
 		*Font = *f;
 	}
 
 	if (Font)
 	{
 		if (!Underline)
 			Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 		}
 
 		if (!Bold)
 			Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 	}
 
 	OnFontChange();
 }
 
 void LTextView3::OnFontChange()
 {
 	if (Font)
 	{
 		// get line height
 		// int OldLineY = LineY;
 		if (!Font->Handle())
 			Font->Create();
 		LineY = Font->GetHeight();
 		if (LineY < 1) LineY = 1;
 
 		// get tab size
 		char Spaces[32];
 		memset(Spaces, 'A', TabSize);
 		Spaces[TabSize] = 0;
 		LDisplayString ds(Font, Spaces);
 		Font->TabSize(ds.X());
 
 		// repour doc
 		d->SetDirty(0, Size);
 
 		// validate blue underline font
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 		}
 
 		#if WINNATIVE // Set the IME font.
 		HIMC hIMC = ImmGetContext(Handle());
 		if (hIMC)
 		{
 			COMPOSITIONFORM Cf;						
 			Cf.dwStyle = CFS_POINT;
 			Cf.ptCurrentPos.x = CursorPos.x1;
 			Cf.ptCurrentPos.y = CursorPos.y1;
 
 			LOGFONT FontInfo;
 			GetObject(Font->Handle(), sizeof(FontInfo), &FontInfo);
 			ImmSetCompositionFont(hIMC, &FontInfo);
 
 			ImmReleaseContext(Handle(), hIMC);
 		}
 		#endif
 
 	}
 }
 
 void LTextView3::LogLines()
 {
 	int Idx = 0;
 	LgiTrace("DocSize: %i\n", (int)Size);
 	for (auto i : Line)
 	{
 		LgiTrace("  [%i]=%p, %i+%i, %s\n", Idx, i, (int)i->Start, (int)i->Len, i->r.GetStr());
 		Idx++;
 	}
 
 	#ifdef _DEBUG
 	if (d->PourLog)
 		LgiTrace("%s", d->PourLog.Get());
 	#endif
 }
 
 bool LTextView3::ValidateLines(bool CheckBox)
 {
 	size_t Pos = 0;
 	char16 *c = Text;
 	size_t Idx = 0;
 	LTextLine *Prev = NULL;
 
 	for (auto i : Line)
 	{
 		LTextLine *l = i;
 		if (l->Start != Pos)
 		{
 			LogLines();
 			LAssert(!"Incorrect start.");
 			return false;
 		}
 
 		char16 *e = c;
 		if (WrapType == TEXTED_WRAP_NONE)
 		{
 			while (*e && *e != '\n')
 				e++;
 		}
 		else
 		{
 			char16 *end = Text + l->Start + l->Len;
 			while (*e && *e != '\n' && e < end)
 				e++;
 		}
 			
 		ssize_t Len = e - c;
 		if (l->Len != Len)
 		{
 			LogLines();
 			LAssert(!"Incorrect length.");
 			return false;
 		}
 
 
 		if (CheckBox &&
 			Prev &&
 			Prev->r.y2 != l->r.y1 - 1)
 		{
 			LogLines();
 			LAssert(!"Lines not joined vertically");
 		}
 
 		if (*e)
 		{
 			if (*e == '\n')
 				e++;
 			else if (WrapType == TEXTED_WRAP_REFLOW)
 				e++;
 		}
 		Pos = e - Text;
 		c = e;
 		Idx++;
 		Prev = l;
 	}
 
 	if (WrapType == TEXTED_WRAP_NONE &&
 		Pos != Size)
 	{
 		LogLines();
 		LAssert(!"Last line != end of doc");
 		return false;
 	}
 
 	return true;
 }
 
 int LTextView3::AdjustStyles(ssize_t Start, ssize_t Diff, bool ExtendStyle)
 {
 	int Changes = 0;
 	for (auto &s : Style)
 	{
 		if (s.Start == Start)
 		{
 			if (Diff < 0 || ExtendStyle)
 				s.Len += Diff;
 			else
 				s.Start += Diff;
 			Changes++;
 		}
 		else if (s.Start > Start)
 		{
 			s.Start += Diff;
 			Changes++;
 		}
 	}
 
 	return Changes;
 }
 
 // break array, break out of loop when we hit these chars
 #define ExitLoop(c)	(	(c) == 0 ||								\
 						(c) == '\n' ||							\
 						(c) == ' ' ||							\
 						(c) == '\t'								\
 					)
 
 // extra breaking opportunities
 #define ExtraBreak(c) (	( (c) >= 0x3040 && (c) <= 0x30FF ) ||	\
 						( (c) >= 0x3300 && (c) <= 0x9FAF )		\
 					)
 
 /*
 Prerequisite:
 The Line list must have either the objects with the correct Start/Len or be missing the lines altogether...
 */
 void LTextView3::PourText(size_t Start, ssize_t Length /* == 0 means it's a delete */)
 {
 	#if PROFILE_POUR
 	char _txt[256];
 	sprintf_s(_txt, sizeof(_txt), "%p::PourText Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(_txt);
 	#endif
 
 	#if !defined(HAIKU)
 	LAssert(InThread());
 	#endif
 
 	LRect Client = GetClient();
 	int Mx = Client.X() - d->rPadding.x1 - d->rPadding.x2;
 	int Cy = 0;
 	MaxX = 0;
 
 	ssize_t Idx = -1;
 	LTextLine *Cur = GetTextLine(Start, &Idx);
 	// LgiTrace("Pour %i:%i Cur=%p Idx=%i\n", (int)Start, (int)Length, (int)Cur, (int)Idx);
 	if (!Cur || !Cur->r.Valid())
 	{
 		// Find the last line that has a valid position...
 		for (auto i = Idx >= 0 ? Line.begin(Idx) : Line.rbegin(); *i; i--, Idx--)
 		{
 			Cur = *i;
 			if (Cur->r.Valid())
 			{
 				Cy = Cur->r.y1;
 				if (Idx < 0)
 					Idx = Line.IndexOf(Cur);
 				break;
 			}
 		}
 	}
 	if (Cur && !Cur->r.Valid())
 		Cur = NULL;
 	if (Cur)
 	{
 		Cy = Cur->r.y1;
 		Start = Cur->Start;
 		Length = Size - Start;
 		// LgiTrace("Reset start to %i:%i because Cur!=NULL\n", (int)Start, (int)Length);
 	}
 	else
 	{
 		Idx = 0;
 		Start = 0;
 		Length = Size;
 	}
 			
 	if (!Text || !Font || Mx <= 0)
 		return;
 
 	// Tracking vars
 	ssize_t e;
 	//int LastX = 0;
 	int WrapCol = GetWrapAtCol();
 
 	LDisplayString Sp(Font, " ", 1);
 	int WidthOfSpace = Sp.X();
 	if (WidthOfSpace < 1)
 	{
 		printf("%s:%i - WidthOfSpace test failed.\n", _FL);
 		return;
 	}
 
 	// Alright... lets pour!
 	uint64 StartTs = LCurrentTime();
 	if (WrapType == TEXTED_WRAP_NONE)
 	{
 		// Find the dimensions of each line that is missing a rect
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: ExistingLines");
 		#endif
 		#ifdef _DEGBUG
 		LStringPipe Log(1024);
 		Log.Printf("Pour: " LPrintfSizeT ", " LPrintfSSizeT ", partial=%i\n", Start, Length, PartialPour);
 		#endif
 
 		ssize_t Pos = 0;
 		for (auto i = Line.begin(Idx); *i; i++, Idx++)
 		{
 			LTextLine *l = *i;
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] exist: r.val=%i\n", Idx, l->r.Valid());
 			#endif
 
 			if (!l->r.Valid()) // If the layout is not valid...
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + ds.X();
 
 				MaxX = MAX(MaxX, l->r.X());
 			}
 
 			// Adjust the y position anyway... it's free.
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			Cy = l->r.y2 + 1;
 			Pos = l->Start + l->Len;
 			if (Text[Pos] == '\n')
 				Pos++;
 		}
 
 		// Now if we are missing lines as well, create them and lay them out
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: NewLines");
 		#endif
 		while (Pos < Size)
 		{
 			LTextLine *l = new LTextLine;
 			l->Start = Pos;
 			char16 *c = Text + Pos;
 			char16 *e = c;
 			while (*e && *e != '\n')
 				e++;
 			l->Len = e - c;
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] new: start=" LPrintfSSizeT ", len=" LPrintfSSizeT "\n", Idx, l->Start, l->Len);
 			#endif
 
 			l->r.x1 = d->rPadding.x1;
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			if (l->Len)
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 				l->r.x2 = l->r.x1 + ds.X();
 			}
 			else
 			{
 				l->r.x2 = l->r.x1;
 			}
 
 			Line.Insert(l);
 
 			if (*e == '\n')
 				e++;
 
 			MaxX = MAX(MaxX, l->r.X());
 			Cy = l->r.y2 + 1;
 			Pos = e - Text;
 			Idx++;
 		}
 
 		#ifdef _DEGBUG
 		d->PourLog = Log.NewLStr();
 		#endif
 		PartialPour = false;
 		PartialPourLines = 0;
 	}
 	else // Wrap text
 	{
 		int DisplayStart = ScrollYLine();
 		int DisplayLines = 	(Client.Y() + LineY - 1) / LineY;
 		int DisplayEnd = DisplayStart + DisplayLines;
 		
 		// Pouring is split into 2 parts... 
 		// 1) pouring to the end of the displayed text.
 		// 2) pouring from there to the end of the document.
 		//	potentially taking several goes to complete the full pour
 		// This allows the document to display and edit faster..
 		bool PourToDisplayEnd = Line.Length() < DisplayEnd;
 
 		#if 0
 		LgiTrace("Idx=%i, DisplayStart=%i, DisplayLines=%i, DisplayEnd=%i, PourToDisplayEnd=%i\n",
 			Idx, DisplayStart, DisplayLines, DisplayEnd, PourToDisplayEnd);
 		#endif
 
 		if ((ssize_t)Line.Length() > Idx)
 		{
 			for (auto i = Line.begin(Idx); *i; i++)
 				delete *i;
 			Line.Length(Idx);
 			Cur = NULL;
 		}
 
 		int Cx = 0;
 		ssize_t i;
 		for (i=Start; i<Size; i = e)
 		{
 			// seek till next char of interest
 			e = i;
 			int	Width = 0;
 
 			// Find break point
 			if (WrapCol)
 			{
 				// Wrap at column
 					
 				// Find the end of line
 				while (true)
 				{
 					if (e >= Size ||
 						Text[e] == '\n' ||
 						(e-i) >= WrapCol)
 					{
 						break;
 					}
 
 					e++;
 				}
 
 				// Seek back some characters if we are mid word
 				size_t OldE = e;
 				if (e < Size &&
 					Text[e] != '\n')
 				{
 					while (e > i)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 						{
 							break;
 						}
 
 						e--;
 					}
 				}
 
 				if (e == i)
 				{
 					// No line break at all, so seek forward instead
 					for (e=OldE; e < Size && Text[e] != '\n'; e++)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 							break;
 					}
 				}
 
 				// Calc the width
 				LDisplayString ds(Font, Text + i, e - i);
 				Width = ds.X();
 			}
 			else
 			{
 				// Wrap to edge of screen
 				ssize_t PrevExitChar = -1;
 				int PrevX = -1;
 
 				while (true)
 				{
 					if (e >= Size ||
 						ExitLoop(Text[e]) ||
 						ExtraBreak(Text[e]))
 					{
 						LDisplayString ds(Font, Text + i, e - i);
 						if (ds.X() + Cx > Mx)
 						{
 							if (PrevExitChar > 0)
 							{
 								e = PrevExitChar;
 								Width = PrevX;
 							}
 							else
 							{
 								Width = ds.X();
 							}
 							break;
 						}
 						else if (e >= Size ||
 								Text[e] == '\n')							
 						{
 							Width = ds.X();
 							break;
 						}
 							
 						PrevExitChar = e;
 						PrevX = ds.X();
 					}
 						
 					e++;
 				}
 			}
 
 			// Create layout line
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = i;
 				l->Len = e - i;
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + Width - 1;
 
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				Line.Insert(l);
 				if (PourToDisplayEnd)
 				{
 					if (Line.Length() > DisplayEnd)
 					{
 						// We have reached the end of the displayed area... so
 						// exit out temporarily to display the layout to the user
 						PartialPour = true;
 						PartialPourLines = std::max(PartialPourLines, Line.Length());
 						break;
 					}
 				}
 				else
 				{
 					// Otherwise check if we are taking too long...
 					if (Line.Length() % 20 == 0)
 					{
 						uint64 Now = LCurrentTime();
 						if (Now - StartTs > WRAP_POUR_TIMEOUT)
 						{
 							PartialPour = true;
 							PartialPourLines = std::max(PartialPourLines, Line.Length());
 							break;
 						}
 					}
 				}
 					
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 					
 				if (e < Size)
 					e++;
 			}
 		}
 
 		if (i >= Size)
 		{
 			PartialPour = false;
 			PartialPourLines = 0;
 		}
 		SendNotify(LNotifyCursorChanged);
 	}
 
 	#ifdef _DEBUG
 	// ValidateLines(true);
 	#endif
 	#if PROFILE_POUR
 	Prof.Add("LastLine");
 	#endif
 
 	if (!PartialPour)
 	{
 		auto It = Line.rbegin();
 		LTextLine *Last = It != Line.end() ? *It : NULL;
 		if (!Last ||
 			Last->Start + Last->Len < Size)
 		{
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = Size;
 				l->Len = 0;
 				l->r.x1 = l->r.x2 = d->rPadding.x1;
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				Line.Insert(l);
 			
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 			}
 		}
 	}
 
 	bool ScrollYNeeded = Client.Y() < (std::max(PartialPourLines, Line.Length()) * LineY);
 	bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 	d->LayoutDirty = WrapType != TEXTED_WRAP_NONE && ScrollChange;
 	#if PROFILE_POUR
 	static LString _s;
 	_s.Printf("ScrollBars dirty=%i", d->LayoutDirty);
 	Prof.Add(_s);
 	#endif
 
 	if (ScrollChange)
 	{
 		#if 0
 		LgiTrace("%s:%i - %p::SetScrollBars(%i) cliy=%i content=%i partial=%i\n",
 			_FL, this, ScrollYNeeded, Client.Y(), (Line.Length() * LineY), PartialPour);
 		#endif
 		SetScrollBars(false, ScrollYNeeded);
 	}
 	UpdateScrollBars();
 	
 	#if 0 // def _DEBUG
 	if (GetWindow())
 	{
 		static char s[256];
 		sprintf_s(s, sizeof(s), "Pour: %.2f sec", (double)_PourTime / 1000);
 		GetWindow()->PostEvent(M_TEXTVIEW_DEBUG_TEXT, (LMessage::Param)s);
 	}
 	#endif
 
 	#if POUR_DEBUG
 	printf("Lines=%i\n", Line.Length());
 	int Index = 0;
 	for (LTextLine *l=Line.First(); l; l=Line.Next(), Index++)
 	{
 		printf("\t[%i] %i,%i (%s)\n", Index, l->Start, l->Len, l->r.Describe());
 	}
 	#endif
 }
 
 bool LTextView3::InsertStyle(LAutoPtr<LStyle> s)
 {
 	if (!s)
 		return false;
 
 	LAssert(s->Start >= 0);
 	LAssert(s->Len > 0);
 	ssize_t Last = 0;
 	// int n = 0;
 
 	// LgiTrace("StartStyle=%i,%i(%i) %s\n", (int)s->Start, (int)s->Len, (int)(s->Start+s->Len), s->Fore.GetStr());
 
 	if (Style.Length() > 0)
 	{
 		// Optimize for last in the list
 		auto Last = Style.rbegin();
 		if (s->Start >= (ssize_t)Last->End())
 		{
 			Style.Insert(*s);
 			return true;
 		}
 	}
 
 	for (auto i = Style.begin(); i != Style.end(); i++)
 	{
 		if (s->Overlap(*i))
 		{
 			if (s->Owner > i->Owner)
 			{
 				// Fail the insert
 				return false;
 			}
 			else
 			{
 				// Replace mode...
 				*i = *s;
 				return true;
 			}
 		}
 
 		if (s->Start >= Last && s->Start < i->Start)
 		{
 			Style.Insert(*s, i);
 			return true;
 		}
 	}
 
 	Style.Insert(*s);
 	return true;
 }
 
 LTextView3::LStyle *LTextView3::GetNextStyle(StyleIter &s, ssize_t Where)
 {
 	if (Where >= 0)
 		s = Style.begin();
 	else
 		s++;
 
 	while (s != Style.end())
 	{
 		// determine whether style is relevant..
 		// styles in the selected region are ignored
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 		if (SelStart >= 0 &&
 			s->Start >= Min &&
 			s->Start+s->Len < Max)
 		{
 			// style is completely inside selection: ignore
 			s++;
 		}
 		else if (Where >= 0 &&
 			s->Start+s->Len < Where)
 		{
 			s++;
 		}
 		else
 		{
 			return &(*s);
 		}
 	}
 
 	return NULL;
 }
 
 #if 0
 CURSOR_CHAR GetCursor()
 {
 	#ifdef WIN32
 	LArray<int> Ver;
 	int Os = LGetOs(&Ver);
 	if ((Os == LGI_OS_WIN32 || Os == LGI_OS_WIN64) &&
 		Ver[0] >= 5)
 	{
 		return MAKEINTRESOURCE(32649); // hand
 	}
 	else
 	{
 		return IDC_ARROW;
 	}
 	#endif
 	return 0;
 }
 #endif
 
 LTextView3::LStyle *LTextView3::HitStyle(ssize_t i)
 {
 	for (auto &s : Style)
 	{
 		if (i >= s.Start && i < (ssize_t)s.End())
 		{
 			return &s;
 		}
 	}
 
 	return NULL;
 }
 
 void LTextView3::PourStyle(size_t Start, ssize_t EditSize)
 {
 	#ifdef _DEBUG
 	int64 StartTime = LCurrentTime();
 	#endif
 
 	LAssert(InThread());
 
 	if (!Text || Size < 1)
 		return;
 
 	ssize_t Length = MAX(EditSize, 0);
 	if ((ssize_t)Start + Length >= Size)
 		Length = Size - Start; // For deletes, this sizes the edit length within bounds.
 
 	// Expand re-style are to word boundaries before and after the area of change
 	while (Start > 0 && UrlChar(Text[Start-1]))
 	{
 		// Move the start back
 		Start--;
 		Length++;
 	}
 	while ((ssize_t)Start + Length < Size && UrlChar(Text[Start+Length]))
 	{
 		// Move the end back
 		Length++;
 	}
 
 	// Delete all the styles that we own inside the changed area
 	for (StyleIter s = Style.begin(); s != Style.end();)
 	{
 		if (s->Owner == STYLE_NONE)
 		{
 			if (EditSize > 0)
 			{
 				if (s->Overlap(Start, EditSize < 0 ? -EditSize : EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 			else
 			{
 				if (s->Overlap(Start, -EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 		}
 
 		s++;
 	}
 
 	if (UrlDetect)
 	{		
 		LArray<LLinkInfo> Links;		
 		LAssert((ssize_t)Start + Length <= Size);		
 		if (LDetectLinks(Links, Text + Start, Length))
 		{
 			for (uint32_t i=0; i<Links.Length(); i++)
 			{
 				LLinkInfo &Inf = Links[i];
                 LAutoPtr<LTextView3::LStyle> Url(new LStyle(STYLE_URL));
 				if (Url)
 				{
 					Url->View = this;
 					Url->Start = Inf.Start + Start;
 					Url->Len = Inf.Len;
 					// Url->Email = Inf.Email;
 					Url->Font = Underline;
 					Url->Fore = d->UrlColour;
 
 					InsertStyle(Url);
 				}
 			}
 		}
 	}
 
 	#ifdef _DEBUG
 	_StyleTime = LCurrentTime() - StartTime;
 	#endif
 }
 
 bool LTextView3::Insert(size_t At, const char16 *Data, ssize_t Len)
 {
 	LProfile Prof("LTextView3::Insert");
 	Prof.HideResultsIfBelow(1000);
 
 	LAssert(InThread());
 	
 	if (!ReadOnly && Len > 0)
 	{
 		if (!Data)
 			return false;
 
 		// limit input to valid data
 		At = MIN(Size, (ssize_t)At);
 
 		// make sure we have enough memory
 		size_t NewAlloc = Size + Len + 1;
 		NewAlloc += ALLOC_BLOCK - (NewAlloc % ALLOC_BLOCK);
 		if (NewAlloc != Alloc)
 		{
 			char16 *NewText = new char16[NewAlloc];
 			if (NewText)
 			{
 				if (Text)
 				{
 					// copy any existing data across
 					memcpy(NewText, Text, (Size + 1) * sizeof(char16));
 				}
 
 				DeleteArray(Text);
 				Text = NewText;
 				Alloc = NewAlloc;
 			}
 			else
 			{
 				// memory allocation error
 				return false;
 			}
 		}
 		
 		Prof.Add("MemChk");
 
 		if (Text)
 		{
 			// Insert the data
 
 			// Move the section after the insert to make space...
 			memmove(Text+(At+Len), Text+At, (Size-At) * sizeof(char16));
 
 			Prof.Add("Cpy");
 
 			// Copy new data in...
 			memcpy(Text+At, Data, Len * sizeof(char16));
 			Size += Len;
 			Text[Size] = 0; // NULL terminate
 
 			Prof.Add("Undo");
 			
 			// Add the undo object...
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView3Undo> Obj(new LTextView3Undo(this));
 				LTextView3Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoInsert);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			// Clear layout info for the new text
 			ssize_t Idx = -1;
 			LTextLine *Cur = NULL;
 			
 			if (Line.Length() == 0)
 			{
 				// Empty doc... set up the first line
 				Line.Insert(Cur = new LTextLine);
 				Idx = 0;
 				Cur->Start = 0;
 			}
 			else
 			{
 				Cur = GetTextLine(At, &Idx);
 			}
 
 			if (Cur)
 			{
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					// Clear layout for current line...
 					Cur->r.ZOff(-1, -1);
 
 					Prof.Add("NoWrap add lines");
 					
 					// Add any new lines that we need...
 					char16 *e = Text + At + Len;
 					char16 *c;
 					for (c = Text + At; c < e; c++)
 					{
 						if (*c == '\n')
 						{
 							// Set the size of the current line...
 							size_t Pos = c - Text;
 							Cur->Len = Pos - Cur->Start;
 
 							// Create a new line...
 							Cur = new LTextLine();
 							if (!Cur)
 								return false;
 							Cur->Start = Pos + 1;
 							Line.Insert(Cur, ++Idx);
 						}
 					}
 
 					Prof.Add("CalcLen");
 
 					// Make sure the last Line's length is set..
 					Cur->CalcLen(Text);
 
 					Prof.Add("UpdatePos");
 	
 					// Now update all the positions of the following lines...
 					for (auto i = Line.begin(++Idx); *i; i++)
 						(*i)->Start += Len;
 				}
 				else
 				{
 					// Clear all lines to the end of the doc...
 					for (auto i = Line.begin(Idx); *i; i++)
 						delete *i;
 					Line.Length(Idx);
 				}
 			}
 			else
 			{
 				// If wrap is on then this can happen when an Insert happens before the 
 				// OnPulse event has laid out the new text. Probably not a good thing in
 				// non-wrap mode			
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					LTextLine *l = *Line.rbegin();
 					printf("%s:%i - Insert error: no cur, At=%i, Size=%i, Lines=%i, WrapType=%i\n",
 						_FL, (int)At, (int)Size, (int)Line.Length(), (int)WrapType);
 					if (l)
 						printf("Last=%i, %i\n", (int)l->Start, (int)l->Len);
 				}
 			}
 
 			#ifdef _DEBUG
 			// Prof.Add("Validate");
 			// ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, Len);
 
 			Dirty = true;
 			if (PourEnabled)
 			{
 				Prof.Add("PourText");
 				PourText(At, Len);
 				Prof.Add("PourStyle");
 				auto Start = LCurrentTime();
 				PourStyle(At, Len);
 				auto End = LCurrentTime();
 				if (End - Start > 1000)
 				{
 					PourStyle(At, Len);
 				}
 			}
 			SendNotify(LNotifyDocChanged);
 
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool LTextView3::Delete(size_t At, ssize_t Len)
 {
 	bool Status = false;
 
 	LAssert(InThread());
 
 	if (!ReadOnly)
 	{
 		// limit input
 		At = MAX(At, 0);
 		At = MIN((ssize_t)At, Size);
 		Len = MIN(Size-(ssize_t)At, Len);
 
 		if (Len > 0)
 		{
 			int HasNewLine = 0;
 
 			for (int i=0; i<Len; i++)
 			{
 				if (Text[At + i] == '\n')
 					HasNewLine++;
 			}
 
 			// do delete
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView3Undo> Obj(new LTextView3Undo(this));
 				LTextView3Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoDelete);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			memmove(Text+At, Text+(At+Len), (Size-At-Len) * sizeof(char16));
 			Size -= Len;
 			Text[Size] = 0;
 
 			if (WrapType == TEXTED_WRAP_NONE)
 			{
 				ssize_t Idx = -1;
 				LTextLine *Cur = GetTextLine(At, &Idx);
 				if (Cur)
 				{
 					Cur->r.ZOff(-1, -1);
 
 					// Delete some lines...
 					for (int i=0; i<HasNewLine; i++)
 					{
 						LTextLine *l = Line[Idx + 1];
 						delete l;
 						Line.DeleteAt(Idx + 1);
 					}
 
 					// Correct the current line's length
 					Cur->CalcLen(Text);
 
 					// Shift all further lines down...
 					for (auto i = Line.begin(Idx + 1); *i; i++)
 						(*i)->Start -= Len;
 				}
 			}
 			else
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					for (auto i = Line.begin(Index); *i; i++)
 						delete *i;
 					Line.Length(Index);
 				}
 			}
 			
 
 			Dirty = true;
 			Status = true;
 
 			#ifdef _DEBUG
 			// ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, -Len);
 
 			if (PourEnabled)
 			{
 				PourText(At, -Len);
 				PourStyle(At, -Len);
 			}
 			
 			if (Cursor >= (ssize_t)At && Cursor <= (ssize_t)At + Len)
 			{
 				SetCaret(At, false, HasNewLine != 0);
 			}
 
 			// Handle repainting in flowed mode, when the line starts change
 			if (WrapType == TEXTED_WRAP_REFLOW)
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					LRect r = Cur->r;
 					r.x2 = GetClient().x2;
 					r.y2 = GetClient().y2;
 					Invalidate(&r);
 				}
 			}
 
 			SendNotify(LNotifyDocChanged);
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 void LTextView3::DeleteSelection(char16 **Cut)
 {
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Cut)
 		{
 			*Cut = NewStrW(Text + Min, Max - Min);
 		}
 
 		Delete(Min, Max - Min);
 		SetCaret(Min, false, true);
 	}
 }
 
 List<LTextView3::LTextLine>::I LTextView3::GetTextLineIt(ssize_t Offset, ssize_t *Index)
 {
 	int i = 0;
 
 	for (auto It = Line.begin(); It != Line.end(); It++)
 	{
 		auto l = *It;
 
 		if (Offset >= l->Start && Offset <= l->Start+l->Len)
 		{
 			if (Index)
 				*Index = i;
 
 			return It;
 		}
 
 		i++;
 	}
 
 	return Line.end();
 }
 
 int64 LTextView3::Value()
 {
 	auto n = Name();
 	#ifdef _MSC_VER
 	return (n) ? _atoi64(n) : 0;
 	#else
 	return (n) ? atoll(n) : 0;
 	#endif
 }
 
 void LTextView3::Value(int64 i)
 {
 	char Str[32];
 	sprintf_s(Str, sizeof(Str), LPrintfInt64, i);
 	Name(Str);
 }
 
 LString LTextView3::operator[](ssize_t LineIdx)
 {
 	if (LineIdx <= 0 || LineIdx > (ssize_t)GetLines())
 		return LString();
 
 	LTextLine *Ln = Line[LineIdx-1];
 	if (!Ln)
 		return LString();
 
 	LString s(Text + Ln->Start, Ln->Len);
 	return s; 
 }
 
 const char *LTextView3::Name()
 {
 	UndoQue.Empty();
 	DeleteArray(TextCache);
 	TextCache = WideToUtf8(Text);
 
 	return TextCache;
 }
 
 bool LTextView3::Name(const char *s)
 {
 	if (InThread())
 	{
 		UndoQue.Empty();
 		DeleteArray(TextCache);
 		DeleteArray(Text);
 		Line.DeleteObjects();
 		Style.Empty();
 
 		LAssert(LIsUtf8(s));
 		Text = Utf8ToWide(s);
 		if (!Text)
 		{
 			Text = new char16[1];
 			if (Text) *Text = 0;
 		}
 
 		Size = Text ? StrlenW(Text) : 0;
 		Alloc = Size + 1;
 		Cursor = MIN(Cursor, Size);
 		if (Text)
 		{
 			// Remove '\r's
 			char16 *o = Text;
 			for (char16 *i=Text; *i; i++)
 			{
 				if (*i != '\r')
 				{
 					*o++ = *i;
 				}
 				else Size--;
 			}
 			*o++ = 0;
 		}
 		
 		// update everything else
 		d->SetDirty(0, Size);
 		PourText(0, Size);
 		PourStyle(0, Size);
 		UpdateScrollBars();
 		Invalidate();
 	}
 	else if (d->Lock(_FL))
 	{
 		if (IsAttached())
 		{
 			d->SetName = s;
 			PostEvent(M_TEXT_UPDATE_NAME);
 		}
 		else LAssert(!"Can't post event to detached/virtual window.");
 		d->Unlock();
 	}
 
 	return true;
 }
 
 const char16 *LTextView3::NameW()
 {
 	return Text;
 }
 
 const char16 *LTextView3::TextAtLine(size_t Index)
 {
 	if (Index >= Line.Length())
 		return NULL;
 
 	auto ln = Line[Index];
 	return Text + ln->Start;	
 }
 
 bool LTextView3::NameW(const char16 *s)
 {
 	DeleteArray(Text);
 	Size = s ? StrlenW(s) : 0;
 	Alloc = Size + 1;
 	Text = new char16[Alloc];
 	Cursor = MIN(Cursor, Size);
 	if (Text)
 	{
 		memcpy(Text, s, Size * sizeof(char16));
 
 		// remove LF's
 		int In = 0, Out = 0;
 		CrLf = false;
 		for (; In<Size; In++)
 		{
 			if (Text[In] != '\r')
 			{
 				Text[Out++] = Text[In];
 			}
 			else
 			{
 				CrLf = true;
 			}
 		}
 		Size = Out;
 		Text[Size] = 0;
 
 	}
 
 	// update everything else
 	Line.DeleteObjects();
 	Style.Empty();
 	d->SetDirty(0, Size);
 	PourText(0, Size);
 	PourStyle(0, Size);
 	UpdateScrollBars();
 	Invalidate();
 
 	return true;
 }
 
 LRange LTextView3::GetSelectionRange()
 {
 	LRange r;
 	if (HasSelection())
 	{
 		r.Start = MIN(SelStart, SelEnd);
 		ssize_t End = MAX(SelStart, SelEnd);
 		r.Len = End - r.Start;
 	}
 	return r;
 }
 
 char *LTextView3::GetSelection()
 {
 	LRange s = GetSelectionRange();
 	if (s.Len > 0)
 	{
 		return (char*)LNewConvertCp("utf-8", Text + s.Start, LGI_WideCharset, s.Len*sizeof(Text[0]) );
 	}
 
 	return 0;
 }
 
 bool LTextView3::HasSelection()
 {
 	return (SelStart >= 0) && (SelStart != SelEnd);
 }
 
 void LTextView3::SelectAll()
 {
 	SelStart = 0;
 	SelEnd = Size;
 	Invalidate();
 }
 
 void LTextView3::UnSelectAll()
 {
 	bool Update = HasSelection();
 
 	SelStart = -1;
 	SelEnd = -1;
 
 	if (Update)
 	{
 		Invalidate();
 	}
 }
 
 size_t LTextView3::GetLines()
 {
 	return Line.Length();
 }
 
 void LTextView3::GetTextExtent(int &x, int &y)
 {
 	PourText(0, Size);
 
 	x = MaxX + d->rPadding.x1;
 	y = (int)(Line.Length() * LineY);
 }
 
 bool LTextView3::GetLineColumnAtIndex(LPoint &Pt, ssize_t Index)
 {
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Index < 0 ? Cursor : Index, &FromIndex);
 	if (!From)
 		return false;
 
 	Pt.x = (int) (Cursor - From->Start);
 	Pt.y = (int) FromIndex;
 	return true;
 }
 
 ssize_t LTextView3::GetCaret(bool Cur)
 {
 	if (Cur)
 	{
 		return Cursor;
 	}
 
 	return 0;
 }
 
 ssize_t LTextView3::IndexAt(int x, int y)
 {
 	LTextLine *l = Line.ItemAt(y);
 	if (l)
 	{
 		return l->Start + MIN(x, l->Len);
 	}
 
 	return 0;
 }
 
 bool LTextView3::ScrollToOffset(size_t Off)
 {
 	bool ForceFullUpdate = false;
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Off, &ToIndex);
 	if (To)
 	{
 		LRect Client = GetClient();
 		int DisplayLines = Client.Y() / LineY;
 
 		if (VScroll)
 		{
 			if (ToIndex < VScroll->Value())
 			{
 				// Above the visible region...
 				if (d->CenterCursor)
 				{
 					ssize_t i = ToIndex - (DisplayLines >> 1);
 					VScroll->Value(MAX(0, i));
 				}
 				else
 				{
 					VScroll->Value(ToIndex);
 				}
 				ForceFullUpdate = true;
 			}
 
 			if (ToIndex >= VScroll->Value() + DisplayLines)
 			{
 				int YOff = d->CenterCursor ? DisplayLines >> 1 : DisplayLines;
 			
 				ssize_t v = MIN(ToIndex - YOff + 1, (ssize_t)Line.Length() - DisplayLines);
 				if (v != VScroll->Value())
 				{
 					// Below the visible region
 					VScroll->Value(v);
 					ForceFullUpdate = true;
 				}
 			}
 		}
 		else
 		{
 			d->VScrollCache = ToIndex;
 		}
 	}
 
 	return ForceFullUpdate;
 }
 
 void LTextView3::SetCaret(size_t i, bool Select, bool ForceFullUpdate)
 {
     // int _Start = LCurrentTime();
 	Blink = true;
 
 	// Bound the new cursor position to the document
 	if ((ssize_t)i > Size) i = Size;
 
 	// Store the old selection and cursor
 	ssize_t s = SelStart, e = SelEnd, c = Cursor;
 	
 	// If there is going to be a selected area
 	if (Select && i != SelStart)
 	{
 		// Then set the start
 		if (SelStart < 0)
 		{
 			// We are starting a new selection
 			SelStart = Cursor;
 		}
 
 		// And end
 		SelEnd = i;
 	}
 	else
 	{
 		// Clear the selection
 		SelStart = SelEnd = -1;
 	}
 
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Cursor, &FromIndex);
 
 	Cursor = i;
 
 	// check the cursor is on the screen
 	ForceFullUpdate |= ScrollToOffset(Cursor);
 
 	// check whether we need to update the screen
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Cursor, &ToIndex);
 	if (ForceFullUpdate ||
 		!To ||
 		!From)
 	{
 		// need full update
 		Invalidate();
 	}
 	else if
 	(
 		(
 			SelStart != s
 			||
 			SelEnd != e
 		)
 	)
 	{
 		// Update just the selection bounds
 		LRect Client = GetClient();
 		size_t Start, End;
 		if (SelStart >= 0 && s >= 0)
 		{
 			// Selection has changed, union the before and after regions
 			Start = MIN(Cursor, c);
 			End = MAX(Cursor, c);
 		}
 		else if (SelStart >= 0)
 		{
 			// Selection created...
 			Start = MIN(SelStart, SelEnd);
 			End = MAX(SelStart, SelEnd);
 		}
 		else if (s >= 0)
 		{
 			// Selection removed...
 			Start = MIN(s, e);
 			End = MAX(s, e);
 		}
 		else return;
 
 		auto SLine = GetTextLine(Start);
 		auto ELine = GetTextLine(End);
 		LRect u;
 		if (SLine && ELine)
 		{
 			if (SLine->r.Valid())
 			{
 				u = DocToScreen(SLine->r);
 			}
 			else
 				u.Set(0, 0, Client.X()-1, 1); // Start of visible page 
 			
 			LRect b(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			if (ELine->r.Valid())
 			{
 				b = DocToScreen(ELine->r);
 			}
 			else
 			{
 				b.Set(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			}
 			u.Union(&b);
 			
 			u.x1 = 0;
 			u.x2 = X();
 		}
 		else
 		{
 			/*
 			printf("%s,%i - Couldn't get SLine and ELine: %i->%p, %i->%p\n",
 				_FL,
 				(int)Start, SLine,
 				(int)End, ELine);
 			*/
 			u = Client;
 		}
 
 		Invalidate(&u);			
 	}
 	else if (Cursor != c)
 	{
 		// just the cursor has moved
 
 		// update the line the cursor moved to
 		LRect r = To->r;
 		r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 		r.x2 = X();
 		Invalidate(&r);
 
 		if (To != From)
 		{
 			// update the line the cursor came from,
 			// if it's a different line from the "to"
 			r = From->r;
 			r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 			r.x2 = X();
 			Invalidate(&r);
 		}
 	}
 
 	if (c != Cursor)
 	{
 		// Send off notify
 		SendNotify(LNotifyCursorChanged);
 	}
 
 //int _Time = LCurrentTime() - _Start;
 //printf("Setcursor=%ims\n", _Time);
 }
 
 void LTextView3::SetBorder(int b)
 {
 }
 
 bool LTextView3::Cut()
 {
 	bool Status = false;
 	char16 *Txt16 = 0;
 	
 	DeleteSelection(&Txt16);
 	if (Txt16)
 	{
 		#ifdef WIN32
 		Txt16 = ConvertToCrLf(Txt16);
 		#endif
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 
 		LClipBoard Clip(this);
 
 		Clip.Text(Txt8);
 		Status = Clip.TextW(Txt16, false);
 		
 		DeleteArray(Txt8);
 		DeleteArray(Txt16);
 	}
 
 	return Status;
 }
 
 bool LTextView3::Copy()
 {
 	bool Status = true;
 
 printf("txt copy\n");
 
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		#ifdef WIN32
 		char16 *Txt16 = NewStrW(Text+Min, Max-Min);
 		Txt16 = ConvertToCrLf(Txt16);
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 		#else
 		char *Txt8 = (char*)LNewConvertCp("utf-8", Text+Min, LGI_WideCharset, (Max-Min)*sizeof(*Text));
 		#endif
 
 		LClipBoard Clip(this);
 		
 		Clip.Text(Txt8);
 		#ifdef WIN32
 		Clip.TextW(Txt16, false);
 		DeleteArray(Txt16);
 		#endif
 		
 		DeleteArray(Txt8);
 	}
 	else LgiTrace("%s:%i - No selection.\n", _FL);
 
 	return Status;
 }
 
 bool LTextView3::Paste()
 {
 	LClipBoard Clip(this);
 
 	LAutoWString Mem;
 	char16 *t = Clip.TextW();
 	if (!t) // ala Win9x
 	{
 		char *s = Clip.Text();
 		if (s)
 		{
 			Mem.Reset(Utf8ToWide(s));
 			t = Mem;
 		}
 	}
 	
 	if (!t)
 		return false;
 
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	// remove '\r's
 	char16 *s = t, *d = t;
 	for (; *s; s++)
 	{
 		if (*s != '\r')
 		{
 			*d++ = *s;
 		}
 	}
 	*d++ = 0;
 
 	// insert text
 	ssize_t Len = StrlenW(t);
 	Insert(Cursor, t, Len);
 	SetCaret(Cursor+Len, false, true); // Multiline
 	
 	return true;
 }
 
 void LTextView3::ClearDirty(std::function<void(bool)> OnStatus, bool Ask, const char *FileName)
 {
 	if (Dirty)
 	{
 		int Answer = (Ask) ? LgiMsg(this,
 									LLoadString(L_TEXTCTRL_ASK_SAVE, "Do you want to save your changes to this document?"),
 									LLoadString(L_TEXTCTRL_SAVE, "Save"),
 									MB_YESNOCANCEL) : IDYES;
 		if (Answer == IDYES)
 		{
 			auto DoSave = [this, OnStatus](bool ok, const char *FileName)
 			{
 				Save(FileName);
 				if (OnStatus)
 					OnStatus(ok);
 			};
 			
 			if (!FileName)
 			{
 				LFileSelect *Select = new LFileSelect;
 				Select->Parent(this);
 				Select->Save([FileName=LString(FileName), DoSave](auto s, auto ok)
 				{
 					if (ok)
 						DoSave(ok, s->Name());
 					else
 						DoSave(ok, FileName);
 					delete s;
 				});
 			}
 			else DoSave(true, FileName);
 		}
 		else if (Answer == IDCANCEL)
 		{
 			if (OnStatus)
 				OnStatus(false);
 			return;
 		}
 	}
 
 	if (OnStatus)
 		OnStatus(true);
 }
 
 bool LTextView3::Open(const char *Name, const char *CharSet)
 {
 	bool Status = false;
 	LFile f;
 
 	if (f.Open(Name, O_READ|O_SHARE))
 	{
 		DeleteArray(Text);
 		int64 Bytes = f.GetSize();
 		if (Bytes < 0 || Bytes & 0xffff000000000000LL)
 		{
 			LgiTrace("%s:%i - Invalid file size: " LPrintfInt64 "\n", _FL, Bytes);
 			return false;
 		}
 			
 		SetCaret(0, false);
 		Line.DeleteObjects();
 		
 		char *c8 = new char[Bytes + 4];
 		if (c8)
 		{
 			if (f.Read(c8, (int)Bytes) == Bytes)
 			{
 				char *DataStart = c8;
 
 				c8[Bytes] = 0;
 				c8[Bytes+1] = 0;
 				c8[Bytes+2] = 0;
 				c8[Bytes+3] = 0;
 				
 				if ((uchar)c8[0] == 0xff && (uchar)c8[1] == 0xfe)
 				{
 					// utf-16
 					if (!CharSet)
 					{
 						CharSet = "utf-16";
 						DataStart += 2;
 					}
 				}
 				
 				// Convert to unicode first....
 				if (Bytes == 0)
 				{
 					Text = new char16[1];
 					if (Text) Text[0] = 0;
 				}
 				else
 				{
 					Text = (char16*)LNewConvertCp(LGI_WideCharset, DataStart, CharSet ? CharSet : DefaultCharset);
 				}
 				
 				if (Text)
 				{
 					// Remove LF's
 					char16 *In = Text, *Out = Text;
 					CrLf = false;
 					Size = 0;
 					while (*In)
 					{
 						if (*In >= ' ' ||
 							*In == '\t' ||
 							*In == '\n')
 						{
 							*Out++ = *In;
 							Size++;
 						}
 						else if (*In == '\r')
 						{
 							CrLf = true;
 						}
 						In++;
 					}
 					Size = (int) (Out - Text);
 					*Out = 0;
 
 					Alloc = Size + 1;
 					Dirty = false;
 					
 					if (Text && Text[0] == 0xfeff) // unicode byte order mark
 					{
 						memmove(Text, Text+1, Size * sizeof(*Text));
 						Size--;
 					}
 
 					PourText(0, Size);
 					PourStyle(0, Size);
 					UpdateScrollBars(true);
 					
 					Status = true;
 				}
 			}
 
 			DeleteArray(c8);
 		}
 		else
 		{
 			Alloc = Size = 0;
 		}
 
 		Invalidate();
 	}
 
 	return Status;
 }
 
 template<typename T>
 bool WriteToStream(LFile &out, T *in, size_t len, bool CrLf)
 {
 	if (!in)
 		return false;
 	
 	if (CrLf)
 	{
 		int BufLen = 1 << 20;
 		LAutoPtr<T,true> Buf(new T[BufLen]);
 		T *b = Buf;
 		T *e = Buf + BufLen;
 		T *c = in;
 		T *end = c + len;
 		
 		while (c < end)
 		{
 			if (b > e - 16)
 			{
 				auto Bytes = (b - Buf) * sizeof(T);
 				if (out.Write(Buf, Bytes) != Bytes)
 					return false;
 				
 				b = Buf;
 			}
 			
 			if (*c == '\n')
 			{
 				*b++ = '\r';
 				*b++ = '\n';
 			}
 			else
 			{
 				*b++ = *c;
 			}
 			c++;
 		}
 
 		auto Bytes = (b - Buf) * sizeof(T);
 		if (out.Write(Buf, Bytes) != Bytes)
 			return false;
 	}
 	else
 	{
 		auto Bytes = len * sizeof(T);
 		if (out.Write(in, Bytes) != Bytes)
 			return false;
 	}
 
 	return true;
 }
 
 bool LTextView3::Save(const char *Name, const char *CharSet)
 {
 	LFile f;
 	LString TmpName;
 	bool Status = false;
 	
 	d->LastError.Empty();
 
 	if (f.Open(Name, O_WRITE))
 	{
 		if (f.SetSize(0) != 0)
 		{
 			// Can't resize file, fall back to renaming it and 
 			// writing a new file...
 			f.Close();
 			TmpName = Name;
 			TmpName += ".tmp";
 			if (!FileDev->Move(Name, TmpName))
 			{
 				LgiTrace("%s:%i - Failed to move '%s'.\n", _FL, Name);
 				return false;
 			}
 
 			if (!f.Open(Name, O_WRITE))
 			{
 				LgiTrace("%s:%i - Failed to open '%s' for writing.\n", _FL, Name);
 				return false;
 			}
 		}
 
 		if (Text)
 		{
 			auto InSize = Size * sizeof(char16);
 			if (CharSet && !Stricmp(CharSet, "utf-16"))
 			{
 				if (sizeof(*Text) == 2)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 32->16 convert
 					LAutoPtr<uint16_t,true> c16((uint16_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c16)
 						Status = WriteToStream(f, c16.Get(), Strlen(c16.Get()), CrLf);
 				}
 			}
 			else if (CharSet && !Stricmp(CharSet, "utf-32"))
 			{
 				if (sizeof(*Text) == 4)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 16->32 convert
 					LAutoPtr<uint32_t,true> c32((uint32_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c32)
 						Status = WriteToStream(f, c32.Get(), Strlen(c32.Get()), CrLf);
 				}
 			}
 			else
 			{
 				LAutoString c8((char*)LNewConvertCp(CharSet ? CharSet : DefaultCharset, Text, LGI_WideCharset, InSize));
 				if (c8)
 					Status = WriteToStream(f, c8.Get(), strlen(c8), CrLf);
 			}
 
 			if (Status)
 				Dirty = false;
 		}
 	}
 	else
 	{
 		int Err = f.GetError();
 		LString sErr = LErrorCodeToString(Err);		
 		d->LastError.Printf("Failed to open '%s' for writing: %i - %s\n", Name, Err, sErr.Get());
 	}
 
 	if (TmpName)
 		FileDev->Delete(TmpName);
 
 	return Status;
 }
 
 const char *LTextView3::GetLastError()
 {
 	return d->LastError;
 }
 
 void LTextView3::UpdateScrollBars(bool Reset)
 {
 	if (!VScroll)
 		return;
 
 	LRect Before = GetClient();
 
 	int DisplayLines = Y() / LineY;
 	ssize_t Lines = std::max(PartialPourLines, Line.Length());
 	VScroll->SetRange(Lines);
 	if (VScroll)
 	{
 		VScroll->SetPage(DisplayLines);
 			
 		ssize_t Max = Lines - DisplayLines + 1;
 		bool Inval = false;
 		if (VScroll->Value() > Max)
 		{
 			VScroll->Value(Max);
 			Inval = true;
 		}
 
 		if (Reset)
 		{
 			VScroll->Value(0);
 			SelStart = SelEnd = -1;
 		}
 		else if (d->VScrollCache >= 0)
 		{
 			VScroll->Value(d->VScrollCache);
 			d->VScrollCache = -1;
 			SelStart = SelEnd = -1;
 		}
 
 		LRect After = GetClient();
 
 		if (Before != After && GetWrapType())
 		{
 			d->SetDirty(0, Size);
 			Inval = true;
 		}
 			
 		if (Inval)
 		{
 			Invalidate();
 		}
 	}
 }
 
 void LTextView3::DoCase(std::function<void(bool)> Callback, bool Upper)
 {
 	if (Text)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Min < Max)
 		{
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView3Undo> Obj(new LTextView3Undo(this));
 				LTextView3Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(Min, Max - Min, UndoChange);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			for (ssize_t i=Min; i<Max; i++)
 			{
 				if (Upper)
 				{
 					if (Text[i] >= 'a' && Text[i] <= 'z')
 						Text[i] = Text[i] - 'a' + 'A';
 				}
 				else
 				{
 					if (Text[i] >= 'A' && Text[i] <= 'Z')
 						Text[i] = Text[i] - 'A' + 'a';
 				}
 			}
 
 			Dirty = true;
 			d->SetDirty(Min, 0);
 			Invalidate();
 
 			SendNotify(LNotifyDocChanged);
 		}
 	}
 	
 	if (Callback)
 		Callback(Text != NULL);
 }
 
 ssize_t LTextView3::GetLine()
 {
 	ssize_t Idx = 0;
 	GetTextLine(Cursor, &Idx);
 	return Idx + 1;
 }
 
 void LTextView3::SetLine(int64_t i, bool select)
 {
 	LTextLine *l = Line.ItemAt(i - 1);
 	if (l)
 	{
 		d->CenterCursor = true;
 		SetCaret(l->Start, select);
 		d->CenterCursor = false;
 	}
 }
 
 void LTextView3::DoGoto(std::function<void(bool)> Callback)
 {
 	LInput *Dlg = new LInput(this, "", LLoadString(L_TEXTCTRL_GOTO_LINE, "Goto line:"), "Text");	
 	Dlg->DoModal([this, Dlg, Callback](auto d, auto code)
 	{
 		auto ok = code == IDOK && Dlg->GetStr();
 		if (ok)
 			SetLine(Dlg->GetStr().Int());
 		if (Callback)
 			Callback(ok);
 		delete Dlg;
 	});
 }
 
 LDocFindReplaceParams *LTextView3::CreateFindReplaceParams()
 {
 	return new LDocFindReplaceParams3;
 }
 
 void LTextView3::SetFindReplaceParams(LDocFindReplaceParams *Params)
 {
 	if (Params)
 	{
 		if (d->OwnFindReplaceParams)
 		{
 			DeleteObj(d->FindReplaceParams);
 		}
 		
 		d->OwnFindReplaceParams = false;
 		d->FindReplaceParams = (LDocFindReplaceParams3*) Params;
 	}
 }
 
 void LTextView3::DoFindNext(std::function<void(bool)> OnStatus)
 {
 	bool Status = false;
 	if (InThread())
 	{
 		if (d->FindReplaceParams->Lock(_FL))
 		{
 			if (d->FindReplaceParams->LastFind)
 				Status = OnFind(d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 							
 			d->FindReplaceParams->Unlock();
 		}
 	}
 	else if (IsAttached())
 	{
 		Status = PostEvent(M_TEXTVIEW_FIND);
 	}
 	if (OnStatus)
 		OnStatus(Status);
 }
 
 void LTextView3::DoFind(std::function<void(bool)> Callback)
 {
 	LString u;
 
 	if (HasSelection())
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		u = LString(Text + Min, Max - Min);
 	}
 	else
 	{
 		u = d->FindReplaceParams->LastFind.Get();
 	}
 
 	auto Dlg = new LFindDlg(this, [this, Params=d->FindReplaceParams, Callback](auto Dlg, auto Action)
 		{
 			if (Params &&
 				Params->Lock(_FL))
 			{
 				Params->MatchWord = Dlg->MatchWord;
 				Params->MatchCase = Dlg->MatchCase;
 				Params->SelectionOnly = Dlg->SelectionOnly;
 				Params->SearchUpwards = Dlg->SearchUpwards;
 				Params->LastFind.Reset(Utf8ToWide(Dlg->Find));
 		
 				Params->Unlock();
 			}
 
 			DoFindNext([this, Callback](bool ok)
 			{
 				Focus(true);
 				if (Callback)
 					Callback(ok);
 			});
 		},
 		u);
 
 	Dlg->DoModal(NULL);
 }
 
 void LTextView3::DoReplace(std::function<void(bool)> Callback)
 {
 	bool SingleLineSelection = false;
 	SingleLineSelection = HasSelection();
 	if (SingleLineSelection)
 	{
 		LRange Sel = GetSelectionRange();
 		for (ssize_t i = Sel.Start; i < Sel.End(); i++)
 		{
 			if (Text[i] == '\n')
 			{
 				SingleLineSelection = false;
 				break;
 			}
 		}
 	}
 
 	auto LastFind8 = SingleLineSelection ? GetSelection() : WideToUtf8(d->FindReplaceParams->LastFind);
 	auto LastReplace8 = WideToUtf8(d->FindReplaceParams->LastReplace);
 	
 	auto Dlg = new LReplaceDlg(this, [this, LastFind8, LastReplace8](auto Dlg, auto Action)
 		{
 			LReplaceDlg *Replace = dynamic_cast<LReplaceDlg*>(Dlg);
 			LAssert(Replace != NULL);
 			
 			LAutoString FindMem(LastFind8);
 			LAutoString ReplaceMem(LastReplace8);
 
 			if (Action == IDCANCEL)
 				return;
 
 			if (d->FindReplaceParams->Lock(_FL))
 			{
 				d->FindReplaceParams->LastFind.Reset(Utf8ToWide(Replace->Find));
 				d->FindReplaceParams->LastReplace.Reset(Utf8ToWide(Replace->Replace));
 				d->FindReplaceParams->MatchWord = Replace->MatchWord;
 				d->FindReplaceParams->MatchCase = Replace->MatchCase;
 				d->FindReplaceParams->SelectionOnly = Replace->SelectionOnly;
 					
 				switch (Action)
 				{
 					case IDC_FR_FIND:
 					{
 						OnFind(	d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 					case IDOK:
 					case IDC_FR_REPLACE:
 					{
 						OnReplace(	d->FindReplaceParams->LastFind,
 									d->FindReplaceParams->LastReplace,
 									Action == IDOK,
 									d->FindReplaceParams->MatchWord,
 									d->FindReplaceParams->MatchCase,
 									d->FindReplaceParams->SelectionOnly,
 									d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 				}
 
 				d->FindReplaceParams->Unlock();
 			}
 		},
 		LastFind8,
 		LastReplace8);
 
 	Dlg->MatchWord = d->FindReplaceParams->MatchWord;
 	Dlg->MatchCase = d->FindReplaceParams->MatchCase;
 	Dlg->SelectionOnly = HasSelection();
 
 	Dlg->DoModal(NULL);
 }
 
 void LTextView3::SelectWord(size_t From)
 {
 	for (SelStart = From; SelStart > 0; SelStart--)
 	{
 		if (strchr(SelectWordDelim, Text[SelStart]))
 		{
 			SelStart++;
 			break;
 		}
 	}
 
 	for (SelEnd = From; SelEnd < Size; SelEnd++)
 	{
 		if (strchr(SelectWordDelim, Text[SelEnd]))
 		{
 			break;
 		}
 	}
 
 	Invalidate();
 }
 
 typedef int (*StringCompareFn)(const char16 *a, const char16 *b, ssize_t n);
 
 ptrdiff_t LTextView3::MatchText(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	if (!ValidStrW(Find))
 		return -1;
 
 	ssize_t FindLen = StrlenW(Find);
 		
 	// Setup range to search
 	ssize_t Begin, End;
 	if (SelectionOnly && HasSelection())
 	{
 		Begin = MIN(SelStart, SelEnd);
 		End = MAX(SelStart, SelEnd);
 	}
 	else
 	{
 		Begin = 0;
 		End = Size;
 	}
 
 	// Look through text...
 	ssize_t i;
 	bool Wrap = false;
 	if (Cursor > End - FindLen)
 	{
 		Wrap = true;
 		if (SearchUpwards)
 			i = End - FindLen;
 		else
 			i = Begin;
 	}
 	else
 	{
 		i = Cursor;
 	}
 		
 	if (i < Begin) i = Begin;
 	if (i > End) i = End;
 	
 	StringCompareFn CmpFn = MatchCase ? StrncmpW : StrnicmpW;
 	char16 FindCh = MatchCase ? Find[0] : toupper(Find[0]);
 
 	for (; SearchUpwards ? i >= Begin : i <= End; i += SearchUpwards ? -1 : 1)
 	{
 		if
 		(
 			(MatchCase ? Text[i] : toupper(Text[i]))
 			==
 			FindCh
 		)
 		{
 			char16 *Possible = Text + i;
 
 			if (CmpFn(Possible, Find, FindLen) == 0)
 			{
 				if (MatchWord)
 				{
 					// Check boundaries
 							
 					if (Possible > Text) // Check off the start
 					{
 						if (!IsWordBoundry(Possible[-1]))
 							continue;
 					}
 					if (i + FindLen < Size) // Check off the end
 					{
 						if (!IsWordBoundry(Possible[FindLen]))
 							continue;
 					}
 				}
 						
 				/* What was this even supposed to do?
 				LRange r(Possible - Text, FindLen);
 				if (!r.Overlap(Cursor))
 				*/
 				return i;
 			}
 		}
 				
 		if (!Wrap && (i + 1 > End - FindLen))
 		{
 			Wrap = true;
 			i = Begin;
 			End = Cursor;
 		}
 	}
 	
 	return -1;
 }
 
 bool LTextView3::OnFind(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	// Not sure what this is doing???
 	if (HasSelection() &&
 		SelEnd < SelStart)
 	{
 		Cursor = SelStart;
 	}
 
 	#if FEATURE_HILIGHT_ALL_MATCHES
 
 	// Clear existing styles for matches
 	for (StyleIter s = Style.begin(); s != Style.end(); )
 	{
 		if (s->Owner == STYLE_FIND_MATCHES)
 			Style.Delete(s);
 		else
 			s++;
 	}
 
 	ssize_t FindLen = StrlenW(Find);
 	ssize_t FirstLoc = MatchText(Find, MatchWord, MatchCase, false, SearchUpwards), Loc;
 	if (FirstLoc >= 0)
 	{
 		SetCaret(FirstLoc, false);
 		SetCaret(FirstLoc + FindLen, true);
 	}
 
 	ssize_t Old = Cursor;
 	if (!SearchUpwards)
 		Cursor += FindLen;
 	
 	while ((Loc = MatchText(Find, MatchWord, MatchCase, false, false)) != FirstLoc)
 	{
 		LAutoPtr<LStyle> s(new LStyle(STYLE_FIND_MATCHES));
 		s->Start = Loc;
 		s->Len = FindLen;
 		s->Fore = LColour(L_FOCUS_SEL_FORE);
 		s->Back = LColour(L_FOCUS_SEL_BACK).Mix(LColour(L_WORKSPACE));
 		InsertStyle(s);
 
 		Cursor = Loc + FindLen;
 	}
 
 	Cursor = Old;
 	ScrollToOffset(Cursor);
 	Invalidate();
 
 	#else
 
 	ssize_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 	if (Loc >= 0)
 	{
 		SetCaret(Loc, false);
 		SetCaret(Loc + StrlenW(Find), true);
 		return true;
 	}
 
 	#endif
 
 	return false;
 }
 
 bool LTextView3::OnReplace(const char16 *Find, const char16 *Replace, bool All, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	if (ValidStrW(Find))
 	{
 		// int Max = -1;
 		ssize_t FindLen = StrlenW(Find);
 		ssize_t ReplaceLen = StrlenW(Replace);
 		// size_t OldCursor = Cursor;
 		ptrdiff_t First = -1;
 
 		while (true)
 		{
 			ptrdiff_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 			if (First < 0)
 			{
 				First = Loc;
 			}
 			else if (Loc == First)
 			{
 				break;
 			}
 			
 			if (Loc >= 0)
 			{
 				ssize_t OldSelStart = SelStart;
 				ssize_t OldSelEnd = SelEnd;
 				
 				Delete(Loc, FindLen);
 				Insert(Loc, Replace, ReplaceLen);
 				
 				SelStart = OldSelStart;
 				SelEnd = OldSelEnd - FindLen + ReplaceLen;
 				Cursor = Loc + ReplaceLen;
 			}
 			if (!All)
 			{
 				return Loc >= 0;
 			}
 			if (Loc < 0) break;
 		}
 	}	
 	
 	return false;
 }
 
 ssize_t LTextView3::SeekLine(ssize_t Offset, GTextViewSeek Where)
 {
 	THREAD_CHECK();
 
 	switch (Where)
 	{
 		case PrevLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 			
 			if (Offset > 0)
 				Offset--;
 			
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
 		case NextLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 
 			Offset++;
 			break;
 		}
 		case StartLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
  		case EndLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 			break;
 		}
 		default:
 		{
 			LAssert(false);
 			break;
 		}
 	}
 
 	return Offset;
 }
 
 bool LTextView3::OnMultiLineTab(bool In)
 {
 	bool Status = false;
 	ssize_t Min = MIN(SelStart, SelEnd);
 	ssize_t Max = MAX(SelStart, SelEnd), i;
 
 	Min = SeekLine(Min, StartLine);
 
 	int Ls = 0;
 	LArray<ssize_t> p;
 	for (i=Min; i<Max && i<Size; i=SeekLine(i, NextLine))
 	{
 		p.Add(i);
 		Ls++;
 	}
 	if (Max < i)
 	{
 		Max = SeekLine(Max, EndLine);
 	}
 
 	PourEnabled = false;
 
 	ssize_t *Indexes = p.AddressOf(0);
 	if (!Indexes)
 		return false;
 
 	UndoCur = new LTextView3Undo(this);
 
 	for (i=Ls-1; i>=0; i--)
 	{
 		if (In)
 		{
 			// <-
 			ssize_t n = Indexes[i], Space = 0;
 			for (; Space<IndentSize && n<Size; n++)
 			{
 				if (Text[n] == 9)
 				{
 					Space += IndentSize;
 				}
 				else if (Text[n] == ' ')
 				{
 					Space += 1;
 				}
 				else
 				{
 					break;
 				}
 			}
 
 			ssize_t Chs = n-Indexes[i];
 			Delete(Indexes[i], Chs);
 			Max -= Chs;
 		}
 		else
 		{
 			// ->
 			ssize_t Len = Indexes[i];
 			for (; Text[Len] != '\n' && Len<Size; Len++);
 			if (Len > Indexes[i])
 			{
 				if (HardTabs)
 				{
 					char16 Tab[] = {'\t', 0};
 					Insert(Indexes[i], Tab, 1);
 					Max++;
 				}
 				else
 				{
 					char16 *Sp = new char16[IndentSize];
 					if (Sp)
 					{
 						for (int n=0; n<IndentSize; n++)
 							Sp[n] = ' ';
 						Insert(Indexes[i], Sp, IndentSize);
 						Max += IndentSize;
 					}
 				}
 			}
 		}
 	}
 
 	if (UndoCur->Changes.Length())
 	{
 		UndoQue += UndoCur;
 		UndoCur = NULL;
 	}
 	else
 	{
 		DeleteObj(UndoCur);
 	}
 
 	SelStart = Min;
 	SelEnd = Cursor = Max;
 
 	PourEnabled = true;
 	PourText(Min, Max - Min);
 	PourStyle(Min, Max - Min);
 	
 	d->SetDirty(Min, Max-Min);
 	Invalidate();
 	Status = true;
 
 	return Status;
 }
 
 void LTextView3::OnSetHidden(int Hidden)
 {
 }
 
 void LTextView3::OnPosChange()
 {
 	static bool Processing = false;
 
 	if (!Processing)
 	{
 		Processing = true;
 		LLayout::OnPosChange();
 
 		LRect c = GetClient();
 		bool ScrollYNeeded = c.Y() < (std::max(PartialPourLines, Line.Length()) * LineY);
 		bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 		if (ScrollChange)
 		{
 			#if 0
 			auto Client = GetClient();
 			LgiTrace("%s:%i - %p::SetScrollBars(%i) cliy=%i content=%i partial=%i\n",
 				_FL, this, ScrollYNeeded, Client.Y(), (Line.Length() * LineY), PartialPour);
 			#endif
 			SetScrollBars(false, ScrollYNeeded);
 		}
 		UpdateScrollBars();
 
 		if (GetWrapType() && d->PourX != X())
 		{
 			d->PourX = X();
 			d->SetDirty(0, Size);
 		}
 		Processing = false;
 	}
 }
 
 int LTextView3::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	Formats.Supports("text/uri-list");
 	Formats.Supports("text/html");
 	Formats.Supports("UniformResourceLocatorW");
 	return Formats.Length() ? DROPEFFECT_COPY : DROPEFFECT_NONE;
 }
 
 int LTextView3::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	int Status = DROPEFFECT_NONE;
 	
 	for (unsigned i=0; i<Data.Length(); i++)
 	{
 		LDragData &dd = Data[i];
 		if (dd.Data.Length() <= 0)
 			continue;
 		
 		if (dd.IsFormat("text/html") || dd.IsFormat("UniformResourceLocatorW"))
 		{
 			LVariant *Data = &dd.Data[0];
 			LAssert(dd.Data.Length() == 1); // Impl multiple data entries if this asserts.
 			if (Data->IsBinary())
 			{
 				OsChar *e = (OsChar*) ((char*)Data->Value.Binary.Data + Data->Value.Binary.Length);
 				OsChar *s = (OsChar*) Data->Value.Binary.Data;
 				int len = 0;
 				while (s < e && s[len])
 				{
 					len++;
 				}
 				
 				LAutoWString w
 				(
 					(char16*)LNewConvertCp
 					(
 						LGI_WideCharset,
 						s,
 						(
 							sizeof(OsChar) == 1
 							?
 							"utf-8"
 							:
 							LGI_WideCharset
 						),
 						len * sizeof(*s)
 					)
 				);
 				
 				Insert(Cursor, w, len);
 				Invalidate();
 				return DROPEFFECT_COPY;
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			// We don't directly handle file drops... pass up to the parent
 			bool FoundTarget = false;
 			for (LViewI *p = GetParent(); p; p = p->GetParent())
 			{
 				LDragDropTarget *t = p->DropTarget();
 				if (t)
 				{
 					Status = t->OnDrop(Data, Pt, KeyState);
 					if (Status != DROPEFFECT_NONE)
 					{
 						FoundTarget = true;
 						break;
 					}
 				}
 			}
 			if (!FoundTarget)
 			{
 				auto Wnd = GetWindow();
 				if (Wnd)
 				{
 					LDropFiles files(dd);
 					Wnd->OnReceiveFiles(files);
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 void LTextView3::OnCreate()
 {
 	SetWindow(this);
 	DropTarget(true);
 
 	#ifndef WINDOWS
 		if (Ctrls.Length() == 0)
 			SetPulse(PULSE_TIMEOUT);
 		Ctrls.Add(this);
 	#else
 		SetPulse(PULSE_TIMEOUT);
 	#endif
 }
 
 void LTextView3::OnEscape(LKey &K)
 {
 }
 
 bool LTextView3::OnMouseWheel(double l)
 {
 	if (VScroll)
 	{
 		int64 NewPos = VScroll->Value() + (int)l;
 		NewPos = limit(NewPos, 0, (ssize_t)GetLines());
 		VScroll->Value(NewPos);
 		Invalidate();
 	}
 	
 	return true;
 }
 
 void LTextView3::OnFocus(bool f)
 {
 	Invalidate();
 }
 
 ssize_t LTextView3::HitText(int x, int y, bool Nearest)
 {
 	if (!Text)
 		return 0;
 
 	bool Down = y >= 0;
 	int Y = (VScroll) ? (int)VScroll->Value() : 0;
 	auto It = Line.begin(Y);
 	if (It != Line.end())
 		y += (*It)->r.y1;
 
 	while (It != Line.end())
 	{
 		auto l = *It;
 
 		if (l->r.Overlap(x, y))
 		{
 			// Over a line
 			int At = x - l->r.x1;
 			ssize_t Char = 0;
 				
 			LDisplayString Ds(Font, MapText(Text + l->Start, l->Len), l->Len, 0);
 			Char = Ds.CharAt(At, Nearest ? LgiNearest : LgiTruncate);
 
 			return l->Start + Char;
 		}
 		else if (y >= l->r.y1 && y <= l->r.y2)
 		{
 			// Click horizontally before of after line
 			if (x < l->r.x1)
 			{
 				return l->Start;
 			}
 			else if (x > l->r.x2)
 			{
 				return l->Start + l->Len;
 			}
 		}
 			
 		if (Down)
 			It++;
 		else
 			It--;
 		Y++;
 	}
 
 	// outside text area
 	if (Down)
 	{
 		It = Line.rbegin();
 		if (It != Line.end())
 		{
 			if (y > (*It)->r.y2)
 			{
 				// end of document
 				return Size;
 			}
 		}
 	}
 
 	return 0;
 }
 
 void LTextView3::Undo()
 {
 	int Old = UndoQue.GetPos();
 	UndoQue.Undo();
 	if (Old && !UndoQue.GetPos())
 	{
 		Dirty = false;
 		SendNotify(LNotifyDocChanged);
 	}
 }
 
 void LTextView3::Redo()
 {
 	UndoQue.Redo();
 }
 
 void LTextView3::DoContextMenu(LMouse &m)
 {
 	LSubMenu RClick;
 	LAutoString ClipText;
 	{
 		LClipBoard Clip(this);
 		ClipText.Reset(NewStr(Clip.Text()));
 	}
 
 	LStyle *s = HitStyle(HitText(m.x, m.y, true));
 	if (s)
 	{
 		if (OnStyleMenu(s, &RClick))
 		{
 			RClick.AppendSeparator();
 		}
 	}
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_CUT, "Cut"), IDM_CUT, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_COPY, "Copy"), IDM_COPY, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_PASTE, "Paste"), IDM_PASTE, ClipText != 0);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem("Copy All", IDM_COPY_ALL, true);
 	RClick.AppendItem("Select All", IDM_SELECT_ALL, true);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_UNDO, "Undo"), IDM_UNDO, UndoQue.CanUndo());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_REDO, "Redo"), IDM_REDO, UndoQue.CanRedo());
 	RClick.AppendSeparator();
 
 	auto i = RClick.AppendItem(LLoadString(L_TEXTCTRL_FIXED, "Fixed Width Font"), IDM_FIXED, true);
 	if (i) i->Checked(GetFixedWidthFont());
 
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_AUTO_INDENT, "Auto Indent"), IDM_AUTO_INDENT, true);
 	if (i) i->Checked(AutoIndent);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_SHOW_WHITESPACE, "Show Whitespace"), IDM_SHOW_WHITE, true);
 	if (i) i->Checked(ShowWhiteSpace);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_HARD_TABS, "Hard Tabs"), IDM_HARD_TABS, true);
 	if (i) i->Checked(HardTabs);
 	
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_INDENT_SIZE, "Indent Size"), IDM_INDENT_SIZE, true);
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_TAB_SIZE, "Tab Size"), IDM_TAB_SIZE, true);
 
 	if (Environment)
 		Environment->AppendItems(&RClick, NULL);
 
 	int Id = 0;
 	m.ToScreen();
 	switch (Id = RClick.Float(this, m))
 	{
 		case IDM_FIXED:
 		{
 			SetFixedWidthFont(!GetFixedWidthFont());							
 			SendNotify(LNotifyFixedWidthChanged);
 			break;
 		}
 		case IDM_CUT:
 		{
 			Cut();
 			break;
 		}
 		case IDM_COPY:
 		{
 			Copy();
 			break;
 		}
 		case IDM_PASTE:
 		{
 			Paste();
 			break;
 		}
 		case IDM_COPY_ALL:
 		{
 			SelectAll();
 			Copy();
 			break;
 		}
 		case IDM_SELECT_ALL:
 		{
 			SelectAll();
 			break;
 		}
 		case IDM_UNDO:
 		{
 			Undo();
 			break;
 		}
 		case IDM_REDO:
 		{
 			Redo();
 			break;
 		}
 		case IDM_AUTO_INDENT:
 		{
 			AutoIndent = !AutoIndent;
 			break;
 		}
 		case IDM_SHOW_WHITE:
 		{
 			ShowWhiteSpace = !ShowWhiteSpace;
 			Invalidate();
 			break;
 		}
 		case IDM_HARD_TABS:
 		{
 			HardTabs = !HardTabs;
 			break;
 		}
 		case IDM_INDENT_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", IndentSize);
 			
 			LInput *i = new LInput(this, s, "Indent Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
 				if (code)
 					IndentSize = atoi(i->GetStr());
 				delete i;
 			});
 			break;
 		}
 		case IDM_TAB_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", TabSize);
 			
 			LInput *i = new LInput(this, s, "Tab Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
-				SetTabSize(atoi(i->GetStr()));
+				if (code)
+					SetTabSize((uint8_t)Atoi(i->GetStr().Get()));
 				delete i;
 			});
 			break;
 		}
 		default:
 		{
 			if (s)
 			{
 				OnStyleMenuClick(s, Id);
 			}
 
 			if (Environment)
 			{
 				Environment->OnMenu(this, Id, 0);
 			}
 			break;
 		}
 	}
 }
 
 bool LTextView3::OnStyleClick(LStyle *style, LMouse *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			if
 			(
 				(!m)
 				||
 				(m->Left() && m->Down() && m->Double())
 			)
 			{
 				LString s(Text + style->Start, style->Len);
 				if (s)
 					OnUrl(s);
 				return true;
 			}
 			break;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 bool LTextView3::OnStyleMenu(LStyle *style, LSubMenu *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 			if (LIsValidEmail(s))
 				m->AppendItem(LLoadString(L_TEXTCTRL_EMAIL_TO, "New Email to..."), IDM_NEW, true);
 			else
 				m->AppendItem(LLoadString(L_TEXTCTRL_OPENURL, "Open URL"), IDM_OPEN, true);
 
 			m->AppendItem(LLoadString(L_TEXTCTRL_COPYLINK, "Copy link location"), IDM_COPY_URL, true);
 			return true;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 void LTextView3::OnStyleMenuClick(LStyle *style, int i)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 
 			switch (i)
 			{
 				case IDM_NEW:
 				case IDM_OPEN:
 				{
 					if (s)
 						OnUrl(s);
 					break;
 				}
 				case IDM_COPY_URL:
 				{
 					if (s)
 					{
 						LClipBoard Clip(this);
 						Clip.Text(s);
 					}
 					break;
 				}
 			}
 			break;
 		}
 		default:
 			break;
 	}
 }
 
 void LTextView3::OnMouseClick(LMouse &m)
 {
 	bool Processed = false;
 
 	m.x += ScrollX;
 
 	if (m.Down())
 	{
 		if (m.IsContextMenu())
 		{
 			DoContextMenu(m);
 			return;
 		}
 		else if (m.Left())
 		{
 			Focus(true);
 
 			ssize_t Hit = HitText(m.x, m.y, true);
 			if (Hit >= 0)
 			{
 				SetCaret(Hit, m.Shift());
 
 				LStyle *s = HitStyle(Hit);
 				if (s)
 					Processed = OnStyleClick(s, &m);
 			}
 
 			if (!Processed && m.Double())
 			{
 				d->WordSelectMode = Cursor;
 				SelectWord(Cursor);
 			}
 			else
 			{
 				d->WordSelectMode = -1;
 			}
 		}
 	}
 
 	if (!Processed)
 	{
 		Capture(m.Down());
 	}
 }
 
 int LTextView3::OnHitTest(int x, int y)
 {
 	#ifdef WIN32
 	if (GetClient().Overlap(x, y))
 	{
 		return HTCLIENT;
 	}
 	#endif
 	return LView::OnHitTest(x, y);
 }
 
 void LTextView3::OnMouseMove(LMouse &m)
 {
 	m.x += ScrollX;
 
 	ssize_t Hit = HitText(m.x, m.y, true);
 	if (IsCapturing())
 	{
 		if (d->WordSelectMode < 0)
 		{
 			SetCaret(Hit, m.Left());
 		}
 		else
 		{
 			ssize_t Min = Hit < d->WordSelectMode ? Hit : d->WordSelectMode;
 			ssize_t Max = Hit > d->WordSelectMode ? Hit : d->WordSelectMode;
 
 			for (SelStart = Min; SelStart > 0; SelStart--)
 			{
 				if (strchr(SelectWordDelim, Text[SelStart]))
 				{
 					SelStart++;
 					break;
 				}
 			}
 
 			for (SelEnd = Max; SelEnd < Size; SelEnd++)
 			{
 				if (strchr(SelectWordDelim, Text[SelEnd]))
 				{
 					break;
 				}
 			}
 
 			Cursor = SelEnd;
 			Invalidate();
 		}
 	}
 }
 
 LCursor LTextView3::GetCursor(int x, int y)
 {
 	LRect c = GetClient();
 	c.Offset(-c.x1, -c.y1);
 	LStyle *s = NULL;
 	if (c.Overlap(x, y))
 	{
 		ssize_t Hit = HitText(x, y, true);
 		s = HitStyle(Hit);
 	}
 
 	return s ? s->Cursor : LCUR_Ibeam;
 }
 
 int LTextView3::GetColumn()
 {
 	int x = 0;
 	LTextLine *l = GetTextLine(Cursor);
 	if (l)
 	{
 		for (ssize_t i=l->Start; i<Cursor; i++)
 		{
 			if (Text[i] == '\t')
 			{
 				x += TabSize - (x % TabSize);
 			}
 			else
 			{
 				x++;
 			}
 		}
 	}
 	return x;
 }
 
 int LTextView3::SpaceDepth(char16 *Start, char16 *End)
 {
 	int Depth = 0;
 	while (Start < End)
 	{
 		if (*Start == '\t')
 			Depth += IndentSize - (Depth % IndentSize);
 		else if (*Start == ' ')
 			Depth ++;
 		else break;
 		Start++;
 	}
 	return Depth;
 }
 
 bool LTextView3::OnKey(LKey &k)
 {
 	if (k.Down())
 	{
 		Blink = true;
 	}
 
 	// k.Trace("LTextView3::OnKey");
 
 	if (k.IsContextMenu())
 	{
 		LMouse m;
 		m.x = CursorPos.x1;
 		m.y = CursorPos.y1 + (CursorPos.Y() >> 1);
 		m.Target = this;
 		DoContextMenu(m);
 	}
 	else if (k.IsChar)
 	{
 		switch (k.vkey)
 		{
 			default:
 			{
 				// process single char input
 				if
 				(
 					!GetReadOnly()
 					&&
 					(
 						(k.c16 >= ' ' || k.vkey == LK_TAB)
 						&&
 						k.c16 != 127
 					)
 				)
 				{
 					if (k.Down())
 					{
 						// letter/number etc
 						if (SelStart >= 0)
 						{
 							bool MultiLine = false;
 							if (k.vkey == LK_TAB)
 							{
 								size_t Min = MIN(SelStart, SelEnd), Max = MAX(SelStart, SelEnd);
 								for (size_t i=Min; i<Max; i++)
 								{
 									if (Text[i] == '\n')
 									{
 										MultiLine = true;
 									}
 								}
 							}
 							if (MultiLine)
 							{
 								if (OnMultiLineTab(k.Shift()))
 								{
 									return true;
 								}
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						
 						LTextLine *l = GetTextLine(Cursor);
 						size_t Len = (l) ? l->Len : 0;
 						
 						if (l && k.vkey == LK_TAB && (!HardTabs || IndentSize != TabSize))
 						{
 							int x = GetColumn();							
 							int Add = IndentSize - (x % IndentSize);
 							
 							if (HardTabs && ((x + Add) % TabSize) == 0)
 							{
 								int Rx = x;
 								size_t Remove;
 								for (Remove = Cursor; Text[Remove - 1] == ' ' && Rx % TabSize != 0; Remove--, Rx--);
 								ssize_t Chars = (ssize_t)Cursor - Remove;
 								Delete(Remove, Chars);
 								Insert(Remove, &k.c16, 1);
 								Cursor = Remove + 1;
 								
 								Invalidate();
 							}
 							else
 							{							
 								char16 *Sp = new char16[Add];
 								if (Sp)
 								{
 									for (int n=0; n<Add; n++) Sp[n] = ' ';
 									if (Insert(Cursor, Sp, Add))
 									{
 										l = GetTextLine(Cursor);
 										size_t NewLen = (l) ? l->Len : 0;
 										SetCaret(Cursor + Add, false, Len != NewLen - 1);
 									}
 									DeleteArray(Sp);
 								}
 							}
 						}
 						else
 						{
 							char16 In = k.GetChar();
 
 							if (In == '\t' &&
 								k.Shift() &&
 								Cursor > 0)
 							{
 								l = GetTextLine(Cursor);
 								if (Cursor > l->Start)
 								{
 									if (Text[Cursor-1] == '\t')
 									{
 										Delete(Cursor - 1, 1);
 										SetCaret(Cursor, false, false);
 									}
 									else if (Text[Cursor-1] == ' ')
 									{
 										ssize_t Start = (ssize_t)Cursor - 1;
 										while (Start >= l->Start && strchr(" \t", Text[Start-1]))
 											Start--;
 										int Depth = SpaceDepth(Text + Start, Text + Cursor);
 										int NewDepth = Depth - (Depth % IndentSize);
 										if (NewDepth == Depth && NewDepth > 0)
 											NewDepth -= IndentSize;
 										int Use = 0;
 										while (SpaceDepth(Text + Start, Text + Start + Use + 1) < NewDepth)
 											Use++;
 										Delete(Start + Use, Cursor - Start - Use);
 										SetCaret(Start + Use, false, false);
 									}
 								}
 								
 							}
 							else if (In && Insert(Cursor, &In, 1))
 							{
 								l = GetTextLine(Cursor);
 								size_t NewLen = (l) ? l->Len : 0;
 								SetCaret(Cursor + 1, false, Len != NewLen - 1);
 							}
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			case LK_RETURN:
 			#if defined MAC
 			case LK_KEYPADENTER:
 			#endif
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Down() && k.IsChar)
 				{
 					OnEnter(k);
 				}
 				return true;
 				break;
 			}
 			case LK_BACKSPACE:
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Ctrl())
 				{
 				    // Ctrl+H
 				}
 				else if (k.Down())
 				{
 					if (SelStart >= 0)
 					{
 						// delete selection
 						DeleteSelection();
 					}
 					else
 					{						
 						char Del = Cursor > 0 ? Text[Cursor-1] : 0;
 						
 						if (Del == ' ' && (!HardTabs || IndentSize != TabSize))
 						{
 							// Delete soft tab
 							int x = GetColumn();
 							int Max = x % IndentSize;
 							if (Max == 0) Max = IndentSize;
 							ssize_t i;
 							for (i=Cursor-1; i>=0; i--)
 							{
 								if (Max-- <= 0 || Text[i] != ' ')
 								{
 									i++;
 									break;
 								}
 							}
 							
 							if (i < 0) i = 0;
 							
 							if (i < Cursor - 1)
 							{
 								ssize_t Del = (ssize_t)Cursor - i;
 								Delete(i, Del);
 								// SetCursor(i, false, false);
 								// Invalidate();
 								break;
 							}
 						}
 						else if (Del == '\t' && HardTabs && IndentSize != TabSize)
 						{
 							int x = GetColumn();
 							Delete(--Cursor, 1);
 							
 							for (int c=GetColumn(); c<x-IndentSize; c=GetColumn())
 							{
 								int Add = IndentSize + (c % IndentSize);
 								if (Add)
 								{
 									char16 *s = new char16[Add];
 									if (s)
 									{
 										for (int n=0; n<Add; n++) s[n] = ' ';
 										Insert(Cursor, s, Add);
 										Cursor += Add;
 										DeleteArray(s);
 									}
 								}
 								else break;
 							}
 							
 							Invalidate();
 							break;
 						}
 
 
 						if (Cursor > 0)
 						{
 							Delete(Cursor - 1, 1);
 						}
 					}
 				}
 				return true;
 				break;
 			}
 		}
 	}
 	else // not a char
 	{
 		switch (k.vkey)
 		{
 			case LK_TAB:
 				return true;
 			case LK_RETURN:
 			{
 				return !GetReadOnly();
 			}
 			case LK_BACKSPACE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Alt())
 					{
 						if (k.Down())
 						{
 							if (k.Ctrl())
 							{
 								Redo();
 							}
 							else
 							{
 								Undo();
 							}
 						}
 					}
 					else if (k.Ctrl())
 					{
 						if (k.Down())
 						{
 							ssize_t Start = Cursor;
 							while (IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							while (!IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							Delete(Cursor, Start - Cursor);
 							Invalidate();
 						}
 					}
 
 					return true;
 				}
 				break;
 			}
 			case LK_F3:
 			{
 				if (k.Down())
 				{
 					DoFindNext(NULL);
 				}
 				return true;
 				break;
 			}
 			case LK_LEFT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MIN(SelStart, SelEnd), false);
 					}
 					else if (Cursor > 0)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_StartOfLine;
 						}
 						else
 						if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							bool StartWhiteSpace = IsWhiteSpace(Text[n]);
 							bool LeftWhiteSpace = n > 0 && IsWhiteSpace(Text[n-1]);
 
 							if (!StartWhiteSpace ||
 								Text[n] == '\n')
 							{
 								n--;
 							}
 							
 							// Skip ws
 							for (; n > 0 && strchr(" \t", Text[n]); n--)
 								;
 							
 							if (Text[n] == '\n')
 							{
 								n--;
 							}
 							else if (!StartWhiteSpace || !LeftWhiteSpace)
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									for (; n > 0 && IsDelimiter(Text[n]); n--);
 								}
 								else
 								{
 									for (; n > 0; n--)
 									{
 										//IsWordBoundry(Text[n])
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 							}
 							if (n > 0) n++;
 						}
 						else
 						{
 							// single char
 							n--;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_RIGHT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MAX(SelStart, SelEnd), false);
 					}
 					else if (Cursor < Size)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_EndOfLine;
 						}
 						else if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							if (IsWhiteSpace(Text[n]))
 							{
 								for (; n<Size && IsWhiteSpace(Text[n]); n++);
 							}
 							else
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									while (IsDelimiter(Text[n]))
 									{
 										n++;
 									}
 								}
 								else
 								{
 									for (; n<Size; n++)
 									{
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 
 								if (n < Size &&
 									Text[n] != '\n')
 								{
 									if (IsWhiteSpace(Text[n]))
 									{
 										n++;
 									}
 								}
 							}
 						}
 						else
 						{
 							// single char
 							n++;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_UP:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView3_PageUp;
 					#endif
 					
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It--;
 						if (It != Line.end())
 						{
 							LTextLine *Prev = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 
 							LDisplayString PrevLine(Font, Text + Prev->Start, Prev->Len);
 							ssize_t CharX = PrevLine.CharAt(ScreenX);
 
 							SetCaret(Prev->Start + MIN(CharX, Prev->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DOWN:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView3_PageDown;
 					#endif
 
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It++;
 						if (It != Line.end())
 						{
 							LTextLine *Next = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 							
 							LDisplayString NextLine(Font, Text + Next->Start, Next->Len);
 							ssize_t CharX = NextLine.CharAt(ScreenX);
 
 							SetCaret(Next->Start + MIN(CharX, Next->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_END:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(Size, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_EndOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							SetCaret(l->Start + l->Len, k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_HOME:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(0, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_StartOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							char16 *Line = Text + l->Start;
 							char16 *s;
 							char16 SpTab[] = {' ', '\t', 0};
 							for (s = Line; (SubtractPtr(s,Line) < l->Len) && StrchrW(SpTab, *s); s++);
 							ssize_t Whitespace = SubtractPtr(s, Line);
 
 							if (l->Start + Whitespace == Cursor)
 							{
 								SetCaret(l->Start, k.Shift());
 							}
 							else
 							{
 								SetCaret(l->Start + Whitespace, k.Shift());
 							}
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEUP:
 			{
 				#ifdef MAC
 				LTextView3_PageUp:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MAX(CurLine - DisplayLines, 0));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEDOWN:
 			{
 				#ifdef MAC
 				LTextView3_PageDown:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MIN(CurLine + DisplayLines, (ssize_t)GetLines()-1));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_INSERT:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						Copy();
 					}
 					else if (k.Shift())
 					{
 						if (!GetReadOnly())
 						{
 							Paste();
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DELETE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Down())
 					{
 						if (SelStart >= 0)
 						{
 							if (k.Shift())
 							{
 								Cut();
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						else if (Cursor < Size &&
 								Delete(Cursor, 1))
 						{
 							Invalidate();
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			default:
 			{
 				if (k.c16 == 17) break;
 
 				if (k.CtrlCmd() &&
 					!k.Alt())
 				{
 					switch (k.GetChar())
 					{
 						case 0xbd: // Ctrl+'-'
 						{
 							if (k.Down() &&
 								Font->PointSize() > 1)
 							{
 								Font->PointSize(Font->PointSize() - 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 0xbb: // Ctrl+'+'
 						{
 							if (k.Down() &&
 								Font->PointSize() < 100)
 							{
 								Font->PointSize(Font->PointSize() + 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 'a':
 						case 'A':
 						{
 							if (k.Down())
 							{
 								// select all
 								SelStart = 0;
 								SelEnd = Size;
 								Invalidate();
 							}
 							return true;
 							break;
 						}
 						case 'y':
 						case 'Y':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Redo();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'z':
 						case 'Z':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									if (k.Shift())
 									{
 										Redo();
 									}
 									else
 									{
 										Undo();
 									}
 								}
 								return true;
 							}
 							break;
 						}
 						case 'x':
 						case 'X':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Cut();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'c':
 						case 'C':
 						{
 							if (k.Shift())
 								return false;
 							
 							if (k.Down())
 								Copy();
 							return true;
 							break;
 						}
 						case 'v':
 						case 'V':
 						{
 							if (!k.Shift() &&
 								!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Paste();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'f':
 						{
 							if (k.Down())
-							{
 								DoFind(NULL);
-							}
 							return true;
 							break;
 						}
 						case 'g':
 						case 'G':
 						{
 							if (k.Down())
 							{
 								DoGoto(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'h':
 						case 'H':
 						{
 							if (k.Down())
 							{
 								DoReplace(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'u':
 						case 'U':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									DoCase(NULL, k.Shift());
 								}
 								return true;
 							}
 							break;
 						}
 						case LK_RETURN:
 						{
 							if (!GetReadOnly() && !k.Shift())
 							{
 								if (k.Down())
 								{
 									OnEnter(k);
 								}
 								return true;
 							}
 							break;
 						}
 					}
 				}
 				break;
 			}
 		}
 	}
 	
 	return false;
 }
 
 void LTextView3::OnEnter(LKey &k)
 {
 	// enter
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	char16 InsertStr[256] = {'\n', 0};
 
 	LTextLine *CurLine = GetTextLine(Cursor);
 	if (CurLine && AutoIndent)
 	{
 		int WsLen = 0;
 		for (;	WsLen < CurLine->Len &&
 				WsLen < (Cursor - CurLine->Start) &&
 				strchr(" \t", Text[CurLine->Start + WsLen]); WsLen++);
 		if (WsLen > 0)
 		{
 			memcpy(InsertStr+1, Text+CurLine->Start, WsLen * sizeof(char16));
 			InsertStr[WsLen+1] = 0;
 		}
 	}
 
 	if (Insert(Cursor, InsertStr, StrlenW(InsertStr)))
 	{
 		SetCaret(Cursor + StrlenW(InsertStr), false, true);
 	}
 }
 
 int LTextView3::TextWidth(LFont *f, char16 *s, int Len, int x, int Origin)
 {
 	int w = x;
 	int Size = f->TabSize();
 
 	for (char16 *c = s; SubtractPtr(c, s) < Len; )
 	{
 		if (*c == 9)
 		{			
 			w = ((((w-Origin) + Size) / Size) * Size) + Origin;
 			c++;
 		}
 		else
 		{
 			char16 *e;
 			for (e = c; SubtractPtr(e, s) < Len && *e != 9; e++);
 			
 			LDisplayString ds(f, c, SubtractPtr(e, c));
 			w += ds.X();
 			c = e;
 		}
 	}
 
 	return w - x;
 }
 
 int LTextView3::ScrollYLine()
 {
 	return (VScroll) ? (int)VScroll->Value() : 0;
 }
 
 int LTextView3::ScrollYPixel()
 {
 	return ScrollYLine() * LineY;
 }
 
 LRect LTextView3::DocToScreen(LRect r)
 {
 	r.Offset(0, d->rPadding.y1 - ScrollYPixel());
 	return r;
 }
 
 void LTextView3::OnPaintLeftMargin(LSurface *pDC, LRect &r, LColour &colour)
 {
 	pDC->Colour(colour);
 	pDC->Rectangle(&r);
 }
 
 void LTextView3::OnPaint(LSurface *pDC)
 {
 	#if LGI_EXCEPTIONS
 	try
 	{
 	#endif
 
 	#if DOUBLE_BUFFER_PAINT
 	LDoubleBuffer MemBuf(pDC);
 	#endif
 
 	#if PROFILE_PAINT
 	char s[256];
 	sprintf_s(s, sizeof(s), "%p::OnPaint Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(s);
 	#endif
 
 		if (d->LayoutDirty)
 		{
 	#if PROFILE_PAINT
 	Prof.Add("PourText");
 	#endif
 			PourText(d->DirtyStart, d->DirtyLen);
 	#if PROFILE_PAINT
 	Prof.Add("PourStyle");
 	#endif
 			PourStyle(d->DirtyStart, d->DirtyLen);
 			
 			d->LayoutDirty = false;
 		}
 
 	#if PROFILE_PAINT
 	Prof.Add("Setup");
 	#endif
 		
 		LRect r = GetClient();
 		r.x2 += ScrollX;
 
 		int Ox, Oy;
 		pDC->GetOrigin(Ox, Oy);
 		pDC->SetOrigin(Ox+ScrollX, Oy);
 		
 		#if 0
 		// Coverage testing...
 		pDC->Colour(Rgb24(255, 0, 255), 24);
 		pDC->Rectangle();
 		#endif
 
 		LSurface *pOut = pDC;
 		bool DrawSel = false;
 		
 		bool HasFocus = Focus();
 		// printf("%s:%i - HasFocus = %i\n", _FL, HasFocus);
 		LColour SelectedText(HasFocus ? LColour(L_FOCUS_SEL_FORE) : LColour(L_NON_FOCUS_SEL_FORE));
 		LColour SelectedBack(HasFocus ? LColour(L_FOCUS_SEL_BACK) : LColour(L_NON_FOCUS_SEL_BACK));
 
 		LCss::ColorDef ForeDef, BkDef;
 		if (GetCss())
 		{
 			ForeDef = GetCss()->Color();
 			BkDef = GetCss()->BackgroundColor();
 		}
 		
 		LColour Fore(ForeDef.Type ==  LCss::ColorRgb ? LColour(ForeDef.Rgb32, 32) : LColour(L_TEXT));
 		LColour Back
 		(
 			/*!ReadOnly &&*/ BkDef.Type == LCss::ColorRgb
 			?
 			LColour(BkDef.Rgb32, 32)
 			:
 			Enabled() ? LColour(L_WORKSPACE) : LColour(L_MED)
 		);
 
 		// LColour Whitespace = Fore.Mix(Back, 0.85f);
 		if (!Enabled())
 		{
 			Fore = LColour(L_LOW);
 			Back = LColour(L_MED);
 		}
 
 		if (Text &&
 			Font)
 		{
 			ssize_t SelMin = MIN(SelStart, SelEnd);
 			ssize_t SelMax = MAX(SelStart, SelEnd);
 
 			// font properties
 			Font->Colour(Fore, Back);
 			// Font->WhitespaceColour(Whitespace);
 			Font->Transparent(false);
 
 			// draw margins
 			pDC->Colour(PAINT_BORDER);
 			// top margin
 			pDC->Rectangle(0, 0, r.x2, d->rPadding.y1-1);
 			// left margin
 			{
 				LRect LeftMargin(0, d->rPadding.y1, d->rPadding.x1-1, r.y2);
 				OnPaintLeftMargin(pDC, LeftMargin, PAINT_BORDER);
 			}
 		
 			// draw lines of text
 			int k = ScrollYLine();
 			auto It = Line.begin(k);
 			LTextLine *l = NULL;
 			int Dy = 0;
 			if (It != Line.end())
 				Dy = -(*It)->r.y1;
 			ssize_t NextSelection = (SelStart != SelEnd) ? SelMin : -1; // offset where selection next changes
 			if (It != Line.end() &&
 				(l = *It) &&
 				SelStart >= 0 &&
 				SelStart < l->Start &&
 				SelEnd > l->Start)
 			{
 				// start of visible area is in selection
 				// init to selection colour
 				DrawSel = true;
 				Font->Colour(SelectedText, SelectedBack);
 				NextSelection = SelMax;
 			}
 
 			StyleIter Si = Style.begin();
 			LStyle *NextStyle = GetNextStyle(Si, (l) ? l->Start : 0);
 
 			DocOffset = (l) ? l->r.y1 : 0;
 
 	#if PROFILE_PAINT
 	Prof.Add("foreach Line loop");
 	#endif
 			// loop through all visible lines
 			int y = d->rPadding.y1;
 			while ((l = *It) &&
 					l->r.y1+Dy < r.Y())
 			{
 				LRect Tr = l->r;
 				Tr.Offset(0, y - Tr.y1);
 				//LRect OldTr = Tr;
 
 				// deal with selection change on beginning of line
 				if (NextSelection == l->Start)
 				{
 					// selection change
 					DrawSel = !DrawSel;
 					NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 				}
 				if (DrawSel)
 				{
 					Font->Colour(SelectedText, SelectedBack);
 				}
 				else
 				{
 					LColour fore = l->c.IsValid() ? l->c : Fore;
 					LColour back = l->Back.IsValid() ? l->Back : Back;
 					Font->Colour(fore, back);
 				}
 
 				// How many chars on this line have we
 				// processed so far:
 				ssize_t Done = 0;
 				bool LineHasSelection =	NextSelection >= l->Start &&
 										NextSelection < l->Start + l->Len;
 
 				// Fractional pixels we have moved so far:
 				int MarginF = d->rPadding.x1 << LDisplayString::FShift;
 				int FX = MarginF;
 				int FY = Tr.y1 << LDisplayString::FShift;
 				
 				// loop through all sections of similar text on a line
 				while (Done < l->Len)
 				{
 					// decide how big this block is
 					int RtlTrailingSpace = 0;
 					ssize_t Cur = l->Start + Done;
 					ssize_t Block = l->Len - Done;
 					
 					// check for style change
 					if (NextStyle &&
 						(ssize_t)NextStyle->End() <= l->Start)
 						NextStyle = GetNextStyle(Si);
 					if (NextStyle)
 					{
 						// start
 						if (l->Overlap(NextStyle->Start) &&
 							NextStyle->Start > Cur &&
 							NextStyle->Start - Cur < Block)
 						{
 							Block = NextStyle->Start - Cur;
 						}
 
 						// end
 						ssize_t StyleEnd = NextStyle->Start + NextStyle->Len;
 						if (l->Overlap(StyleEnd) &&
 							StyleEnd > Cur &&
 							StyleEnd - Cur < Block)
 						{
 							Block = StyleEnd - Cur;
 						}
 					}
 
 					// check for next selection change
 					// this may truncate the style
 					if (NextSelection > Cur &&
 						NextSelection - Cur < Block)
 					{
 						Block = NextSelection - Cur;
 					}
 
 					LAssert(Block != 0);	// sanity check
 					
 					if (NextStyle &&							// There is a style
 						(Cur < SelMin || Cur >= SelMax) &&		// && we're not drawing a selection block
 						Cur >= NextStyle->Start &&				// && we're inside the styled area
 						Cur < NextStyle->Start+NextStyle->Len)
 					{
 						LFont *Sf = NextStyle->Font ? NextStyle->Font : Font;
 						if (Sf)
 						{
 							// draw styled text
 							if (NextStyle->Fore.IsValid())
 								Sf->Fore(NextStyle->Fore);
 							if (NextStyle->Back.IsValid())
 								Sf->Back(NextStyle->Back);
 							else if (l->Back.IsValid())
 								Sf->Back(l->Back);
 							else
 								Sf->Back(Back);								
 
 							Sf->Transparent(false);
 
 							LAssert(l->Start + Done >= 0);
 
 							LDisplayString Ds(	Sf,
 												MapText(Text + (l->Start + Done),
 														Block,
 														RtlTrailingSpace != 0),
 												Block + RtlTrailingSpace);
 							Ds.SetDrawOffsetF(FX - MarginF);
 							Ds.ShowVisibleTab(ShowWhiteSpace);
 							Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 
 							if (NextStyle->Decor == LCss::TextDecorSquiggle)
 							{
 								pOut->Colour(NextStyle->DecorColour);
 								int x = FX >> LDisplayString::FShift;
 								int End = x + Ds.X();
 								while (x < End)
 								{
 									pOut->Set(x, Tr.y2-(x%2));
 									x++;
 								}
 							}
 
 							FX += Ds.FX();
 
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Sf->Colour(fore, back);
 						}
 						else LAssert(0);
 					}
 					else
 					{
 						// draw a block of normal text
 						LAssert(l->Start + Done >= 0);
 						
 						LDisplayString Ds(	Font,
 											MapText(Text + (l->Start + Done),
 													Block,
 													RtlTrailingSpace != 0),
 											Block + RtlTrailingSpace);
 						Ds.SetDrawOffsetF(FX - MarginF);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 						FX += Ds.FX();
 					}
 
 					if (NextStyle &&
 						Cur+Block >= NextStyle->Start+NextStyle->Len)
 					{
 						// end of this styled block
 						NextStyle = GetNextStyle(Si);
 					}
 
 					if (NextSelection == Cur+Block)
 					{
 						// selection change
 						DrawSel = !DrawSel;
 						if (DrawSel)
 						{
 							Font->Colour(SelectedText, SelectedBack);
 						}
 						else
 						{
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Font->Colour(fore, back);
 						}
 						NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 					}
 
 					Done += Block + RtlTrailingSpace;
 				
 				} // end block loop
 
 				Tr.x1 = FX >> LDisplayString::FShift;
 
 				// eol processing
 				ssize_t EndOfLine = l->Start+l->Len;
 				if (EndOfLine >= SelMin && EndOfLine < SelMax)
 				{
 					// draw the '\n' at the end of the line as selected
 					// LColour bk = Font->Back();
 					pOut->Colour(Font->Back());
 					pOut->Rectangle(Tr.x2, Tr.y1, Tr.x2+7, Tr.y2);
 					Tr.x2 += 7;
 				}
 				else Tr.x2 = Tr.x1;
 
 				// draw any space after text
 				pOut->Colour(PAINT_AFTER_LINE);
 				pOut->Rectangle(Tr.x2, Tr.y1, r.x2, Tr.y2);
 
 				// cursor?
 				if (HasFocus)
 				{
 					// draw the cursor if on this line
 					if (Cursor >= l->Start && Cursor <= l->Start+l->Len)
 					{
 						CursorPos.ZOff(1, LineY-1);
 
 						ssize_t At = Cursor-l->Start;
 						
 						LDisplayString Ds(Font, MapText(Text+l->Start, At), At);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						int CursorX = Ds.X();
 						CursorPos.Offset(d->rPadding.x1 + CursorX, Tr.y1);
 						
 						if (CanScrollX)
 						{
 							// Cursor on screen check
 							LRect Scr = GetClient();
 							Scr.Offset(ScrollX, 0);
 							LRect Cur = CursorPos;
 							if (Cur.x2 > Scr.x2 - 5) // right edge check
 							{
 								ScrollX = ScrollX + Cur.x2 - Scr.x2 + 40;
 								Invalidate();
 							}
 							else if (Cur.x1 < Scr.x1 && ScrollX > 0)
 							{
 								ScrollX = MAX(0, Cur.x1 - 40);
 								Invalidate();
 							}
 						}
 
 						if (Blink)
 						{
 							LRect c = CursorPos;
 
 							pOut->Colour(!ReadOnly ? Fore : LColour(192, 192, 192));
 							pOut->Rectangle(&c);
 						}
 
 						#if WINNATIVE
 						HIMC hIMC = ImmGetContext(Handle());
 						if (hIMC)
 						{
 							COMPOSITIONFORM Cf;						
 							Cf.dwStyle = CFS_POINT;
 							Cf.ptCurrentPos.x = CursorPos.x1;
 							Cf.ptCurrentPos.y = CursorPos.y1;
 							ImmSetCompositionWindow(hIMC, &Cf);
 							ImmReleaseContext(Handle(), hIMC);
 						}
 						#endif
 					}
 				}
 
 				#if DRAW_LINE_BOXES
 				{
 					uint Style = pDC->LineStyle(LSurface::LineAlternate);
 					LColour Old = pDC->Colour(LColour::Red);
 					pDC->Box(&OldTr);
 					pDC->Colour(Old);
 					pDC->LineStyle(Style);
 
 					LString s;
 					s.Printf("%i, %i", Line.IndexOf(l), l->Start);
 					LDisplayString ds(LSysFont, s);
 					LSysFont->Transparent(true);
 					ds.Draw(pDC, OldTr.x2 + 2, OldTr.y1);
 				}
 				#endif
 
 				y += LineY;
 
 				It++;
 
 			} // end of line loop
 
 			// draw any space under the lines
 			if (y <= r.y2)
 			{
 				pDC->Colour(Back);
 				// pDC->Colour(LColour(255, 0, 255));
 				pDC->Rectangle(d->rPadding.x1, y, r.x2, r.y2);
 			}
 		}
 		else
 		{
 			// default drawing: nothing
 			pDC->Colour(Back);
 			pDC->Rectangle(&r);
 		}
 
 		// _PaintTime = LCurrentTime() - StartTime;
 		#ifdef PAINT_DEBUG
 		if (GetNotify())
 		{
 			char s[256];
 			sprintf_s(s, sizeof(s), "Pour:%i Style:%i Paint:%i ms", _PourTime, _StyleTime, _PaintTime);
 			LMessage m = CreateMsg(DEBUG_TIMES_MSG, 0, (int)s);
 			GetNotify()->OnEvent(&m);
 		}
 		#endif
 		// printf("PaintTime: %ims\n", _PaintTime);
 	
 	#if LGI_EXCEPTIONS
 	}
 	catch (...)
 	{
 		LgiMsg(this, "LTextView3::OnPaint crashed.", "Lgi");
 	}
 	#endif
 }
 
 LMessage::Result LTextView3::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_TEXT_UPDATE_NAME:
 		{
 			if (d->Lock(_FL))
 			{
 				Name(d->SetName);
 				d->SetName.Empty();
 				d->Unlock();
 			}
 			break;
 		}
 		case M_TEXTVIEW_FIND:
 		{
 			if (InThread())
 				DoFindNext(NULL);
 			else
 				LgiTrace("%s:%i - Not in thread.\n", _FL);
 			break;
 		}
 		case M_TEXTVIEW_REPLACE:
 		{
 			// DoReplace();
 			break;
 		}
 		case M_CUT:
 		{
 			Cut();
 			break;
 		}
 		case M_COPY:
 		{
 			Copy();
 			break;
 		}
 		case M_PASTE:
 		{
 			Paste();
 			break;
 		}
 		#if defined WIN32
 		case WM_GETTEXTLENGTH:
 		{
 			return Size;
 		}
 		case WM_GETTEXT:
 		{
 			int Chars = (int)Msg->A();
 			char *Out = (char*)Msg->B();
 			if (Out)
 			{
 				char *In = (char*)LNewConvertCp(LAnsiToLgiCp(), NameW(), LGI_WideCharset, Chars);
 				if (In)
 				{
 					int Len = (int)strlen(In);
 					memcpy(Out, In, Len);
 					DeleteArray(In);
 					return Len;
 				}
 			}
 			return 0;
 		}
 
 		/* This is broken... the IME returns garbage in the buffer. :(
 		case WM_IME_COMPOSITION:
 		{
 			if (Msg->b & GCS_RESULTSTR) 
 			{
 				HIMC hIMC = ImmGetContext(Handle());
 				if (hIMC)
 				{
 					int Size = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);
 					char *Buf = new char[Size];
 					if (Buf)
 					{
 						ImmGetCompositionString(hIMC, GCS_RESULTSTR, Buf, Size);
 
 						char16 *Utf = (char16*)LNewConvertCp(LGI_WideCharset, Buf, LAnsiToLgiCp(), Size);
 						if (Utf)
 						{
 							Insert(Cursor, Utf, StrlenW(Utf));
 							DeleteArray(Utf);
 						}
 
 						DeleteArray(Buf);
 					}
 
 					ImmReleaseContext(Handle(), hIMC);
 				}
 				return 0;
 			}
 			break;
 		}
 		*/
 		#endif
 	}
 
 	return LLayout::OnEvent(Msg);
 }
 
 int LTextView3::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (Ctrl->GetId() == IDC_VSCROLL && VScroll)
 	{
 		if (n.Type == LNotifyScrollBarCreate)
 		{
 			UpdateScrollBars();
 		}
 			
 		Invalidate();
 	}
 
 	return 0;
 }
 
 void LTextView3::InternalPulse()
 {
 	if (!ReadOnly)
 	{
 		uint64 Now = LCurrentTime();
 		if (!BlinkTs)
 			BlinkTs = Now;
 		else if (Now - BlinkTs > CURSOR_BLINK)
 		{
 			Blink = !Blink;
 
 			LRect p = CursorPos;
 			p.Offset(-ScrollX, 0);
 			Invalidate(&p);
 			BlinkTs = Now;
 		}
 	}
 
 	if (PartialPour)
 		PourText(Size, 0);
 }
 
 void LTextView3::OnPulse()
 {
 	#ifdef WINDOWS
 		InternalPulse();
 	#else
 		for (auto c: Ctrls)
 			c->InternalPulse();
 	#endif
 }
 
 void LTextView3::OnUrl(char *Url)
 {
 	if (Environment)
 		Environment->OnNavigate(this, Url);
 	else
 	{
 		LUri u(Url);
 		bool Email = LIsValidEmail(Url);
 		const char *Proto = Email ? "mailto" : u.sProtocol;
 		LString App = LGetAppForProtocol(Proto);
 		if (App)
 			LExecute(App, Url);
 		else
 			LgiMsg(this, "Failed to find application for protocol '%s'", "Error", MB_OK, Proto);
 	}
 }
 
 bool LTextView3::OnLayout(LViewLayoutInfo &Inf)
 {
 	Inf.Width.Min = 32;
 	Inf.Width.Max = -1;
 
 	Inf.Height.Min = (Font ? Font->GetHeight() : 18) + 4;
 	Inf.Height.Max = -1;
 
 	return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 class LTextView3_Factory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (_stricmp(Class, "LTextView3") == 0)
 		{
 			return new LTextView3(-1, 0, 0, 2000, 2000);
 		}
 
 		return 0;
 	}
 } TextView3_Factory;
diff --git a/src/common/Text/TextView4.cpp b/src/common/Text/TextView4.cpp
--- a/src/common/Text/TextView4.cpp
+++ b/src/common/Text/TextView4.cpp
@@ -1,5511 +1,5512 @@
 #ifdef WIN32
 #include <winsock2.h>
 #include <imm.h>
 #endif
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/TextView4.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ScrollBar.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Mail.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/DropFiles.h"
 #include "ViewPriv.h"
 
 #ifdef _DEBUG
 #define FEATURE_HILIGHT_ALL_MATCHES	1
 #else
 #define FEATURE_HILIGHT_ALL_MATCHES	0
 #endif
 
 #define DefaultCharset              "utf-8"
 #define SubtractPtr(a, b)			((a) - (b))
 
 #define GDCF_UTF8					-1
 #define POUR_DEBUG					0
 #define PROFILE_POUR				0
 #define PROFILE_PAINT				0
 #define DRAW_LINE_BOXES				0
 #define WRAP_POUR_TIMEOUT			90 // ms
 #define PULSE_TIMEOUT				250 // ms
 #define CURSOR_BLINK				1000 // ms
 
 #define ALLOC_BLOCK					64
 #define IDC_VS						1000
 
 enum Cmds
 {
 	IDM_COPY_URL = 100,
 	IDM_AUTO_INDENT,
 	IDM_UTF8,
 	IDM_PASTE_NO_CONVERT,
 	IDM_FIXED,
 	IDM_SHOW_WHITE,
 	IDM_HARD_TABS,
 	IDM_INDENT_SIZE,
 	IDM_TAB_SIZE,
 	IDM_DUMP,
 	IDM_RTL,
 	IDM_COPY_ALL,
 	IDM_SELECT_ALL,
 	#ifndef IDM_OPEN
 		IDM_OPEN,
 	#endif
 	#ifndef IDM_NEW
 		IDM_NEW,
 	#endif
 	#ifndef IDM_COPY
 		IDM_COPY,
 	#endif
 	#ifndef IDM_CUT
 		IDM_CUT,
 	#endif
 	#ifndef IDM_PASTE
 		IDM_PASTE,
 	#endif
 	#ifndef IDM_UNDO
 		IDM_UNDO,
 	#endif
 	#ifndef IDM_REDO
 		IDM_REDO,
 	#endif
 };
 
 #define PAINT_BORDER				Back
 #if DRAW_LINE_BOXES
 	#define PAINT_AFTER_LINE			LColour(240, 240, 240)
 #else
 	#define PAINT_AFTER_LINE			Back
 #endif
 
 #define CODEPAGE_BASE				100
 #define CONVERT_CODEPAGE_BASE		200
 
 #if !defined(WIN32) && !defined(toupper)
 #define toupper(c)					(((c)>='a'&&(c)<='z') ? (c)-'a'+'A' : (c))
 #endif
 
 #define THREAD_CHECK() \
 	if (!InThread()) \
 	{ \
 		LgiTrace("%s:%i - %s called out of thread.\n", _FL, __FUNCTION__); \
 		return false; \
 	}
 
 static char SelectWordDelim[] = " \t\n.,()[]<>=?/\\{}\"\';:+=-|!@#$%^&*";
 #ifndef WINDOWS
 static LArray<LTextView4*> Ctrls;
 #endif
 
 //////////////////////////////////////////////////////////////////////
 class GDocFindReplaceParams4 :
 	public LDocFindReplaceParams,
 	public LMutex
 {
 public:
 	// Find/Replace History
 	LAutoWString LastFind;
 	LAutoWString LastReplace;
 	bool MatchCase;
 	bool MatchWord;
 	bool SelectionOnly;
 	bool SearchUpwards;
 	
 	GDocFindReplaceParams4() : LMutex("GDocFindReplaceParams4")
 	{
 		MatchCase = false;
 		MatchWord = false;
 		SelectionOnly = false;
 		SearchUpwards = false;
 	}
 };
 
 class LTextView4Private : public LCss, public LMutex
 {
 public:
 	LTextView4 *View;
 	LRect rPadding;
 	int PourX;
 	bool LayoutDirty;
 	ssize_t DirtyStart, DirtyLen;
 	LColour UrlColour;
 	bool CenterCursor;
 	ssize_t WordSelectMode;
 	LString Eol;
 	LString LastError;
 	
 	// If the scroll position is set before we get a scroll bar, store the index
 	// here and set it when the LNotifyScrollBarCreate arrives.
 	ssize_t VScrollCache;
 
 	// Find/Replace Params
 	bool OwnFindReplaceParams;
 	GDocFindReplaceParams4 *FindReplaceParams;
 
 	// Map buffer
 	ssize_t MapLen;
 	char16 *MapBuf;
 
 	// <RequiresLocking>
 		// Thread safe Name(char*) impl
 		LString SetName;
 	// </RequiresLocking>
 
 	#ifdef _DEBUG
 	LString PourLog;
 	#endif
 
 	LTextView4Private(LTextView4 *view) : LMutex("LTextView4Private")
 	{
 		View = view;
 		WordSelectMode = -1;
 		PourX = -1;
 		VScrollCache = -1;
 		DirtyStart = DirtyLen = 0;
 		UrlColour.Rgb(0, 0, 255);		
 		LColour::GetConfigColour("colour.L_URL", UrlColour);
 
 		CenterCursor = false;
 		
 		LayoutDirty = true;
 		rPadding.ZOff(0, 0);
 		MapBuf = 0;
 		MapLen = 0;
 		
 		OwnFindReplaceParams = true;
 		FindReplaceParams = new GDocFindReplaceParams4;
 	}
 	
 	~LTextView4Private()
 	{
 		if (OwnFindReplaceParams)
 		{
 			DeleteObj(FindReplaceParams);
 		}
 		
 		DeleteArray(MapBuf);
 	}
 	
 	void SetDirty(ssize_t Start, ssize_t Len = 0)
 	{
 		LayoutDirty = true;
 		DirtyStart = Start;
 		DirtyLen = Len;
 	}
 
 	void OnChange(PropType Prop)
 	{
 		if (Prop == LCss::PropPadding ||
 			Prop == LCss::PropPaddingLeft ||
 			Prop == LCss::PropPaddingRight ||
 			Prop == LCss::PropPaddingTop ||
 			Prop == LCss::PropPaddingBottom)
 		{
 			LCssTools t(this, View->GetFont());
 			rPadding.ZOff(0, 0);
 			rPadding = t.ApplyPadding(rPadding);
 		}
 	}
 };
 
 //////////////////////////////////////////////////////////////////////
 enum UndoType
 {
 	UndoDelete, UndoInsert, UndoChange
 };
 
 struct Change : public LRange
 {
 	UndoType Type;
 	LArray<char16> Txt;
 };
 
 struct LTextView4Undo : public LUndoEvent
 {
 	LTextView4 *View;
 	LArray<Change> Changes;
 
 	LTextView4Undo(LTextView4 *view)
 	{
 		View = view;
 	}
 
 	void AddChange(ssize_t At, ssize_t Len, UndoType Type)
 	{
 		Change &c = Changes.New();
 		c.Start = At;
 		c.Len = Len;
 		c.Txt.Add(View->Text + At, Len);
 		c.Type = Type;
 	}
 
 	void OnChange()
 	{
 		for (auto &c : Changes)
 		{
 			size_t Len = c.Len;
 			if (View->Text)
 			{
 				char16 *t = View->Text + c.Start;
 				for (size_t i=0; i<Len; i++)
 				{
 					char16 n = c.Txt[i];
 					c.Txt[i] = t[i];
 					t[i] = n;
 				}
 			}
 
 			View->d->SetDirty(c.Start, c.Len);
 		}
 	}
 
 	// LUndoEvent
     void ApplyChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					View->Cursor = c.Start + c.Len;
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Delete(c.Start, c.Len);
 					View->Cursor = c.Start;
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();
 					break;
 				}
 			}
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 
     void RemoveChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Delete(c.Start, c.Len);
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();				
 					break;
 				}
 			}
 
 			View->Cursor = c.Start;
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 };
 
 void LTextView4::LStyle::RefreshLayout(size_t Start, ssize_t Len)
 {
 	View->PourText(Start, Len);
 	View->PourStyle(Start, Len);
 }
 
 //////////////////////////////////////////////////////////////////////
 LTextView4::LTextView4(	int Id,
 						int x, int y, int cx, int cy,
 						LFontType *FontType)
 	: ResObject(Res_Custom)
 {
 	// init vars
 	LView::d->Css.Reset(d = new LTextView4Private(this));
 	
 	PourEnabled = true;
 	PartialPour = false;
 	AdjustStylePos = true;
 	BlinkTs = 0;
 	LineY = 1;
 	MaxX = 0;
 	TextCache = 0;
 	UndoOn = true;
 	UndoCur = NULL;
 	Font = 0;
 	FixedWidthFont = false;
 	FixedFont = 0;
 	ShowWhiteSpace = false;
 	ObscurePassword = false;
 	TabSize = TAB_SIZE;
 	IndentSize = TAB_SIZE;
 	HardTabs = true;
 	CanScrollX = false;
 	Blink = true;
 
 	// setup window
 	SetId(Id);
 
 	// default options
 	Dirty = false;
 	#if WINNATIVE
 	CrLf = true;
 	SetDlgCode(DLGC_WANTALLKEYS);
 	#else
 	CrLf = false;
 	#endif
 	Underline = NULL;
 	Bold = NULL;
 	d->Padding(LCss::Len(LCss::LenPx, 2));
 
 	#ifdef _DEBUG
 	// debug times
 	_PourTime = 0;
 	_StyleTime = 0;
 	_PaintTime = 0;
 	#endif
 
 	// Data
 	Alloc = ALLOC_BLOCK;
 	Text = new char16[Alloc];
 	if (Text) *Text = 0;
 	Cursor = 0;
 	Size = 0;
 
 	// Display
 	SelStart = SelEnd = -1;
 	DocOffset = 0;
 	ScrollX = 0;
 
 	if (FontType)
 	{
 		Font = FontType->Create();
 	}
 	else
 	{
 		LFontType Type;
 		if (Type.GetSystemFont("Fixed"))
 			Font = Type.Create();
 		else
 			printf("%s:%i - failed to create font.\n", _FL);
 	}
 
 	if (Font)
 	{
 		SetTabStop(true);
 
 		Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 			Underline->Create();
 		}
 		Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 
 		OnFontChange();
 	}
 	else
 	{
 		LgiTrace("%s:%i - Failed to create font, FontType=%p\n", _FL, FontType);
 		Font = LSysFont;
 	}
 
 	CursorPos.ZOff(1, LineY-1);
 	CursorPos.Offset(d->rPadding.x1, d->rPadding.y1);
 
 	LRect r;
 	r.ZOff(cx-1, cy-1);
 	r.Offset(x, y);
 	SetPos(r);
 	LResources::StyleElement(this);
 }
 
 LTextView4::~LTextView4()
 {
 	#ifndef WINDOWS
 	Ctrls.Delete(this);
 	#endif
 	Line.DeleteObjects();
 	Style.Empty();
 
 	DeleteArray(TextCache);
 	DeleteArray(Text);
 
 	if (Font != LSysFont) DeleteObj(Font);
 	DeleteObj(FixedFont);
 	DeleteObj(Underline);
 	DeleteObj(Bold);
 	// 'd' is owned by the LView::Css auto ptr
 }
 
 char16 *LTextView4::MapText(char16 *Str, ssize_t Len, bool RtlTrailingSpace)
 {
 	if (ObscurePassword /*|| ShowWhiteSpace*/ || RtlTrailingSpace)
 	{
 		if (Len > d->MapLen)
 		{
 			DeleteArray(d->MapBuf);
 			d->MapBuf = new char16[Len + RtlTrailingSpace];
 			d->MapLen = Len;
 		}
 
 		if (d->MapBuf)
 		{
 			int n = 0;
 
 			if (RtlTrailingSpace)
 			{
 				d->MapBuf[n++] = ' ';
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = Str[i];
 				}
 			}
 			else if (ObscurePassword)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = '*';
 				}
 			}
 			/*
 			else if (ShowWhiteSpace)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					if (Str[i] == ' ')
 					{
 						d->MapBuf[n++] = 0xb7;
 					}
 					else if (Str[i] == '\t')
 					{
 						d->MapBuf[n++] = 0x2192;
 					}
 					else
 					{
 						d->MapBuf[n++] = Str[i];
 					}
 				}
 			}
 			*/			
 
 			return d->MapBuf;
 		}
 	}
 
 	return Str;
 }
 
 void LTextView4::SetFixedWidthFont(bool i)
 {
 	if (FixedWidthFont ^ i)
 	{
 		if (i)
 		{
 			LFontType Type;
 			if (Type.GetSystemFont("Fixed"))
 			{
 				LFont *f = FixedFont;
 				FixedFont = Font;
 				Font = f;
 
 				if (!Font)
 				{
 					Font = Type.Create();
 					if (Font)
 					{
 						Font->PointSize(FixedFont->PointSize());
 					}
 				}
 
 				LDocView::SetFixedWidthFont(i);
 			}
 		}
 		else if (FixedFont)
 		{
 			LFont *f = FixedFont;
 			FixedFont = Font;
 			Font = f;
 			LDocView::SetFixedWidthFont(i);
 		}
 
 		OnFontChange();
 		Invalidate();
 	}
 }
 
 void LTextView4::SetReadOnly(bool i)
 {
 	LDocView::SetReadOnly(i);
 
 	#if WINNATIVE
 	SetDlgCode(i ? DLGC_WANTARROWS : DLGC_WANTALLKEYS);
 	#endif
 }
 
 void LTextView4::SetCrLf(bool crlf)
 {
 	CrLf = crlf;
 }
 
 
 void LTextView4::SetTabSize(uint8_t i)
 {
 	TabSize = limit(i, 2, 32);
 	OnFontChange();
 	OnPosChange();
 	Invalidate();
 }
 
 void LTextView4::SetWrapType(LDocWrapType i)
 {
 	LDocView::SetWrapType(i);
 	CanScrollX = i != TEXTED_WRAP_REFLOW;
 
 	OnPosChange();
 	Invalidate();
 }
 
 LFont *LTextView4::GetFont()
 {
 	return Font;
 }
 
 LFont *LTextView4::GetBold()
 {
 	return Bold;
 }
 
 void LTextView4::SetFont(LFont *f, bool OwnIt)
 {
 	if (!f)
 		return;
 	
 	if (OwnIt)
 	{
 		if (Font != LSysFont)
 			DeleteObj(Font);
 		Font = f;
 	}
 	else if (!Font || Font == LSysFont)
 	{
 		Font = new LFont(*f);
 	}
 	else
 	{
 		*Font = *f;
 	}
 
 	if (Font)
 	{
 		if (!Underline)
 			Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 		}
 
 		if (!Bold)
 			Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 	}
 
 	OnFontChange();
 }
 
 void LTextView4::OnFontChange()
 {
 	if (Font)
 	{
 		// get line height
 		// int OldLineY = LineY;
 		if (!Font->Handle())
 			Font->Create();
 		LineY = Font->GetHeight();
 		if (LineY < 1) LineY = 1;
 
 		// get tab size
 		char Spaces[32];
 		memset(Spaces, 'A', TabSize);
 		Spaces[TabSize] = 0;
 		LDisplayString ds(Font, Spaces);
 		Font->TabSize(ds.X());
 
 		// repour doc
 		d->SetDirty(0, Size);
 
 		// validate blue underline font
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 		}
 
 		#if WINNATIVE // Set the IME font.
 		HIMC hIMC = ImmGetContext(Handle());
 		if (hIMC)
 		{
 			COMPOSITIONFORM Cf;						
 			Cf.dwStyle = CFS_POINT;
 			Cf.ptCurrentPos.x = CursorPos.x1;
 			Cf.ptCurrentPos.y = CursorPos.y1;
 
 			LOGFONT FontInfo;
 			GetObject(Font->Handle(), sizeof(FontInfo), &FontInfo);
 			ImmSetCompositionFont(hIMC, &FontInfo);
 
 			ImmReleaseContext(Handle(), hIMC);
 		}
 		#endif
 
 	}
 }
 
 void LTextView4::LogLines()
 {
 	int Idx = 0;
 	LStringPipe p;
 	p.Print("DocSize: %i\n", (int)Size);
 	for (auto i : Line)
 	{
 		p.Print("  [%i]=%p, %i+%i, %s\n", Idx, i, (int)i->Start, (int)i->Len, i->r.GetStr());
 		Idx++;
 	}
 	LgiTrace(p.NewLStr());
 
 	#ifdef _DEBUG
 	if (d->PourLog)
 		LgiTrace("%s", d->PourLog.Get());
 	#endif
 }
 
 bool LTextView4::ValidateLines(bool CheckBox)
 {
 	size_t Pos = 0;
 	char16 *c = Text;
 	size_t Idx = 0;
 	LTextLine *Prev = NULL;
 
 	for (auto l: Line)
 	{
 		if (l->Start != Pos)
 		{
 			LogLines();
 			LAssert(!"Incorrect start.");
 			return false;
 		}
 
 		char16 *e = c;
 		if (WrapType == TEXTED_WRAP_NONE)
 		{
 			while (*e && *e != '\n')
 				e++;
 		}
 		else
 		{
 			char16 *end = Text + l->Start + l->Len;
 			while (*e && *e != '\n' && e < end)
 				e++;
 		}
 			
 		ssize_t Len = e - c;
 		if (l->Len != Len)
 		{
 			LogLines();
 			LAssert(!"Incorrect length.");
 			return false;
 		}
 
 
 		if (CheckBox &&
 			Prev &&
 			Prev->r.y2 != l->r.y1 - 1)
 		{
 			LogLines();
 			LAssert(!"Lines not joined vertically");
 		}
 
 		if (*e)
 		{
 			if (*e == '\n')
 				e++;
 			else if (WrapType == TEXTED_WRAP_REFLOW)
 				e++;
 		}
 		Pos = e - Text;
 		c = e;
 		Idx++;
 		Prev = l;
 	}
 
 	if (WrapType == TEXTED_WRAP_NONE &&
 		Pos != Size)
 	{
 		LogLines();
 		LAssert(!"Last line != end of doc");
 		return false;
 	}
 
 	return true;
 }
 
 int LTextView4::AdjustStyles(ssize_t Start, ssize_t Diff, bool ExtendStyle)
 {
 	int Changes = 0;
 	for (auto &s : Style)
 	{
 		if (s.Start == Start)
 		{
 			if (Diff < 0 || ExtendStyle)
 				s.Len += Diff;
 			else
 				s.Start += Diff;
 			Changes++;
 		}
 		else if (s.Start > Start)
 		{
 			s.Start += Diff;
 			Changes++;
 		}
 	}
 
 	return Changes;
 }
 
 // break array, break out of loop when we hit these chars
 #define ExitLoop(c)	(	(c) == 0 ||								\
 						(c) == '\n' ||							\
 						(c) == ' ' ||							\
 						(c) == '\t'								\
 					)
 
 // extra breaking opportunities
 #define ExtraBreak(c) (	( (c) >= 0x3040 && (c) <= 0x30FF ) ||	\
 						( (c) >= 0x3300 && (c) <= 0x9FAF )		\
 					)
 
 /*
 Prerequisite:
 The Line list must have either the objects with the correct Start/Len or be missing the lines altogether...
 */
 void LTextView4::PourText(size_t Start, ssize_t Length /* == 0 means it's a delete */)
 {
 	#if PROFILE_POUR
 	char _txt[256];
 	sprintf_s(_txt, sizeof(_txt), "%p::PourText Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(_txt);
 	#endif
 
 	LAssert(InThread());
 
 	LRect Client = GetClient();
 	int Mx = Client.X() - d->rPadding.x1 - d->rPadding.x2;
 	int Cy = 0;
 	MaxX = 0;
 
 	ssize_t Idx = -1;
 	LTextLine *Cur = GetTextLine(Start, &Idx);
 	if (!Cur || !Cur->r.Valid())
 	{
 		// Find the last line that has a valid position...
 		for (int64_t mid, s = 0, e = Idx >= 0 ? Idx : Line.Length() - 1; s < e; )
 		{
 			if (e - s <= 1)
 			{
 				if (Line[e]->r.Valid())
 					mid = e;
 				else
 					mid = s;
 
 				Cur = Line[mid];
 				Cy = Cur->r.y1;
 				Idx = mid;
 				break;
 			}
 			else mid = s + ((e - s) >> 1);
 
 			auto sItem = Line[mid];
 			if (sItem->r.Valid())
 				s = mid + 1; // Search Mid->e
 			else
 				e = mid - 1; // Search s->Mid
 		}
 	}
 	if (Cur && !Cur->r.Valid())
 		Cur = NULL;
 	if (Cur)
 	{
 		Cy = Cur->r.y1;
 		Start = Cur->Start;
 		Length = Size - Start;
 	}
 	else
 	{
 		Idx = 0;
 		Start = 0;
 		Length = Size;
 	}
 			
 	if (!Text || !Font || Mx <= 0)
 		return;
 
 	// Tracking vars
 	ssize_t e;
 	int WrapCol = GetWrapAtCol();
 
 	LDisplayString Sp(Font, " ", 1);
 	int WidthOfSpace = Sp.X();
 	if (WidthOfSpace < 1)
 	{
 		printf("%s:%i - WidthOfSpace test failed.\n", _FL);
 		return;
 	}
 
 	// Alright... lets pour!
 	uint64 StartTs = LCurrentTime();
 	if (WrapType == TEXTED_WRAP_NONE)
 	{
 		// Find the dimensions of each line that is missing a rect
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: ExistingLines");
 		#endif
 		#ifdef _DEGBUG
 		LStringPipe Log(1024);
 		Log.Printf("Pour: " LPrintfSizeT ", " LPrintfSSizeT ", partial=%i\n", Start, Length, PartialPour);
 		#endif
 
 		ssize_t Pos = 0;
 		for (; Idx < (ssize_t)Line.Length(); Idx++)
 		{
 			LTextLine *l = Line[Idx];
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] exist: r.val=%i\n", Idx, l->r.Valid());
 			#endif
 
 			if (!l->r.Valid()) // If the layout is not valid...
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + ds.X();
 
 				MaxX = MAX(MaxX, l->r.X());
 			}
 
 			// Adjust the y position anyway... it's free.
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			Cy = l->r.y2 + 1;
 			Pos = l->Start + l->Len;
 			if (Text[Pos] == '\n')
 				Pos++;
 		}
 
 		// Now if we are missing lines as well, create them and lay them out
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: NewLines");
 		#endif
 		while (Pos < Size)
 		{
 			LTextLine *l = new LTextLine;
 			l->Start = Pos;
 			char16 *c = Text + Pos;
 			char16 *e = c;
 			while (*e && *e != '\n')
 				e++;
 			l->Len = e - c;
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] new: start=" LPrintfSSizeT ", len=" LPrintfSSizeT "\n", Idx, l->Start, l->Len);
 			#endif
 
 			l->r.x1 = d->rPadding.x1;
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			if (l->Len)
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 				l->r.x2 = l->r.x1 + ds.X();
 			}
 			else
 			{
 				l->r.x2 = l->r.x1;
 			}
 
 			LAssert(l->Len > 0);
 			Line.Add(l);
 
 			if (*e == '\n')
 				e++;
 
 			MaxX = MAX(MaxX, l->r.X());
 			Cy = l->r.y2 + 1;
 			Pos = e - Text;
 			Idx++;
 		}
 
 		#ifdef _DEGBUG
 		d->PourLog = Log.NewLStr();
 		#endif
 		PartialPour = false;
 	}
 	else // Wrap text
 	{
 		int DisplayStart = ScrollYLine();
 		int DisplayLines = 	(Client.Y() + LineY - 1) / LineY;
 		int DisplayEnd = DisplayStart + DisplayLines;
 		
 		// Pouring is split into 2 parts... 
 		// 1) pouring to the end of the displayed text.
 		// 2) pouring from there to the end of the document.
 		//	potentially taking several goes to complete the full pour
 		// This allows the document to display and edit faster..
 		bool PourToDisplayEnd = Line.Length() < DisplayEnd;
 
 		#if 0
 		LgiTrace("Idx=%i, DisplayStart=%i, DisplayLines=%i, DisplayEnd=%i, PourToDisplayEnd=%i\n",
 			Idx, DisplayStart, DisplayLines, DisplayEnd, PourToDisplayEnd);
 		#endif
 
 		if ((ssize_t)Line.Length() > Idx)
 		{
 			for (size_t i=Idx; i<Line.Length(); i++)
 				delete Line[i];
 			Line.Length(Idx);
 			Cur = NULL;
 		}
 
 		int Cx = 0;
 		ssize_t i;
 		for (i=Start; i<Size; i = e)
 		{
 			// seek till next char of interest
 			e = i;
 			int	Width = 0;
 
 			// Find break point
 			if (WrapCol)
 			{
 				// Wrap at column
 					
 				// Find the end of line
 				while (true)
 				{
 					if (e >= Size ||
 						Text[e] == '\n' ||
 						(e-i) >= WrapCol)
 					{
 						break;
 					}
 
 					e++;
 				}
 
 				// Seek back some characters if we are mid word
 				size_t OldE = e;
 				if (e < Size &&
 					Text[e] != '\n')
 				{
 					while (e > i)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 						{
 							break;
 						}
 
 						e--;
 					}
 				}
 
 				if (e == i)
 				{
 					// No line break at all, so seek forward instead
 					for (e=OldE; e < Size && Text[e] != '\n'; e++)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 							break;
 					}
 				}
 
 				// Calc the width
 				LDisplayString ds(Font, Text + i, e - i);
 				Width = ds.X();
 			}
 			else
 			{
 				// Wrap to edge of screen
 				ssize_t PrevExitChar = -1;
 				int PrevX = -1;
 
 				while (true)
 				{
 					if (e >= Size ||
 						ExitLoop(Text[e]) ||
 						ExtraBreak(Text[e]))
 					{
 						LDisplayString ds(Font, Text + i, e - i);
 						if (ds.X() + Cx > Mx)
 						{
 							if (PrevExitChar > 0)
 							{
 								e = PrevExitChar;
 								Width = PrevX;
 							}
 							else
 							{
 								Width = ds.X();
 							}
 							break;
 						}
 						else if (e >= Size ||
 								Text[e] == '\n')							
 						{
 							Width = ds.X();
 							break;
 						}
 							
 						PrevExitChar = e;
 						PrevX = ds.X();
 					}
 						
 					e++;
 				}
 			}
 
 			// Create layout line
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = i;
 				l->Len = e - i;
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + Width - 1;
 
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				LAssert(l->Len > 0);
 				Line.Add(l);
 				if (PourToDisplayEnd)
 				{
 					if (Line.Length() > DisplayEnd)
 					{
 						// We have reached the end of the displayed area... so
 						// exit out temporarily to display the layout to the user
 						PartialPour = true;
 						break;
 					}
 				}
 				else
 				{
 					// Otherwise check if we are taking too long...
 					if (Line.Length() % 20 == 0)
 					{
 						uint64 Now = LCurrentTime();
 						if (Now - StartTs > WRAP_POUR_TIMEOUT)
 						{
 							PartialPour = true;
 							// LgiTrace("Pour timeout...\n");
 							break;
 						}
 					}
 				}
 					
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 					
 				if (e < Size)
 					e++;
 			}
 		}
 
 		if (i >= Size)
 			PartialPour = false;
 		SendNotify(LNotifyCursorChanged);
 	}
 
 	#ifdef _DEBUG
 	ValidateLines(true);
 	#endif
 	#if PROFILE_POUR
 	Prof.Add("LastLine");
 	#endif
 
 	if (!PartialPour)
 	{
 		auto It = Line.rbegin();
 		LTextLine *Last = It != Line.end() ? *It : NULL;
 		if (!Last ||
 			Last->Start + Last->Len < Size)
 		{
 			auto LastEnd = Last ? Last->End() : 0;
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = LastEnd;
 				l->Len = Size - LastEnd;
 				l->r.x1 = l->r.x2 = d->rPadding.x1;
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				Line.Add(l);
 			
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 			}
 		}
 	}
 
 	bool ScrollYNeeded = Client.Y() < (Line.Length() * LineY);
 	bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 	d->LayoutDirty = WrapType != TEXTED_WRAP_NONE && ScrollChange;
 	#if PROFILE_POUR
 	static LString _s;
 	_s.Printf("ScrollBars dirty=%i", d->LayoutDirty);
 	Prof.Add(_s);
 	#endif
 
 	if (ScrollChange)
 	{
 		// LgiTrace("%s:%i - SetScrollBars(%i) %i %i\n", _FL, ScrollYNeeded, Client.Y(), (Line.Length() * LineY));
 		SetScrollBars(false, ScrollYNeeded);
 	}
 	UpdateScrollBars();
 	
 	#if 0 // def _DEBUG
 	if (GetWindow())
 	{
 		static char s[256];
 		sprintf_s(s, sizeof(s), "Pour: %.2f sec", (double)_PourTime / 1000);
 		GetWindow()->PostEvent(M_TEXTVIEW_DEBUG_TEXT, (LMessage::Param)s);
 	}
 	#endif
 
 	#if POUR_DEBUG
 	printf("Lines=%i\n", Line.Length());
 	int Index = 0;
 	for (LTextLine *l=Line.First(); l; l=Line.Next(), Index++)
 	{
 		printf("\t[%i] %i,%i (%s)\n", Index, l->Start, l->Len, l->r.Describe());
 	}
 	#endif
 }
 
 bool LTextView4::InsertStyle(LAutoPtr<LStyle> s)
 {
 	if (!s)
 		return false;
 
 	LAssert(s->Start >= 0);
 	LAssert(s->Len > 0);
 	ssize_t Last = 0;
 	// int n = 0;
 
 	// LgiTrace("StartStyle=%i,%i(%i) %s\n", (int)s->Start, (int)s->Len, (int)(s->Start+s->Len), s->Fore.GetStr());
 
 	if (Style.Length() > 0)
 	{
 		// Optimize for last in the list
 		auto Last = Style.rbegin();
 		if (s->Start >= (ssize_t)Last->End())
 		{
 			Style.Insert(*s);
 			return true;
 		}
 	}
 
 	for (auto i = Style.begin(); i != Style.end(); i++)
 	{
 		if (s->Overlap(*i))
 		{
 			if (s->Owner > i->Owner)
 			{
 				// Fail the insert
 				return false;
 			}
 			else
 			{
 				// Replace mode...
 				*i = *s;
 				return true;
 			}
 		}
 
 		if (s->Start >= Last && s->Start < i->Start)
 		{
 			Style.Insert(*s, i);
 			return true;
 		}
 	}
 
 	Style.Insert(*s);
 	return true;
 }
 
 LTextView4::LStyle *LTextView4::GetNextStyle(StyleIter &s, ssize_t Where)
 {
 	if (Where >= 0)
 		s = Style.begin();
 	else
 		s++;
 
 	while (s != Style.end())
 	{
 		// determine whether style is relevant..
 		// styles in the selected region are ignored
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 		if (SelStart >= 0 &&
 			s->Start >= Min &&
 			s->Start+s->Len < Max)
 		{
 			// style is completely inside selection: ignore
 			s++;
 		}
 		else if (Where >= 0 &&
 			s->Start+s->Len < Where)
 		{
 			s++;
 		}
 		else
 		{
 			return &(*s);
 		}
 	}
 
 	return NULL;
 }
 
 #if 0
 CURSOR_CHAR GetCursor()
 {
 	#ifdef WIN32
 	LArray<int> Ver;
 	int Os = LGetOs(&Ver);
 	if ((Os == LGI_OS_WIN32 || Os == LGI_OS_WIN64) &&
 		Ver[0] >= 5)
 	{
 		return MAKEINTRESOURCE(32649); // hand
 	}
 	else
 	{
 		return IDC_ARROW;
 	}
 	#endif
 	return 0;
 }
 #endif
 
 LTextView4::LStyle *LTextView4::HitStyle(ssize_t i)
 {
 	for (auto &s : Style)
 	{
 		if (i >= s.Start && i < (ssize_t)s.End())
 		{
 			return &s;
 		}
 	}
 
 	return NULL;
 }
 
 void LTextView4::PourStyle(size_t Start, ssize_t EditSize)
 {
 	#ifdef _DEBUG
 	int64 StartTime = LCurrentTime();
 	#endif
 
 	LAssert(InThread());
 
 	if (!Text || Size < 1)
 		return;
 
 	ssize_t Length = MAX(EditSize, 0);
 	if ((ssize_t)Start + Length >= Size)
 		Length = Size - Start; // For deletes, this sizes the edit length within bounds.
 
 	// Expand re-style are to word boundaries before and after the area of change
 	while (Start > 0 && UrlChar(Text[Start-1]))
 	{
 		// Move the start back
 		Start--;
 		Length++;
 	}
 	while ((ssize_t)Start + Length < Size && UrlChar(Text[Start+Length]))
 	{
 		// Move the end back
 		Length++;
 	}
 
 	// Delete all the styles that we own inside the changed area
 	for (StyleIter s = Style.begin(); s != Style.end();)
 	{
 		if (s->Owner == STYLE_NONE)
 		{
 			if (EditSize > 0)
 			{
 				if (s->Overlap(Start, EditSize < 0 ? -EditSize : EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 			else
 			{
 				if (s->Overlap(Start, -EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 		}
 
 		s++;
 	}
 
 	if (UrlDetect)
 	{		
 		LArray<LLinkInfo> Links;		
 		LAssert((ssize_t)Start + Length <= Size);		
 		if (LDetectLinks(Links, Text + Start, Length))
 		{
 			for (uint32_t i=0; i<Links.Length(); i++)
 			{
 				LLinkInfo &Inf = Links[i];
                 LAutoPtr<LStyle> Url(new LStyle(STYLE_URL));
 				if (Url)
 				{
 					Url->View = this;
 					Url->Start = Inf.Start + Start;
 					Url->Len = Inf.Len;
 					Url->Font = Underline;
 					Url->Fore = d->UrlColour;
 
 					InsertStyle(Url);
 				}
 			}
 		}
 	}
 
 	#ifdef _DEBUG
 	_StyleTime = LCurrentTime() - StartTime;
 	#endif
 }
 
 bool LTextView4::Insert(size_t At, const char16 *Data, ssize_t Len)
 {
 	static int count = -1;
 	count++;
 
 	LProfile Prof("LTextView4::Insert");
 	Prof.HideResultsIfBelow(1000);
 
 	LAssert(InThread());
 	
 	if (!ReadOnly && Len > 0)
 	{
 		if (!Data)
 			return false;
 
 		// limit input to valid data
 		At = MIN(Size, (ssize_t)At);
 
 		// make sure we have enough memory
 		size_t NewAlloc = Size + Len + 1;
 		NewAlloc += ALLOC_BLOCK - (NewAlloc % ALLOC_BLOCK);
 		if (NewAlloc != Alloc)
 		{
 			char16 *NewText = new char16[NewAlloc];
 			if (NewText)
 			{
 				if (Text)
 				{
 					// copy any existing data across
 					memcpy(NewText, Text, (Size + 1) * sizeof(char16));
 				}
 
 				DeleteArray(Text);
 				Text = NewText;
 				Alloc = NewAlloc;
 			}
 			else
 			{
 				// memory allocation error
 				return false;
 			}
 		}
 		
 		Prof.Add("MemChk");
 
 		if (Text)
 		{
 			// Insert the data
 
 			// Move the section after the insert to make space...
 			memmove(Text+(At+Len), Text+At, (Size-At) * sizeof(char16));
 
 			Prof.Add("Cpy");
 
 			// Copy new data in...
 			memcpy(Text+At, Data, Len * sizeof(char16));
 			Size += Len;
 			Text[Size] = 0; // NULL terminate
 
 			Prof.Add("Undo");
 			
 			// Add the undo object...
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView4Undo> Obj;
 				if (!UndoCur)
 					Obj.Reset(new LTextView4Undo(this));
 				auto u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoInsert);
 				else
 					LAssert(!"No undo obj?");
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			// Clear layout info for the new text
 			ssize_t Idx = -1;
 			LTextLine *Cur = NULL;
 			
 			if (Line.Length() == 0)
 			{
 				// Empty doc... set up the first line
 				Line.Add(Cur = new LTextLine);
 				Idx = 0;
 				Cur->Start = 0;
 			}
 			else
 			{
 				Cur = GetTextLine(At, &Idx);
 			}
 
 			if (Cur)
 			{
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					// Clear layout for current line...
 					Cur->r.ZOff(-1, -1);
 
 					Prof.Add("NoWrap add lines");
 					
 					// Add any new lines that we need...
 					char16 *e = Text + At + Len;
 					char16 *c;
 					for (c = Text + At; c < e; c++)
 					{
 						if (*c == '\n')
 						{
 							// Set the size of the current line...
 							size_t Pos = c - Text;
 							Cur->Len = Pos - Cur->Start;
 
 							// Create a new line...
 							Cur = new LTextLine();
 							if (!Cur)
 								return false;
 							Cur->Start = Pos + 1;
 							Line.AddAt(++Idx, Cur);
 						}
 					}
 
 					Prof.Add("CalcLen");
 
 					// Make sure the last Line's length is set..
 					Cur->CalcLen(Text);
 
 					Prof.Add("UpdatePos");
 	
 					// Now update all the positions of the following lines...
 					for (size_t i = ++Idx; i < Line.Length(); i++)
 						Line[i]->Start += Len;
 				}
 				else
 				{
 					// Clear all lines to the end of the doc...
 					LgiTrace("ClearLines %i\n", (int)Idx+1);
 					for (size_t i = ++Idx; i < Line.Length(); i++)
 						delete Line[i];
 					Line.Length(Idx);
 				}
 			}
 			else
 			{
 				// If wrap is on then this can happen when an Insert happens before the 
 				// OnPulse event has laid out the new text. Probably not a good thing in
 				// non-wrap mode			
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					LTextLine *l = *Line.rbegin();
 					printf("%s:%i - Insert error: no cur, At=%i, Size=%i, Lines=%i, WrapType=%i\n",
 						_FL, (int)At, (int)Size, (int)Line.Length(), (int)WrapType);
 					if (l)
 						printf("Last=%i, %i\n", (int)l->Start, (int)l->Len);
 				}
 			}
 
 			#ifdef _DEBUG
 			// Prof.Add("Validate");
 			// ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, Len);
 
 			Dirty = true;
 			if (PourEnabled)
 			{
 				Prof.Add("PourText");
 				PourText(At, Len);
 				Prof.Add("PourStyle");
 				auto Start = LCurrentTime();
 				PourStyle(At, Len);
 				auto End = LCurrentTime();
 				if (End - Start > 1000)
 				{
 					PourStyle(At, Len);
 				}
 			}
 			SendNotify(LNotifyDocChanged);
 
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool LTextView4::Delete(size_t At, ssize_t Len)
 {
 	bool Status = false;
 
 	LAssert(InThread());
 
 	if (!ReadOnly)
 	{
 		// limit input
 		At = MAX(At, 0);
 		At = MIN((ssize_t)At, Size);
 		Len = MIN(Size-(ssize_t)At, Len);
 
 		if (Len > 0)
 		{
 			int HasNewLine = 0;
 
 			for (int i=0; i<Len; i++)
 			{
 				if (Text[At + i] == '\n')
 					HasNewLine++;
 			}
 
 			// do delete
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView4Undo> Obj(new LTextView4Undo(this));
 				LTextView4Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoDelete);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			memmove(Text+At, Text+(At+Len), (Size-At-Len) * sizeof(char16));
 			Size -= Len;
 			Text[Size] = 0;
 
 			if (WrapType == TEXTED_WRAP_NONE)
 			{
 				ssize_t Idx = -1;
 				LTextLine *Cur = GetTextLine(At, &Idx);
 				if (Cur)
 				{
 					Cur->r.ZOff(-1, -1);
 
 					// Delete some lines...
 					for (int i=0; i<HasNewLine; i++)
 					{
 						LTextLine *l = Line[Idx + 1];
 						delete l;
 						Line.DeleteAt(Idx + 1);
 					}
 
 					// Correct the current line's length
 					Cur->CalcLen(Text);
 
 					// Shift all further lines down...
 					for (size_t i = Idx + 1; i < Line.Length(); i++)
 						Line[i]->Start -= Len;
 				}
 			}
 			else
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					for (size_t i = Index; i < Line.Length(); i++)
 						delete Line[i];
 					Line.Length(Index);
 				}
 			}
 			
 
 			Dirty = true;
 			Status = true;
 
 			#ifdef _DEBUG
 			ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, -Len);
 
 			if (PourEnabled)
 			{
 				PourText(At, -Len);
 				PourStyle(At, -Len);
 			}
 			
 			if (Cursor >= (ssize_t)At && Cursor <= (ssize_t)At + Len)
 			{
 				SetCaret(At, false, HasNewLine != 0);
 			}
 
 			// Handle repainting in flowed mode, when the line starts change
 			if (WrapType == TEXTED_WRAP_REFLOW)
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					LRect r = Cur->r;
 					r.x2 = GetClient().x2;
 					r.y2 = GetClient().y2;
 					Invalidate(&r);
 				}
 			}
 
 			SendNotify(LNotifyDocChanged);
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 void LTextView4::DeleteSelection(char16 **Cut)
 {
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Cut)
 		{
 			*Cut = NewStrW(Text + Min, Max - Min);
 		}
 
 		Delete(Min, Max - Min);
 		SetCaret(Min, false, true);
 	}
 }
 
 LArray<LTextView4::LTextLine*>::I LTextView4::GetTextLineIt(ssize_t Offset, ssize_t *Index)
 {
 	if (Line.Length() == 0)
 	{
 		if (Index)
 			*Index = 0;
 		return Line.end();
 	}
 	if (Offset <= 0)
 	{
 		if (Index)
 			*Index = 0;
 		return Line.begin();
 	}
 	else if (Line.Length())
 	{
 		auto l = Line.Last();
 		if (Offset > l->End())
 		{
 			if (Index)
 				*Index = Line.Length() - 1;
 			return Line.begin(Line.Length()-1);
 		}
 	}
 
 	size_t mid = 0, s = 0, e = Line.Length() - 1;
 	while (s < e)
 	{
 		if (e - s <= 1)
 		{
 			if (Line[s]->Overlap(Offset))
 				mid = s;
 			else if (Line[e]->Overlap(Offset))
 				mid = e;
 			else
 			{
 				LAssert(!"Needs to match Line s or e...");
 				break;
 			}
 		}
 		else mid = s + ((e - s) >> 1);
 		
 		auto l = Line[mid];
 		auto end = l->End();
 
 		if (Offset < l->Start)
 			e = mid - 1;
 		else if (Offset > end)
 			s = mid + 1;
 		else
 		{
 			LAssert(Line[mid]->Overlap(Offset));
 			if (Index)
 				*Index = mid;
 			return Line.begin(mid);
 		}
 	}
 
 	LAssert(Line[s]->Overlap(Offset));
 	if (Index)
 		*Index = s;
 	return Line.begin(s);
 }
 
 int64 LTextView4::Value()
 {
 	auto n = Name();
 	#ifdef _MSC_VER
 	return (n) ? _atoi64(n) : 0;
 	#else
 	return (n) ? atoll(n) : 0;
 	#endif
 }
 
 void LTextView4::Value(int64 i)
 {
 	char Str[32];
 	sprintf_s(Str, sizeof(Str), LPrintfInt64, i);
 	Name(Str);
 }
 
 LString LTextView4::operator[](ssize_t LineIdx)
 {
 	if (LineIdx <= 0 || LineIdx > (ssize_t)GetLines())
 		return LString();
 
 	LTextLine *Ln = Line[LineIdx-1];
 	if (!Ln)
 		return LString();
 
 	LString s(Text + Ln->Start, Ln->Len);
 	return s; 
 }
 
 const char *LTextView4::Name()
 {
 	UndoQue.Empty();
 	DeleteArray(TextCache);
 	TextCache = WideToUtf8(Text);
 
 	return TextCache;
 }
 
 bool LTextView4::Name(const char *s)
 {
 	if (InThread())
 	{
 		UndoQue.Empty();
 		DeleteArray(TextCache);
 		DeleteArray(Text);
 		Line.DeleteObjects();
 		Style.Empty();
 
 		LAssert(LIsUtf8(s));
 		Text = Utf8ToWide(s);
 		if (!Text)
 		{
 			Text = new char16[1];
 			if (Text) *Text = 0;
 		}
 
 		Size = Text ? StrlenW(Text) : 0;
 		Alloc = Size + 1;
 		Cursor = MIN(Cursor, Size);
 		if (Text)
 		{
 			// Remove '\r's
 			char16 *o = Text;
 			for (char16 *i=Text; *i; i++)
 			{
 				if (*i != '\r')
 				{
 					*o++ = *i;
 				}
 				else Size--;
 			}
 			*o++ = 0;
 		}
 		
 		// update everything else
 		d->SetDirty(0, Size);
 		PourText(0, Size);
 		PourStyle(0, Size);
 		UpdateScrollBars();
 		Invalidate();
 	}
 	else if (d->Lock(_FL))
 	{
 		if (IsAttached())
 		{
 			d->SetName = s;
 			PostEvent(M_TEXT_UPDATE_NAME);
 		}
 		else LAssert(!"Can't post event to detached/virtual window.");
 		d->Unlock();
 	}
 
 	return true;
 }
 
 const char16 *LTextView4::NameW()
 {
 	return Text;
 }
 
 bool LTextView4::NameW(const char16 *s)
 {
 	DeleteArray(Text);
 	Size = s ? StrlenW(s) : 0;
 	Alloc = Size + 1;
 	Text = new char16[Alloc];
 	Cursor = MIN(Cursor, Size);
 	if (Text)
 	{
 		memcpy(Text, s, Size * sizeof(char16));
 
 		// remove LF's
 		int In = 0, Out = 0;
 		CrLf = false;
 		for (; In<Size; In++)
 		{
 			if (Text[In] != '\r')
 			{
 				Text[Out++] = Text[In];
 			}
 			else
 			{
 				CrLf = true;
 			}
 		}
 		Size = Out;
 		Text[Size] = 0;
 
 	}
 
 	// update everything else
 	Line.DeleteObjects();
 	Style.Empty();
 	d->SetDirty(0, Size);
 	PourText(0, Size);
 	PourStyle(0, Size);
 	UpdateScrollBars();
 	Invalidate();
 
 	return true;
 }
 
 LRange LTextView4::GetSelectionRange()
 {
 	LRange r;
 	if (HasSelection())
 	{
 		r.Start = MIN(SelStart, SelEnd);
 		ssize_t End = MAX(SelStart, SelEnd);
 		r.Len = End - r.Start;
 	}
 	return r;
 }
 
 char *LTextView4::GetSelection()
 {
 	LRange s = GetSelectionRange();
 	if (s.Len > 0)
 	{
 		return (char*)LNewConvertCp("utf-8", Text + s.Start, LGI_WideCharset, s.Len*sizeof(Text[0]) );
 	}
 
 	return 0;
 }
 
 bool LTextView4::HasSelection()
 {
 	return (SelStart >= 0) && (SelStart != SelEnd);
 }
 
 void LTextView4::SelectAll()
 {
 	SelStart = 0;
 	SelEnd = Size;
 	Invalidate();
 }
 
 void LTextView4::UnSelectAll()
 {
 	bool Update = HasSelection();
 
 	SelStart = -1;
 	SelEnd = -1;
 
 	if (Update)
 	{
 		Invalidate();
 	}
 }
 
 size_t LTextView4::GetLines()
 {
 	return Line.Length();
 }
 
 void LTextView4::GetTextExtent(int &x, int &y)
 {
 	PourText(0, Size);
 
 	x = MaxX + d->rPadding.x1;
 	y = (int)(Line.Length() * LineY);
 }
 
 bool LTextView4::GetLineColumnAtIndex(LPoint &Pt, ssize_t Index)
 {
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Index < 0 ? Cursor : Index, &FromIndex);
 	if (!From)
 		return false;
 
 	Pt.x = (int) (Cursor - From->Start);
 	Pt.y = (int) FromIndex;
 	return true;
 }
 
 ssize_t LTextView4::GetCaret(bool Cur)
 {
 	if (Cur)
 	{
 		return Cursor;
 	}
 
 	return 0;
 }
 
 ssize_t LTextView4::IndexAt(int x, int y)
 {
 	LTextLine *l = Line.ItemAt(y);
 	if (l)
 	{
 		return l->Start + MIN(x, l->Len);
 	}
 
 	return 0;
 }
 
 bool LTextView4::ScrollToOffset(size_t Off)
 {
 	bool ForceFullUpdate = false;
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Off, &ToIndex);
 	if (To)
 	{
 		LRect Client = GetClient();
 		int DisplayLines = Client.Y() / LineY;
 
 		if (VScroll)
 		{
 			if (ToIndex < VScroll->Value())
 			{
 				// Above the visible region...
 				if (d->CenterCursor)
 				{
 					ssize_t i = ToIndex - (DisplayLines >> 1);
 					VScroll->Value(MAX(0, i));
 				}
 				else
 				{
 					VScroll->Value(ToIndex);
 				}
 				ForceFullUpdate = true;
 			}
 
 			if (ToIndex >= VScroll->Value() + DisplayLines)
 			{
 				int YOff = d->CenterCursor ? DisplayLines >> 1 : DisplayLines;
 			
 				ssize_t v = MIN(ToIndex - YOff + 1, (ssize_t)Line.Length() - DisplayLines);
 				if (v != VScroll->Value())
 				{
 					// Below the visible region
 					VScroll->Value(v);
 					ForceFullUpdate = true;
 				}
 			}
 		}
 		else
 		{
 			d->VScrollCache = ToIndex;
 		}
 	}
 
 	return ForceFullUpdate;
 }
 
 void LTextView4::SetCaret(size_t i, bool Select, bool ForceFullUpdate)
 {
     // int _Start = LCurrentTime();
 	Blink = true;
 
 	// Bound the new cursor position to the document
 	if ((ssize_t)i > Size) i = Size;
 
 	// Store the old selection and cursor
 	ssize_t s = SelStart, e = SelEnd, c = Cursor;
 	
 	// If there is going to be a selected area
 	if (Select && i != SelStart)
 	{
 		// Then set the start
 		if (SelStart < 0)
 		{
 			// We are starting a new selection
 			SelStart = Cursor;
 		}
 
 		// And end
 		SelEnd = i;
 	}
 	else
 	{
 		// Clear the selection
 		SelStart = SelEnd = -1;
 	}
 
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Cursor, &FromIndex);
 
 	Cursor = i;
 
 	// check the cursor is on the screen
 	ForceFullUpdate |= ScrollToOffset(Cursor);
 
 	// check whether we need to update the screen
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Cursor, &ToIndex);
 	if (ForceFullUpdate ||
 		!To ||
 		!From)
 	{
 		// need full update
 		Invalidate();
 	}
 	else if
 	(
 		(
 			SelStart != s
 			||
 			SelEnd != e
 		)
 	)
 	{
 		// Update just the selection bounds
 		LRect Client = GetClient();
 		size_t Start, End;
 		if (SelStart >= 0 && s >= 0)
 		{
 			// Selection has changed, union the before and after regions
 			Start = MIN(Cursor, c);
 			End = MAX(Cursor, c);
 		}
 		else if (SelStart >= 0)
 		{
 			// Selection created...
 			Start = MIN(SelStart, SelEnd);
 			End = MAX(SelStart, SelEnd);
 		}
 		else if (s >= 0)
 		{
 			// Selection removed...
 			Start = MIN(s, e);
 			End = MAX(s, e);
 		}
 		else return;
 
 		LTextLine *SLine = GetTextLine(Start);
 		LTextLine *ELine = GetTextLine(End);
 		LRect u;
 		if (SLine && ELine)
 		{
 			if (SLine->r.Valid())
 			{
 				u = DocToScreen(SLine->r);
 			}
 			else
 				u.Set(0, 0, Client.X()-1, 1); // Start of visible page 
 			
 			LRect b(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			if (ELine->r.Valid())
 			{
 				b = DocToScreen(ELine->r);
 			}
 			else
 			{
 				b.Set(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			}
 			u.Union(&b);
 			
 			u.x1 = 0;
 			u.x2 = X();
 		}
 		else
 		{
 			/*
 			printf("%s,%i - Couldn't get SLine and ELine: %i->%p, %i->%p\n",
 				_FL,
 				(int)Start, SLine,
 				(int)End, ELine);
 			*/
 			u = Client;
 		}
 
 		Invalidate(&u);			
 	}
 	else if (Cursor != c)
 	{
 		// just the cursor has moved
 
 		// update the line the cursor moved to
 		LRect r = To->r;
 		r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 		r.x2 = X();
 		Invalidate(&r);
 
 		if (To != From)
 		{
 			// update the line the cursor came from,
 			// if it's a different line from the "to"
 			r = From->r;
 			r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 			r.x2 = X();
 			Invalidate(&r);
 		}
 	}
 
 	if (c != Cursor)
 	{
 		// Send off notify
 		SendNotify(LNotifyCursorChanged);
 	}
 
 //int _Time = LCurrentTime() - _Start;
 //printf("Setcursor=%ims\n", _Time);
 }
 
 void LTextView4::SetBorder(int b)
 {
 }
 
 bool LTextView4::Cut()
 {
 	bool Status = false;
 	char16 *Txt16 = 0;
 	
 	DeleteSelection(&Txt16);
 	if (Txt16)
 	{
 		#ifdef WIN32
 		Txt16 = ConvertToCrLf(Txt16);
 		#endif
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 
 		LClipBoard Clip(this);
 
 		Clip.Text(Txt8);
 		Status = Clip.TextW(Txt16, false);
 		
 		DeleteArray(Txt8);
 		DeleteArray(Txt16);
 	}
 
 	return Status;
 }
 
 bool LTextView4::Copy()
 {
 	bool Status = true;
 
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		#ifdef WIN32
 		char16 *Txt16 = NewStrW(Text+Min, Max-Min);
 		Txt16 = ConvertToCrLf(Txt16);
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 		#else
 		char *Txt8 = (char*)LNewConvertCp("utf-8", Text+Min, LGI_WideCharset, (Max-Min)*sizeof(*Text));
 		#endif
 
 		LClipBoard Clip(this);
 		
 		Clip.Text(Txt8);
 		#ifdef WIN32
 		Clip.TextW(Txt16, false);
 		DeleteArray(Txt16);
 		#endif
 		
 		DeleteArray(Txt8);
 	}
 	else LgiTrace("%s:%i - No selection.\n", _FL);
 
 	return Status;
 }
 
 bool LTextView4::Paste()
 {
 	LClipBoard Clip(this);
 
 	LAutoWString Mem;
 	char16 *t = Clip.TextW();
 	if (!t) // ala Win9x
 	{
 		char *s = Clip.Text();
 		if (s)
 		{
 			Mem.Reset(Utf8ToWide(s));
 			t = Mem;
 		}
 	}
 	
 	if (!t)
 		return false;
 
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	// remove '\r's
 	char16 *s = t, *d = t;
 	for (; *s; s++)
 	{
 		if (*s != '\r')
 		{
 			*d++ = *s;
 		}
 	}
 	*d++ = 0;
 
 	// insert text
 	ssize_t Len = StrlenW(t);
 	Insert(Cursor, t, Len);
 	SetCaret(Cursor+Len, false, true); // Multiline
 	
 	return true;
 }
 
 void LTextView4::ClearDirty(std::function<void(bool)> OnStatus, bool Ask, const char *FileName)
 {
 	if (Dirty)
 	{
 		int Answer = (Ask) ? LgiMsg(this,
 									LLoadString(L_TEXTCTRL_ASK_SAVE, "Do you want to save your changes to this document?"),
 									LLoadString(L_TEXTCTRL_SAVE, "Save"),
 									MB_YESNOCANCEL) : IDYES;
 		if (Answer == IDYES)
 		{
 			auto DoSave = [this, OnStatus](bool ok, const char *FileName)
 			{
 				Save(FileName);				
 				if (OnStatus)
 					OnStatus(ok);
 			};
 			
 			if (!FileName)
 			{
 				LFileSelect *Select = new LFileSelect;
 				Select->Parent(this);
 				Select->Save([FileName=LString(FileName), DoSave](auto Select, auto ok)
 				{
 					if (ok)
 						DoSave(ok, Select->Name());
 					else
 						DoSave(ok, FileName);
 					delete Select;
 				});
 			}
 			else DoSave(true, FileName);
 		}
 		else if (Answer == IDCANCEL)
 		{
 			if (OnStatus)
 				OnStatus(false);
 			return;
 		}
 	}
 
 	if (OnStatus)
 		OnStatus(true);
 }
 
 bool LTextView4::Open(const char *Name, const char *CharSet)
 {
 	bool Status = false;
 	LFile f;
 
 	if (f.Open(Name, O_READ|O_SHARE))
 	{
 		DeleteArray(Text);
 		int64 Bytes = f.GetSize();
 		if (Bytes < 0 || Bytes & 0xffff000000000000LL)
 		{
 			LgiTrace("%s:%i - Invalid file size: " LPrintfInt64 "\n", _FL, Bytes);
 			return false;
 		}
 			
 		SetCaret(0, false);
 		Line.DeleteObjects();
 		
 		char *c8 = new char[Bytes + 4];
 		if (c8)
 		{
 			if (f.Read(c8, (int)Bytes) == Bytes)
 			{
 				char *DataStart = c8;
 
 				c8[Bytes] = 0;
 				c8[Bytes+1] = 0;
 				c8[Bytes+2] = 0;
 				c8[Bytes+3] = 0;
 				
 				if ((uchar)c8[0] == 0xff && (uchar)c8[1] == 0xfe)
 				{
 					// utf-16
 					if (!CharSet)
 					{
 						CharSet = "utf-16";
 						DataStart += 2;
 					}
 				}
 				
 				// Convert to unicode first....
 				if (Bytes == 0)
 				{
 					Text = new char16[1];
 					if (Text) Text[0] = 0;
 				}
 				else
 				{
 					Text = (char16*)LNewConvertCp(LGI_WideCharset, DataStart, CharSet ? CharSet : DefaultCharset);
 				}
 				
 				if (Text)
 				{
 					// Remove LF's
 					char16 *In = Text, *Out = Text;
 					CrLf = false;
 					Size = 0;
 					while (*In)
 					{
 						if (*In >= ' ' ||
 							*In == '\t' ||
 							*In == '\n')
 						{
 							*Out++ = *In;
 							Size++;
 						}
 						else if (*In == '\r')
 						{
 							CrLf = true;
 						}
 						In++;
 					}
 					Size = (int) (Out - Text);
 					*Out = 0;
 
 					Alloc = Size + 1;
 					Dirty = false;
 					
 					if (Text && Text[0] == 0xfeff) // unicode byte order mark
 					{
 						memmove(Text, Text+1, Size * sizeof(*Text));
 						Size--;
 					}
 
 					PourText(0, Size);
 					PourStyle(0, Size);
 					UpdateScrollBars(true);
 					
 					Status = true;
 				}
 			}
 
 			DeleteArray(c8);
 		}
 		else
 		{
 			Alloc = Size = 0;
 		}
 
 		Invalidate();
 	}
 
 	return Status;
 }
 
 template<typename T>
 bool WriteToStream(LFile &out, T *in, size_t len, bool CrLf)
 {
 	if (!in)
 		return false;
 	
 	if (CrLf)
 	{
 		int BufLen = 1 << 20;
 		LAutoPtr<T,true> Buf(new T[BufLen]);
 		T *b = Buf;
 		T *e = Buf + BufLen;
 		T *c = in;
 		T *end = c + len;
 		
 		while (c < end)
 		{
 			if (b > e - 16)
 			{
 				auto Bytes = (b - Buf) * sizeof(T);
 				if (out.Write(Buf, Bytes) != Bytes)
 					return false;
 				
 				b = Buf;
 			}
 			
 			if (*c == '\n')
 			{
 				*b++ = '\r';
 				*b++ = '\n';
 			}
 			else
 			{
 				*b++ = *c;
 			}
 			c++;
 		}
 
 		auto Bytes = (b - Buf) * sizeof(T);
 		if (out.Write(Buf, Bytes) != Bytes)
 			return false;
 	}
 	else
 	{
 		auto Bytes = len * sizeof(T);
 		if (out.Write(in, Bytes) != Bytes)
 			return false;
 	}
 
 	return true;
 }
 
 bool LTextView4::Save(const char *Name, const char *CharSet)
 {
 	LFile f;
 	LString TmpName;
 	bool Status = false;
 	
 	d->LastError.Empty();
 
 	if (f.Open(Name, O_WRITE))
 	{
 		if (f.SetSize(0) != 0)
 		{
 			// Can't resize file, fall back to renaming it and 
 			// writing a new file...
 			f.Close();
 			TmpName = Name;
 			TmpName += ".tmp";
 			if (!FileDev->Move(Name, TmpName))
 			{
 				LgiTrace("%s:%i - Failed to move '%s'.\n", _FL, Name);
 				return false;
 			}
 
 			if (!f.Open(Name, O_WRITE))
 			{
 				LgiTrace("%s:%i - Failed to open '%s' for writing.\n", _FL, Name);
 				return false;
 			}
 		}
 
 		if (Text)
 		{
 			auto InSize = Size * sizeof(char16);
 			if (CharSet && !Stricmp(CharSet, "utf-16"))
 			{
 				if (sizeof(*Text) == 2)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 32->16 convert
 					LAutoPtr<uint16_t,true> c16((uint16_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c16)
 						Status = WriteToStream(f, c16.Get(), Strlen(c16.Get()), CrLf);
 				}
 			}
 			else if (CharSet && !Stricmp(CharSet, "utf-32"))
 			{
 				if (sizeof(*Text) == 4)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 16->32 convert
 					LAutoPtr<uint32_t,true> c32((uint32_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c32)
 						Status = WriteToStream(f, c32.Get(), Strlen(c32.Get()), CrLf);
 				}
 			}
 			else
 			{
 				LAutoString c8((char*)LNewConvertCp(CharSet ? CharSet : DefaultCharset, Text, LGI_WideCharset, InSize));
 				if (c8)
 					Status = WriteToStream(f, c8.Get(), strlen(c8), CrLf);
 			}
 
 			if (Status)
 				Dirty = false;
 		}
 	}
 	else
 	{
 		int Err = f.GetError();
 		LString sErr = LErrorCodeToString(Err);		
 		d->LastError.Printf("Failed to open '%s' for writing: %i - %s\n", Name, Err, sErr.Get());
 	}
 
 	if (TmpName)
 		FileDev->Delete(TmpName);
 
 	return Status;
 }
 
 const char *LTextView4::GetLastError()
 {
 	return d->LastError;
 }
 
 void LTextView4::UpdateScrollBars(bool Reset)
 {
 	if (VScroll)
 	{
 		LRect Before = GetClient();
 
 		int DisplayLines = Y() / LineY;
 		ssize_t Lines = GetLines();
 		VScroll->SetRange(Lines);
 		if (VScroll)
 		{
 			VScroll->SetPage(DisplayLines);
 			
 			ssize_t Max = Lines - DisplayLines + 1;
 			bool Inval = false;
 			if (VScroll->Value() > Max)
 			{
 				VScroll->Value(Max);
 				Inval = true;
 			}
 
 			if (Reset)
 			{
 				VScroll->Value(0);
 				SelStart = SelEnd = -1;
 			}
 			else if (d->VScrollCache >= 0)
 			{
 				VScroll->Value(d->VScrollCache);
 				d->VScrollCache = -1;
 				SelStart = SelEnd = -1;
 			}
 
 			LRect After = GetClient();
 
 			if (Before != After && GetWrapType())
 			{
 				d->SetDirty(0, Size);
 				Inval = true;
 			}
 			
 			if (Inval)
 			{
 				Invalidate();
 			}
 		}
 	}
 }
 
 void LTextView4::DoCase(std::function<void(bool)> Callback, bool Upper)
 {
 	if (Text)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Min < Max)
 		{
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView4Undo> Obj(new LTextView4Undo(this));
 				LTextView4Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(Min, Max - Min, UndoChange);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			for (ssize_t i=Min; i<Max; i++)
 			{
 				if (Upper)
 				{
 					if (Text[i] >= 'a' && Text[i] <= 'z')
 						Text[i] = Text[i] - 'a' + 'A';
 				}
 				else
 				{
 					if (Text[i] >= 'A' && Text[i] <= 'Z')
 						Text[i] = Text[i] - 'A' + 'a';
 				}
 			}
 
 			Dirty = true;
 			d->SetDirty(Min, 0);
 			Invalidate();
 
 			SendNotify(LNotifyDocChanged);
 		}
 	}
 	
 	if (Callback)
 		Callback(Text != NULL);
 }
 
 ssize_t LTextView4::GetLine()
 {
 	ssize_t Idx = 0;
 	GetTextLine(Cursor, &Idx);
 	return Idx + 1;
 }
 
 void LTextView4::SetLine(int64_t i)
 {
 	LTextLine *l = Line.ItemAt(i - 1);
 	if (l)
 	{
 		d->CenterCursor = true;
 		SetCaret(l->Start, false);
 		d->CenterCursor = false;
 	}
 }
 
 void LTextView4::DoGoto(std::function<void(bool)> Callback)
 {
 	LInput *Dlg = new LInput(this, "", LLoadString(L_TEXTCTRL_GOTO_LINE, "Goto line:"), "Text");	
 	Dlg->DoModal([this, Dlg, Callback](auto d, auto code)
 	{
 		auto ok = code == IDOK && Dlg->GetStr();
 		if (ok)
 			SetLine(Dlg->GetStr().Int());
 		if (Callback)
 			Callback(ok);
 		delete Dlg;
 	});
 }
 
 LDocFindReplaceParams *LTextView4::CreateFindReplaceParams()
 {
 	return new GDocFindReplaceParams4;
 }
 
 void LTextView4::SetFindReplaceParams(LDocFindReplaceParams *Params)
 {
 	if (Params)
 	{
 		if (d->OwnFindReplaceParams)
 		{
 			DeleteObj(d->FindReplaceParams);
 		}
 		
 		d->OwnFindReplaceParams = false;
 		d->FindReplaceParams = (GDocFindReplaceParams4*) Params;
 	}
 }
 
 void LTextView4::DoFindNext(std::function<void(bool)> Callback)
 {
 	bool Status = false;
 	if (InThread())
 	{
 		if (d->FindReplaceParams->Lock(_FL))
 		{
 			if (d->FindReplaceParams->LastFind)
 				Status = OnFind(d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 							
 			d->FindReplaceParams->Unlock();
 		}
 	}
 	else if (IsAttached())
 	{
 		Status = PostEvent(M_TEXTVIEW_FIND);
 	}
 	if (Callback)
 		Callback(Status);
 }
 
 void LTextView4::DoFind(std::function<void(bool)> Callback)
 {
 	LString u;
 
 	if (HasSelection())
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		u = LString(Text + Min, Max - Min);
 	}
 	else
 	{
 		u = d->FindReplaceParams->LastFind.Get();
 	}
 
 	auto Dlg = new LFindDlg(this, [this, Params=d->FindReplaceParams, Callback](auto Dlg, auto Action)
 		{
 			if (Params &&
 				Params->Lock(_FL))
 			{
 				Params->MatchWord = Dlg->MatchWord;
 				Params->MatchCase = Dlg->MatchCase;
 				Params->SelectionOnly = Dlg->SelectionOnly;
 				Params->SearchUpwards = Dlg->SearchUpwards;
 				Params->LastFind.Reset(Utf8ToWide(Dlg->Find));
 		
 				Params->Unlock();
 			}
 
 			DoFindNext([this, Callback](bool ok)
 			{
 				Focus(true);
 				if (Callback)
 					Callback(ok);
 			});
 		},
 		u);
 
 	Dlg->DoModal(NULL);
 }
 
 void LTextView4::DoReplace(std::function<void(bool)> Callback)
 {
 	bool SingleLineSelection = false;
 	SingleLineSelection = HasSelection();
 	if (SingleLineSelection)
 	{
 		LRange Sel = GetSelectionRange();
 		for (ssize_t i = Sel.Start; i < Sel.End(); i++)
 		{
 			if (Text[i] == '\n')
 			{
 				SingleLineSelection = false;
 				break;
 			}
 		}
 	}
 
 	LAutoString LastFind8(SingleLineSelection ? GetSelection() : WideToUtf8(d->FindReplaceParams->LastFind));
 	LAutoString LastReplace8(WideToUtf8(d->FindReplaceParams->LastReplace));
 	
 	auto Dlg = new LReplaceDlg(this,
 		[this](auto Dlg, auto Action)
 		{
 			LReplaceDlg *Replace = dynamic_cast<LReplaceDlg*>(Dlg);
 			LAssert(Replace != NULL);
 
 			if (Action == IDCANCEL)
 				return;
 
 			if (d->FindReplaceParams->Lock(_FL))
 			{
 				d->FindReplaceParams->LastFind.Reset(Utf8ToWide(Replace->Find));
 				d->FindReplaceParams->LastReplace.Reset(Utf8ToWide(Replace->Replace));
 				d->FindReplaceParams->MatchWord = Replace->MatchWord;
 				d->FindReplaceParams->MatchCase = Replace->MatchCase;
 				d->FindReplaceParams->SelectionOnly = Replace->SelectionOnly;
 					
 				switch (Action)
 				{
 					case IDC_FR_FIND:
 					{
 						OnFind(	d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 					case IDOK:
 					case IDC_FR_REPLACE:
 					{
 						OnReplace(	d->FindReplaceParams->LastFind,
 									d->FindReplaceParams->LastReplace,
 									Action == IDOK,
 									d->FindReplaceParams->MatchWord,
 									d->FindReplaceParams->MatchCase,
 									d->FindReplaceParams->SelectionOnly,
 									d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 				}
 
 				d->FindReplaceParams->Unlock();
 			}
 		},
 		LastFind8,
 		LastReplace8);
 
 	Dlg->MatchWord = d->FindReplaceParams->MatchWord;
 	Dlg->MatchCase = d->FindReplaceParams->MatchCase;
 	Dlg->SelectionOnly = HasSelection();
 
 	Dlg->DoModal(NULL);
 }
 
 void LTextView4::SelectWord(size_t From)
 {
 	for (SelStart = From; SelStart > 0; SelStart--)
 	{
 		if (strchr(SelectWordDelim, Text[SelStart]))
 		{
 			SelStart++;
 			break;
 		}
 	}
 
 	for (SelEnd = From; SelEnd < Size; SelEnd++)
 	{
 		if (strchr(SelectWordDelim, Text[SelEnd]))
 		{
 			break;
 		}
 	}
 
 	Invalidate();
 }
 
 typedef int (*StringCompareFn)(const char16 *a, const char16 *b, ssize_t n);
 
 ptrdiff_t LTextView4::MatchText(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	if (!ValidStrW(Find))
 		return -1;
 
 	ssize_t FindLen = StrlenW(Find);
 		
 	// Setup range to search
 	ssize_t Begin, End;
 	if (SelectionOnly && HasSelection())
 	{
 		Begin = MIN(SelStart, SelEnd);
 		End = MAX(SelStart, SelEnd);
 	}
 	else
 	{
 		Begin = 0;
 		End = Size;
 	}
 
 	// Look through text...
 	ssize_t i;
 	bool Wrap = false;
 	if (Cursor > End - FindLen)
 	{
 		Wrap = true;
 		if (SearchUpwards)
 			i = End - FindLen;
 		else
 			i = Begin;
 	}
 	else
 	{
 		i = Cursor;
 	}
 		
 	if (i < Begin) i = Begin;
 	if (i > End) i = End;
 	
 	StringCompareFn CmpFn = MatchCase ? StrncmpW : StrnicmpW;
 	char16 FindCh = MatchCase ? Find[0] : toupper(Find[0]);
 
 	for (; SearchUpwards ? i >= Begin : i <= End - FindLen; i += SearchUpwards ? -1 : 1)
 	{
 		if
 		(
 			(MatchCase ? Text[i] : toupper(Text[i]))
 			==
 			FindCh
 		)
 		{
 			char16 *Possible = Text + i;
 
 			if (CmpFn(Possible, Find, FindLen) == 0)
 			{
 				if (MatchWord)
 				{
 					// Check boundaries
 							
 					if (Possible > Text) // Check off the start
 					{
 						if (!IsWordBoundry(Possible[-1]))
 							continue;
 					}
 					if (i + FindLen < Size) // Check off the end
 					{
 						if (!IsWordBoundry(Possible[FindLen]))
 							continue;
 					}
 				}
 						
 				LRange r(Possible - Text, FindLen);
 				if (!r.Overlap(Cursor))
 					return r.Start;
 			}
 		}
 				
 		if (!Wrap && (i + 1 > End - FindLen))
 		{
 			Wrap = true;
 			i = Begin;
 			End = Cursor;
 		}
 	}
 	
 	return -1;
 }
 
 bool LTextView4::OnFind(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	// Not sure what this is doing???
 	if (HasSelection() &&
 		SelEnd < SelStart)
 	{
 		Cursor = SelStart;
 	}
 
 	#if FEATURE_HILIGHT_ALL_MATCHES
 
 	// Clear existing styles for matches
 	for (StyleIter s = Style.begin(); s != Style.end(); )
 	{
 		if (s->Owner == STYLE_FIND_MATCHES)
 			Style.Delete(s);
 		else
 			s++;
 	}
 
 	ssize_t FindLen = StrlenW(Find);
 	ssize_t FirstLoc = MatchText(Find, MatchWord, MatchCase, false, SearchUpwards), Loc;
 	if (FirstLoc >= 0)
 	{
 		SetCaret(FirstLoc, false);
 		SetCaret(FirstLoc + FindLen, true);
 	}
 
 	ssize_t Old = Cursor;
 	if (!SearchUpwards)
 		Cursor += FindLen;
 	
 	while ((Loc = MatchText(Find, MatchWord, MatchCase, false, false)) != FirstLoc)
 	{
 		LAutoPtr<LStyle> s(new LStyle(STYLE_FIND_MATCHES));
 		s->Start = Loc;
 		s->Len = FindLen;
 		s->Fore = LColour(L_FOCUS_SEL_FORE);
 		s->Back = LColour(L_FOCUS_SEL_BACK).Mix(LColour(L_WORKSPACE));
 		InsertStyle(s);
 
 		Cursor = Loc + FindLen;
 	}
 
 	Cursor = Old;
 	ScrollToOffset(Cursor);
 	Invalidate();
 
 	#else
 
 	ssize_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 	if (Loc >= 0)
 	{
 		SetCaret(Loc, false);
 		SetCaret(Loc + StrlenW(Find), true);
 		return true;
 	}
 
 	#endif
 
 	return false;
 }
 
 bool LTextView4::OnReplace(const char16 *Find, const char16 *Replace, bool All, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	if (ValidStrW(Find))
 	{
 		// int Max = -1;
 		ssize_t FindLen = StrlenW(Find);
 		ssize_t ReplaceLen = StrlenW(Replace);
 		// size_t OldCursor = Cursor;
 		ptrdiff_t First = -1;
 
 		while (true)
 		{
 			ptrdiff_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 			if (First < 0)
 			{
 				First = Loc;
 			}
 			else if (Loc == First)
 			{
 				break;
 			}
 			
 			if (Loc >= 0)
 			{
 				ssize_t OldSelStart = SelStart;
 				ssize_t OldSelEnd = SelEnd;
 				
 				Delete(Loc, FindLen);
 				Insert(Loc, Replace, ReplaceLen);
 				
 				SelStart = OldSelStart;
 				SelEnd = OldSelEnd - FindLen + ReplaceLen;
 				Cursor = Loc + ReplaceLen;
 			}
 			if (!All)
 			{
 				return Loc >= 0;
 			}
 			if (Loc < 0) break;
 		}
 	}	
 	
 	return false;
 }
 
 ssize_t LTextView4::SeekLine(ssize_t Offset, GTextViewSeek Where)
 {
 	THREAD_CHECK();
 
 	switch (Where)
 	{
 		case PrevLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 			
 			if (Offset > 0)
 				Offset--;
 			
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
 		case NextLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 
 			Offset++;
 			break;
 		}
 		case StartLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
  		case EndLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 			break;
 		}
 		default:
 		{
 			LAssert(false);
 			break;
 		}
 	}
 
 	return Offset;
 }
 
 bool LTextView4::OnMultiLineTab(bool In)
 {
 	bool Status = false;
 	ssize_t Min = MIN(SelStart, SelEnd);
 	ssize_t Max = MAX(SelStart, SelEnd), i;
 
 	Min = SeekLine(Min, StartLine);
 
 	int Ls = 0;
 	LArray<ssize_t> p;
 	for (i=Min; i<Max && i<Size; i=SeekLine(i, NextLine))
 	{
 		p.Add(i);
 		Ls++;
 	}
 	if (Max < i)
 	{
 		Max = SeekLine(Max, EndLine);
 	}
 
 	PourEnabled = false;
 
 	ssize_t *Indexes = p.AddressOf(0);
 	if (!Indexes)
 		return false;
 
 	UndoCur = new LTextView4Undo(this);
 
 	for (i=Ls-1; i>=0; i--)
 	{
 		if (In)
 		{
 			// <-
 			ssize_t n = Indexes[i], Space = 0;
 			for (; Space<IndentSize && n<Size; n++)
 			{
 				if (Text[n] == 9)
 				{
 					Space += IndentSize;
 				}
 				else if (Text[n] == ' ')
 				{
 					Space += 1;
 				}
 				else
 				{
 					break;
 				}
 			}
 
 			ssize_t Chs = n-Indexes[i];
 			Delete(Indexes[i], Chs);
 			Max -= Chs;
 		}
 		else
 		{
 			// ->
 			ssize_t Len = Indexes[i];
 			for (; Text[Len] != '\n' && Len<Size; Len++);
 			if (Len > Indexes[i])
 			{
 				if (HardTabs)
 				{
 					char16 Tab[] = {'\t', 0};
 					Insert(Indexes[i], Tab, 1);
 					Max++;
 				}
 				else
 				{
 					char16 *Sp = new char16[IndentSize];
 					if (Sp)
 					{
 						for (int n=0; n<IndentSize; n++)
 							Sp[n] = ' ';
 						Insert(Indexes[i], Sp, IndentSize);
 						Max += IndentSize;
 					}
 				}
 			}
 		}
 	}
 
 	if (UndoCur->Changes.Length())
 	{
 		UndoQue += UndoCur;
 		UndoCur = NULL;
 	}
 	else
 	{
 		DeleteObj(UndoCur);
 	}
 
 	SelStart = Min;
 	SelEnd = Cursor = Max;
 
 	PourEnabled = true;
 	PourText(Min, Max - Min);
 	PourStyle(Min, Max - Min);
 	
 	d->SetDirty(Min, Max-Min);
 	Invalidate();
 	Status = true;
 
 	return Status;
 }
 
 void LTextView4::OnSetHidden(int Hidden)
 {
 }
 
 void LTextView4::OnPosChange()
 {
 	static bool Processing = false;
 
 	if (!Processing)
 	{
 		Processing = true;
 		LLayout::OnPosChange();
 
 		LRect c = GetClient();
 		bool ScrollYNeeded = c.Y() < (Line.Length() * LineY);
 		bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 		if (ScrollChange)
 		{
 			// printf("%s:%i - SetScrollBars(%i)\n", _FL, ScrollYNeeded);
 			SetScrollBars(false, ScrollYNeeded);
 		}
 		UpdateScrollBars();
 
 		if (GetWrapType() && d->PourX != X())
 		{
 			d->PourX = X();
 			d->SetDirty(0, Size);
 		}
 		Processing = false;
 	}
 }
 
 int LTextView4::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	Formats.Supports("text/uri-list");
 	Formats.Supports("text/html");
 	Formats.Supports("UniformResourceLocatorW");
 	return Formats.Length() ? DROPEFFECT_COPY : DROPEFFECT_NONE;
 }
 
 int LTextView4::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	int Status = DROPEFFECT_NONE;
 	
 	for (unsigned i=0; i<Data.Length(); i++)
 	{
 		LDragData &dd = Data[i];
 		if (dd.Data.Length() <= 0)
 			continue;
 		
 		if (dd.IsFormat("text/html") || dd.IsFormat("UniformResourceLocatorW"))
 		{
 			LVariant *Data = &dd.Data[0];
 			LAssert(dd.Data.Length() == 1); // Impl multiple data entries if this asserts.
 			if (Data->IsBinary())
 			{
 				OsChar *e = (OsChar*) ((char*)Data->Value.Binary.Data + Data->Value.Binary.Length);
 				OsChar *s = (OsChar*) Data->Value.Binary.Data;
 				int len = 0;
 				while (s < e && s[len])
 				{
 					len++;
 				}
 				
 				LAutoWString w
 				(
 					(char16*)LNewConvertCp
 					(
 						LGI_WideCharset,
 						s,
 						(
 							sizeof(OsChar) == 1
 							?
 							"utf-8"
 							:
 							LGI_WideCharset
 						),
 						len * sizeof(*s)
 					)
 				);
 				
 				Insert(Cursor, w, len);
 				Invalidate();
 				return DROPEFFECT_COPY;
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			// We don't directly handle file drops... pass up to the parent
 			bool FoundTarget = false;
 			for (LViewI *p = GetParent(); p; p = p->GetParent())
 			{
 				LDragDropTarget *t = p->DropTarget();
 				if (t)
 				{
 					Status = t->OnDrop(Data, Pt, KeyState);
 					if (Status != DROPEFFECT_NONE)
 					{
 						FoundTarget = true;
 						break;
 					}
 				}
 			}
 			if (!FoundTarget)
 			{
 				auto Wnd = GetWindow();
 				if (Wnd)
 				{
 					LDropFiles files(dd);
 					Wnd->OnReceiveFiles(files);
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 void LTextView4::OnCreate()
 {
 	SetWindow(this);
 	DropTarget(true);
 
 	#ifndef WINDOWS
 	if (Ctrls.Length() == 0)
 	#endif
 		SetPulse(PULSE_TIMEOUT);
 	#ifndef WINDOWS
 	Ctrls.Add(this);
 	#endif
 }
 
 void LTextView4::OnEscape(LKey &K)
 {
 }
 
 bool LTextView4::OnMouseWheel(double l)
 {
 	if (VScroll)
 	{
 		int64 NewPos = VScroll->Value() + (int)l;
 		NewPos = limit(NewPos, 0, (ssize_t)GetLines());
 		VScroll->Value(NewPos);
 		Invalidate();
 	}
 	
 	return true;
 }
 
 void LTextView4::OnFocus(bool f)
 {
 	Invalidate();
 }
 
 ssize_t LTextView4::HitText(int x, int y, bool Nearest)
 {
 	if (!Text)
 		return 0;
 
 	bool Down = y >= 0;
 	auto Y = VScroll ? VScroll->Value() : 0;
 	if (Y < (ssize_t)Line.Length())
 		y += Line[Y]->r.y1;
 
 	while (Y>=0 && Y<(ssize_t)Line.Length())
 	{
 		auto l = Line[Y];
 
 		if (l->r.Overlap(x, y))
 		{
 			// Over a line
 			int At = x - l->r.x1;
 			ssize_t Char = 0;
 				
 			LDisplayString Ds(Font, MapText(Text + l->Start, l->Len), l->Len, 0);
 			Char = Ds.CharAt(At, Nearest ? LgiNearest : LgiTruncate);
 
 			return l->Start + Char;
 		}
 		else if (y >= l->r.y1 && y <= l->r.y2)
 		{
 			// Click horizontally before of after line
 			if (x < l->r.x1)
 				return l->Start;
 			else if (x > l->r.x2)
 				return l->Start + l->Len;
 		}
 			
 		if (Down)
 			Y++;
 		else
 			Y--;
 	}
 
 	// outside text area
 	if (Down)
 	{
 		if (Line.Length())
 		{
 			if (y > Line.Last()->r.y2)
 			{
 				// end of document
 				return Size;
 			}
 		}
 	}
 
 	return 0;
 }
 
 void LTextView4::Undo()
 {
 	int Old = UndoQue.GetPos();
 	UndoQue.Undo();
 	if (Old && !UndoQue.GetPos())
 	{
 		Dirty = false;
 		SendNotify(LNotifyDocChanged);
 	}
 }
 
 void LTextView4::Redo()
 {
 	UndoQue.Redo();
 }
 
 void LTextView4::DoContextMenu(LMouse &m)
 {
 	LSubMenu RClick;
 	LAutoString ClipText;
 	{
 		LClipBoard Clip(this);
 		ClipText.Reset(NewStr(Clip.Text()));
 	}
 
 	LStyle *s = HitStyle(HitText(m.x, m.y, true));
 	if (s)
 	{
 		if (OnStyleMenu(s, &RClick))
 		{
 			RClick.AppendSeparator();
 		}
 	}
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_CUT, "Cut"), IDM_CUT, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_COPY, "Copy"), IDM_COPY, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_PASTE, "Paste"), IDM_PASTE, ClipText != 0);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem("Copy All", IDM_COPY_ALL, true);
 	RClick.AppendItem("Select All", IDM_SELECT_ALL, true);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_UNDO, "Undo"), IDM_UNDO, UndoQue.CanUndo());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_REDO, "Redo"), IDM_REDO, UndoQue.CanRedo());
 	RClick.AppendSeparator();
 
 	auto i = RClick.AppendItem(LLoadString(L_TEXTCTRL_FIXED, "Fixed Width Font"), IDM_FIXED, true);
 	if (i) i->Checked(GetFixedWidthFont());
 
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_AUTO_INDENT, "Auto Indent"), IDM_AUTO_INDENT, true);
 	if (i) i->Checked(AutoIndent);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_SHOW_WHITESPACE, "Show Whitespace"), IDM_SHOW_WHITE, true);
 	if (i) i->Checked(ShowWhiteSpace);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_HARD_TABS, "Hard Tabs"), IDM_HARD_TABS, true);
 	if (i) i->Checked(HardTabs);
 	
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_INDENT_SIZE, "Indent Size"), IDM_INDENT_SIZE, true);
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_TAB_SIZE, "Tab Size"), IDM_TAB_SIZE, true);
 
 	if (Environment)
 		Environment->AppendItems(&RClick, NULL);
 
 	int Id = 0;
 	m.ToScreen();
 	switch (Id = RClick.Float(this, m))
 	{
 		case IDM_FIXED:
 		{
 			SetFixedWidthFont(!GetFixedWidthFont());							
 			SendNotify(LNotifyFixedWidthChanged);
 			break;
 		}
 		case IDM_CUT:
 		{
 			Cut();
 			break;
 		}
 		case IDM_COPY:
 		{
 			Copy();
 			break;
 		}
 		case IDM_PASTE:
 		{
 			Paste();
 			break;
 		}
 		case IDM_COPY_ALL:
 		{
 			SelectAll();
 			Copy();
 			break;
 		}
 		case IDM_SELECT_ALL:
 		{
 			SelectAll();
 			break;
 		}
 		case IDM_UNDO:
 		{
 			Undo();
 			break;
 		}
 		case IDM_REDO:
 		{
 			Redo();
 			break;
 		}
 		case IDM_AUTO_INDENT:
 		{
 			AutoIndent = !AutoIndent;
 			break;
 		}
 		case IDM_SHOW_WHITE:
 		{
 			ShowWhiteSpace = !ShowWhiteSpace;
 			Invalidate();
 			break;
 		}
 		case IDM_HARD_TABS:
 		{
 			HardTabs = !HardTabs;
 			break;
 		}
 		case IDM_INDENT_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", IndentSize);
 			
 			LInput *i = new LInput(this, s, "Indent Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
 				if (code)
 					IndentSize = atoi(i->GetStr());
 				delete i;
 			});
 			break;
 		}
 		case IDM_TAB_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", TabSize);
 			
 			LInput *i = new LInput(this, s, "Tab Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
-				SetTabSize(atoi(i->GetStr()));
+				if (code)
+					SetTabSize((uint8_t)Atoi(i->GetStr().Get()));
 				delete i;
 			});
 			break;
 		}
 		default:
 		{
 			if (s)
 			{
 				OnStyleMenuClick(s, Id);
 			}
 
 			if (Environment)
 			{
 				Environment->OnMenu(this, Id, 0);
 			}
 			break;
 		}
 	}
 }
 
 bool LTextView4::OnStyleClick(LStyle *style, LMouse *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			if
 			(
 				(!m)
 				||
 				(m->Left() && m->Down() && m->Double())
 			)
 			{
 				LString s(Text + style->Start, style->Len);
 				if (s)
 					OnUrl(s);
 				return true;
 			}
 			break;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 bool LTextView4::OnStyleMenu(LStyle *style, LSubMenu *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 			if (LIsValidEmail(s))
 				m->AppendItem(LLoadString(L_TEXTCTRL_EMAIL_TO, "New Email to..."), IDM_NEW, true);
 			else
 				m->AppendItem(LLoadString(L_TEXTCTRL_OPENURL, "Open URL"), IDM_OPEN, true);
 
 			m->AppendItem(LLoadString(L_TEXTCTRL_COPYLINK, "Copy link location"), IDM_COPY_URL, true);
 			return true;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 void LTextView4::OnStyleMenuClick(LStyle *style, int i)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 
 			switch (i)
 			{
 				case IDM_NEW:
 				case IDM_OPEN:
 				{
 					if (s)
 						OnUrl(s);
 					break;
 				}
 				case IDM_COPY_URL:
 				{
 					if (s)
 					{
 						LClipBoard Clip(this);
 						Clip.Text(s);
 					}
 					break;
 				}
 			}
 			break;
 		}
 		default:
 			break;
 	}
 }
 
 void LTextView4::OnMouseClick(LMouse &m)
 {
 	bool Processed = false;
 
 	m.x += ScrollX;
 
 	if (m.Down())
 	{
 		if (!m.IsContextMenu())
 		{
 			Focus(true);
 
 			ssize_t Hit = HitText(m.x, m.y, true);
 			if (Hit >= 0)
 			{
 				SetCaret(Hit, m.Shift());
 
 				LStyle *s = HitStyle(Hit);
 				if (s)
 					Processed = OnStyleClick(s, &m);
 			}
 
 			if (!Processed && m.Double())
 			{
 				d->WordSelectMode = Cursor;
 				SelectWord(Cursor);
 			}
 			else
 			{
 				d->WordSelectMode = -1;
 			}
 		}
 		else
 		{
 			DoContextMenu(m);
 			return;
 		}
 	}
 
 	if (!Processed)
 	{
 		Capture(m.Down());
 	}
 }
 
 int LTextView4::OnHitTest(int x, int y)
 {
 	#ifdef WIN32
 	if (GetClient().Overlap(x, y))
 	{
 		return HTCLIENT;
 	}
 	#endif
 	return LView::OnHitTest(x, y);
 }
 
 void LTextView4::OnMouseMove(LMouse &m)
 {
 	m.x += ScrollX;
 
 	ssize_t Hit = HitText(m.x, m.y, true);
 	if (IsCapturing())
 	{
 		if (d->WordSelectMode < 0)
 		{
 			SetCaret(Hit, m.Left());
 		}
 		else
 		{
 			ssize_t Min = Hit < d->WordSelectMode ? Hit : d->WordSelectMode;
 			ssize_t Max = Hit > d->WordSelectMode ? Hit : d->WordSelectMode;
 
 			for (SelStart = Min; SelStart > 0; SelStart--)
 			{
 				if (strchr(SelectWordDelim, Text[SelStart]))
 				{
 					SelStart++;
 					break;
 				}
 			}
 
 			for (SelEnd = Max; SelEnd < Size; SelEnd++)
 			{
 				if (strchr(SelectWordDelim, Text[SelEnd]))
 				{
 					break;
 				}
 			}
 
 			Cursor = SelEnd;
 			Invalidate();
 		}
 	}
 }
 
 LCursor LTextView4::GetCursor(int x, int y)
 {
 	LRect c = GetClient();
 	c.Offset(-c.x1, -c.y1);
 	LStyle *s = NULL;
 	if (c.Overlap(x, y))
 	{
 		ssize_t Hit = HitText(x, y, true);
 		s = HitStyle(Hit);
 	}
 
 	return s ? s->Cursor : LCUR_Ibeam;
 }
 
 int LTextView4::GetColumn()
 {
 	int x = 0;
 	LTextLine *l = GetTextLine(Cursor);
 	if (l)
 	{
 		for (ssize_t i=l->Start; i<Cursor; i++)
 		{
 			if (Text[i] == '\t')
 			{
 				x += TabSize - (x % TabSize);
 			}
 			else
 			{
 				x++;
 			}
 		}
 	}
 	return x;
 }
 
 int LTextView4::SpaceDepth(char16 *Start, char16 *End)
 {
 	int Depth = 0;
 	while (Start < End)
 	{
 		if (*Start == '\t')
 			Depth += IndentSize - (Depth % IndentSize);
 		else if (*Start == ' ')
 			Depth ++;
 		else break;
 		Start++;
 	}
 	return Depth;
 }
 
 bool LTextView4::OnKey(LKey &k)
 {
 	if (k.Down())
 	{
 		Blink = true;
 	}
 
 	// k.Trace("LTextView4::OnKey");
 
 	if (k.IsContextMenu())
 	{
 		LMouse m;
 		m.x = CursorPos.x1;
 		m.y = CursorPos.y1 + (CursorPos.Y() >> 1);
 		m.Target = this;
 		DoContextMenu(m);
 	}
 	else if (k.IsChar)
 	{
 		switch (k.vkey)
 		{
 			default:
 			{
 				// process single char input
 				if
 				(
 					!GetReadOnly()
 					&&
 					(
 						(k.c16 >= ' ' || k.vkey == LK_TAB)
 						&&
 						k.c16 != 127
 					)
 				)
 				{
 					if (k.Down())
 					{
 						// letter/number etc
 						if (SelStart >= 0)
 						{
 							bool MultiLine = false;
 							if (k.vkey == LK_TAB)
 							{
 								size_t Min = MIN(SelStart, SelEnd), Max = MAX(SelStart, SelEnd);
 								for (size_t i=Min; i<Max; i++)
 								{
 									if (Text[i] == '\n')
 									{
 										MultiLine = true;
 									}
 								}
 							}
 							if (MultiLine)
 							{
 								if (OnMultiLineTab(k.Shift()))
 								{
 									return true;
 								}
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						
 						LTextLine *l = GetTextLine(Cursor);
 						size_t Len = (l) ? l->Len : 0;
 						
 						if (l && k.vkey == LK_TAB && (!HardTabs || IndentSize != TabSize))
 						{
 							int x = GetColumn();							
 							int Add = IndentSize - (x % IndentSize);
 							
 							if (HardTabs && ((x + Add) % TabSize) == 0)
 							{
 								int Rx = x;
 								size_t Remove;
 								for (Remove = Cursor; Text[Remove - 1] == ' ' && Rx % TabSize != 0; Remove--, Rx--);
 								ssize_t Chars = (ssize_t)Cursor - Remove;
 								Delete(Remove, Chars);
 								Insert(Remove, &k.c16, 1);
 								Cursor = Remove + 1;
 								
 								Invalidate();
 							}
 							else
 							{							
 								char16 *Sp = new char16[Add];
 								if (Sp)
 								{
 									for (int n=0; n<Add; n++) Sp[n] = ' ';
 									if (Insert(Cursor, Sp, Add))
 									{
 										l = GetTextLine(Cursor);
 										size_t NewLen = (l) ? l->Len : 0;
 										SetCaret(Cursor + Add, false, Len != NewLen - 1);
 									}
 									DeleteArray(Sp);
 								}
 							}
 						}
 						else
 						{
 							char16 In = k.GetChar();
 
 							if (In == '\t' &&
 								k.Shift() &&
 								Cursor > 0)
 							{
 								l = GetTextLine(Cursor);
 								if (Cursor > l->Start)
 								{
 									if (Text[Cursor-1] == '\t')
 									{
 										Delete(Cursor - 1, 1);
 										SetCaret(Cursor, false, false);
 									}
 									else if (Text[Cursor-1] == ' ')
 									{
 										ssize_t Start = (ssize_t)Cursor - 1;
 										while (Start >= l->Start && strchr(" \t", Text[Start-1]))
 											Start--;
 										int Depth = SpaceDepth(Text + Start, Text + Cursor);
 										int NewDepth = Depth - (Depth % IndentSize);
 										if (NewDepth == Depth && NewDepth > 0)
 											NewDepth -= IndentSize;
 										int Use = 0;
 										while (SpaceDepth(Text + Start, Text + Start + Use + 1) < NewDepth)
 											Use++;
 										Delete(Start + Use, Cursor - Start - Use);
 										SetCaret(Start + Use, false, false);
 									}
 								}
 								
 							}
 							else if (In && Insert(Cursor, &In, 1))
 							{
 								l = GetTextLine(Cursor);
 								size_t NewLen = (l) ? l->Len : 0;
 								SetCaret(Cursor + 1, false, Len != NewLen - 1);
 							}
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			case LK_RETURN:
 			#if defined MAC
 			case LK_KEYPADENTER:
 			#endif
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Down() && k.IsChar)
 				{
 					OnEnter(k);
 				}
 				return true;
 				break;
 			}
 			case LK_BACKSPACE:
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Ctrl())
 				{
 				    // Ctrl+H
 				}
 				else if (k.Down())
 				{
 					if (SelStart >= 0)
 					{
 						// delete selection
 						DeleteSelection();
 					}
 					else
 					{						
 						char Del = Cursor > 0 ? Text[Cursor-1] : 0;
 						
 						if (Del == ' ' && (!HardTabs || IndentSize != TabSize))
 						{
 							// Delete soft tab
 							int x = GetColumn();
 							int Max = x % IndentSize;
 							if (Max == 0) Max = IndentSize;
 							ssize_t i;
 							for (i=Cursor-1; i>=0; i--)
 							{
 								if (Max-- <= 0 || Text[i] != ' ')
 								{
 									i++;
 									break;
 								}
 							}
 							
 							if (i < 0) i = 0;
 							
 							if (i < Cursor - 1)
 							{
 								ssize_t Del = (ssize_t)Cursor - i;
 								Delete(i, Del);
 								// SetCursor(i, false, false);
 								// Invalidate();
 								break;
 							}
 						}
 						else if (Del == '\t' && HardTabs && IndentSize != TabSize)
 						{
 							int x = GetColumn();
 							Delete(--Cursor, 1);
 							
 							for (int c=GetColumn(); c<x-IndentSize; c=GetColumn())
 							{
 								int Add = IndentSize + (c % IndentSize);
 								if (Add)
 								{
 									char16 *s = new char16[Add];
 									if (s)
 									{
 										for (int n=0; n<Add; n++) s[n] = ' ';
 										Insert(Cursor, s, Add);
 										Cursor += Add;
 										DeleteArray(s);
 									}
 								}
 								else break;
 							}
 							
 							Invalidate();
 							break;
 						}
 
 
 						if (Cursor > 0)
 						{
 							Delete(Cursor - 1, 1);
 						}
 					}
 				}
 				return true;
 				break;
 			}
 		}
 	}
 	else // not a char
 	{
 		switch (k.vkey)
 		{
 			case LK_TAB:
 				return true;
 			case LK_RETURN:
 			{
 				return !GetReadOnly();
 			}
 			case LK_BACKSPACE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Alt())
 					{
 						if (k.Down())
 						{
 							if (k.Ctrl())
 							{
 								Redo();
 							}
 							else
 							{
 								Undo();
 							}
 						}
 					}
 					else if (k.Ctrl())
 					{
 						if (k.Down())
 						{
 							ssize_t Start = Cursor;
 							while (IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							while (!IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							Delete(Cursor, Start - Cursor);
 							Invalidate();
 						}
 					}
 
 					return true;
 				}
 				break;
 			}
 			case LK_F3:
 			{
 				if (k.Down())
 				{
 					DoFindNext(NULL);
 				}
 				return true;
 				break;
 			}
 			case LK_LEFT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MIN(SelStart, SelEnd), false);
 					}
 					else if (Cursor > 0)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_StartOfLine;
 						}
 						else
 						if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							bool StartWhiteSpace = IsWhiteSpace(Text[n]);
 							bool LeftWhiteSpace = n > 0 && IsWhiteSpace(Text[n-1]);
 
 							if (!StartWhiteSpace ||
 								Text[n] == '\n')
 							{
 								n--;
 							}
 							
 							// Skip ws
 							for (; n > 0 && strchr(" \t", Text[n]); n--)
 								;
 							
 							if (Text[n] == '\n')
 							{
 								n--;
 							}
 							else if (!StartWhiteSpace || !LeftWhiteSpace)
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									for (; n > 0 && IsDelimiter(Text[n]); n--);
 								}
 								else
 								{
 									for (; n > 0; n--)
 									{
 										//IsWordBoundry(Text[n])
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 							}
 							if (n > 0) n++;
 						}
 						else
 						{
 							// single char
 							n--;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_RIGHT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MAX(SelStart, SelEnd), false);
 					}
 					else if (Cursor < Size)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_EndOfLine;
 						}
 						else if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							if (IsWhiteSpace(Text[n]))
 							{
 								for (; n<Size && IsWhiteSpace(Text[n]); n++);
 							}
 							else
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									while (IsDelimiter(Text[n]))
 									{
 										n++;
 									}
 								}
 								else
 								{
 									for (; n<Size; n++)
 									{
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 
 								if (n < Size &&
 									Text[n] != '\n')
 								{
 									if (IsWhiteSpace(Text[n]))
 									{
 										n++;
 									}
 								}
 							}
 						}
 						else
 						{
 							// single char
 							n++;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_UP:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView4_PageUp;
 					#endif
 					
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It--;
 						if (It != Line.end())
 						{
 							LTextLine *Prev = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 
 							LDisplayString PrevLine(Font, Text + Prev->Start, Prev->Len);
 							ssize_t CharX = PrevLine.CharAt(ScreenX);
 
 							SetCaret(Prev->Start + MIN(CharX, Prev->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DOWN:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView4_PageDown;
 					#endif
 
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It++;
 						if (It != Line.end())
 						{
 							LTextLine *Next = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 							
 							LDisplayString NextLine(Font, Text + Next->Start, Next->Len);
 							ssize_t CharX = NextLine.CharAt(ScreenX);
 
 							SetCaret(Next->Start + MIN(CharX, Next->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_END:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(Size, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_EndOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							SetCaret(l->Start + l->Len, k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_HOME:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(0, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_StartOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							char16 *Line = Text + l->Start;
 							char16 *s;
 							char16 SpTab[] = {' ', '\t', 0};
 							for (s = Line; (SubtractPtr(s,Line) < l->Len) && StrchrW(SpTab, *s); s++);
 							ssize_t Whitespace = SubtractPtr(s, Line);
 
 							if (l->Start + Whitespace == Cursor)
 							{
 								SetCaret(l->Start, k.Shift());
 							}
 							else
 							{
 								SetCaret(l->Start + Whitespace, k.Shift());
 							}
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEUP:
 			{
 				#ifdef MAC
 				LTextView4_PageUp:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MAX(CurLine - DisplayLines, 0));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEDOWN:
 			{
 				#ifdef MAC
 				LTextView4_PageDown:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MIN(CurLine + DisplayLines, (ssize_t)GetLines()-1));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_INSERT:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						Copy();
 					}
 					else if (k.Shift())
 					{
 						if (!GetReadOnly())
 						{
 							Paste();
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DELETE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Down())
 					{
 						if (SelStart >= 0)
 						{
 							if (k.Shift())
 							{
 								Cut();
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						else if (Cursor < Size &&
 								Delete(Cursor, 1))
 						{
 							Invalidate();
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			default:
 			{
 				if (k.c16 == 17) break;
 
 				if (k.CtrlCmd() &&
 					!k.Alt())
 				{
 					switch (k.GetChar())
 					{
 						case 0xbd: // Ctrl+'-'
 						{
 							if (k.Down() &&
 								Font->PointSize() > 1)
 							{
 								Font->PointSize(Font->PointSize() - 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 0xbb: // Ctrl+'+'
 						{
 							if (k.Down() &&
 								Font->PointSize() < 100)
 							{
 								Font->PointSize(Font->PointSize() + 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 'a':
 						case 'A':
 						{
 							if (k.Down())
 							{
 								// select all
 								SelStart = 0;
 								SelEnd = Size;
 								Invalidate();
 							}
 							return true;
 							break;
 						}
 						case 'y':
 						case 'Y':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Redo();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'z':
 						case 'Z':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									if (k.Shift())
 									{
 										Redo();
 									}
 									else
 									{
 										Undo();
 									}
 								}
 								return true;
 							}
 							break;
 						}
 						case 'x':
 						case 'X':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Cut();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'c':
 						case 'C':
 						{
 							if (k.Shift())
 								return false;
 							
 							if (k.Down())
 								Copy();
 							return true;
 							break;
 						}
 						case 'v':
 						case 'V':
 						{
 							if (!k.Shift() &&
 								!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Paste();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'f':
 						{
 							if (k.Down())
 							{
 								DoFind(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'g':
 						case 'G':
 						{
 							if (k.Down())
 							{
 								DoGoto(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'h':
 						case 'H':
 						{
 							if (k.Down())
 							{
 								DoReplace(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'u':
 						case 'U':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									DoCase(NULL, k.Shift());
 								}
 								return true;
 							}
 							break;
 						}
 						case LK_RETURN:
 						{
 							if (!GetReadOnly() && !k.Shift())
 							{
 								if (k.Down())
 								{
 									OnEnter(k);
 								}
 								return true;
 							}
 							break;
 						}
 					}
 				}
 				break;
 			}
 		}
 	}
 	
 	return false;
 }
 
 void LTextView4::OnEnter(LKey &k)
 {
 	// enter
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	char16 InsertStr[256] = {'\n', 0};
 
 	LTextLine *CurLine = GetTextLine(Cursor);
 	if (CurLine && AutoIndent)
 	{
 		int WsLen = 0;
 		for (;	WsLen < CurLine->Len &&
 				WsLen < (Cursor - CurLine->Start) &&
 				strchr(" \t", Text[CurLine->Start + WsLen]); WsLen++);
 		if (WsLen > 0)
 		{
 			memcpy(InsertStr+1, Text+CurLine->Start, WsLen * sizeof(char16));
 			InsertStr[WsLen+1] = 0;
 		}
 	}
 
 	if (Insert(Cursor, InsertStr, StrlenW(InsertStr)))
 	{
 		SetCaret(Cursor + StrlenW(InsertStr), false, true);
 	}
 }
 
 int LTextView4::TextWidth(LFont *f, char16 *s, int Len, int x, int Origin)
 {
 	int w = x;
 	int Size = f->TabSize();
 
 	for (char16 *c = s; SubtractPtr(c, s) < Len; )
 	{
 		if (*c == 9)
 		{			
 			w = ((((w-Origin) + Size) / Size) * Size) + Origin;
 			c++;
 		}
 		else
 		{
 			char16 *e;
 			for (e = c; SubtractPtr(e, s) < Len && *e != 9; e++);
 			
 			LDisplayString ds(f, c, SubtractPtr(e, c));
 			w += ds.X();
 			c = e;
 		}
 	}
 
 	return w - x;
 }
 
 int LTextView4::ScrollYLine()
 {
 	return (VScroll) ? (int)VScroll->Value() : 0;
 }
 
 int LTextView4::ScrollYPixel()
 {
 	return ScrollYLine() * LineY;
 }
 
 LRect LTextView4::DocToScreen(LRect r)
 {
 	r.Offset(0, d->rPadding.y1 - ScrollYPixel());
 	return r;
 }
 
 void LTextView4::OnPaintLeftMargin(LSurface *pDC, LRect &r, LColour &colour)
 {
 	pDC->Colour(colour);
 	pDC->Rectangle(&r);
 }
 
 void LTextView4::OnPaint(LSurface *pDC)
 {
 	#if LGI_EXCEPTIONS
 	try
 	{
 	#endif
 
 	#if PROFILE_PAINT
 	char s[256];
 	sprintf_s(s, sizeof(s), "%p::OnPaint Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(s);
 	#endif
 
 		if (d->LayoutDirty)
 		{
 	#if PROFILE_PAINT
 	Prof.Add("PourText");
 	#endif
 			PourText(d->DirtyStart, d->DirtyLen);
 	#if PROFILE_PAINT
 	Prof.Add("PourStyle");
 	#endif
 			PourStyle(d->DirtyStart, d->DirtyLen);
 			
 			d->LayoutDirty = false;
 		}
 
 	#if PROFILE_PAINT
 	Prof.Add("Setup");
 	#endif
 		
 		LRect r = GetClient();
 		r.x2 += ScrollX;
 
 		int Ox, Oy;
 		pDC->GetOrigin(Ox, Oy);
 		pDC->SetOrigin(Ox+ScrollX, Oy);
 		
 		#if 0
 		// Coverage testing...
 		pDC->Colour(Rgb24(255, 0, 255), 24);
 		pDC->Rectangle();
 		#endif
 
 		LSurface *pOut = pDC;
 		bool DrawSel = false;
 		
 		bool HasFocus = Focus();
 		// printf("%s:%i - HasFocus = %i\n", _FL, HasFocus);
 		LColour SelectedText(HasFocus ? LColour(L_FOCUS_SEL_FORE) : LColour(L_NON_FOCUS_SEL_FORE));
 		LColour SelectedBack(HasFocus ? LColour(L_FOCUS_SEL_BACK) : LColour(L_NON_FOCUS_SEL_BACK));
 
 		LCss::ColorDef ForeDef, BkDef;
 		if (GetCss())
 		{
 			ForeDef = GetCss()->Color();
 			BkDef = GetCss()->BackgroundColor();
 		}
 		
 		LColour Fore(ForeDef.Type ==  LCss::ColorRgb ? LColour(ForeDef.Rgb32, 32) : LColour(L_TEXT));
 		LColour Back
 		(
 			/*!ReadOnly &&*/ BkDef.Type == LCss::ColorRgb
 			?
 			LColour(BkDef.Rgb32, 32)
 			:
 			Enabled() ? LColour(L_WORKSPACE) : LColour(L_MED)
 		);
 
 		// LColour Whitespace = Fore.Mix(Back, 0.85f);
 		if (!Enabled())
 		{
 			Fore = LColour(L_LOW);
 			Back = LColour(L_MED);
 		}
 
 		#ifdef DOUBLE_BUFFER_PAINT
 		LMemDC *pMem = new LMemDC;
 		pOut = pMem;
 		#endif
 		if (Text &&
 			Font
 			#ifdef DOUBLE_BUFFER_PAINT
 			&&
 			pMem &&
 			pMem->Create(r.X()-d->rPadding.x1, LineY, GdcD->GetBits())
 			#endif
 			)
 		{
 			ssize_t SelMin = MIN(SelStart, SelEnd);
 			ssize_t SelMax = MAX(SelStart, SelEnd);
 
 			// font properties
 			Font->Colour(Fore, Back);
 			// Font->WhitespaceColour(Whitespace);
 			Font->Transparent(false);
 
 			// draw margins
 			pDC->Colour(PAINT_BORDER);
 			// top margin
 			pDC->Rectangle(0, 0, r.x2, d->rPadding.y1-1);
 			// left margin
 			{
 				LRect LeftMargin(0, d->rPadding.y1, d->rPadding.x1-1, r.y2);
 				OnPaintLeftMargin(pDC, LeftMargin, PAINT_BORDER);
 			}
 		
 			// draw lines of text
 			int k = ScrollYLine();
 			LTextLine *l = NULL;
 			int Dy = 0;
 			if (k < Line.Length())
 				Dy = -Line[k]->r.y1;
 			ssize_t NextSelection = (SelStart != SelEnd) ? SelMin : -1; // offset where selection next changes
 			if (k < Line.Length() &&
 				(l = Line[k]) &&
 				SelStart >= 0 &&
 				SelStart < l->Start &&
 				SelEnd > l->Start)
 			{
 				// start of visible area is in selection
 				// init to selection colour
 				DrawSel = true;
 				Font->Colour(SelectedText, SelectedBack);
 				NextSelection = SelMax;
 			}
 
 			StyleIter Si = Style.begin();
 			LStyle *NextStyle = GetNextStyle(Si, (l) ? l->Start : 0);
 
 			DocOffset = (l) ? l->r.y1 : 0;
 
 	#if PROFILE_PAINT
 	Prof.Add("foreach Line loop");
 	#endif
 			// loop through all visible lines
 			int y = d->rPadding.y1;
 			while (	k < Line.Length() &&
 					(l = Line[k]) &&
 					l->r.y1+Dy < r.Y())
 			{
 				LRect Tr = l->r;
 				#ifdef DOUBLE_BUFFER_PAINT
 				Tr.Offset(-Tr.x1, -Tr.y1);
 				#else
 				Tr.Offset(0, y - Tr.y1);
 				#endif
 				//LRect OldTr = Tr;
 
 				// deal with selection change on beginning of line
 				if (NextSelection == l->Start)
 				{
 					// selection change
 					DrawSel = !DrawSel;
 					NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 				}
 				if (DrawSel)
 				{
 					Font->Colour(SelectedText, SelectedBack);
 				}
 				else
 				{
 					LColour fore = l->c.IsValid() ? l->c : Fore;
 					LColour back = l->Back.IsValid() ? l->Back : Back;
 					Font->Colour(fore, back);
 				}
 
 				// How many chars on this line have we
 				// processed so far:
 				ssize_t Done = 0;
 				bool LineHasSelection =	NextSelection >= l->Start &&
 										NextSelection < l->Start + l->Len;
 
 				// Fractional pixels we have moved so far:
 				int MarginF = d->rPadding.x1 << LDisplayString::FShift;
 				int FX = MarginF;
 				int FY = Tr.y1 << LDisplayString::FShift;
 				
 				// loop through all sections of similar text on a line
 				while (Done < l->Len)
 				{
 					// decide how big this block is
 					int RtlTrailingSpace = 0;
 					ssize_t Cur = l->Start + Done;
 					ssize_t Block = l->Len - Done;
 					
 					// check for style change
 					if (NextStyle &&
 						(ssize_t)NextStyle->End() <= l->Start)
 						NextStyle = GetNextStyle(Si);
 					if (NextStyle)
 					{
 						// start
 						if (l->Overlap(NextStyle->Start) &&
 							NextStyle->Start > Cur &&
 							NextStyle->Start - Cur < Block)
 						{
 							Block = NextStyle->Start - Cur;
 						}
 
 						// end
 						ssize_t StyleEnd = NextStyle->Start + NextStyle->Len;
 						if (l->Overlap(StyleEnd) &&
 							StyleEnd > Cur &&
 							StyleEnd - Cur < Block)
 						{
 							Block = StyleEnd - Cur;
 						}
 					}
 
 					// check for next selection change
 					// this may truncate the style
 					if (NextSelection > Cur &&
 						NextSelection - Cur < Block)
 					{
 						Block = NextSelection - Cur;
 					}
 
 					LAssert(Block != 0);	// sanity check
 					
 					if (NextStyle &&							// There is a style
 						(Cur < SelMin || Cur >= SelMax) &&		// && we're not drawing a selection block
 						Cur >= NextStyle->Start &&				// && we're inside the styled area
 						Cur < NextStyle->Start+NextStyle->Len)
 					{
 						LFont *Sf = NextStyle->Font ? NextStyle->Font : Font;
 						if (Sf)
 						{
 							// draw styled text
 							if (NextStyle->Fore.IsValid())
 								Sf->Fore(NextStyle->Fore);
 							if (NextStyle->Back.IsValid())
 								Sf->Back(NextStyle->Back);
 							else if (l->Back.IsValid())
 								Sf->Back(l->Back);
 							else
 								Sf->Back(Back);								
 
 							Sf->Transparent(false);
 
 							LAssert(l->Start + Done >= 0);
 
 							LDisplayString Ds(	Sf,
 												MapText(Text + (l->Start + Done),
 														Block,
 														RtlTrailingSpace != 0),
 												Block + RtlTrailingSpace);
 							Ds.SetDrawOffsetF(FX - MarginF);
 							Ds.ShowVisibleTab(ShowWhiteSpace);
 							Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 
 							if (NextStyle->Decor == LCss::TextDecorSquiggle)
 							{
 								pOut->Colour(NextStyle->DecorColour);
 								int x = FX >> LDisplayString::FShift;
 								int End = x + Ds.X();
 								while (x < End)
 								{
 									pOut->Set(x, Tr.y2-(x%2));
 									x++;
 								}
 							}
 
 							FX += Ds.FX();
 
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Sf->Colour(fore, back);
 						}
 						else LAssert(0);
 					}
 					else
 					{
 						// draw a block of normal text
 						LAssert(l->Start + Done >= 0);
 						
 						LDisplayString Ds(	Font,
 											MapText(Text + (l->Start + Done),
 													Block,
 													RtlTrailingSpace != 0),
 											Block + RtlTrailingSpace);
 						Ds.SetDrawOffsetF(FX - MarginF);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 						FX += Ds.FX();
 					}
 
 					if (NextStyle &&
 						Cur+Block >= NextStyle->Start+NextStyle->Len)
 					{
 						// end of this styled block
 						NextStyle = GetNextStyle(Si);
 					}
 
 					if (NextSelection == Cur+Block)
 					{
 						// selection change
 						DrawSel = !DrawSel;
 						if (DrawSel)
 						{
 							Font->Colour(SelectedText, SelectedBack);
 						}
 						else
 						{
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Font->Colour(fore, back);
 						}
 						NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 					}
 
 					Done += Block + RtlTrailingSpace;
 				
 				} // end block loop
 
 				Tr.x1 = FX >> LDisplayString::FShift;
 
 				// eol processing
 				ssize_t EndOfLine = l->Start+l->Len;
 				if (EndOfLine >= SelMin && EndOfLine < SelMax)
 				{
 					// draw the '\n' at the end of the line as selected
 					// LColour bk = Font->Back();
 					pOut->Colour(Font->Back());
 					pOut->Rectangle(Tr.x2, Tr.y1, Tr.x2+7, Tr.y2);
 					Tr.x2 += 7;
 				}
 				else Tr.x2 = Tr.x1;
 
 				// draw any space after text
 				pOut->Colour(PAINT_AFTER_LINE);
 				pOut->Rectangle(Tr.x2, Tr.y1, r.x2, Tr.y2);
 
 				// cursor?
 				if (HasFocus)
 				{
 					// draw the cursor if on this line
 					if (Cursor >= l->Start && Cursor <= l->Start+l->Len)
 					{
 						CursorPos.ZOff(1, LineY-1);
 
 						ssize_t At = Cursor-l->Start;
 						
 						LDisplayString Ds(Font, MapText(Text+l->Start, At), At);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						int CursorX = Ds.X();
 						CursorPos.Offset(d->rPadding.x1 + CursorX, Tr.y1);
 						
 						if (CanScrollX)
 						{
 							// Cursor on screen check
 							LRect Scr = GetClient();
 							Scr.Offset(ScrollX, 0);
 							LRect Cur = CursorPos;
 							if (Cur.x2 > Scr.x2 - 5) // right edge check
 							{
 								ScrollX = ScrollX + Cur.x2 - Scr.x2 + 40;
 								Invalidate();
 							}
 							else if (Cur.x1 < Scr.x1 && ScrollX > 0)
 							{
 								ScrollX = MAX(0, Cur.x1 - 40);
 								Invalidate();
 							}
 						}
 
 						if (Blink)
 						{
 							LRect c = CursorPos;
 							#ifdef DOUBLE_BUFFER_PAINT
 							c.Offset(-d->rPadding.x1, -y);
 							#endif
 
 							pOut->Colour(!ReadOnly ? Fore : LColour(192, 192, 192));
 							pOut->Rectangle(&c);
 						}
 
 						#if WINNATIVE
 						HIMC hIMC = ImmGetContext(Handle());
 						if (hIMC)
 						{
 							COMPOSITIONFORM Cf;						
 							Cf.dwStyle = CFS_POINT;
 							Cf.ptCurrentPos.x = CursorPos.x1;
 							Cf.ptCurrentPos.y = CursorPos.y1;
 							ImmSetCompositionWindow(hIMC, &Cf);
 							ImmReleaseContext(Handle(), hIMC);
 						}
 						#endif
 					}
 				}
 
 				#if DRAW_LINE_BOXES
 				{
 					uint Style = pDC->LineStyle(LSurface::LineAlternate);
 					LColour Old = pDC->Colour(LColour::Red);
 					pDC->Box(&OldTr);
 					pDC->Colour(Old);
 					pDC->LineStyle(Style);
 
 					LString s;
 					s.Printf("%i, %i", Line.IndexOf(l), l->Start);
 					LDisplayString ds(LSysFont, s);
 					LSysFont->Transparent(true);
 					ds.Draw(pDC, OldTr.x2 + 2, OldTr.y1);
 				}
 				#endif
 
 				#ifdef DOUBLE_BUFFER_PAINT
 				// dump to screen
 				pDC->Blt(d->rPadding.x1, y, pOut);
 				#endif
 				y += LineY;
 
 				k++;
 
 			} // end of line loop
 
 			// draw any space under the lines
 			if (y <= r.y2)
 			{
 				pDC->Colour(Back);
 				// pDC->Colour(LColour(255, 0, 255));
 				pDC->Rectangle(d->rPadding.x1, y, r.x2, r.y2);
 			}
 
 			#ifdef DOUBLE_BUFFER_PAINT
 			DeleteObj(pMem);
 			#endif
 		}
 		else
 		{
 			// default drawing: nothing
 			pDC->Colour(Back);
 			pDC->Rectangle(&r);
 		}
 
 		// _PaintTime = LCurrentTime() - StartTime;
 		#ifdef PAINT_DEBUG
 		if (GetNotify())
 		{
 			char s[256];
 			sprintf_s(s, sizeof(s), "Pour:%i Style:%i Paint:%i ms", _PourTime, _StyleTime, _PaintTime);
 			LMessage m = CreateMsg(DEBUG_TIMES_MSG, 0, (int)s);
 			GetNotify()->OnEvent(&m);
 		}
 		#endif
 		// printf("PaintTime: %ims\n", _PaintTime);
 	
 	#if LGI_EXCEPTIONS
 	}
 	catch (...)
 	{
 		LgiMsg(this, "LTextView4::OnPaint crashed.", "Lgi");
 	}
 	#endif
 }
 
 LMessage::Result LTextView4::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_TEXT_UPDATE_NAME:
 		{
 			if (d->Lock(_FL))
 			{
 				Name(d->SetName);
 				d->SetName.Empty();
 				d->Unlock();
 			}
 			break;
 		}
 		case M_TEXTVIEW_FIND:
 		{
 			if (InThread())
 				DoFindNext(NULL);
 			else
 				LgiTrace("%s:%i - Not in thread.\n", _FL);
 			break;
 		}
 		case M_TEXTVIEW_REPLACE:
 		{
 			// DoReplace();
 			break;
 		}
 		case M_CUT:
 		{
 			Cut();
 			break;
 		}
 		case M_COPY:
 		{
 			Copy();
 			break;
 		}
 		case M_PASTE:
 		{
 			Paste();
 			break;
 		}
 		#if defined WIN32
 		case WM_GETTEXTLENGTH:
 		{
 			return Size;
 		}
 		case WM_GETTEXT:
 		{
 			int Chars = (int)Msg->A();
 			char *Out = (char*)Msg->B();
 			if (Out)
 			{
 				char *In = (char*)LNewConvertCp(LAnsiToLgiCp(), NameW(), LGI_WideCharset, Chars);
 				if (In)
 				{
 					int Len = (int)strlen(In);
 					memcpy(Out, In, Len);
 					DeleteArray(In);
 					return Len;
 				}
 			}
 			return 0;
 		}
 
 		/* This is broken... the IME returns garbage in the buffer. :(
 		case WM_IME_COMPOSITION:
 		{
 			if (Msg->b & GCS_RESULTSTR) 
 			{
 				HIMC hIMC = ImmGetContext(Handle());
 				if (hIMC)
 				{
 					int Size = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);
 					char *Buf = new char[Size];
 					if (Buf)
 					{
 						ImmGetCompositionString(hIMC, GCS_RESULTSTR, Buf, Size);
 
 						char16 *Utf = (char16*)LNewConvertCp(LGI_WideCharset, Buf, LAnsiToLgiCp(), Size);
 						if (Utf)
 						{
 							Insert(Cursor, Utf, StrlenW(Utf));
 							DeleteArray(Utf);
 						}
 
 						DeleteArray(Buf);
 					}
 
 					ImmReleaseContext(Handle(), hIMC);
 				}
 				return 0;
 			}
 			break;
 		}
 		*/
 		#endif
 	}
 
 	return LLayout::OnEvent(Msg);
 }
 
 int LTextView4::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (Ctrl->GetId() == IDC_VSCROLL && VScroll)
 	{
 		if (n.Type == LNotifyScrollBarCreate)
 		{
 			UpdateScrollBars();
 		}
 			
 		Invalidate();
 	}
 
 	return 0;
 }
 
 void LTextView4::InternalPulse()
 {
 	if (!ReadOnly)
 	{
 		uint64 Now = LCurrentTime();
 		if (!BlinkTs)
 			BlinkTs = Now;
 		else if (Now - BlinkTs > CURSOR_BLINK)
 		{
 			Blink = !Blink;
 
 			LRect p = CursorPos;
 			p.Offset(-ScrollX, 0);
 			Invalidate(&p);
 			BlinkTs = Now;
 		}
 	}
 
 	if (PartialPour)
 		PourText(Size, 0);
 }
 
 void LTextView4::OnPulse()
 {
 	#ifdef WINDOWS
 	InternalPulse();
 	#else
 	for (auto c: Ctrls)
 		c->InternalPulse();
 	#endif
 }
 
 void LTextView4::OnUrl(char *Url)
 {
 	if (Environment)
 		Environment->OnNavigate(this, Url);
 	else
 	{
 		LUri u(Url);
 		bool Email = LIsValidEmail(Url);
 		const char *Proto = Email ? "mailto" : u.sProtocol;
 		LString App = LGetAppForProtocol(Proto);
 		if (App)
 			LExecute(App, Url);
 		else
 			LgiMsg(this, "Failed to find application for protocol '%s'", "Error", MB_OK, Proto);
 	}
 }
 
 bool LTextView4::OnLayout(LViewLayoutInfo &Inf)
 {
 	Inf.Width.Min = 32;
 	Inf.Width.Max = -1;
 
 	Inf.Height.Min = (Font ? Font->GetHeight() : 18) + 4;
 	Inf.Height.Max = -1;
 
 	return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 class LTextView4_Factory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (_stricmp(Class, "LTextView4") == 0)
 		{
 			return new LTextView4(-1, 0, 0, 2000, 2000);
 		}
 
 		return 0;
 	}
 }	TextView4_Factory;
diff --git a/src/common/Widgets/Editor/RichTextEdit.cpp b/src/common/Widgets/Editor/RichTextEdit.cpp
--- a/src/common/Widgets/Editor/RichTextEdit.cpp
+++ b/src/common/Widgets/Editor/RichTextEdit.cpp
@@ -1,3101 +1,3097 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/RichTextEdit.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ScrollBar.h"
 #ifdef WIN32
 #include <imm.h>
 #endif
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/FontCache.h"
 #include "lgi/common/Unicode.h"
 #include "lgi/common/DropFiles.h"
 #include "lgi/common/HtmlCommon.h"
 #include "lgi/common/HtmlParser.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/Homoglyphs.h"
 
 // If this is not found add $lgi/private/common to your include paths
 #include "ViewPriv.h"
 
 #define DefaultCharset              "utf-8"
 
 #define GDCF_UTF8					-1
 #define POUR_DEBUG					0
 #define PROFILE_POUR				0
 
 #define ALLOC_BLOCK					64
 #define IDC_VS						1000
 
 #define PAINT_BORDER				Back
 #define PAINT_AFTER_LINE			Back
 
 #if !defined(WIN32) && !defined(toupper)
 #define toupper(c)					(((c)>='a'&&(c)<='z') ? (c)-'a'+'A' : (c))
 #endif
 
 // static char SelectWordDelim[] = " \t\n.,()[]<>=?/\\{}\"\';:+=-|!@#$%^&*";
 
 #include "RichTextEditPriv.h"
 
 //////////////////////////////////////////////////////////////////////
 LRichTextEdit::LRichTextEdit(	int Id,
 								int x, int y, int cx, int cy,
 								LFontType *FontType)
 	: ResObject(Res_Custom)
 {
 	// init vars
 	LView::d->Css.Reset(new LRichTextPriv(this, &d));
 
 	// setup window
 	SetId(Id);
 	SetTabStop(true);
 
 	// default options
 	#if WINNATIVE
 	CrLf = true;
 	SetDlgCode(DLGC_WANTALLKEYS);
 	#else
 	CrLf = false;
 	#endif
 	d->Padding(LCss::Len(LCss::LenPx, 4));
 	
 	#if 0
 	d->BackgroundColor(LCss::ColorDef(LColour::Green));
 	#else
 	d->BackgroundColor(LColour(L_WORKSPACE));
 	#endif
 	
 	SetFont(LSysFont);
 
 	#if 0 // def _DEBUG
 	Name("<html>\n"
 		"<body>\n"
 		"	This is some <b style='font-size: 20pt; color: green;'>bold text</b> to test with.<br>\n"
 		"   A second line of text for testing.\n"
 		"</body>\n"
 		"</html>\n");
 	#endif
 }
 
 LRichTextEdit::~LRichTextEdit()
 {
 	// 'd' is owned by the LView CSS autoptr.
 }
 
 bool LRichTextEdit::SetSpellCheck(LSpellCheck *sp)
 {
 	if ((d->SpellCheck = sp))
 	{
 		if (IsAttached())
 			d->SpellCheck->EnumLanguages(AddDispatch());
 		// else call that OnCreate
 		
 	}
 
 	return d->SpellCheck != NULL;
 }
 
 bool LRichTextEdit::IsDirty()
 {
 	return d->Dirty;
 }
 
 void LRichTextEdit::IsDirty(bool dirty)
 {
 	if (d->Dirty ^ dirty)
 	{
 		d->Dirty = dirty;
 	}
 }
 
 void LRichTextEdit::SetFixedWidthFont(bool i)
 {
 	if (FixedWidthFont ^ i)
 	{
 		if (i)
 		{
 			LFontType Type;
 			if (Type.GetSystemFont("Fixed"))
 			{
 				LDocView::SetFixedWidthFont(i);
 			}
 		}
 
 		OnFontChange();
 		Invalidate();
 	}
 }
 
 void LRichTextEdit::SetReadOnly(bool i)
 {
 	LDocView::SetReadOnly(i);
 
 	#if WINNATIVE
 	SetDlgCode(i ? DLGC_WANTARROWS : DLGC_WANTALLKEYS);
 	#endif
 }
 
 LRect LRichTextEdit::GetArea(RectType Type)
 {
 	return	Type >= ContentArea &&
 			Type <= MaxArea
 			?
 			d->Areas[Type]
 			:
 			LRect(0, 0, -1, -1);
 }
 
 bool LRichTextEdit::ShowStyleTools()
 {
 	return d->ShowTools;
 }
 
 void LRichTextEdit::ShowStyleTools(bool b)
 {
 	if (d->ShowTools ^ b)
 	{
 		d->ShowTools = b;
 		Invalidate();
 	}
 }
 
 void LRichTextEdit::SetTabSize(uint8_t i)
 {
 	TabSize = limit(i, 2, 32);
 	OnFontChange();
 	OnPosChange();
 	Invalidate();
 }
 
 void LRichTextEdit::SetWrapType(LDocWrapType i)
 {
 	LDocView::SetWrapType(i);
 
 	OnPosChange();
 	Invalidate();
 }
 
 LFont *LRichTextEdit::GetFont()
 {
 	return d->Font;
 }
 
 void LRichTextEdit::SetFont(LFont *f, bool OwnIt)
 {
 	if (!f)
 		return;
 	
 	if (OwnIt)
 	{
 		d->Font.Reset(f);
 	}
 	else if (d->Font.Reset(new LFont))
 	{		
 		*d->Font = *f;
 		d->Font->Create(NULL, 0, 0);
 	}
 	
 	OnFontChange();
 }
 
 void LRichTextEdit::OnFontChange()
 {
 }
 
 void LRichTextEdit::PourText(ssize_t Start, ssize_t Length /* == 0 means it's a delete */)
 {
 }
 
 void LRichTextEdit::PourStyle(ssize_t Start, ssize_t EditSize)
 {
 }
 
 bool LRichTextEdit::Insert(int At, char16 *Data, int Len)
 {
 	return false;
 }
 
 bool LRichTextEdit::Delete(int At, int Len)
 {
 	return false;
 }
 
 bool LRichTextEdit::DeleteSelection(char16 **Cut)
 {
 	AutoTrans t(new LRichTextPriv::Transaction);
 	if (!d->DeleteSelection(t, Cut))
 		return false;
 
 	return d->AddTrans(t);
 }
 
 int64 LRichTextEdit::Value()
 {
 	const char *n = Name();
 	#ifdef _MSC_VER
 	return (n) ? _atoi64(n) : 0;
 	#else
 	return (n) ? atoll(n) : 0;
 	#endif
 }
 
 void LRichTextEdit::Value(int64 i)
 {
 	char Str[32];
 	sprintf_s(Str, sizeof(Str), LPrintfInt64, i);
 	Name(Str);
 }
 
 bool LRichTextEdit::GetFormattedContent(const char *MimeType, LString &Out, LArray<ContentMedia> *Media)
 {
 	if (!MimeType || _stricmp(MimeType, "text/html"))
 		return false;
 
 	if (!d->ToHtml(Media))
 		return false;
 	
 	Out = d->UtfNameCache;
 	return true;
 }
 
 const char *LRichTextEdit::Name()
 {
 	d->ToHtml();
 	return d->UtfNameCache;
 }
 
 const char *LRichTextEdit::GetCharset()
 {
 	return d->Charset;
 }
 
 void LRichTextEdit::SetCharset(const char *s)
 {
 	d->Charset = s;
 }
 
 bool LRichTextEdit::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	LDomProperty p = LStringToDomProp(Name);
 	switch (p)
 	{
 		case HtmlImagesLinkCid:
 		{
 			Value = d->HtmlLinkAsCid;
 			break;
 		}
 		case SpellCheckLanguage:
 		{
 			Value = d->SpellLang.Get();
 			break;
 		}
 		case SpellCheckDictionary:
 		{
 			Value = d->SpellDict.Get();
 			break;
 		}
 		default:
 			return false;
 	}
 	
 	return true;
 }
 
 bool LRichTextEdit::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	LDomProperty p = LStringToDomProp(Name);
 	switch (p)
 	{
 		case HtmlImagesLinkCid:
 		{
 			d->HtmlLinkAsCid = Value.CastInt32() != 0;
 			break;
 		}
 		case SpellCheckLanguage:
 		{
 			d->SpellLang = Value.Str();
 			break;
 		}
 		case SpellCheckDictionary:
 		{
 			d->SpellDict = Value.Str();
 			break;
 		}
 		default:
 			return false;
 	}
 	
 	return true;
 }
 
 static LHtmlElement *FindElement(LHtmlElement *e, HtmlTag TagId)
 {
 	if (e->TagId == TagId)
 		return e;
 		
 	for (unsigned i = 0; i < e->Children.Length(); i++)
 	{
 		LHtmlElement *c = FindElement(e->Children[i], TagId);
 		if (c)
 			return c;
 	}
 	
 	return NULL;
 }
 
 void LRichTextEdit::OnAddStyle(const char *MimeType, const char *Styles)
 {
 	if (d->CreationCtx)
 	{
 		d->CreationCtx->StyleStore.Parse(Styles);
 	}
 }
 
 bool LRichTextEdit::Name(const char *s)
 {
 	d->Empty();
 	d->OriginalText = s;
 	
 	LHtmlElement Root(NULL);
 
 	if (!d->CreationCtx.Reset(new LRichTextPriv::CreateContext(d)))
 		return false;
 
 	if (!d->LHtmlParser::Parse(&Root, s))
 		return d->Error(_FL, "Failed to parse HTML.");
 	
 	LHtmlElement *Body = FindElement(&Root, TAG_BODY);
 	if (!Body)
 		Body = &Root;
 
 	bool Status = d->FromHtml(Body, *d->CreationCtx);
 	
 	// d->DumpBlocks();
 	
 	if (!d->Blocks.Length())
 	{
 		d->EmptyDoc();
 	}
 	else
 	{
 		// Clear out any zero length blocks.
 		for (unsigned i=0; i<d->Blocks.Length(); i++)
 		{
 			LRichTextPriv::Block *b = d->Blocks[i];
 			if (b->Length() == 0)
 			{
 				d->Blocks.DeleteAt(i--, true);
 				DeleteObj(b);
 			}
 		}
 	}
 	
 	if (Status)
 		SetCursor(0, false);
 	
 	Invalidate();
 	
 	return Status;
 }
 
 const char16 *LRichTextEdit::NameW()
 {
 	d->WideNameCache.Reset(Utf8ToWide(Name()));
 	return d->WideNameCache;
 }
 
 bool LRichTextEdit::NameW(const char16 *s)
 {
 	LAutoString a(WideToUtf8(s));
 	return Name(a);
 }
 
 char *LRichTextEdit::GetSelection()
 {
 	if (!HasSelection())
 		return NULL;
 
 	LArray<char16> Text;
 	if (!d->GetSelection(&Text, NULL))
 		return NULL;
 	
 	return WideToUtf8(&Text[0]);
 }
 
 bool LRichTextEdit::HasSelection()
 {
 	return d->Selection.Get() != NULL;
 }
 
 void LRichTextEdit::SelectAll()
 {
 	AutoCursor Start(new BlkCursor(d->Blocks.First(), 0, 0));
 	d->SetCursor(Start);
 
 	LRichTextPriv::Block *Last = d->Blocks.Length() ? d->Blocks.Last() : NULL;
 	if (Last)
 	{
 		AutoCursor End(new BlkCursor(Last, Last->Length(), Last->GetLines()-1));
 		d->SetCursor(End, true);
 	}
 	else d->Selection.Reset();
 
 	Invalidate();
 }
 
 void LRichTextEdit::UnSelectAll()
 {
 	bool Update = HasSelection();
 
 	if (Update)
 	{
 		d->Selection.Reset();
 		Invalidate();
 	}
 }
 
 void LRichTextEdit::SetStylePrefix(LString s)
 {
 	d->SetPrefix(s);
 }
 
 bool LRichTextEdit::IsBusy(bool Stop)
 {
 	return d->IsBusy(Stop);
 }
 
 size_t LRichTextEdit::GetLines()
 {
 	uint32_t Count = 0;
 	for (size_t i=0; i<d->Blocks.Length(); i++)
 	{
 		LRichTextPriv::Block *b = d->Blocks[i];
 		Count += b->GetLines();
 	}
 	return Count;
 }
 
 int LRichTextEdit::GetLine()
 {
 	if (!d->Cursor)
 		return -1;
 
 	ssize_t Idx = d->Blocks.IndexOf(d->Cursor->Blk);
 	if (Idx < 0)
 	{
 		LAssert(0);
 		return -1;
 	}
 
 	int Count = 0;
 	
 	// Count lines in blocks before the cursor...
 	for (int i=0; i<Idx; i++)
 	{
 		LRichTextPriv::Block *b = d->Blocks[i];
 		Count += b->GetLines();
 	}
 
 	// Add the lines in the cursor's block...
 	if (d->Cursor->LineHint)
 	{
 		Count += d->Cursor->LineHint;
 	}
 	else
 	{
 		LArray<int> BlockLine;
 		if (d->Cursor->Blk->OffsetToLine(d->Cursor->Offset, NULL, &BlockLine))
 			Count += BlockLine.First();
 		else
 		{
 			// Hmmm...
 			LAssert(!"Can't find block line.");
 			return -1;
 		}
 	}
 
 
 	return Count;
 }
 
-void LRichTextEdit::SetLine(int i)
+void LRichTextEdit::SetLine(int Line)
 {
 	int Count = 0;
 	
 	// Count lines in blocks before the cursor...
 	for (int i=0; i<(int)d->Blocks.Length(); i++)
 	{
 		LRichTextPriv::Block *b = d->Blocks[i];
 		int Lines = b->GetLines();
-		if (i >= Count && i < Count + Lines)
+		if (Line >= Count && Line < Count + Lines)
 		{
-			auto BlockLine = i - Count;
+			auto BlockLine = Line - Count;
 			auto Offset = b->LineToOffset(BlockLine);
 			if (Offset >= 0)
 			{
 				AutoCursor c(new BlkCursor(b, Offset, BlockLine));
 				d->SetCursor(c);
 				break;
 			}
 		}		
 		Count += Lines;
 	}
 }
 
 void LRichTextEdit::GetTextExtent(int &x, int &y)
 {
 	x = d->DocumentExtent.x;
 	y = d->DocumentExtent.y;
 }
 
 bool LRichTextEdit::GetLineColumnAtIndex(LPoint &Pt, ssize_t Index)
 {
 	ssize_t Offset = -1;
 	int BlockLines = -1;
 	LRichTextPriv::Block *b = d->GetBlockByIndex(Index, &Offset, NULL, &BlockLines);
 	if (!b)
 		return false;
 
 	int Cols;
 	LArray<int> Lines;
 	if (b->OffsetToLine(Offset, &Cols, &Lines))
 		return false;
 	
 	Pt.x = Cols;
 	Pt.y = BlockLines + Lines.First();
 	return true;
 }
 
 ssize_t LRichTextEdit::GetCaret(bool Cur)
 {
 	if (!d->Cursor)
 		return -1;
 		
 	ssize_t CharPos = 0;
 	for (ssize_t i=0; i<(ssize_t)d->Blocks.Length(); i++)
 	{
 		LRichTextPriv::Block *b = d->Blocks[i];
 		if (d->Cursor->Blk == b)
 			return CharPos + d->Cursor->Offset;
 		CharPos += b->Length();
 	}
 	
 	LAssert(!"Cursor block not found.");
 	return -1;
 }
 
 bool LRichTextEdit::IndexAt(int x, int y, ssize_t &Off, int &LineHint)
 {
 	LPoint Doc = d->ScreenToDoc(x, y);
 	Off = d->HitTest(Doc.x, Doc.y, LineHint);
 	return Off >= 0;
 }
 
 ssize_t LRichTextEdit::IndexAt(int x, int y)
 {
 	ssize_t Idx;
 	int Line;
 	if (!IndexAt(x, y, Idx, Line))
 		return -1;
 	return Idx;
 }
 
 void LRichTextEdit::SetCursor(int i, bool Select, bool ForceFullUpdate)
 {
 	ssize_t Offset = -1;
 	LRichTextPriv::Block *Blk = d->GetBlockByIndex(i, &Offset);
 	if (Blk)
 	{
 		AutoCursor c(new BlkCursor(Blk, Offset, -1));
 		if (c)
 			d->SetCursor(c, Select);
 	}
 }
 
 bool LRichTextEdit::Cut()
 {
 	if (!HasSelection())
 		return false;
 
 	char16 *Txt = NULL;
 	if (!DeleteSelection(&Txt))
 		return false;
 
 	bool Status = true;
 	if (Txt)
 	{
 		LClipBoard Cb(this);
 		Status = Cb.TextW(Txt);
 		DeleteArray(Txt);
 	}
 
 	SendNotify(LNotifyDocChanged);
 
 	return Status;
 }
 
 bool LRichTextEdit::Copy()
 {
 	if (!HasSelection())
 		return false;
 
 	LArray<char16> PlainText;
 	LAutoString Html;
 	if (!d->GetSelection(&PlainText, &Html))
 		return false;
 
 	LString PlainUtf8 = PlainText.AddressOf();
 	if (HasHomoglyphs(PlainUtf8, PlainUtf8.Length()))
 	{
 		if (LgiMsg(	this,
 					LLoadString(L_TEXTCTRL_HOMOGLYPH_WARNING,
 								"Text contains homoglyph characters that maybe a phishing attack.\n"
 								"Do you really want to copy it?"),
 					LLoadString(L_TEXTCTRL_WARNING, "Warning"),
 					MB_YESNO) == IDNO)
 			return false;
 	}
 
 	// Put on the clipboard
 	LClipBoard Cb(this);
 	bool Status = Cb.TextW(PlainText.AddressOf());
 	Cb.Html(Html, false);
 	return Status;
 }
 
 bool LRichTextEdit::Paste()
 {
 	LClipBoard Cb(this);
 		
 	return Cb.Bitmap([this](auto bmp, auto str)
 	{
 		LString Html;
 		LAutoWString Text;
 		LAutoPtr<LSurface> Img;
 
 		Img = bmp;
 		if (!Img)
 		{
 			LClipBoard Cb(this);
 			Html = Cb.Html();
 			if (!Html)
 				Text.Reset(NewStrW(Cb.TextW()));
 		}
 
 		if (!Html && !Text && !Img)
 			return false;
 	
 		if (!d->Cursor ||
 			!d->Cursor->Blk)
 		{
 			LAssert(0);
 			return false;
 		}
 
 		AutoTrans Trans(new LRichTextPriv::Transaction);						
 
 		if (HasSelection())
 		{
 			if (!d->DeleteSelection(Trans, NULL))
 				return false;
 		}
 
 		if (Html)
 		{
 			LHtmlElement Root(NULL);
 
 			if (!d->CreationCtx.Reset(new LRichTextPriv::CreateContext(d)))
 				return false;
 
 			if (!d->LHtmlParser::Parse(&Root, Html))
 				return d->Error(_FL, "Failed to parse HTML.");
 	
 			LHtmlElement *Body = FindElement(&Root, TAG_BODY);
 			if (!Body)
 				Body = &Root;
 
 			if (d->Cursor)
 			{
 				auto *b = d->Cursor->Blk;
 				ssize_t BlkIdx = d->Blocks.IndexOf(b);
 				LRichTextPriv::Block *After = NULL;
 				ssize_t AddIndex = BlkIdx;;
 
 				// Split 'b' to make room for pasted objects
 				if (d->Cursor->Offset > 0)
 				{
 					After = b->Split(Trans, d->Cursor->Offset);
 					AddIndex = BlkIdx+1;									
 				}
 				// else Insert before cursor block
 
 				auto *PastePoint = new LRichTextPriv::TextBlock(d);
 				if (PastePoint)
 				{
 					d->Blocks.AddAt(AddIndex++, PastePoint);
 					if (After) d->Blocks.AddAt(AddIndex++, After);
 
 					d->CreationCtx->Tb = PastePoint;
 					d->FromHtml(Body, *d->CreationCtx);
 				}
 			}
 		}
 		else if (Text)
 		{
 			LAutoPtr<uint32_t,true> Utf32((uint32_t*)LNewConvertCp("utf-32", Text, LGI_WideCharset));
 			ptrdiff_t Len = Strlen(Utf32.Get());
 			if (!d->Cursor->Blk->AddText(Trans, d->Cursor->Offset, Utf32.Get(), (int)Len))
 			{
 				LAssert(0);
 				return false;
 			}
 
 			d->Cursor->Offset += Len;
 			d->Cursor->LineHint = -1;
 		}
 		else if (Img)
 		{
 			LRichTextPriv::Block *b = d->Cursor->Blk;
 			ssize_t BlkIdx = d->Blocks.IndexOf(b);
 			LRichTextPriv::Block *After = NULL;
 			ssize_t AddIndex;
 		
 			LAssert(BlkIdx >= 0);
 
 			// Split 'b' to make room for the image
 			if (d->Cursor->Offset > 0)
 			{
 				After = b->Split(Trans, d->Cursor->Offset);
 				AddIndex = BlkIdx+1;									
 			}
 			else
 			{
 				// Insert before..
 				AddIndex = BlkIdx;
 			}
 
 			LRichTextPriv::ImageBlock *ImgBlk = new LRichTextPriv::ImageBlock(d);
 			if (ImgBlk)
 			{
 				d->Blocks.AddAt(AddIndex++, ImgBlk);
 				if (After)
 					d->Blocks.AddAt(AddIndex++, After);
 
 				Img->MakeOpaque();
 				ImgBlk->SetImage(Img);
 			
 				AutoCursor c(new BlkCursor(ImgBlk, 1, -1));
 				d->SetCursor(c);			
 			}
 		}
 
 		Invalidate();
 		SendNotify(LNotifyDocChanged);
 
 		return d->AddTrans(Trans);
 	});
 }
 
 bool LRichTextEdit::ClearDirty(bool Ask, const char *FileName)
 {
 	if (1 /*dirty*/)
 	{
 		int Answer = (Ask) ? LgiMsg(this,
 									LLoadString(L_TEXTCTRL_ASK_SAVE, "Do you want to save your changes to this document?"),
 									LLoadString(L_TEXTCTRL_SAVE, "Save"),
 									MB_YESNOCANCEL) : IDYES;
 		if (Answer == IDYES)
 		{
 			if (FileName)
 				Save(FileName);
 			else				
 			{
 				LFileSelect *Select = new LFileSelect;
 				Select->Parent(this);
 				Select->Save([this](auto dlg, auto status)
 				{
 					if (status)
 						Save(dlg->Name());
 					delete dlg;
 				});
 			}
 		}
 		else if (Answer == IDCANCEL)
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool LRichTextEdit::Open(const char *Name, const char *CharSet)
 {
 	bool Status = false;
 	LFile f;
 
 	if (f.Open(Name, O_READ|O_SHARE))
 	{
 		size_t Bytes = (size_t)f.GetSize();
 		SetCursor(0, false);
 		
 		char *c8 = new char[Bytes + 4];
 		if (c8)
 		{
 			if (f.Read(c8, (int)Bytes) == Bytes)
 			{
 				char *DataStart = c8;
 
 				c8[Bytes] = 0;
 				c8[Bytes+1] = 0;
 				c8[Bytes+2] = 0;
 				c8[Bytes+3] = 0;
 				
 				if ((uchar)c8[0] == 0xff && (uchar)c8[1] == 0xfe)
 				{
 					// utf-16
 					if (!CharSet)
 					{
 						CharSet = "utf-16";
 						DataStart += 2;
 					}
 				}
 				
 			}
 
 			DeleteArray(c8);
 		}
 		else
 		{
 		}
 
 		Invalidate();
 	}
 
 	return Status;
 }
 
 bool LRichTextEdit::Save(const char *FileName, const char *CharSet)
 {
 	LFile f;
 	if (!FileName || !f.Open(FileName, O_WRITE))
 		return false;
 
 	f.SetSize(0);
 	const char *Nm = Name();
 	if (!Nm)
 		return false;
 
 	size_t Len = strlen(Nm);
 	return f.Write(Nm, (int)Len) == Len;
 }
 
 void LRichTextEdit::UpdateScrollBars(bool Reset)
 {
 	if (VScroll)
 	{
 		//LRect Before = GetClient();
 
 	}
 }
 
 void LRichTextEdit::DoCase(std::function<void(bool)> Callback, bool Upper)
 {
 	if (!HasSelection())
 	{
 		if (Callback)
 			Callback(false);
 		return;
 	}
 
 	bool Cf = d->CursorFirst();
 	LRichTextPriv::BlockCursor *Start = Cf ? d->Cursor : d->Selection;
 	LRichTextPriv::BlockCursor *End = Cf ? d->Selection : d->Cursor;
 	if (Start->Blk == End->Blk)
 	{
 		// In the same block...
 		ssize_t Len = End->Offset - Start->Offset;
 		Start->Blk->DoCase(NoTransaction, Start->Offset, Len, Upper);
 	}
 	else
 	{
 		// Multi-block delete...
 
 		// 1) Delete all the content to the end of the first block
 		ssize_t StartLen = Start->Blk->Length();
 		if (Start->Offset < StartLen)
 			Start->Blk->DoCase(NoTransaction, Start->Offset, StartLen - Start->Offset, Upper);
 
 		// 2) Delete any blocks between 'Start' and 'End'
 		ssize_t i = d->Blocks.IndexOf(Start->Blk);
 		if (i >= 0)
 		{
 			for (++i; d->Blocks[i] != End->Blk && i < (int)d->Blocks.Length(); )
 			{
 				LRichTextPriv::Block *b = d->Blocks[i];
 				b->DoCase(NoTransaction, 0, -1, Upper);
 			}
 		}
 		else
 		{
 			LAssert(0);
 			if (Callback)
 				Callback(false);
 			return;
 		}
 
 		// 3) Delete any text up to the Cursor in the 'End' block
 		End->Blk->DoCase(NoTransaction, 0, End->Offset, Upper);
 	}
 
 	// Update the screen
 	d->Dirty = true;
 	Invalidate();
 	
 	if (Callback)
 		Callback(true);
 }
 
 void LRichTextEdit::DoGoto(std::function<void(bool)> Callback)
 {
 	auto input = new LInput(this, "", LLoadString(L_TEXTCTRL_GOTO_LINE, "Goto line:"), "Text");
-	input->DoModal([this, input, Callback](auto dlg, auto ctrlId)
+	input->DoModal([this, input, Callback](auto dlg, auto ok)
 	{
-		if (ctrlId == IDOK)
+		if (ok)
 		{
-			LString s = input->GetStr();
-			int64 i = s.Int();
+			auto i = input->GetStr().Int();
 			if (i >= 0)
 			{
 				SetLine((int)i);
 				if (Callback)
 					Callback(true);
 				return;
 			}
 		}
 
 		if (Callback)
 			Callback(false);
 
 		delete dlg;
 	});
 }
 
 LDocFindReplaceParams *LRichTextEdit::CreateFindReplaceParams()
 {
 	return new LDocFindReplaceParams3;
 }
 
 void LRichTextEdit::SetFindReplaceParams(LDocFindReplaceParams *Params)
 {
 	if (Params)
 	{
 	}
 }
 
 void LRichTextEdit::DoFindNext(std::function<void(bool)> Callback)
 {
 	if (Callback)
 		Callback(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////// FIND
 void LRichTextEdit::DoFind(std::function<void(bool)> Callback)
 {
 	LArray<char16> Sel;
 	if (HasSelection())
 		d->GetSelection(&Sel, NULL);
 	LAutoString u(Sel.Length() ? WideToUtf8(&Sel.First()) : NULL);
 	
 	auto Dlg = new LFindDlg(this,
 							[this](auto dlg, auto ctrlId)
 							{
 								return OnFind(dlg);
 							},
 							u);
 	Dlg->DoModal([this, Dlg, Callback](auto dlg, auto ctrlId)
 	{
 		if (Callback)
 			Callback(ctrlId != IDCANCEL);
 		
 		Focus(true);
 
 		delete dlg;
 	});
 }
 
 bool LRichTextEdit::OnFind(LFindReplaceCommon *Params)
 {
 	if (!Params || !d->Cursor)
 	{
 		LAssert(0);
 		return false;
 	}
 	
 	LAutoPtr<uint32_t,true> w((uint32_t*)LNewConvertCp("utf-32", Params->Find, "utf-8", Params->Find.Length()));
 	ssize_t Idx = d->Blocks.IndexOf(d->Cursor->Blk);
 	if (Idx < 0)
 	{
 		LAssert(0);
 		return false;
 	}
 
 	for (unsigned n = 0; n < d->Blocks.Length(); n++)
 	{
 		ssize_t i = Idx + n;
 		LRichTextPriv::Block *b = d->Blocks[i % d->Blocks.Length()];
 		ssize_t At = n ? 0 : d->Cursor->Offset;
 		ssize_t Result = b->FindAt(At, w, Params);
 		if (Result >= At)
 		{
 			ptrdiff_t Len = Strlen(w.Get());
 			AutoCursor Sel(new BlkCursor(b, Result, -1));
 			d->SetCursor(Sel, false);
 
 			AutoCursor Cur(new BlkCursor(b, Result + Len, -1));
 			return d->SetCursor(Cur, true);
 		}
 	}
 
 	return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////// REPLACE
 void LRichTextEdit::DoReplace(std::function<void(bool)> Callback)
 {
 	if (Callback)
 		Callback(false);
 }
 
 bool LRichTextEdit::OnReplace(LFindReplaceCommon *Params)
 {
 	return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 void LRichTextEdit::SelectWord(size_t From)
 {
 	int BlockIdx;
 	ssize_t Start, End;
 	LRichTextPriv::Block *b = d->GetBlockByIndex(From, &Start, &BlockIdx);
 	if (!b)
 		return;
 
 	LArray<uint32_t> Txt;
 	if (!b->CopyAt(0, b->Length(), &Txt))
 		return;
 
 	End = Start;
 	while (Start > 0 &&
 			!IsWordBreakChar(Txt[Start-1]))
 		Start--;
 	
 	while
 	(
 		End < b->Length()
 		&&
 		(
 			End == Txt.Length()
 			||
 			!IsWordBreakChar(Txt[End])
 		)
 	)
 		End++;
 
 	AutoCursor c(new BlkCursor(b, Start, -1));
 	d->SetCursor(c);
 	c.Reset(new BlkCursor(b, End, -1));
 	d->SetCursor(c, true);
 }
 
 bool LRichTextEdit::OnMultiLineTab(bool In)
 {
 	return false;
 }
 
 void LRichTextEdit::OnSetHidden(int Hidden)
 {
 }
 
 void LRichTextEdit::OnPosChange()
 {
 	static bool Processing = false;
 
 	if (!Processing)
 	{
 		Processing = true;
 		LLayout::OnPosChange();
 
 		// LRect c = GetClient();
 		Processing = false;
 	}
 	
 	LLayout::OnPosChange();
 }
 
 int LRichTextEdit::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	Formats.SupportsFileDrops();
 	#ifdef WINDOWS
 	Formats.Supports("UniformResourceLocatorW");
 	#endif
 
 	return Formats.Length() ? DROPEFFECT_COPY : DROPEFFECT_NONE;
 }
 
 int LRichTextEdit::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	int Effect = DROPEFFECT_NONE;
 
 	for (unsigned i=0; i<Data.Length(); i++)
 	{
 		LDragData &dd = Data[i];
 		if (dd.IsFileDrop() && d->Areas[ContentArea].Overlap(Pt.x, Pt.y))
 		{
 			int AddIndex = -1;
 			LPoint TestPt(	Pt.x - d->Areas[ContentArea].x1,
 							Pt.y - d->Areas[ContentArea].y1);
 			if (VScroll)
 				TestPt.y += (int)(VScroll->Value() * d->ScrollLinePx);
 
 			LDropFiles Df(dd);
 			for (unsigned n=0; n<Df.Length(); n++)
 			{
 				const char *f = Df[n];
 				LString Mt = LGetFileMimeType(f);
 				if (Mt && Mt.Find("image/") == 0)
 				{
 					if (AddIndex < 0)
 					{
 						int LineHint = -1;
 						ssize_t Idx = d->HitTest(TestPt.x, TestPt.y, LineHint);
 						if (Idx >= 0)
 						{
 							ssize_t BlkOffset;
 							int BlkIdx;
 							LRichTextPriv::Block *b = d->GetBlockByIndex(Idx, &BlkOffset, &BlkIdx);
 							if (b)
 							{
 								LRichTextPriv::Block *After = NULL;
 
 								// Split 'b' to make room for the image
 								if (BlkOffset > 0)
 								{
 									After = b->Split(NoTransaction, BlkOffset);
 									AddIndex = BlkIdx+1;									
 								}
 								else
 								{
 									// Insert before..
 									AddIndex = BlkIdx;
 								}
 
 								LRichTextPriv::ImageBlock *ImgBlk = new LRichTextPriv::ImageBlock(d);
 								if (ImgBlk)
 								{
 									d->Blocks.AddAt(AddIndex++, ImgBlk);
 									if (After)
 										d->Blocks.AddAt(AddIndex++, After);
 
 									ImgBlk->Load(f);
 									Effect = DROPEFFECT_COPY;
 								}
 							}
 						}
 					}
 				}
 			}
 
 			break;
 		}
 	}
 
 	if (Effect != DROPEFFECT_NONE)
 	{
 		Invalidate();
 		SendNotify(LNotifyDocChanged);
 	}
 
 	return Effect;
 }
 
 void LRichTextEdit::OnCreate()
 {
 	SetWindow(this);
 	DropTarget(true);
 
 	if (Focus())
 		SetPulse(RTE_PULSE_RATE);
 
 	if (d->SpellCheck)
 		d->SpellCheck->EnumLanguages(AddDispatch());
 }
 
 void LRichTextEdit::OnEscape(LKey &K)
 {
 }
 
 bool LRichTextEdit::OnMouseWheel(double l)
 {
 	if (VScroll)
 	{
 		VScroll->Value(VScroll->Value() + (int64)l);
 		Invalidate();
 	}
 	
 	return true;
 }
 
 void LRichTextEdit::OnFocus(bool f)
 {
 	Invalidate();
 	SetPulse(f ? RTE_PULSE_RATE : -1);
 }
 
 ssize_t LRichTextEdit::HitTest(int x, int y)
 {
 	int Line = -1;
 	return d->HitTest(x, y, Line);
 }
 
 void LRichTextEdit::Undo()
 {
 	if (d->UndoPos > 0)
 		d->SetUndoPos(d->UndoPos - 1);
 }
 
 void LRichTextEdit::Redo()
 {
 	if (d->UndoPos < (int)d->UndoQue.Length())
 		d->SetUndoPos(d->UndoPos + 1);
 }
 
 #ifdef _DEBUG
 class NodeView : public LWindow
 {
 public:
 	LTree *Tree;
 	
 	NodeView(LViewI *w)
 	{
 		LRect r(0, 0, 500, 600);
 		SetPos(r);
 		MoveSameScreen(w);
 		Attach(0);
 
 		if ((Tree = new LTree(100, 0, 0, 100, 100)))
 		{
 			Tree->SetPourLargest(true);
 			Tree->Attach(this);
 		}
 	}
 };
 #endif
 
 void LRichTextEdit::DoContextMenu(LMouse &m)
 {
 	LMenuItem *i;
 	LSubMenu RClick;
 	LAutoString ClipText;
 	{
 		LClipBoard Clip(this);
 		ClipText.Reset(NewStr(Clip.Text()));
 	}
 
 	LRichTextPriv::Block *Over = NULL;
 	LRect &Content = d->Areas[ContentArea];
 	LPoint Doc = d->ScreenToDoc(m.x, m.y);
 	ssize_t Offset = -1, BlkOffset = -1;
 	if (Content.Overlap(m.x, m.y))
 	{
 		int LineHint;
 		Offset = d->HitTest(Doc.x, Doc.y, LineHint, &Over, &BlkOffset);
 	}
 	if (Over)
 		Over->DoContext(RClick, Doc, BlkOffset, true);
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_CUT, "Cut"), IDM_RTE_CUT, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_COPY, "Copy"), IDM_RTE_COPY, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_PASTE, "Paste"), IDM_RTE_PASTE, ClipText != 0);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_UNDO, "Undo"), IDM_RTE_UNDO, false /* UndoQue.CanUndo() */);
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_REDO, "Redo"), IDM_RTE_REDO, false /* UndoQue.CanRedo() */);
 	RClick.AppendSeparator();
 
 	#if 0
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_FIXED, "Fixed Width Font"), IDM_FIXED, true);
 	if (i) i->Checked(GetFixedWidthFont());
 	#endif
 
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_AUTO_INDENT, "Auto Indent"), IDM_AUTO_INDENT, true);
 	if (i) i->Checked(AutoIndent);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_SHOW_WHITESPACE, "Show Whitespace"), IDM_SHOW_WHITE, true);
 	if (i) i->Checked(ShowWhiteSpace);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_HARD_TABS, "Hard Tabs"), IDM_HARD_TABS, true);
 	if (i) i->Checked(HardTabs);
 	
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_INDENT_SIZE, "Indent Size"), IDM_INDENT_SIZE, true);
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_TAB_SIZE, "Tab Size"), IDM_TAB_SIZE, true);
 	
 	LSubMenu *Src = RClick.AppendSub("Source");
 	if (Src)
 	{
 		Src->AppendItem("Copy Original", IDM_COPY_ORIGINAL, d->OriginalText.Get() != NULL);
 		Src->AppendItem("Copy Current", IDM_COPY_CURRENT);
 		#ifdef _DEBUG
 		Src->AppendItem("Dump Nodes", IDM_DUMP_NODES);
 		// Edit->DumpNodes(Tree);
 		#endif
 	}
 
 	if (Over)
 	{
 		#ifdef _DEBUG
 		// RClick.AppendItem(Over->GetClass(), -1, false);
 		#endif
 		Over->DoContext(RClick, Doc, BlkOffset, false);
 	}
 	if (Environment)
 		Environment->AppendItems(&RClick, NULL);
 
 	int Id = 0;
 	m.ToScreen();
 	switch (Id = RClick.Float(this, m.x, m.y))
 	{
 		case IDM_FIXED:
 		{
 			SetFixedWidthFont(!GetFixedWidthFont());							
 			SendNotify(LNotifyFixedWidthChanged);
 			break;
 		}
 		case IDM_RTE_CUT:
 		{
 			Cut();
 			break;
 		}
 		case IDM_RTE_COPY:
 		{
 			Copy();
 			break;
 		}
 		case IDM_RTE_PASTE:
 		{
 			Paste();
 			break;
 		}
 		case IDM_RTE_UNDO:
 		{
 			Undo();
 			break;
 		}
 		case IDM_RTE_REDO:
 		{
 			Redo();
 			break;
 		}
 		case IDM_AUTO_INDENT:
 		{
 			AutoIndent = !AutoIndent;
 			break;
 		}
 		case IDM_SHOW_WHITE:
 		{
 			ShowWhiteSpace = !ShowWhiteSpace;
 			Invalidate();
 			break;
 		}
 		case IDM_HARD_TABS:
 		{
 			HardTabs = !HardTabs;
 			break;
 		}
 		case IDM_INDENT_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", IndentSize);
 			auto i = new LInput(this, s, "Indent Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto ctrlId)
 			{
 				if (ctrlId == IDOK)
 				{
 					IndentSize = (uint8_t)i->GetStr().Int();
 					Invalidate();
 				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_TAB_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", TabSize);
 			auto i = new LInput(this, s, "Tab Size:", "Text");
-			i->DoModal([this, i](auto dlg, auto ctrlId)
+			i->DoModal([this, i](auto dlg, auto ok)
 			{
-				if (ctrlId == IDOK)
-				{
+				if (ok)
 					SetTabSize((uint8_t)i->GetStr().Int());
-					Invalidate();
-				}
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_COPY_ORIGINAL:
 		{
 			LClipBoard c(this);
 			c.Text(d->OriginalText);
 			break;
 		}
 		case IDM_COPY_CURRENT:
 		{
 			LClipBoard c(this);
 			c.Text(Name());
 			break;
 		}
 		case IDM_DUMP_NODES:
 		{
 			#ifdef _DEBUG
 			NodeView *nv = new NodeView(GetWindow());
 			DumpNodes(nv->Tree);
 			nv->Visible(true);
 			#endif
 			break;
 		}
 		default:
 		{
 			if (Over)
 			{
 				LMessage Cmd(M_COMMAND, Id);
 				if (Over->OnEvent(&Cmd))
 					break;
 			}
 			
 			if (Environment)
 				Environment->OnMenu(this, Id, 0);
 			break;
 		}
 	}
 }
 
 void LRichTextEdit::OnMouseClick(LMouse &m)
 {
 	bool Processed = false;
 	RectType Clicked = 	d->PosToButton(m);
 	if (m.Down())
 	{
 		Focus(true);
 		
 		if (m.IsContextMenu())
 		{
 			DoContextMenu(m);
 			return;
 		}
 		else
 		{
 			Focus(true);
 
 			if (d->Areas[ToolsArea].Overlap(m.x, m.y)
 				// || d->Areas[CapabilityArea].Overlap(m.x, m.y)
 				)
 			{
 				if (Clicked != MaxArea)
 				{
 					if (d->BtnState[Clicked].IsPress)
 					{
 						d->BtnState[d->ClickedBtn = Clicked].Pressed = true;
 						Invalidate(d->Areas + Clicked);
 						Capture(true);
 					}
 					else
 					{
 						Processed |= d->ClickBtn(m, Clicked);
 					}
 				}
 			}
 			else
 			{
 				d->WordSelectMode = !Processed && m.Double();
 
 				AutoCursor c(new BlkCursor(NULL, 0, 0));
 				LPoint Doc = d->ScreenToDoc(m.x, m.y);
 				ssize_t Idx = -1;
 				if (d->CursorFromPos(Doc.x, Doc.y, &c, &Idx))
 				{
 					d->ClickedBtn = ContentArea;
 					d->SetCursor(c, m.Shift());
 					if (d->WordSelectMode)
 						SelectWord(Idx);
 				}
 			}
 		}
 	}
 	else if (IsCapturing())
 	{
 		Capture(false);
 
 		if (d->ClickedBtn != MaxArea)
 		{
 			d->BtnState[d->ClickedBtn].Pressed = false;
 			Invalidate(d->Areas + d->ClickedBtn);
 			Processed |= d->ClickBtn(m, Clicked);
 		}
 
 		d->ClickedBtn = MaxArea;
 	}
 
 	if (!Processed)
 	{
 		Capture(m.Down());
 	}
 }
 
 int LRichTextEdit::OnHitTest(int x, int y)
 {
 	#ifdef WIN32
 	if (GetClient().Overlap(x, y))
 	{
 		return HTCLIENT;
 	}
 	#endif
 	return LView::OnHitTest(x, y);
 }
 
 void LRichTextEdit::OnMouseMove(LMouse &m)
 {
 	LRichTextEdit::RectType OverBtn = d->PosToButton(m);
 	if (d->OverBtn != OverBtn)
 	{
 		if (d->OverBtn < MaxArea)
 		{
 			d->BtnState[d->OverBtn].MouseOver = false;
 			Invalidate(&d->Areas[d->OverBtn]);
 		}
 		d->OverBtn = OverBtn;
 		if (d->OverBtn < MaxArea)
 		{
 			d->BtnState[d->OverBtn].MouseOver = true;
 			Invalidate(&d->Areas[d->OverBtn]);
 		}
 	}
 	
 	if (IsCapturing())
 	{
 		if (d->ClickedBtn == ContentArea)
 		{
 			AutoCursor c;
 			LPoint Doc = d->ScreenToDoc(m.x, m.y);
 			ssize_t Idx = -1;
 			if (d->CursorFromPos(Doc.x, Doc.y, &c, &Idx) && c)
 			{
 				if (d->WordSelectMode && d->Selection)
 				{
 					// Extend the selection to include the whole word
 					if (!d->CursorFirst())
 					{
 						// Extend towards the end of the doc...
 						LArray<uint32_t> Txt;
 						if (c->Blk->CopyAt(0, c->Blk->Length(), &Txt))
 						{
 							while
 							(
 								c->Offset < (int)Txt.Length() &&
 								!IsWordBreakChar(Txt[c->Offset])
 							)
 								c->Offset++;
 						}
 					}
 					else
 					{
 						// Extend towards the start of the doc...
 						LArray<uint32_t> Txt;
 						if (c->Blk->CopyAt(0, c->Blk->Length(), &Txt))
 						{
 							while
 							(
 								c->Offset > 0 &&
 								!IsWordBreakChar(Txt[c->Offset-1])
 							)
 								c->Offset--;
 						}
 					}
 				}
 
 				d->SetCursor(c, m.Left());
 			}
 		}
 	}
 
 	#ifdef WIN32
 	LRect c = GetClient();
 	c.Offset(-c.x1, -c.y1);
 	if (c.Overlap(m.x, m.y))
 	{
 		/*
 		LStyle *s = HitStyle(Hit);
 		TCHAR *c = (s) ? s->GetCursor() : 0;
 		if (!c) c = IDC_IBEAM;
 		::SetCursor(LoadCursor(0, MAKEINTRESOURCE(c)));
 		*/
 	}
 	#endif
 }
 
 bool LRichTextEdit::OnKey(LKey &k)
 {
 	if (k.Down() &&
 		d->Cursor)
 		d->Cursor->Blink = true;
 
 	if (k.c16 == 17)
 		return false;
 
 	#ifdef WINDOWS
 	// Wtf is this?
 	// Weeeelll, windows likes to send a LK_TAB after a Ctrl+I doesn't it?
 	// And this just takes care of that TAB before it can overwrite your
 	// selection.
 	if (ToLower(k.c16) == 'i' &&
 		k.Ctrl())
 	{
 		d->EatVkeys.Add(LK_TAB);
 	}
 	else if (d->EatVkeys.Length())
 	{
 		auto Idx = d->EatVkeys.IndexOf(k.vkey);
 		if (Idx >= 0)
 		{
 			// Yum yum
 			d->EatVkeys.DeleteAt(Idx);
 			return true;
 		}
 	}
 	#endif
 
 	// k.Trace("LRichTextEdit::OnKey");
 	if (k.IsContextMenu())
 	{
 		LMouse m;
 		DoContextMenu(m);
 	}
 	else if (k.IsChar)
 	{
 		switch (k.vkey)
 		{
 			default:
 			{
 				// process single char input
 				if
 				(
 					!GetReadOnly()
 					&&
 					(
 						(k.c16 >= ' ' || k.vkey == LK_TAB)
 						&&
 						k.c16 != 127
 					)
 				)
 				{
 					if (k.Down() &&
 						d->Cursor &&
 						d->Cursor->Blk)
 					{
 						// letter/number etc
 						LRichTextPriv::Block *b = d->Cursor->Blk;
 
 						AutoTrans Trans(new LRichTextPriv::Transaction);						
 						d->DeleteSelection(Trans, NULL);
 
 						LNamedStyle *AddStyle = NULL;
 						if (d->StyleDirty.Length() > 0)
 						{
 							LAutoPtr<LCss> Mod(new LCss);
 							if (Mod)
 							{
 								// Get base styles at the cursor..
 								LNamedStyle *Base = b->GetStyle(d->Cursor->Offset);
 								if (Base)
 									*Mod = *Base;
 
 								// Apply dirty toolbar styles...
 								if (d->StyleDirty.HasItem(FontFamilyBtn))
 									Mod->FontFamily(LCss::StringsDef(d->Values[FontFamilyBtn].Str()));
 								if (d->StyleDirty.HasItem(FontSizeBtn))
 									Mod->FontSize(LCss::Len(LCss::LenPt, (float) d->Values[FontSizeBtn].CastDouble()));
 								if (d->StyleDirty.HasItem(BoldBtn))
 									Mod->FontWeight(d->Values[BoldBtn].CastInt32() ? LCss::FontWeightBold : LCss::FontWeightNormal);
 								if (d->StyleDirty.HasItem(ItalicBtn))
 									Mod->FontStyle(d->Values[ItalicBtn].CastInt32() ? LCss::FontStyleItalic : LCss::FontStyleNormal);
 								if (d->StyleDirty.HasItem(UnderlineBtn))
 									Mod->TextDecoration(d->Values[UnderlineBtn].CastInt32() ? LCss::TextDecorUnderline : LCss::TextDecorNone);
 								if (d->StyleDirty.HasItem(ForegroundColourBtn))
 									Mod->Color(LCss::ColorDef(LCss::ColorRgb, (uint32_t)d->Values[ForegroundColourBtn].CastInt64()));
 								if (d->StyleDirty.HasItem(BackgroundColourBtn))
 									Mod->BackgroundColor(LCss::ColorDef(LCss::ColorRgb, (uint32_t)d->Values[BackgroundColourBtn].CastInt64()));
 							
 								AddStyle = d->AddStyleToCache(Mod);
 							}
 							
 							d->StyleDirty.Length(0);
 						}
 						else if (b->Length() == 0)
 						{
 							// We have no existing style to modify, so create one from scratch.
 							LAutoPtr<LCss> Mod(new LCss);
 							if (Mod)
 							{
 								// Apply dirty toolbar styles...
 								Mod->FontFamily(LCss::StringsDef(d->Values[FontFamilyBtn].Str()));
 								Mod->FontSize(LCss::Len(LCss::LenPt, (float)d->Values[FontSizeBtn].CastDouble()));
 								Mod->FontWeight(d->Values[BoldBtn].CastInt32() ? LCss::FontWeightBold : LCss::FontWeightNormal);
 								Mod->FontStyle(d->Values[ItalicBtn].CastInt32() ? LCss::FontStyleItalic : LCss::FontStyleNormal);
 								Mod->TextDecoration(d->Values[UnderlineBtn].CastInt32() ? LCss::TextDecorUnderline : LCss::TextDecorNone);
 								Mod->Color(LCss::ColorDef(LCss::ColorRgb, (uint32_t)d->Values[ForegroundColourBtn].CastInt64()));
 								
 								auto Bk = d->Values[BackgroundColourBtn].CastInt64();
 								if (Bk > 0)
 									Mod->BackgroundColor(LCss::ColorDef(LCss::ColorRgb, (uint32_t)Bk));
 							
 								AddStyle = d->AddStyleToCache(Mod);
 							}
 						}
 
 						uint32_t Ch = k.c16;
 						if (b->AddText(Trans, d->Cursor->Offset, &Ch, 1, AddStyle))
 						{
 							d->Cursor->Set(d->Cursor->Offset + 1);
 							Invalidate();
 							SendNotify(LNotifyDocChanged);
 
 							d->AddTrans(Trans);
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			case LK_RETURN:
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Down() && k.IsChar)
 				{
 					OnEnter(k);
 					SendNotify(LNotifyDocChanged);
 				}
 
 				return true;
 			}
 			case LK_BACKSPACE:
 			{
 				if (GetReadOnly())
 					break;
 
 				bool Changed = false;
 				AutoTrans Trans(new LRichTextPriv::Transaction);
 
 				if (k.Ctrl())
 				{
 				    // Ctrl+H
 				}
 				else if (k.Down())
 				{
 					LRichTextPriv::Block *b;
 
 					if (HasSelection())
 					{
 						Changed = d->DeleteSelection(Trans, NULL);
 					}
 					else if (d->Cursor &&
 							 (b = d->Cursor->Blk))
 					{
 						if (d->Cursor->Offset > 0)
 						{
 							Changed = b->DeleteAt(Trans, d->Cursor->Offset-1, 1) > 0;
 							if (Changed)
 							{
 								// Has block size reached 0?
 								if (b->Length() == 0)
 								{
 									// Then delete it...
 									LRichTextPriv::Block *n = d->Next(b);
 									if (n)
 									{
 										d->Blocks.Delete(b, true);
 										d->Cursor.Reset(new LRichTextPriv::BlockCursor(n, 0, 0));
 									}
 									else
 									{
 										// No other block to go to, so leave this empty block at the end
 										// of the documnent but set the cursor correctly.
 										d->Cursor->Set(0);
 									}
 								}
 								else
 								{
 									d->Cursor->Set(d->Cursor->Offset - 1);
 								}
 							}
 						}
 						else
 						{
 							// At the start of a block:
 							LRichTextPriv::Block *Prev = d->Prev(d->Cursor->Blk);
 							if (Prev)
 							{
 								// Try and merge the two blocks...
 								ssize_t Len = Prev->Length();
 								d->Merge(Trans, Prev, d->Cursor->Blk);
 								
 								AutoCursor c(new BlkCursor(Prev, Len, -1));
 								d->SetCursor(c);
 							}
 							else // at the start of the doc...
 							{
 								// Don't send the doc changed...
 								return true;
 							}
 						}
 					}
 				}
 
 				if (Changed)
 				{
 					Invalidate();
 					d->AddTrans(Trans);
 					SendNotify(LNotifyDocChanged);
 				}
 				return true;
 			}
 		}
 	}
 	else // not a char
 	{
 		switch (k.vkey)
 		{
 			case LK_TAB:
 				return true;
 			case LK_RETURN:
 				return !GetReadOnly();
 			case LK_BACKSPACE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Alt())
 					{
 						if (k.Down())
 						{
 							if (k.Ctrl())
 								Redo();
 							else
 								Undo();
 						}
 					}
 					else if (k.Ctrl())
 					{
 						if (k.Down())
 						{
 							// Implement delete by word
 							LAssert(!"Impl backspace by word");
 						}
 					}
 
 					return true;
 				}
 				break;
 			}
 			case LK_F3:
 			{
 				if (k.Down())
 					DoFindNext(NULL);
 				return true;
 			}
 			case LK_LEFT:
 			{
 				#ifdef MAC
 				if (k.Ctrl())
 				#else
 				if (k.Alt())
 				#endif
 					return false;
 
 				if (k.Down())
 				{
 					if (HasSelection() && !k.Shift())
 					{
 						LRect r = d->SelectionRect();
 						Invalidate(&r);
 						
 						AutoCursor c(new BlkCursor(d->CursorFirst() ? *d->Cursor : *d->Selection));
 						d->SetCursor(c);
 					}
 					else
 					{
 						#ifdef MAC
 						if (k.System())
 							goto Jump_StartOfLine;
 						else
 						#endif
 
 						d->Seek(d->Cursor,
 								#ifdef MAC
 								k.Alt() ?
 								#else
 								k.Ctrl() ?
 								#endif
 									LRichTextPriv::SkLeftWord : LRichTextPriv::SkLeftChar,
 								k.Shift());
 					}
 				}
 				return true;
 			}
 			case LK_RIGHT:
 			{
 				#ifdef MAC
 				if (k.Ctrl())
 				#else
 				if (k.Alt())
 				#endif
 					return false;
 
 				if (k.Down())
 				{
 					if (HasSelection() && !k.Shift())
 					{
 						LRect r = d->SelectionRect();
 						Invalidate(&r);
 
 						AutoCursor c(new BlkCursor(d->CursorFirst() ? *d->Selection : *d->Cursor));
 						d->SetCursor(c);
 					}
 					else
 					{
 						#ifdef MAC
 						if (k.System())
 							goto Jump_EndOfLine;
 						#endif
 
 						d->Seek(d->Cursor,
 								#ifdef MAC
 								k.Alt() ?
 								#else
 								k.Ctrl() ?
 								#endif
 									LRichTextPriv::SkRightWord : LRichTextPriv::SkRightChar,
 								k.Shift());
 					}
 				}
 				return true;
 			}
 			case LK_UP:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto GTextView4_PageUp;
 					#endif
 
 					d->Seek(d->Cursor,
 							LRichTextPriv::SkUpLine,
 							k.Shift());
 				}
 				return true;
 			}
 			case LK_DOWN:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto GTextView4_PageDown;
 					#endif
 
 					d->Seek(d->Cursor,
 							LRichTextPriv::SkDownLine,
 							k.Shift());
 				}
 				return true;
 			}
 			case LK_END:
 			{
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (!k.Ctrl())
 						Jump_EndOfLine:
 					#endif
 
 					d->Seek(d->Cursor,
 							k.Ctrl() ? LRichTextPriv::SkDocEnd : LRichTextPriv::SkLineEnd,
 							k.Shift());
 				}
 				return true;
 			}
 			case LK_HOME:
 			{
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (!k.Ctrl())
 						Jump_StartOfLine:
 					#endif
 
 					d->Seek(d->Cursor,
 							k.Ctrl() ? LRichTextPriv::SkDocStart : LRichTextPriv::SkLineStart,
 							k.Shift());
 				}
 				return true;
 			}
 			case LK_PAGEUP:
 			{
 				#ifdef MAC
 				GTextView4_PageUp:
 				#endif
 				if (k.Down())
 				{
 					d->Seek(d->Cursor,
 							LRichTextPriv::SkUpPage,
 							k.Shift());
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEDOWN:
 			{
 				#ifdef MAC
 				GTextView4_PageDown:
 				#endif
 				if (k.Down())
 				{
 					d->Seek(d->Cursor,
 							LRichTextPriv::SkDownPage,
 							k.Shift());
 				}
 				return true;
 				break;
 			}
 			case LK_INSERT:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						Copy();
 					}
 					else if (k.Shift())
 					{
 						if (!GetReadOnly())
 						{
 							Paste();
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DELETE:
 			{
 				if (GetReadOnly())
 					break;
 
 				if (!k.Down())
 					return true;
 
 				bool Changed = false;
 				LRichTextPriv::Block *b;
 				AutoTrans Trans(new LRichTextPriv::Transaction);
 
 				if (HasSelection())
 				{
 					if (k.Shift())
 						Changed |= Cut();
 					else
 						Changed |= d->DeleteSelection(Trans, NULL);
 				}
 				else if (d->Cursor &&
 						(b = d->Cursor->Blk))
 				{
 					if (d->Cursor->Offset >= b->Length())
 					{
 						// Cursor is at the end of this block, pull the styles
 						// from the next block into this one.
 						LRichTextPriv::Block *next = d->Next(b);
 						if (!next)
 						{
 							// No next block, therefor nothing to delete
 							break;
 						}
 
 						// Try and merge the blocks
 						if (d->Merge(Trans, b, next))
 							Changed = true;
 						else
 						{
 							// If the cursor is on the last empty line of a text block,
 							// we should delete that '\n' first
 							LRichTextPriv::TextBlock *tb = dynamic_cast<LRichTextPriv::TextBlock*>(b);
 							if (tb && tb->IsEmptyLine(d->Cursor))
 								Changed = tb->StripLast(Trans);
 
 							// move the cursor to the next block
 							d->Cursor.Reset(new LRichTextPriv::BlockCursor(b = next, 0, 0));
 						}
 					}
 
 					if (!Changed && b->DeleteAt(Trans, d->Cursor->Offset, 1))
 					{
 						if (b->Length() == 0)
 						{
 							LRichTextPriv::Block *n = d->Next(b);
 							if (n)
 							{
 								d->Blocks.Delete(b, true);
 								d->Cursor.Reset(new LRichTextPriv::BlockCursor(n, 0, 0));
 							}
 						}
 
 						Changed = true;
 					}
 				}
 						
 				if (Changed)
 				{
 					Invalidate();
 					d->AddTrans(Trans);
 					SendNotify(LNotifyDocChanged);
 				}
 				return true;
 			}
 			default:
 			{
 				if (k.c16 == 17)
 					break;
 
 				if (k.c16 == ' ' &&
 					k.Ctrl() &&
 					k.Alt() &&
 					d->Cursor &&
 					d->Cursor->Blk)
 				{
 					if (k.Down())
 					{
 						// letter/number etc
 						LRichTextPriv::Block *b = d->Cursor->Blk;
 						uint32_t Nbsp[] = {0xa0};
 						if (b->AddText(NoTransaction, d->Cursor->Offset, Nbsp, 1))
 						{
 							d->Cursor->Set(d->Cursor->Offset + 1);
 							Invalidate();
 							SendNotify(LNotifyDocChanged);
 						}
 					}
 					break;
 				}
 
 				if (k.CtrlCmd() &&
 					!k.Alt())
 				{
 					switch (k.GetChar())
 					{
 						case 0xbd: // Ctrl+'-'
 						{
 							/*
 							if (k.Down() &&
 								Font->PointSize() > 1)
 							{
 								Font->PointSize(Font->PointSize() - 1);
 								OnFontChange();
 								Invalidate();
 							}
 							*/
 							break;
 						}
 						case 0xbb: // Ctrl+'+'
 						{
 							/*
 							if (k.Down() &&
 								Font->PointSize() < 100)
 							{
 								Font->PointSize(Font->PointSize() + 1);
 								OnFontChange();
 								Invalidate();
 							}
 							*/
 							break;
 						}
 						case 'a':
 						case 'A':
 						{
 							if (k.Down())
 							{
 								// select all
 								SelectAll();
 							}
 							return true;
 							break;
 						}
 						case 'b':
 						case 'B':
 						{
 							if (k.Down())
 							{
 								// Bold selection
 								LMouse m;
 								GetMouse(m);
 								d->ClickBtn(m, BoldBtn);
 							}
 							return true;
 							break;
 						}
 						case 'l':
 						case 'L':
 						{
 							if (k.Down())
 							{
 								// Underline selection
 								LMouse m;
 								GetMouse(m);
 								d->ClickBtn(m, UnderlineBtn);
 							}
 							return true;
 							break;
 						}
 						case 'i':
 						case 'I':
 						{
 							if (k.Down())
 							{
 								// Italic selection
 								LMouse m;
 								GetMouse(m);
 								d->ClickBtn(m, ItalicBtn);
 							}
 							return true;
 							break;
 						}
 						case 'y':
 						case 'Y':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Redo();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'z':
 						case 'Z':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									if (k.Shift())
 									{
 										Redo();
 									}
 									else
 									{
 										Undo();
 									}
 								}
 								return true;
 							}
 							break;
 						}
 						case 'x':
 						case 'X':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Cut();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'c':
 						case 'C':
 						{
 							if (k.Shift())
 								return false;
 							
 							if (k.Down())
 								Copy();
 							return true;
 							break;
 						}
 						case 'v':
 						case 'V':
 						{
 							if (!k.Shift() &&
 								!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Paste();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'f':
 						{
 							if (k.Down())
 								DoFind(NULL);
 							return true;
 						}
 						case 'g':
 						case 'G':
 						{
 							if (k.Down())
 								DoGoto(NULL);
 							return true;
 							break;
 						}
 						case 'h':
 						case 'H':
 						{
 							if (k.Down())
 								DoReplace(NULL);
 							return true;
 							break;
 						}
 						case 'u':
 						case 'U':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 									DoCase(NULL, k.Shift());
 								return true;
 							}
 							break;
 						}
 						case LK_RETURN:
 						{
 							if (!GetReadOnly() && !k.Shift())
 							{
 								if (k.Down())
 								{
 									OnEnter(k);
 								}
 								return true;
 							}
 							break;
 						}
 					}
 				}
 				break;
 			}
 		}
 	}
 	
 	return false;
 }
 
 void LRichTextEdit::OnEnter(LKey &k)
 {
 	AutoTrans Trans(new LRichTextPriv::Transaction);						
 
 	// Enter key handling
 	bool Changed = false;
 
 	if (HasSelection())
 		Changed |= d->DeleteSelection(Trans, NULL);
 	
 	if (d->Cursor &&
 		d->Cursor->Blk)
 	{
 		LRichTextPriv::Block *b = d->Cursor->Blk;
 		const uint32_t Nl[] = {'\n'};
 
 		if (b->AddText(Trans, d->Cursor->Offset, Nl, 1))
 		{
 			d->Cursor->Set(d->Cursor->Offset + 1);
 			Changed = true;
 		}
 		else
 		{
 			// Some blocks don't take text. However a new block can be created or
 			// the text added to the start of the next block
 			if (d->Cursor->Offset == 0)
 			{
 				LRichTextPriv::Block *Prev = d->Prev(b);
 				if (Prev)
 					Changed = Prev->AddText(Trans, Prev->Length(), Nl, 1);
 				else // No previous... must by first block... create new block:
 				{
 					LRichTextPriv::TextBlock *tb = new LRichTextPriv::TextBlock(d);
 					if (tb)
 					{
 						Changed = true; // tb->AddText(Trans, 0, Nl, 1);
 						d->Blocks.AddAt(0, tb);
 					}
 				}
 			}
 			else if (d->Cursor->Offset == b->Length())
 			{
 				LRichTextPriv::Block *Next = d->Next(b);
 				if (Next)
 				{
 					if ((Changed = Next->AddText(Trans, 0, Nl, 1)))
 						d->Cursor->Set(Next, 0, -1);
 				}
 				else // No next block. Create one:
 				{
 					LRichTextPriv::TextBlock *tb = new LRichTextPriv::TextBlock(d);
 					if (tb)
 					{
 						Changed = true; // tb->AddText(Trans, 0, Nl, 1);
 						d->Blocks.Add(tb);
 					}
 				}
 			}
 		}
 	}
 
 	if (Changed)
 	{
 		Invalidate();
 		d->AddTrans(Trans);
 		SendNotify(LNotifyDocChanged);
 	}
 }
 
 void LRichTextEdit::OnPaintLeftMargin(LSurface *pDC, LRect &r, LColour &colour)
 {
 	pDC->Colour(colour);
 	pDC->Rectangle(&r);
 }
 
 void LRichTextEdit::OnPaint(LSurface *pDC)
 {
 	LRect r = GetClient();
 	if (!r.Valid())
 		return;
 
 	#if 0
 	pDC->Colour(LColour(255, 0, 255));
 	pDC->Rectangle();
 	#endif
 
 	int FontY = GetFont()->GetHeight();
 
 	LCssTools ct(d, d->Font);
 	r = ct.PaintBorder(pDC, r);
 
 	bool HasSpace = r.Y() > (FontY * 3);
 	if (d->ShowTools && HasSpace)
 	{
 		d->Areas[ToolsArea] = r;
 		d->Areas[ToolsArea].y2 = d->Areas[ToolsArea].y1 + (FontY + 8) - 1;
 		r.y1 = d->Areas[ToolsArea].y2 + 1;
 	}
 	else
 	{
 		d->Areas[ToolsArea].ZOff(-1, -1);
 	}
 
 	d->Areas[ContentArea] = r;
 
 	if (d->Layout(VScroll))
 		d->Paint(pDC, VScroll);
 	// else the scroll bars changed, wait for re-paint
 }
 
 LMessage::Result LRichTextEdit::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_CUT:
 		{
 			Cut();
 			break;
 		}
 		case M_COPY:
 		{
 			Copy();
 			break;
 		}
 		case M_PASTE:
 		{
 			Paste();
 			break;
 		}
 		case M_BLOCK_MSG:
 		{
 			LRichTextPriv::Block *b = (LRichTextPriv::Block*)Msg->A();
 			LAutoPtr<LMessage> msg((LMessage*)Msg->B());
 			if (d->Blocks.HasItem(b) && msg)
 			{
 				b->OnEvent(msg);
 			}
 			else printf("%s:%i - No block to receive M_BLOCK_MSG.\n", _FL);
 			break;
 		}
 		case M_ENUMERATE_LANGUAGES:
 		{
 			LAutoPtr< LArray<LSpellCheck::LanguageId> > Languages((LArray<LSpellCheck::LanguageId>*)Msg->A());
 			if (!Languages)
 			{
 				LgiTrace("%s:%i - M_ENUMERATE_LANGUAGES no param\n", _FL);
 				break;
 			}
 
 			// LgiTrace("%s:%i - Got M_ENUMERATE_LANGUAGES %s\n", _FL, d->SpellLang.Get());
 			bool Match = false;
 			for (auto &s: *Languages)
 			{
 				if (s.LangCode.Equals(d->SpellLang) ||
 					s.EnglishName.Equals(d->SpellLang))
 				{
 					// LgiTrace("%s:%i - EnumDict called %s\n", _FL, s.LangCode.Get());
 					d->SpellCheck->EnumDictionaries(AddDispatch(), s.LangCode);
 					Match = true;
 					break;
 				}
 			}
 			if (!Match)
 				LgiTrace("%s:%i - EnumDict not called %s\n", _FL, d->SpellLang.Get());
 			break;
 		}
 		case M_ENUMERATE_DICTIONARIES:
 		{
 			LAutoPtr< LArray<LSpellCheck::DictionaryId> > Dictionaries((LArray<LSpellCheck::DictionaryId>*)Msg->A());
 			if (!Dictionaries)
 				break;
 	
 			bool Match = false;		
 			for (auto &s: *Dictionaries)
 			{
 				// LgiTrace("%s:%i - M_ENUMERATE_DICTIONARIES: %s, %s\n", _FL, s.Dict.Get(), d->SpellDict.Get());
 				if (s.Dict.Equals(d->SpellDict))
 				{
 					d->SpellCheck->SetDictionary(AddDispatch(), s.Lang, s.Dict);
 					Match = true;
 					break;
 				}
 			}
 			if (!Match)
 				d->SpellCheck->SetDictionary(AddDispatch(), d->SpellLang, NULL);
 			break;
 		}
 		case M_SET_DICTIONARY:
 		{
 			d->SpellDictionaryLoaded = Msg->A() != 0;
 			// LgiTrace("%s:%i - M_SET_DICTIONARY=%i\n", _FL, d->SpellDictionaryLoaded);
 			if (d->SpellDictionaryLoaded)
 			{
 				AutoTrans Trans(new LRichTextPriv::Transaction);
 
 				// Get any loaded text blocks to check their spelling
 				bool Status = false;
 				for (unsigned i=0; i<d->Blocks.Length(); i++)
 				{
 					Status |= d->Blocks[i]->OnDictionary(Trans);
 				}
 
 				if (Status)
 					d->AddTrans(Trans);
 			}
 			break;
 		}
 		case M_CHECK_TEXT:
 		{
 			LAutoPtr<LSpellCheck::CheckText> Ct((LSpellCheck::CheckText*)Msg->A());
 			if (!Ct || Ct->User.Length() > 1)
 			{
 				LAssert(0);
 				break;
 			}
 			
 			LRichTextPriv::Block *b = (LRichTextPriv::Block*)Ct->User[SpellBlockPtr].CastVoidPtr();
 			if (!d->Blocks.HasItem(b))
 				break;
 
 			b->SetSpellingErrors(Ct->Errors, *Ct);
 			Invalidate();
 			break;
 		}
 		#if defined WIN32
 		case WM_GETTEXTLENGTH:
 		{
 			return 0 /*Size*/;
 		}
 		case WM_GETTEXT:
 		{
 			int Chars = (int)Msg->A();
 			char *Out = (char*)Msg->B();
 			if (Out)
 			{
 				char *In = (char*)LNewConvertCp(LAnsiToLgiCp(), NameW(), LGI_WideCharset, Chars);
 				if (In)
 				{
 					int Len = (int)strlen(In);
 					memcpy(Out, In, Len);
 					DeleteArray(In);
 					return Len;
 				}
 			}
 			return 0;
 		}
 		case M_COMPONENT_INSTALLED:
 		{
 			LAutoPtr<LString> Comp((LString*)Msg->A());
 			if (Comp)
 				d->OnComponentInstall(*Comp);
 			break;
 		}
 
 		/* This is broken... the IME returns garbage in the buffer. :(
 		case WM_IME_COMPOSITION:
 		{
 			if (Msg->b & GCS_RESULTSTR) 
 			{
 				HIMC hIMC = ImmGetContext(Handle());
 				if (hIMC)
 				{
 					int Size = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);
 					char *Buf = new char[Size];
 					if (Buf)
 					{
 						ImmGetCompositionString(hIMC, GCS_RESULTSTR, Buf, Size);
 
 						char16 *Utf = (char16*)LNewConvertCp(LGI_WideCharset, Buf, LAnsiToLgiCp(), Size);
 						if (Utf)
 						{
 							Insert(Cursor, Utf, StrlenW(Utf));
 							DeleteArray(Utf);
 						}
 
 						DeleteArray(Buf);
 					}
 
 					ImmReleaseContext(Handle(), hIMC);
 				}
 				return 0;
 			}
 			break;
 		}
 		*/
 		#endif
 	}
 
 	return LLayout::OnEvent(Msg);
 }
 
 int LRichTextEdit::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (Ctrl->GetId() == IDC_VSCROLL && VScroll)
 	{
 		Invalidate(d->Areas + ContentArea);
 	}
 
 	return 0;
 }
 
 void LRichTextEdit::OnPulse()
 {
 	if (!ReadOnly && d->Cursor)
 	{
 		uint64 n = LCurrentTime();
 		if (d->BlinkTs - n >= RTE_CURSOR_BLINK_RATE)
 		{
 			d->BlinkTs = n;
 			d->Cursor->Blink = !d->Cursor->Blink;
 			d->InvalidateDoc(&d->Cursor->Pos);
 		}
 		
 		// Do autoscroll while the user has clicked and dragged off the control:
 		if (VScroll && IsCapturing() && d->ClickedBtn == LRichTextEdit::ContentArea)
 		{
 			LMouse m;
 			GetMouse(m);
 			
 			// Is the mouse outside the content window
 			LRect &r = d->Areas[ContentArea];
 			if (!r.Overlap(m.x, m.y))
 			{
 				AutoCursor c(new BlkCursor(NULL, 0, 0));
 				LPoint Doc = d->ScreenToDoc(m.x, m.y);
 				ssize_t Idx = -1;
 				if (d->CursorFromPos(Doc.x, Doc.y, &c, &Idx))
 				{
 					d->SetCursor(c, true);
 					if (d->WordSelectMode)
 						SelectWord(Idx);
 				}
 				
 				// Update the screen.
 				d->InvalidateDoc(NULL);
 			}
 		}
 	}
 }
 
 void LRichTextEdit::OnUrl(char *Url)
 {
 	if (Environment)
 	{
 		Environment->OnNavigate(this, Url);
 	}
 }
 
 bool LRichTextEdit::OnLayout(LViewLayoutInfo &Inf)
 {
 	Inf.Width.Min = 32;
 	Inf.Width.Max = -1;
 
 	// Inf.Height.Min = (Font ? Font->GetHeight() : 18) + 4;
 	Inf.Height.Max = -1;
 
 	return true;
 }
 
 #if _DEBUG
 void LRichTextEdit::SelectNode(LString Param)
 {
 	LRichTextPriv::Block *b = (LRichTextPriv::Block*) Param.Int(16);
 	bool Valid = false;
 	for (auto i : d->Blocks)
 	{
 		if (i == b)
 			Valid = true;
 		i->DrawDebug = false;
 	}
 	if (Valid)
 	{
 		b->DrawDebug = true;
 		Invalidate();
 	}
 }
 
 void LRichTextEdit::DumpNodes(LTree *Root)
 {
 	d->DumpNodes(Root);
 }
 #endif
 
 
 ///////////////////////////////////////////////////////////////////////////////
 SelectColour::SelectColour(LRichTextPriv *priv, LPoint p, LRichTextEdit::RectType t) : LPopup(priv->View)
 {
 	d = priv;
 	Type = t;
 
 	int Px = 16;
 	int PxSp = Px + 2;
 	int x = 6;
 	int y = 6;
 
 	// Do grey ramp
 	for (int i=0; i<8; i++)
 	{
 		Entry &en = e.New();
 		int Grey = i * 255 / 7;
 		en.r.ZOff(Px-1, Px-1);
 		en.r.Offset(x + (i * PxSp), y);
 		en.c.Rgb(Grey, Grey, Grey);
 	}
 
 	// Do colours
 	y += PxSp + 4;
 	int SatRange = 255 - 64;
 	int SatStart = 255 - 32;
 	int HueStep = 360 / 8;
 	for (int sat=0; sat<8; sat++)
 	{
 		for (int hue=0; hue<8; hue++)
 		{
 			LColour c;
 			c.SetHLS(hue * HueStep, SatStart - ((sat * SatRange) / 7), 255);
 			c.ToRGB();
 
 			Entry &en = e.New();
 			en.r.ZOff(Px-1, Px-1);
 			en.r.Offset(x + (hue * PxSp), y);
 			en.c = c;
 		}
 
 		y += PxSp;
 	}
 
 	SetParent(d->View);
 
 	LRect r(0, 0, 12 + (8 * PxSp) - 1, y + 6 - 1);
 	r.Offset(p.x, p.y);
 	SetPos(r);
 
 	Visible(true);
 }
 
 void SelectColour::OnPaint(LSurface *pDC)
 {
 	pDC->Colour(L_MED);
 	pDC->Rectangle();
 	for (unsigned i=0; i<e.Length(); i++)
 	{
 		pDC->Colour(e[i].c);
 		pDC->Rectangle(&e[i].r);
 	}
 }
 
 void SelectColour::OnMouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		for (unsigned i=0; i<e.Length(); i++)
 		{
 			if (e[i].r.Overlap(m.x, m.y))
 			{
 				d->Values[Type] = (int64)e[i].c.c32();
 				d->View->Invalidate(d->Areas + Type);
 				d->OnStyleChange(Type);
 				Visible(false);
 				break;
 			}
 		}
 	}
 }
 
 void SelectColour::Visible(bool i)
 {
 	LPopup::Visible(i);
 	if (!i)
 	{
 		d->View->Focus(true);
 		delete this;
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #define EMOJI_PAD	2
 #include "lgi/common/Emoji.h"
 int EmojiMenu::Cur = 0;
 
 EmojiMenu::EmojiMenu(LRichTextPriv *priv, LPoint p) : LPopup(priv->View)
 {
 	d = priv;
 	d->GetEmojiImage();
 
 	int MaxIdx = 0;
 	LHashTbl<IntKey<int>, int> Map;
 	for (int b=0; b<CountOf(EmojiRanges); b++)
 	{
 		LRange &r = EmojiRanges[b];
 		for (int i=0; i<r.Len; i++)
 		{
 			uint32_t u = (int)r.Start + i;
 			auto Emoji = EmojiToIconIndex(&u, 1);
 			if (Emoji.Index >= 0)
 			{
 				Map.Add(Emoji.Index, u);
 				MaxIdx = MAX(MaxIdx, Emoji.Index);
 			}
 		}
 	}
 
 	int Sz = EMOJI_CELL_SIZE - 1;
 	int PaneCount = 5;
 	int PaneSz = (int)(Map.Length() / PaneCount);
 	int ImgIdx = 0;
 
 	int PaneSelectSz = LSysFont->GetHeight() * 2;
 	int Rows = (PaneSz + EMOJI_GROUP_X - 1) / EMOJI_GROUP_X;
 	LRect r(0, 0,
 			(EMOJI_CELL_SIZE + EMOJI_PAD) * EMOJI_GROUP_X + EMOJI_PAD,
 			(EMOJI_CELL_SIZE + EMOJI_PAD) * Rows + EMOJI_PAD + PaneSelectSz);
 	r.Offset(p.x, p.y);
 	SetPos(r);
 	
 	for (int pi = 0; pi < PaneCount; pi++)
 	{
 		Pane &p = Panes[pi];
 		int Wid = X() - (EMOJI_PAD*2);
 		p.Btn.x1 = EMOJI_PAD + (pi * Wid / PaneCount);
 		p.Btn.y1 = EMOJI_PAD;
 		p.Btn.x2 = EMOJI_PAD + ((pi + 1) * Wid / PaneCount) - 1;
 		p.Btn.y2 = EMOJI_PAD + PaneSelectSz;
 		int Dx = EMOJI_PAD;
 		int Dy = p.Btn.y2 + 1;
 		
 		while ((int)p.e.Length() < PaneSz && ImgIdx <= MaxIdx)
 		{
 			uint32_t u = Map.Find(ImgIdx);
 			if (u)
 			{
 				Emoji &Ch = p.e.New();
 				Ch.u = u;
 
 				int Sx = ImgIdx % EMOJI_GROUP_X;
 				int Sy = ImgIdx / EMOJI_GROUP_X;
 
 				Ch.Src.ZOff(Sz, Sz);
 				Ch.Src.Offset(Sx * EMOJI_CELL_SIZE, Sy * EMOJI_CELL_SIZE);
 
 				Ch.Dst.ZOff(Sz, Sz);
 				Ch.Dst.Offset(Dx, Dy);
 
 				Dx += EMOJI_PAD + EMOJI_CELL_SIZE;
 				if (Dx + EMOJI_PAD + EMOJI_CELL_SIZE >= r.X())
 				{
 					Dx = EMOJI_PAD;
 					Dy += EMOJI_PAD + EMOJI_CELL_SIZE;
 				}
 			}
 			ImgIdx++;
 		}
 	}
 
 	SetParent(d->View);
 	Visible(true);
 }
 
 void EmojiMenu::OnPaint(LSurface *pDC)
 {
 	LAutoPtr<LDoubleBuffer> DblBuf;
 	if (!pDC->SupportsAlphaCompositing())
 		DblBuf.Reset(new LDoubleBuffer(pDC));
 
 	pDC->Colour(L_MED);
 	pDC->Rectangle();
 
 	LSurface *EmojiImg = d->GetEmojiImage();
 	if (EmojiImg)
 	{
 		pDC->Op(GDC_ALPHA);
 		
 		for (unsigned i=0; i<Panes.Length(); i++)
 		{
 			Pane &p = Panes[i];
 			
 			LString s;
 			s.Printf("%i", i);
 			LDisplayString Ds(LSysFont, s);
 			if (Cur == i)
 			{
 				pDC->Colour(L_LIGHT);
 				pDC->Rectangle(&p.Btn);
 			}
 			LSysFont->Fore(L_TEXT);
 			LSysFont->Transparent(true);
 			Ds.Draw(pDC, p.Btn.x1 + ((p.Btn.X()-Ds.X())>>1), p.Btn.y1 + ((p.Btn.Y()-Ds.Y())>>1));
 		}
 		
 		Pane &p = Panes[Cur];
 		for (unsigned i=0; i<p.e.Length(); i++)
 		{
 			Emoji &g = p.e[i];
 			pDC->Blt(g.Dst.x1, g.Dst.y1, EmojiImg, &g.Src);
 		}
 	}
 	else
 	{
 		LRect c = GetClient();
 		LDisplayString Ds(LSysFont, "Loading...");
 		LSysFont->Colour(L_TEXT, L_MED);
 		LSysFont->Transparent(true);
 		Ds.Draw(pDC, (c.X()-Ds.X())>>1, (c.Y()-Ds.Y())>>1);
 	}
 }
 
 bool EmojiMenu::InsertEmoji(uint32_t Ch)
 {
 	if (!d->Cursor || !d->Cursor->Blk)
 		return false;
 
 	AutoTrans Trans(new LRichTextPriv::Transaction);						
 
 	if (!d->Cursor->Blk->AddText(NoTransaction, d->Cursor->Offset, &Ch, 1, NULL))
 		return false;
 
 	AutoCursor c(new BlkCursor(*d->Cursor));
 	c->Offset++;
 	d->SetCursor(c);
 
 	d->AddTrans(Trans);
 						
 	d->Dirty = true;
 	d->InvalidateDoc(NULL);
 	d->View->SendNotify(LNotifyDocChanged);
 
 	return true;
 }
 
 void EmojiMenu::OnMouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		for (unsigned i=0; i<Panes.Length(); i++)
 		{
 			Pane &p = Panes[i];
 			if (p.Btn.Overlap(m.x, m.y))
 			{
 				Cur = i;
 				Invalidate();
 				return;
 			}
 		}
 		
 		Pane &p = Panes[Cur];
 		for (unsigned i=0; i<p.e.Length(); i++)
 		{
 			Emoji &Ch = p.e[i];
 			if (Ch.Dst.Overlap(m.x, m.y))
 			{
 				InsertEmoji(Ch.u);
 				Visible(false);
 				break;
 			}
 		}
 	}
 }
 
 void EmojiMenu::Visible(bool i)
 {
 	LPopup::Visible(i);
 	if (!i)
 	{
 		d->View->Focus(true);
 		delete this;
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 class LRichTextEdit_Factory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (_stricmp(Class, "LRichTextEdit") == 0)
 		{
 			return new LRichTextEdit(-1, 0, 0, 2000, 2000);
 		}
 
 		return 0;
 	}
 }	RichTextEdit_Factory;
diff --git a/src/common/Widgets/Editor/TextBlock.cpp b/src/common/Widgets/Editor/TextBlock.cpp
--- a/src/common/Widgets/Editor/TextBlock.cpp
+++ b/src/common/Widgets/Editor/TextBlock.cpp
@@ -1,2616 +1,2627 @@
 #include "lgi/common/Lgi.h"
 #include "lgi/common/RichTextEdit.h"
 #include "RichTextEditPriv.h"
 #include "lgi/common/Emoji.h"
 #include "lgi/common/DocView.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/GdcTools.h"
 
 #define DEBUG_LAYOUT				0
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 LRichTextPriv::StyleText::StyleText(const StyleText *St)
 {
 	Emoji = St->Emoji;
 	Style = NULL;
 	Element = St->Element;
 	Param = St->Param;
 	if (St->Style)
 		SetStyle(St->Style);
 	Add((uint32_t*)&St->ItemAt(0), St->Length());
 }
 		
 LRichTextPriv::StyleText::StyleText(const uint32_t *t, ssize_t Chars, LNamedStyle *style)
 {
 	Emoji = false;
 	Style = NULL;
 	Element = CONTENT;
 	if (style)
 		SetStyle(style);
 	if (t)
 	{
 		if (Chars < 0)
 			Chars = Strlen(t);
 		Add((uint32_t*)t, (int)Chars);
 	}
 }
 
 uint32_t *LRichTextPriv::StyleText::At(ssize_t i)
 {
 	if (i >= 0 && i < (int)Length())
 		return &(*this)[i];
 	LAssert(0);
 	return NULL;
 }
 		
 LNamedStyle *LRichTextPriv::StyleText::GetStyle()
 {
 	return Style;
 }
 				
 void LRichTextPriv::StyleText::SetStyle(LNamedStyle *s)
 {
 	if (Style != s)
 	{
 		Style = s;
 		Colours.Empty();
 				
 		if (Style)
 		{			
 			LCss::ColorDef c = Style->Color();
 			if (c.Type == LCss::ColorRgb)
 				Colours.Fore.Set(c.Rgb32, 32);
 			c = Style->BackgroundColor();
 			if (c.Type == LCss::ColorRgb)
 				Colours.Back.Set(c.Rgb32, 32);
 		}				
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 LRichTextPriv::EmojiDisplayStr::EmojiDisplayStr(StyleText *src,
 												LSurface *img,
 												LCss::Len &fntSize,
 												const uint32_t *s,
 												ssize_t l) :
 	DisplayStr(src, NULL, s, l)
 {
 	Img = img;
 
 	#if defined(_MSC_VER)
 		Utf32.Add(s, l);
 		uint32_t *u = &Utf32[0];
 	#else
 		LAssert(sizeof(char16) == 4);
 		uint32_t *u = (uint32_t*)Wide;
 		Chars = Strlen(u);
 	#endif
 
 	CharPx = EMOJI_CELL_SIZE;
 	Size = fntSize;
 	if (Size.IsValid())
 	{
 		int Px = Size.ToPx();
 		if (Px > 0)
 			CharPx = (int)(Px / 0.8);
 	}
 
 	for (int i=0; i<Chars; )
 	{
 		auto Emoji = EmojiToIconIndex(u + i, Chars - i);
 		LAssert(Emoji.Index >= 0);
 		if (Emoji.Index >= 0)
 		{
 			int x = Emoji.Index % EMOJI_GROUP_X;
 			int y = Emoji.Index / EMOJI_GROUP_X;
 			LRect &rc = SrcRect[i];
 			rc.ZOff(EMOJI_CELL_SIZE-1, EMOJI_CELL_SIZE-1);
 			rc.Offset(x * EMOJI_CELL_SIZE, y * EMOJI_CELL_SIZE);
 
 			i += Emoji.Size;
 		}
 		else
 		{
 			LAssert(!"Not an emoji.");
 			break;
 		}
 	}
 
 	x = (int)SrcRect.Length() * CharPx;
 	y = CharPx;
 	xf = IntToFixed(x);
 	yf = IntToFixed(y);
 }
 
 LAutoPtr<LRichTextPriv::DisplayStr> LRichTextPriv::EmojiDisplayStr::Clone(ssize_t Start, ssize_t Len)
 {
 	if (Len < 0)
 		Len = Chars - Start;
 	#if defined(_MSC_VER)
 		LAssert(	Start >= 0 &&
 					Start < (int)Utf32.Length() &&
 					Start + Len <= (int)Utf32.Length());
 	#endif
 	LAutoPtr<DisplayStr> s(new EmojiDisplayStr(Src, Img, Size,
 		#if defined(_MSC_VER)
 		&Utf32[Start]
 		#else
 		(uint32_t*)(const char16*)(*this)
 		#endif
 		, Len));
 	return s;
 }
 
 void LRichTextPriv::EmojiDisplayStr::Paint(LSurface *pDC, int &FixX, int FixY, LColour &Back)
 {
 	LRect f(0, 0, x-1, y-1);
 
 	f.Offset(FixedToInt(FixX), FixedToInt(FixY));
 	pDC->Colour(Back);
 	pDC->Rectangle(&f);
 
 	int Op = pDC->Op(GDC_ALPHA);
 	for (unsigned i=0; i<SrcRect.Length(); i++)
 	{
 		if (CharPx != EMOJI_CELL_SIZE)
 		{
 			LMemDC mem(CharPx, CharPx, System32BitColourSpace);
 			ResampleDC(&mem, Img, &SrcRect[i]);
 			pDC->Blt(f.x1, f.y1, &mem);
 		}
 		else
 		{
 			pDC->Blt(f.x1, f.y1, Img, &SrcRect[i]);
 		}
 		f.x1 += CharPx;
 		FixX += IntToFixed(CharPx);
 	}
 
 	pDC->Op(Op);
 }
 
 double LRichTextPriv::EmojiDisplayStr::GetAscent()
 {
 	return CharPx * 0.8;
 }
 
 ssize_t LRichTextPriv::EmojiDisplayStr::PosToIndex(int XPos, bool Nearest)
 {
 	if (XPos >= (int)x)
 		return Chars;
 	if (XPos <= 0)
 		return 0;
 	return (XPos + (Nearest ? CharPx >> 1 : 0)) / CharPx;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 LRichTextPriv::TextLine::TextLine(int XOffsetPx, int WidthPx, int YOffsetPx)
 {
 	NewLine = 0;
 	PosOff.ZOff(0, 0);
 	PosOff.Offset(XOffsetPx, YOffsetPx);
 }
 
 ssize_t LRichTextPriv::TextLine::Length()
 {
 	ssize_t Len = NewLine;
 	for (unsigned i=0; i<Strs.Length(); i++)
 		Len += Strs[i]->Chars;
 	return Len;
 }
 		
 /// This runs after the layout line has been filled with display strings.
 /// It measures the line and works out the right offsets for each strings
 /// so that their baselines all match up correctly.
 void LRichTextPriv::TextLine::LayoutOffsets(int DefaultFontHt)
 {
 	double BaseLine = 0.0;
 	int HtPx = 0;
 			
 	for (unsigned i=0; i<Strs.Length(); i++)
 	{
 		DisplayStr *ds = Strs[i];
 		double Ascent = ds->GetAscent();
 		BaseLine = MAX(BaseLine, Ascent);
 		HtPx = MAX(HtPx, ds->Y());
 	}
 			
 	if (Strs.Length() == 0)
 		HtPx = DefaultFontHt;
 	else
 		LAssert(HtPx > 0);
 			
 	for (unsigned i=0; i<Strs.Length(); i++)
 	{
 		DisplayStr *ds = Strs[i];
 		double Ascent = ds->GetAscent();
 		if (Ascent > 0.0)
 			ds->OffsetY = (int)(BaseLine - Ascent);
 		LAssert(ds->OffsetY >= 0);
 		HtPx = MAX(HtPx, ds->OffsetY+ds->Y());
 	}
 			
 	PosOff.y2 = PosOff.y1 + HtPx - 1;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 LRichTextPriv::TextBlock::TextBlock(LRichTextPriv *priv) : Block(priv)
 {
 	LayoutDirty = false;
 	Len = 0;
 	Pos.ZOff(-1, -1);
 	Style = NULL;
 	Fnt = NULL;
 	ClickErrIdx = -1;
 			
 	Margin.ZOff(0, 0);
 	Border.ZOff(0, 0);
 	Padding.ZOff(0, 0);
 }
 
 LRichTextPriv::TextBlock::TextBlock(const TextBlock *Copy) : Block(Copy)
 {
 	LayoutDirty = true;
 	Len = Copy->Len;
 	Pos = Copy->Pos;
 	Style = Copy->Style;
 	Fnt = Copy->Fnt;
 			
 	Margin = Copy->Margin;
 	Border = Copy->Border;
 	Padding = Copy->Padding;
 
 	for (unsigned i=0; i<Copy->Txt.Length(); i++)
 	{
 		Txt.Add(new StyleText(Copy->Txt.ItemAt(i)));
 	}
 }
 		
 LRichTextPriv::TextBlock::~TextBlock()
 {
 	LAssert(Cursors == 0);
 	Txt.DeleteObjects();
 }
 
 void LRichTextPriv::TextBlock::Dump()
 {
 	LgiTrace("    Txt.Len=%i, margin=%s, border=%s, padding=%s\n",
 				Txt.Length(),
 				Margin.GetStr(),
 				Border.GetStr(),
 				Padding.GetStr());
 	for (unsigned i=0; i<Txt.Length(); i++)
 	{
 		StyleText *t = Txt[i];
 		LString s(t->Length() ?
 					#ifndef WINDOWS
 					(char16*)
 					#endif
 					t->At(0) : NULL, t->Length());
 		s = s.Strip();
 				
 		LgiTrace("    %p: style=%p/%s, len=%i\n",
 			t,
 			t->GetStyle(),
 			t->GetStyle() ? t->GetStyle()->Name.Get() : NULL,
 			t->Length());
 	}
 }
 		
 LNamedStyle *LRichTextPriv::TextBlock::GetStyle(ssize_t At)
 {
 	if (At >= 0)
 	{
 		LArray<StyleText*> t;
 		if (GetTextAt(At, t))
 			return t[0]->GetStyle();
 	}
 
 	return Style;
 }
 		
 void LRichTextPriv::TextBlock::SetStyle(LNamedStyle *s)
 {
 	if ((Style = s))
 	{
 		Fnt = d->GetFont(s);
 		LayoutDirty = true;
 		LAssert(Fnt != NULL);
 
 		Margin.x1 = Style->MarginLeft().ToPx(Pos.X(), Fnt);
 		Margin.y1 = Style->MarginTop().ToPx(Pos.Y(), Fnt);
 		Margin.x2 = Style->MarginRight().ToPx(Pos.X(), Fnt);
 		Margin.y2 = Style->MarginBottom().ToPx(Pos.Y(), Fnt);
 
 		Border.x1 = Style->BorderLeft().ToPx(Pos.X(), Fnt);
 		Border.y1 = Style->BorderTop().ToPx(Pos.Y(), Fnt);
 		Border.x2 = Style->BorderRight().ToPx(Pos.X(), Fnt);
 		Border.y2 = Style->BorderBottom().ToPx(Pos.Y(), Fnt);
 
 		Padding.x1 = Style->PaddingLeft().ToPx(Pos.X(), Fnt);
 		Padding.y1 = Style->PaddingTop().ToPx(Pos.Y(), Fnt);
 		Padding.x2 = Style->PaddingRight().ToPx(Pos.X(), Fnt);
 		Padding.y2 = Style->PaddingBottom().ToPx(Pos.Y(), Fnt);
 	}
 }
 
 ssize_t LRichTextPriv::TextBlock::Length()
 {
 	return Len;
 }
 
 HtmlTag IsDefaultStyle(HtmlTag Id, LCss *Css)
 {
 	if (!Css)
 		return CONTENT;
 
 	if (Css->Length() == 2)
 	{
 		LCss::ColorDef c = Css->Color();
 		if ((LColour)c != LColour::Blue)
 			return CONTENT;
 				
 		LCss::TextDecorType td = Css->TextDecoration();
 		if (td != LCss::TextDecorUnderline)
 			return CONTENT;
 
 		return TAG_A;
 	}
 	else if (Css->Length() == 1)
 	{
 		LCss::FontWeightType fw = Css->FontWeight();
 		if (fw == LCss::FontWeightBold ||
 			fw == LCss::FontWeightBolder ||
 			fw >= LCss::FontWeight700)
 			return TAG_B;
 
 		LCss::TextDecorType td = Css->TextDecoration();
 		if (td == LCss::TextDecorUnderline)
 			return TAG_U;
 
 		LCss::FontStyleType fs = Css->FontStyle();
 		if (fs == LCss::FontStyleItalic)
 			return TAG_I;
 	}
 
 	return CONTENT;
 }
 
 bool LRichTextPriv::TextBlock::ToHtml(LStream &s, LArray<LDocView::ContentMedia> *Media, LRange *Rng)
 {
 	s.Print("<p>");
 
 	LRange All(0, Length());
 	if (!Rng)
 		Rng = &All;
 
 	size_t Pos = 0;
 	for (unsigned i=0; i<Txt.Length(); i++)
 	{
 		StyleText *t = Txt[i];
 		LNamedStyle *style = t->GetStyle();
 		ssize_t tlen = t->Length();
 		if (!tlen)
 			continue;
 		LRange TxtRange(Pos, tlen);
 		LRange Common = TxtRange.Overlap(*Rng);
 		if (Common.Valid())
 		{		
 			LString utf(
 				#ifndef WINDOWS
 				(char16*)
 				#endif
 				t->At(Common.Start - Pos), Common.Len);
 			char *str = utf;
 
 			const char *ElemName = NULL;
 			if (t->Element != CONTENT)
 			{
 				LHtmlElemInfo *e = d->Inst.Static->GetTagInfo(t->Element);
 				if (!e)
 					return false;
 				ElemName = e->Tag;
 				if (style)
 				{
 					HtmlTag tag = IsDefaultStyle(t->Element, style);
 					if (tag == t->Element)
 						style = NULL;
 				}
 			}
 			else
 			{
 				HtmlTag tag = IsDefaultStyle(t->Element, style);
 				if (tag != CONTENT)
 				{
 					LHtmlElemInfo *e = d->Inst.Static->GetTagInfo(tag);
 					if (e)
 					{
 						ElemName = e->Tag;
 						style = NULL;
 					}
 				}			
 			}
 
 			if (style && !ElemName)
 				ElemName = "span";
 			if (ElemName)
 				s.Print("<%s", ElemName);
 			if (style)
 				s.Print(" class='%s'", style->Name.Get());
 			if (t->Element == TAG_A && t->Param)
 				s.Print(" href='%s'", t->Param.Get());
 			if (ElemName)
 				s.Print(">");
 		
 			// Encode entities...
 			LUtf8Ptr last(str);
 			LUtf8Ptr cur(str);
 			LUtf8Ptr end(str + utf.Length());
 			while (cur < end)
 			{
 				int32 ch = cur;
 				switch (ch)
 				{
 					case '<':
 						s.Print("%.*s&lt;", cur - last, last.GetPtr());
 						last = ++cur;
 						break;
 					case '>':
 						s.Print("%.*s&gt;", cur - last, last.GetPtr());
 						last = ++cur;
 						break;
 					case '\n':
 						s.Print("%.*s<br>\n", cur - last, last.GetPtr());
 						last = ++cur;
 						break;
 					case '&':
 						s.Print("%.*s&amp;", cur - last, last.GetPtr());
 						last = ++cur;
 						break;
 					case 0xa0:
 						s.Print("%.*s&nbsp;", cur - last, last.GetPtr());
 						last = ++cur;
 						break;
 					default:
 						cur++;
 						break;
 				}
 			}
 			s.Print("%.*s", cur - last, last.GetPtr());
 
 			if (ElemName)
 				s.Print("</%s>", ElemName);
 		}
 
 		Pos += tlen;
 	}
 	s.Print("</p>\n");
 	return true;
 }		
 
 bool LRichTextPriv::TextBlock::GetPosFromIndex(BlockCursor *Cursor)
 {
 	if (!Cursor)
 		return d->Error(_FL, "No cursor param.");
 
 	if (LayoutDirty)
 	{
 		Cursor->Pos.ZOff(-1, -1); // This is valid behaviour... need to 
 								// wait for layout before getting cursor
 								// position.
 		return false;
 	}
 		
 	ssize_t CharPos = 0;
 	int LastY = 0;
 	for (unsigned i=0; i<Layout.Length(); i++)
 	{
 		TextLine *tl = Layout[i];
 		PtrCheckBreak(tl);
 
 		LRect r = tl->PosOff;
 		r.Offset(Pos.x1, Pos.y1);
 				
 		int FixX = 0;
 		for (unsigned n=0; n<tl->Strs.Length(); n++)
 		{
 			DisplayStr *ds = tl->Strs[n];
 			ssize_t dsChars = ds->Chars;
 					
 			if
 			(
 				Cursor->Offset >= CharPos
 				&&
 				Cursor->Offset <= CharPos + dsChars
 				&&
 				(
 					Cursor->LineHint < 0
 					||
 					Cursor->LineHint == i
 				)
 			)
 			{
 				ssize_t CharOffset = Cursor->Offset - CharPos;
 				if (CharOffset == 0)
 				{
 					// First char
 					Cursor->Pos.x1 = r.x1 + FixedToInt(FixX);
 				}
 				else if (CharOffset == dsChars)
 				{
 					// Last char
 					Cursor->Pos.x1 = r.x1 + FixedToInt(FixX + ds->FX());
 				}
 				else
 				{
 					// In the middle somewhere...
 					LAutoPtr<DisplayStr> Tmp = ds->Clone(0, CharOffset);
 					// LDisplayString Tmp(ds->GetFont(), *ds, CharOffset);
 					if (Tmp)
 						Cursor->Pos.x1 = r.x1 + FixedToInt(FixX + Tmp->FX());
 				}
 
 				Cursor->Pos.y1 = r.y1 + ds->OffsetY;
 				Cursor->Pos.y2 = Cursor->Pos.y1 + ds->Y() - 1;
 				Cursor->Pos.x2 = Cursor->Pos.x1 + 1;
 
 				Cursor->Line.Set(Pos.x1, r.y1, Pos.x2, r.y2);
 				return true;
 			}					
 					
 			FixX += ds->FX();
 			CharPos += ds->Chars;
 		}
 				
 		if
 		(
 			(
 				tl->Strs.Length() == 0
 				||
 				i == Layout.Length() - 1
 			)
 			&&
 			Cursor->Offset == CharPos
 		)
 		{
 			// Cursor at the start of empty line.
 			Cursor->Pos.x1 = r.x1;
 			Cursor->Pos.x2 = Cursor->Pos.x1 + 1;
 			Cursor->Pos.y1 = r.y1;
 			Cursor->Pos.y2 = r.y2;
 
 			Cursor->Line.Set(Pos.x1, r.y1, Pos.x2, r.y2);
 			return true;
 		}
 				
 		CharPos += tl->NewLine;
 		LastY = tl->PosOff.y2;
 	}
 	
 	if (Cursor->Offset == 0 &&
 		Len == 0)
 	{
 		Cursor->Pos.x1 = Pos.x1;
 		Cursor->Pos.x2 = Pos.x1 + 1;
 		Cursor->Pos.y1 = Pos.y1;
 		Cursor->Pos.y2 = Pos.y2;
 
 		Cursor->Line = Pos;
 		return true;
 	}
 			
 	return false;
 }
 		
 bool LRichTextPriv::TextBlock::HitTest(HitTestResult &htr)
 {
 	if (htr.In.y < Pos.y1 || htr.In.y > Pos.y2)
 		return false;
 
 	ssize_t CharPos = 0;
 	for (unsigned i=0; i<Layout.Length(); i++)
 	{
 		TextLine *tl = Layout[i];
 		PtrCheckBreak(tl);
 		// int InitCharPos = CharPos;
 
 		LRect r = tl->PosOff;
 		r.Offset(Pos.x1, Pos.y1);
 		bool Over = r.Overlap(htr.In.x, htr.In.y);
 		bool OnThisLine =	htr.In.y >= r.y1 &&
 							htr.In.y <= r.y2;
 		if (OnThisLine && htr.In.x <= r.x1)
 		{
 			htr.Near = true;
 			htr.Idx = CharPos;
 			htr.LineHint = i;
 			
 			LAssert(htr.Idx <= Length());
 			
 			return true;
 		}
 		
 		int FixX = 0;
 		int InputX = IntToFixed(htr.In.x - Pos.x1 - tl->PosOff.x1);
 		for (unsigned n=0; n<tl->Strs.Length(); n++)
 		{
 			DisplayStr *ds = tl->Strs[n];
 			int dsFixX = ds->FX();
 			
 			if (Over &&
 				InputX >= FixX &&
 				InputX < FixX + dsFixX)
 			{
 				int OffFix = InputX - FixX;
 				int OffPx = FixedToInt(OffFix);
 				ssize_t OffChar = ds->PosToIndex(OffPx, true);
 
 				// d->DebugRects[0].Set(Pos.x1, r.y1, Pos.x1 + InputX+1, r.y2);
 						
 				htr.Blk = this;
 				htr.Ds = ds;
 				htr.Idx = CharPos + OffChar;
 				htr.LineHint = i;
 
 				LAssert(htr.Idx <= Length());
 
 				return true;
 			}
 					
 			FixX += ds->FX();
 
 			CharPos += ds->Chars;
 		}
 
 		if (OnThisLine)
 		{
 			htr.Near = true;
 			htr.Idx = CharPos;
 			htr.LineHint = i;
 			
 			LAssert(htr.Idx <= Length());
 
 			return true;
 		}
 				
 		CharPos += tl->NewLine;
 	}
 
 	return false;
 }
 
 void DrawDecor(LSurface *pDC, LRichTextPriv::DisplayStr *Ds, int Fx, int Fy, ssize_t Start, ssize_t Len)
 {
 	// LColour Old = pDC->Colour(LColour::Red);
 	LDisplayString ds1(Ds->GetFont(), (const char16*)(*Ds), Start);
 	LDisplayString ds2(Ds->GetFont(), (const char16*)(*Ds), Start+Len);
 
 	int x = (Fx >> LDisplayString::FShift);
 	int y = (Fy >> LDisplayString::FShift) + (int)Ds->GetAscent() + 1;
 	int End = x + ds2.X();
 	x += ds1.X();
 	pDC->Colour(LColour::Red);
 	while (x < End)
 	{
 		pDC->Set(x, y+(x%2));
 		x++;
 	}
 }
 
 bool Overlap(LSpellCheck::SpellingError *e, ssize_t start, ssize_t len)
 {
 	if (!e)
 		return false;
 	if (start+len <= e->Start)
 		return false;
 	if (start >= e->End())
 		return false;
 	return true;
 }
 
 void LRichTextPriv::TextBlock::DrawDisplayString(LSurface *pDC, DisplayStr *Ds, int &FixX, int FixY, LColour &Bk, ssize_t &Pos)
 {
 	int OldX = FixX;
 
 	// Paint the string itself...
 	Ds->Paint(pDC, FixX, FixY, Bk);
 
 	// Does the a spelling error overlap this string?
 	ssize_t DsEnd = Pos + Ds->Chars;
 	while (Overlap(SpErr, Pos, Ds->Chars))
 	{
 		// Yes, work out the region of characters and paint the decor
 		ssize_t Start = MAX(SpErr->Start, Pos);
 		ssize_t Len = MIN(SpErr->End(), Pos + Ds->Chars) - Start;
 		
 		// Draw the decor for the error
 		DrawDecor(pDC, Ds, OldX, FixY, Start - Pos, Len);
 		
 		if (SpErr->End() < DsEnd)
 		{
 			// Are there more errors?
 			SpErr = SpellingErrors.AddressOf(++PaintErrIdx);
 		}
 		else break;
 	}
 
 	while (SpErr && SpErr->End() < DsEnd)
 	{
 		// Are there more errors?
 		SpErr = SpellingErrors.AddressOf(++PaintErrIdx);
 	}
 
 
 	Pos += Ds->Chars;
 }
 
 
 void LRichTextPriv::TextBlock::OnPaint(PaintContext &Ctx)
 {
 	ssize_t CharPos = 0;
 	ssize_t EndPoints = 0;
 	ssize_t EndPoint[2] = {-1, -1};
 	ssize_t CurEndPoint = 0;
 
 	if (Cursors > 0 && Ctx.Select)
 	{
 		// Selection end point checks...
 		if (Ctx.Cursor && Ctx.Cursor->Blk == this)
 			EndPoint[EndPoints++] = Ctx.Cursor->Offset;
 		if (Ctx.Select && Ctx.Select->Blk == this)
 			EndPoint[EndPoints++] = Ctx.Select->Offset;
 				
 		// Sort the end points
 		if (EndPoints > 1 &&
 			EndPoint[0] > EndPoint[1])
 		{
 			ssize_t ep = EndPoint[0];
 			EndPoint[0] = EndPoint[1];
 			EndPoint[1] = ep;
 		}
 	}
 	
 	// Paint margins, borders and padding...
 	LRect r = Pos;
 	r.x1 -= Margin.x1;
 	r.y1 -= Margin.y1;
 	r.x2 -= Margin.x2;
 	r.y2 -= Margin.y2;
 	LCss::ColorDef BorderStyle;
 	if (Style)
 		BorderStyle = Style->BorderLeft().Color;
 	LColour BorderCol(222, 222, 222);
 	if (BorderStyle.Type == LCss::ColorRgb)
 		BorderCol.Set(BorderStyle.Rgb32, 32);
 
 	Ctx.DrawBox(r, Margin, Ctx.Colours[Unselected].Back);
 	Ctx.DrawBox(r, Border, BorderCol);
 	Ctx.DrawBox(r, Padding, Ctx.Colours[Unselected].Back);
 	
 	int CurY = Pos.y1;
 	PaintErrIdx = 0;
 	SpErr = SpellingErrors.AddressOf(PaintErrIdx);
 
 	for (unsigned i=0; i<Layout.Length(); i++)
 	{
 		TextLine *Line = Layout[i];
 
 		LRect LinePos = Line->PosOff;
 		LinePos.Offset(Pos.x1, Pos.y1);
 		if (Line->PosOff.X() < Pos.X())
 		{
 			Ctx.pDC->Colour(Ctx.Colours[Unselected].Back);
 			Ctx.pDC->Rectangle(LinePos.x2, LinePos.y1, Pos.x2, LinePos.y2);
 		}
 
 		int FixX = IntToFixed(LinePos.x1);
 		
 		if (CurY < LinePos.y1)
 		{
 			// Fill padded area...
 			Ctx.pDC->Colour(Ctx.Colours[Unselected].Back);
 			Ctx.pDC->Rectangle(Pos.x1, CurY, Pos.x2, LinePos.y1 - 1);
 		}
 
 		CurY = LinePos.y1;
 		LFont *Fnt = NULL;
 
 		#if DEBUG_NUMBERED_LAYOUTS
 		LString s;
 		s.Printf("%i", Ctx.Index);
 		Ctx.Index++;
 		#endif
 
 		for (unsigned n=0; n<Line->Strs.Length(); n++)
 		{
 			DisplayStr *Ds = Line->Strs[n];
 			LFont *DsFnt = Ds->GetFont();
 			ColourPair &Cols = Ds->Src->Colours;
 			if (DsFnt && DsFnt != Fnt)
 			{
 				Fnt = DsFnt;
 				Fnt->Transparent(false);
 			}
 
 			// If the current text part doesn't cover the full line height we have to
 			// fill in the rest here...
 			if (Ds->Y() < Line->PosOff.Y())
 			{
 				Ctx.pDC->Colour(Ctx.Colours[Unselected].Back);
 				int CurX = FixedToInt(FixX);
 				if (Ds->OffsetY > 0)
 					Ctx.pDC->Rectangle(CurX, CurY, CurX+Ds->X(), CurY+Ds->OffsetY-1);
 
 				int DsY2 = Ds->OffsetY + Ds->Y();
 				if (DsY2 < Pos.Y())
 					Ctx.pDC->Rectangle(CurX, CurY+DsY2, CurX+Ds->X(), Pos.y2);
 			}
 
 			// Check for selection changes...
 			int FixY = IntToFixed(CurY + Ds->OffsetY);
 
 			#if DEBUG_OUTLINE_CUR_STYLE_TEXT
 			LRect r(0, 0, -1, -1);
 			if (Ctx.Cursor->Blk == (Block*)this)
 			{
 				LArray<StyleText*> CurStyle;
 				if (GetTextAt(Ctx.Cursor->Offset, CurStyle) && Ds->Src == CurStyle.First())
 				{
 					r.ZOff(Ds->X()-1, Ds->Y()-1);
 					r.Offset(FixedToInt(FixX), FixedToInt(FixY));
 				}
 			}
 			#endif
 
 			if (CurEndPoint < EndPoints &&
 				EndPoint[CurEndPoint] >= CharPos &&
 				EndPoint[CurEndPoint] <= CharPos + Ds->Chars)
 			{
 				// Process string into parts based on the selection boundaries
 				ssize_t Ch = EndPoint[CurEndPoint] - CharPos;
 				ssize_t TmpPos = CharPos;
 				LAutoPtr<DisplayStr> ds1 = Ds->Clone(0, Ch);
 						
 				// First part...
 				LColour Bk = Ctx.Type == Unselected && Cols.Back.IsValid() ? Cols.Back : Ctx.Back();
 				if (DsFnt)
 					DsFnt->Colour(Ctx.Type == Unselected && Cols.Fore.IsValid() ? Cols.Fore : Ctx.Fore(), Bk);
 				if (ds1)
 					DrawDisplayString(Ctx.pDC, ds1, FixX, FixY, Bk, TmpPos);
 
 
 				Ctx.Type = Ctx.Type == Selected ? Unselected : Selected;
 				CurEndPoint++;
 						
 				// Is there 3 parts?
 				//
 				// This happens when the selection starts and end in the one string.
 				//
 				// The alternative is that it starts or ends in the strings but the other
 				// end point is in a different string. In which case there is only 2 strings
 				// to draw.
 				if (CurEndPoint < EndPoints &&
 					EndPoint[CurEndPoint] >= CharPos &&
 					EndPoint[CurEndPoint] <= CharPos + Ds->Chars)
 				{
 					// Yes..
 					ssize_t Ch2 = EndPoint[CurEndPoint] - CharPos;
 
 					// Part 2
 					LAutoPtr<DisplayStr> ds2 = Ds->Clone(Ch, Ch2 - Ch);
 					LColour Bk = Ctx.Type == Unselected && Cols.Back.IsValid() ? Cols.Back : Ctx.Back();
 					if (DsFnt)
 						DsFnt->Colour(Ctx.Type == Unselected && Cols.Fore.IsValid() ? Cols.Fore : Ctx.Fore(), Bk);
 					if (ds2)
 						DrawDisplayString(Ctx.pDC, ds2, FixX, FixY, Bk, TmpPos);
 					Ctx.Type = Ctx.Type == Selected ? Unselected : Selected;
 					CurEndPoint++;
 
 					// Part 3
 					if (Ch2 < Ds->Length())
 					{
 						LAutoPtr<DisplayStr> ds3 = Ds->Clone(Ch2);
 						Bk = Ctx.Type == Unselected && Cols.Back.IsValid() ? Cols.Back : Ctx.Back();
 						if (DsFnt)
 							DsFnt->Colour(Ctx.Type == Unselected && Cols.Fore.IsValid() ? Cols.Fore : Ctx.Fore(), Bk);
 						if (ds3)
 							DrawDisplayString(Ctx.pDC, ds3, FixX, FixY, Bk, TmpPos);
 					}
 				}
 				else if (Ch < Ds->Chars)
 				{
 					// No... draw 2nd part
 					LAutoPtr<DisplayStr> ds2 = Ds->Clone(Ch);
 					LColour Bk = Ctx.Type == Unselected && Cols.Back.IsValid() ? Cols.Back : Ctx.Back();
 					if (DsFnt)
 						DsFnt->Colour(Ctx.Type == Unselected && Cols.Fore.IsValid() ? Cols.Fore : Ctx.Fore(), Bk);
 					if (ds2)	
 						DrawDisplayString(Ctx.pDC, ds2, FixX, FixY, Bk, TmpPos);
 				}
 			}
 			else
 			{
 				// No selection changes... draw the whole string
 				LColour Bk = Ctx.Type == Unselected && Cols.Back.IsValid() ? Cols.Back : Ctx.Back();
 				if (DsFnt)
 					DsFnt->Colour(Ctx.Type == Unselected && Cols.Fore.IsValid() ? Cols.Fore : Ctx.Fore(), Bk);
 						
 				#if DEBUG_OUTLINE_CUR_DISPLAY_STR
 				int OldFixX = FixX;
 				#endif
 
 				auto TmpPos = CharPos;
 				DrawDisplayString(Ctx.pDC, Ds, FixX, FixY, Bk, TmpPos);
 
 				#if DEBUG_OUTLINE_CUR_DISPLAY_STR
 				if (Ctx.Cursor->Blk == (Block*)this &&
 					Ctx.Cursor->Offset >= CharPos &&
 					Ctx.Cursor->Offset < CharPos + Ds->Chars)
 				{
 					LRect r(0, 0, Ds->X()-1, Ds->Y()-1);
 					r.Offset(FixedToInt(OldFixX), FixedToInt(FixY));
 					Ctx.pDC->Colour(LColour::Red);
 					Ctx.pDC->Box(&r);
 				}
 				#endif
 			}
 
 			#if DEBUG_OUTLINE_CUR_STYLE_TEXT
 			if (r.Valid())
 			{
 				Ctx.pDC->Colour(LColour(192, 192, 192));
 				Ctx.pDC->LineStyle(LSurface::LineDot);
 				Ctx.pDC->Box(&r);
 				Ctx.pDC->LineStyle(LSurface::LineSolid);
 			}
 			#endif
 
 			CharPos += Ds->Chars;
 		}
 		if (Line->Strs.Length() == 0)
 		{
 			if (CurEndPoint < EndPoints &&
 				EndPoint[CurEndPoint] == CharPos)
 			{
 				Ctx.Type = Ctx.Type == Selected ? Unselected : Selected;
 				CurEndPoint++;
 			}
 		}
 		if (Ctx.Type == Selected)
 		{
 			// Draw new line
 			int x1 = FixedToInt(FixX);
 			FixX += IntToFixed(5);
 			int x2 = FixedToInt(FixX);
 			Ctx.pDC->Colour(Ctx.Colours[Selected].Back);
 			Ctx.pDC->Rectangle(x1, LinePos.y1, x2, LinePos.y2);
 		}
 		Ctx.pDC->Colour(Ctx.Colours[Unselected].Back);
 		Ctx.pDC->Rectangle(FixedToInt(FixX), LinePos.y1, Pos.x2, LinePos.y2);
 		
 
 		#if DEBUG_NUMBERED_LAYOUTS
 		LDisplayString Ds(LSysFont, s);
 		LSysFont->Colour(LColour::Green, LColour::White);
 		LSysFont->Transparent(false);
 		Ds.Draw(Ctx.pDC, LinePos.x1, LinePos.y1);
 		/*
 		Ctx.pDC->Colour(LColour::Blue);
 		Ctx.pDC->Line(LinePos.x1, LinePos.y1,LinePos.x2,LinePos.y2);
 		*/
 		#endif
 				
 		CurY = LinePos.y2 + 1;
 		CharPos += Line->NewLine;
 	}
 
 	if (CurY < Pos.y2)
 	{
 		// Fill padded area...
 		Ctx.pDC->Colour(Ctx.Colours[Unselected].Back);
 		Ctx.pDC->Rectangle(Pos.x1, CurY, Pos.x2, Pos.y2);
 	}
 
 	if (Ctx.Cursor &&
 		Ctx.Cursor->Blk == this &&
 		Ctx.Cursor->Blink &&
 		d->View->Focus())
 	{
 		Ctx.pDC->Colour(CursorColour);
+		
+		if (!Ctx.Cursor->Pos.Valid())
+		{
+			// Try and recover a valid position for the cursor...
+			if (!GetPosFromIndex(Ctx.Cursor))
+			{
+				Ctx.Cursor->LineHint = -1;
+				GetPosFromIndex(Ctx.Cursor);
+			}
+		}
+
 		if (Ctx.Cursor->Pos.Valid())
 			Ctx.pDC->Rectangle(&Ctx.Cursor->Pos);
 		else
 			Ctx.pDC->Rectangle(Pos.x1, Pos.y1, Pos.x1, Pos.y2);
 	}
 	#if 0 // def _DEBUG
 	if (Ctx.Select &&
 		Ctx.Select->Blk == this)
 	{
 		Ctx.pDC->Colour(LColour(255, 0, 0));
 		Ctx.pDC->Rectangle(&Ctx.Select->Pos);
 	}
 	#endif
 }
 		
 bool LRichTextPriv::TextBlock::OnLayout(Flow &flow)
 {
 	if (Pos.X() == flow.X() && !LayoutDirty)
 	{
 		// Adjust position to match the flow, even if we are not dirty
 		Pos.Offset(0, flow.CurY - Pos.y1);
 		flow.CurY = Pos.y2 + 1;
 		return true;
 	}
 
 	static int Count = 0;
 	Count++;
 
 	LayoutDirty = false;
 	Layout.DeleteObjects();
 			
 	flow.Left += Margin.x1;
 	flow.Right -= Margin.x2;
 	flow.CurY += Margin.y1;
 			
 	Pos.x1 = flow.Left;
 	Pos.y1 = flow.CurY;
 	Pos.x2 = flow.Right;
 	Pos.y2 = flow.CurY-1; // Start with a 0px height.
 			
 	flow.Left += Border.x1 + Padding.x1;
 	flow.Right -= Border.x2 + Padding.x2;
 	flow.CurY += Border.y1 + Padding.y1;
 
 	int FixX = 0; // Current x offset (fixed point) on the current line
 	LAutoPtr<TextLine> CurLine(new TextLine(flow.Left - Pos.x1, flow.X(), flow.CurY - Pos.y1));
 	if (!CurLine)
 		return flow.d->Error(_FL, "alloc failed.");
 
 	ssize_t LayoutSize = 0;
 	ssize_t TextSize = 0;
 	for (unsigned i=0; i<Txt.Length(); i++)
 	{
 		StyleText *t = Txt[i];
 		LNamedStyle *tstyle = t->GetStyle();
 		LAssert(t->Length() >= 0);			
 		TextSize += t->Length();
 		
 		if (t->Length() == 0)
 			continue;
 
 		int AvailableX = Pos.X() - CurLine->PosOff.x1;
 		if (AvailableX < 0)
 			AvailableX = 1;
 
 		// Get the font for 't'
 		LFont *f = flow.d->GetFont(t->GetStyle());
 		if (!f)
 			return flow.d->Error(_FL, "font creation failed.");
 		LCss::WordWrapType WrapType = tstyle ? tstyle->WordWrap() : LCss::WrapNormal;
 		
 		uint32_t *sStart = t->At(0);
 		uint32_t *sEnd = sStart + t->Length();
 		for (ssize_t Off = 0; Off < (ssize_t)t->Length(); )
 		{
 			// How much of 't' is on the same line?
 			uint32_t *s = sStart + Off;
 
 			#if DEBUG_LAYOUT
 			LgiTrace("Txt[%i][%i]: FixX=%i, Txt='%.*S'\n", i, Off, FixX, t->Length() - Off, s);
 			#endif
 
 			if (*s == '\n')
 			{
 				// New line handling...
 				Off++;
 				CurLine->PosOff.x2 = CurLine->PosOff.x1 + FixedToInt(FixX) - 1;
 				FixX = 0;
 				CurLine->LayoutOffsets(f->GetHeight());
 				Pos.y2 = MAX(Pos.y2, Pos.y1 + CurLine->PosOff.y2);
 				CurLine->NewLine = 1;
 				
 				LayoutSize += CurLine->Length();
 				
 				#if DEBUG_LAYOUT
 				LgiTrace("\tNewLineChar, LayoutSize=%i, TextSize=%i\n", LayoutSize, TextSize);
 				#endif
 				
 				Layout.Add(CurLine.Release());
 				CurLine.Reset(new TextLine(flow.Left - Pos.x1, flow.X(), Pos.Y()));
 
 				if (Off == t->Length())
 				{
 					// Empty line at the end of the StyleText
 					const uint32_t Empty[] = {0};
 					CurLine->Strs.Add(new DisplayStr(t, f, Empty, 0, flow.pDC));
 				}
 				continue;
 			}
 
 			uint32_t *e = s;
 			/*
 			printf("e=%i sEnd=%i len=%i\n",
 				(int)(e - sStart),
 				(int)(sEnd - sStart),
 				(int)t->Length());
 			*/
 			while (e < sEnd && *e != '\n')
 				e++;
 					
 			// Add 't' to current line
 			LCss::Len fntSize;
 			if (f)
 				fntSize = f->Size();
 			
 			ssize_t Chars = MIN(1024, e - s);
 			LAutoPtr<DisplayStr> Ds
 			(
 				t->Emoji
 				?
 				new EmojiDisplayStr(t,
 									d->GetEmojiImage(),
 									fntSize,
 									s,
 									Chars)
 				:
 				new DisplayStr(t, f, s, Chars, flow.pDC)
 			);
 			if (!Ds)
 				return flow.d->Error(_FL, "display str creation failed.");
 
 			if (WrapType != LCss::WrapNone &&
 				FixX + Ds->FX() > IntToFixed(AvailableX))
 			{
 				#if DEBUG_LAYOUT
 				LgiTrace("\tNeedToWrap: %i, %i + %i > %i\n", WrapType, FixX, Ds->FX(), IntToFixed(AvailableX));
 				#endif
 
 				// Wrap the string onto the line...
 				int AvailablePx = AvailableX - FixedToInt(FixX);
 				ssize_t FitChars = Ds->PosToIndex(AvailablePx, false);
 				if (FitChars < 0)
 				{
 					#if DEBUG_LAYOUT
 					LgiTrace("\tFitChars error: %i\n", FitChars);
 					#endif
 					flow.d->Error(_FL, "PosToIndex(%i) failed.", AvailablePx);
 					LAssert(0);
 				}
 				else
 				{
 					// Wind back to the last break opportunity
 					ssize_t ch = 0;
 					for (ch = FitChars; ch > 0; ch--)
 					{
 						if (IsWordBreakChar(s[ch-1]))
 							break;
 					}
 					#if DEBUG_LAYOUT
 					LgiTrace("\tWindBack: %i\n", (int)ch);
 					#endif
 					if (ch == 0)
 					{
 						// One word minimum per line
 						for (ch = 1; ch < Chars; ch++)
 						{
 							if (IsWordBreakChar(s[ch]))
 								break;
 						}
 						Chars = ch;
 					}						
 					else if (ch > (FitChars >> 2))
 						Chars = ch;
 					else
 						Chars = FitChars;
 							
 					// Create a new display string of the right size...
 					LCss::Len fntSize;
 					if (f)
 						fntSize = f->Size();
 					if
 					(
 						!
 						Ds.Reset
 						(
 							t->Emoji
 							?
 							new EmojiDisplayStr(t, d->GetEmojiImage(), fntSize, s, Chars)
 							:
 							new DisplayStr(t, f, s, Chars, flow.pDC)
 						)
 					)
 						return flow.d->Error(_FL, "failed to create wrapped display str.");
 					
 					// Finish off line
 					CurLine->PosOff.x2 = CurLine->PosOff.x1 + FixedToInt(FixX + Ds->FX()) - 1;
 					CurLine->Strs.Add(Ds.Release());
 
 					CurLine->LayoutOffsets(d->Font->GetHeight());
 					Pos.y2 = MAX(Pos.y2, Pos.y1 + CurLine->PosOff.y2);
 					LayoutSize += CurLine->Length();
 					Layout.Add(CurLine.Release());
 
 					#if DEBUG_LAYOUT
 					LgiTrace("\tWrap, LayoutSize=%i TextSize=%i\n", LayoutSize, TextSize);
 					#endif
 					
 					// New line...
 					CurLine.Reset(new TextLine(flow.Left - Pos.x1, flow.X(), Pos.Y()));
 					FixX = 0;
 					Off += Chars;
 					continue;
 				}
 			}
 			else
 			{
 				FixX += Ds->FX();
 			}
 					
 			if (!Ds)
 				break;
 					
 			CurLine->PosOff.x2 = CurLine->PosOff.x1 + FixedToInt(FixX) - 1;
 			CurLine->Strs.Add(Ds.Release());
 			Off += Chars;
 		}
 	}
 	if (Txt.Length() == 0)
 	{
 		// Empty node case
 		int y = Pos.y1 + flow.d->View->GetFont()->GetHeight() - 1;
 		CurLine->PosOff.y2 = Pos.y2 = MAX(Pos.y2, y);
 		LayoutSize += CurLine->Length();
 
 		Layout.Add(CurLine.Release());
 	}
 			
 	if (CurLine && CurLine->Strs.Length() > 0)
 	{
 		LFont *f = d->View ? d->View->GetFont() : LSysFont;
 		CurLine->LayoutOffsets(f->GetHeight());
 		Pos.y2 = MAX(Pos.y2, Pos.y1 + CurLine->PosOff.y2);
 		LayoutSize += CurLine->Length();
 
 		#if DEBUG_LAYOUT
 		LgiTrace("\tRemaining, LayoutSize=%i, TextSize=%i\n", LayoutSize, TextSize);
 		#endif
 
 		Layout.Add(CurLine.Release());
 	}
 	
 	LAssert(LayoutSize == Len);
 			
 	flow.CurY = Pos.y2 + 1 + Margin.y2 + Border.y2 + Padding.y2;
 	flow.Left -= Margin.x1 + Border.x1 + Padding.x1;
 	flow.Right += Margin.x2 + Border.x2 + Padding.x2;
 			
 	return true;
 }
 		
 ssize_t LRichTextPriv::TextBlock::GetTextAt(ssize_t Offset, LArray<StyleText*> &Out)
 {
 	if (Txt.Length() == 0)
 		return 0;
 
 	StyleText **t = &Txt[0];
 	StyleText **e = t + Txt.Length();
 	Out.Length(0);
 
 	ssize_t Pos = 0;
 	while (t < e)
 	{
 		ssize_t Len = (*t)->Length();
 		if (Offset >= Pos && Offset <= Pos + Len)
 			Out.Add(*t);
 
 		t++;
 		Pos += Len;
 	}
 
 	LAssert(Pos == Len);
 	return Out.Length();
 }
 
 bool LRichTextPriv::TextBlock::IsValid()
 {
 	ssize_t TxtLen = 0;
 	for (unsigned i = 0; i < Txt.Length(); i++)
 	{
 		StyleText *t = Txt[i];
 		TxtLen += t->Length();
 		for (unsigned n = 0; n < t->Length(); n++)
 		{
 			if ((*t)[n] == 0)
 			{
 				LAssert(0);
 				return false;
 			}
 		}
 	}
 	
 	if (Len != TxtLen)
 		return d->Error(_FL, "Txt.Len vs Len mismatch: %i, %i.", TxtLen, Len);
 
 	return true;
 }
 
 int LRichTextPriv::TextBlock::GetLines()
 {
 	return (int)Layout.Length();
 }
 
 bool LRichTextPriv::TextBlock::OffsetToLine(ssize_t Offset, int *ColX, LArray<int> *LineY)
 {
 	if (LayoutDirty)
 		return false;
 
 	if (LineY)
 		LineY->Length(0);
 	if (Offset <= 0)
 	{
 		if (ColX) *ColX = 0;
 		if (LineY) LineY->Add(0);
 		return true;
 	}
 
 	bool Found = false;
 	ssize_t Pos = 0;
 
 	for (unsigned i=0; i<Layout.Length(); i++)
 	{
 		TextLine *tl = Layout[i];
 		auto Len = tl->Length();
 
 		if (Offset >= Pos && Offset <= Pos + Len - tl->NewLine)
 		{
 			if (ColX) *ColX = (int)(Offset - Pos);
 			if (LineY) LineY->Add(i);
 			Found = true;
 		}
 		
 		Pos += Len;
 	}
 
 	return Found;
 }
 
 ssize_t LRichTextPriv::TextBlock::LineToOffset(ssize_t Line)
 {
 	if (LayoutDirty)
 		return -1;
 	
 	if (Line <= 0)
 		return 0;
 
 	ssize_t Pos = 0;
 	for (size_t i=0; i<Layout.Length(); i++)
 	{
 		auto tl = Layout[i];
 		auto Len = tl->Length();
 		if (i == Line)
 			return Pos;
-		Pos = Len;
+		Pos += Len;
 	}
 
 	return (int)Length();
 }
 
 
 bool LRichTextPriv::TextBlock::PreEdit(Transaction *Trans)
 {
 	if (Trans)
 	{
 		bool HasThisBlock = false;
 		for (unsigned i=0; i<Trans->Changes.Length(); i++)
 		{
 			CompleteTextBlockState *c = dynamic_cast<CompleteTextBlockState*>(Trans->Changes[i]);
 			if (c)
 			{
 				if (c->Uid == BlockUid)
 				{
 					HasThisBlock = true;
 					break;
 				}
 			}
 		}
 
 		if (!HasThisBlock)
 			Trans->Add(new CompleteTextBlockState(d, this));
 	}
 
 	return true;
 }
 
 ssize_t LRichTextPriv::TextBlock::DeleteAt(Transaction *Trans, ssize_t BlkOffset, ssize_t Chars, LArray<uint32_t> *DeletedText)
 {
 	ssize_t Pos = 0;
 	ssize_t Deleted = 0;
 
 	PreEdit(Trans);
 
 	for (unsigned i=0; i<Txt.Length() && Chars > 0; i++)
 	{
 		StyleText *t = Txt[i];
 		ssize_t TxtOffset = BlkOffset - Pos;
 		if (TxtOffset >= 0 && TxtOffset < (int)t->Length())
 		{
 			ssize_t MaxChars = t->Length() - TxtOffset;
 			ssize_t Remove = MIN(Chars, MaxChars);
 			if (Remove <= 0)
 				return 0;
 			ssize_t Remaining = MaxChars - Remove;
 			ssize_t NewLen = t->Length() - Remove;
 			
 			if (DeletedText)
 			{
 				DeletedText->Add(t->At(TxtOffset), Remove);
 			}
 			if (Remaining > 0)
 			{
 				// Copy down
 				memmove(&(*t)[TxtOffset], &(*t)[TxtOffset + Remove], Remaining * sizeof(uint32_t));
 				(*t)[NewLen] = 0;
 			}
 
 			// Change length
 			if (NewLen == 0)
 			{
 				// Remove run completely
 				// LgiTrace("DelRun %p/%i '%.*S'\n", t, i, t->Length(), &(*t)[0]);
 				Txt.DeleteAt(i--, true);
 				DeleteObj(t);
 			}
 			else
 			{
 				// Shorten run
 				t->Length(NewLen);
 				// LgiTrace("ShortenRun %p/%i '%.*S'\n", t, i, t->Length(), &(*t)[0]);
 			}
 
 			LayoutDirty = true;
 			Chars -= Remove;
 			Len -= Remove;
 			Deleted += Remove;
 		}
 
 		if (t)
 			Pos += t->Length();
 	}
 
 	if (Deleted > 0)
 	{
 		// Adjust start of existing spelling styles
 		LRange r(BlkOffset, Deleted);
 		for (auto &Err : SpellingErrors)
 		{
 			if (Err.Overlap(r).Valid())
 			{
 				Err -= r;
 			}
 			else if (Err > r)
 			{
 				Err.Start -= Deleted;
 			}
 		}
 
 		LayoutDirty = true;
 		UpdateSpellingAndLinks(Trans, LRange(BlkOffset, 0));
 	}
 
 	IsValid();
 
 	return Deleted;
 }
 		
 bool LRichTextPriv::TextBlock::AddText(Transaction *Trans, ssize_t AtOffset, const uint32_t *InStr, ssize_t InChars, LNamedStyle *Style)
 {
 	if (!InStr)
 		return d->Error(_FL, "No input text.");
 	if (InChars < 0)
 		InChars = Strlen(InStr);
 
 	PreEdit(Trans);
 	
 	LArray<EmojiChar> EmojiIdx;
 	for (int i=0; i<InChars;)
 	{
 		auto &e = EmojiIdx[i];
 		e = EmojiToIconIndex(InStr + i, InChars - i);
 		if (e.Index >= 0)
 			i += e.Size;
 		else
 			i++;
 	}
 
 	ssize_t InitialOffset = AtOffset >= 0 ? AtOffset : Len;
 	ssize_t Chars = 0; // Length of run to insert
 	ssize_t Pos = 0; // Current character position in this block
 	uint32_t TxtIdx = 0; // Index into Txt array
 	
 	for (ssize_t i = 0; i < InChars; i += Chars)
 	{
 		// Work out the run of chars that are either
 		// Emoji or not Emoji...
 		bool IsEmoji = EmojiIdx[i].Index >= 0;
 		Chars = 0;
 		for (auto n = i; n < InChars;)
 		{
 			if ( IsEmoji ^ (EmojiIdx[n].Index >= 0) )
 				break;
 
 			if (IsEmoji)
 			{
 				auto &e = EmojiIdx[n];
 				if (e.Index >= 0 && e.Size > 0)
 				{
 					Chars += e.Size;
 					n += e.Size;
 				}
 				else
 				{
 					LAssert(!"Something went wrong.");
 					Chars++;
 					n++;
 				}
 			}
 			else
 			{
 				Chars++;
 				n++;
 			}
 		}
 		
 		// Now process 'Char' chars
 		const uint32_t *Str = InStr + i;
 
 		if (AtOffset >= 0 && Txt.Length() > 0)
 		{
 			// Seek further into block?
 			while (	Pos < AtOffset &&
 					TxtIdx < Txt.Length())
 			{
 				StyleText *t = Txt[TxtIdx];
 				ssize_t Len = t->Length();
 				if (AtOffset <= Pos + Len)
 					break;
 				Pos += Len;
 				TxtIdx++;
 			}
 			
 			StyleText *t = TxtIdx >= Txt.Length() ? Txt.Last() : Txt[TxtIdx];
 			ssize_t TxtLen = t->Length();
 			if (AtOffset >= Pos && AtOffset <= Pos + TxtLen)
 			{
 				ssize_t StyleOffset = AtOffset - Pos;	// Offset into 't' in which we need to potentially break the style
 														// to insert the new content.
 				bool UrlEdge = t->Element == TAG_A && *Str == '\n';
 
 				if (!Style && IsEmoji == t->Emoji && !UrlEdge)
 				{
 					// Insert/append to existing text run
 					ssize_t After = t->Length() - StyleOffset;
 					ssize_t NewSz = t->Length() + Chars;
 					t->Length(NewSz);
 					uint32_t *c = &t->First();
 
 					LOG_FN("TextBlock(%i)::Add(%i,%i,%s)::Append StyleOffset=%i, After=%i\n", GetUid(), AtOffset, InChars, Style?Style->Name.Get():NULL, StyleOffset, After);
 
 					// Do we need to move characters up to make space?
 					if (After > 0)
 						memmove(c + StyleOffset + Chars, c + StyleOffset, After * sizeof(*c));
 
 					// Insert the new string...
 					memcpy(c + StyleOffset, Str, Chars * sizeof(*c));
 					Len += Chars;
 					AtOffset += Chars;
 				}
 				else
 				{
 					// Break into 2 runs, with the new text in the middle...
 
 					// Insert the new text+style
 					StyleText *Run = new StyleText(Str, Chars, Style);
 					if (!Run)
 						return false;
 					Run->Emoji = IsEmoji;
 					
 					
 					/* This following code could be wrong. In terms of test cases I fixed this:
 					
 					A) Starting with basic empty email + signature.
 						Insert a URL at the very start.
 						Then hit enter.
 						Buf: \n inserted BEFORE the URL.
 						Changed the condition to 'StyleOffset != 0' rather than 'TxtIdx != 0'
 					
 					Potentially other test cases could exhibit bugs that need to be added here.
 					*/
 					if (StyleOffset)
 						Txt.AddAt(++TxtIdx, Run);
 					else
 						Txt.AddAt(TxtIdx++, Run);
 					////////////////////////////////////
 					
 					Pos += StyleOffset; // We are skipping over the run at 'TxtIdx', update pos
 
 					LOG_FN("TextBlock(%i)::Add(%i,%i,%s)::Insert StyleOffset=%i\n", GetUid(), AtOffset, InChars, Style?Style->Name.Get():NULL, StyleOffset);
 
 					if (StyleOffset < TxtLen)
 					{
 						// Insert the 2nd part of the string
 						Run = new StyleText(t->At(StyleOffset), TxtLen - StyleOffset, t->GetStyle());
 						if (!Run) return false;
 						Pos += Chars;
 						Txt.AddAt(++TxtIdx, Run);
 
 						// Now truncate the existing text..
 						t->Length(StyleOffset);
 					}
 					
 					Len += Chars;
 					AtOffset += Chars;
 				}
 
 				Str = NULL;
 			}
 		}
 
 		if (Str)
 		{
 			// At the end
 			StyleText *Last = Txt.Length() > 0 ? Txt.Last() : NULL;
 			if (Last &&
 				Last->GetStyle() == Style &&
 				IsEmoji == Last->Emoji)
 			{
 				if (Last->Add((uint32_t*)Str, Chars))
 				{
 					Len += Chars;
 					if (AtOffset >= 0)
 						AtOffset += Chars;
 				}
 			}
 			else
 			{			
 				StyleText *Run = new StyleText(Str, Chars, Style);
 				if (!Run)
 					return false;
 				Run->Emoji = IsEmoji;
 				Txt.Add(Run);
 				Len += Chars;
 				if (AtOffset >= 0)
 					AtOffset += Chars;
 			}
 		}
 	}
 
 	// Push existing spelling styles along
 	for (auto &Err : SpellingErrors)
 	{
 		if (Err.Start >= InitialOffset)
 			Err.Start += InChars;
 	}
 
 	// Update layout and styling
 	LayoutDirty = true;	
 	IsValid();
 	UpdateSpellingAndLinks(Trans, LRange(InitialOffset, InChars));
 	
 	return true;
 }
 
 bool LRichTextPriv::TextBlock::OnDictionary(Transaction *Trans)
 {
 	UpdateSpellingAndLinks(Trans, LRange(0, Length()));
 	return true;
 }
 
 #define IsUrlWordChar(t) \
 	(((t) > ' ') && !strchr("./:", (t)))
 
 template<typename Char>
 bool _ScanWord(Char *&t, Char *e)
 {
 	if (!IsUrlWordChar(*t))
 		return false;
 	
 	Char *s = t;
 	while (t < e && IsUrlWordChar(*t))
 		t++;
 	
 	return t > s;
 }
 
 bool IsBracketed(int s, int e)
 {
 	if (s == '(' && e == ')')
 		return true;
 	if (s == '[' && e == ']')
 		return true;
 	if (s == '{' && e == '}')
 		return true;
 	if (s == '<' && e == '>')
 		return true;
 	return false;
 }
 
 #define ScanWord() \
 	if (t >= e || !_ScanWord(t, e)) return false
 #define ScanChar(ch) \
 	if (t >= e || *t != ch) \
 		return false; \
 	t++
 
 template<typename Char>
 bool DetectUrl(Char *t, ssize_t &len)
 {
 	#ifdef _DEBUG
 	LString str(t, len);
 	//char *ss = str;
 	#endif
 	
 	Char *s = t;
 	Char *e = t + len;
 	ScanWord(); // Protocol
 	ScanChar(':');
 	ScanChar('/');
 	ScanChar('/');
 	ScanWord(); // Host name or username..
 	if (t < e && *t == ':')
 	{
 		t++;
 		_ScanWord(t, e); // Don't return if missing... password optional
 		ScanChar('@');
 		ScanWord(); // First part of host name...
 	}
 
 	// Rest of host name
 	while (t < e && *t == '.')
 	{
 		t++;
 		if (t < e && IsUrlWordChar(*t))
 			ScanWord(); // Second part of host name
 	}
 	
 	if (t < e && *t == ':') // Port number
 	{
 		t++;
 		ScanWord();
 	}
 	
 	while (t < e && strchr("/.:", *t)) // Path
 	{
 		t++;
 		if (t < e && (IsUrlWordChar(*t) || *t == ':'))
 			ScanWord();
 	}
 	
 	if (strchr("!.", t[-1]))
 		t--;
 	
 	len = t - s;
 	return true;
 }
 
 int ErrSort(LSpellCheck::SpellingError *a, LSpellCheck::SpellingError *b)
 {
 	return (int) (a->Start - b->Start);
 }
 
 void LRichTextPriv::TextBlock::SetSpellingErrors(LArray<LSpellCheck::SpellingError> &Errors, LRange r)
 {
 	// LgiTrace("%s:%i - SetSpellingErrors " LPrintfSSizeT ", " LPrintfSSizeT ":" LPrintfSSizeT "\n", _FL, Errors.Length(), r.Start, r.End());
 
 	// Delete any errors overlapping 'r'
 	for (unsigned i=0; i<SpellingErrors.Length(); i++)
 	{
 		if (SpellingErrors[i].Overlap(r).Valid())
 			SpellingErrors.DeleteAt(i--, true);
 	}
 
 	// Insert the new errors and sort into place..
 	for (auto &e : Errors)
 	{
 		auto &n = SpellingErrors.New();
 		n.Start = r.Start + e.Start;
 		n.Len = e.Len;
 		n.Suggestions = e.Suggestions;
 	}
 	SpellingErrors.Sort(ErrSort);
 }
 
 #define IsWordChar(ch) ( IsAlpha(ch) || (ch) == '\'' )
 
 void LRichTextPriv::TextBlock::UpdateSpellingAndLinks(Transaction *Trans, LRange r)
 {
 	LArray<uint32_t> Text;
 	if (!CopyAt(0, Length(), &Text))
 		return;
 
 	// Spelling...
 	if (d->SpellCheck &&
 		d->SpellDictionaryLoaded)
 	{
 		LRange Rgn = r;
 		while (Rgn.Start > 0 &&
 				IsWordChar(Text[Rgn.Start-1]))
 		{
 			Rgn.Start--;
 			Rgn.Len++;
 		}
 		while (Rgn.End() < Len &&
 				IsWordChar(Text[Rgn.End()]))
 		{
 			Rgn.Len++;
 		}
 
 		LString s(Text.AddressOf(Rgn.Start), Rgn.Len);
 		LArray<LVariant> Params;
 		Params[SpellBlockPtr] = (Block*)this;
 
 		// LgiTrace("%s:%i - Check(%s) " LPrintfSSizeT ":" LPrintfSSizeT "\n", _FL, s.Get(), Rgn.Start, Rgn.End());
 
 		d->SpellCheck->Check(d->View->AddDispatch(), s, Rgn.Start, Rgn.Len, &Params);
 	}
 
 	// Link detection...
 	
 	// Extend the range to include whole words
 	while (r.Start > 0 && !IsWhiteSpace(Text[r.Start]))
 	{
 		r.Start--;
 		r.Len++;
 	}
 	while (r.End() < (ssize_t)Text.Length() && !IsWhiteSpace(Text[r.End()]))
 		r.Len++;
 
 	// Create array of words...
 	LArray<LRange> Words;
 	bool Ws = true;
 	for (int i = 0; i < r.Len; i++)
 	{
 		bool w = IsWhiteSpace(Text[r.Start + i]);
 		if (w ^ Ws)
 		{
 			Ws = w;
 			if (!w)
 			{
 				LRange &w = Words.New();
 				w.Start = r.Start + i;
 				// printf("StartWord=%i, %i\n", w.Start, w.Len);
 			}
 			else if (Words.Length() > 0)
 			{
 				LRange &w = Words.Last();
 				w.Len = r.Start + i - w.Start;
 				// printf("EndWord=%i, %i\n", w.Start, w.Len);
 			}
 		}
 	}
 	if (!Ws && Words.Length() > 0)
 	{
 		LRange &w = Words.Last();
 		w.Len = r.Start + r.Len - w.Start;
 		// printf("TermWord=%i, %i Words=%i\n", w.Start, w.Len, Words.Length());
 	}
 	
 	// For each word in the range of text
 	for (unsigned i = 0; i<Words.Length(); i++)
 	{
 		LRange w = Words[i];
 
 		// Check there is a URL at the location
 		bool IsUrl = DetectUrl(Text.AddressOf(w.Start), w.Len);
 		
 		#if 0
 		{
 			LString s(Text.AddressOf(w.Start), w.Len);
 			printf("DetectUrl(%s)=%i\n", s.Get(), IsUrl);
 		}
 		#endif
 		
 		if (IsUrl)
 		{
 			// Are there chars bracketing the URL?
 			if (IsBracketed(Text[w.Start], Text[w.End()-1]))
 			{
 				w.Start++;
 				w.Len -= 2;
 			}
 			
 			// Make it a link...
 			LString Link(Text.AddressOf(w.Start), w.Len);
 			d->MakeLink(this, w.Start, w.Len, Link);
 			
 			// Also unlink any of the word after the URL
 			if (w.End() < Words[i].End())
 			{
 				LCss Style;
 				ChangeStyle(Trans, w.End(), Words[i].End() - w.End(), &Style, false);
 			}
 		}
 	}
 }
 
 bool LRichTextPriv::TextBlock::StripLast(Transaction *Trans, const char *Set)
 {
 	if (Txt.Length() == 0)
 		return false;
 
 	StyleText *l = Txt.Last();
 	if (!l || l->Length() <= 0)
 		return false;
 
 	if (!strchr(Set, l->Last()))
 		return false;
 	
 	PreEdit(Trans);
 	if (!l->PopLast())
 		return false;
 
 	LayoutDirty = true;
 	Len--;
 	return true;
 }
 
 bool LRichTextPriv::TextBlock::DoContext(LSubMenu &s, LPoint Doc, ssize_t Offset, bool TopOfMenu)
 {
 	if (!TopOfMenu)
 		return false;
 
 	// Is there a spelling error at 'Offset'?		
 	for (unsigned i=0; i<SpellingErrors.Length(); i++)
 	{
 		LSpellCheck::SpellingError &e = SpellingErrors[i];
 		if (Offset >= e.Start && Offset < e.End())
 		{
 			ClickErrIdx = i;
 			if (e.Suggestions.Length())
 			{
 				auto Sp = s.AppendSub("Spelling");
 				if (Sp)
 				{
 					s.AppendSeparator();
 					for (unsigned n=0; n<e.Suggestions.Length(); n++)
 						Sp->AppendItem(e.Suggestions[n], SPELLING_BASE+n);
 				}
 				// else printf("%s:%i - No sub menu.\n", _FL);
 			}
 			// else printf("%s:%i - No Suggestion.\n", _FL);
 			break;
 		}
 		// else printf("%s:%i - Outside area, Offset=%i e=%i,%i.\n", _FL, Offset, e.Start, e.End());
 	}
 
 	// Check for URLs under the cursor?
 	ssize_t pos = 0;
 	for (auto t: Txt)
 	{
 		// LgiTrace("t: %i %i\n", (int)pos, t->Element);
 		if (t->Element == TAG_A)
 		{
 			// LgiTrace("off: %i %i %i\n", (int)Offset, (int)pos, (int)pos + (int)t->Length());
 			if (Offset >= pos && Offset < pos + (ssize_t)t->Length())
 			{
 				// Is over a link...
 				s.AppendItem("Open URL", IDM_OPEN_URL);
 				ClickedUri = t->Param;
 				break;
 			}
 		}
 
 		pos += t->Length();
 	}
 
 	return true;
 }
 
 LMessage::Result LRichTextPriv::TextBlock::OnEvent(LMessage* Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_COMMAND:
 		{
 			if (Msg->A() == IDM_OPEN_URL)
 			{
 				if (ClickedUri)
 					LExecute(ClickedUri);
 			}
 			else if (auto e = SpellingErrors.AddressOf(ClickErrIdx))
 			{
 				// Replacing text with spell check suggestion:
 				int i = (int)Msg->A() - SPELLING_BASE;
 				if (i >= 0 && i < (int)e->Suggestions.Length())
 				{
 					auto Start = e->Start;
 					LString s = e->Suggestions[i];
 					AutoTrans t(new LRichTextPriv::Transaction);
 
 					// Delete the old text...
 					DeleteAt(t, Start, e->Len); // 'e' might disappear here
 
 					// Insert the new text....
 					LAutoPtr<uint32_t, true> u((uint32_t*)LNewConvertCp("utf-32", s, "utf-8"));
 					AddText(t, Start, u.Get(), Strlen(u.Get()));
 
 					d->AddTrans(t);
 					return true;
 				}
 			}
 			break;
 		}
 	}
 
 	return false;
 }
 
 bool LRichTextPriv::TextBlock::IsEmptyLine(BlockCursor *Cursor)
 {
 	if (!Cursor)
 		return false;
 
 	TextLine *Line = Layout.AddressOf(Cursor->LineHint) ? Layout[Cursor->LineHint] : NULL;
 	if (!Line)
 		return false;
 
 	auto LineLen = Line->Length();
 	return LineLen == 0;
 }
 
 LRichTextPriv::Block *LRichTextPriv::TextBlock::Clone()
 {
 	return new TextBlock(this);
 }
 
 ssize_t LRichTextPriv::TextBlock::CopyAt(ssize_t Offset, ssize_t Chars, LArray<uint32_t> *Text)
 {
 	if (!Text)
 		return 0;
 	if (Chars < 0)
 		Chars = Length() - Offset;
 
 	ssize_t Pos = 0;
 	for (size_t i=0; i<Txt.Length(); i++)
 	{
 		StyleText *t = Txt[i];
 		if (Offset >= Pos && Offset < Pos + (int)t->Length())
 		{
 			ssize_t Skip = Offset - Pos;
 			ssize_t Remain = t->Length() - Skip;
 			ssize_t Cp = MIN(Chars, Remain);
 			Text->Add(&(*t)[Skip], Cp);
 			Chars -= Cp;
 			Offset += Cp;
 		}
 
 		Pos += t->Length();
 	}
 
 	return Text->Length();
 }
 
 ssize_t LRichTextPriv::TextBlock::FindAt(ssize_t StartIdx, const uint32_t *Str, LFindReplaceCommon *Params)
 {
 	if (!Str || !Params)
 		return -1;
 
 	size_t InLen = Strlen(Str);
 	bool Match;
 	ssize_t CharPos = 0;
 	for (size_t i=0; i<Txt.Length(); i++)
 	{
 		StyleText *t = Txt[i];
 		uint32_t *s = &t->First();
 		uint32_t *e = s + t->Length();
 		if (Params->MatchCase)
 		{
 			for (uint32_t *c = s; c < e; c++)
 			{
 				if (*c == *Str)
 				{
 					if (c + InLen <= e)
 						Match = !Strncmp(c, Str, InLen);
 					else
 					{
 						LArray<uint32_t> tmp;
 						if (CopyAt(CharPos + (c - s), InLen, &tmp) &&
 							tmp.Length() == InLen)
 							Match = !Strncmp(&tmp[0], Str, InLen);
 						else
 							Match = false;
 					}
 					if (Match)
 						return CharPos + (c - s);
 				}
 			}
 		}
 		else
 		{
 			uint32_t l = ToLower(*Str);
 			for (uint32_t *c = s; c < e; c++)
 			{
 				if (ToLower(*c) == l)
 				{
 					if (c + InLen <= e)
 						Match = !Strnicmp(c, Str, InLen);
 					else
 					{
 						LArray<uint32_t> tmp;
 						if (CopyAt(CharPos + (c - s), InLen, &tmp) &&
 							tmp.Length() == InLen)
 							Match = !Strnicmp(&tmp[0], Str, InLen);
 						else
 							Match = false;
 					}
 					if (Match)
 						return CharPos + (c - s);
 				}
 			}
 		}
 
 		CharPos += t->Length();
 	}
 
 	return -1;
 }
 
 bool LRichTextPriv::TextBlock::DoCase(Transaction *Trans, ssize_t StartIdx, ssize_t Chars, bool Upper)
 {
 	LRange Blk(0, Len);
 	LRange Inp(StartIdx, Chars < 0 ? Len - StartIdx : Chars);
 	LRange Change = Blk.Overlap(Inp);
 
 	PreEdit(Trans);
 
 	LRange Run(0, 0);
 	bool Changed = false;
 	for (unsigned i=0; i<Txt.Length(); i++)
 	{
 		StyleText *st = Txt[i];
 		Run.Len = st->Length();
 		LRange Edit = Run.Overlap(Change);
 		if (Edit.Len > 0)
 		{
 			uint32_t *s = st->At(Edit.Start - Run.Start);
 			for (int n=0; n<Edit.Len; n++)
 			{
 				if (Upper)
 				{
 					if (s[n] >= 'a' && s[n] <= 'z')
 						s[n] = s[n] - 'a' + 'A';
 				}
 				else
 				{
 					if (s[n] >= 'A' && s[n] <= 'Z')
 						s[n] = s[n] - 'A' + 'a';
 				}
 			}
 			Changed = true;
 		}
 
 		Run.Start += Run.Len;
 	}
 
 	LayoutDirty |= Changed;
 
 	return Changed;
 }
 
 LRichTextPriv::Block *LRichTextPriv::TextBlock::Split(Transaction *Trans, ssize_t AtOffset)
 {
 	if (AtOffset < 0 || 
 		AtOffset >= Len)
 		return NULL;
 
 	LRichTextPriv::TextBlock *After = new LRichTextPriv::TextBlock(d);
 	if (!After)
 	{
 		d->Error(_FL, "Alloc Err");
 		return NULL;
 	}
 
 	After->SetStyle(GetStyle());
 	
 	ssize_t Pos = 0;
 	unsigned i;
 	for (i=0; i<Txt.Length(); i++)
 	{
 		StyleText *St = Txt[i];
 		ssize_t StLen = St->Length();
 		if (AtOffset >= Pos && AtOffset < Pos + StLen)
 		{
 			ssize_t StOff = AtOffset - Pos;
 			if (StOff > 0)
 			{
 				// Split the text into 2 blocks...
 				uint32_t *t = St->At(StOff);
 				ssize_t remaining = St->Length() - StOff;
 				StyleText *AfterText = new StyleText(t, remaining, St->GetStyle());
 				if (!AfterText)
 				{
 					d->Error(_FL, "Alloc Err");
 					return NULL;
 				}
 				St->Length(StOff);
 				i++;
 				Len = Pos + StOff;
 
 				After->Txt.Add(AfterText);
 				After->Len += AfterText->Length();
 			}
 			else
 			{
 				Len = Pos;
 			}
 			break;
 		}
 
 		Pos += StLen;
 	}
 
 	while (i < Txt.Length())
 	{
 		StyleText *St = Txt[i];
 		Txt.DeleteAt(i, true);
 		After->Txt.Add(St);
 		After->Len += St->Length();
 	}
 
 	LayoutDirty = true;
 	After->LayoutDirty = true;
 
 	return After;
 }
 
 void LRichTextPriv::TextBlock::IncAllStyleRefs()
 {
 	if (Style)
 		Style->RefCount++;
 	for (unsigned i=0; i<Txt.Length(); i++)
 	{
 		LNamedStyle *s = Txt[i]->GetStyle();
 		if (s) s->RefCount++;
 	}
 }
 
 bool LRichTextPriv::TextBlock::ChangeStyle(Transaction *Trans, ssize_t Offset, ssize_t Chars, LCss *Style, bool Add)
 {
 	if (!Style)
 		return d->Error(_FL, "No style.");
 
 	if (Offset < 0 || Offset >= Len)
 		return true;
 	if (Chars < 0)
 		Chars = Len;
 
 	if (Trans)
 		Trans->Add(new CompleteTextBlockState(d, this));
 
 	ssize_t CharPos = 0;
 	ssize_t RestyleEnd = Offset + Chars;
 	for (unsigned i=0; i<Txt.Length(); i++)
 	{
 		StyleText *t = Txt[i];
 		ssize_t Len = t->Length();
 		ssize_t End = CharPos + Len;
 
 		if (End <= Offset || CharPos > RestyleEnd)
 			;
 		else
 		{
 			ssize_t Before = Offset >= CharPos ? Offset - CharPos : 0;
 			LAssert(Before >= 0);
 			ssize_t After = RestyleEnd < End ? End - RestyleEnd : 0;
 			LAssert(After >= 0);
 			ssize_t Inside = Len - Before - After;
 			LAssert(Inside >= 0);
 
 
 			LAutoPtr<LCss> TmpStyle(new LCss);
 			if (Add)
 			{
 				if (t->GetStyle())
 					*TmpStyle = *t->GetStyle();
 				*TmpStyle += *Style;
 			}
 			else if (Style->Length() != 0)
 			{
 				if (t->GetStyle())
 					*TmpStyle = *t->GetStyle();
 				*TmpStyle -= *Style;
 			}
 
 			LNamedStyle *CacheStyle = TmpStyle && TmpStyle->Length() ? d->AddStyleToCache(TmpStyle) : NULL;
 
 			if (Before && After)
 			{
 				// Split into 3 parts:
 				// |---before----|###restyled###|---after---|
 				StyleText *st = new StyleText(t->At(Before), Inside, CacheStyle);
 				if (st)
 					Txt.AddAt(++i, st);
 				
 				st = new StyleText(t->At(Before + Inside), After, t->GetStyle());
 				if (st)
 					Txt.AddAt(++i, st);
 				
 				t->Length(Before);
 				LayoutDirty = true;
 				return true;
 			}
 			else if (Before)
 			{
 				// Split into 2 parts:
 				// |---before----|###restyled###|
 				StyleText *st = new StyleText(t->At(Before), Inside, CacheStyle);
 				if (st)
 					Txt.AddAt(++i, st);
 				
 				t->Length(Before);
 				LayoutDirty = true;
 			}
 			else if (After)
 			{
 				// Split into 2 parts:
 				// |###restyled###|---after---|
 				StyleText *st = new StyleText(t->At(0), Inside, CacheStyle);
 				if (st)
 					Txt.AddAt(i, st);
 				
 				memmove(t->At(0), t->At(Inside), After*sizeof(uint32_t));
 				t->Length(After);
 				LayoutDirty = true;
 			}
 			else if (Inside)
 			{
 				// Re-style the whole run
 				t->SetStyle(CacheStyle);
 				LayoutDirty = true;
 			}
 		}
 
 		CharPos += Len;
 	}
 
 	// Merge any regions of the same style into contiguous sections
 	for (unsigned i=0; i<Txt.Length()-1; i++)
 	{
 		StyleText *a = Txt[i];
 		StyleText *b = Txt[i+1];
 		if (a->GetStyle() == b->GetStyle() &&
 			a->Emoji == b->Emoji)
 		{
 			// Merge...
 			a->Add(b->AddressOf(0), b->Length());
 			Txt.DeleteAt(i + 1, true);
 			delete b;
 			i--;
 		}		
 	}
 
 	return true;
 }
 
 bool LRichTextPriv::TextBlock::Seek(SeekType To, BlockCursor &Cur)
 {
 	int XOffset = Cur.Pos.x1 - Pos.x1;
 	ssize_t CharPos = 0;
 	LArray<ssize_t> LineOffset;
 	LArray<ssize_t> LineLen;
 	int CurLine = -1;
 	int CurLineScore = 0;
 	
 	for (unsigned i=0; i<Layout.Length(); i++)
 	{
 		TextLine *Line = Layout[i];
 		PtrCheckBreak(Line);
 		auto Len = Line->Length();				
 				
 		LineOffset[i] = CharPos;
 		LineLen[i] = Len;
 				
 		if (Cur.Offset >= CharPos &&
 			Cur.Offset <= CharPos + Len - Line->NewLine)	// Minus 'NewLine' is because the cursor can't be
 															// after the '\n' on a line. It's actually on the 
 															// next line.
 		{
 			int Score = 1;
 			if (Cur.LineHint >= 0 && i == Cur.LineHint)
 				Score++;
 			if (Score > CurLineScore)
 			{
 				CurLine = i;
 				CurLineScore = Score;
 			}
 		}				
 				
 		CharPos += Len;
 	}
 			
 	if (CurLine < 0)
 	{
 		CharPos = 0;
 		d->Log->Print("TextBlock(%i)::Seek, lines=%i\n", GetUid(), Layout.Length());
 		for (unsigned i=0; i<Layout.Length(); i++)
 		{
 			TextLine *Line = Layout[i];
 			if (Line) { d->Log->Print("\tLine[%i] @ %i+%i=%i\n", i, CharPos, Line->Length(), CharPos + Line->Length()); CharPos += Line->Length(); }
 			else      { d->Log->Print("\tLine[%i] @ %i, is NULL\n", i, CharPos); break; }
 		}
 		return d->Error(_FL, "Index '%i' not in layout lines.", Cur.Offset);
 	}
 				
 	TextLine *Line = NULL;
 	switch (To)
 	{
 		case SkLineStart:
 		{
 			Cur.Offset = LineOffset[CurLine];
 			Cur.LineHint = CurLine;
 			return true;
 		}
 		case SkLineEnd:
 		{
 			Cur.Offset = LineOffset[CurLine] +
 						LineLen[CurLine] -
 						Layout[CurLine]->NewLine;
 			Cur.LineHint = CurLine;
 			return true;
 		}
 		case SkUpLine:
 		{
 			// Get previous line...
 			if (CurLine == 0)
 				return false;
 			Line = Layout[--CurLine];
 			if (!Line)
 				return d->Error(_FL, "No line at %i.", CurLine);
 			break;
 		}				
 		case SkDownLine:
 		{
 			// Get next line...
 			if (CurLine >= (int)Layout.Length() - 1)
 				return false;
 			Line = Layout[++CurLine];
 			if (!Line)
 				return d->Error(_FL, "No line at %i.", CurLine);
 			break;
 		}
 		default:
 		{
 			return false;
 			break;
 		}
 	}
 			
 	if (Line)
 	{
 		// Work out where the cursor should be based on the 'XOffset'
 		if (Line->Strs.Length() > 0)
 		{
 			int FixX = 0;
 			ssize_t CharOffset = 0;
 			for (unsigned i=0; i<Line->Strs.Length(); i++)
 			{
 				DisplayStr *Ds = Line->Strs[i];
 				PtrCheckBreak(Ds);
 						
 				if (XOffset >= FixedToInt(FixX) &&
 					XOffset <= FixedToInt(FixX + Ds->FX()))
 				{
 					// This is the matching string...
 					int Px = XOffset - FixedToInt(FixX) - Line->PosOff.x1;
 					ssize_t Char = Ds->PosToIndex(Px, true);
 					if (Char >= 0)
 					{
 						Cur.Offset = LineOffset[CurLine] +	// Character offset of line
 									CharOffset +			// Character offset of current string
 									Char;					// Offset into current string for 'XOffset'
 						Cur.LineHint = CurLine;
 						return true;
 					}
 				}
 						
 				FixX += Ds->FX();
 				CharOffset += Ds->Length();
 			}
 					
 			// Cursor is nearest the end of the string...?
 			Cur.Offset = LineOffset[CurLine] + Line->Length() - Line->NewLine;
 			Cur.LineHint = CurLine;
 			return true;
 		}
 		else if (Line->NewLine)
 		{
 			Cur.Offset = LineOffset[CurLine];
 			Cur.LineHint = CurLine;
 			return true;
 		}
 	}
 			
 	return false;
 }
 	
 #ifdef _DEBUG
 void LRichTextPriv::TextBlock::DumpNodes(LTreeItem *Ti)
 {
 	LString s;
 	s.Printf("TextBlock, style=%s, pos=%s, ptr=%p", Style?Style->Name.Get():NULL, Pos.GetStr(), this);
 	Ti->SetText(s);
 
 	LTreeItem *TxtRoot = PrintNode(Ti, "Txt(%i)", Txt.Length());
 	if (TxtRoot)
 	{
 		ssize_t Pos = 0;
 		for (size_t i=0; i<Txt.Length(); i++)
 		{
 			StyleText *St = Txt[i];
 			ssize_t Len = St->Length();
 			LString u;
 			if (Len)
 			{
 				LStringPipe p(256);
 				uint32_t *Str = St->At(0);
 				p.Write("\'", 1);
 				for (int k=0; k<MIN(Len, 30); k++)
 				{
 					if (Str[k] == '\n')
 						p.Write("\\n", 2);
 					else if (Str[k] >= 0x10000)
 						p.Print("&#%i;", Str[k]);
 					else
 					{
 						uint8_t utf8[6], *n = utf8;
 						ssize_t utf8len = sizeof(utf8);
 						if (LgiUtf32To8(Str[k], n, utf8len))
 							p.Write(utf8, sizeof(utf8)-utf8len);
 					}
 				}
 				p.Write("\'", 1);
 				u = p.NewLStr();
 			}
 			else u = "(Empty)";
 
 			PrintNode(	TxtRoot, "[%i] range=%i-%i, len=%i, style=%s, %s",
 						i,
 						Pos, Pos + Len - 1,
 						Len,
 						St->GetStyle() ? St->GetStyle()->Name.Get() : NULL,
 						u.Get());
 			Pos += Len;
 		}
 	}
 
 	LTreeItem *LayoutRoot = PrintNode(Ti, "Layout(%i)", Layout.Length());
 	if (LayoutRoot)
 	{
 		ssize_t Pos = 0;
 		for (size_t i=0; i<Layout.Length(); i++)
 		{
 			TextLine *Tl = Layout[i];
 			LTreeItem *Elem = PrintNode(LayoutRoot,
 										"[%i] chars=%i-%i, len=%i + %i, pos=%s",
 										i,
 										Pos, Pos + Tl->Length() - 1,
 										Tl->Length(),
 										Tl->NewLine,
 										Tl->PosOff.GetStr());
 			for (unsigned n=0; n<Tl->Strs.Length(); n++)
 			{
 				DisplayStr *Ds = Tl->Strs[n];
 				LNamedStyle *Style = Ds->Src ? Ds->Src->GetStyle() : NULL;
 				PrintNode(	Elem, "[%i] style=%s len=%i txt='%.20S'",
 							n,
 							Style ? Style->Name.Get() : NULL,
 							Ds->Length(),
 							(const char16*) (*Ds));
 			}
 			
 			Pos += Tl->Length() + Tl->NewLine;
 		}
 	}
 }
 #endif