diff --git a/include/lgi/common/List.h b/include/lgi/common/List.h
--- a/include/lgi/common/List.h
+++ b/include/lgi/common/List.h
@@ -1,516 +1,516 @@
 /// \file
 /// \author Matthew Allen (fret@memecode.com)
 /// \brief A list control
 
 #ifndef __LList_H
 #define __LList_H
 
 // Includes
 #include "lgi/common/Mem.h"
 #include "lgi/common/Array.h"
 #include "lgi/common/Popup.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/Css.h"
 #include "lgi/common/ItemContainer.h"
 #include "lgi/common/UnrolledList.h"
 
 class LList;
 class LListItem;
 
 // Messages
 #define WM_END_EDIT_LABEL			(WM_USER+0x556)
 
 //////////////////////////////////////////////////////////////////////////////
 
 /// View modes for the list control
 enum LListMode
 {
 	LListDetails,
 	LListColumns,
 	LListSpacial,
 };
 
 #if 1
 typedef LUnrolledList<LListItem*> LListT;
 #else
 typedef List<LListItem> LListT;
 #endif
 
 class LgiClass LListItemPainter
 {
 public:
 	// Overridable
 	virtual void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c) = 0;
 };
 
 class LgiClass LListItemColumn : public LBase, public LItem, public LListItemPainter
 {
 	LListItem *_Item;
 	int _Column;
 	int64 _Value;
 
 	void OnPaint(ItemPaintCtx &Ctx) {}
 
 protected:
 	LListT *GetAllItems();
 	LListItemColumn *GetItemCol(LListItem *i, int Col);
 
 public:
 	LListItemColumn(LListItem *item, int col);
 
 	// Other objects
 	LListItem *GetItem() { return _Item; }
 	LList *GetList();
 	LItemContainer *GetContainer();
 
 	// Props
 	int GetColumn() { return _Column; }
 	void SetColumn(int i) { _Column = i; }
 	virtual int64 Value() { return _Value; }
 	virtual void Value(int64 i);
 };
 
 /// LItem for populating a LList
 class LgiClass LListItem : public LItem, public LListItemPainter
 {
 	friend class LList;
 	friend class LListItemColumn;
 	friend class LItemColumn;
 
 protected:
 	// Data
-	class LListItemPrivate *d;
+	class LListItemPrivate *d = NULL;
 	LRect Pos;
-	LList *Parent;
+	LList *Parent = NULL;
 
 	// Methods
 	bool GridLines();
 	LDisplayString *GetDs(int Col, int FitTo = -1);
 	void ClearDs(int Col);
 
 public:
 	// Application defined, defaults to 0
 	union {
 		void *_UserPtr;
 		NativeInt _UserInt;
 	};
 
 	// Object
-	LListItem();
+	LListItem(const char *initStr = NULL);
 	virtual ~LListItem();
 
 	LItemContainer *GetContainer() override;
 	/// Get the owning list
 	LList *GetList() { return Parent; }
 	/// Gets the LListItemColumn's.
 	List<LListItemColumn> *GetItemCols();
 
 	// Properties
 	
 	/// Set the text for a given column
 	bool SetText(const char *s, int i=0) override;
 
 	/// \brief Get the text for a given column.
 	///
 	/// Override this in your LListItem based class to
 	/// return the text for a column. Otherwise call SetText to store the text in the
 	/// control.
 	/// 
 	/// \returns A string
 	const char *GetText
 	(
 		/// The index of the column.
 		int i = 0
 	)	override;
 
 	/// Get the icon index to display in the '0th' column. The image list is stored in
 	/// the parent LList.
 	int GetImage(int Flags = 0) override;
 	/// Sets the icon index
 	void SetImage(int i) override;
 	/// Returns true if selected
 	bool Select() override;
 	/// Changes the selection start of the control.
 	void Select(bool b) override;
 	/// Gets the on screen position of the field at column 'col'
 	LRect *GetPos(int Col = -1) override;
 	/// True if the item is visible
 	bool OnScreen() { return Pos.y1 < Pos.y2; }
 
 	// Methods
 	
 	/// Update the text cache and display the updated data
 	void Update() override;
 	/// Moves the item on screen if not visible
 	void ScrollTo() override;
 	
 	// Events;
 	void OnMouseClick(LMouse &m) override;
 	void OnMeasure(LPoint *Info) override;
 	void OnPaint(LSurface *pDC) override { LAssert(0); }
 	void OnPaint(LItem::ItemPaintCtx &Ctx) override;
 	void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c) override;
 
 	// Over-ridable
 	virtual int Compare(LListItem *To, ssize_t Field = 0) { return 0; }
 	virtual void OnColumnNotify(int Col, int64 Data) { Update(); }
 };
 
 // typedef int (*LListCompareFunc)(LListItem *a, LListItem *b, NativeInt Data);
 
 class LListItems
 {
 protected:
 	LListT Items;
 
 public:
 	template<class T>
 	bool GetSelection(List<T> &n)
 	{
 		n.Empty();
 		for (auto i : Items)
 		{
 			if (i->Select())
 			{
 				T *ptr = dynamic_cast<T*>(i);
 				if (ptr)
 					n.Insert(ptr);
 			}
 		}
 		return n.Length() > 0;
 	}
 
 	template<class T>
 	bool GetSelection(LArray<T*> &n)
 	{
 		n.Empty();
 		for (auto i : Items)
 		{
 			if (i->Select())
 			{
 				T *ptr = dynamic_cast<T*>(i);
 				if (ptr)
 					n.Add(ptr);
 			}
 		}
 		return n.Length() > 0;
 	}
 
 	template<class T>
 	bool GetAll(List<T> &n)
 	{
 		n.Empty();
 		for (auto i : Items)
 		{
 			T *ptr = dynamic_cast<T*>(i);
 			if (ptr)
 				n.Insert(ptr);
 		}
 		return n.Length() > 0;
 	}
 
 	template<class T>
 	bool GetAll(LArray<T*> &n)
 	{
 		n.Empty();
 		for (auto i : Items)
 		{
 			T *ptr = dynamic_cast<T*>(i);
 			if (ptr)
 				n.Add(ptr);
 		}
 		return n.Length() == Items.Length();
 	}
 
 	LListT::I begin()
 	{
 		return Items.begin();
 	}
 
 	LListT::I end()
 	{
 		return Items.end();
 	}
 
 	/*
 	template<typename T>
 	bool Iterate(T *&Ptr)
 	{
 		if (Ptr)
 			// Next
 			Ptr = dynamic_cast<T*>(Items.Next());
 		else
 			// First
 			Ptr = dynamic_cast<T*>(Items.First());
 
 		return Ptr != NULL;
 	}
 	*/
 };
 
 /// List widget
 class LgiClass LList :
 	public LItemContainer,
 	public ResObject,
 	public LListItems
 {
 	friend class LListItem;
 	friend class LItemColumn;
 	friend class LListItemColumn;
 
 	#ifdef WIN32
 	HCURSOR Cursor;
 	#endif
 	
 protected:
 	class LListPrivate *d;
 
 	// Contents
 	int Keyboard; // index of the item with keyboard focus
 
 	// Flags
 	bool EditLabels;
 	bool GridLines;
 
 	// Double buffered
 	LSurface *Buf;
 
 	// Drawing locations
 	LRect ItemsPos;
 	LRect ScrollX, ScrollY;
 	int FirstVisible;
 	int LastVisible;
 	int CompletelyVisible;
 
 	// Misc
 	bool GetUpdateRegion(LListItem *i, LRegion &r);
 	LListItem *HitItem(int x, int y, int *Index = 0);
 	LRect &GetClientRect();
 	void PourAll();
 	void UpdateScrollBars();
 	void KeyScroll(int iTo, int iFrom, bool SelectItems);
 	void ClearDs(int Col);
 
 public:
 	/// Constructor
 	LList
 	(
 		/// The control's ID
 		int id,
 		/// Left edge position
 		int x = 0,
 		/// Top edge position
 		int y = 0,
 		/// The width
 		int cx = 100,
 		/// The height
 		int cy = 100,
 		/// An unseen descriptor of the control
 		const char *name = NULL
 	);
 	~LList();
 
 	const char *GetClass() { return "LList"; }
 
 	// Overridables
 	
 	/// Called when an item is clicked
 	virtual void OnItemClick
 	(
 		/// The item clicked
 		LListItem *Item,
 		/// The mouse parameters for the click
 		LMouse &m
 	);
 	/// Called when the user selects an item and starts to drag it
 	virtual void OnItemBeginDrag
 	(
 		/// The item being dragged
 		LListItem *Item,
 		/// The mouse parameters at the time
 		LMouse &m
 	);
 	/// Called when the user selects an item. If multiple items are selected
 	/// in one hit this is only called for the first item. Use GetSelection to
 	/// get the extent of the selected items.
 	virtual void OnItemSelect
 	(
 		/// The item selected
 		LArray<LListItem*> &Items
 	);
 	/// Called when a column is dragged somewhere
 	virtual void OnColumnDrag
 	(
 		/// The column index
 		int Col,
 		/// The mouse parameters at the time
 		LMouse &m
 	) {}
 	/// Called when the column is dropped to a new location
 	/// /return true to have the columns reindexed for you
 	virtual bool OnColumnReindex
 	(
 		/// The column dropped
 		LItemColumn *Col,
 		/// The old index
 		int OldIndex,
 		/// The new index
 		int NewIndex
 	)
 	{
 		return false;
 	}
 	
 	// Events
 	
 	void OnPaint(LSurface *pDC);
 	LMessage::Result OnEvent(LMessage *Msg);
 	// int OnHitTest(int x, int y);
 	LCursor GetCursor(int x, int y);
 	void OnMouseClick(LMouse &m);
 	void OnMouseMove(LMouse &m);
 	int OnNotify(LViewI *Ctrl, LNotification n);
 	void OnPosChange();
 	bool OnKey(LKey &k);
 	bool OnMouseWheel(double Lines);
 	void OnFocus(bool b);
 	void OnPulse();
 
 	// Properties
 	
 	/// Returns whether the user can edit labels
 	bool AllowEditLabels() { return EditLabels; }
 	/// Sets whether the user can edit labels
 	void AllowEditLabels(bool b) { EditLabels = b; }
 	/// Returns whether grid lines are drawn
 	bool DrawGridLines() { return GridLines; }
 	/// Sets whether grid lines are drawn
 	void DrawGridLines(bool b) { GridLines = b; }
 
 	// Methods
 	
 	/// Get the display mode.
 	/// \sa LListMode
 	LListMode GetMode();
 	/// Set the display mode.
 	/// \sa LListMode
 	void SetMode(LListMode m);	
 
 	/// Returns the index of the first selected item
 	int64 Value();
 	/// Selects the item at index 'i'
 	void Value(int64 i);
 	/// Selects 'obj'
 	bool Select(LListItem *Obj);
 	/// Gets the first selected object
 	LListItem *GetSelected();
 	/// Select all the item in the list
 	void SelectAll();
 	/// Scrolls the view to the first selected item if not in view
 	void ScrollToSelection();
 	/// Clears the text cache for all the items and repaints the screen.
 	void UpdateAllItems();
 	/// Gets the number of items.
 	size_t Length() { return Items.Length(); }
 
 	/// Returns true if the list is empty
 	bool IsEmpty() { return Items.Length() == 0; }
 	/// Deletes the item at index 'Index'
 	bool Delete(ssize_t Index);
 	/// Deletes the item 'p'
 	virtual bool Delete(LListItem *p);
 	/// Remove the item 'Obj' but don't delete it
 	virtual bool Remove(LListItem *Obj);
 	/// Inserts the item 'p' at index 'Index'.
 	bool Insert
 	(
 		/// The item to insert
 		LListItem *p,
 		/// The index to insert at or -1 for append
 		int Index = -1,
 		/// True if you want the list to update immediately. If you are inserting a lot of items quickly
 		/// then you should pass false here and then update just once at the end of the insertions.
 		bool Update = true
 	);
 	/// Insert a list of item
 	virtual bool Insert
 	(
 		/// The items to insert
 		List<LListItem> &l,
 		/// The starting index to insert at
 		int Index = -1,
 		/// True if you want the list to update immediately. If you are inserting a lot of item list quickly
 		/// then you should pass false here and then update just once at the end of the insertions.
 		bool Update = true
 	);
 	/// Return true if the item 'Obj' is in the list
 	bool HasItem(LListItem *Obj);
 	/// Return the index of the item 'Obj' or -1 if not present
 	int IndexOf(LListItem *Obj);
 	/// Returns the item at index 'Index'
 	LListItem *ItemAt(size_t Index);
 
 	/*
 	/// Sort the list
 	void Sort
 	(
 		/// The comparison function. Should return a integer greater then > 0 if the first item item is greater in value.
 		LListCompareFunc Compare,
 		/// User defined 32-bit value passed through to the 'Compare' function
 		NativeInt Data = 0
 	);
 	*/
 
 	/// Sort the list
 	template<typename User>
 	void Sort
 	(
 		/// The comparison function. Should return a integer greater then > 0 if the first item item is greater in value.
 		int (*Compare)(LListItem *a, LListItem *b, User data),
 		/// User defined value passed through to the 'Compare' function
 		User Data = 0
 	)
 	{
 		if (!Compare || !Lock(_FL))
 			return;
 
 		LListItem *Kb = Keyboard >= 0 && Keyboard < (int)Items.Length() ? Items[Keyboard] : NULL;
 		Items.Sort(Compare, Data);
 		Keyboard = Kb ? (int)Items.IndexOf(Kb) : -1;
 		Unlock();
 		Invalidate(&ItemsPos);
 	}
 
 	void Sort(int Column)
 	{
 		if (Items.Length() == 0)
 			return;
 		if (!Lock(_FL))
 			return;
 
 		LListItem *Kb = Items[Keyboard];
 		Items.Sort
 		(
 			[](LListItem *a, LListItem *b, int Column) -> int
 			{
 				const char *ATxt = a->GetText(Column);
 				const char *BTxt = b->GetText(Column);
 				return (ATxt && BTxt) ? stricmp(ATxt, BTxt) : 0;
 			},
 			Column
 		);
 		Keyboard = Kb ? (int)Items.IndexOf(Kb) : -1;
 		Unlock();
 		Invalidate(&ItemsPos);
 	}
 
 	/// Removes all items from list and delete the objects.
 	virtual void Empty();
 	/// Removes all references to externally owned items. Doesn't delete objects.
 	virtual void RemoveAll();
 
 	// Impl
 	int GetContentSize(int ColumnIdx);
 };
 
 #endif
diff --git a/include/lgi/common/Tree.h b/include/lgi/common/Tree.h
--- a/include/lgi/common/Tree.h
+++ b/include/lgi/common/Tree.h
@@ -1,305 +1,305 @@
 /// \file
 /// \author Matthew Allen (fret@memecode.com)
 /// \brief A tree/heirarchy control
 
 #ifndef __GTREE2_H
 #define __GTREE2_H
 
 #include "lgi/common/ItemContainer.h"
 #include <functional>
 
 enum LTreeItemRect
 {
 	TreeItemPos,
 	TreeItemThumb,
 	TreeItemText,
 	TreeItemIcon
 };
 
 class LTreeItem;
 
 class LgiClass LTreeNode
 {
 protected:
 	class LTree *Tree;
 	LTreeItem *Parent;
 	List<LTreeItem> Items;
 
 	virtual LTreeItem *Item() { return 0; }
 	virtual LRect *Pos() { return 0; }
 	virtual void _ClearDs(int Col);
 	void _Visible(bool v);
 	void SetLayoutDirty();
 
 public:
 	LTreeNode();
 	virtual ~LTreeNode();
 
 	/// Inserts a tree item as a child at 'Pos'
 	LTreeItem *Insert(LTreeItem *Obj = NULL, ssize_t Pos = -1);
 	/// Removes this node from it's parent, for permanent separation.
 	void Remove();
 	/// Detachs the item from the tree so it can be re-inserted else where.
 	void Detach();
 	/// Gets the node after this one at the same level.
 	LTreeItem *GetNext();
 	/// Gets the node before this one at the same level.
 	LTreeItem *GetPrev();
 	/// Gets the first child node.
 	LTreeItem *GetChild();
 	/// Gets the parent of this node.
 	LTreeItem *GetParent() { return Parent; }
 	/// Gets the owning tree. May be NULL if not attached to a tree.
 	LTree *GetTree() { return Tree; }
 	/// Returns true if this is the root node.
 	bool IsRoot();
 	/// Returns the index of this node in the list of item owned by it's parent.
 	ssize_t IndexOf();
 	/// \returns number of child.
 	size_t Length();
 	/// \returns if the object is in the tree
 	bool HasItem(LTreeItem *obj, bool recurse = true);
 
 	List<LTreeItem>::I begin()
 	{
 		return Items.begin();
 	}
 	
 	List<LTreeItem>::I end()
 	{
 		return Items.end();
 	}
 
 	/// Sorts the child items
 	template<typename T>
 	bool Sort(int (*Compare)(LTreeItem*, LTreeItem*, T user_param), T user_param = 0)
 	{
 		if (!Compare)
 			return false;
 		
 		Items.Sort(Compare, user_param);
 		SetLayoutDirty();
 		return true;
 	}
 
 	/// Calls a f(n) for each
 	int ForEach(std::function<void(LTreeItem*)> Fn);
 
 	virtual bool Expanded() { return false; }
 	virtual void Expanded(bool b) {}
 	virtual void OnVisible(bool v) {}
 };
 
 /// The item class for a tree. This defines a node in the heirarchy.
 class LgiClass LTreeItem : public LItem, public LTreeNode
 {
 	friend class LTree;
 	friend class LTreeNode;
 
 protected:
 	class LTreeItemPrivate *d;
 
 	// Private methods
 	void _RePour();
 	void _Pour(LPoint *Limit, int ColumnPx, int Depth, bool Visible);
 	void _Remove();
 	void _MouseClick(LMouse &m);
 	void _SetTreePtr(LTree *t);
 	LTreeItem *_HitTest(int x, int y, bool Debug = false);
 	LRect *_GetRect(LTreeItemRect Which);
 	LPoint _ScrollPos();
 	LTreeItem *Item() override { return this; }
 	LRect *Pos() override;
 
 	virtual void _PourText(LPoint &Size);
 	virtual void _PaintText(LItem::ItemPaintCtx &Ctx);
 	void _ClearDs(int Col) override;
 	virtual void OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c);
 	int GetColumnSize(int Col);
 
 protected:
 	LString::Array Str;
 	int Sys_Image = -1;
 
 public:
-	LTreeItem();
+	LTreeItem(const char *initStr = NULL);
 	virtual ~LTreeItem();
 
 	LItemContainer *GetContainer() override;
 	
 	/// \brief Get the text for the node
 	///
 	/// You can either return a string stored internally to your
 	/// object by implementing this function in your item class 
 	/// or use the SetText function to store the string in this 
 	/// class.
 	const char *GetText(int i = 0) override;
 	/// \brief Sets the text for the node.
 	///
 	/// This will allocate and store the string in this class.
 	bool SetText(const char *s, int i=0) override;
 	/// Returns the icon index into the parent tree's LImageList.
 	int GetImage(int Flags = 0) override;
 	/// Sets the icon index into the parent tree's LImageList.
 	void SetImage(int i) override;
 	/// Tells the item to update itself on the screen when the
 	/// LTreeItem::GetText data has changed.
 	void Update() override;
 	/// Returns true if the tree item is currently selected.
 	bool Select() override;
 	/// Selects or deselects the tree item.
 	void Select(bool b) override;
 	/// Returns true if the node has children and is open.
 	bool Expanded() override;
 	/// Opens or closes the node to show or hide the children.
 	void Expanded(bool b) override;
 	/// Scrolls the tree view so this node is visible.
 	void ScrollTo() override;
 	/// Gets the bounding box of the item.
 	LRect *GetPos(int Col = -1) override;
 	/// True if the node is the drop target
 	bool IsDropTarget();
 
 	/// Called when the node expands/contracts to show or hide it's children.
 	virtual void OnExpand(bool b);
 
 	/// Paints the item
 	void OnPaint(ItemPaintCtx &Ctx) override;
 	void OnPaint(LSurface *pDC) override { LAssert(0); }
 };
 
 /// A tree control.
 class LgiClass LTree :
 	public LItemContainer,
 	public ResObject,
 	public LTreeNode
 {
 	friend class LTreeItem;
 	friend class LTreeNode;
 
 	class LTreePrivate *d;
 
 	// Private methods
 	void _Pour();
 	void _OnSelect(LTreeItem *Item);
 	void _Update(LRect *r = 0, bool Now = false);
 	void _UpdateBelow(int y, bool Now = false);
 	void _UpdateScrollBars();
 	List<LTreeItem>	*GetSelLst();
 
 protected:
 	// Options
 	bool Lines;
 	bool Buttons;
 	bool LinesAtRoot;
 	bool EditLabels;
 	
 	LRect rItems;
 	
 	LPoint _ScrollPos();
 	LTreeItem *GetAdjacent(LTreeItem *From, bool Down);
 	void OnDragEnter();
 	void OnDragExit();
 	void ClearDs(int Col) override;
 	
 public:
 	LTree(int id, int x = 0, int y = 0, int cx = 100, int cy = 100, const char *name = NULL);
 	~LTree();
 
 	const char *GetClass() override { return "LTree"; }
 
 	/// Called when an item is clicked
 	virtual void OnItemClick(LTreeItem *Item, LMouse &m);
 	/// Called when an item is dragged from it's position
 	virtual void OnItemBeginDrag(LTreeItem *Item, LMouse &m);
 	/// Called when an item is expanded/contracted to show or hide it's children
 	virtual void OnItemExpand(LTreeItem *Item, bool Expand);
 	/// Called when an item is selected
 	virtual void OnItemSelect(LTreeItem *Item);
 	
 	// Implementation
 	void OnMouseClick(LMouse &m) override;
 	void OnMouseMove(LMouse &m) override;
 	bool OnMouseWheel(double Lines) override;
 	void OnPaint(LSurface *pDC) override;
 	void OnFocus(bool b) override;
 	void OnPosChange() override;
 	bool OnKey(LKey &k) override;
 	int OnNotify(LViewI *Ctrl, LNotification n) override;
 	LMessage::Result OnEvent(LMessage *Msg) override;
 	void OnPulse() override;
 	int GetContentSize(int ColumnIdx) override;
 	LCursor GetCursor(int x, int y) override;
 
 	/// Add a item to the tree
 	LTreeItem *Insert(LTreeItem *Obj = 0, ssize_t Pos = -1);
 	/// Remove and delete an item
 	bool Delete(LTreeItem *Obj);
 	/// Remove but don't delete an item
 	bool Remove(LTreeItem *Obj);
 	/// Gets the item at an index
 	LTreeItem *ItemAt(size_t Pos) { return Items[Pos]; }
 	/// \returns if the object is in the tree
 	bool HasItem(LTreeItem *obj, bool recurse = true);
 
 	/// Select the item 'Obj'
 	bool Select(LTreeItem *Obj);
 	/// Returns the first selected item
 	LTreeItem *Selection();
 
 	/// Gets the whole selection and puts it in 'n'
 	template<class T>
 	bool GetSelection(LArray<T*> &n)
 	{
 		n.Empty();
 		auto s = GetSelLst();
 		for (auto i : *s)
 		{
 			T *ptr = dynamic_cast<T*>(i);
 			if (ptr)
 				n.Add(ptr);
 		}
 		return n.Length() > 0;
 	}
 	
 	/// Gets an array of all items
 	template<class T>
 	bool GetAll(LArray<T*> &n)
 	{
 		n.Empty();
 		return ForAllItems([&n](LTreeItem *item)
 			{
 				T *t = dynamic_cast<T*>(item);
 				if (t)
 					n.Add(t);
 			});
 	}
 	
 	/// Call a function for every item
 	bool ForAllItems(std::function<void(LTreeItem*)> Callback);
 
 	/// Returns the item at an x,y location
 	LTreeItem *ItemAtPoint(int x, int y, bool Debug = false);
 	/// Temporarily selects one of the items as the drop target during a
 	/// drag and drop operation. Call SelectDropTarget(0) when done.
 	void SelectDropTarget(LTreeItem *Item);
 
 	/// Delete all items (frees the items)
 	void Empty();
 	/// Remove reference to items (doesn't free the items)
 	void RemoveAll();
 	/// Call 'Update' on all tree items
 	void UpdateAllItems() override;
 	
 	// Visual style
 	enum ThumbStyle
 	{
 		TreePlus,
 		TreeTriangle
 	};
 
 	void SetVisualStyle(ThumbStyle Btns, bool JoiningLines);
 };
 
 #endif
 
diff --git a/src/common/Net/Mail.cpp b/src/common/Net/Mail.cpp
--- a/src/common/Net/Mail.cpp
+++ b/src/common/Net/Mail.cpp
@@ -1,2709 +1,2709 @@
 /*hdr
 **      FILE:           Mail.cpp
 **      AUTHOR:         Matthew Allen
 **      DATE:           28/5/98
 **      DESCRIPTION:    Mail app
 **
 **      Copyright (C) 1998, Matthew Allen
 **              fret@memecode.com
 */
 
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <time.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Mail.h"
 #include "lgi/common/Base64.h"
 #include "lgi/common/NetTools.h"
 #include "lgi/common/DateTime.h"
 #include "lgi/common/DocView.h"
 #include "lgi/common/Store3Defs.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/TextConvert.h"
 #include "lgi/common/Mime.h"
 #include "../Hash/md5/md5.h"
 
 const char *sTextPlain = "text/plain";
 const char *sTextHtml = "text/html";
 const char *sTextXml = "text/xml";
 const char *sApplicationInternetExplorer = "application/internet-explorer";
 const char sMultipartMixed[] = "multipart/mixed";
 const char sMultipartEncrypted[] = "multipart/encrypted";
 const char sMultipartSigned[] = "multipart/signed";
 const char sMultipartAlternative[] = "multipart/alternative";
 const char sMultipartRelated[] = "multipart/related";
 const char sAppOctetStream[] = "application/octet-stream";
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 LogEntry::LogEntry(LColour col)
 {
 	c = col;
 }
 
 bool LogEntry::Add(const char *t, ssize_t len)
 {
 	if (!t)
 		return false;
 
 	if (len < 0)
 		len = strlen(t);
 
 	/*
 	// Strip off any whitespace on the end of the line.
 	while (len > 0 && strchr(" \t\r\n", t[len-1]))
 		len--;
 	*/
 
 	LAutoWString w(Utf8ToWide(t, len));
 	if (!w)
 		return false;
 
 	size_t ch = StrlenW(w);
 	return Txt.Add(w, ch);	
 }
 	
 bool Base64Str(LString &s)
 {
 	LString b64;
 	ssize_t Base64Len = BufferLen_BinTo64(s.Length());
 	if (!b64.Set(NULL, Base64Len))
 		return false;
 	
 	#ifdef _DEBUG
 	ssize_t Ch =
 	#endif
 	ConvertBinaryToBase64(b64.Get(), b64.Length(), (uchar*)s.Get(), s.Length());
 	LAssert(Ch == b64.Length());
 	s = b64;
 	return true;
 }
 
 bool UnBase64Str(LString &s)
 {
 	LString Bin;
 	ssize_t BinLen = BufferLen_64ToBin(s.Length());
 	if (!Bin.Set(NULL, BinLen))
 		return false;
 	
 	ssize_t Ch = ConvertBase64ToBinary((uchar*)Bin.Get(), Bin.Length(), s.Get(), s.Length());
 	LAssert(Ch <= (int)Bin.Length());
 	s = Bin;
 	s.Get()[Ch] = 0;
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 // returns the maximum length of the lines contained in the string
 int MaxLineLen(char *Text)
 {
 	if (!Text)
 		return false;
 
 	int Max = 0;
 	int i = 0;
 	for (char *c = Text; *c; c++)
 	{
 		if (*c == '\r')
 		{
 			// return
 		}
 		else if (*c == '\n')
 		{
 			// eol
 			Max = MAX(i, Max);
 			i = 0;
 		}
 		else
 		{
 			// normal char
 			i++;
 		}
 	}
 
 	return Max;
 }
 
 bool IsDotLined(char *Text)
 {
 	if (Text)
 	{
 		for (char *l = Text; l && *l; )
 		{
 			if (l[0] == '.')
 			{
 				if (l[1] == '\n' || l[1] == 0)
 				{
 					return true;
 				}
 			}
 
 			l = strchr(l, '\n');
 			if (l) l++;
 		}
 	}
 
 	return false;
 }
 
 // Is s a valid non-whitespace string?
 bool ValidNonWSStr(const char *s)
 {
 	if (s && *s)
 	{
 		while (*s && strchr(" \r\t\n", *s))
 		{
 			s++;
 		}
 
 		if (*s)
 		{
 			return true;
 		}
 	}
 
 	return false;
 }
 
 void TokeniseStrList(char *Str, List<char> &Output, const char *Delim)
 {
 	if (Str && Delim)
 	{
 		char *s = Str;
 		while (*s)
 		{
 		    while (*s && strchr(WhiteSpace, *s))
 		        s++;
 
 			char *e = s;
 			for (; *e; e++)
 			{
 				if (strchr("\'\"", *e))
 				{
 					// handle string constant
 					char delim = *e++;
 					e = strchr(e, delim);
 				}
 				else if (*e == '<')
 				{
 					e = strchr(e, '>');
 				}
 				else
 				{
 					while (*e && *e != '<' && !IsWhiteSpace(*e) && !strchr(Delim, *e))
 						e++;
 				}
 
 				if (!e || !*e || strchr(Delim, *e))
 				{
 					break;
 				}
 			}
 
 			ssize_t Len = e ? e - s : strlen(s);
 			if (Len > 0)
 			{
 				char *Temp = new char[Len+1];
 				if (Temp)
 				{
 					memcpy(Temp, s, Len);
 					Temp[Len] = 0;
 					Output.Insert(Temp);
 				}
 			}
 
 			if (e)
 			{
 				s = e;
 				for (; *s && strchr(Delim, *s); s++);
 			}
 			else break;
 		}
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 void DeNullText(char *in, ssize_t &len)
 {
 	char *out = in;
 	char *end = in + len;
 	while (in < end)
 	{
 		if (*in)
 		{
 			*out++ = *in;
 		}
 		else
 		{
 			len--;
 		}
 		in++;
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 typedef char CharPair[2];
 static CharPair Pairs[] =
 {
     {'<', '>'},
     {'(', ')'},
     {'\'', '\''},
     {'\"', '\"'},
     {0, 0},
 };
 
 struct MailAddrPart
 {
     LAutoString Part;
     bool Brackets;
     bool ValidEmail;
     
 
     LAutoString RemovePairs(char *Str, ssize_t Len, CharPair *Pairs)
     {
 	    char *s = Str;
 	    if (Len < 0)
 	        Len = strlen(s);
 	    while (*s && strchr(WhiteSpace, *s))
 	    {
 	        s++;
 	        Len--;
 	    }
 
 	    if (!*s)
 		    return LAutoString();
 
 	    // Get the end of the string...
 	    char *e = s;
 	    if (Len < 0)
 	        e += strlen(s);
 	    else
 	        e += Len;
 
 	    // Seek back over any trailing whitespace
 	    while (e > s && strchr(WhiteSpace, e[-1]))
 		    e--;
 
 	    for (CharPair *p = Pairs; (*p)[0]; p++)
 	    {
 		    if ((*p)[0] == *s && (*p)[1] == e[-1])
 		    {
 			    s++;
 			    e--;
 			    if (s < e)
 			    {
 				    // reset search
 				    p = Pairs - 1;
 			    }
 			    else break;
 		    }
 	    }
 
 	    Len = e - s;
 	    if (Len < 0)
 		    return LAutoString();
 
 	    return LAutoString(NewStr(s, Len));
     }
 
     MailAddrPart(char *s, ssize_t len)
     {
         ValidEmail = false;
         Brackets = false;
         if (s)
         {
 		    if (len < 0)
 		        len = strlen(s);
 		    while (strchr(WhiteSpace, *s) && len > 0)
 		    {
 			    s++;
 			    len--;
 		    }
             
             Brackets = *s == '<';
             Part = RemovePairs(s, len, Pairs);
             // ValidEmail = IsValidEmail(Part);
         }
     }
     
     int Score()
     {
         if (!Part)
             return 0;
         return (ValidEmail ? 1 : 0) + (Brackets ? 1 : 0);
     }
 };
 
 int PartCmp(LAutoPtr<MailAddrPart> *a, LAutoPtr<MailAddrPart> *b)
 {
     return (*b)->Score() - (*a)->Score();
 }
 
 bool IsAngleBrackets(LString &s)
 {
 	if (s(0) == '<' && s(-1) == '>')
 		return true;
 	return false;
 }
 
 void DecodeAddrName(const char *Str, std::function<void(LString,LString)> Cb, const char *DefaultDomain)
 {
 	if (!Str)
 		return;
 
 	LString s = Str;
 	LString non;
 	LString email;
 	LString::Array a;
 
 	auto startBracket = s.Find("<");
 	auto endBracket = s.Find(">", startBracket);
 	if (startBracket >= 0 && endBracket >= 0)
 	{
 		// Keep the angle brackets for the time being...
 		a.New() = s(0, startBracket) + s(++endBracket, -1);
 		a.New() = s(startBracket, endBracket);
 	}
 	else a.New() = s;
 	
 	for (unsigned i=0; i<a.Length(); i++)
 	{
 		if (LIsValidEmail(a[i]) ||
 			IsAngleBrackets(a[i]))
 		{
 			email = a[i].Strip("<>");
 		}
 		else
 		{
 			non += a[i];
 		}
 	}
 	if (!email)
 	{
 		a = s.SplitDelimit("()");
 		non.Empty();
 		for (unsigned i=0; i<a.Length(); i++)
 		{
 			if (LIsValidEmail(a[i]))
 			{
 				email = a[i];
 			}
 			else
 			{
 				non += a[i];
 			}
 		}	
 		if (!email)
 		{
 			a = s.SplitDelimit(WhiteSpace);
 			non.Empty();
 			for (unsigned i=0; i<a.Length(); i++)
 			{
 				if (LIsValidEmail(a[i]))
 				{
 					email = a[i];
 				}
 				else
 				{
 					if (non.Get())
 						non += " ";
 					non += a[i];
 				}
 			}	
 		}
 	}
 	
 	if (non.Length() > 0)
 	{
 		const char *ChSet = " \t\r\n\'\"<>";
 		do
 		{
 			non = non.Strip(ChSet);
 		}
 		while (non.Length() > 0 && strchr(ChSet, non(0)));
 	}
 	
 	Cb(non, email.Strip());
 }
 
 void DecodeAddrName(const char *Start, LAutoString &Name, LAutoString &Addr, const char *DefaultDomain)
 {
-	DecodeAddrName(Start, [&](LString n, LString a){
+	DecodeAddrName(Start, [&Name, &Addr](LString n, LString a){
 		Name.Reset(NewStr(n));
 		Addr.Reset(NewStr(a));
 	}, DefaultDomain);
 }
 
 void DecodeAddrName(const char *Start, LString &Name, LString &Addr, const char *DefaultDomain)
 {
-	DecodeAddrName(Start, [&](LString n, LString a){
+	DecodeAddrName(Start, [&Name, &Addr](LString n, LString a){
 		Name = n;
 		Addr = a;
 	}, DefaultDomain);
 }
 
 #if 0
 struct LDecodeAddrNameTest
 {
 	LDecodeAddrNameTest()
 	{
 		// Testing code
 		char *Input[] =
 		{
 			"\"Sound&Secure@speedytechnical.com\" <soundandsecure@speedytechnical.com>",
 			"\"@MM-Social Mailman List\" <social@cisra.canon.com.au>",
 			"'Matthew Allen (fret)' <fret@memecode.com>",
 			"Matthew Allen (fret) <fret@memecode.com>",
 			"\"'Matthew Allen'\" <fret@memecode.com>",
 			"Matthew Allen",
 			"fret@memecode.com",
 			"\"<Matthew Allen>\" <fret@memecode.com>",
 			"<Matthew Allen> (fret@memecode.com)",
 			"Matthew Allen <fret@memecode.com>",
 			"\"Matthew, Allen\" (fret@memecode.com)",
 			"Matt'hew Allen <fret@memecode.com>",
 			"john.omalley <john.O'Malley@testing.com>",
 			"Bankers' Association (ABA)<survey@aawp.org.au>",
 			"'Amy's Mum' <name@domain.com>",
 			"\"Philip Doggett (JIRA)\" <jira@audinate.atlassian.net>",
 			"\"group name\" <groupAddress>",
 			NULL
 		};
 
 		LAutoString Name, Addr;
 		for (char **i = Input; *i; i++)
 		{
 			Name.Reset();
 			Addr.Reset();
 			DecodeAddrName(*i, Name, Addr, "name.com");
 			LgiTrace("N=%-#32s A=%-32s\n", Name, Addr);
 		}
 		int asd=0;
 	}
 }	DecodeAddrNameTest;
 #endif
 
 void StrCopyToEOL(char *d, char *s)
 {
 	if (d && s)
 	{
 		while (*s && *s != '\r' && *s != '\n')
 		{
 			*d++ = *s++;
 		}
 
 		*d = 0;
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 MailTransaction::MailTransaction()
 {
 	Index = -1;
 	Flags = 0;
 	Status = false;
 	Oversize = false;
 	Stream = 0;
 	UserData = 0;
 }
 
 MailTransaction::~MailTransaction()
 {
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 FileDescriptor::FileDescriptor()
 {
 	Embeded = 0;
 	Offset = 0;
 	Size = 0;
 	Data = 0;
 	MimeType = 0;
 	ContentId = 0;
 	Lock = 0;
 	OwnEmbeded = false;
 }
 
 FileDescriptor::FileDescriptor(LStreamI *embed, int64 offset, int64 size, char *name)
 {
 	Embeded = embed;
 	Offset = offset;
 	Size = size;
 	Data = 0;
 	MimeType = 0;
 	Lock = 0;
 	ContentId = 0;
 	OwnEmbeded = false;
 
 	if (name)
 	{
 		Name(name);
 	}
 }
 
 FileDescriptor::FileDescriptor(char *name)
 {
 	Embeded = 0;
 	Offset = 0;
 	Size = 0;
 	Data = 0;
 	MimeType = 0;
 	Lock = 0;
 	ContentId = 0;
 	OwnEmbeded = false;
 
 	if (name)
 	{
 		Name(name);
 		if (File.Open(name, O_READ))
 		{
 			Size = File.GetSize();
 			File.Close();
 		}
 	}
 }
 
 FileDescriptor::FileDescriptor(char *data, int64 len)
 {
 	Embeded = 0;
 	Offset = 0;
 	MimeType = 0;
 	Lock = 0;
 	ContentId = 0;
 	Size = len;
 	OwnEmbeded = false;
 
 	Data = data ? new uchar[(size_t)Size] : 0;
 	if (Data)
 	{
 		memcpy(Data, data, (size_t)Size);
 	}
 }
 
 FileDescriptor::~FileDescriptor()
 {
 	if (OwnEmbeded)
 	{
 		DeleteObj(Embeded);
 	}
 
 	DeleteArray(MimeType);
 	DeleteArray(ContentId);
 	DeleteArray(Data);
 }
 
 void FileDescriptor::SetOwnEmbeded(bool i)
 {
 	OwnEmbeded = i;
 }
 
 void FileDescriptor::SetLock(LMutex *l)
 {
 	Lock = l;
 }
 
 LMutex *FileDescriptor::GetLock()
 {
 	return Lock;
 }
 
 LStreamI *FileDescriptor::GotoObject()
 {
 	if (Embeded)
 	{
 		Embeded->SetPos(Offset);
 		return Embeded;
 	}
 	else if (Name() && File.Open(Name(), O_READ))
 	{
 		return &File;
 	}
 	else if (Data && Size > 0)
 	{
 		DataStream.Reset(new LMemStream(Data, Size, false));
 		return DataStream;
 	}
 
 	return 0;
 }
 
 int FileDescriptor::Sizeof()
 {
 	return (int)Size;
 }
 
 uchar *FileDescriptor::GetData()
 {
 	return Data;
 }
 
 bool FileDescriptor::Decode(char *ContentType,
 							char *ContentTransferEncoding,
 							char *MimeData,
 							int MimeDataLen)
 {
 	bool Status = false;
 	int Content = CONTENT_NONE;
 
 	if (ContentType && ContentTransferEncoding)
 	{
 		// Content-Type: application/octet-stream; name="Scribe.opt"
 		Content = CONTENT_OCTET_STREAM;
 
 		if (strnistr(ContentTransferEncoding, "base64", 1000))
 		{
 			Content = CONTENT_BASE64;
 		}
 
 		if (strnistr(ContentTransferEncoding, "quoted-printable", 1000))
 		{
 			Content = CONTENT_QUOTED_PRINTABLE;
 		}
 
 		if (Content != CONTENT_NONE)
 		{
 			const char *NameKey = "name";
 			char *n = strnistr(ContentType, NameKey, 1000);
 			if (n)
 			{
 				char *Equal = strchr(n, '=');
 				if (Equal)
 				{
 					Equal++;
 					while (*Equal && *Equal == '\"')
 					{
 						Equal++;
 					}
 
 					char *End = strchr(Equal, '\"');
 					if (End)
 					{
 						*End = 0;
 					}
 
 					Name(Equal);
 					Status = true;
 				}
 			}
 		}
 	}
 
 	if (Status && MimeData && MimeDataLen > 0 && Content != CONTENT_NONE)
 	{
 		Status = false;
 		char *Base64 = new char[MimeDataLen];
 
 		switch (Content)
 		{
 			case CONTENT_OCTET_STREAM:
 			{
 				Size = 0;
 				DeleteObj(Data);
 				Data = new uchar[MimeDataLen];
 				if (Data)
 				{
 					Size = MimeDataLen;
 					memcpy(Data, MimeData, (size_t)Size);
 					Status = true;
 				}
 				break;
 			}
 			case CONTENT_QUOTED_PRINTABLE:
 			{
 				Size = 0;
 				DeleteObj(Data);
 				Data = new uchar[MimeDataLen+1];
 				if (Data)
 				{
 					char *Out = (char*) Data;
 					for (int i=0; i<MimeDataLen; i++)
 					{
 						if (MimeData[i] == '=')
 						{
 							if (MimeData[i+1] == '\r' || MimeData[i+1] == '\n')
 							{
 								if (MimeData[i+1] == '\r') i++;
 								if (MimeData[i+1] == '\n') i++;
 							}
 							else
 							{
 								i++;
 								char c = ConvHexToBin(MimeData[i]) << 4;
 								i++;
 								c |= ConvHexToBin(MimeData[i]) & 0xF;
 
 								Size++;
 								*Out++ = c;
 							}
 						}
 						else
 						{
 							Size++;
 							*Out++ = MimeData[i];
 						}
 					}
 
 					*Out++ = 0;
 					Status = true;
 				}
 				break;
 			}
 			case CONTENT_BASE64:
 			{
 				int InCount = 0;
 				int OutCount = 0;
 				char *In = MimeData;
 				char *Out = Base64;
 				while (InCount < MimeDataLen)
 				{
 					if (*In != '\r' && *In != '\n')
 					{
 						*Out++ = *In;
 						OutCount++;
 					}
 					InCount++;
 					In++;
 				}
 
 				Size = BufferLen_64ToBin(OutCount);
 				Data = new uchar[(size_t)Size];
 				if (Data)
 				{
 					ssize_t Converted = ConvertBase64ToBinary(Data, Size, Base64, OutCount);
 					Status = Converted <= Size && Converted >= Size - 3;
 					if (Status)
 					{
 						Size = Converted;
 					}
 					else
 					{
 						DeleteArray(Data);
 						Size = 0;
 					}
 				}
 				break;
 			}
 		}
 	}
 	return Status;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 AddressDescriptor::AddressDescriptor(const AddressDescriptor *Copy)
 {
 	if (Copy)
 	{
 		Status = Copy->Status;
 		CC = Copy->CC;
 		sAddr = Copy->sAddr;
 		sName = Copy->sName;
 	}
 }
 
 AddressDescriptor::~AddressDescriptor()
 {
 	_Delete();
 }
 
 void AddressDescriptor::_Delete()
 {
 	Status = false;
 	CC = MAIL_ADDR_CC;
 	sName.Empty();
 	sAddr.Empty();
 }
 
 LString AddressDescriptor::Print()
 {
 	LString s;
 	char delim = '\'';
 	if (sName)
 	{
 		bool hasSingle = sName.Find("\'") >= 0;
 		bool hasDouble = sName.Find("\"") >= 0;
 		if (hasSingle && !hasDouble)
 			delim = '\"';
 	}
 
 	if (sAddr && sName)
 		s.Printf("%c%s%c <%s>", delim, sAddr.Get(), delim, sName.Get());
 	else if (sAddr)
 		s.Printf("<%s>", sAddr.Get());
 	else if (sName)
 		s.Printf("%c%s%c", delim, sName.Get(), delim);
 
 	return s;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 MailProtocol::MailProtocol() :
 	SocketLock("MailProtocol")
 {
 	Buffer[0] = 0;
 	Logger = 0;
 	ErrMsgId = 0;
 	SettingStore = NULL;
 
 	Items = 0;
 	Transfer = 0;
 }
 
 MailProtocol::~MailProtocol()
 {
 	CharsetPrefs.DeleteArrays();
 }
 
 void MailProtocol::Log(const char *Str, LSocketI::SocketMsgType type)
 {
 	if (Logger && Str)
 	{
 		char s[1024];
 		char *e = s + sizeof(s) - 2;
 		const char *i = Str;
 		char *o = s;
 		while (*i && o < e)
 		{
 			*o++ = *i++;
 		}
 		while (o > s && (o[-1] == '\r' || o[-1] == '\n'))
 			o--;
 		*o++ = '\n';
 		*o = 0;
 
 		Logger->Write(s, o - s, type);
 	}
 }
 
 bool MailProtocol::Error(const char *file, int line, const char *msg, ...)
 {
 	char s[1024];
 	va_list a;
 	va_start(a, msg);
 	vsprintf_s(s, sizeof(s), msg, a);
 	va_end(a);
 
 	Log(s, LSocketI::SocketMsgError);
 	LgiTrace("%s:%i - Error: %s", file, line, s);
 	return false;
 }
 
 bool MailProtocol::Read()
 {
 	bool Status = false;
 	if (Socket)
 	{
 		Status = Socket->Read(Buffer, sizeof(Buffer), 0) > 0;
 	}
 	return Status;
 }
 
 bool MailProtocol::Write(const char *Buf, bool LogWrite)
 {
 	bool Status = false;
 	if (Socket)
 	{
 		const char *p = Buf ? Buf : Buffer;
 		Status = Socket->Write(p, strlen(p), 0) > 0;
 		
 		if (LogWrite)
 		{
 			Log(p, LSocketI::SocketMsgSend);
 		}
 	}
 	return Status;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 #define	VERIFY_RET_VAL(Arg)						\
 {												\
 	if (!Arg)									\
 	{											\
 		LMutex::Auto Lck(&SocketLock, _FL);	\
 		Socket.Reset(0);						\
 		return NULL;							\
 	}											\
 }
 
 #define	VERIFY_ONERR(Arg)						\
 {												\
 	if (!Arg)									\
 	{											\
 		LMutex::Auto Lck(&SocketLock, _FL);	\
 		Socket.Reset(0);						\
 		goto CleanUp;							\
 	}											\
 }
 
 void Reorder(LArray<LString> &a, const char *s)
 {
 	for (unsigned i=0; i<a.Length(); i++)
 	{
 		if (a[i].Equals(s) && i > 0)
 		{
 			a.DeleteAt(i, true);
 			a.AddAt(0, s);
 			break;
 		}
 	}
 }
 
 MailSmtp::MailSmtp()
 {
 }
 
 MailSmtp::~MailSmtp()
 {
 }
 
 bool MailSmtp::Open(LSocketI *S,
 					const char *RemoteHost,
 					const char *LocalDomain,
 					const char *UserName,
 					const char *Password,
 					int Port,
 					int Flags)
 {
 	char Str[256] = "";
 	bool Status = false;
 
 	if (!RemoteHost)
 		Error(_FL, "No remote SMTP host.\n");
 	else
 	{
 		strcpy_s(Str, sizeof(Str), RemoteHost);
 		char *Colon = strchr(Str, ':');
 		if (Colon)
 		{
 			*Colon = 0;
 			Colon++;
 			Port = atoi(Colon);
 		}
 		if (Port == 0)
 		{
 			if (Flags & MAIL_SSL)
 				Port = SMTP_SSL_PORT;
 			else
 				Port = SMTP_PORT;
 		}
 
 		LAutoString Server(TrimStr(Str));
 		if (Server)
 		{
 			if (SocketLock.Lock(_FL))
 			{
 				Socket.Reset(S);
 				SocketLock.Unlock();
 			}
 
 			Socket->SetTimeout(30 * 1000);
 
 			char Msg[256];
 			sprintf_s(Msg, sizeof(Msg), "Connecting to %s:%i...", Server.Get(), Port);
 			Log(Msg, LSocketI::SocketMsgInfo);
 	
 			if (!Socket->Open(Server, Port))
 				Error(_FL, "Failed to connect socket to %s:%i\n", Server.Get(), Port);
 			else
 			{
 				LStringPipe Str;
 
 				// receive signon message
 				VERIFY_RET_VAL(ReadReply("220"));
 
 				// Rfc 2554 ESMTP authentication
 				SmtpHello:
 				sprintf_s(Buffer, sizeof(Buffer), "EHLO %s\r\n", (ValidNonWSStr(LocalDomain)) ? LocalDomain : "default");
 				VERIFY_RET_VAL(Write(0, true));
 				/*bool HasSmtpExtensions =*/ ReadReply("250", &Str);
 
 				bool Authed = false;
 				bool NoAuthTypes = false;
 				bool SupportsStartTLS = false;
 				LArray<LString> AuthTypes;
 
 				// Look through the response for the auth line
 				LString Response = Str.NewGStr();
 				if (Response)
 				{
 					auto Lines = Response.SplitDelimit("\n");
 					for (auto &l: Lines)
 					{
 						char *AuthStr = stristr(l, "AUTH");
 						if (AuthStr)
 						{
 							// walk through AUTH types
 							auto Types = LString(AuthStr + 4).SplitDelimit(" ,;");
 							for (auto &t: Types)
 								AuthTypes.Add(t);
 						}
 						if (stristr(l, "STARTTLS"))
 							SupportsStartTLS = true;
 					}
 				}
 
 				if (SupportsStartTLS && TestFlag(Flags, MAIL_USE_STARTTLS))
 				{
 					strcpy_s(Buffer, sizeof(Buffer), "STARTTLS\r\n");
 					VERIFY_RET_VAL(Write(0, true));
 					VERIFY_RET_VAL(ReadReply("220", &Str));
 
 					LVariant v;
 					if (Socket->SetValue(LSocket_Protocol, v="SSL"))
 					{
 						Flags &= ~MAIL_USE_STARTTLS;
 						goto SmtpHello;
 					}
 					else
 					{
 						// SSL init failed... what to do here?
 						return false;
 					}
 				}
 
 
 				if (TestFlag(Flags, MAIL_USE_AUTH))
 				{
 					if (!ValidStr(UserName))
 					{
 						// We need a user name in all authentication types.
 						SetError(L_ERROR_ESMTP_NO_USERNAME, "No username for authentication.");
 						return false;
 					}
 
 					if (AuthTypes.Length() == 0)
 					{
 						// No auth types? huh?
 						if (TestFlag(Flags, MAIL_USE_PLAIN))
 							// Force plain type
 							AuthTypes.Add("PLAIN");
 						else if (TestFlag(Flags, MAIL_USE_LOGIN))
 							// Force login type
 							AuthTypes.Add("LOGIN");
 						else if (TestFlag(Flags, MAIL_USE_CRAM_MD5))
 							// Force CRAM MD5 type
 							AuthTypes.Add("CRAM-MD5");
 						else if (TestFlag(Flags, MAIL_USE_OAUTH2))
 							// Force OAUTH2 type
 							AuthTypes.Add("XOAUTH2");
 						else
 						{
 							// Try all
 							AuthTypes.Add("PLAIN");
 							AuthTypes.Add("LOGIN");
 							AuthTypes.Add("CRAM-MD5");
 							AuthTypes.Add("XOAUTH2");
 						}
 					}
 					else
 					{
 						// Force user preference
 						if (TestFlag(Flags, MAIL_USE_PLAIN))
 							Reorder(AuthTypes, "PLAIN");
 						else if (TestFlag(Flags, MAIL_USE_LOGIN))
 							Reorder(AuthTypes, "LOGIN");
 						else if (TestFlag(Flags, MAIL_USE_CRAM_MD5))
 							Reorder(AuthTypes, "CRAM-MD5");
 						else if (TestFlag(Flags, MAIL_USE_OAUTH2))
 							Reorder(AuthTypes, "XOAUTH2");
 					}
 
 					for (auto Auth : AuthTypes)
 					{
 						// Try all their auth types against our internally support types
 						if (Auth.Equals("LOGIN"))
 						{
 							VERIFY_RET_VAL(Write("AUTH LOGIN\r\n", true));
 							VERIFY_RET_VAL(ReadReply("334"));
 
 							ZeroObj(Buffer);
 							ConvertBinaryToBase64(Buffer, sizeof(Buffer), (uchar*)UserName, strlen(UserName));
 							strcat(Buffer, "\r\n");
 							VERIFY_RET_VAL(Write(0, true));
 							if (ReadReply("334") && Password)
 							{
 								ZeroObj(Buffer);
 								ConvertBinaryToBase64(Buffer, sizeof(Buffer), (uchar*)Password, strlen(Password));
 								strcat(Buffer, "\r\n");
 								VERIFY_RET_VAL(Write(0, true));
 								if (ReadReply("235"))
 									Authed = true;
 							}
 						}
 						else if (Auth.Equals("PLAIN"))
 						{
 							char Ascii[512];
 							int ch = sprintf_s(Ascii, sizeof(Ascii), "%c%s%c%s", 0, UserName, 0, Password);
 							char Base64[512] = {0};
 							ConvertBinaryToBase64(Base64, sizeof(Base64), (uint8_t*)Ascii, ch);
 
 							sprintf_s(Buffer, sizeof(Buffer), "AUTH PLAIN %s\r\n", Base64);
 							VERIFY_RET_VAL(Write(0, true));
 							if (ReadReply("235"))
 							{
 								Authed = true;
 							}
 						}
 						else if (Auth.Equals("CRAM-MD5"))
 						{
 							sprintf_s(Buffer, sizeof(Buffer), "AUTH CRAM-MD5\r\n");
 							VERIFY_RET_VAL(Write(0, true));
 							if (ReadReply("334"))
 							{
 								auto Sp = strchr(Buffer, ' ');
 								if (Sp)
 								{
 									Sp++;
 
 									// Decode the server response:
 									uint8_t Txt[128];
 									auto InLen = strlen(Sp);
 									ssize_t TxtLen = ConvertBase64ToBinary(Txt, sizeof(Txt), Sp, InLen);
 
 									// Calc the hash:
 									// https://tools.ietf.org/html/rfc2104
 									char Key[64] = {0};
 									memcpy(Key, Password, MIN(strlen(Password), sizeof(Key)));
 									uint8_t iKey[256];
 									char oKey[256];
 									for (unsigned i=0; i<64; i++)
 									{
 										iKey[i] = Key[i] ^ 0x36;
 										oKey[i] = Key[i] ^ 0x5c;
 									}
 									memcpy(iKey+64, Txt, TxtLen);
 									md5_state_t md5;
 									md5_init(&md5);
 									md5_append(&md5, iKey, 64 + TxtLen);
 									md5_finish(&md5, oKey + 64);
 
 									md5_init(&md5);
 									md5_append(&md5, (uint8_t*)oKey, 64 + 16);
 									char digest[16];
 									md5_finish(&md5, digest);
 
 									char r[256];
 									int ch = sprintf_s(r, sizeof(r), "%s ", UserName);
 									for (unsigned i=0; i<16; i++)
 										ch += sprintf_s(r+ch, sizeof(r)-ch, "%02x", (uint8_t)digest[i]);
 
 									// Base64 encode
 									ssize_t Len = ConvertBinaryToBase64(Buffer, sizeof(Buffer), (uint8_t*)r, ch);
 									Buffer[Len++] = '\r';
 									Buffer[Len++] = '\n';
 									Buffer[Len++] = 0;
 									VERIFY_RET_VAL(Write(0, true));
 									if (ReadReply("235"))
 										Authed = true;
 								}
 							}
 						}
 						else if (Auth.Equals("XOAUTH2"))
 						{
 							auto Log = dynamic_cast<LStream*>(Socket->GetLog());
 							LOAuth2 Authenticator(OAuth2, UserName, SettingStore, Socket->GetCancel(), Log);
 							auto Tok = Authenticator.GetAccessToken();
 							if (Tok)
 							{
 								LString s;
 								s.Printf("user=%s\001auth=Bearer %s\001\001\0", UserName, Tok.Get());
 								Base64Str(s);
 
 								sprintf_s(Buffer, sizeof(Buffer), "AUTH %s %s\r\n", Auth.Get(), s.Get());
 								VERIFY_RET_VAL(Write(0, true));
 								Authed = ReadReply("235");
 								if (!Authed)
 								{
 									Authenticator.Refresh();
 								}
 							}
 						}
 						else
 						{
 							LgiTrace("%s:%i - Unsupported auth type '%s'\n", _FL, Auth.Get());
 						}
 
 						if (Authed)
 							break;
 					}
 
 					if (!Authed)
 					{
 						if (NoAuthTypes)
 							SetError(L_ERROR_ESMTP_NO_AUTHS, "The server didn't return the authentication methods it supports.");
 						else
 						{
 							LString p;
 							for (auto i : AuthTypes)
 							{
 								if (p.Get())
 									p += ", ";
 								p += i;
 							}
 
 							SetError(L_ERROR_UNSUPPORTED_AUTH, "Authentication failed, types available:\n\t%s", p);
 						}
 					}
 
 					Status = Authed;
 				}
 				else
 				{
 					Status = true;
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool MailSmtp::WriteText(const char *Str)
 {
 	// we have to convert all strings to CRLF in here
 	bool Status = false;
 	if (Str)
 	{
 		LMemQueue Temp;
 
 		const char *Start = Str;
 		while (*Str)
 		{
 			if (*Str == '\n')
 			{
 				// send a string
 				ssize_t Size = Str-Start;
 				if (Str[-1] == '\r') Size--;
 				Temp.Write((uchar*) Start, Size);
 				Temp.Write((uchar*) "\r\n", 2);
 				Start = Str + 1;
 			}
 
 			Str++;
 		}
 
 		// send the final string
 		ssize_t Size = Str-Start;
 		if (Str[-1] == '\r') Size--;
 		Temp.Write((uchar*) Start, (int)Size);
 
 		Size = (int)Temp.GetSize();
 		char *Data = new char[(size_t)Size];
 		if (Data)
 		{
 			Temp.Read((uchar*) Data, Size);
 			Status = Socket->Write(Data, (int)Size, 0) == Size;
 			DeleteArray(Data);
 		}
 	}
 
 	return Status;
 }
 
 void StripChars(LString &s)
 {
 	s = s.Strip("\r\n");
 }
 
 char *CreateAddressTag(List<AddressDescriptor> &l, int Type, List<char> *CharsetPrefs)
 {
 	char *Result = 0;
 	List<AddressDescriptor> Addr;
 	for (auto a: l)
 	{
 		if (a->CC == Type)
 		{
 			Addr.Insert(a);
 		}
 	}
 	
 	if (Addr.Length() > 0)
 	{
 		LStringPipe StrBuf;
 		StrBuf.Push((Type == 0) ? (char*)"To: " : (char*)"Cc: ");
 
 		for (auto It = Addr.begin(); It != Addr.end(); )
 		{
 			auto a = *It;
 			AddressDescriptor *NextA = *(++It);
 			char Buffer[256] = "";
 			
 			StripChars(a->sName);
 			StripChars(a->sAddr);
 
 			if (a->sAddr && strchr(a->sAddr, ','))
 			{
 				// Multiple address format
 				auto t = a->sAddr.SplitDelimit(",");
 				for (uint32_t i=0; i<t.Length(); i++)
 				{
 					sprintf_s(Buffer, sizeof(Buffer), "<%s>", t[i].Get());
 					if (i < t.Length()-1) strcat(Buffer, ",\r\n\t");
 					StrBuf.Push(Buffer);
 					Buffer[0] = 0;
 				}
 			}
 			else if (a->sName)
 			{
 				// Name and addr
 				char *Mem = 0;
 				char *Name = a->sName.Get();
 
 				if (Is8Bit(Name))
 				{
 					Name = Mem = EncodeRfc2047(NewStr(Name), 0, CharsetPrefs);
 				}
 
 				if (strchr(Name, '\"'))
 				    sprintf_s(Buffer, sizeof(Buffer), "'%s' <%s>", Name, a->sAddr.Get());
 				else
 				    sprintf_s(Buffer, sizeof(Buffer), "\"%s\" <%s>", Name, a->sAddr.Get());
 
 				DeleteArray(Mem);
 			}
 			else if (a->sAddr)
 			{
 				// Just addr
 				sprintf_s(Buffer, sizeof(Buffer), "<%s>", a->sAddr.Get());
 			}
 
 			if (NextA) strcat(Buffer, ",\r\n\t");
 			StrBuf.Push(Buffer);
 
 			a = NextA;
 		}
 
 		StrBuf.Push("\r\n");
 		Result = StrBuf.NewStr();
 	}
 
 	return Result;
 }
 
 // This class implements a pipe that writes to a socket
 class SocketPipe : public LStringPipe
 {
 	LSocketI *s;
 	MailProtocolProgress *p;
 
 public:
 	bool Status;
 
 	SocketPipe(LSocketI *socket, MailProtocolProgress *progress)
 	{
 		s = socket;
 		p = progress;
 		Status = true;
 	}
 
 	ssize_t Read(void *Ptr, ssize_t Size, int Flags)
 	{
 		return false;
 	}
 	
 	int64 SetSize(int64 Size)
 	{
 		if (p)
 		{
 			p->Start = LCurrentTime();
 			p->Range = (int)Size;
 			return Size;
 		}
 
 		return -1;
 	}
 
 	ssize_t Write(const void *InPtr, ssize_t Size, int Flags)
 	{
 		char *Ptr = (char*)InPtr;
 		char *e = Ptr + Size;
 		
 		while (Ptr < e)
 		{
 			ssize_t w = s->Write(Ptr, e - Ptr, 0);
 			if (w > 0)
 			{
 				Ptr += w;
 
 				if (p && p->Range && w > 0)
 					p->Value += w;
 			}
 			else break;
 		}
 
 		return Ptr - (char*)InPtr;
 	}
 };
 
 bool MailSmtp::SendToFrom(List<AddressDescriptor> &To, AddressDescriptor *From, MailProtocolError *Err)
 {
 	bool AddrOk = false;
 
 	if (To.Length() == 0)
 	{
 		ErrMsgId = L_ERROR_ESMTP_NO_RECIPIENT;
 		ErrMsgFmt = "No recipients to send to.";
 		ErrMsgParam.Empty();
 
 		LgiTrace("%s:%i - No recipients.\n", _FL);
 		return false;
 	}
 
 	// send MAIL message
 	if (From && ValidStr(From->sAddr))
 	{
 		sprintf_s(Buffer, sizeof(Buffer), "MAIL FROM: <%s>\r\n", From->sAddr.Get());
 	}
 	else
 	{
 		ErrMsgId = L_ERROR_ESMTP_NO_FROM;
 		ErrMsgFmt = "No 'from' address in email.";
 		ErrMsgParam.Empty();
 
 		LgiTrace("%s:%i - Invalid from '%s'.\n", _FL, From->sAddr.Get());
 		return false;
 	}
 
 	VERIFY_RET_VAL(Write(0, true));
 	VERIFY_RET_VAL(ReadReply("250", 0, Err));
 
 	// send RCPT message
 	AddrOk = true;
 	List<AddressDescriptor>::I Recip = To.begin();
 	for (AddressDescriptor *a = *Recip; a; a = *++Recip)
 	{
 		LString Addr = ValidStr(a->sAddr) ? a->sAddr : a->sName;
 		if (ValidStr(Addr))
 		{
 			auto Parts = Addr.SplitDelimit(",");
 			for (auto p: Parts)
 			{
 				sprintf_s(Buffer, sizeof(Buffer), "RCPT TO: <%s>\r\n", p.Get());
 				VERIFY_RET_VAL(Write(0, true));
 				a->Status = ReadReply("25", 0, Err);
 				AddrOk |= a->Status != 0; // at least one address is ok
 			}
 		}
 		else if (Err)
 		{
 			ErrMsgId = L_ERROR_ESMTP_BAD_RECIPIENT;
 			ErrMsgFmt = "Invalid recipient '%s'.";
 			ErrMsgParam = Addr;
 		}
 	}
 
 	return AddrOk;
 }
 
 LStringPipe *MailSmtp::SendData(MailProtocolError *Err)
 {
 	// send DATA message
 	sprintf_s(Buffer, sizeof(Buffer), "DATA\r\n");
 	VERIFY_RET_VAL(Write(0, true));
 	VERIFY_RET_VAL(ReadReply("354", 0, Err));
 
 	return new SocketPipe(Socket, Transfer);
 }
 
 LStringPipe *MailSmtp::SendStart(List<AddressDescriptor> &To, AddressDescriptor *From, MailProtocolError *Err)
 {
 	return SendToFrom(To, From, Err) ? SendData(Err) : NULL;
 }
 
 bool MailSmtp::SendEnd(LStringPipe *m)
 {
 	bool Status = false;
 
 	SocketPipe *Msg = dynamic_cast<SocketPipe*>(m);
 	if (Msg)
 	{
 		// send message terminator and receive reply
 		if (Msg->Status &&
 			Msg->Write((void*)"\r\n.\r\n", 5, 0))
 		{
 			Status = ReadReply("250");
 		}
 		// else
 		//		just close the connection on them
 		//		so nothing gets sent
 	}
 
 	DeleteObj(m);
 
 	return Status;
 }
 
 /*
 bool MailSmtp::Send(MailMessage *Msg, bool Mime)
 {
 	bool Status = false;
 
 	if (Socket && Msg)
 	{
 		LStringPipe *Sink = SendStart(Msg->To, Msg->From);
 		if (Sink)
 		{
 			// setup a gui progress meter to send the email,
 			// the length is just a guesstimate as we won't know the exact
 			// size until we encode it all, and I don't want it hanging around
 			// in memory at once, so we encode and send on the fly.
 			int Length =	1024 +
 									(Msg->GetBody() ? strlen(Msg->GetBody()) : 0);
 			for (FileDescriptor *f=Msg->FileDesc.First(); f; f=Msg->FileDesc.Next())
 			{
 				Length += f->Sizeof() * 4 / 3;
 			}
 
 			// encode and send message for transport
 			Msg->Encode(*Sink, 0, this);
 			Status = SendEnd(Sink);
 		}
 	}
 
 	return Status;
 }
 */
 
 bool MailSmtp::Close()
 {
 	if (Socket)
 	{
 		// send QUIT message
 		sprintf_s(Buffer, sizeof(Buffer), "QUIT\r\n");
 		VERIFY_RET_VAL(Write(0, true));
 		VERIFY_RET_VAL(ReadReply("221"));
 		
 		LMutex::Auto Lock(&SocketLock, _FL);
 		Socket.Reset(0);
 		return true;
 	}
 
 	return false;
 }
 
 bool MailSmtp::ReadReply(const char *Str, LStringPipe *Pipe, MailProtocolError *Err)
 {
 	bool Status = false;
 	if (Socket && Str)
 	{
 		ssize_t Pos = 0;
 		char *Start = Buffer;
 		ZeroObj(Buffer);
 
 		while (Pos < sizeof(Buffer))
 		{
 			ssize_t Len = Socket->Read(Buffer+Pos, sizeof(Buffer)-Pos, 0);
 			if (Len > 0)
 			{
 				char *Eol = strstr(Start, "\r\n");
 				while (Eol)
 				{
 					// wipe EOL chars
 					*Eol++ = 0;
 					*Eol++ = 0;
 
 					// process
 					if (Pipe)
 					{
 						if (Pipe->GetSize()) Pipe->Push("\n");
 						Pipe->Push(Start);
 					}
 
 					if (Start[3] == ' ')
 					{
 						// end of response
 						if (!strncmp(Start, Str, strlen(Str)))
 						{
 							Status = true;
 						}
 
 						if (Err)
 						{
 							Err->Code = atoi(Start);
 							char *Sp = strchr(Start, ' ');
 							Err->ErrMsg = Sp ? Sp + 1 : Start;
 						}
 
 						// Log
 						Log(Start, atoi(Start) >= 400 ? LSocketI::SocketMsgError : LSocketI::SocketMsgReceive);
 
 						// exit loop
 						Pos = sizeof(Buffer);
 						break;
 					}
 					else
 					{
 						Log(Start, LSocketI::SocketMsgReceive);
 
 						// more lines follow
 						Start = Eol;
 						Eol = strstr(Start, "\r\n");
 					}
 				}
 
 				Pos += Len;
    			}
 			else break;
 		}
 
 		if (!Status)
 		{
 			SetError(L_ERROR_GENERIC, "Error: %s", Buffer);
 		}
 	}
 
 	return Status;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 class Mail2Folder : public LStringPipe
 {
 	char File[256];
 	LFile F;
 
 public:
 	Mail2Folder(char *Path, List<AddressDescriptor> &To)
 	{
 		do
 		{
 			char n[32];
 			sprintf_s(n, sizeof(n), "%u.mail", LRand());
 			LMakePath(File, sizeof(File), Path, n);
 		}
 		while (LFileExists(File));
 
 		if (F.Open(File, O_WRITE))
 		{
 			F.Print("Forward-Path: ");
 
 			int i = 0;
 			for (auto a: To)
 			{
 				a->Status = true;
 				auto Addrs = a->sAddr.SplitDelimit(",");
 				for (unsigned n=0; n<Addrs.Length(); n++, i++)
 				{
 					if (i) F.Print(",");
 					F.Print("<%s>", Addrs[n].Get());
 				}
 			}
 
 			F.Print("\r\n");
 		}
 	}
 
 	~Mail2Folder()
 	{
 		F.Close();
 	}
 
 	ssize_t Read(void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		return F.Read(Buffer, Size, Flags);
 	}
 
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0)
 	{
 		return F.Write(Buffer, Size, Flags);
 	}
 };
 
 class MailPostFolderPrivate
 {
 public:
 	char *Path;
 
 	MailPostFolderPrivate()
 	{
 		Path = 0;
 	}
 
 	~MailPostFolderPrivate()
 	{
 		DeleteArray(Path);
 	}
 };
 
 MailSendFolder::MailSendFolder(char *Path)
 {
 	d = new MailPostFolderPrivate;
 	d->Path = NewStr(Path);
 }
 
 MailSendFolder::~MailSendFolder()
 {
 	DeleteObj(d);
 }
 
 bool MailSendFolder::Open(LSocketI *S, const char *RemoteHost, const char *LocalDomain, const char *UserName, const char *Password, int Port, int Flags)
 {
 	return LDirExists(d->Path);
 }
 
 bool MailSendFolder::Close()
 {
 	return true;
 }
 
 LStringPipe *MailSendFolder::SendStart(List<AddressDescriptor> &To, AddressDescriptor *From, MailProtocolError *Err)
 {
 	return new Mail2Folder(d->Path, To);
 }
 
 bool MailSendFolder::SendEnd(LStringPipe *Sink)
 {
 	DeleteObj(Sink);
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 class MailItem
 {
 public:
 	char *File;
 	bool Delete;
 	
 	MailItem(char *f)
 	{
 		File = NewStr(f);
 		Delete = false;
 	}
 
 	~MailItem()
 	{
 		DeleteArray(File);
 	}
 };
 
 class MailReceiveFolderPrivate
 {
 public:
 	char *Path;
 	List<MailItem> Mail;
 
 	MailReceiveFolderPrivate()
 	{
 		Path = 0;
 	}
 
 	~MailReceiveFolderPrivate()
 	{
 		DeleteArray(Path);
 		Mail.DeleteObjects();
 	}
 
 	void Empty()
 	{
 		for (auto m: Mail)
 		{
 			if (m->Delete)
 			{
 				FileDev->Delete(m->File, false);
 			}
 		}
 
 		Mail.DeleteObjects();
 	}
 };
 
 MailReceiveFolder::MailReceiveFolder(char *Path)
 {
 	d = new MailReceiveFolderPrivate;
 	d->Path = NewStr(Path);
 }
 
 MailReceiveFolder::~MailReceiveFolder()
 {
 	DeleteObj(d);
 }
 
 bool MailReceiveFolder::Open(LSocketI *S, const char *RemoteHost, int Port, const char *User, const char *Password, LDom *SettingStore, int Flags)
 {
 	// We don't use the socket so just free it here...
 	DeleteObj(S);
 
 	// Argument check
 	if (!LDirExists(d->Path))
 		return false;
 	
 	LDirectory Dir;
 
 	// Loop through files, looking for email
 	for (int b = Dir.First(d->Path, LGI_ALL_FILES); b; b = Dir.Next())
 	{
 		if (!Dir.IsDir())
 		{
 			if (MatchStr("*.eml", Dir.GetName()) ||
 				MatchStr("*.mail", Dir.GetName()))
 			{
 				char p[300];
 				Dir.Path(p, sizeof(p));
 				d->Mail.Insert(new MailItem(p));
 			}
 		}
 	}
 
 	return true;
 }
 
 bool MailReceiveFolder::Close()
 {
 	d->Empty();
 	return true;
 }
 
 ssize_t MailReceiveFolder::GetMessages()
 {
 	return d->Mail.Length();
 }
 
 bool MailReceiveFolder::Receive(LArray<MailTransaction*> &Trans, MailCallbacks *Callbacks)
 {
 	bool Status = false;
 
 	for (unsigned i=0; i<Trans.Length(); i++)
 	{
 		MailTransaction *t = Trans[i];
 		if (t && t->Stream)
 		{
 			t->Status = false;
 
 			MailItem *m = d->Mail[t->Index];
 			if (m)
 			{
 				LFile i;
 				if (i.Open(m->File, O_READ))
 				{
 					LCopyStreamer c;
 					if (c.Copy(&i, t->Stream))
 					{
 						Status = t->Status = true;
 						if (Callbacks && Callbacks->OnReceive)
 						{
 							Callbacks->OnReceive(t, Callbacks->CallbackData);
 						}
 					}
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 bool MailReceiveFolder::Delete(int Message)
 {
 	MailItem *m = d->Mail[Message];
 	if (m)
 	{
 		m->Delete = true;
 		return false;
 	}
 
 	return false;
 }
 
 int MailReceiveFolder::Sizeof(int Message)
 {
 	MailItem *m = d->Mail[Message];
 	if (m)
 	{
 		return (int)LFileSize(m->File);
 	}
 
 	return 0;
 }
 
 bool MailReceiveFolder::GetUid(int Message, char *Id, int IdLen)
 {
 	if (Id)
 	{
 		MailItem *m = d->Mail[Message];
 		if (m)
 		{
 			char *s = strrchr(m->File, DIR_CHAR);
 			if (s++)
 			{
 				char *e = strchr(s, '.');
 				if (!e) e = s + strlen(s);
 				ssize_t Len = e - s;
 				memcpy(Id, s, Len);
 				Id[Len] = 0;
 
 				return true;
 			}		
 		}
 	}
 
 	return false;
 }
 
 bool MailReceiveFolder::GetUidList(LString::Array &Id)
 {
 	bool Status = false;
 
 	for (int i=0; i<d->Mail.Length(); i++)
 	{
 		char Uid[256];
 		if (GetUid(i, Uid, sizeof(Uid)))
 		{
 			Status = true;
 			Id.New() = Uid;
 		}
 		else
 		{
 			Status = false;
 			break;
 		}
 	}
 
 	return Status;
 }
 
 LString MailReceiveFolder::GetHeaders(int Message)
 {
 	MailItem *m = d->Mail[Message];
 	if (!m)
 		return NULL;
 	
 	LFile i;
 	if (!i.Open(m->File, O_READ))
 		return NULL;
 
 	LStringPipe o;
 	LCopyStreamer c;
 	LHtmlLinePrefix e("", false);
 	if (!c.Copy(&i, &o, &e))
 		return NULL;
 
 	return o.NewGStr();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 MailPop3::MailPop3()
 {
 	End = "\r\n.\r\n";
 	Marker = End;
 	Messages = -1;
 }
 
 MailPop3::~MailPop3()
 {
 }
 
 ssize_t MailPop3::GetMessages()
 {
 	if (Messages < 0)
 	{
 		if (Socket && Socket->IsOpen())
 		{
 			// see how many messages there are
 			VERIFY_ONERR(Write("STAT\r\n", true));
 			VERIFY_ONERR(ReadReply());
 
 			Messages = GetInt();
 		}
 		else LAssert(!"No socket to get message count.");
 	}
 
 CleanUp:
 	return Messages;
 }
 
 int MailPop3::GetInt()
 {
 	char Buf[32];
 	char *Start = strchr(Buffer, ' ');
 	if (Start)
 	{
 		Start++;
 		char *End = strchr(Start, ' ');
 		if (End)
 		{
 			int Len = (int) (End - Start);
 			memcpy(Buf, Start, Len);
 			Buf[Len] = 0;
 			return atoi(Buf);
 		}
 	}
 	return 0;
 }
 
 bool MailPop3::ReadReply()
 {
 	bool Status = false;
 	if (Socket)
 	{
 		ssize_t Pos = 0;
 		ZeroObj(Buffer);
 		do
 		{
 			ssize_t Result = Socket->Read(Buffer+Pos, sizeof(Buffer)-Pos, 0);
 			if (Result <= 0) // an error?
 			{
 				// Leave the loop...
 				break;
 			}
 
 			Pos += Result;
     	}
 		while (	!strstr(Buffer, "\r\n") &&
 				sizeof(Buffer)-Pos > 0);
 
 		Status = (Buffer[0] == '+') && strstr(Buffer, "\r\n");
 
 		char *Cr = strchr(Buffer, '\r');
 		if (Cr) *Cr = 0;
 		if (ValidStr(Buffer))
 			Log(Buffer, (Status) ? LSocketI::SocketMsgReceive : LSocketI::SocketMsgError);
 		if (Cr) *Cr = '\r';
 
 		if (!Status)
 		{
 			SetError(L_ERROR_GENERIC, "Error: %s", Buffer);
 		}
 	}
 
 	return Status;
 }
 
 bool MailPop3::ListCmd(const char *Cmd, LHashTbl<ConstStrKey<char,false>, bool> &Results)
 {
 	sprintf_s(Buffer, sizeof(Buffer), "%s\r\n", Cmd);
 	if (!Write(0, true))
 		return false;
 
 	char *b = Buffer;
 	ssize_t r;
 	while ((r = Socket->Read(b, sizeof(Buffer)-(b-Buffer))) > 0)
 	{
 		b += r;
 		if (Strnstr(Buffer, "\r\n.\r\n", b-Buffer))
 			break;
 	}
 
 	if (r <= 0)
 		return false;
 
 	auto Lines = LString(Buffer).SplitDelimit("\r\n");
 	for (unsigned i=1; i<Lines.Length()-1; i++)
 		Results.Add(Lines[i], true);
 
 	return true;
 }
 
 #define OPT_Pop3NoApop		"NoAPOP"
 
 bool MailPop3::Open(LSocketI *S, const char *RemoteHost, int Port, const char *User, const char *Password, LDom *SettingStore, int Flags)
 {
 	bool Status = false;
 	// bool RemoveMail = false;
 	char Str[256] = "";
 	char *Apop = 0;
 	char *Server = 0;
 	bool SecureAuth = TestFlag(Flags, MAIL_SECURE_AUTH);
 
 	if (!RemoteHost)
 		Error(_FL, "No remote POP host.\n");
 	else 
 	{
 		LXmlTag LocalStore;
 		if (!SettingStore)
 			SettingStore = &LocalStore;
 
 		if (Port < 1)
 		{
 			LVariant IsSsl;
 			if (S->GetValue("IsSSL", IsSsl) &&
 				IsSsl.CastInt32())
 				Port = POP3_SSL_PORT;
 			else
 				Port = POP3_PORT;
 		}
 
 		strcpy_s(Str, sizeof(Str), RemoteHost);
 		char *Colon = strchr(Str, ':');
 		if (Colon)
 		{
 			*Colon = 0;
 			Colon++;
 			Port = atoi(Colon);
 		}
 
 		if (S &&
 			User &&
 			Password &&
 			(Server = TrimStr(Str)))
 		{
 			S->SetTimeout(30 * 1000);
 
 			ReStartConnection:
 			
 			if (SocketLock.Lock(_FL))
 			{
 				Socket.Reset(S);
 				SocketLock.Unlock();
 			}
 
 			if (Socket &&
 				Socket->Open(Server, Port) &&
 				ReadReply())
 			{
 				LVariant NoAPOP = false;
 				if (SettingStore)
 					SettingStore->GetValue(OPT_Pop3NoApop, NoAPOP);
 				if (!NoAPOP.CastInt32())
 				{
 					char *s = strchr(Buffer + 3, '<');
 					if (s)
 					{
 						char *e = strchr(s + 1, '>');
 						if (e)
 						{
 							Apop = NewStr(s, e - s + 1);
 						}
 					}
 				}
 
 				// login
 				bool Authed = false;
 				char *user = (char*) LNewConvertCp("iso-8859-1", User, "utf-8");
 				char *pass = (char*) LNewConvertCp("iso-8859-1", Password, "utf-8");
 
 				if (user && (pass || SecureAuth))
 				{
 					bool SecurityError = false;
 
 					if (TestFlag(Flags, MAIL_USE_STARTTLS))
 					{
 						strcpy_s(Buffer, sizeof(Buffer), "STARTTLS\r\n");
 						VERIFY_RET_VAL(Write(0, true));
 						VERIFY_RET_VAL(ReadReply());
 
 						LVariant v;
 						if (Socket->SetValue(LSocket_Protocol, v="SSL"))
 						{
 							Flags &= ~MAIL_USE_STARTTLS;
 						}
 						else
 						{
 							SecurityError = true;
 						}
 					}
 
 					if (!SecurityError && Apop) // GotKey, not implemented
 					{
 						// using encrypted password
 						unsigned char Digest[16];
 						char HexDigest[33];
 
 						// append password
 						char Key[256];
 						sprintf_s(Key, sizeof(Key), "%s%s", Apop, pass);
 
 						ZeroObj(Digest);
 						MDStringToDigest(Digest, Key);
 						for (int i = 0; i < 16; i++)
 							sprintf_s(HexDigest + (i*2), 3, "%2.2x", Digest[i]);
 						HexDigest[32] = 0;
 
 						sprintf_s(Buffer, sizeof(Buffer), "APOP %s %s\r\n", user, HexDigest);
 						VERIFY_ONERR(Write(0, true));
 						Authed = ReadReply();
 
 						if (!Authed)
 						{
 							DeleteArray(Apop);
 							LVariant NoAPOP = true;
 							if (SettingStore)
 								SettingStore->SetValue(OPT_Pop3NoApop, NoAPOP);
 							S->Close();
 							goto ReStartConnection;
 						}
 					}
 
 					if (!SecurityError && SecureAuth)
 					{
 						LHashTbl<ConstStrKey<char,false>, bool> AuthTypes, Capabilities;
 						if (ListCmd("AUTH", AuthTypes) &&
 							ListCmd("CAPA", Capabilities))
 						{
 							if (AuthTypes.Find("GSSAPI"))
 							{
 								sprintf_s(Buffer, sizeof(Buffer), "AUTH GSSAPI\r\n");
 								VERIFY_ONERR(Write(0, true));
 								VERIFY_ONERR(ReadReply());
 
 								// http://www.faqs.org/rfcs/rfc2743.html
 							}
 						}
 					}					
 					else if (!SecurityError && !Authed)
 					{
 						// have to use non-key method
 						sprintf_s(Buffer, sizeof(Buffer), "USER %s\r\n", user);
 						VERIFY_ONERR(Write(0, true));
 						VERIFY_ONERR(ReadReply());
 
 						sprintf_s(Buffer, sizeof(Buffer), "PASS %s\r\n", pass);
 						VERIFY_ONERR(Write(0, false));
 						Log("PASS *******", LSocketI::SocketMsgSend);
 
 						Authed = ReadReply();
 					}
 
 					DeleteArray(user);
 					DeleteArray(pass);
 				}
 
 				if (Authed)
 				{
 					Status = true;
 				}
 				else
 				{
 					if (SocketLock.Lock(_FL))
 					{
 						Socket.Reset(0);
 						SocketLock.Unlock();
 					}
 					LgiTrace("%s:%i - Failed auth.\n", _FL);
 				}
 			}
 			else
 				Error(_FL, "Failed to open socket to %s:%i and read reply.\n", Server, Port);
 		}
 		else Error(_FL, "No user/pass.\n");
 	}
 
 CleanUp:
 	DeleteArray(Apop);
 	DeleteArray(Server);
 
 	return Status;
 }
 
 bool MailPop3::MailIsEnd(LString &s)
 {
 	ssize_t Len = s.Length();
 	for (auto c = s.Get(); c && Len-- > 0; c++)
 	{
 		if (*c != *Marker)
 		{
 			Marker = End;
 		}
 
 		if (*c == *Marker)
 		{
 			Marker++;
 			if (!*Marker)
 			{
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 bool MailPop3::Receive(LArray<MailTransaction*> &Trans, MailCallbacks *Callbacks)
 {
 	bool Status = false;
 
 	if (Trans.Length() > 0 &&
 		Socket)
 	{
 		for (unsigned n = 0; n<Trans.Length(); n++)
 		{
 			int Message = Trans[n]->Index;
 			LStreamI *Msg = Trans[n]->Stream;
 			if (Msg)
 			{
 				int Size = 0;
 				
 				// Transfer is not null when the caller wants info on the bytes comming in
 				if (Transfer || Callbacks)
 				{
 					// get message size
 					sprintf_s(Buffer, sizeof(Buffer), "LIST %i\r\n", Message + 1);
 					VERIFY_RET_VAL(Write(0, true));
 					VERIFY_RET_VAL(ReadReply());
 
 					char *s = strchr(Buffer, ' ');
 					if (s)
 					{
 						s = strchr(s+1, ' ');
 						if (s)
 						{
 							Size = atoi(s);
 						}
 					}
 				}
 
 				MailSrcStatus Action = DownloadAll;
 				int TopLines = 100;
 
 				if (Callbacks && Callbacks->OnSrc)
 				{
 					Action = Callbacks->OnSrc(Trans[n], Size, &TopLines, Callbacks->CallbackData);
 				}
 
 				if (Action == DownloadAbort)
 				{
 					break;
 				}
 
 				if (Action == DownloadAll ||
 					Action == DownloadTop)
 				{
 					if (Action == DownloadAll)
 					{
 						sprintf_s(Buffer, sizeof(Buffer), "RETR %i\r\n", Message + 1);
 					}
 					else
 					{
 						sprintf_s(Buffer, sizeof(Buffer), "TOP %i %i\r\n", Message + 1, TopLines);
 					}
 					VERIFY_RET_VAL(Write(0, true));
 
 					LHtmlLinePrefix End(".\r\n");
 
 					if (Transfer)
 					{
 						Transfer->Value = 0;
 						Transfer->Range = Size;
 						Transfer->Start = LCurrentTime();
 					}
 
 					// Read status line
 					ZeroObj(Buffer);
 
 					ssize_t Used = 0;
 					bool Ok = false;
 					bool Finished = false;
 					int64 DataPos = 0;
 					while (Socket->IsOpen())
 					{
 						ssize_t r = Socket->Read(Buffer+Used, sizeof(Buffer)-Used-1, 0);
 						if (r > 0)
 						{
 							DeNullText(Buffer + Used, r);
 							
 							if (Transfer)
 							{
 								Transfer->Value += r;
 							}
 
 							char *Eol = strchr(Buffer, '\n');
 							if (Eol)
 							{
 								Eol++;
 								Ok = Buffer[0] == '+';
 								if (Ok)
 								{
 									// Log(Buffer, LSocketI::SocketMsgReceive);
 
 									// The Buffer was zero'd at the beginning garrenteeing
 									// NULL termination
 									size_t Len = strlen(Eol);
 									ssize_t EndPos = End.IsEnd(Eol, Len);
 									if (EndPos >= 0)
 									{
 										Msg->Write(Eol, EndPos - 3);
 										Status = Trans[n]->Status = true;
 										Finished = true;
 									}
 									else
 									{
 										Msg->Write(Eol, Len);
 										DataPos += Len;
 									}
 								}
 								else
 								{
 									Log(Buffer, LSocketI::SocketMsgError);
 									Finished = true;								
 								}
 								break;
 							}
 
 							Used += r;
 						}
 						else break;
 					}
 
 					if (!Finished)
 					{
 						if (Ok)
 						{
 							// Read rest of message
 							while (Socket->IsOpen())
 							{
 								ssize_t r = Socket->Read(Buffer, sizeof(Buffer), 0);
 								if (r > 0)
 								{
 									DeNullText(Buffer, r);
 									
 									if (Transfer)
 									{
 										Transfer->Value += r;
 									}
 
 									ssize_t EndPos = End.IsEnd(Buffer, r);
 									if (EndPos >= 0)
 									{
 										ssize_t Actual = EndPos - DataPos - 3;
 										if (Actual > 0)
 										{
 											#ifdef _DEBUG
 											ssize_t w =
 											#endif
 											Msg->Write(Buffer, Actual);
 											LAssert(w == Actual);
 										}
 										// else the end point was in the last buffer
 
 										Status = Trans[n]->Status = true;
 										break;
 									}
 									else
 									{
 										#ifdef _DEBUG
 										ssize_t w =
 										#endif
 										Msg->Write(Buffer, r);
 										LAssert(w == r);
 										DataPos += r;
 									}
 								}
 								else
 								{
 									break;
 								}
 							}
 							
 							if (!Status)
 							{
 								LgiTrace("%s:%i - Didn't get end-of-mail marker.\n", _FL);
 							}
 						}
 						else
 						{
 							LgiTrace("%s:%i - Didn't get Ok.\n", _FL);
 							break;
 						}
 					}
 
 					if (Callbacks && Callbacks->OnReceive)
 					{
 						Callbacks->OnReceive(Trans[n], Callbacks->CallbackData);
 					}
 
 					if (Transfer)
 					{
 						Transfer->Empty();
 					}
 				}
 				else
 				{
 					Trans[n]->Oversize = Status = true;
 				}
 
 				if (Items)
 				{
 					Items->Value++;
 				}
 			}
 			else
 			{
 				LgiTrace("%s:%i - No stream.\n", _FL);
 			}
 		}
 	}
 	else
 	{
 		LgiTrace("%s:%i - Arg check failed, len=%p, sock=%p.\n", _FL, Trans.Length(), Socket.Get());
 	}
 
 	return Status;
 }
 
 bool MailPop3::GetSizes(LArray<int64_t> &Sizes)
 {
 	if (!Socket)
 		return false;
 
 	strcpy_s(Buffer, sizeof(Buffer), (char*)"LIST\r\n");
 	VERIFY_RET_VAL(Write(0, true));
 
 	auto s = ReadMultiLineReply();
 	if (!s)
 		return false;
 
 	for (auto ln: s.SplitDelimit("\r\n"))
 	{
 		auto p = ln.SplitDelimit();
 		if (p.Length() > 1)
 			Sizes.Add((int)p.Last().Int());
 	}
 
 	return Sizes.Length() > 0;
 }
 
 int MailPop3::Sizeof(int Message)
 {
 	int Size = 0;
 	if (Socket)
 	{
 		sprintf_s(Buffer, sizeof(Buffer), "LIST %i\r\n", Message + 1);
 		VERIFY_RET_VAL(Write(0, true));
 		VERIFY_RET_VAL(ReadReply());
 
 		char *s = strchr(Buffer, ' ');
 		if (s)
 		{
 			s = strchr(s+1, ' ');
 			if (s)
 			{
 				Size = atoi(s);
 			}
 		}
 	}
 
 	return Size;
 }
 
 bool MailPop3::Delete(int Message)
 {
 	if (Socket)
 	{
 		sprintf_s(Buffer, sizeof(Buffer), "DELE %i\r\n", Message + 1);
 		VERIFY_RET_VAL(Write(0, true));
 		VERIFY_RET_VAL(ReadReply());
 
 		return true;
 	}
 
 	return false;
 }
 
 bool MailPop3::GetUid(int Index, char *Id, int IdLen)
 {
 	if (Socket && Id)
 	{
 		sprintf_s(Buffer, sizeof(Buffer), "UIDL %i\r\n", Index + 1);
 		VERIFY_RET_VAL(Write(0, true));
 		VERIFY_RET_VAL(ReadReply());
 
 		char *Space = strchr(Buffer, ' ');
 		if (Space)
 		{
 			Space = strchr(Space+1, ' ');
 			if (Space)
 			{
 				for (char *s = Space+1; *s; s++)
 				{
 					if (*s == '\r' || *s == '\n')
 					{
 						*s = 0;
 						break;
 					}
 				}
 				
 				strcpy_s(Id, IdLen, Space+1);
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 bool MailPop3::GetUidList(LString::Array &Id)
 {
 	if (!Socket)
 		return false;
 
 	sprintf_s(Buffer, sizeof(Buffer), "UIDL\r\n");
 	VERIFY_RET_VAL(Write(0, true));
 	auto Str = ReadMultiLineReply();
 	if (!Str)
 		return false;
 
 	auto lines = Str.SplitDelimit("\r\n");
 	for (auto s: lines)
 	{
 		if (s(0) != '.')
 		{
 			char *Space = strchr(s, ' ');
 			if (Space++)
 				Id.New() = Space;
 		}
 	}
 
 	return true;
 }
 
 LString MailPop3::GetHeaders(int Message)
 {
 	if (!Socket)
 		return NULL;
 
 	sprintf_s(Buffer, sizeof(Buffer), "TOP %i 0\r\n", Message + 1);
 	if (!Write(NULL, true))
 		return NULL;
 
 	return ReadMultiLineReply();
 }
 
 LString MailPop3::ReadMultiLineReply()
 {
 	if (!Socket)
 	{
 		LAssert(!"No socket.");
 		return false;
 	}
 
 	LString a;
 
 	do
 	{
 		auto s = Socket->Read();
 		if (!s)
 			break;
 
 		a += s;
 		if (!a || a[0] != '+')
 			return NULL;
 	}
 	while (!MailIsEnd(a));
 
 	// Strip off the first line...
 	auto FirstNewLen = a.Find("\n");
 	return FirstNewLen >= 0 ? a(FirstNewLen, -1) : NULL;
 }
 
 bool MailPop3::Close()
 {
 	if (Socket)
 	{
 		// logout
 		VERIFY_RET_VAL(Write("QUIT\r\n", true));
 		
 		// 2 sec timeout, we don't really care about the server's response
 		Socket->SetTimeout(2000);
 		ReadReply();
 
 		if (SocketLock.Lock(_FL))
 		{
 			Socket.Reset(0);
 			SocketLock.Unlock();
 		}
 		Messages = 0;
 		return true;
 	}
 	return false;
 }
diff --git a/src/common/Text/Html.cpp b/src/common/Text/Html.cpp
--- a/src/common/Text/Html.cpp
+++ b/src/common/Text/Html.cpp
@@ -1,9482 +1,9482 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <math.h>
 #include <cmath>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Html.h"
 #include "lgi/common/ScrollBar.h"
 #include "lgi/common/Variant.h"
 #include "lgi/common/FindReplaceDlg.h"
 #include "lgi/common/Unicode.h"
 #include "lgi/common/Emoji.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/GdcTools.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/Palette.h"
 #include "lgi/common/Path.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Net.h"
 #include "lgi/common/Base64.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/FindReplaceDlg.h"
 #include "lgi/common/Homoglyphs.h"
 #include "lgi/common/Charset.h"
 
 #include "HtmlPriv.h"
 
 #define DEBUG_TABLE_LAYOUT			1
 #define DEBUG_DRAW_TD				0
 #define DEBUG_RESTYLE				0
 #define DEBUG_TAG_BY_POS			0
 #define DEBUG_SELECTION				0
 #define DEBUG_TEXT_AREA				0
 
 #define ENABLE_IMAGE_RESIZING		1
 #define DOCUMENT_LOAD_IMAGES		1
 #define MAX_RECURSION_DEPTH			300
 #define ALLOW_TABLE_GROWTH			1
 #define LGI_HTML_MAXPAINT_TIME		350 // ms
 #define FLOAT_TOLERANCE				0.001
 
 #define CRASH_TRACE					0
 #ifdef MAC
 #define HTML_USE_DOUBLE_BUFFER		0
 #else
 #define HTML_USE_DOUBLE_BUFFER		1
 #endif
 #define GT_TRANSPARENT				0x00000000
 #ifndef IDC_HAND
 #define IDC_HAND					MAKEINTRESOURCE(32649)
 #endif
 
 #undef CellSpacing
 #define DefaultCellSpacing			0
 #define DefaultCellPadding			1
 
 #ifdef MAC
 #define MinimumPointSize			9
 #define MinimumBodyFontSize			12
 #else
 #define MinimumPointSize			8
 #define MinimumBodyFontSize			11
 #endif
 
 // #define DefaultFont					"font-family: Times; font-size: 16pt;"
 #define DefaultBodyMargin			"5px"
 #define DefaultImgSize				16
 #define DefaultMissingCellColour	GT_TRANSPARENT // Rgb32(0xf0,0xf0,0xf0)
 #define ShowNbsp					0
 
 #define FontPxHeight(fnt)			(fnt->GetHeight() - (int)(fnt->Leading() + 0.5))
 
 #if 0 // def _DEBUG
 #define DefaultTableBorder			Rgb32(0xf8, 0xf8, 0xf8)
 #else
 #define DefaultTableBorder			GT_TRANSPARENT
 #endif
 
 #if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 #define DEBUG_LOG(...)				if (Table->Debug) LgiTrace(__VA_ARGS__)
 #else
 #define DEBUG_LOG(...)
 #endif
 
 #define IsTableCell(id)				( ((id) == TAG_TD) || ((id) == TAG_TH) )
 #define IsTableTag()				(TagId == TAG_TABLE || TagId == TAG_TR || TagId == TAG_TD || TagId == TAG_TH)
 #define GetCssLen(a, b)				a().Type == LCss::LenInherit ? b() : a()
 
 static char WordDelim[]	=			".,<>/?[]{}()*&^%$#@!+|\'\"";
 static char16 WhiteW[] =			{' ', '\t', '\r', '\n', 0};
 
 #if 0
 static char DefaultCss[] = {
 "a				{ color: blue; text-decoration: underline; }"
 "body			{ margin: 8px; }"
 "strong			{ font-weight: bolder; }"
 "pre				{ font-family: monospace }"
 "h1				{ font-size: 2em; margin: .67em 0px; }"
 "h2				{ font-size: 1.5em; margin: .75em 0px; }"
 "h3				{ font-size: 1.17em; margin: .83em 0px; }"
 "h4, p,"
 "blockquote, ul,"
 "fieldset, form,"
 "ol, dl, dir,"
 "menu            { margin: 1.12em 0px; }"
 "h5              { font-size: .83em; margin: 1.5em 0px; }"
 "h6              { font-size: .75em; margin: 1.67em 0px; }"
 "strike, del		{ text-decoration: line-through; }"
 "hr              { border: 1px inset; }"
 "center          { text-align: center; }"
 "h1, h2, h3, h4,"
 "h5, h6, b,"
 "strong          { font-weight: bolder; }"
 };
 #endif
 
 template<typename T>
 void RemoveChars(T *str, T *remove_list)
 {
 	T *i = str, *o = str, *c;
 	while (*i)
 	{
 		for (c = remove_list; *c; c++)
 		{
 			if (*c == *i)
 				break;
 		}
 		if (*c == 0)
 			*o++ = *i;
 		i++;
 	}
 	*o++ = NULL;
 }
 
 //////////////////////////////////////////////////////////////////////
 using namespace Html1;
 
 namespace Html1
 {
 
 class LHtmlPrivate
 {
 public:
 	LHashTbl<ConstStrKey<char>, LTag*> Loading;
 	LHtmlStaticInst Inst;
 	bool CursorVis;
 	LRect CursorPos;
 	LPoint Content;
 	bool WordSelectMode;
 	bool LinkDoubleClick;
 	LAutoString OnLoadAnchor;
 	bool DecodeEmoji;
 	LAutoString EmojiImg;
 	int NextCtrlId;
 	uint64 SetScrollTime;
 	int DeferredLoads;
 
 	bool IsParsing;
 	bool IsLoaded;
 	bool StyleDirty;
 
 	// Paint time limits...
 	bool MaxPaintTimeout = false;
 	int MaxPaintTime = LGI_HTML_MAXPAINT_TIME;
 	
 	// Find settings
 	LAutoWString FindText;
 	bool MatchCase;
 	
 	LHtmlPrivate()
 	{
 		IsLoaded = false;
 		StyleDirty = false;
 		IsParsing = false;
 		LinkDoubleClick = true;
 		WordSelectMode = false;
 		NextCtrlId = 2000;
 		SetScrollTime = 0;
 		CursorVis = false;
 		CursorPos.ZOff(-1, -1);
 		DeferredLoads = 0;
 
 		char EmojiPng[MAX_PATH_LEN];
 		#ifdef MAC
 		LMakePath(EmojiPng, sizeof(EmojiPng), LGetExeFile(), "Contents/Resources/Emoji.png");
 		#else
 		LGetSystemPath(LSP_APP_INSTALL, EmojiPng, sizeof(EmojiPng));
 		LMakePath(EmojiPng, sizeof(EmojiPng), EmojiPng, "resources/emoji.png");
 		#endif
 		if (LFileExists(EmojiPng))
 		{
 			DecodeEmoji = true;
 			EmojiImg.Reset(NewStr(EmojiPng));
 		}
 		else
 			DecodeEmoji = false;
 	}
 
 	~LHtmlPrivate()
 	{
 	}
 };
 
 class InputButton : public LButton
 {
 	LTag *Tag;
 	
 public:
 	InputButton(LTag *tag, int Id, const char *Label) : LButton(Id, 0, 0, -1, -1, Label)
 	{
 		Tag = tag;
 	}
 	
 	void OnClick(const LMouse &m)
 	{
 		Tag->OnClick(m);
 	}
 };
 
 class LFontCache
 {
 	LHtml *Owner;
 	List<LFont> Fonts;
 
 public:
 	LFontCache(LHtml *owner)
 	{
 		Owner = owner;
 	}
 
 	~LFontCache()
 	{
 		Fonts.DeleteObjects();
 	}
 
 	LFont *FontAt(int i)
 	{
 		return Fonts.ItemAt(i);
 	}
 	
 	LFont *FindMatch(LFont *m)
 	{
 		for (auto f: Fonts)
 		{
 			if (*f == *m)
 			{
 				return f;
 			}
 		}
 		
 		return 0;
 	}
 
 	LFont *GetFont(LCss *Style)
 	{
 		if (!Style)
 			return NULL;
 		
 		LFont *Default = Owner->GetFont();
 		LCss::StringsDef Face = Style->FontFamily();
 		if (Face.Length() < 1 || !ValidStr(Face[0]))
 		{
 			Face.Empty();
 			const char *DefFace = Default->Face();
 			LAssert(ValidStr(DefFace));
 			Face.Add(NewStr(DefFace));
 		}
 		LAssert(ValidStr(Face[0]));
 		LCss::Len Size = Style->FontSize();
 		LCss::FontWeightType Weight = Style->FontWeight();
 		bool IsBold =	Weight == LCss::FontWeightBold ||
 						Weight == LCss::FontWeightBolder ||
 						Weight > LCss::FontWeight400;
 		bool IsItalic = Style->FontStyle() == LCss::FontStyleItalic;
 		bool IsUnderline = Style->TextDecoration() == LCss::TextDecorUnderline;
 
 		if (Size.Type == LCss::LenInherit ||
 			Size.Type == LCss::LenNormal)
 		{
 			Size.Type = LCss::LenPt;
 			Size.Value = (float)Default->PointSize();
 		}
 
 		auto Scale = Owner->GetDpiScale();
 		if (Size.Type == LCss::LenPx)
 		{
 			Size.Value *= (float) Scale.y;
 		    int RequestPx = (int) Size.Value;
 
 			// Look for cached fonts of the right size...
 			for (auto f: Fonts)
 			{
 				if (f->Face() &&
 					_stricmp(f->Face(), Face[0]) == 0 &&
 					f->Bold() == IsBold &&
 					f->Italic() == IsItalic &&
 					f->Underline() == IsUnderline)
 				{
 				    int Px = FontPxHeight(f);
 				    int Diff = Px - RequestPx;
 					if (Diff >= 0 && Diff <= 2)
 						return f;
 				}
 			}
 		}
 		else if (Size.Type == LCss::LenPt)
 		{
 			double Pt = Size.Value;
 			for (auto f: Fonts)
 			{
 				if (!f->Face() || Face.Length() == 0)
 				{
 					LAssert(0);
 					break;
 				}
 				
 				auto FntSz = f->Size();
 				if (f->Face() &&
 					_stricmp(f->Face(), Face[0]) == 0 &&
 					FntSz.Type == LCss::LenPt &&
 					std::abs(FntSz.Value - Pt) < FLOAT_TOLERANCE &&
 					f->Bold() == IsBold &&
 					f->Italic() == IsItalic &&
 					f->Underline() == IsUnderline)
 				{
 					// Return cached font
 					return f;
 				}
 			}
 		}
 		else if (Size.Type == LCss::LenPercent)
 		{
 			// Most of the percentages will be resolved in the "Apply" stage
 			// of the CSS calculations, any that appear here have no "font-size"
 			// in their parent tree, so we just use the default font size times
 			// the requested percent
 			Size.Type = LCss::LenPt;
 			Size.Value *= Default->PointSize() / 100.0f;
 			if (Size.Value < MinimumPointSize)
 				Size.Value = MinimumPointSize;
 		}
 		else if (Size.Type == LCss::LenEm)
 		{
 			// Most of the relative sizes will be resolved in the "Apply" stage
 			// of the CSS calculations, any that appear here have no "font-size"
 			// in their parent tree, so we just use the default font size times
 			// the requested percent
 			Size.Type = LCss::LenPt;
 			Size.Value *= Default->PointSize();
 			if (Size.Value < MinimumPointSize)
 				Size.Value = MinimumPointSize;
 		}
 		else if (Size.Type == LCss::SizeXXSmall ||
 				Size.Type == LCss::SizeXSmall ||
 				Size.Type == LCss::SizeSmall ||
 				Size.Type == LCss::SizeMedium ||
 				Size.Type == LCss::SizeLarge ||
 				Size.Type == LCss::SizeXLarge ||
 				Size.Type == LCss::SizeXXLarge)
 		{
 			int Idx = Size.Type-LCss::SizeXXSmall;
 			LAssert(Idx >= 0 && Idx < CountOf(LCss::FontSizeTable));
 			Size.Type = LCss::LenPt;
 			Size.Value = Default->PointSize() * LCss::FontSizeTable[Idx];
 			if (Size.Value < MinimumPointSize)
 				Size.Value = MinimumPointSize;
 		}
 		else if (Size.Type == LCss::SizeSmaller)
 		{
 			Size.Type = LCss::LenPt;
 			Size.Value = (float)(Default->PointSize() - 1);
 		}
 		else if (Size.Type == LCss::SizeLarger)
 		{
 			Size.Type = LCss::LenPt;
 			Size.Value = (float)(Default->PointSize() + 1);
 		}
 		else LAssert(!"Not impl.");
 
 		LFont *f;
 		if ((f = new LFont))
 		{
 			auto ff = ValidStr(Face[0]) ? Face[0] : Default->Face();
 			f->Face(ff);
 			f->Size(Size.IsValid() ? Size : Default->Size());
 			f->Bold(IsBold);
 			f->Italic(IsItalic);
 			f->Underline(IsUnderline);
 			
 			// printf("Add cache font %s,%i %i,%i,%i\n", f->Face(), f->PointSize(), f->Bold(), f->Italic(), f->Underline());
 			if (std::abs(Size.Value) < FLOAT_TOLERANCE)
 				;
 			else if (!f->Create((char*)0, 0))
 			{
 				// Broken font...
 				f->Face(Default->Face());
 				LFont *DefMatch = FindMatch(f);
 				// printf("Falling back to default face for '%s:%i', DefMatch=%p\n", ff, f->PointSize(), DefMatch);
 				if (DefMatch)
 				{
 					DeleteObj(f);
 					return DefMatch;
 				}
 				else
 				{
 					if (!f->Create((char*)0, 0))
 					{
 						DeleteObj(f);
 						return Fonts[0];
 					}
 				}
 			}
 
 			// Not already cached
 			Fonts.Insert(f);
 			if (!f->Face())
 			{
 				LAssert(0);
 			}
 			
 			return f;
 		}
 
 		return 0;
 	}
 };
 
 class LFlowRegion
 {
 	LCss::LengthType Align = LCss::LenInherit;
 	List<LFlowRect> Line;	// These pointers aren't owned by the flow region
 							// When the line is finish, all the tag regions
 							// will need to be vertically aligned
 
 	struct LFlowStack
 	{
 		int LeftAbs;
 		int RightAbs;
 		int TopAbs;
 	};
 	LArray<LFlowStack> Stack;
 
 public:
 	LHtml *Html;
 	int x1, x2;					// Left and right margins
 	int y1;						// Current y position
 	int y2;						// Maximum used y position
 	int cx;						// Current insertion point
 	int my;						// How much of the area above y2 was just margin
 	LPoint MAX;					// Max dimensions
 	int Inline;
 	int InBody;
 
 	LFlowRegion(LHtml *html, bool inbody)
 	{
 		Html = html;
 		x1 = x2 = y1 = y2 = cx = my = 0;
 		Inline = 0;
 		InBody = inbody;
 	}
 
 	LFlowRegion(LHtml *html, LRect r, bool inbody)
 	{
 		Html = html;
 		MAX.x = cx = x1 = r.x1;
 		MAX.y = y1 = y2 = r.y1;
 		x2 = r.x2;
 		my = 0;
 		Inline = 0;
 		InBody = inbody;
 	}
 
 	LFlowRegion(LFlowRegion &r)
 	{
 		Html = r.Html;
 		x1 = r.x1;
 		x2 = r.x2;
 		y1 = r.y1;
 		MAX.x = cx = r.cx;
 		MAX.y = y2 = r.y2;
 		my = r.my;
 		Inline = r.Inline;
 		InBody = r.InBody; 
 	}
 
 	LString ToString()
 	{
 		LString s;
 		s.Printf("Flow: x=%i(%i)%i y=%i,%i my=%i inline=%i",
 			x1, cx, x2,
 			y1, y2, my,
 			Inline);
 		return s;
 	}
 
 	int X()
 	{
 		return x2 - cx;
 	}
 
 	void X(int newx)
 	{
 		x2 = x1 + newx - 1;
 	}
 
 	int Width()
 	{
 		return x2 - x1 + 1;
 	}
 
 	LFlowRegion &operator +=(LRect r)
 	{
 		x1 += r.x1;
 		cx += r.x1;
 		x2 -= r.x2;
 		y1 += r.y1;
 		y2 += r.y1;
 		
 		return *this;
 	}
 
 	LFlowRegion &operator -=(LRect r)
 	{
 		x1 -= r.x1;
 		cx -= r.x1;
 		x2 += r.x2;
 		y1 += r.y2;
 		y2 += r.y2;
 	
 		return *this;
 	}
 	
 	void AlignText();
 	void FinishLine(bool Margin = false);
 	void EndBlock();
 	void Insert(LFlowRect *Tr, LCss::LengthType Align);
 	LRect *LineBounds();
 
 	void Indent(LTag *Tag,
 				LCss::Len Left,
 				LCss::Len Top,
 				LCss::Len Right,
 				LCss::Len Bottom,
 				bool IsMargin)
 	{
 		LFlowRegion This(*this);
 		LFlowStack &Fs = Stack.New();
 
 		Fs.LeftAbs = Left.IsValid() ? ResolveX(Left, Tag, IsMargin) : 0;
 		Fs.RightAbs = Right.IsValid() ? ResolveX(Right, Tag, IsMargin) : 0;
 		Fs.TopAbs = Top.IsValid() ? ResolveY(Top, Tag, IsMargin) : 0;
 
 		x1 += Fs.LeftAbs;
 		cx += Fs.LeftAbs;
 		x2 -= Fs.RightAbs;
 		y1 += Fs.TopAbs;
 		y2 += Fs.TopAbs;
 		if (IsMargin)
 			my += Fs.TopAbs;
 	}
 
 	void Indent(LRect &Px,
 				bool IsMargin)
 	{
 		LFlowRegion This(*this);
 		LFlowStack &Fs = Stack.New();
 
 		Fs.LeftAbs = Px.x1;
 		Fs.RightAbs = Px.x2;
 		Fs.TopAbs = Px.y1;
 
 		x1 += Fs.LeftAbs;
 		cx += Fs.LeftAbs;
 		x2 -= Fs.RightAbs;
 		y1 += Fs.TopAbs;
 		y2 += Fs.TopAbs;
 		
 		if (IsMargin)
 			my += Fs.TopAbs;
 	}
 
 	void Outdent(LRect &Px,
 				bool IsMargin)
 	{
 		LFlowRegion This = *this;
 
 		ssize_t len = Stack.Length();
 		if (len > 0)
 		{
 			LFlowStack &Fs = Stack[len-1];
 
 			int &BottomAbs = Px.y2;
 
 			x1 -= Fs.LeftAbs;
 			cx -= Fs.LeftAbs;
 			x2 += Fs.RightAbs;
 			y2 += BottomAbs;
 			if (IsMargin)
 				my += BottomAbs;
 
 			Stack.Length(len-1);
 		}
 		else LAssert(!"Nothing to pop.");
 	}
 
 	void Outdent(LTag *Tag,
 				LCss::Len Left,
 				LCss::Len Top,
 				LCss::Len Right,
 				LCss::Len Bottom,
 				bool IsMargin)
 	{
 		LFlowRegion This = *this;
 
 		ssize_t len = Stack.Length();
 		if (len > 0)
 		{
 			LFlowStack &Fs = Stack[len-1];
 
 			int BottomAbs = Bottom.IsValid() ? ResolveY(Bottom, Tag, IsMargin) : 0;
 
 			x1 -= Fs.LeftAbs;
 			cx -= Fs.LeftAbs;
 			x2 += Fs.RightAbs;
 			y2 += BottomAbs;
 			if (IsMargin)
 				my += BottomAbs;
 
 			Stack.Length(len-1);
 		}
 		else LAssert(!"Nothing to pop.");
 	}
 
 	int ResolveX(LCss::Len l, LTag *t, bool IsMargin)
 	{
 		LFont *f = t->GetFont();
 		switch (l.Type)
 		{
 			default:
 			case LCss::LenInherit:
 				return IsMargin ? 0 : X();
 			case LCss::LenPx:
 				// return MIN((int)l.Value, X());
 				return (int)l.Value;
 			case LCss::LenPt:
 				return (int) (l.Value * LScreenDpi().x / 72.0);
 			case LCss::LenCm:
 				return (int) (l.Value * LScreenDpi().x / 2.54);
 			case LCss::LenEm:
 			{
 				if (!f)
 				{
 					LAssert(!"No font?");
 					f = LSysFont;
 				}
 				return (int)(l.Value * f->GetHeight());
 			}
 			case LCss::LenEx:
 			{
 				if (!f)
 				{
 					LAssert(!"No font?");
 					f = LSysFont;
 				}
 				return (int) (l.Value * f->GetHeight() / 2); // More haha, who uses 'ex' anyway?
 			}
 			case LCss::LenPercent:
 			{
 				int my_x = X();
 				int px = (int) (l.Value * my_x / 100.0);
 				return px;
 			}
 			case LCss::LenAuto:
 			{
 				if (IsMargin)
 					return 0;
 				else
 					return X();
 				break;
 			}
 			case LCss::SizeSmall:
 			{
 				return 1; // px
 			}
 			case LCss::SizeMedium:
 			{
 				return 2; // px
 			}
 			case LCss::SizeLarge:
 			{
 				return 3; // px
 			}
 		}
 
 		return 0;
 	}
 	
 	bool LimitX(int &x, LCss::Len Min, LCss::Len Max, LFont *f)
 	{
 		bool Limited = false;
 		if (Min.IsValid())
 		{
 			int Px = Min.ToPx(x2 - x1 + 1, f, false);
 			if (Px > x)
 			{
 				x = Px;
 				Limited = true;
 			}
 		}
 		if (Max.IsValid())
 		{
 			int Px = Max.ToPx(x2 - x1 + 1, f, false);
 			if (Px < x)
 			{
 				x = Px;
 				Limited = true;
 			}
 		}
 		return Limited;
 	}
 
 	int ResolveY(LCss::Len l, LTag *t, bool IsMargin)
 	{
 		LFont *f = t->GetFont();
 		switch (l.Type)
 		{
 			case LCss::LenInherit:
 			case LCss::LenAuto:
 			case LCss::LenNormal:
 			case LCss::LenPx:
 				return (int)l.Value;
 			case LCss::LenPt:
 				return (int) (l.Value * LScreenDpi().y / 72.0);
 			case LCss::LenCm:
 				return (int) (l.Value * LScreenDpi().y / 2.54);
 
 			case LCss::LenEm:
 			{
 				if (!f)
 				{
 					f = LSysFont;
 					LAssert(!"No font");
 				}
 				return (int) (l.Value * f->GetHeight());
 			}
 			case LCss::LenEx:
 			{
 				if (!f)
 				{
 					f = LSysFont;
 					LAssert(!"No font");
 				}
 				return (int) (l.Value * f->GetHeight() / 2); // More haha, who uses 'ex' anyway?
 			}
 			case LCss::LenPercent:
 			{
 				// Walk up tree of tags to find an absolute size...
 				LCss::Len Ab;
 				for (LTag *p = ToTag(t->Parent); p; p = ToTag(p->Parent))
 				{
 					auto h = p->Height();
 					if (h.IsValid() && !h.IsDynamic())
 					{
 						Ab = h;
 						break;
 					}
 				}
 
 				if (!Ab.IsValid())
 				{
 					LAssert(Html != NULL);
 					Ab.Type = LCss::LenPx;
 					Ab.Value = (float)Html->Y();
 				}
 
 				LCss::Len m = Ab * l;
 				
 				return (int)m.ToPx(0, f);;
 			}
 			case LCss::SizeSmall:
 			{
 				return 1; // px
 			}
 			case LCss::SizeMedium:
 			{
 				return 2; // px
 			}
 			case LCss::SizeLarge:
 			{
 				return 3; // px
 			}
 			case LCss::AlignLeft:
 			case LCss::AlignRight:
 			case LCss::AlignCenter:
 			case LCss::AlignJustify:
 			case LCss::VerticalBaseline:
 			case LCss::VerticalSub:
 			case LCss::VerticalSuper:
 			case LCss::VerticalTop:
 			case LCss::VerticalTextTop:
 			case LCss::VerticalMiddle:
 			case LCss::VerticalBottom:
 			case LCss::VerticalTextBottom:
 			{
 				// Meaningless in this context
 				break;
 			}
 			default:
 			{
 				LAssert(!"Not supported.");
 				break;
 			}
 		}
 
 		return 0;
 	}
 
 	bool LimitY(int &y, LCss::Len Min, LCss::Len Max, LFont *f)
 	{
 		bool Limited = false;
 		int TotalY = Html ? Html->Y() : 0;
 		if (Min.IsValid())
 		{
 			int Px = Min.ToPx(TotalY, f, false);
 			if (Px > y)
 			{
 				y = Px;
 				Limited = true;
 			}
 		}
 		if (Max.IsValid())
 		{
 			int Px = Max.ToPx(TotalY, f, false);
 			if (Px < y)
 			{
 				y = Px;
 				Limited = true;
 			}
 		}
 		return Limited;
 	}
 
 	LRect ResolveMargin(LCss *Src, LTag *Tag)
 	{
 		LRect r;
 		r.x1 = ResolveX(Src->MarginLeft(), Tag, true);
 		r.y1 = ResolveY(Src->MarginTop(), Tag, true);
 		r.x2 = ResolveX(Src->MarginRight(), Tag, true);
 		r.y2 = ResolveY(Src->MarginBottom(), Tag, true);
 		return r;
 	}
 
 	LRect ResolveBorder(LCss *Src, LTag *Tag)
 	{
 		LRect r;
 		r.x1 = ResolveX(Src->BorderLeft(), Tag, true);
 		r.y1 = ResolveY(Src->BorderTop(), Tag, true);
 		r.x2 = ResolveX(Src->BorderRight(), Tag, true);
 		r.y2 = ResolveY(Src->BorderBottom(), Tag, true);
 		return r;
 	}
 
 	LRect ResolvePadding(LCss *Src, LTag *Tag)
 	{
 		LRect r;
 		r.x1 = ResolveX(Src->PaddingLeft(), Tag, true);
 		r.y1 = ResolveY(Src->PaddingTop(), Tag, true);
 		r.x2 = ResolveX(Src->PaddingRight(), Tag, true);
 		r.y2 = ResolveY(Src->PaddingBottom(), Tag, true);
 		return r;
 	}
 };
 
 };
 
 //////////////////////////////////////////////////////////////////////
 static bool ParseDistance(char *s, float &d, char *units = 0)
 {
 	if (!s)
 		return false;
 
 	while (*s && IsWhiteSpace(*s)) s++;
 
 	if (!IsDigit(*s) && !strchr("-.", *s))
 		return false;
 
 	d = (float)atof(s);
 
 	while (*s && (IsDigit(*s) || strchr("-.", *s))) s++;
 	while (*s && IsWhiteSpace(*s)) s++;
 	
 	char _units[128];
 	char *o = units = units ? units : _units;
 	while (*s && (IsAlpha(*s) || *s == '%'))
 	{
 		*o++ = *s++;
 	}
 	*o++ = 0;
 
 	return true;
 }
 
 LHtmlLength::LHtmlLength()
 {
 	d = 0;
 	PrevAbs = 0;
 	u = LCss::LenInherit;
 }
 
 LHtmlLength::LHtmlLength(char *s)
 {
 	Set(s);
 }
 
 bool LHtmlLength::IsValid()
 {
 	return u != LCss::LenInherit;
 }
 
 bool LHtmlLength::IsDynamic()
 {
 	return u == LCss::LenPercent || d == 0.0;
 }
 
 LHtmlLength::operator float ()
 {
 	return d;
 }
 
 LHtmlLength &LHtmlLength::operator =(float val)
 {
 	d = val;
 	u = LCss::LenPx;
 	return *this;
 }
 
 LCss::LengthType LHtmlLength::GetUnits()
 {
 	return u;
 }
 
 void LHtmlLength::Set(char *s)
 {
 	if (ValidStr(s))
 	{
 		char Units[256] = "";
 		if (ParseDistance(s, d, Units))
 		{
 			if (Units[0])
 			{
 				if (strchr(Units, '%'))
 				{
 					u = LCss::LenPercent;
 				}
 				else if (stristr(Units, "pt"))
 				{
 					u = LCss::LenPt;
 				}
 				else if (stristr(Units, "em"))
 				{
 					u = LCss::LenEm;
 				}
 				else if (stristr(Units, "ex"))
 				{
 					u = LCss::LenEx;
 				}
 				else
 				{
 					u = LCss::LenPx;
 				}
 			}
 			else
 			{
 				u = LCss::LenPx;
 			}
 		}
 	}
 }
 
 float LHtmlLength::Get(LFlowRegion *Flow, LFont *Font, bool Lock)
 {
 	switch (u)
 	{
 		default: break;
 		case LCss::LenEm:
 		{
 			return PrevAbs = d * (Font ? Font->GetHeight() : 14);
 			break;
 		}
 		case LCss::LenEx:
 		{
 			return PrevAbs = (Font ? Font->GetHeight() * d : 14) / 2;
 			break;
 		}
 		case LCss::LenPercent:
 		{
 			if (Lock || PrevAbs == 0.0)
 			{
 				return PrevAbs = (Flow->X() * d / 100);
 			}
 			else
 			{
 				return PrevAbs;
 			}
 			break;
 		}
 	}
 
 	float FlowX = Flow ? Flow->X() : d;
 	return PrevAbs = MIN(FlowX, d);
 }
 
 LHtmlLine::LHtmlLine()
 {
 	LineStyle = -1;
 	LineReset = 0x80000000;
 }
 
 LHtmlLine::~LHtmlLine()
 {
 }
 
 LHtmlLine &LHtmlLine::operator =(int i)
 {
 	d = (float)i;
 	return *this;
 }
 
 void LHtmlLine::Set(char *s)
 {
 	LToken t(s, " \t");
 	LineReset = 0x80000000;
 	LineStyle = -1;
 	char *Style = 0;
 
 	for (unsigned i=0; i<t.Length(); i++)
 	{
 		char *c = t[i];
 		if
 		(
 			*c == '#'
 			||
 			LHtmlStatic::Inst->ColourMap.Find(c)
 		)
 		{
 			LHtmlParser::ParseColour(c, Colour);
 		}
 		else if (_strnicmp(c, "rgb(", 4) == 0)
 		{
 			char Buf[256];
 			strcpy_s(Buf, sizeof(Buf), c);
 			while (!strchr(c, ')') &&
 					(c = t[++i]))
 			{
 				strcat(Buf, c);
 			}
 			LHtmlParser::ParseColour(Buf, Colour);
 		}
 		else if (IsDigit(*c))
 		{
 			LHtmlLength::Set(c);
 		}
 		else if (_stricmp(c, "none") == 0)
 		{
 			Style = 0;
 		}
 		else if (	_stricmp(c, "dotted") == 0 ||
 					_stricmp(c, "dashed") == 0 ||
 					_stricmp(c, "solid") == 0 ||
 					_stricmp(c, "float") == 0 ||
 					_stricmp(c, "groove") == 0 ||
 					_stricmp(c, "ridge") == 0 ||
 					_stricmp(c, "inset") == 0 ||
 					_stricmp(c, "outse") == 0)
 		{
 			Style = c;
 		}
 		else
 		{
 			// ???
 		}
 	}
 
 	if (Style && _stricmp(Style, "dotted") == 0)
 	{
 		switch ((int)d)
 		{
 			case 2:
 			{
 				LineStyle = 0xcccccccc;
 				break;
 			}
 			case 3:
 			{
 				LineStyle = 0xe38e38;
 				LineReset = 0x800000;
 				break;
 			}
 			case 4:
 			{
 				LineStyle = 0xf0f0f0f0;
 				break;
 			}
 			case 5:
 			{
 				LineStyle = 0xf83e0;
 				LineReset = 0x80000;
 				break;
 			}
 			case 6:
 			{
 				LineStyle = 0xfc0fc0;
 				LineReset = 0x800000;
 				break;
 			}
 			case 7:
 			{
 				LineStyle = 0xfe03f80;
 				LineReset = 0x8000000;
 				break;
 			}
 			case 8:
 			{
 				LineStyle = 0xff00ff00;
 				break;
 			}
 			case 9:
 			{
 				LineStyle = 0x3fe00;
 				LineReset = 0x20000;
 				break;
 			}
 			default:
 			{
 				LineStyle = 0xaaaaaaaa;
 				break;
 			}
 		}
 	}
 }
 
 //////////////////////////////////////////////////////////////////////
 LRect LTag::GetRect(bool Client)
 {
 	LRect r(Pos.x, Pos.y, Pos.x + Size.x - 1, Pos.y + Size.y - 1);
 	if (!Client)
 	{
 		for (LTag *p = ToTag(Parent); p; p=ToTag(p->Parent))
 		{
 			r.Offset(p->Pos.x, p->Pos.y);
 		}
 	}
 	return r;
 }
 
 LCss::LengthType LTag::GetAlign(bool x)
 {
 	for (LTag *t = this; t; t = ToTag(t->Parent))
 	{
 		LCss::Len l;
 		
 		if (x)
 		{
 			if (IsTableCell(TagId) && Cell && Cell->XAlign)
 				l.Type = Cell->XAlign;
 			else
 				l = t->TextAlign();
 		}
 		else
 		{
 			l = t->VerticalAlign();
 		}
 		
 		if (l.Type != LenInherit)
 		{
 			return l.Type;
 		}
 
 		if (t->TagId == TAG_TABLE)
 			break;
 	}
 	
 	return LenInherit;
 }
 
 //////////////////////////////////////////////////////////////////////
 void LFlowRegion::EndBlock()
 {
 	if (cx > x1)
 		FinishLine();
 }
 
 void LFlowRegion::AlignText()
 {
 	if (Align != LCss::AlignLeft)
 	{
 		int Used = 0;
 		for (auto l : Line)
 			Used += l->X();
 		int Total = x2 - x1 + 1;
 		if (Used < Total)
 		{
 			int Offset = 0;
 			if (Align == LCss::AlignCenter)
 				Offset = (Total - Used) / 2;
 			else if (Align == LCss::AlignRight)
 				Offset = Total - Used;
 			if (Offset)
 				for (auto l : Line)
 				{
 					if (l->Tag->Display() != LCss::DispInlineBlock)
 						l->Offset(Offset, 0);
 				}
 		}
 	}
 }
 
 void LFlowRegion::FinishLine(bool Margin)
 {
 	// AlignText();
 
 	if (y2 > y1)
 	{
 		my = Margin ? y2 - y1 : 0;
 		y1 = y2;
 	}
 	else
 	{
 		int fy = Html->DefFont()->GetHeight();
 		my = Margin ? fy : 0;
 		y1 += fy;
 	}
 	cx = x1;
 	y2 = y1;
 
 	Line.Empty();
 }
 
 LRect *LFlowRegion::LineBounds()
 {
 	auto It = Line.begin();
 	LFlowRect *Prev = *It;
 	LFlowRect *r=Prev;
 	if (r)
 	{
 		LRect b;
 		
 		b = *r;
 		int Ox = r->Tag->AbsX();
 		int Oy = r->Tag->AbsY();
 		b.Offset(Ox, Oy);
 
 		// int Ox = 0, Oy = 0;
 		while ((r = *(++It) ))
 		{
 			LRect c = *r;
 			Ox = r->Tag->AbsX();
 			Oy = r->Tag->AbsY();
 			c.Offset(Ox, Oy);
 
 			/*
 			Ox += r->Tag->Pos.x - Prev->Tag->Pos.x;
 			Oy += r->Tag->Pos.y - Prev->Tag->Pos.y;
 			c.Offset(Ox, Oy);
 			*/
 
 			b.Union(&c);
 			Prev = r;
 		}
 
 		static LRect Rgn;
 		Rgn = b;
 		return &Rgn;
 	}
 
 	return 0;
 }
 
 void LFlowRegion::Insert(LFlowRect *Tr, LCss::LengthType align)
 {
 	if (Tr)
 	{
 		Align = align;
 		Line.Insert(Tr);
 	}
 }
 
 //////////////////////////////////////////////////////////////////////
 LTag::LTag(LHtml *h, LHtmlElement *p) :
 	LHtmlElement(p),
 	Attr(8)
 {
 	Ctrl = 0;
 	CtrlType = CtrlNone;
 	TipId = 0;
 	Display(DispInline);
 	Html = h;
 	
 	ImageResized = false;
 	Cursor = -1;
 	Selection = -1;
 	Font = 0;
 	LineHeightCache = -1;
 	HtmlId = NULL;
 	// TableBorder = 0;
 	Cell = NULL;
 	TagId = CONTENT;
 	Info = 0;
 	Pos.x = Pos.y = 0;
 
 	#ifdef _DEBUG
 	Debug = false;
 	#endif
 }
 
 LTag::~LTag()
 {
 	if (Html->Cursor == this)
 	{
 		Html->Cursor = 0;
 	}
 	if (Html->Selection == this)
 	{
 		Html->Selection = 0;
 	}
 
 	DeleteObj(Ctrl);
 	Attr.DeleteArrays();
 
 	DeleteObj(Cell);
 }
 
 void LTag::OnChange(PropType Prop)
 {
 }
 
 bool LTag::OnClick(const LMouse &m)
 {
 	if (!Html->Environment)
 		return false;
 
 	const char *OnClick = NULL;
 	if (Get("onclick", OnClick))
 	{
 		Html->Environment->OnExecuteScript(Html, (char*)OnClick);
 	}
 	else
 	{
 		OnNotify(LNotification(m));
 	}
 
 	return true;
 }
 
 void LTag::Set(const char *attr, const char *val)
 {
 	char *existing = Attr.Find(attr);
 	if (existing) DeleteArray(existing);
 
 	if (val)
 		Attr.Add(attr, NewStr(val));
 }
 
 bool LTag::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	LDomProperty Fld = LStringToDomProp(Name);
 	switch (Fld)
 	{
 		case ObjStyle: // Type: LCssStyle
 		{
 			Value = &StyleDom;
 			return true;
 		}
 		case ObjTextContent: // Type: String
 		{
 			Value = Text();
 			return true;
 		}
 		default:
 		{
 			char *a = Attr.Find(Name);
 			if (a)
 			{
 				Value = a;
 				return true;
 			}
 			break;
 		}
 	}
 	
 	return false;
 }
 
 bool LTag::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	LDomProperty Fld = LStringToDomProp(Name);
 	switch (Fld)
 	{
 		case ObjStyle:
 		{
 			const char *Defs = Value.Str();
 			if (!Defs)
 				return false;
 				
 			return Parse(Defs, ParseRelaxed);
 		}
 		case ObjTextContent:
 		{
 			const char *s = Value.Str();
 			if (s)
 			{
 				LAutoWString w(CleanText(s, strlen(s), "utf-8", true, true));
 				Txt = w;
 				return true;
 			}
 			break;
 		}
 		case ObjInnerHtml: // Type: String
 		{
 			// Clear out existing tags..
 			Children.DeleteObjects();
 		
 			char *Doc = Value.CastString();
 			if (Doc)
 			{
 				// Create new tags...
 				bool BackOut = false;
 				
 				while (Doc && *Doc)
 				{
 					LTag *t = new LTag(Html, this);
 					if (t)
 					{
 						Doc = Html->ParseHtml(t, Doc, 1, false, &BackOut);
 						if (!Doc)
 							break;
 					}
 					else break;
 				}
 			}
 			else return false;
 			break;
 		}
 		default:
 		{
 			Set(Name, Value.CastString());
 			SetStyle();
 			break;
 		}
 	}
 
 	Html->ViewWidth = -1;
 	return true;
 }
 
 ssize_t LTag::GetTextStart()
 {
 	if (PreText() && TextPos.Length() > 1)
 	{
 		LFlowRect *t = TextPos[1];
 		if (t)
 			return t->Text - Text();
 	}
 	else if (TextPos.Length() > 0)
 	{
 		LFlowRect *t = TextPos[0];
 		if (t && Text())
 		{
 			LAssert(t->Text >= Text() && t->Text <= Text()+2);
 			return t->Text - Text();
 		}
 	}
 
 	return 0;
 }
 
 static bool TextToStream(LStream &Out, char16 *Text)
 {
 	if (!Text)
 		return true;
 
 	uint8_t Buf[256];
 	uint8_t *s = Buf;
 	ssize_t Len = sizeof(Buf);
 	while (*Text)
 	{
 		#define WriteExistingContent() \
 			if (s > Buf) \
 				Out.Write(Buf, (int)(s - Buf)); \
 			s = Buf; \
 			Len = sizeof(Buf); \
 			Buf[0] = 0;
 
 		if (*Text == '<' || *Text == '>')
 		{
 			WriteExistingContent();
 			Out.Print("&%ct;", *Text == '<' ? 'l' : 'g');
 		}
 		else if (*Text == 0xa0)
 		{
 			WriteExistingContent();
 			Out.Write((char*)"&nbsp;", 6);
 		}
 		else
 		{
 			LgiUtf32To8(*Text, s, Len);
 			if (Len < 16)
 			{
 				WriteExistingContent();
 			}
 		}
 
 		Text++;
 	}
 
 	if (s > Buf)
 		Out.Write(Buf, s - Buf);
 
 	return true;
 }
 
 bool LTag::CreateSource(LStringPipe &p, int Depth, bool LastWasBlock)
 {
 	char *Tabs = new char[Depth+1];
 	memset(Tabs, '\t', Depth);
 	Tabs[Depth] = 0;
 
 	if (ValidStr(Tag))
 	{
 		if (IsBlock())
 		{
 			p.Print("%s%s<%s", TagId != TAG_HTML ? "\n" : "", Tabs, Tag.Get());
 		}
 		else
 		{
 			p.Print("<%s", Tag.Get());
 		}
 
 		if (Attr.Length())
 		{
 			// const char *a;
 			// for (char *v = Attr.First(&a); v; v = Attr.Next(&a))
 			for (auto v : Attr)
 			{
 				if (_stricmp(v.key, "style"))
 					p.Print(" %s=\"%s\"", v.key, v.value);
 			}
 		}
 		if (Props.Length())
 		{
 			LCss *Css = this;
 			LCss Tmp;
 			#define DelProp(p) \
 				if (Css == this) { Tmp = *Css; Css = &Tmp; } \
 				Css->DeleteProp(p);
 			
 			// Clean out any default CSS properties where we can...
 			LHtmlElemInfo *i = LHtmlStatic::Inst->GetTagInfo(Tag);
 			if (i)
 			{
 				if (Props.Find(PropDisplay)
 					&&
 					(
 						(!i->Block() && Display() == DispInline)
 						||
 						(i->Block() && Display() == DispBlock)
 					))
 				{
 					DelProp(PropDisplay);
 				}
 				switch (TagId)
 				{
 					default:
 						break;
 					case TAG_A:
 					{
 						LCss::ColorDef Blue(LCss::ColorRgb, Rgb32(0, 0, 255));
 						if (Props.Find(PropColor) && Color() == Blue)
 							DelProp(PropColor);
 						if (Props.Find(PropTextDecoration) && TextDecoration() == LCss::TextDecorUnderline)
 							DelProp(PropTextDecoration)
 						break;
 					}
 					case TAG_BODY:
 					{
 						LCss::Len FivePx(LCss::LenPx, 5.0f);
 						if (Props.Find(PropPaddingLeft) && PaddingLeft() == FivePx)
 							DelProp(PropPaddingLeft)
 						if (Props.Find(PropPaddingTop) && PaddingTop() == FivePx)
 							DelProp(PropPaddingTop)
 						if (Props.Find(PropPaddingRight) && PaddingRight() == FivePx)
 							DelProp(PropPaddingRight)
 						break;
 					}
 					case TAG_B:
 					{
 						if (Props.Find(PropFontWeight) && FontWeight() == LCss::FontWeightBold)
 							DelProp(PropFontWeight);
 						break;
 					}
 					case TAG_U:
 					{
 						if (Props.Find(PropTextDecoration) && TextDecoration() == LCss::TextDecorUnderline)
 							DelProp(PropTextDecoration);
 						break;
 					}
 					case TAG_I:
 					{
 						if (Props.Find(PropFontStyle) && FontStyle() == LCss::FontStyleItalic)
 							DelProp(PropFontStyle);
 						break;
 					}
 				}
 			}
 			
 			// Convert CSS props to a string and emit them...
 			auto s = Css->ToString();
 			if (ValidStr(s))
 			{			
 				// Clean off any trailing whitespace...
 				char *e = s ? s + strlen(s) : NULL;
 				while (e && strchr(WhiteSpace, e[-1]))
 					*--e = 0;
 				
 				// Print them to the tags attributes...
 				p.Print(" style=\"%s\"", s.Get());
 			}
 		}
 	}
 
 	if (Children.Length() || TagId == TAG_STYLE) // <style> tags always have </style>
 	{
 		if (Tag)
 		{
 			p.Write((char*)">", 1);
 			TextToStream(p, Text());
 		}
 
 		bool Last = IsBlock();
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			LTag *c = ToTag(Children[i]);
 			c->CreateSource(p, Parent ? Depth+1 : 0, Last);
 			Last = c->IsBlock();
 		}
 
 		if (Tag)
 		{
 			if (IsBlock())
 			{
 				if (Children.Length())
 					p.Print("\n%s", Tabs);
 			}
 
 			p.Print("</%s>", Tag.Get());
 		}
 	}
 	else if (Tag)
 	{
 		if (Text())
 		{
 			p.Write((char*)">", 1);
 			TextToStream(p, Text());
 			p.Print("</%s>", Tag.Get());
 		}
 		else
 		{
 			p.Print("/>\n");
 		}
 	}
 	else
 	{
 		TextToStream(p, Text());
 	}
 
 	DeleteArray(Tabs);
 
 	return true;
 }
 
 void LTag::SetTag(const char *NewTag)
 {
 	Tag.Reset(NewStr(NewTag));
 
 	if (NewTag)
 	{
 		Info = Html->GetTagInfo(Tag);
 		if (Info)
 		{
 			TagId = Info->Id;
 			Display(Info->Flags & LHtmlElemInfo::TI_BLOCK ? LCss::DispBlock : LCss::DispInline);
 		}
 	}
 	else
 	{
 		Info = NULL;
 		TagId = CONTENT;
 	}
 
 	SetStyle();
 }
 
 LColour LTag::_Colour(bool f)
 {
 	for (LTag *t = this; t; t = ToTag(t->Parent))
 	{
 		ColorDef c = f ? t->Color() : t->BackgroundColor();
 		if (c.Type != ColorInherit)
 		{
 			return LColour(c.Rgb32, 32);
 		}
 
 		#if 1
 		if (!f && t->TagId == TAG_TABLE)
 			break;
 		#else
 		/*	This implements some basic level of colour inheritance for
 			background colours. See test case 'cisra-cqs.html'. */
 		if (!f && t->TagId == TAG_TABLE)
 			break;
 		#endif
 	}
 
 	return LColour();
 }
 
 void LTag::CopyClipboard(LMemQueue &p, bool &InSelection)
 {
 	ssize_t Min = -1;
 	ssize_t Max = -1;
 
 	if (Cursor >= 0 && Selection >= 0)
 	{
 		Min = MIN(Cursor, Selection);
 		Max = MAX(Cursor, Selection);
 	}
 	else if (InSelection)
 	{
 		Max = MAX(Cursor, Selection);
 	}
 	else
 	{
 		Min = MAX(Cursor, Selection);
 	}
 
 	ssize_t Off = -1;
 	ssize_t Chars = 0;
 	auto Start = GetTextStart();
 	if (Min >= 0 && Max >= 0)
 	{
 		Off = Min + Start;
 		Chars = Max - Min;
 	}
 	else if (Min >= 0)
 	{
 		Off = Min + Start;
 		Chars = StrlenW(Text()) - Min;
 		InSelection = true;
 	}
 	else if (Max >= 0)
 	{
 		Off = Start;
 		Chars = Max;
 		InSelection = false;
 	}
 	else if (InSelection)
 	{
 		Off = Start;
 		Chars = StrlenW(Text());
 	}
 
 	if (Off >= 0 && Chars > 0)
 	{
 		p.Write((uchar*) (Text() + Off), Chars * sizeof(char16));
 	}
 
 	if (InSelection)
 	{
 		switch (TagId)
 		{
 			default: break;
 			case TAG_BR:
 			{
 				char16 NL[] = {'\n', 0};
 				p.Write((uchar*) NL, sizeof(char16));
 				break;
 			}
 			case TAG_P:
 			{
 				char16 NL[] = {'\n', '\n', 0};
 				p.Write((uchar*) NL, sizeof(char16) * 2);
 				break;
 			}
 		}
 	}
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *c = ToTag(Children[i]);
 		c->CopyClipboard(p, InSelection);
 	}
 }
 
 static
 char*
 _DumpColour(LCss::ColorDef c)
 {
 	static char Buf[4][32];
 	#ifdef _MSC_VER
 	static LONG Cur = 0;
 	LONG Idx = InterlockedIncrement(&Cur);
 	#else
 	static int Cur = 0;
 	int Idx = __sync_fetch_and_add(&Cur, 1);
 	#endif
 	char *b = Buf[Idx % 4];
 	
 	if (c.Type == LCss::ColorInherit)
 		strcpy_s(b, 32, "Inherit");
 	else
 		sprintf_s(b, 32, "%2.2x,%2.2x,%2.2x(%2.2x)", R32(c.Rgb32),G32(c.Rgb32),B32(c.Rgb32),A32(c.Rgb32));
 
 	return b;
 }
 
 void LTag::_Dump(LStringPipe &Buf, int Depth)
 {
 	LString Tabs;
 	Tabs.Set(NULL, Depth);
 	memset(Tabs.Get(), '\t', Depth);	
 
 	const char *Empty = "";
 	char *ElementName = TagId == CONTENT ? (char*)"Content" :
 				(TagId == ROOT ? (char*)"Root" : Tag);
 
 	Buf.Print(	"%s%s(%p)%s%s%s (%i) Pos=%i,%i Size=%i,%i Color=%s/%s",
 				Tabs.Get(),
 				ElementName,
 				this,
 				HtmlId ? "#" : Empty,
 				HtmlId ? HtmlId : Empty,
 				#ifdef _DEBUG
 				Debug ? " debug" : Empty,
 				#else
 				Empty,
 				#endif
 				WasClosed,
 				Pos.x, Pos.y,
 				Size.x, Size.y,
 				_DumpColour(Color()), _DumpColour(BackgroundColor()));
 
 	for (unsigned i=0; i<TextPos.Length(); i++)
 	{
 		LFlowRect *Tr = TextPos[i];
 		
 		LAutoString Utf8(WideToUtf8(Tr->Text, Tr->Len));
 		if (Utf8)
 		{
 			size_t Len = strlen(Utf8);
 			if (Len > 40)
 			{
 				Utf8[40] = 0;
 			}
 		}
 		else if (Tr->Text)
 		{
 			Utf8.Reset(NewStr(""));
 		}
 
 		Buf.Print("Tr(%i,%i %ix%i '%s') ", Tr->x1, Tr->y1, Tr->X(), Tr->Y(), Utf8.Get());
 	}
 	
 	Buf.Print("\r\n");
 	
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		t->_Dump(Buf, Depth+1);
 	}
 
 	if (Children.Length())
 	{
 		Buf.Print("%s/%s\r\n", Tabs.Get(), ElementName);
 	}
 }
 
 LAutoWString LTag::DumpW()
 {
 	LStringPipe Buf;
 	// Buf.Print("Html pos=%s\n", Html?Html->GetPos().GetStr():0);
 	_Dump(Buf, 0);
 	LAutoString a(Buf.NewStr());
 	LAutoWString w(Utf8ToWide(a));
 	return w;
 }
 
 LAutoString LTag::DescribeElement()
 {
 	LStringPipe s(256);
 	s.Print("%s", Tag ? Tag.Get() : "CONTENT");
 	if (HtmlId)
 		s.Print("#%s", HtmlId);
 	for (unsigned i=0; i<Class.Length(); i++)
 		s.Print(".%s", Class[i].Get());
 	return LAutoString(s.NewStr());
 }
 
 LFont *LTag::NewFont()
 {
 	LFont *f = new LFont;
 	if (f)
 	{
 		LFont *Cur = GetFont();
 		if (Cur) *f = *Cur;
 		else *f = *Html->DefFont();
 	}
 	return f;
 }
 
 LFont *LTag::GetFont()
 {
 	if (!Font)
 	{
 		if (PropAddress(PropFontFamily) != 0                    ||
 			FontSize().Type             != LenInherit           ||
 			FontStyle()                 != FontStyleInherit     ||
 			FontVariant()               != FontVariantInherit   ||
 			FontWeight()                != FontWeightInherit    ||
 			TextDecoration()            != TextDecorInherit)
 		{
 			LCss c;
 			
             LCss::PropMap Map;
             Map.Add(PropFontFamily, new LCss::PropArray);
 			Map.Add(PropFontSize, new LCss::PropArray);
 			Map.Add(PropFontStyle, new LCss::PropArray);
 			Map.Add(PropFontVariant, new LCss::PropArray);
 			Map.Add(PropFontWeight, new LCss::PropArray);
 			Map.Add(PropTextDecoration, new LCss::PropArray);
 
 			for (LTag *t = this; t; t = ToTag(t->Parent))
 			{
 				if (t->TagId == TAG_IFRAME)
 					break;
 				if (!c.InheritCollect(*t, Map))
 					break;
 			}
 			
 			c.InheritResolve(Map);
 			
 			Map.DeleteObjects();
 
 			if ((Font = Html->FontCache->GetFont(&c)))
 				return Font;
 		}
 		else
 		{
 			LTag *t = this;
 			while (!t->Font && t->Parent)
 			{
 				t = ToTag(t->Parent);
 			}
 
 			if (t->Font)
 				return t->Font;
 		}
 		
 		Font = Html->DefFont();
 	}
 	
 	return Font;
 }
 
 LTag *LTag::PrevTag()
 {
 	if (Parent)
 	{
 		ssize_t i = Parent->Children.IndexOf(this);
 		if (i >= 0)
 		{
 			return ToTag(Parent->Children[i - 1]);
 		}
 	}
 
 	return 0;
 }
 
 void LTag::Invalidate()
 {
 	LRect p = GetRect();
 	for (LTag *t=ToTag(Parent); t; t=ToTag(t->Parent))
 	{
 		p.Offset(t->Pos.x, t->Pos.y);
 	}
 	Html->Invalidate(&p);
 }
 
 LTag *LTag::IsAnchor(LString *Uri)
 {
 	LTag *a = 0;
 	for (LTag *t = this; t; t = ToTag(t->Parent))
 	{
 		if (t->TagId == TAG_A)
 		{
 			a = t;
 			break;
 		}
 	}
 
 	if (a && Uri)
 	{
 		const char *u = 0;
 		if (a->Get("href", u))
 		{
 			LAutoWString w(CleanText(u, strlen(u), "utf-8"));
 			if (w)
 			{
 				*Uri = w;
 			}
 		}
 	}
 
 	return a;
 }
 
 bool LTag::OnMouseClick(LMouse &m)
 {
 	bool Processed = false;
 
 	if (m.IsContextMenu())
 	{
 		LString Uri;
 		const char *ImgSrc = NULL;
 		LTag *a = IsAnchor(&Uri);
 		bool IsImg = TagId == TAG_IMG;
 		if (IsImg)
 			Get("src", ImgSrc);
 		bool IsAnchor = a && ValidStr(Uri);
 		if (IsAnchor || IsImg)
 		{
 			LSubMenu RClick;
 
 			#define IDM_COPY_LINK	100
 			#define IDM_COPY_IMG	101
 			if (Html->GetMouse(m, true))
 			{
 				int Id = 0;
 
 				if (IsAnchor)
 					RClick.AppendItem(LLoadString(L_COPY_LINK_LOCATION, "&Copy Link Location"), IDM_COPY_LINK, Uri != NULL);
 				if (IsImg)
 					RClick.AppendItem("Copy Image Location", IDM_COPY_IMG, ImgSrc != NULL);
 				if (Html->GetEnv())
 					Html->GetEnv()->AppendItems(&RClick, Uri);
 
 				switch (Id = RClick.Float(Html, m.x, m.y))
 				{
 					case IDM_COPY_LINK:
 					{
 						LClipBoard Clip(Html);
 						Clip.Text(Uri);
 						break;
 					}
 					case IDM_COPY_IMG:
 					{
 						LClipBoard Clip(Html);						
 						Clip.Text(ImgSrc);
 						break;
 					}
 					default:
 					{
 						if (Html->GetEnv())
 							Html->GetEnv()->OnMenu(Html, Id, a);
 						break;
 					}
 				}
 			}
 
 			Processed = true;
 		}
 	}
 	else if (m.Down() && m.Left())
 	{
 		#ifdef _DEBUG
 		if (m.Ctrl())
 		{
 			auto Style = ToString();
 			LStringPipe p(256);
 			p.Print("Tag: %s\n", Tag ? Tag.Get() : "CONTENT");
 			if (Class.Length())
 			{
 				p.Print("Class(es): ");
 				for (unsigned i=0; i<Class.Length(); i++)
 				{
 					p.Print("%s%s", i?", ":"", Class[i].Get());
 				}
 				p.Print("\n");
 			}
 			if (HtmlId)
 			{
 				p.Print("Id: %s\n", HtmlId);
 			}
 			p.Print("Pos: %i,%i   Size: %i,%i\n\n", Pos.x, Pos.y, Size.x, Size.y);
 			p.Print("Style:\n", Style.Get());
 			LToken s(Style, "\n");
 			for (unsigned i=0; i<s.Length(); i++)
 				p.Print("    %s\n", s[i]);
 			
 			p.Print("\nParent tags:\n");
 			LDisplayString Sp(LSysFont, " ");
 			for (LTag *t=ToTag(Parent); t && t->Parent; t=ToTag(t->Parent))
 			{
 				LStringPipe Tmp;
 				Tmp.Print("    %s", t->Tag ? t->Tag.Get() : "CONTENT");
 				if (t->HtmlId)
 				{
 					Tmp.Print("#%s", t->HtmlId);
 				}
 				for (unsigned i=0; i<t->Class.Length(); i++)
 				{
 					Tmp.Print(".%s", t->Class[i].Get());
 				}
 				LAutoString Txt(Tmp.NewStr());
 				p.Print("%s", Txt.Get());
 				LDisplayString Ds(LSysFont, Txt);
 				int Px = 170 - Ds.X();
 				int Chars = Px / Sp.X();
 				for (int c=0; c<Chars; c++)
 					p.Print(" ");
 
 				p.Print("(%i,%i)-(%i,%i)\n",
 					t->Pos.x,
 					t->Pos.y,
 					t->Size.x,
 					t->Size.y);
 			}
 			
 			LAutoString a(p.NewStr());
 			
 			LgiMsg(	Html,
 					"%s",
 					Html->GetClass(),
 					MB_OK,
 					a.Get());
 		}
 		else
 		#endif
 		{
 			LString Uri;
 			
 			if (Html &&
 				Html->Environment)
 			{
 				if (IsAnchor(&Uri))
 				{
 					if (Uri)
 					{
 						if (!Html->d->LinkDoubleClick || m.Double())
 						{
 							Html->Environment->OnNavigate(Html, Uri);
 							Processed = true;
 						}
 					}
 					
 					const char *OnClk = NULL;
 					if (!Processed && Get("onclick", OnClk))
 					{
 						Html->Environment->OnExecuteScript(Html, (char*)OnClk);
 					}
 				}
 				else
 				{
 					Processed = OnClick(m);
 				}
 			}
 		}
 	}
 
 	return Processed;
 }
 
 LTag *LTag::GetBlockParent(ssize_t *Idx)
 {
 	if (IsBlock())
 	{
 		if (Idx)
 			*Idx = 0;
 
 		return this;
 	}
 
 	for (LTag *t = this; t; t = ToTag(t->Parent))
 	{
 		if (ToTag(t->Parent)->IsBlock())
 		{
 			if (Idx)
 			{
 				*Idx = t->Parent->Children.IndexOf(t);
 			}
 
 			return ToTag(t->Parent);
 		}
 	}
 
 	return 0;
 }
 
 LTag *LTag::GetAnchor(char *Name)
 {
 	if (!Name)
 		return 0;
 
 	const char *n;
 	if (IsAnchor(0) && Get("name", n) && n && !_stricmp(Name, n))
 	{
 		return this;
 	}
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		LTag *Result = t->GetAnchor(Name);
 		if (Result) return Result;
 	}
 
 	return 0;
 }
 
 LTag *LTag::GetTagByName(const char *Name)
 {
 	if (Name)
 	{
 		if (Tag && _stricmp(Tag, Name) == 0)
 		{
 			return this;
 		}
 
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			LTag *t = ToTag(Children[i]);
 			LTag *Result = t->GetTagByName(Name);
 			if (Result) return Result;
 		}
 	}
 
 	return 0;
 }
 
 static int IsNearRect(LRect *r, int x, int y)
 {
 	if (r->Overlap(x, y))
 	{
 		return 0;
 	}
 	else if (x >= r->x1 && x <= r->x2)
 	{
 		if (y < r->y1)
 			return r->y1 - y;
 		else
 			return y - r->y2;
 	}
 	else if (y >= r->y1 && y <= r->y2)
 	{
 		if (x < r->x1)
 			return r->x1 - x;
 		else
 			return x - r->x2;
 	}
 
 	int64 dx = 0;
 	int64 dy = 0;
 	
 	if (x < r->x1)
 	{
 		if (y < r->y1)
 		{
 			// top left
 			dx = r->x1 - x;
 			dy = r->y1 - y;
 		}
 		else
 		{
 			// bottom left
 			dx = r->x1 - x;
 			dy = y - r->y2;
 		}
 	}
 	else
 	{
 		if (y < r->y1)
 		{
 			// top right
 			dx = x - r->x2;
 			dy = r->y1 - y;
 		}
 		else
 		{
 			// bottom right
 			dx = x - r->x2;
 			dy = y - r->y2;
 		}
 	}
 
 	return (int) sqrt( (double) ( (dx * dx) + (dy * dy) ) );
 }
 
 ssize_t LTag::NearestChar(LFlowRect *Tr, int x, int y)
 {
 	LFont *f = GetFont();
 	if (f)
 	{
 		LDisplayString ds(f, Tr->Text, Tr->Len);
 		ssize_t c = ds.CharAt(x - Tr->x1);
 		
 		if (Tr->Text == PreText())
 		{
 			return 0;
 		}
 		else
 		{
 			char16 *t = Tr->Text + c;
 			size_t Len = StrlenW(Text());
 			if (t >= Text() &&
 				t <= Text() + Len)
 			{
 				return (t - Text()) - GetTextStart();
 			}
 			else
 			{
 				LgiTrace("%s:%i - Error getting char at position.\n", _FL);
 			}
 		}
 	}
 
 	return -1;
 }
 
 void LTag::GetTagByPos(LTagHit &TagHit, int x, int y, int Depth, bool InBody, bool DebugLog)
 {
 	/*
 	InBody: Originally I had this test in the code but it seems that some test cases
 	have actual content after the body. And testing for "InBody" breaks functionality
 	for those cases (see "spam4.html" and the unsubscribe link at the end of the doc).	
 	*/
 
 	if (TagId == TAG_IMG)
 	{
 		LRect img(0, 0, Size.x - 1, Size.y - 1);
 		if (/*InBody &&*/ img.Overlap(x, y))
 		{
 			TagHit.Direct = this;
 			TagHit.Block = 0;
 		}
 	}
 	else if (/*InBody &&*/ TextPos.Length())
 	{
 		for (unsigned i=0; i<TextPos.Length(); i++)
 		{
 			LFlowRect *Tr = TextPos[i];
 			if (!Tr)
 				break;
 			
 			bool SameRow = y >= Tr->y1 && y <= Tr->y2;			
 			int Near = IsNearRect(Tr, x, y);
 			if (Near >= 0 && Near < 100)
 			{
 				if
 				(
 					!TagHit.NearestText
 					||
 					(
 						SameRow
 						&&
 						!TagHit.NearSameRow
 					)
 					||
 					(
 						SameRow == TagHit.NearSameRow
 						&&
 						Near < TagHit.Near
 					)
 				)
 				{
 					TagHit.NearestText = this;
 					TagHit.NearSameRow = SameRow;
 					TagHit.Block = Tr;
 					TagHit.Near = Near;
 					TagHit.Index = NearestChar(Tr, x, y);
 					
 					if (DebugLog)
 					{
 						LgiTrace("%i:GetTagByPos HitText %s #%s, idx=%i, near=%i, txt='%S'\n",
 							Depth,
 							Tag.Get(),
 							HtmlId,
 							TagHit.Index,
 							TagHit.Near,
 							Tr->Text);
 					}
 
 					if (!TagHit.Near)
 					{
 						TagHit.Direct = this;
 						TagHit.LocalCoords.x = x;
 						TagHit.LocalCoords.y = y;
 					}
 				}
 			}
 		}
 	}
 	else if
 	(
 		TagId != TAG_TR &&
 		Tag &&
 		x >= 0 &&
 		y >= 0 &&
 		x < Size.x &&
 		y < Size.y
 		// && InBody
 	)
 	{
 		// Direct hit
 		TagHit.Direct = this;
 		TagHit.LocalCoords.x = x;
 		TagHit.LocalCoords.y = y;
 
 		if (DebugLog)
 		{
 			LgiTrace("%i:GetTagByPos DirectHit %s #%s, idx=%i, near=%i\n",
 				Depth,
 				Tag.Get(),
 				HtmlId,
 				TagHit.Index,
 				TagHit.Near);
 		}
 	}
 	
 	if (TagId == TAG_BODY)
 		InBody = true;
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		if (t->Pos.x >= 0 &&
 			t->Pos.y >= 0)
 		{
 			t->GetTagByPos(TagHit, x - t->Pos.x, y - t->Pos.y, Depth + 1, InBody, DebugLog);
 		}
 	}
 }
 
 int LTag::OnNotify(LNotification n)
 {
 	if (!Ctrl || !Html->InThread())
 		return 0;
 	
 	switch (CtrlType)
 	{
 		case CtrlSubmit:
 		{
 			LTag *Form = this;
 			while (Form && Form->TagId != TAG_FORM)
 				Form = ToTag(Form->Parent);
 			if (Form)
 				Html->OnSubmitForm(Form);
 			break;
 		}
 		default:
 		{
 			CtrlValue = Ctrl->Name();
 			break;
 		}
 	}
 	
 	return 0;
 }
 
 void LTag::CollectFormValues(LHashTbl<ConstStrKey<char,false>,char*> &f)
 {
 	if (CtrlType != CtrlNone)
 	{
 		const char *Name;
 		if (Get("name", Name))
 		{
 			char *Existing = f.Find(Name);
 			if (Existing)
 				DeleteArray(Existing);
 
 			char *Val = CtrlValue.Str();
 			if (Val)
 			{
 				LStringPipe p(256);
 				for (char *v = Val; *v; v++)
 				{
 					if (*v == ' ')
 						p.Write("+", 1);
 					else if (IsAlpha(*v) || IsDigit(*v) || *v == '_' || *v == '.')
 						p.Write(v, 1);
 					else
 						p.Print("%%%02.2X", *v);
 				}
 				f.Add(Name, p.NewStr());
 			}
 			else
 			{
 				f.Add(Name, NewStr(""));
 			}
 		}
 	}
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		t->CollectFormValues(f);
 	}
 }
 
 LTag *LTag::FindCtrlId(int Id)
 {
 	if (Ctrl && Ctrl->GetId() == Id)
 		return this;
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		LTag *f = t->FindCtrlId(Id);
 		if (f)
 			return f;
 	}
 	
 	return NULL;
 }
 
 void LTag::Find(int TagType, LArray<LTag*> &Out)
 {
 	if (TagId == TagType)
 	{
 		Out.Add(this);
 	}
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		t->Find(TagType, Out);
 	}
 }
 
 void LTag::SetImage(const char *Uri, LSurface *Img)
 {
 	if (Img)
 	{
 		if (TagId != TAG_IMG)
 		{
 			ImageDef *Def = (ImageDef*)LCss::Props.Find(PropBackgroundImage);
 			if (Def)
 			{
 				Def->Type = ImageOwn;
 				DeleteObj(Def->Img);
 				Def->Img = Img;
 			}
 		}
 		else
 		{
 			if (Img->GetColourSpace() == CsIndex8)
 			{
 				if (Image.Reset(new LMemDC(Img->X(), Img->Y(), System32BitColourSpace)))
 				{
 					Image->Colour(0, 32);
 					Image->Rectangle();
 					Image->Blt(0, 0, Img);
 				}
 				else LgiTrace("%s:%i - SetImage can't promote 8bit image to 32bit.\n", _FL);
 			}
 			else Image.Reset(Img);
 			
 			LRect r = XSubRect();
 			if (r.Valid())
 			{
 				LAutoPtr<LSurface> t(new LMemDC(r.X(), r.Y(), Image->GetColourSpace()));
 				if (t)
 				{
 					t->Blt(0, 0, Image, &r);
 					Image = t;
 				}
 			}
 		}		
 
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			LTag *t = ToTag(Children[i]);
 			if (t->Cell)
 			{
 				t->Cell->MinContent = 0;
 				t->Cell->MaxContent = 0;
 			}
 		}
 	}
 	else
 	{
 		Html->d->Loading.Add(Uri, this);
 	}
 }
 
 void LTag::LoadImage(const char *Uri)
 {
 	#if DOCUMENT_LOAD_IMAGES
 	if (!Html->Environment)
 		return;
 
 	LUri u(Uri);
 	bool LdImg = Html->GetLoadImages();
 	bool IsRemote = u.sProtocol &&
 					(
 						!_stricmp(u.sProtocol, "http") ||
 						!_stricmp(u.sProtocol, "https") ||
 						!_stricmp(u.sProtocol, "ftp")
 					);
 	if (IsRemote && !LdImg)
 	{
 		Html->NeedsCapability("RemoteContent");
 		return;
 	}
 	else if (u.IsProtocol("data"))
 	{
 		if (!u.sPath)
 			return;
 
 		const char *s = u.sPath;
 		if (*s++ != '/')
 			return;
 		LAutoString Type(LTokStr(s));
 		if (*s++ != ',')
 			return;
 		auto p = LString(Type).SplitDelimit(",;:");
 		if (p.Length() != 2 || !p.Last().Equals("base64"))
 			return;
 		LString Name = LString("name.") + p[0];
 		auto Filter = LFilterFactory::New(Name, FILTER_CAP_READ, NULL);
 		if (!Filter)
 			return;
 
 		auto slen = strlen(s);
 		auto blen = BufferLen_64ToBin(slen);
 		LMemStream bin;
 		bin.SetSize(blen);
 		ConvertBase64ToBinary((uint8_t*)bin.GetBasePtr(), blen, s, slen);
 		
 		bin.SetPos(0);
 		if (!Image.Reset(new LMemDC))
 			return;
 		auto result = Filter->ReadImage(Image, &bin);
 		if (result != LFilter::IoSuccess)
 			Image.Reset();
 		return;
 	}
 
 	LDocumentEnv::LoadJob *j = Html->Environment->NewJob();
 	if (j)
 	{
 		LAssert(Html != NULL);
 		j->Uri.Reset(NewStr(Uri));
 		j->Env = Html->Environment;
 		j->UserData = this;
 		j->UserUid = Html->GetDocumentUid();
 
 		// LgiTrace("%s:%i - new job %p, %p\n", _FL, j, j->UserData);
 
 		LDocumentEnv::LoadType Result = Html->Environment->GetContent(j);
 		if (Result == LDocumentEnv::LoadImmediate)
 		{
 			SetImage(Uri, j->pDC.Release());
 		}
 		else if (Result == LDocumentEnv::LoadDeferred)
 		{
 			Html->d->DeferredLoads++;
 		}
 				
 		DeleteObj(j);
 	}
 	#endif
 }
 
 void LTag::LoadImages()
 {
 	const char *Uri = 0;
 	if (Html->Environment &&
 		TagId == TAG_IMG &&
 		!Image)
 	{
 		if (Get("src", Uri))
 			LoadImage(Uri);
 	}
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		t->LoadImages();
 	}
 }
 
 void LTag::ImageLoaded(char *uri, LSurface *Img, int &Used)
 {
 	const char *Uri = 0;
 	if (!Image &&
 		Get("src", Uri))
 	{
 		if (strcmp(Uri, uri) == 0)
 		{
 			if (Used == 0)
 			{
 				SetImage(Uri, Img);
 			}
 			else
 			{
 				SetImage(Uri, new LMemDC(Img));
 			}
 			Used++;
 		}
 	}
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		t->ImageLoaded(uri, Img, Used);
 	}
 }
 
 struct LTagElementCallback : public LCss::ElementCallback<LTag>
 {
 	const char *Val;
 
 	const char *GetElement(LTag *obj)
 	{
 		return obj->Tag;
 	}
 	
 	const char *GetAttr(LTag *obj, const char *Attr)
 	{
 		if (obj->Get(Attr, Val))
 			return Val;
 		return NULL;
 	}
 	
 	bool GetClasses(LString::Array &Classes, LTag *obj) 
 	{
 		Classes = obj->Class;
 		return Classes.Length() > 0;
 	}
 	
 	LTag *GetParent(LTag *obj)
 	{
 		return ToTag(obj->Parent);
 	}
 	
 	LArray<LTag*> GetChildren(LTag *obj)
 	{
 		LArray<LTag*> c;
 		for (unsigned i=0; i<obj->Children.Length(); i++)
 			c.Add(ToTag(obj->Children[i]));
 		return c;
 	}
 };
 
 void LTag::RestyleAll()
 {
 	Restyle();
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LHtmlElement *c = Children[i];
 		LTag *t = ToTag(c);
 		if (t)
 			t->RestyleAll();
 	}
 }
 
 // After CSS has changed this function scans through the CSS and applies any rules
 // that match the current tag.
 void LTag::Restyle()
 {
 	// Use the matching built into the LCss Store.
 	LCss::SelArray Styles;
 	LTagElementCallback Context;
 	if (Html->CssStore.Match(Styles, &Context, this))
 	{
 		for (unsigned i=0; i<Styles.Length(); i++)
 		{
 			LCss::Selector *s = Styles[i];
 			if (s)
 				SetCssStyle(s->Style);
 		}
 	}
 	
 	// Do the element specific styles
 	const char *s;
 	if (Get("style", s))
 		SetCssStyle(s);
 
 	#if DEBUG_RESTYLE && defined(_DEBUG)
 	if (Debug)
 	{
 		auto Style = ToString();
 		LgiTrace(">>>> %s <<<<:\n%s\n\n", Tag.Get(), Style.Get());
 	}
 	#endif
 }
 
 void LTag::SetStyle()
 {
 	const static float FntMul[] =
 	{
 		0.6f,	// size=1
 		0.89f,	// size=2
 		1.0f,	// size=3
 		1.2f,	// size=4
 		1.5f,	// size=5
 		2.0f,	// size=6
 		3.0f	// size=7
 	};
 
 	const char *s = 0;
 	#ifdef _DEBUG
 	if (Get("debug", s))
 	{
 		if ((Debug = atoi(s)))
 		{
 			LgiTrace("Debug Tag: %p '%s'\n", this, Tag ? Tag.Get() : "CONTENT");
 		}
 	}
 	#endif
 
 	if (Get("Color", s))
 	{
 		ColorDef Def;
 		if (LHtmlParser::ParseColour(s, Def))
 		{
 			Color(Def);
 		}
 	}
 
 	if (Get("Background", s) ||
 		Get("bgcolor", s))
 	{
 		ColorDef Def;
 		if (LHtmlParser::ParseColour(s, Def))
 		{
 			BackgroundColor(Def);
 		}
 		else
 		{
 			LCss::ImageDef Img;
 			
 			Img.Type = ImageUri;
 			Img.Uri = s;
 			
 			BackgroundImage(Img);
 			BackgroundRepeat(RepeatBoth);
 		}
 	}
 
 	switch (TagId)
 	{
 		default:
 		{
 			if (!Stricmp(Tag.Get(), "o:p"))
 				Display(LCss::DispNone);
 			break;
 		}
 		case TAG_LINK:
 		{
 			const char *Type, *Href;
 			if (Html->Environment &&
 				Get("type", Type) &&
 				Get("href", Href) &&
 				!Stricmp(Type, "text/css") &&
 				!Html->CssHref.Find(Href))
 			{
 				LDocumentEnv::LoadJob *j = Html->Environment->NewJob();
 				if (j)
 				{
 					LAssert(Html != NULL);
 					LTag *t = this;
 					
 					j->Uri.Reset(NewStr(Href));
 					j->Env = Html->Environment;
 					j->UserData = t;
 					j->UserUid = Html->GetDocumentUid();
 
 					LDocumentEnv::LoadType Result = Html->Environment->GetContent(j);
 					if (Result == LDocumentEnv::LoadImmediate)
 					{
 						LStreamI *s = j->GetStream();							
 						if (s)
 						{
 							int Len = (int)s->GetSize();
 							if (Len > 0)
 							{
 								LAutoString a(new char[Len+1]);
 								ssize_t r = s->Read(a, Len);
 								a[r] = 0;
 
 								Html->CssHref.Add(Href, true);
 								Html->OnAddStyle("text/css", a);
 							}
 						}
 					}
 					else if (Result == LDocumentEnv::LoadDeferred)
 					{
 						Html->d->DeferredLoads++;
 					}
 
 					DeleteObj(j);
 				}
 			}
 			break;
 		}
 		case TAG_BLOCKQUOTE:
 		{
 			MarginTop(Len("8px"));
 			MarginBottom(Len("8px"));
 			MarginLeft(Len("16px"));
 
 			if (Get("Type", s))
 			{
 				if (_stricmp(s, "cite") == 0)
 				{
 					BorderLeft(BorderDef(this, "1px solid blue"));
 					PaddingLeft(Len("0.5em"));
 					
 					/*
 					ColorDef Def;
 					Def.Type = ColorRgb;
 					Def.Rgb32 = Rgb32(0x80, 0x80, 0x80);
 					Color(Def);
 					*/
 				}
 			}
 			break;
 		}
 		case TAG_P:
 		{
 			MarginBottom(Len("1em"));
 			break;
 		}
 		case TAG_A:
 		{
 			const char *Href;
 			if (Get("href", Href))
 			{
 				ColorDef c;
 				c.Type = ColorRgb;
 				c.Rgb32 = Rgb32(0, 0, 255);
 				Color(c);
 				TextDecoration(TextDecorUnderline);
 			}
 			break;
 		}
 		case TAG_TABLE:
 		{
 			Len l;
 
 			if (!Cell)
 				Cell = new TblCell;
 
 			if (Get("border", s))
 			{
 				BorderDef b;
 				if (b.Parse(this, s))
 				{
 					BorderLeft(b);
 					BorderRight(b);
 					BorderTop(b);
 					BorderBottom(b);
 				}
 			}
 
 			if (Get("cellspacing", s) &&
 				l.Parse(s, PropBorderSpacing, ParseRelaxed))
 			{
 				BorderSpacing(l);
 			}
 			else
 			{
 				// BorderSpacing(LCss::Len(LCss::LenPx, 2.0f));
 			}
 
 			if (Get("cellpadding", s) &&
 				l.Parse(s, Prop_CellPadding, ParseRelaxed))
 			{
 				_CellPadding(l);
 			}
 
 			if (Get("align", s))
 			{
 				Len l;
 				if (l.Parse(s))
 					Cell->XAlign = l.Type;
 			}
 			break;
 		}
 		case TAG_TD:
 		case TAG_TH:
 		{
 			if (!Cell)
 				Cell = new TblCell;
 
 			LTag *Table = GetTable();
 			if (Table)
 			{
 				Len l = Table->_CellPadding();
 				if (!l.IsValid())
 				{
 					l.Type = LCss::LenPx;
 					l.Value = DefaultCellPadding;
 				}
 				PaddingLeft(l);
 				PaddingRight(l);
 				PaddingTop(l);
 				PaddingBottom(l);
 			}
 			
 			if (TagId == TAG_TH)
 				FontWeight(LCss::FontWeightBold);
 			break;
 		}
 		case TAG_BODY:
 		{
 			MarginLeft(Len(Get("leftmargin", s) ? s : DefaultBodyMargin));
 			MarginTop(Len(Get("topmargin", s) ? s : DefaultBodyMargin));
 			MarginRight(Len(Get("rightmargin", s) ? s : DefaultBodyMargin));
 			
 			if (Get("text", s))
 			{
 				ColorDef c;
 				if (c.Parse(s))
 				{
 					Color(c);
 				}
 			}
 			break;
 		}
 		case TAG_OL:
 		case TAG_UL:
 		{
 			MarginLeft(Len("16px"));
 			break;
 		}
 		case TAG_STRONG:
 		case TAG_B:
 		{
 			FontWeight(FontWeightBold);
 			break;
 		}
 		case TAG_I:
 		{
 			FontStyle(FontStyleItalic);
 			break;
 		}
 		case TAG_U:
 		{
 			TextDecoration(TextDecorUnderline);
 			break;
 		}
 		case TAG_SUP:
 		{
 			VerticalAlign(VerticalSuper);
 			FontSize(SizeSmaller);
 			break;
 		}
 		case TAG_SUB:
 		{
 			VerticalAlign(VerticalSub);
 			FontSize(SizeSmaller);
 			break;
 		}
 		case TAG_TITLE:
 		{
 			Display(LCss::DispNone);
 			break;
 		}
 	}
 
 	if (Get("width", s))
 	{
 		Len l;
 		if (l.Parse(s, PropWidth, ParseRelaxed))
 		{
 			Width(l);
 		}
 	}
 	if (Get("height", s))
 	{
 		Len l;
 		if (l.Parse(s, PropHeight, ParseRelaxed))
 			Height(l);
 	}
 	if (Get("align", s))
 	{
 		if (_stricmp(s, "left") == 0) TextAlign(Len(AlignLeft));
 		else if (_stricmp(s, "right") == 0) TextAlign(Len(AlignRight));
 		else if (_stricmp(s, "center") == 0) TextAlign(Len(AlignCenter));
 	}
 	if (Get("valign", s))
 	{
 		if (_stricmp(s, "top") == 0) VerticalAlign(Len(VerticalTop));
 		else if (_stricmp(s, "middle") == 0) VerticalAlign(Len(VerticalMiddle));
 		else if (_stricmp(s, "bottom") == 0) VerticalAlign(Len(VerticalBottom));
 	}
 
 	Get("id", HtmlId);
 
 	if (Get("class", s))
 	{
 		Class = LString(s).SplitDelimit(" \t");
 	}
 
 	Restyle();
 
 	switch (TagId)
 	{
 		default: break;
 	    case TAG_BIG:
 	    {
             LCss::Len l;
             l.Type = SizeLarger;
 	        FontSize(l);
 	        break;
 	    }
 	    /*
 		case TAG_META:
 		{
 			LAutoString Cs;
 
 			const char *s;
 			if (Get("http-equiv", s) &&
 				_stricmp(s, "Content-Type") == 0)
 			{
 				const char *ContentType;
 				if (Get("content", ContentType))
 				{
 					char *CharSet = stristr(ContentType, "charset=");
 					if (CharSet)
 					{
 						char16 *cs = NULL;
 						Html->ParsePropValue(CharSet + 8, cs);
 						Cs.Reset(WideToUtf8(cs));
 						DeleteArray(cs);
 					}
 				}
 			}
 
 			if (Get("name", s) && _stricmp(s, "charset") == 0 && Get("content", s))
 			{
 				Cs.Reset(NewStr(s));
 			}
 			else if (Get("charset", s))
 			{
 				Cs.Reset(NewStr(s));
 			}
 
 			if (Cs)
 			{
 				if (Cs &&
 					_stricmp(Cs, "utf-16") != 0 &&
 					_stricmp(Cs, "utf-32") != 0 &&
 					LGetCsInfo(Cs))
 				{
 					// Html->SetCharset(Cs);
 				}
 			}
 			break;
 		}
 		*/
 		case TAG_BODY:
 		{
 			LCss::ColorDef Bk = BackgroundColor();
 			if (Bk.Type != ColorInherit)
 			{
 				// Copy the background up to the LHtml wrapper
 				Html->GetCss(true)->BackgroundColor(Bk);
 			}
 			
 			/*
 			LFont *f = GetFont();
 			if (FontSize().Type == LenInherit)
 			{
        		    FontSize(Len(LenPt, (float)f->PointSize()));
 			}
 			*/
 			break;
 		}
 		case TAG_HEAD:
 		{
 			Display(DispNone);
 			break;
 		}
 		case TAG_PRE:
 		{
 			LFontType Type;
 			if (Type.GetSystemFont("Fixed"))
 			{
 				LAssert(ValidStr(Type.GetFace()));
 				FontFamily(StringsDef(Type.GetFace()));
 			}
 			break;
 		}
 		case TAG_TR:
 			break;
 		case TAG_TD:
 		case TAG_TH:
 		{
 			LAssert(Cell != NULL);
 			
 			const char *s;
 			if (Get("colspan", s))
 				Cell->Span.x = atoi(s);
 			else
 				Cell->Span.x = 1;
 			if (Get("rowspan", s))
 				Cell->Span.y = atoi(s);
 			else
 				Cell->Span.y = 1;
 			
 			Cell->Span.x = MAX(Cell->Span.x, 1);
 			Cell->Span.y = MAX(Cell->Span.y, 1);
 			
 			if (Display() == DispInline ||
 				Display() == DispInlineBlock)
 			{
 				Display(DispBlock); // Inline-block TD??? Nope.
 			}
 			break;
 		}
 		case TAG_IMG:
 		{
 			const char *Uri;
 			if (Html->Environment &&
 				Get("src", Uri))
 			{
 				// printf("Uri: %s\n", Uri);
 				LoadImage(Uri);
 			}
 			break;
 		}
 		case TAG_H1:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%ipt", (int)((float)Html->DefFont()->PointSize() * FntMul[5]));
 			FontSize(Len(s));
 			FontWeight(FontWeightBold);
 			break;
 		}
 		case TAG_H2:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%ipt", (int)((float)Html->DefFont()->PointSize() * FntMul[4]));
 			FontSize(Len(s));
 			FontWeight(FontWeightBold);
 			break;
 		}
 		case TAG_H3:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%ipt", (int)((float)Html->DefFont()->PointSize() * FntMul[3]));
 			FontSize(Len(s));
 			FontWeight(FontWeightBold);
 			break;
 		}
 		case TAG_H4:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%ipt", (int)((float)Html->DefFont()->PointSize() * FntMul[2]));
 			FontSize(Len(s));
 			FontWeight(FontWeightBold);
 			break;
 		}
 		case TAG_H5:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%ipt", (int)((float)Html->DefFont()->PointSize() * FntMul[1]));
 			FontSize(Len(s));
 			FontWeight(FontWeightBold);
 			break;
 		}
 		case TAG_H6:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%ipt", (int)((float)Html->DefFont()->PointSize() * FntMul[0]));
 			FontSize(Len(s));
 			FontWeight(FontWeightBold);
 			break;
 		}
 		case TAG_FONT:
 		{
 			const char *s = 0;
 			if (Get("Face", s))
 			{
 				char16 *cw = CleanText(s, strlen(s), "utf-8", true);
 				char *c8 = WideToUtf8(cw);
 				DeleteArray(cw);
 				LToken Faces(c8, ",");
 				DeleteArray(c8);
 				char *face = TrimStr(Faces[0]);
 				if (ValidStr(face))
 				{
 					FontFamily(face);
 					DeleteArray(face);
 				}
 				else
 				{
 					LgiTrace("%s:%i - No face for font tag.\n", __FILE__, __LINE__);
 				}
 			}
 
 			if (Get("Size", s))
 			{
 				bool Digit = false, NonW = false;
 				for (auto *c = s; *c; c++)
 				{
 					if (IsDigit(*c) || *c == '-') Digit = true;
 					else if (!IsWhiteSpace(*c)) NonW = true;
 				}
 				if (Digit && !NonW)
 				{
 					auto Sz = atoi(s);
 					switch (Sz)
 					{
 						case 1: FontSize(Len(LCss::LenEm, 0.63f)); break;
 						case 2: FontSize(Len(LCss::LenEm, 0.82f)); break;
 						case 3: FontSize(Len(LCss::LenEm, 1.0f)); break;
 						case 4: FontSize(Len(LCss::LenEm, 1.13f)); break;
 						case 5: FontSize(Len(LCss::LenEm, 1.5f)); break;
 						case 6: FontSize(Len(LCss::LenEm, 2.0f)); break;
 						case 7: FontSize(Len(LCss::LenEm, 3.0f)); break;
 					}
 				}
 				else
 				{
 					FontSize(Len(s));
 				}
 			}
 			break;
 		}
 		case TAG_SELECT:
 		{
 			if (!Html->InThread())
 				break;
 
 			LAssert(!Ctrl);
 			Ctrl = new LCombo(Html->d->NextCtrlId++, 0, 0, 100, LSysFont->GetHeight() + 8, NULL);
 			CtrlType = CtrlSelect;
 			break;
 		}
 		case TAG_INPUT:
 		{
 			if (!Html->InThread())
 				break;
 
 			LAssert(!Ctrl);
 
 			const char *Type, *Value = NULL;
 			Get("value", Value);
 			LAutoWString CleanValue(Value ? CleanText(Value, strlen(Value), "utf-8", true, true) : NULL);
 			if (CleanValue)
 			{
 				CtrlValue = CleanValue;
 			}
 			
 			if (Get("type", Type))
 			{
 				if (!_stricmp(Type, "password")) CtrlType = CtrlPassword;
 				else if (!_stricmp(Type, "email")) CtrlType = CtrlEmail;
 				else if (!_stricmp(Type, "text")) CtrlType = CtrlText;
 				else if (!_stricmp(Type, "button")) CtrlType = CtrlButton;
 				else if (!_stricmp(Type, "submit")) CtrlType = CtrlSubmit;
 				else if (!_stricmp(Type, "hidden")) CtrlType = CtrlHidden;
 
 				DeleteObj(Ctrl);
 				if (CtrlType == CtrlEmail ||
 					CtrlType == CtrlText ||
 					CtrlType == CtrlPassword)
 				{
 					LEdit *Ed;
 					LAutoString UtfCleanValue(WideToUtf8(CleanValue));
 					Ctrl = Ed = new LEdit(Html->d->NextCtrlId++, 0, 0, 60, LSysFont->GetHeight() + 8, UtfCleanValue);
 					if (Ctrl)
 					{
 						Ed->Sunken(false);
 						Ed->Password(CtrlType == CtrlPassword);
 					}						
 				}
 				else if (CtrlType == CtrlButton ||
 						 CtrlType == CtrlSubmit)
 				{
 					LAutoString UtfCleanValue(WideToUtf8(CleanValue));
 					if (UtfCleanValue)
 					{
 						Ctrl = new InputButton(this, Html->d->NextCtrlId++, UtfCleanValue);
 					}
 				}
 			}
 			break;
 		}
 	}
 
 	if (IsBlock())
 	{
 		LCss::ImageDef bk = BackgroundImage();
 		if (bk.Type == LCss::ImageUri &&
 			ValidStr(bk.Uri) &&
 			!bk.Uri.Equals("transparent"))
 		{
 			LoadImage(bk.Uri);
 		} 
 	}
 	
 	if (Ctrl)
 	{
 		LFont *f = GetFont();
 		if (f)
 			Ctrl->SetFont(f, false);
 	}
 }
 
 void LTag::OnStyleChange(const char *name)
 {
 	if (!Stricmp(name, "display") && Html)
 	{
 		Html->Layout(true);
 		Html->Invalidate();
 	}
 }
 
 void LTag::SetCssStyle(const char *Style)
 {
 	if (Style)
 	{
 		// Strip out comments
 		char *Comment = NULL;
 		while ((Comment = strstr((char*)Style, "/*")))
 		{
 			char *End = strstr(Comment+2, "*/");
 			if (!End)
 				break;
 			for (char *c = Comment; c<End+2; c++)
 				*c = ' ';
 		}
 
 		// Parse CSS
 		const char *Ptr = Style;
 		LCss::Parse(Ptr, LCss::ParseRelaxed);
 	}
 }
 
 char16 *LTag::CleanText(const char *s, ssize_t Len, const char *SourceCs,  bool ConversionAllowed, bool KeepWhiteSpace)
 {
 	if (!s || Len <= 0)
 		return NULL;
 
 	static const char *DefaultCs = "iso-8859-1";
 	char16 *t = 0;
 	bool DocAndCsTheSame = false;
 	if (Html->DocCharSet && Html->Charset)
 	{
 		DocAndCsTheSame = _stricmp(Html->DocCharSet, Html->Charset) == 0;
 	}
 
 	if (SourceCs)
 	{
 		t = (char16*) LNewConvertCp(LGI_WideCharset, s, SourceCs, Len);
 	}
 	else if (Html->DocCharSet &&
 		Html->Charset &&
 		!DocAndCsTheSame &&
 		!Html->OverideDocCharset)
 	{
 		char *DocText = (char*)LNewConvertCp(Html->DocCharSet, s, Html->Charset, Len);
 		t = (char16*) LNewConvertCp(LGI_WideCharset, DocText, Html->DocCharSet, -1);
 		DeleteArray(DocText);
 	}
 	else if (Html->DocCharSet)
 	{
 		t = (char16*) LNewConvertCp(LGI_WideCharset, s, Html->DocCharSet, Len);
 	}
 	else
 	{
 		t = (char16*) LNewConvertCp(LGI_WideCharset, s, Html->Charset.Get() ? Html->Charset.Get() : DefaultCs, Len);
 	}
 
 	if (t && ConversionAllowed)
 	{
 		char16 *o = t;
 		for (char16 *i=t; *i; )
 		{
 			switch (*i)
 			{
 				case '&':
 				{
 					i++;
 					
 					if (*i == '#')
 					{
 						// Unicode Number
 						char n[32] = "", *p = n;
 						
 						i++;
 						
 						if (*i == 'x' || *i == 'X')
 						{
 							// Hex number
 							i++;
 							while (	*i &&
 									(
 										IsDigit(*i) ||
 										(*i >= 'A' && *i <= 'F') ||
 										(*i >= 'a' && *i <= 'f')
 									) &&
 									(p - n) < 31)
 							{
 								*p++ = (char)*i++;
 							}
 						}
 						else
 						{
 							// Decimal number
 							while (*i && IsDigit(*i) && (p - n) < 31)
 							{
 								*p++ = (char)*i++;
 							}
 						}
 						*p++ = 0;
 						
 						char16 Ch = atoi(n);
 						if (Ch)
 						{
 							*o++ = Ch;
 						}
 						
 						if (*i && *i != ';')
 							i--;
 					}
 					else
 					{
 						// Named Char
 						char16 *e = i;
 						while (*e && IsAlpha(*e) && *e != ';')
 						{
 							e++;
 						}
 						
 						LAutoWString Var(NewStrW(i, e-i));							
 						char16 Char = LHtmlStatic::Inst->VarMap.Find(Var);
 						if (Char)
 						{
 							*o++ = Char;
 							i = e;
 						}
 						else
 						{
 							i--;
 							*o++ = *i;
 						}
 					}
 					break;
 				}
 				case '\r':
 				{
 					break;
 				}
 				case ' ':
 				case '\t':
 				case '\n':
 				{
 					if (KeepWhiteSpace)
 					{
 						*o++ = *i;
 					}
 					else
 					{
 						*o++ = ' ';
 
 						// Skip furthur whitespace
 						while (i[1] && IsWhiteSpace(i[1]))
 						{
 							i++;
 						}
 					}
 					break;
 				}
 				default:
 				{
 					// Normal char
 					*o++ = *i;
 					break;
 				}
 			}
 
 			if (*i) i++;
 			else break;
 		}
 		*o++ = 0;
 	}
 
 	if (t && !*t)
 	{
 		DeleteArray(t);
 	}
 
 	return t;
 }
 
 char *LTag::ParseText(char *Doc)
 {
 	ColorDef c;
 	c.Type = ColorRgb;
 	c.Rgb32 = LColour(L_WORKSPACE).c32();
 	BackgroundColor(c);
 	
 	TagId = TAG_BODY;
 	Tag.Reset(NewStr("body"));
 	Info = Html->GetTagInfo(Tag);
 	char *OriginalCp = NewStr(Html->Charset);
 
 	LStringPipe Utf16;
 	char *s = Doc;
 	while (s)
 	{
 		if (*s == '\r')
 		{
 			s++;
 		}
 		else if (*s == '<')
 		{
 			// Process tag
 			char *e = s;
 			e++;
 			while (*e && *e != '>')
 			{
 				if (*e == '\"' || *e == '\'')
 				{
 					char *q = strchr(e + 1, *e);
 					if (q) e = q + 1;
 					else e++;
 				}
 				else e++;
 			}
 			if (*e == '>') e++;
 
 			// Output tag
 			Html->SetCharset("iso-8859-1");
 			char16 *t = CleanText(s, e - s, NULL, false);
 			if (t)
 			{
 				Utf16.Push(t);
 				DeleteArray(t);
 			}
 			s = e;
 		}
 		else if (!*s || *s == '\n')
 		{
 			// Output previous line
 			char16 *Line = Utf16.NewStrW();
 			if (Line)
 			{
 				LTag *t = new LTag(Html, this);
 				if (t)
 				{
 					t->Color(LColour(L_TEXT));
 					t->Text(Line);
 				}
 			}
 
 			if (*s == '\n')
 			{
 				s++;
 				LTag *t = new LTag(Html, this);
 				if (t)
 				{
 					t->TagId = TAG_BR;
 					t->Tag.Reset(NewStr("br"));
 					t->Info = Html->GetTagInfo(t->Tag);
 				}
 			}
 			else break;
 		}
 		else
 		{
 			// Seek end of text
 			char *e = s;
 			while (*e && *e != '\r' && *e != '\n' && *e != '<') e++;
 			
 			// Output text
 			Html->SetCharset(OriginalCp);
 			LAutoWString t(CleanText(s, e - s, NULL, false));
 			if (t)
 			{
 				Utf16.Push(t);
 			}			
 			s = e;
 		}
 	}
 	
 	Html->SetCharset(OriginalCp);
 	DeleteArray(OriginalCp);
 
 	return 0;
 }
 
 bool LTag::ConvertToText(TextConvertState &State)
 {
 	const static char *Rule = "------------------------------------------------------";
 	int DepthInc = 0;
 
 	switch (TagId)
 	{
 		default: break;
 		case TAG_P:
 			if (State.GetPrev())
 				State.NewLine();
 			break;
 		case TAG_UL:
 		case TAG_OL:
 			DepthInc = 2;
 			break;
 	}
 
 	if (ValidStrW(Txt))
 	{
 		for (int i=0; i<State.Depth; i++)
 			State.Write("  ", 2);
 		
 		if (TagId == TAG_LI)
 			State.Write("* ", 2);
 
 		LFont *f = GetFont();
 		LAutoString u;
 		if (f)
 			u = f->ConvertToUnicode(Txt);
 		else
 			u.Reset(WideToUtf8(Txt));
 		if (u)
 		{
 			size_t u_len = strlen(u);
 			State.Write(u, u_len);
 		}
 	}
 	
 	State.Depth += DepthInc;
 	
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *c = ToTag(Children[i]);
 		c->ConvertToText(State);
 	}
 
 	State.Depth -= DepthInc;
 	
 	if (IsBlock())
 	{
 		if (State.CharsOnLine)
 			State.NewLine();
 	}
 	else
 	{
 		switch (TagId)
 		{
 			case TAG_A:
 			{
 				// Emit the link to the anchor if it's different from the text of the span...
 				const char *Href;
 				if (Get("href", Href) &&
 					ValidStrW(Txt))
 				{
 					if (_strnicmp(Href, "mailto:", 7) == 0)
 						Href += 7;
 						
 					size_t HrefLen = strlen(Href);
 					LAutoWString h(CleanText(Href, HrefLen, "utf-8"));
 					if (h && StrcmpW(h, Txt) != 0)
 					{
 						// Href different from the text of the link
 						State.Write(" (", 2);
 						State.Write(Href, HrefLen);
 						State.Write(")", 1);
 					}
 				}
 				break;
 			}
 			case TAG_HR:
 			{
 				State.Write(Rule, strlen(Rule));
 				State.NewLine();
 				break;
 			}
 			case TAG_BR:
 			{
 				State.NewLine();
 				break;
 			}
 			default:
 				break;
 		}
 	}
 	
 	return true;
 }
 
 char *LTag::NextTag(char *s)
 {
 	while (s && *s)
 	{
 		char *n = strchr(s, '<');
 		if (n)
 		{
 			if (!n[1])
 				return NULL;
 
 			if (IsAlpha(n[1]) || strchr("!/", n[1]) || n[1] == '?')
 			{
 				return n;
 			}
 
 			s = n + 1;
 		}
 		else break;
 	}
 
 	return 0;
 }
 
 void LHtml::CloseTag(LTag *t)
 {
 	if (!t)
 		return;
 
 	OpenTags.Delete(t);
 }
 
 bool LTag::OnUnhandledColor(LCss::ColorDef *def, const char *&s)
 {
 	const char *e = s;
 	while (*e && (IsText(*e) || *e == '_'))
 		e++;
 
 	char tmp[256];
 	ssize_t len = e - s;
 	memcpy(tmp, s, len);
 	tmp[len] = 0;
 	int m = LHtmlStatic::Inst->ColourMap.Find(tmp);
 	s = e;
 
 	if (m >= 0)
 	{
 		def->Type = LCss::ColorRgb;
 		def->Rgb32 = Rgb24To32(m);
 		return true;
 	}
 
 	return false;
 }
 
 void LTag::ZeroTableElements()
 {
 	if (TagId == TAG_TABLE ||
 		TagId == TAG_TR ||
 		IsTableCell(TagId))
 	{
 		Size.x = 0;
 		Size.y = 0;
 		if (Cell)
 		{
 			Cell->MinContent = 0;
 			Cell->MaxContent = 0;
 		}
 
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			LTag *t = ToTag(Children[i]);
 			t->ZeroTableElements();
 		}
 	}
 }
 
 void LTag::ResetCaches()
 {
 	/*
 	If during the parse process a callback causes a layout to happen then it's possible
 	to have partial information in the LHtmlTableLayout structure, like missing TD cells.
 	Because they haven't been parsed yet.
 	This is called at the end of the parsing to reset all the cached info in LHtmlTableLayout.
 	That way when the first real layout happens all the data is there.
 	*/
 	if (Cell)
 		DeleteObj(Cell->Cells);
 	for (size_t i=0; i<Children.Length(); i++)
 		ToTag(Children[i])->ResetCaches();
 }
 
 LPoint LTag::GetTableSize()
 {
 	LPoint s(0, 0);
 	
 	if (Cell && Cell->Cells)
 	{
 		Cell->Cells->GetSize(s.x, s.y);
 	}
 
 	return s;
 }
 
 LTag *LTag::GetTableCell(int x, int y)
 {
 	LTag *t = this;
 	while (	t &&
 			!t->Cell &&
 			!t->Cell->Cells &&
 			t->Parent)
 	{
 		t = ToTag(t->Parent);
 	}
 	
 	if (t && t->Cell && t->Cell->Cells)
 	{
 		return t->Cell->Cells->Get(x, y);
 	}
 
 	return 0;
 }
 
 // This function gets the largest and smallest piece of content
 // in this cell and all it's children.
 bool LTag::GetWidthMetrics(LTag *Table, uint16 &Min, uint16 &Max)
 {
 	bool Status = true;
 	int MarginPx = 0;
 	int LineWidth = 0;
 
 	if (Display() == LCss::DispNone)
 		return true;
 
 	// Break the text into words and measure...
 	if (Text())
 	{
 		int MinContent = 0;
 		int MaxContent = 0;
 
 		LFont *f = GetFont();
 		if (f)
 		{
 			for (char16 *s = Text(); s && *s; )
 			{
 				// Skip whitespace...
 				while (*s && StrchrW(WhiteW, *s)) s++;
 				
 				// Find end of non-whitespace
 				char16 *e = s;
 				while (*e && !StrchrW(WhiteW, *e)) e++;
 				
 				// Find size of the word
 				ssize_t Len = e - s;
 				if (Len > 0)
 				{
 					LDisplayString ds(f, s, Len);
 					MinContent = MAX(MinContent, ds.X());
 				}
 				
 				// Move to the next word.
 				s = (*e) ? e + 1 : 0;
 			}
 
 			LDisplayString ds(f, Text());
 			LineWidth = MaxContent = ds.X();
 		}
 
 		#if 0//def _DEBUG
 		if (Debug)
 		{
 			LgiTrace("GetWidthMetrics Font=%p Sz=%i,%i\n", f, MinContent, MaxContent);
 		}
 		#endif
 		
 		Min = MAX(Min, MinContent);
 		Max = MAX(Max, MaxContent);
 	}
 
 	// Specific tag handling?
 	switch (TagId)
 	{
 		default:
 		{
 			if (IsBlock())
 			{
 				MarginPx = (int)(BorderLeft().ToPx() +
 								BorderRight().ToPx() +
 								PaddingLeft().ToPx() +
 								PaddingRight().ToPx());
 			}
 			break;
 		}
 		case TAG_IMG:
 		{
 			Len w = Width();
 			if (w.IsValid())
 			{
 				int x = (int) w.Value;
 				Min = MAX(Min, x);
 				Max = MAX(Max, x);
 			}
 			else if (Image)
 			{
 				Min = Max = Image->X();
 			}
 			else
 			{
 				Size.x = Size.y = DefaultImgSize;
 				Min = MAX(Min, Size.x);
 				Max = MAX(Max, Size.x);
 			}
 			break;
 		}
 		case TAG_TD:
 		case TAG_TH:
 		{
 			Len w = Width();
 			if (w.IsValid())
 			{
 				if (w.IsDynamic())
 				{
 					Min = MAX(Min, (int)w.Value);
 					Max = MAX(Max, (int)w.Value);
 				}
 				else
 				{
 					Max = w.ToPx(0, GetFont());
 				}
 			}
 			else
 			{
 				LCss::BorderDef BLeft = BorderLeft();
 				LCss::BorderDef BRight = BorderRight();
 				LCss::Len PLeft = PaddingLeft();
 				LCss::Len PRight = PaddingRight();
 				
 				MarginPx = (int)(PLeft.ToPx()  +
 								PRight.ToPx()  + 
 								BLeft.ToPx());
 				
 				if (Table->BorderCollapse() == LCss::CollapseCollapse)
 					MarginPx += BRight.ToPx();
 			}
 			break;
 		}
 		case TAG_TABLE:
 		{
 			Len w = Width();
 			if (w.IsValid() && !w.IsDynamic())
 			{
 				// Fixed width table...
 				int CellSpacing = BorderSpacing().ToPx(Min, GetFont());
 				
 				int Px = ((int)w.Value) + (CellSpacing << 1);
 				Min = MAX(Min, Px);
 				Max = MAX(Max, Px);
 				return true;
 			}
 			else
 			{
 				LPoint s;
 				LHtmlTableLayout c(this);
 				c.GetSize(s.x, s.y);
 
 				// Auto layout table
 				LArray<int> ColMin, ColMax;
 				for (int y=0; y<s.y; y++)
 				{
 					for (int x=0; x<s.x;)
 					{
 						LTag *t = c.Get(x, y);
 						if (t)
 						{
 							uint16 a = 0, b = 0;							
 							if (t->GetWidthMetrics(Table, a, b))
 							{
 								ColMin[x] = MAX(ColMin[x], a);
 								ColMax[x] = MAX(ColMax[x], b);
 							}
 							
 							x += t->Cell->Span.x;
 						}
 						else break;
 					}
 				}
 				
 				int MinSum = 0, MaxSum = 0;
 				for (int i=0; i<s.x; i++)
 				{
 					MinSum += ColMin[i];
 					MaxSum += ColMax[i];
 				}
 				
 				Min = MAX(Min, MinSum);
 				Max = MAX(Max, MaxSum);
 				return true;
 			}
 			break;
 		}
 	}
 
 	for (unsigned i = 0; i < Children.Length(); i++)
 	{
 		LTag *c = ToTag(Children[i]);
 		uint16 TagMax = 0;
 		
 		Status &= c->GetWidthMetrics(Table, Min, TagMax);
 		LineWidth += TagMax;
 		if (c->TagId == TAG_BR ||
 			c->TagId == TAG_LI)
 		{
 			Max = MAX(Max, LineWidth);
 			LineWidth = 0;
 		}
 	}
 	Max = MAX(Max, LineWidth);
 
 	Min += MarginPx;
 	Max += MarginPx;
 	
 	return Status;
 }
 
 static void DistributeSize(LArray<int> &a, int Start, int Span, int Size, int Border)
 {
 	// Calculate the current size of the cells
 	int Cur = -Border;
 	for (int i=0; i<Span; i++)
 	{
 		Cur += a[Start+i] + Border;
 	}
 
 	// Is there more to allocate?
 	if (Cur < Size)
 	{
 		// Distribute size amongst the rows
 		int Needs = Size - Cur;
 		int Part = Needs / Span;
 		for (int k=0; k<Span; k++)
 		{
 			int Add = k < Span - 1 ? Part : Needs;
 			a[Start+k] = a[Start+k] + Add;
 			Needs -= Add;
 		}
 	}
 }
 
 template <class T>
 T Sum(LArray<T> &a)
 {
 	T s = 0;
 	for (unsigned i=0; i<a.Length(); i++)
 		s += a[i];
 	return s;
 }
 
 void LTag::LayoutTable(LFlowRegion *f, uint16 Depth)
 {
 	if (!Cell->Cells)
 	{
 		#if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 		if (Debug)
 		{
 			//int asd=0;
 		}
 		#endif
 		Cell->Cells = new LHtmlTableLayout(this);
 		#if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 		if (Cell->Cells && Debug)
 			Cell->Cells->Dump();
 		#endif
 	}
 	if (Cell->Cells)
 		Cell->Cells->LayoutTable(f, Depth);
 }
 
 void LHtmlTableLayout::AllocatePx(int StartCol, int Cols, int MinPx, bool HasToFillAllAvailable)
 {
 	// Get the existing total size and size of the column set
 	int CurrentTotalX = GetTotalX();
 	int CurrentSpanX = GetTotalX(StartCol, Cols);
 	int MaxAdditionalPx = AvailableX - CurrentTotalX;
 	if (MaxAdditionalPx <= 0)
 		return;
 
 	// Calculate the maximum space we have for this column set
 	int AvailPx = (CurrentSpanX + MaxAdditionalPx) - BorderX1 - BorderX2;
 	
 	// Allocate any remaining space...
 	int RemainingPx = MaxAdditionalPx;
 	LArray<int> Growable, NonGrowable, SizeInherit;
 	int GrowablePx = 0;
 	for (int x=StartCol; x<StartCol+Cols; x++)
 	{
 		int DiffPx = MaxCol[x] - MinCol[x];
 		if (DiffPx > 0)
 		{
 			GrowablePx += DiffPx;
 			Growable.Add(x);
 		}
 		else if (MinCol[x] > 0)
 		{
 			NonGrowable.Add(x);
 		}
 		else if (MinCol[x] == 0 && CurrentSpanX < AvailPx)
 		{
 			// Growable.Add(x);
 		}
 		
 		if (SizeCol[x].Type == LCss::LenInherit)
 			SizeInherit.Add(x);
 	}
 	if (GrowablePx < RemainingPx && HasToFillAllAvailable)
 	{
 		if (Growable.Length() == 0)
 		{
 			// Add any suitable non-growable columns as well
 			for (unsigned i=0; i<NonGrowable.Length(); i++)
 			{
 				int Col = NonGrowable[i];
 				
 				LCss::Len c = SizeCol[Col];
 				if (c.Type != LCss::LenPercent && c.IsDynamic())
 					Growable.Add(Col);
 			}
 		}
 		
 		if (Growable.Length() == 0)
 		{
 			// Still nothing to grow... so just pick the largest column
 			int Largest = -1;
 			for (int i=StartCol; i<StartCol+Cols; i++)
 			{
 				if (Largest < 0 || MinCol[i] > MinCol[Largest])
 					Largest = i;
 			}
 			Growable.Add(Largest);
 		}
 	}
 	
 	if (Growable.Length())
 	{
 		// Some growable columns...
 		int Added = 0;
 
 		// Reasonably increase the size of the columns...
 		for (unsigned i=0; i<Growable.Length(); i++)
 		{
 			int x = Growable[i];
 			int DiffPx = MaxCol[x] - MinCol[x];
 			int AddPx = 0;
 			if (GrowablePx < RemainingPx && DiffPx > 0)
 			{
 				AddPx = DiffPx;
 			}
 			else if (DiffPx > 0)
 			{
 				double Ratio = (double)DiffPx / GrowablePx;
 				AddPx = (int) (Ratio * RemainingPx);
 			}
 			else
 			{
 				AddPx = RemainingPx / (int)Growable.Length();
 			}
 								
 			LAssert(AddPx >= 0);
 			MinCol[x] += AddPx;
 			LAssert(MinCol[x] >= 0);
 			Added += AddPx;
 		}
 
 		if (Added < RemainingPx && HasToFillAllAvailable)
 		{
 			// Still more to add, so
 			if (SizeInherit.Length())
 			{
 				Growable = SizeInherit;
 			}
 			else
 			{
 				int Largest = -1;
 				for (unsigned i=0; i<Growable.Length(); i++)
 				{
 					int x = Growable[i];
 					if (Largest < 0 || MinCol[x] > MinCol[Largest])
 						Largest = x;
 				}
 				Growable.Length(1);
 				Growable[0] = Largest;
 			}
 
 			int AddPx = (RemainingPx - Added) / (int)Growable.Length();
 			for (unsigned i=0; i<Growable.Length(); i++)
 			{
 				int x = Growable[i];
 				if (i == Growable.Length() - 1)
 				{
 					MinCol[x] += RemainingPx - Added;
 					LAssert(MinCol[x] >= 0);
 				}
 				else
 				{
 					MinCol[x] += AddPx;
 					LAssert(MinCol[x] >= 0);
 					Added += AddPx;
 				}
 			}
 		}
 	}
 }
 
 struct ColInfo
 {
 	int Large;
 	int Growable;
 	int Idx;
 	int Px;
 };
 
 int ColInfoCmp(ColInfo *a, ColInfo *b)
 {
 	int LDiff = b->Large - a->Large;
 	int LGrow = b->Growable - a->Growable;
 	int LSize = b->Px - a->Px;
 	return LDiff + LGrow + LSize;
 }
 
 void LHtmlTableLayout::DeallocatePx(int StartCol, int Cols, int MaxPx)
 {
 	int TotalPx = GetTotalX(StartCol, Cols);
 	if (TotalPx <= MaxPx || MaxPx == 0)
 		return;
 	
 	int TrimPx = TotalPx - MaxPx;
 	LArray<ColInfo> Inf;
 	int HalfMax = MaxPx >> 1;
 	unsigned Interesting = 0;
 	int InterestingPx = 0;
 	
 	for (int x=StartCol; x<StartCol+Cols; x++)
 	{
 		ColInfo &ci = Inf.New();
 		ci.Idx = x;
 		ci.Px = MinCol[x];
 		ci.Large = MinCol[x] > HalfMax;
 		ci.Growable = MinCol[x] < MaxCol[x];
 		if (ci.Large || ci.Growable)
 		{
 			Interesting++;
 			InterestingPx += ci.Px;
 		}
 	}
 	
 	Inf.Sort(ColInfoCmp);
 	
 	if (InterestingPx > 0)
 	{
 		for (unsigned i=0; i<Interesting; i++)
 		{
 			ColInfo &ci = Inf[i];
 			double r = (double)ci.Px / InterestingPx;
 			int DropPx = (int) (r * TrimPx);
 			if (DropPx < MinCol[ci.Idx])
 			{
 				MinCol[ci.Idx] -= DropPx;
 				LAssert(MinCol[ci.Idx] >= 0);
 			}
 			else
 				break;
 		}
 	}
 }
 
 int LHtmlTableLayout::GetTotalX(int StartCol, int Cols)
 {
 	if (Cols < 0)
 		Cols = s.x;
 	
 	int TotalX = BorderX1 + BorderX2 + CellSpacing;
 	for (int x=StartCol; x<Cols; x++)
 		TotalX += MinCol[x] + CellSpacing;
 	
 	return TotalX;
 }
 
 void LHtmlTableLayout::LayoutTable(LFlowRegion *f, uint16 Depth)
 {
 	GetSize(s.x, s.y);
 	if (s.x == 0 || s.y == 0)
 	{
 		return;
 	}
 
 	Table->ZeroTableElements();
 	MinCol.Length(0);
 	MaxCol.Length(0);
 	MaxRow.Length(0);
 	SizeCol.Length(0);
 	
 	LCss::Len BdrSpacing = Table->BorderSpacing();
 	CellSpacing = BdrSpacing.IsValid() ? (int)BdrSpacing.Value : 0;
 
 	// Resolve total table width.
 	TableWidth = Table->Width();
 	if (TableWidth.IsValid())
 		AvailableX = f->ResolveX(TableWidth, Table, false);
 	else
 		AvailableX = f->X();
 
 	LCss::Len MaxWidth = Table->MaxWidth();
 	if (MaxWidth.IsValid())
 	{
 	    int Px = f->ResolveX(MaxWidth, Table, false);
 	    if (Px < AvailableX)
 	        AvailableX = Px;
 	}
 	
 	TableBorder = f->ResolveBorder(Table, Table);
 	if (Table->BorderCollapse() != LCss::CollapseCollapse)
 		TablePadding = f->ResolvePadding(Table, Table);
 	else
 		TablePadding.ZOff(0, 0);
 	
 	BorderX1 = TableBorder.x1 + TablePadding.x1;
 	BorderX2 = TableBorder.x2 + TablePadding.x2;
 	
 	#if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 	if (Table->Debug)
 		LgiTrace("AvailableX=%i, BorderX1=%i, BorderX2=%i\n", AvailableX, BorderX1, BorderX2);
 	#endif
 
 	#ifdef _DEBUG
 	if (Table->Debug)
 	{
 		printf("Table Debug\n");
 	}
 	#endif
 
 	// Size detection pass
 	int y;
 	for (y=0; y<s.y; y++)
 	{
 		for (int x=0; x<s.x; )
 		{
 			LTag *t = Get(x, y);
 			if (t)
 			{
 				// This is needed for the metrics...
 				t->GetFont();
 				t->Cell->BorderPx = f->ResolveBorder(t, t);
 				t->Cell->PaddingPx = f->ResolvePadding(t, t);
 
 				if (t->Cell->Pos.x == x && t->Cell->Pos.y == y)
 				{
 					LCss::DisplayType Disp = t->Display();
 					if (Disp == LCss::DispNone)
 						continue;
 
 					LCss::Len Content = t->Width();
 					if (Content.IsValid() && t->Cell->Span.x == 1)
 					{
 						if (SizeCol[x].IsValid())
 						{
 							int OldPx = f->ResolveX(SizeCol[x], t, false);
 							int NewPx = f->ResolveX(Content, t, false);
 							if (NewPx > OldPx)
 							{
 								SizeCol[x] = Content;
 							}
 						}
 						else
 						{
 							SizeCol[x] = Content;
 						}
 					}
 					
 					if (!t->GetWidthMetrics(Table, t->Cell->MinContent, t->Cell->MaxContent))
 					{
 						t->Cell->MinContent = 16;
 						t->Cell->MaxContent = 16;
 					}
 					
 					#if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 					if (Table->Debug)
 						LgiTrace("Content[%i,%i] MIN=%i MAX=%i\n", x, y, t->Cell->MinContent, t->Cell->MaxContent);
 					#endif
 
 					if (t->Cell->Span.x == 1)
 					{
 						int BoxPx = t->Cell->BorderPx.x1 +
 									t->Cell->BorderPx.x2 +
 									t->Cell->PaddingPx.x1 +
 									t->Cell->PaddingPx.x2;
 
 						MinCol[x] = MAX(MinCol[x], t->Cell->MinContent + BoxPx);
 						LAssert(MinCol[x] >= 0);
 						MaxCol[x] = MAX(MaxCol[x], t->Cell->MaxContent + BoxPx);
 					}
 				}
 				
 				x += t->Cell->Span.x;
 			}
 			else break;
 		}
 	}
 	
 	// How much space used so far?
 	int TotalX = GetTotalX();
 	if (TotalX > AvailableX)
 	{
 		// FIXME:
 		// Off -> 'cisra-cqs.html' renders correctly.
 		// On -> 'cisra_outage.html', 'steam1.html' renders correctly.
 		#if 1
 		DeallocatePx(0, (int)MinCol.Length(), AvailableX);
 		TotalX = GetTotalX();
 		#endif
 	}
 
 	#if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 	#define DumpCols(msg) \
 		if (Table->Debug) \
 		{ \
 			LgiTrace("%s Ln%i - TotalX=%i AvailableX=%i\n", msg, __LINE__, TotalX, AvailableX); \
 			for (unsigned i=0; i<MinCol.Length(); i++) \
 				LgiTrace("\t[%i] = %i/%i\n", i, MinCol[i], MaxCol[i]); \
 		}
 
 	#else
 	#define DumpCols(msg)
 	#endif
 
 	DumpCols("AfterSingleCells");
 
 	#ifdef _DEBUG
 	if (Table->Debug)
 	{
 		printf("TableDebug\n");
 	}
 	#endif
 
 	// Process spanned cells
 	for (y=0; y<s.y; y++)
 	{
 		for (int x=0; x<s.x; )
 		{
 			LTag *t = Get(x, y);
 			if (t && t->Cell->Pos.x == x && t->Cell->Pos.y == y)
 			{
 				if (t->Cell->Span.x > 1 || t->Cell->Span.y > 1)
 				{
 					int i;
 					int ColMin = -CellSpacing;
 					int ColMax = -CellSpacing;
 					for (i=0; i<t->Cell->Span.x; i++)
 					{
 						ColMin += MinCol[x + i] + CellSpacing;
 						ColMax += MaxCol[x + i] + CellSpacing;
 					}
 					
 					LCss::Len Width = t->Width();
 					if (Width.IsValid())
 					{
 						int Px = f->ResolveX(Width, t, false);
 						t->Cell->MinContent = MAX(t->Cell->MinContent, Px);
 						t->Cell->MaxContent = MAX(t->Cell->MaxContent, Px);
 					}
 
 					#if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 					if (Table->Debug)
 						LgiTrace("Content[%i,%i] MIN=%i MAX=%i\n", x, y, t->Cell->MinContent, t->Cell->MaxContent);
 					#endif
 
 					if (t->Cell->MinContent > ColMin)
 						AllocatePx(t->Cell->Pos.x, t->Cell->Span.x, t->Cell->MinContent, false);
 					if (t->Cell->MaxContent > ColMax)
 						DistributeSize(MaxCol, t->Cell->Pos.x, t->Cell->Span.x, t->Cell->MaxContent, CellSpacing);
 				}
 
 				x += t->Cell->Span.x;
 			}
 			else break;
 		}
 	}
 
 	TotalX = GetTotalX();
 	DumpCols("AfterSpannedCells");
 
 	// Sometimes the web page specifies too many percentages:
 	// Scale them all.	
 	float PercentSum = 0.0f;
 	for (int i=0; i<s.x; i++)
 	{
 		if (SizeCol[i].Type == LCss::LenPercent)
 			PercentSum += SizeCol[i].Value;
 	}	
 	if (PercentSum > 100.0)
 	{
 		float Ratio = PercentSum / 100.0f;
 		for (int i=0; i<s.x; i++)
 		{
 			if (SizeCol[i].Type == LCss::LenPercent)
 				SizeCol[i].Value /= Ratio;
 		}
 	}
 	
 	// Do minimum column size from CSS values
 	if (TotalX < AvailableX)
 	{
 		for (int x=0; x<s.x; x++)
 		{
 			LCss::Len w = SizeCol[x];
 			if (w.IsValid())
 			{
 				int Px = f->ResolveX(w, Table, false);
 				
 				if (w.Type == LCss::LenPercent)
 				{
 					MaxCol[x] = Px;
 				}
 				else if (Px > MinCol[x])
 				{
 					int RemainingPx = AvailableX - TotalX;
 					int AddPx = Px - MinCol[x];
 					AddPx = MIN(RemainingPx, AddPx);
 					
 					TotalX += AddPx;
 					MinCol[x] += AddPx;
 					LAssert(MinCol[x] >= 0);
 				}
 			}
 		}
 	}
 
 	TotalX = GetTotalX();
 	DumpCols("AfterCssNonPercentageSizes");
 	
 	if (TotalX > AvailableX)
 	{
 		#if !ALLOW_TABLE_GROWTH
 		// Deallocate space if overused
 		// Take some from the largest column
 		int Largest = 0;
 		for (int i=0; i<s.x; i++)
 		{
 			if (MinCol[i] > MinCol[Largest])
 			{
 				Largest = i;
 			}
 		}
 		int Take = TotalX - AvailableX;
 		if (Take < MinCol[Largest])
 		{
 			MinCol[Largest] = MinCol[Largest] - Take;
 			LAssert(MinCol[Largest] >= 0);
 			TotalX -= Take;
 		}
 
 		DumpCols("AfterSpaceDealloc");
 		#endif
 	}
 	else if (TotalX < AvailableX)
 	{
 		AllocatePx(0, s.x, AvailableX, TableWidth.IsValid());
 		DumpCols("AfterRemainingAlloc");
 	}
 
 	// Layout cell horizontally and then flow the contents to get 
 	// the height of all the cells
 	LArray<LRect> RowPad;
 	MaxRow.Length(s.y);
 	for (y=0; y<s.y; y++)
 	{
 		int XPos = CellSpacing;
 		for (int x=0; x<s.x; )
 		{
 			auto t = Get(x, y);
 			if (!t)
 			{
 				x++;
 				continue;
 			}
 
 			if (t->Cell->Pos.x == x && t->Cell->Pos.y == y)
 			{
 				t->Pos.x = XPos;
 				t->Size.x = -CellSpacing;
 				XPos -= CellSpacing;
 					
 				RowPad[y].y1 = MAX(RowPad[y].y1, t->Cell->BorderPx.y1 + t->Cell->PaddingPx.y1);
 				RowPad[y].y2 = MAX(RowPad[y].y2, t->Cell->BorderPx.y2 + t->Cell->PaddingPx.y2);
 					
 				LRect Box(0, 0, -CellSpacing, 0);
 				for (int i=0; i<t->Cell->Span.x; i++)
 				{
 					int ColSize = MinCol[x + i] + CellSpacing;
 					LAssert(ColSize >= 0);
 					if (ColSize < 0)
 						break;
 					t->Size.x += ColSize;
 					XPos += ColSize;
 					Box.x2 += ColSize;
 				}
 					
 				LCss::Len Ht = t->Height();
 				LFlowRegion r(Table->Html, Box, true);
 
 				t->OnFlow(&r, Depth+1);
 
 				if (r.MAX.y > r.y2)
 				{
 					t->Size.y = MAX(r.MAX.y, t->Size.y);
 				}
 
 					
 				if (Ht.IsValid() &&
 					Ht.Type != LCss::LenPercent)
 				{
 					int h = f->ResolveY(Ht, t, false);
 					t->Size.y = MAX(h, t->Size.y);
 
 					DistributeSize(MaxRow, y, t->Cell->Span.y, t->Size.y, CellSpacing);
 				}
 			}
 
 			x += t->Cell->Span.x;
 		}
 	}
 
 	#if defined(_DEBUG)
 	DEBUG_LOG("%s:%i - AfterCellFlow\n", _FL);
 	for (unsigned i=0; i<MaxRow.Length(); i++)
 		DEBUG_LOG("[%i] = %i\n", i, MaxRow[i]);
 	#endif
 
 	// Calculate row height
 	for (y=0; y<s.y; y++)
 	{
 		for (int x=0; x<s.x; )
 		{
 			LTag *t = Get(x, y);
 			if (t)
 			{
 				if (t->Cell->Pos.x == x && t->Cell->Pos.y == y)
 				{
 					LCss::Len Ht = t->Height();
 					if (!(Ht.IsValid() && Ht.Type != LCss::LenPercent))
 					{
 						DistributeSize(MaxRow, y, t->Cell->Span.y, t->Size.y, CellSpacing);
 					}
 				}
 
 				x += t->Cell->Span.x;
 			}
 			else break;
 		}			
 	}
 	
 	// Cell positioning
 	int Cx = BorderX1 + CellSpacing;
 	int Cy = TableBorder.y1 + TablePadding.y1 + CellSpacing;
 	
 	for (y=0; y<s.y; y++)
 	{
 		LTag *Prev = 0;
 		for (int x=0; x<s.x; )
 		{
 			LTag *t = Get(x, y);
 			if (!t && Prev)
 			{
 				// Add missing cell
 				LTag *Row = ToTag(Prev->Parent);
 				if (Row && Row->TagId == TAG_TR)
 				{
 					t = new LTag(Table->Html, Row);
 					if (t)
 					{
 						t->TagId = TAG_TD;
 						t->Tag.Reset(NewStr("td"));
 						t->Info = Table->Html->GetTagInfo(t->Tag);
 						if ((t->Cell = new LTag::TblCell))
 						{
 							t->Cell->Pos.x = x;
 							t->Cell->Pos.y = y;
 							t->Cell->Span.x = 1;
 							t->Cell->Span.y = 1;
 						}
 						t->BackgroundColor(LCss::ColorDef(LCss::ColorRgb, DefaultMissingCellColour));
 
 						Set(Table);
 					}
 					else break;
 				}
 				else break;
 			}
 			if (t)
 			{
 				if (t->Cell->Pos.x == x && t->Cell->Pos.y == y)
 				{
 					int RowPadOffset =	RowPad[y].y1 -
 										t->Cell->BorderPx.y1 -
 										t->Cell->PaddingPx.y1;
 					
 					t->Pos.x = Cx;
 					t->Pos.y = Cy + RowPadOffset;
 					
 					t->Size.x = -CellSpacing;
 					for (int i=0; i<t->Cell->Span.x; i++)
 					{
 						int w = MinCol[x + i] + CellSpacing;
 						t->Size.x += w;
 						Cx += w;
 					}
 					t->Size.y = -CellSpacing;						
 					for (int n=0; n<t->Cell->Span.y; n++)
 					{
 						t->Size.y += MaxRow[y+n] + CellSpacing;
 					}
 					
 					Table->Size.x = MAX(Cx + BorderX2, Table->Size.x);
 
 					#if defined(_DEBUG) && DEBUG_TABLE_LAYOUT
 					if (Table->Debug)
 					{
 						LgiTrace("cell(%i,%i) = pos(%i,%i)+size(%i,%i)\n",
 							t->Cell->Pos.x, t->Cell->Pos.y,
 							t->Pos.x, t->Pos.y,
 							t->Size.x, t->Size.y);
 					}
 					#endif
 				}
 				else
 				{
 					Cx += t->Size.x + CellSpacing;
 				}
 				
 				x += t->Cell->Span.x;
 			}
 			else break;
 			Prev = t;
 		}
 		
 		Cx = BorderX1 + CellSpacing;
 		Cy += MaxRow[y] + CellSpacing;
 	}
 
 	switch (Table->Cell->XAlign ? Table->Cell->XAlign : ToTag(Table->Parent)->GetAlign(true))
 	{
 		case LCss::AlignCenter:
 		{
 			int fx = f->X();
 			int Ox = (fx-Table->Size.x) >> 1;
 			Table->Pos.x = f->x1 + MAX(Ox, 0);
 			DEBUG_LOG("%s:%i - AlignCenter fx=%i ox=%i pos.x=%i size.x=%i\n", _FL, fx, Ox, Table->Pos.x, Table->Size.x);
 			break;
 		}
 		case LCss::AlignRight:
 		{
 			Table->Pos.x = f->x2 - Table->Size.x;
 			DEBUG_LOG("%s:%i - AlignRight f->x2=%i size.x=%i pos.x=%i\n", _FL, f->x2, Table->Size.x, Table->Pos.x);
 			break;
 		}
 		default:
 		{
 			Table->Pos.x = f->x1;
 			DEBUG_LOG("%s:%i - AlignLeft f->x1=%i size.x=%i pos.x=%i\n", _FL, f->x2, Table->Size.x, Table->Pos.x);
 			break;
 		}
 	}
 	
 	Table->Pos.y = f->y1;
 	Table->Size.y = Cy + TablePadding.y2 + TableBorder.y2;
 }
 
 LRect LTag::ChildBounds()
 {
 	LRect b(0, 0, -1, -1);
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		if (i)
 		{
 			LRect c = t->GetRect();
 			b.Union(&c);
 		}
 		else
 		{
 			b = t->GetRect();
 		}
 	}
 
 	return b;
 }
 
 LPoint LTag::AbsolutePos()
 {
 	LPoint p;
 	for (LTag *t=this; t; t=ToTag(t->Parent))
 	{
 		p += t->Pos;
 	}
 	return p;
 }
 
 void LTag::SetSize(LPoint &s)
 {
 	Size = s;
 }
 
 LHtmlArea::~LHtmlArea()
 {
 	DeleteObjects();
 }
 
 LRect LHtmlArea::Bounds()
 {
 	LRect n(0, 0, -1, -1);
 
 	for (unsigned i=0; i<Length(); i++)
 	{
 		LFlowRect *r = (*this)[i];
 		if (r)
 		{
 			if (i)
 				n.Union(r);
 			else
 				n = r;
 		}
 	}
 	
 	return n;
 }
 
 LRect *LHtmlArea::TopRect(LRegion *c)
 {
 	LRect *Top = 0;
 	
 	for (int i=0; i<c->Length(); i++)
 	{
 		LRect *r = (*c)[i];
 		if (!Top || (r && (r->y1 < Top->y1)))
 		{
 			Top = r;
 		}
 	}
 
 	return Top;
 }
 
 void LHtmlArea::FlowText(LTag *Tag, LFlowRegion *Flow, LFont *Font, int LineHeight, char16 *Text, LCss::LengthType Align)
 {
 	if (!Flow || !Text || !Font)
 		return;
 
 	SetFixedLength(false);
 	char16 *Start = Text;
 	size_t FullLen = StrlenW(Text);
 
 	#if 1
 	if (!Tag->Html->GetReadOnly() && !*Text)
 	{
 		// Insert a text rect for this tag, even though it's empty.
 		// This allows the user to place the cursor on a blank line.
 		LFlowRect *Tr = new LFlowRect;
 		Tr->Tag = Tag;
 		Tr->Text = Text;
 		Tr->x1 = Flow->cx;
 		Tr->x2 = Tr->x1 + 1;
 		Tr->y1 = Flow->y1;
 		Tr->y2 = Tr->y1 + Font->GetHeight();
 		LAssert(Tr->y2 >= Tr->y1);
 		Flow->y2 = MAX(Flow->y2, Tr->y2+1);
 		Flow->cx = Tr->x2 + 1;
 
 		Add(Tr);
 		Flow->Insert(Tr, Align);
 		return;				
 	}
 	#endif
 	
 	while (*Text)
 	{
 		LFlowRect *Tr = new LFlowRect;
 		if (!Tr)
 			break;
 
 		Tr->Tag = Tag;
 	Restart:
 		Tr->x1 = Flow->cx;
 		Tr->y1 = Flow->y1;
 
 		#if 1 // I removed this at one stage but forget why.
 		
 		// Remove white space at start of line if not in edit mode..
 		if (Tag->Html->GetReadOnly() && Flow->x1 == Flow->cx && *Text == ' ')
 		{
 			Text++;
 			if (!*Text)
 			{
 				DeleteObj(Tr);
 				break;
 			}
 		}
 		#endif
 		
 		Tr->Text = Text;
 
 		LDisplayString ds(Font, Text, MIN(1024, FullLen - (Text-Start)));
 		ssize_t Chars = ds.CharAt(Flow->X());
 		bool Wrap = false;
 		if (Text[Chars])
 		{
 			// Word wrap
 
 			// Seek back to the nearest break opportunity
 			ssize_t n = Chars;
 			while (n > 0 && !StrchrW(WhiteW, Text[n]))
 				n--;
 
 			if (n == 0)
 			{
 				if (Flow->x1 == Flow->cx)
 				{
 					// Already started from the margin and it's too long to 
 					// fit across the entire page, just let it hang off the right edge.
 
 					// Seek to the end of the word
 					for (Tr->Len = Chars; Text[Tr->Len] && !StrchrW(WhiteW, Text[Tr->Len]); Tr->Len++)
 						;
 
 					// Wrap...
 					if (*Text == ' ') Text++;
 				}
 				else
 				{
 					// Not at the start of the margin
 					Flow->FinishLine();
 					goto Restart;
 				}
 			}
 			else
 			{
 				Tr->Len = n;
 				LAssert(Tr->Len > 0);
 				Wrap = true;
 			}
 
 		}
 		else
 		{
 			// Fits..
 			Tr->Len = Chars;
 			LAssert(Tr->Len > 0);
 		}
 
 		LDisplayString ds2(Font, Tr->Text, Tr->Len);
 		Tr->x2 = ds2.X();
 		Tr->y2 = LineHeight > 0 ? LineHeight - 1 : 0;
 		
 		if (Wrap)
 		{
 			Flow->cx = Flow->x1;
 			Flow->y1 += Tr->y2 + 1;
 			Tr->x2 = Flow->x2 - Tag->RelX();
 		}
 		else
 		{
 			Tr->x2 += Tr->x1 - 1;
 			Flow->cx = Tr->x2 + 1;
 		}
 		Tr->y2 += Tr->y1;
 		Flow->y2 = MAX(Flow->y2, Tr->y2 + 1);
 		
 		Add(Tr);
 		Flow->Insert(Tr, Align);
 		
 		Text += Tr->Len;
 		if (Wrap)
 		{
 			while (*Text == ' ')
 				Text++;
 		}
 
 		Tag->Size.x = MAX(Tag->Size.x, Tr->x2 + 1);
 		Tag->Size.y = MAX(Tag->Size.y, Tr->y2 + 1);
 		Flow->MAX.x = MAX(Flow->MAX.x, Tr->x2);
 		Flow->MAX.y = MAX(Flow->MAX.y, Tr->y2);
 
 		if (Tr->Len == 0)
 			break;
 	}
 	
 	SetFixedLength(true);
 }
 
 char16 htoi(char16 c)
 {
 	if (c >= '0' && c <= '9')
 		return c - '0';
 	if (c >= 'a' && c <= 'f')
 		return c - 'a' + 10;
 	if (c >= 'A' && c <= 'F')
 		return c - 'A' + 10;
 	LAssert(0);
 	return 0;
 }
 
 bool LTag::Serialize(LXmlTag *t, bool Write)
 {
 	LRect pos;
 	if (Write)
 	{
 		// Obj -> Tag
 		if (Tag) t->SetAttr("tag", Tag);
 		pos.ZOff(Size.x, Size.y);
 		pos.Offset(Pos.x, Pos.y);
 		t->SetAttr("pos", pos.GetStr());
 		t->SetAttr("tagid", TagId);		
 		if (Txt)
 		{
 			LStringPipe p(256);
 			for (char16 *c = Txt; *c; c++)
 			{
 				if (*c > ' ' &&
 					*c < 127 &&
 					!strchr("%<>\'\"", *c))
 					p.Print("%c", (char)*c);
 				else
 					p.Print("%%%.4x", *c);
 			}
 			
 			LAutoString Tmp(p.NewStr());
 			t->SetContent(Tmp);
 		}
 		if (Props.Length())
 		{
 			auto CssStyles = ToString();
 			LAssert(!strchr(CssStyles, '\"'));
 			t->SetAttr("style", CssStyles);
 		}
 		if (Html->Cursor == this)
 		{
 			LAssert(Cursor >= 0);
 			t->SetAttr("cursor", (int64)Cursor);
 		}
 		else LAssert(Cursor < 0);
 		if (Html->Selection == this)
 		{
 			LAssert(Selection >= 0);
 			t->SetAttr("selection", (int64)Selection);
 		}
 		else LAssert(Selection < 0);
 		
 		for (unsigned i=0; i<Children.Length(); i++)
 		{
 			LXmlTag *child = new LXmlTag("e");
 			LTag *tag = ToTag(Children[i]);
 			if (!child || !tag)
 			{
 				LAssert(0);
 				return false;
 			}
 			t->InsertTag(child);
 			if (!tag->Serialize(child, Write))
 			{
 				return false;
 			}
 		}
 	}
 	else
 	{
 		// Tag -> Obj
 		Tag.Reset(NewStr(t->GetAttr("tag")));
 		TagId = (HtmlTag) t->GetAsInt("tagid");
 		pos.SetStr(t->GetAttr("pos"));
 		if (pos.Valid())
 		{
 			Pos.x = pos.x1;
 			Pos.y = pos.y1;
 			Size.x = pos.x2;
 			Size.y = pos.y2;
 		}
 		if (ValidStr(t->GetContent()))
 		{
 			LStringPipe p(256);
 			char *c = t->GetContent();
 			SkipWhiteSpace(c);
 			for (; *c && *c > ' '; c++)
 			{
 				char16 ch;
 				if (*c == '%')
 				{
 					ch = 0;
 					for (int i=0; i<4 && *c; i++)
 					{
 						ch <<= 4;
 						ch |= htoi(*++c);
 					}
 				}
 				else ch = *c;
 				p.Write(&ch, sizeof(ch));
 			}
 			Txt.Reset(p.NewStrW());
 		}
 		const char *s = t->GetAttr("style");
 		if (s)
 			Parse(s, ParseRelaxed);
 		s = t->GetAttr("cursor");
 		if (s)
 		{
 			LAssert(Html->Cursor == NULL);
 			Html->Cursor = this;
 			Cursor = atoi(s);
 			LAssert(Cursor >= 0);			
 		}
 		s = t->GetAttr("selection");
 		if (s)
 		{
 			LAssert(Html->Selection == NULL);
 			Html->Selection = this;
 			Selection = atoi(s);
 			LAssert(Selection >= 0);			
 		}
 		#ifdef _DEBUG
 		s = t->GetAttr("debug");
 		if (s && atoi(s) != 0)
 			Debug = true;
 		#endif
 		
 		for (int i=0; i<t->Children.Length(); i++)
 		{
 			LXmlTag *child = t->Children[i];
 			if (child->IsTag("e"))
 			{
 				LTag *tag = new LTag(Html, NULL);
 				if (!tag)
 				{
 					LAssert(0);
 					return false;
 				}
 				
 				if (!tag->Serialize(child, Write))
 				{
 					return false;
 				}
 				
 				Attach(tag);
 			}
 		}
 	}
 	
 	return true;
 }
 
 /*
 /// This method centers the text in the area given to the tag. Used for inline block elements.
 void LTag::CenterText()
 {
 	if (!Parent)
 		return;
 
 	// Find the size of the text elements.
 	int ContentPx = 0;
 	for (unsigned i=0; i<TextPos.Length(); i++)
 	{
 		LFlowRect *fr = TextPos[i];
 		ContentPx += fr->X();
 	}
 	
 	LFont *f = GetFont();
 	int ParentPx = ToTag(Parent)->Size.x;
 	int AvailPx = Size.x;
 
 	// Remove the border and padding from the content area
 	AvailPx -= BorderLeft().ToPx(ParentPx, f);
 	AvailPx -= BorderRight().ToPx(ParentPx, f);
 	AvailPx -= PaddingLeft().ToPx(ParentPx, f);
 	AvailPx -= PaddingRight().ToPx(ParentPx, f);
 	if (AvailPx > ContentPx)
 	{
 		// Now offset all the regions to the right
 		int OffPx = (AvailPx - ContentPx) >> 1;
 		for (unsigned i=0; i<TextPos.Length(); i++)
 		{
 			LFlowRect *fr = TextPos[i];
 			fr->Offset(OffPx, 0);
 		}
 	}
 }
 */
 
 void LTag::OnFlow(LFlowRegion *Flow, uint16 Depth)
 {
 	if (Depth >= MAX_RECURSION_DEPTH)
 		return;
 
 	DisplayType Disp = Display();
 	if (Disp == DispNone)
 		return;
 
 	LFont *f = GetFont();
 	LFlowRegion Local(*Flow);
 	bool Restart = true;
 	int BlockFlowWidth = 0;
 	const char *ImgAltText = NULL;
 
 	Size.x = 0;
 	Size.y = 0;
 	
 	LCssTools Tools(this, f);
 	LRect rc(Flow->X(), Html->Y());
 	PadPx = Tools.GetPadding(rc);
 
 	if (TipId)
 	{
 		Html->Tip.DeleteTip(TipId);
 		TipId = 0;
 	}
 
 	switch (TagId)
 	{
 		default:
 			break;
 		case TAG_BODY:
 		{
 			Flow->InBody++;
 			break;
 		}
 		case TAG_IFRAME:
 		{
 			LFlowRegion Temp = *Flow;
 			Flow->EndBlock();
 			Flow->Indent(this, MarginLeft(), MarginTop(), MarginRight(), MarginBottom(), true);
 
 			// Flow children
 			for (unsigned i=0; i<Children.Length(); i++)
 			{
 				LTag *t = ToTag(Children[i]);
 				t->OnFlow(&Temp, Depth + 1);
 
 				if (TagId == TAG_TR)
 				{
 					Temp.x2 -= MIN(t->Size.x, Temp.X());
 				}
 			}
 
 			Flow->Outdent(this, MarginLeft(), MarginTop(), MarginRight(), MarginBottom(), true);
 			BoundParents();
 			return;
 			break;
 		}
 		case TAG_TR:
 		{
 			Size.x = Flow->X();
 			break;
 		}
 		case TAG_IMG:
 		{
 			Size.x = Size.y = 0;
 			
 			LCss::Len w    = Width();
 			LCss::Len h    = Height();
 			// LCss::Len MinX = MinWidth();
 			// LCss::Len MaxX = MaxWidth();
 			LCss::Len MinY = MinHeight();
 			LCss::Len MaxY = MaxHeight();
 			LAutoPtr<LDisplayString> a;
 			int ImgX, ImgY;		
 			if (Image)
 			{
 				ImgX = Image->X();
 				ImgY = Image->Y();
 			}
 			else if (Get("alt", ImgAltText) && ValidStr(ImgAltText))
 			{
 				LDisplayString a(f, ImgAltText);
 				ImgX = a.X() + 4;
 				ImgY = a.Y() + 4;
 			}
 			else
 			{
 				ImgX = DefaultImgSize;
 				ImgY = DefaultImgSize;
 			}
 			
 			double AspectRatio = ImgY != 0 ? (double)ImgX / ImgY : 1.0;
 			bool XLimit = false, YLimit = false;
 			double Scale = 1.0;
 
 			if (w.IsValid() && w.Type != LenAuto)
 			{
 				Size.x = Flow->ResolveX(w, this, false);
 				XLimit = true;
 			}
 			else
 			{
 				int Fx = Flow->x2 - Flow->x1 + 1;
 				if (ImgX > Fx)
 				{
 					Size.x = Fx; //  * 0.8;
 					if (Image)
 						Scale = (double) Fx / ImgX;
 				}
 				else
 				{
 					Size.x = ImgX;
 				}
 			}
 			XLimit |= Flow->LimitX(Size.x, MinWidth(), MaxWidth(), f);
 
 			if (h.IsValid() && h.Type != LenAuto)
 			{
 				Size.y = Flow->ResolveY(h, this, false);
 				YLimit = true;
 			}
 			else
 			{
 				Size.y = (int) (ImgY * Scale);
 			}
 			YLimit |= Flow->LimitY(Size.y, MinHeight(), MaxHeight(), f);
 
 			if
 			(
 				(XLimit ^ YLimit)
 				&&
 				Image
 			)
 			{
 				if (XLimit)
 				{
 					Size.y = (int) ceil((double)Size.x / AspectRatio);
 				}
 				else
 				{
 					Size.x = (int) ceil((double)Size.y * AspectRatio);
 				}
 			}
 			if (MinY.IsValid())
 			{
 				int Px = Flow->ResolveY(MinY, this, false);
 				if (Size.y < Px)
 					Size.y = Px;
 			}
 			if (MaxY.IsValid())
 			{
 				int Px = Flow->ResolveY(MaxY, this, false);
 				if (Size.y > Px)
 					Size.y = Px;
 			}
 
 			if (Disp == DispInline ||
 				Disp == DispInlineBlock)
 			{
 				Restart = false;
 
 				if (Flow->cx > Flow->x1 &&
 					Size.x > Flow->X())
 				{
 					Flow->FinishLine();
 				}
 
 				Pos.y = Flow->y1;
 				Flow->y2 = MAX(Flow->y1, Pos.y + Size.y - 1);
 
 				LCss::LengthType a = GetAlign(true);
 				switch (a)
 				{
 					case AlignCenter:
 					{
 						int Fx = Flow->x2 - Flow->x1;
 						Pos.x = Flow->x1 + ((Fx - Size.x) / 2);
 						break;
 					}
 					case AlignRight:
 					{
 						Pos.x = Flow->x2 - Size.x;
 						break;
 					}
 					default:
 					{
 						Pos.x = Flow->cx;
 						break;
 					}
 				}
 			}
 			break;
 		}
 		case TAG_HR:
 		{
 			Flow->FinishLine();
 			
 			Pos.x = Flow->x1;
 			Pos.y = Flow->y1 + 7;
 			Size.x = Flow->X();
 			Size.y = 2;
 			
 			Flow->cx ++;
 			Flow->y2 += 16;
 
 			Flow->FinishLine();
 			return;
 			break;
 		}
 		case TAG_TABLE:
 		{
 			Flow->EndBlock();
 			
 			LCss::Len left = GetCssLen(MarginLeft, Margin);
 			LCss::Len top = GetCssLen(MarginTop, Margin);
 			LCss::Len right = GetCssLen(MarginRight, Margin);
 			LCss::Len bottom = GetCssLen(MarginBottom, Margin);
 			Flow->Indent(this, left, top, right, bottom, true);
 
 			LayoutTable(Flow, Depth + 1);
 
 			Flow->y1 += Size.y;
 			Flow->y2 = Flow->y1;
 			Flow->cx = Flow->x1;
 			Flow->my = 0;
 			Flow->MAX.y = MAX(Flow->MAX.y, Flow->y2);
 
 			Flow->Outdent(this, left, top, right, bottom, true);
 			BoundParents();
 			return;
 		}
 	}
 
 	if (Disp == DispBlock || Disp == DispInlineBlock)
 	{
 		// This is a block level element, so end the previous non-block elements
 		if (Disp == DispBlock)
 			Flow->EndBlock();
 		
 		#ifdef _DEBUG
 		if (Debug)
 			LgiTrace("Before %s\n", Flow->ToString().Get());
 		#endif
 
 		BlockFlowWidth = Flow->X();
 		
 		// Indent the margin...
 		LCss::Len left = GetCssLen(MarginLeft, Margin);
 		LCss::Len top = GetCssLen(MarginTop, Margin);
 		LCss::Len right = GetCssLen(MarginRight, Margin);
 		LCss::Len bottom = GetCssLen(MarginBottom, Margin);
 		Flow->Indent(this, left, top, right, bottom, true);
 
 		// Set the width if any
 		LCss::Len Wid = Width();
 		if (!IsTableCell(TagId) && Wid.IsValid())
 			Size.x = Flow->ResolveX(Wid, this, false);
 		else if (TagId != TAG_IMG)
 		{
 			if (Disp == DispInlineBlock) // Flow->Inline)
 				Size.x = 0; // block inside inline-block default to fit the content
 			else
 				Size.x = Flow->X();
 		}
 		else if (Disp == DispInlineBlock)
 			Size.x = 0;
 
 		if (MaxWidth().IsValid())
 		{
 			int Px = Flow->ResolveX(MaxWidth(), this, false);
 			if (Size.x > Px)
 				Size.x = Px;
 		}
 		if (MinWidth().IsValid())
 		{
 			int Px = Flow->ResolveX(MinWidth(), this, false);
 			if (Size.x < Px)
 				Size.x = Px;
 		}
 
 		Pos.x = Disp == DispInlineBlock ? Flow->cx : Flow->x1;
 		Pos.y = Flow->y1;
 
 		Flow->y1 -= Pos.y;
 		Flow->y2 -= Pos.y;
 			
 		if (Disp == DispBlock)
 		{
 			Flow->x1 -= Pos.x;
 			Flow->x2 = Flow->x1 + Size.x;
 			Flow->cx -= Pos.x;
 
 			Flow->Indent(this, LCss::BorderLeft(), LCss::BorderTop(), LCss::BorderRight(), LCss::BorderBottom(), false);
 			Flow->Indent(PadPx, false);
 		}
 		else
 		{
 			Flow->x2 = Flow->X();
 			Flow->x1 =	Flow->ResolveX(BorderLeft(), this, true) +
 						Flow->ResolveX(PaddingLeft(), this, true);
 			Flow->cx = Flow->x1;
 			Flow->y1 += Flow->ResolveY(BorderTop(), this, true) +
 						Flow->ResolveY(PaddingTop(), this, true);
 			Flow->y2 = Flow->y1;
 			
 			if (!IsTableTag())
 				Flow->Inline++;
 		}
 	}
 	else
 	{
 		Flow->Indent(PadPx, false);
 	}
 
 	if (f)
 	{
 		// Clear the previous text layout...
 		TextPos.DeleteObjects();
 
 		switch (TagId)
 		{
 			default:
 				break;
 			case TAG_LI:
 			{
 				// Insert the list marker
 				if (!PreText())
 				{
 					LCss::ListStyleTypes s = Parent->ListStyleType();
 					if (s == ListInherit)
 					{
 						if (Parent->TagId == TAG_OL)
 							s = ListDecimal;
 						else if (Parent->TagId == TAG_UL)
 							s = ListDisc;
 					}
 					
 					switch (s)
 					{
 						default: break;
 						case ListDecimal:
 						{
 							ssize_t Index = Parent->Children.IndexOf(this);
 							char Txt[32];
 							sprintf_s(Txt, sizeof(Txt), "%i. ", (int)(Index + 1));
 							PreText(Utf8ToWide(Txt));
 							break;
 						}
 						case ListDisc:
 						{
 							PreText(NewStrW(LHtmlListItem));
 							break;
 						}
 					}
 				}
 
 				if (PreText())
 					TextPos.FlowText(this, Flow, f, f->GetHeight(), PreText(), AlignLeft);
 				break;
 			}
 			case TAG_IMG:
 			{
 				if (Disp == DispBlock)
 				{
 					Flow->cx += Size.x;
 					Flow->y2 += Size.y;
 				}
 				break;
 			}
 		}
 
 		if (Text() && Flow->InBody)
 		{
 			// Setup the line height cache
 			if (LineHeightCache < 0)
 			{
 				LCss::Len LineHt;
 				LFont *LineFnt = GetFont();
 
 				for (LTag *t = this; t && !LineHt.IsValid(); t = ToTag(t->Parent))
 				{
 					LineHt = t->LineHeight();
 					if (t->TagId == TAG_TABLE)
 						break;
 				}
 
 				if (LineFnt)
 				{
 					int FontPx = LineFnt->GetHeight();
 					
 					if (!LineHt.IsValid() ||
 						LineHt.Type == LCss::LenAuto ||
 						LineHt.Type == LCss::LenNormal)
 					{
 						LineHeightCache = FontPx;
 						// LgiTrace("LineHeight FontPx=%i Px=%i Auto\n", FontPx, LineHeightCache);
 					}
 					else if (LineHt.Type == LCss::LenPx)
 					{
 						auto Scale = Html->GetDpiScale().y;
 						LineHt.Value *= (float)Scale;
 						LineHeightCache = LineHt.ToPx(FontPx, f);
 						// LgiTrace("LineHeight FontPx=%i Px=%i (Scale=%f)\n", FontPx, LineHeightCache, Scale);
 					}
 					else
 					{
 						LineHeightCache = LineHt.ToPx(FontPx, f);
 						// LgiTrace("LineHeight FontPx=%i Px=%i ToPx\n", FontPx, LineHeightCache);
 					}
 				}
 			}
 
 			// Flow in the rest of the text...
 			char16 *Txt = Text();
 			LCss::LengthType Align = GetAlign(true);
 			TextPos.FlowText(this, Flow, f, LineHeightCache, Txt, Align);
 
 			#ifdef _DEBUG
 			if (Debug)
 				LgiTrace("%s:%i - %p.size=%p\n", _FL, this, &Size.x);
 			#endif
 		}
 	}
 
 	// Flow children
 	PostFlowAlign.Length(0);
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 
 		switch (t->Position())
 		{
 			case PosStatic:
 			case PosAbsolute:
 			case PosFixed:
 			{
 				LFlowRegion old = *Flow;
 				t->OnFlow(Flow, Depth + 1);
 				
 				// Try and reset the flow to how it was before...
 				Flow->x1 = old.x1;
 				Flow->x2 = old.x2;
 				Flow->cx = old.cx;
 				Flow->y1 = old.y1;
 				Flow->y2 = old.y2;
 				Flow->MAX.x = MAX(Flow->MAX.x, old.MAX.x);
 				Flow->MAX.y = MAX(Flow->MAX.y, old.MAX.y);
 				break;
 			}
 			default:
 			{
 				t->OnFlow(Flow, Depth + 1);
 				break;
 			}
 		}
 
 		if (TagId == TAG_TR)
 		{
 			Flow->x2 -= MIN(t->Size.x, Flow->X());
 		}
 	}
 
 	LCss::LengthType XAlign = GetAlign(true);
 	int FlowSz = Flow->Width();
 
 	// Align the children...
 	for (auto &group: PostFlowAlign)
 	{
 		int MinX = FlowSz, MaxX = 0;
 		for (auto &a: group)
 		{
 			MinX = MIN(MinX, a.t->Pos.x);
 			MaxX = MAX(MaxX, a.t->Pos.x + a.t->Size.x - 1);
 		}
 		int TotalX = MaxX - MinX + 1;
 		int FirstX = group.Length() ? group[0].t->Pos.x : 0;
 
 		for (auto &a: group)
 		{
 			if (a.XAlign == LCss::AlignCenter)
 			{
 				int OffX = (Size.x - TotalX) >> 1;
 				if (OffX > 0)
 				{
 					a.t->Pos.x += OffX;
 				}
 			}
 			else if (a.XAlign == LCss::AlignRight)
 			{
 				int OffX = FlowSz - FirstX - TotalX;
 				if (OffX > 0)
 				{
 					a.t->Pos.x += OffX;
 				}
 			}
 		}
 	}
 
 	if (Disp == DispBlock || Disp == DispInlineBlock)
 	{		
 		LCss::Len Ht = Height();
 		LCss::Len MaxHt = MaxHeight();
 
 		// I dunno, there should be a better way... :-(
 		if (MarginLeft().Type == LenAuto &&
 			MarginRight().Type == LenAuto)
 		{
 			XAlign = LCss::AlignCenter;
 		}
 
 		bool AcceptHt = !IsTableCell(TagId) && Ht.Type != LenPercent;
 		if (AcceptHt)
 		{
 			if (Ht.IsValid())
 			{
 				int HtPx = Flow->ResolveY(Ht, this, false);
 				if (HtPx > Flow->y2)
 					Flow->y2 = HtPx;
 			}
 			if (MaxHt.IsValid())
 			{
 				int MaxHtPx = Flow->ResolveY(MaxHt, this, false);
 				if (MaxHtPx < Flow->y2)
 				{
 					Flow->y2 = MaxHtPx;
 					Flow->MAX.y = MIN(Flow->y2, Flow->MAX.y);
 				}
 			}
 		}
 
 		if (Disp == DispBlock)
 		{
 			Flow->EndBlock();
 
 			int OldFlowSize = Flow->x2 - Flow->x1 + 1;
 			Flow->Outdent(this, PaddingLeft(), PaddingTop(), PaddingRight(), PaddingBottom(), false);
 			Flow->Outdent(this, LCss::BorderLeft(), LCss::BorderTop(), LCss::BorderRight(), LCss::BorderBottom(), false);
 
 			Size.y = Flow->y2 > 0 ? Flow->y2 : 0;
 
 			Flow->Outdent(this, MarginLeft(), MarginTop(), MarginRight(), MarginBottom(), true);
 			
 			int NewFlowSize = Flow->x2 - Flow->x1 + 1;
 			int Diff = NewFlowSize - OldFlowSize;
 			if (Diff)
 				Flow->MAX.x += Diff;
 			
 			Flow->y1 = Flow->y2;
 			Flow->x2 = Flow->x1 + BlockFlowWidth;
 		}
 		else
 		{
 			LCss::Len Wid = Width();
 			int WidPx = Wid.IsValid() ? Flow->ResolveX(Wid, this, true) : 0;
 			
 			Size.x = MAX(WidPx, Size.x);
 			Size.x += Flow->ResolveX(PaddingRight(), this, true);
 			Size.x += Flow->ResolveX(BorderRight(), this, true);
 
 			int MarginR = Flow->ResolveX(MarginRight(), this, true);
 			int MarginB = Flow->ResolveX(MarginBottom(), this, true);
 
 			Flow->x1 = Local.x1 - Pos.x;
 			Flow->cx = Local.cx + Size.x + MarginR - Pos.x;
 			Flow->x2 = Local.x2 - Pos.x;
 
 			if (Height().IsValid())
 			{
 				Size.y = Flow->ResolveY(Height(), this, false);
 				Flow->y2 = MAX(Flow->y1 + Size.y + MarginB - 1, Flow->y2);
 			}
 			else
 			{
 				Flow->y2 += Flow->ResolveX(PaddingBottom(), this, true);
 				Flow->y2 += Flow->ResolveX(BorderBottom(), this, true);
 				Size.y = Flow->y2;
 			}
 
 			Flow->y1 = Local.y1 - Pos.y;
 			Flow->y2 = MAX(Local.y2, Flow->y1+Size.y-1);
 			
 			if (!IsTableTag())
 				Flow->Inline--;
 		}
 
 		// Can't do alignment here because pos is used to
 		// restart the parents flow region...
 	}
 	else
 	{
 		Flow->Outdent(PadPx, false);
 		
 		switch (TagId)
 		{
 			default: break;
 			case TAG_SELECT:
 			case TAG_INPUT:
 			{
 				if (Html->InThread() && Ctrl)
 				{
 					LRect r = Ctrl->GetPos();
 
 					if (Width().IsValid())
 						Size.x = Flow->ResolveX(Width(), this, false);
 					else
 						Size.x = r.X();
 					if (Height().IsValid())
 						Size.y = Flow->ResolveY(Height(), this, false);
 					else
 						Size.y = r.Y();
 					
 					if (Html->IsAttached() && !Ctrl->IsAttached())
 						Ctrl->Attach(Html);
 				}
 
 				Flow->cx += Size.x;
 				Flow->y2 = MAX(Flow->y2, Flow->y1 + Size.y - 1);
 				break;
 			}
 			case TAG_IMG:
 			{
 				Flow->cx += Size.x;
 				Flow->y2 = MAX(Flow->y2, Flow->y1 + Size.y - 1);
 				break;
 			}
 			case TAG_BR:
 			{
 				int OldFlowY2 = Flow->y2;
 				Flow->FinishLine();
 				Size.y = Flow->y2 - OldFlowY2;
 				Flow->y2 = MAX(Flow->y2, Flow->y1 + Size.y - 1);
 				break;
 			}
 			case TAG_CENTER:
 			{
 				int Px = Flow->X();
 				for (auto e: Children)
 				{
 					LTag *t = ToTag(e);
 					if (t && t->IsBlock() && t->Size.x < Px)
 					{
 						t->Pos.x = (Px - t->Size.x) >> 1;
 					}
 				}
 				break;
 			}
 		}
 	}
 
 	BoundParents();
 
 	if (Restart)
 	{
 		Flow->x1 += Pos.x;
 		Flow->x2 += Pos.x;
 		Flow->cx += Pos.x;
 
 		Flow->y1 += Pos.y;
 		Flow->y2 += Pos.y;
 		Flow->MAX.y = MAX(Flow->MAX.y, Flow->y2);
 	}
 
 	if (Disp == DispBlock || Disp == DispInlineBlock)
 	{
 		if (XAlign == LCss::AlignCenter ||
 			XAlign == LCss::AlignRight)
 		{
 			int Match = 0;
 			auto parent = ToTag(Parent);
 			for (auto &grp: parent->PostFlowAlign)
 			{
 				bool Overlaps = false;
 				for (auto &a: grp)
 				{
 					if (a.Overlap(this))
 					{
 						Overlaps = true;
 						break;
 					}
 				}
 
 				if (!Overlaps)
 					Match++;
 			}
 			
 			auto &grp = parent->PostFlowAlign[Match];
 			if (grp.Length() == 0)
 			{
 				grp.x1 = Flow->x1;
 				grp.x2 = Flow->x2;
 			}
 			auto &pf = grp.New();
 			pf.Disp = Disp;
 			pf.XAlign = XAlign;
 			pf.t = this;
 		}
 	}
 
 	if (TagId == TAG_BODY && Flow->InBody > 0)
 	{
 		Flow->InBody--;
 	}
 }
 
 bool LTag::PeekTag(char *s, char *tag)
 {
 	bool Status = false;
 
 	if (s && tag)
 	{
 		if (*s == '<')
 		{
 			char *t = 0;
 			Html->ParseName(++s, &t);
 			if (t)
 			{
 				Status = _stricmp(t, tag) == 0;
 			}
 
 			DeleteArray(t);
 		}
 	}
 
 	return Status;
 }
 
 LTag *LTag::GetTable()
 {
 	LTag *t = 0;
 	for (t=ToTag(Parent); t && t->TagId != TAG_TABLE; t = ToTag(t->Parent))
 		;
 	return t;
 }
 
 void LTag::BoundParents()
 {
 	if (!Parent)
 		return;
 
 	LTag *np;
 	for (LTag *n=this; n; n = np)
 	{
 		np = ToTag(n->Parent);
 
 		if (!np || np->TagId == TAG_IFRAME)
 			break;
 				
 		np->Size.x = MAX(np->Size.x, n->Pos.x + n->Size.x);
 		np->Size.y = MAX(np->Size.y, n->Pos.y + n->Size.y);
 	}
 }
 
 struct DrawBorder
 {
 	LSurface *pDC;
 	uint32_t LineStyle;
 	uint32_t LineReset;
 	uint32_t OldStyle;
 
 	DrawBorder(LSurface *pdc, LCss::BorderDef &d)
 	{
 		LineStyle = 0xffffffff;
 		LineReset = 0x80000000;
 
 		if (d.Style == LCss::BorderDotted)
 		{
 			switch ((int)d.Value)
 			{
 				case 2:
 				{
 					LineStyle = 0xcccccccc;
 					break;
 				}
 				case 3:
 				{
 					LineStyle = 0xe38e38;
 					LineReset = 0x800000;
 					break;
 				}
 				case 4:
 				{
 					LineStyle = 0xf0f0f0f0;
 					break;
 				}
 				case 5:
 				{
 					LineStyle = 0xf83e0;
 					LineReset = 0x80000;
 					break;
 				}
 				case 6:
 				{
 					LineStyle = 0xfc0fc0;
 					LineReset = 0x800000;
 					break;
 				}
 				case 7:
 				{
 					LineStyle = 0xfe03f80;
 					LineReset = 0x8000000;
 					break;
 				}
 				case 8:
 				{
 					LineStyle = 0xff00ff00;
 					break;
 				}
 				case 9:
 				{
 					LineStyle = 0x3fe00;
 					LineReset = 0x20000;
 					break;
 				}
 				default:
 				{
 					LineStyle = 0xaaaaaaaa;
 					break;
 				}
 			}
 		}
 
 		pDC = pdc;
 		OldStyle = pDC->LineStyle();
 	}
 
 	~DrawBorder()
 	{
 		pDC->LineStyle(OldStyle);
 	}
 };
 
 void LTag::GetInlineRegion(LRegion &rgn, int ox, int oy)
 {
 	if (TagId == TAG_IMG)
 	{
 		LRect rc(0, 0, Size.x-1, Size.y-1);
 		rc.Offset(ox + Pos.x, oy + Pos.y);
 		rgn.Union(&rc);
 	}
 	else
 	{
 		for (unsigned i=0; i<TextPos.Length(); i++)
 		{
 			LRect rc = *(TextPos[i]);
 			rc.Offset(ox + Pos.x, oy + Pos.y);
 			rgn.Union(&rc);
 		}
 	}
 	
 	for (unsigned c=0; c<Children.Length(); c++)
 	{
 		LTag *ch = ToTag(Children[c]);
 		ch->GetInlineRegion(rgn, ox + Pos.x, oy + Pos.y);
 	}
 }
 
 class CornersImg : public LMemDC
 {
 public:
 	int Px, Px2;
 
 	CornersImg(	float RadPx,
 				LRect *BorderPx,
 				LCss::BorderDef **defs,
 				LColour &Back,
 				bool DrawBackground)
 	{
 		Px = 0;
 		Px2 = 0;
 
 		//Radius.Type != LCss::LenInherit &&			
 		if (RadPx > 0.0f)
 		{
 			Px = (int)ceil(RadPx);
 			Px2 = Px << 1;
 			
 			if (Create(Px2, Px2, System32BitColourSpace))
 			{
 				#if 1
 				Colour(0, 32);
 				#else
 				Colour(LColour(255, 0, 255));
 				#endif
 				Rectangle();
 
 				LPointF ctr(Px, Px);
 				LPointF LeftPt(0.0, Px);
 				LPointF TopPt(Px, 0.0);
 				LPointF RightPt(X(), Px);
 				LPointF BottomPt(Px, Y());
 				int x_px[4] = {BorderPx->x1, BorderPx->x2, BorderPx->x2, BorderPx->x1};
 				int y_px[4] = {BorderPx->y1, BorderPx->y1, BorderPx->y2, BorderPx->y2};
 				LPointF *pts[4] = {&LeftPt, &TopPt, &RightPt, &BottomPt};
 				
 				// Draw border parts..
 				for (int i=0; i<4; i++)
 				{
 					int k = (i + 1) % 4;
 
 					// Setup the stops					
 					LBlendStop stops[2] = { {0.0, 0}, {1.0, 0} };
 					uint32_t iColour = defs[i]->Color.IsValid() ? defs[i]->Color.Rgb32 : Back.c32();
 					uint32_t kColour = defs[k]->Color.IsValid() ? defs[k]->Color.Rgb32 : Back.c32();
 					if (defs[i]->IsValid() && defs[k]->IsValid())
 					{
 						stops[0].c32 = iColour;
 						stops[1].c32 = kColour;
 					}
 					else if (defs[i]->IsValid())
 					{
 						stops[0].c32 = stops[1].c32 = iColour;
 					}
 					else
 					{
 						stops[0].c32 = stops[1].c32 = kColour;
 					}
 					
 					// Create a brush
 					LLinearBlendBrush br
 					(
 						*pts[i],
 						*pts[k],
 						2,
 						stops
 					);
 					
 					// Setup the clip
 					LRect clip(	(int)MIN(pts[i]->x, pts[k]->x),
 								(int)MIN(pts[i]->y, pts[k]->y),
 								(int)MAX(pts[i]->x, pts[k]->x)-1,
 								(int)MAX(pts[i]->y, pts[k]->y)-1);
 					ClipRgn(&clip);
 					
 					// Draw the arc...
 					LPath p;
 					p.Circle(ctr, Px);
 					if (defs[i]->IsValid() || defs[k]->IsValid())
 						p.Fill(this, br);
 					
 					// Fill the background
 					p.Empty();
 					p.Ellipse(ctr, Px-x_px[i], Px-y_px[i]);
 					if (DrawBackground)
 					{
 						LSolidBrush br(Back);
 						p.Fill(this, br);					
 					}
 					else
 					{
 						LEraseBrush br;
 						p.Fill(this, br);
 					}
 					
 					ClipRgn(NULL);
 				}
 				
 				#ifdef MAC
 				ConvertPreMulAlpha(true);
 				#endif
 				
 				#if 0
 				static int count = 0;
 				LString file;
 				file.Printf("c:\\temp\\img-%i.bmp", ++count);
 				GdcD->Save(file, Corners);
 				#endif
 			}
 		}
 	}
 };
 
 void LTag::PaintBorderAndBackground(LSurface *pDC, LColour &Back, LRect *BorderPx)
 {
 	LArray<LRect> r;
 	LRect BorderPxRc;
 	bool DrawBackground = !Back.IsTransparent();
 
 	#ifdef _DEBUG
 	if (Debug)
 	{
 		//int asd=0;
 	}
 	#endif
 
 	if (!BorderPx)
 		BorderPx = &BorderPxRc;
 	BorderPx->ZOff(0, 0);
 
 	// Get all the border info and work out the pixel sizes.
 	LFont *f = GetFont();
 	
 	#define DoEdge(coord, axis, name) \
 		BorderDef name = Border##name(); \
 		BorderPx->coord = name.Style != LCss::BorderNone ? name.ToPx(Size.axis, f) : 0;
 	#define BorderValid(name) \
 		((name).IsValid() && (name).Style != LCss::BorderNone)
 	
 	DoEdge(x1, x, Left);
 	DoEdge(y1, y, Top);
 	DoEdge(x2, x, Right);
 	DoEdge(y2, y, Bottom);
 	
 	LCss::BorderDef *defs[4] = {&Left, &Top, &Right, &Bottom};
 
 	if (BorderValid(Left) ||
 		BorderValid(Right) ||
 		BorderValid(Top) ||
 		BorderValid(Bottom) ||
 		DrawBackground)
 	{
 		// Work out the rectangles
 		switch (Display())
 		{
 			case DispInlineBlock:
 			case DispBlock:
 			{
 				r[0].ZOff(Size.x-1, Size.y-1);
 				break;
 			}
 			case DispInline:
 			{
 				LRegion rgn;
 				GetInlineRegion(rgn);
 				if (BorderPx)
 				{
 					for (int i=0; i<rgn.Length(); i++)
 					{
 						LRect *r = rgn[i];
 						r->x1 -= BorderPx->x1 + PadPx.x1;
 						r->y1 -= BorderPx->y1 + PadPx.y1;
 						r->x2 += BorderPx->x2 + PadPx.x2;
 						r->y2 += BorderPx->y2 + PadPx.y2;
 					}
 				}
 
 				r.Length(rgn.Length());
 				auto p = r.AddressOf();
 				for (auto i = rgn.First(); i; i = rgn.Next())
 					*p++ = *i;
 				break;
 			}
 			default:
 				return;
 		}
 
 		// If we are drawing rounded corners, draw them into a memory context
 		LAutoPtr<CornersImg> Corners;
 		int Px = 0, Px2 = 0;
 		LCss::Len Radius = BorderRadius();
 		float RadPx = Radius.Type == LCss::LenPx ? Radius.Value : Radius.ToPx(Size.x, GetFont());
 		bool HasRadius = Radius.Type != LCss::LenInherit && RadPx > 0.0f;
 
 		// Loop over the rectangles and draw everything
 		int Op = pDC->Op(GDC_ALPHA);
 
 		for (unsigned i=0; i<r.Length(); i++)
 		{
 			LRect rc = r[i];
 			if (HasRadius)
 			{
 				Px = (int)ceil(RadPx);
 				Px2 = Px << 1;
 				if (Px2 > rc.Y())
 				{
 					Px = rc.Y() / 2;
 					Px2 = Px << 1;
 				}			
 				if (!Corners || Corners->Px2 != Px2)
 				{
 					Corners.Reset(new CornersImg((float)Px, BorderPx, defs, Back, DrawBackground));
 				}
 			
 				// top left
 				LRect r(0, 0, Px-1, Px-1);
 				pDC->Blt(rc.x1, rc.y1, Corners, &r);
 			
 				// top right
 				r.Set(Px, 0, Corners->X()-1, Px-1);
 				pDC->Blt(rc.x2-Px+1, rc.y1, Corners, &r);
 			
 				// bottom left
 				r.Set(0, Px, Px-1, Corners->Y()-1);
 				pDC->Blt(rc.x1, rc.y2-Px+1, Corners, &r);
 			
 				// bottom right
 				r.Set(Px, Px, Corners->X()-1, Corners->Y()-1);
 				pDC->Blt(rc.x2-Px+1, rc.y2-Px+1, Corners, &r);
 			
 				#if 1
 				pDC->Colour(Back);
 				pDC->Rectangle(rc.x1+Px, rc.y1, rc.x2-Px, rc.y2);
 				pDC->Rectangle(rc.x1, rc.y1+Px, rc.x1+Px-1, rc.y2-Px);
 				pDC->Rectangle(rc.x2-Px+1, rc.y1+Px, rc.x2, rc.y2-Px);
 				#else
 				pDC->Colour(LColour(255, 0, 0, 0x80));
 				pDC->Rectangle(rc.x1+Px, rc.y1, rc.x2-Px, rc.y2);
 				pDC->Colour(LColour(0, 255, 0, 0x80));
 				pDC->Rectangle(rc.x1, rc.y1+Px, rc.x1+Px-1, rc.y2-Px);
 				pDC->Colour(LColour(0, 0, 255, 0x80));
 				pDC->Rectangle(rc.x2-Px+1, rc.y1+Px, rc.x2, rc.y2-Px);
 				#endif
 			}
 			else if (DrawBackground)
 			{
 				pDC->Colour(Back);
 				pDC->Rectangle(&rc);
 			}
 
 			LCss::BorderDef *b;
 			if ((b = &Left) && BorderValid(*b))
 			{
 				pDC->Colour(b->Color.Rgb32, 32);
 				DrawBorder db(pDC, *b);
 				for (int i=0; i<b->Value; i++)
 				{
 					pDC->LineStyle(db.LineStyle, db.LineReset);
 					pDC->Line(rc.x1 + i, rc.y1+Px, rc.x1+i, rc.y2-Px);
 				}
 			}
 			if ((b = &Top) && BorderValid(*b))
 			{
 				pDC->Colour(b->Color.Rgb32, 32);
 				DrawBorder db(pDC, *b);
 				for (int i=0; i<b->Value; i++)
 				{
 					pDC->LineStyle(db.LineStyle, db.LineReset);
 					pDC->Line(rc.x1+Px, rc.y1+i, rc.x2-Px, rc.y1+i);
 				}
 			}
 			if ((b = &Right) && BorderValid(*b))
 			{
 				pDC->Colour(b->Color.Rgb32, 32);
 				DrawBorder db(pDC, *b);
 				for (int i=0; i<b->Value; i++)
 				{
 					pDC->LineStyle(db.LineStyle, db.LineReset);
 					pDC->Line(rc.x2-i, rc.y1+Px, rc.x2-i, rc.y2-Px);
 				}			
 			}
 			if ((b = &Bottom) && BorderValid(*b))
 			{
 				pDC->Colour(b->Color.Rgb32, 32);
 				DrawBorder db(pDC, *b);
 				for (int i=0; i<b->Value; i++)
 				{
 					pDC->LineStyle(db.LineStyle, db.LineReset);
 					pDC->Line(rc.x1+Px, rc.y2-i, rc.x2-Px, rc.y2-i);
 				}
 			}
 		}
 
 		pDC->Op(Op);
 	}
 }
 
 static void FillRectWithImage(LSurface *pDC, LRect *r, LSurface *Image, LCss::RepeatType Repeat)
 {
 	int Px = 0, Py = 0;
 	int Old = pDC->Op(GDC_ALPHA);
 
 	if (!Image)
 		return;
 
 	switch (Repeat)
 	{
 		default:
 		case LCss::RepeatBoth:
 		{
 			for (int y=0; y<r->Y(); y += Image->Y())
 			{
 				for (int x=0; x<r->X(); x += Image->X())
 				{
 					pDC->Blt(Px + x, Py + y, Image);
 				}
 			}
 			break;
 		}
 		case LCss::RepeatX:
 		{
 			for (int x=0; x<r->X(); x += Image->X())
 			{
 				pDC->Blt(Px + x, Py, Image);
 			}
 			break;
 		}
 		case LCss::RepeatY:
 		{
 			for (int y=0; y<r->Y(); y += Image->Y())
 			{
 				pDC->Blt(Px, Py + y, Image);
 			}
 			break;
 		}
 		case LCss::RepeatNone:
 		{
 			pDC->Blt(Px, Py, Image);
 			break;
 		}
 	}
 
 	pDC->Op(Old);
 }
 
 void LTag::OnPaint(LSurface *pDC, bool &InSelection, uint16 Depth)
 {
 	if (Depth >= MAX_RECURSION_DEPTH ||
 		Display() == DispNone)
 		return;
 	if (
 		#ifdef _DEBUG
 		!Html->_Debug &&
 		#endif
 		LCurrentTime() - Html->PaintStart > Html->d->MaxPaintTime)
 	{
 		Html->d->MaxPaintTimeout = true;
 		return;
 	}
 
 	int Px, Py;
 	pDC->GetOrigin(Px, Py);
 	
 	#if 0
 	if (Debug)
 	{
 		Gtk::cairo_matrix_t mx;
 		Gtk::cairo_get_matrix(pDC->Handle(), &mx);
 		LPoint Offset;
 		Html->WindowVirtualOffset(&Offset);
 		LRect cli;
 		pDC->GetClient(&cli);
 		printf("\tTag paint mx=%g,%g off=%i,%i p=%i,%i Pos=%i,%i cli=%s\n",
 			mx.x0, mx.y0,
 			Offset.x, Offset.y,
 			Px, Py,
 			Pos.x, Pos.y,
 			cli.GetStr());
 	}
 	#endif
 
 	switch (TagId)
 	{
 		case TAG_INPUT:
 		case TAG_SELECT:
 		{
 			if (Ctrl)
 			{
 				int64 Sx = 0, Sy = 0;
 				int64 LineY = GetFont()->GetHeight();
 				Html->GetScrollPos(Sx, Sy);
 				Sx *= LineY;
 				Sy *= LineY;
 				
 				LRect r(0, 0, Size.x-1, Size.y-1), Px;
 				LColour back = _Colour(false);
 				PaintBorderAndBackground(pDC, back, &Px);
 				if (!dynamic_cast<LButton*>(Ctrl))
 				{
 					r.x1 += Px.x1;
 					r.y1 += Px.y1;
 					r.x2 -= Px.x2;
 					r.y2 -= Px.y2;
 				}
 				r.Offset(AbsX() - (int)Sx, AbsY() - (int)Sy);
 				Ctrl->SetPos(r);
 			}
 			
 			if (TagId == TAG_SELECT)
 				return;
 			break;
 		}
 		case TAG_BODY:
 		{
 			auto b = _Colour(false);
 			if (!b.IsTransparent())
 			{
 				pDC->Colour(b);
 				pDC->Rectangle(Pos.x, Pos.y, Pos.x+Size.x, Pos.y+Size.y);
 			}
 			if (Image)
 			{
 				LRect r;
 				r.ZOff(Size.x-1, Size.y-1);
 				FillRectWithImage(pDC, &r, Image, BackgroundRepeat());
 			}
 			break;
 		}
 		case TAG_HEAD:
 		{
 			// Nothing under here to draw.
 			return;
 		}
 		case TAG_HR:
 		{
 			pDC->Colour(L_MED);
 			pDC->Rectangle(0, 0, Size.x - 1, Size.y - 1);
 			break;
 		}
 		case TAG_TR:
 		case TAG_TBODY:
 		case TAG_META:
 		{
 			// Draws nothing...
 			break;
 		}
 		case TAG_IMG:
 		{
 			LRect Clip(0, 0, Size.x-1, Size.y-1);
 			pDC->ClipRgn(&Clip);
 			
 			if (Image)
 			{
 				#if ENABLE_IMAGE_RESIZING
 				if
 				(
 					!ImageResized &&
 					(				
 						Size.x != Image->X() ||
 						Size.y != Image->Y()
 					)
 				)
 				{
 					ImageResized = true;
 
 					LColourSpace Cs = Image->GetColourSpace();
 					if (Cs == CsIndex8 &&
 						Image->AlphaDC())
 						Cs = System32BitColourSpace;
 					
 					LAutoPtr<LSurface> r(new LMemDC(Size.x, Size.y, Cs));
 					if (r)
 					{
 						if (Cs == CsIndex8)
 							r->Palette(new LPalette(Image->Palette()));
 						ResampleDC(r, Image);
 						Image = r;
 					}
 				}
 				#endif
 
 				int Old = pDC->Op(GDC_ALPHA);
 				pDC->Blt(0, 0, Image);
 				pDC->Op(Old);
 			}
 			else if (Size.x > 1 && Size.y > 1)
 			{
 				LRect b(0, 0, Size.x-1, Size.y-1);
 				LColour Fill(LColour(L_MED).Mix(LColour(L_LIGHT), 0.2f));
 				LColour Border(L_MED);
 
 				// Border
 				pDC->Colour(Border);
 				pDC->Box(&b);
 				b.Inset(1, 1);
 				pDC->Box(&b);
 				b.Inset(1, 1);
 				pDC->Colour(Fill);
 				pDC->Rectangle(&b);
 
 				const char *Alt;
 				LColour Red(LColour(255, 0, 0).Mix(Fill, 0.3f));
 				if (Get("alt", Alt) && ValidStr(Alt))
 				{
 					LDisplayString Ds(Html->GetFont(), Alt);
 					Html->GetFont()->Colour(Red, Fill);
 					Ds.Draw(pDC, 2, 2, &b);
 				}
 				else if (Size.x >= 16 && Size.y >= 16)
 				{
 					// Red 'x'
 					int Cx = b.x1 + (b.X()/2);
 					int Cy = b.y1 + (b.Y()/2);
 					LRect c(Cx-4, Cy-4, Cx+4, Cy+4);
 					
 					pDC->Colour(Red);
 					pDC->Line(c.x1, c.y1, c.x2, c.y2);
 					pDC->Line(c.x1, c.y2, c.x2, c.y1);
 					pDC->Line(c.x1, c.y1 + 1, c.x2 - 1, c.y2);
 					pDC->Line(c.x1 + 1, c.y1, c.x2, c.y2 - 1);
 					pDC->Line(c.x1 + 1, c.y2, c.x2, c.y1 + 1);
 					pDC->Line(c.x1, c.y2 - 1, c.x2 - 1, c.y1);
 				}
 			}
 			
 			pDC->ClipRgn(0);
 			break;
 		}
 		default:
 		{
 			LColour fore = _Colour(true);
 			LColour back = _Colour(false);
 
 			if (Display() == DispBlock && Html->Environment)
 			{
 				LCss::ImageDef Img = BackgroundImage();
 				if (Img.Img)
 				{
 					LRect Clip(0, 0, Size.x-1, Size.y-1);
 					pDC->ClipRgn(&Clip);					
 					FillRectWithImage(pDC, &Clip, Img.Img, BackgroundRepeat());					
 					pDC->ClipRgn(NULL);
 
 					back.Empty();
 				}
 			}
 
 			PaintBorderAndBackground(pDC, back, NULL);
 
 			LFont *f = GetFont();
 			#if DEBUG_TEXT_AREA
 			bool IsEditor = Html ? !Html->GetReadOnly() : false;
 			#else
 			bool IsEditor = false;
 			#endif
 			if (f && TextPos.Length())
 			{
 				// This is the non-display part of the font bounding box
 				int LeadingPx = (int)(f->Leading() + 0.5);
 				
 				// This is the displayable part of the font
 				int FontPx = f->GetHeight() - LeadingPx;
 				
 				// This is the pixel height we're aiming to fill
 				int EffectiveLineHt = LineHeightCache >= 0 ? MAX(FontPx, LineHeightCache) : FontPx;
 				
 				// This gets added to the y coord of each piece of text
 				int LineHtOff = ((EffectiveLineHt - FontPx + 1) >> 1) - LeadingPx;
 								
 				#define FontColour(InSelection) \
 					f->Transparent(!InSelection && !IsEditor); \
 					if (InSelection) \
 						f->Colour(L_FOCUS_SEL_FORE, L_FOCUS_SEL_BACK); \
 					else \
 					{ \
 						LColour bk(back.IsTransparent() ? LColour(L_WORKSPACE) : back);			\
 						LColour fr(fore.IsTransparent() ? LColour(DefaultTextColour) : fore);		\
 						if (IsEditor)																\
 							bk = bk.Mix(LColour::Black, 0.05f);									\
 						f->Colour(fr, bk);															\
 					}
 
 				if (Html->HasSelection() &&
 					(Selection >= 0 || Cursor >= 0) &&
 					Selection != Cursor)
 				{
 					ssize_t Min = -1;
 					ssize_t Max = -1;
 
 					ssize_t Base = GetTextStart();
 					if (Cursor >= 0 && Selection >= 0)
 					{
 						Min = MIN(Cursor, Selection) + Base;
 						Max = MAX(Cursor, Selection) + Base;
 					}
 					else if (InSelection)
 					{
 						Max = MAX(Cursor, Selection) + Base;
 					}
 					else
 					{
 						Min = MAX(Cursor, Selection) + Base;
 					}
 
 					LRect CursorPos;
 					CursorPos.ZOff(-1, -1);
 
 					for (unsigned i=0; i<TextPos.Length(); i++)
 					{
 						LFlowRect *Tr = TextPos[i];
 						ssize_t Start = Tr->Text - Text();
 						ssize_t Done = 0;
 						int x = Tr->x1;
 
 						if (Tr->Len == 0)
 						{
 							// Is this a selection edge point?
 							if (!InSelection && Min == 0)
 							{
 								InSelection = !InSelection;
 							}
 							else if (InSelection && Max == 0)
 							{
 								InSelection = !InSelection;
 							}
 
 							if (Cursor >= 0)
 							{
 								// Is this the cursor, then draw it and save it's position
 								if (Cursor == Start + Done - Base)
 								{
 									Html->d->CursorPos.Set(x, Tr->y1 + LineHtOff, x + 1, Tr->y2 - LineHtOff);
 
 									if (Html->d->CursorPos.x1 > Tr->x2)
 										Html->d->CursorPos.Offset(Tr->x2 - Html->d->CursorPos.x1, 0);
 
 									CursorPos = Html->d->CursorPos;
 									Html->d->CursorPos.Offset(AbsX(), AbsY());
 								}
 							}
 							break;
 						}
 
 						while (Done < Tr->Len)
 						{
 							ssize_t c = Tr->Len - Done;
 
 							FontColour(InSelection);
 
 							// Is this a selection edge point?
 							if (		!InSelection &&
 										Min - Start >= Done &&
 										Min - Start < Done + Tr->Len)
 							{
 								InSelection = !InSelection;
 								c = Min - Start - Done;
 							}
 							else if (	InSelection &&
 										Max - Start >= Done &&
 										Max - Start <= Tr->Len)
 							{
 								InSelection = !InSelection;
 								c = Max - Start - Done;
 							}
 
 							// Draw the text run
 							LDisplayString ds(f, Tr->Text + Done, c);
 							if (IsEditor)
 							{
 								LRect r(x, Tr->y1, x + ds.X() - 1, Tr->y2);
 								ds.Draw(pDC, x, Tr->y1 + LineHtOff, &r);
 							}
 							else
 							{
 								ds.Draw(pDC, x, Tr->y1 + LineHtOff);
 							}
 							x += ds.X();
 							Done += c;
 							
 							// Is this is end of the tag?
 							if (Tr->Len == Done)
 							{
 								// Is it also a selection edge?
 								if (		!InSelection &&
 											Min - Start == Done)
 								{
 									InSelection = !InSelection;
 								}
 								else if (	InSelection &&
 											Max - Start == Done)
 								{
 									InSelection = !InSelection;
 								}
 							}
 
 							if (Cursor >= 0)
 							{
 								// Is this the cursor, then draw it and save it's position
 								if (Cursor == Start + Done - Base)
 								{
 									Html->d->CursorPos.Set(x, Tr->y1 + LineHtOff, x + 1, Tr->y2 - LineHtOff);
 
 									if (Html->d->CursorPos.x1 > Tr->x2)
 										Html->d->CursorPos.Offset(Tr->x2 - Html->d->CursorPos.x1, 0);
 
 									CursorPos = Html->d->CursorPos;
 									Html->d->CursorPos.Offset(AbsX(), AbsY());
 								}
 							}
 
 						}
 					}
 
 					if (Html->d->CursorVis && CursorPos.Valid())
 					{
 						pDC->Colour(L_TEXT);
 						pDC->Rectangle(&CursorPos);
 					}
 				}
 				else if (Cursor >= 0)
 				{
 					FontColour(InSelection);
 
 					ssize_t Base = GetTextStart();
 					for (unsigned i=0; i<TextPos.Length(); i++)
 					{
 						LFlowRect *Tr = TextPos[i];
 						if (!Tr)
 							break;
 						ssize_t Pos = (Tr->Text - Text()) - Base;
 
 						LAssert(Tr->y2 >= Tr->y1);
 						LDisplayString ds(f, Tr->Text, Tr->Len);
 						ds.Draw(pDC, Tr->x1, Tr->y1 + LineHtOff, IsEditor ? Tr : NULL);
 
 						if
 						(
 							(
 								Tr->Text == PreText()
 								&&
 								!ValidStrW(Text())
 							)
 							||
 							(
 								Cursor >= Pos
 								&&
 								Cursor <= Pos + Tr->Len
 							)
 						)
 						{
 							ssize_t Off = Tr->Text == PreText() ? StrlenW(PreText()) : Cursor - Pos;
 							pDC->Colour(L_TEXT);
 							LRect c;
 							if (Off)
 							{
 								LDisplayString ds(f, Tr->Text, Off);
 								int x = ds.X();
 								if (x >= Tr->X())
 									x = Tr->X()-1;
 								c.Set(Tr->x1 + x, Tr->y1, Tr->x1 + x + 1, Tr->y1 + f->GetHeight());
 							}
 							else
 							{
 								c.Set(Tr->x1, Tr->y1, Tr->x1 + 1, Tr->y1 + f->GetHeight());
 							}
 							Html->d->CursorPos = c;
 							if (Html->d->CursorVis)
 								pDC->Rectangle(&c);
 							Html->d->CursorPos.Offset(AbsX(), AbsY());
 						}
 					}
 				}
 				else
 				{
 					FontColour(InSelection);
 
 					for (auto &Tr: TextPos)
 					{
 						LDisplayString ds(f, Tr->Text, Tr->Len);
 						ds.Draw(pDC, Tr->x1, Tr->y1 + LineHtOff, IsEditor ? Tr : NULL);
 					}
 				}
 			}
 			break;
 		}
 	}
 	
 	#if DEBUG_TABLE_LAYOUT && 0
 	if (IsTableCell(TagId))
 	{
 		LTag *Tbl = this;
 		while (Tbl->TagId != TAG_TABLE && Tbl->Parent)
 			Tbl = Tbl->Parent;
 		if (Tbl && Tbl->TagId == TAG_TABLE && Tbl->Debug)
 		{
 			pDC->Colour(LColour(255, 0, 0));
 			pDC->Box(0, 0, Size.x-1, Size.y-1);
 		}
 	}
 	#endif
 
 	for (unsigned i=0; i<Children.Length(); i++)
 	{
 		LTag *t = ToTag(Children[i]);
 		pDC->SetOrigin(Px - t->Pos.x, Py - t->Pos.y);
 		t->OnPaint(pDC, InSelection, Depth + 1);
 		pDC->SetOrigin(Px, Py);
 	}
 	
 	#if DEBUG_DRAW_TD
 	if (TagId == TAG_TD)
 	{
 		LTag *Tbl = this;
 		while (Tbl && Tbl->TagId != TAG_TABLE)
 			Tbl = ToTag(Tbl->Parent);
 		if (Tbl && Tbl->Debug)
 		{
 			int Ls = pDC->LineStyle(LSurface::LineDot);
 			pDC->Colour(LColour::Blue);
 			pDC->Box(0, 0, Size.x-1, Size.y-1);
 			pDC->LineStyle(Ls);
 		}
 	}
 	#endif
 }
 
 //////////////////////////////////////////////////////////////////////
 LHtml::LHtml(int id, int x, int y, int cx, int cy, LDocumentEnv *e) :
 	LDocView(e),
 	ResObject(Res_Custom),
 	LHtmlParser(NULL)
 {
 	View = this;
 	d = new LHtmlPrivate;
 	SetReadOnly(true);
 	ViewWidth = -1;
 	SetId(id);
 	LRect r(x, y, x+cx, y+cy);
 	SetPos(r);
 	Cursor = 0;
 	Selection = 0;
 	DocumentUid = 0;
 
 	_New();
 }
 
 LHtml::~LHtml()
 {
 	_Delete();
 	DeleteObj(d);
 
 	if (JobSem.Lock(_FL))
 	{
 		JobSem.Jobs.DeleteObjects();
 		JobSem.Unlock();
 	}
 }
 
 void LHtml::_New()
 {
 	d->StyleDirty = false;
 	d->IsLoaded = false;
 	d->Content.x = d->Content.y = 0;
 	d->DeferredLoads = 0;
 	Tag = 0;
 	DocCharSet.Reset();
 
 	IsHtml = true;
 	
 	#ifdef DefaultFont
 	LFont *Def = new LFont;
 	if (Def)
 	{
 		if (Def->CreateFromCss(DefaultFont))
 			SetFont(Def, true);
 		else
 			DeleteObj(Def);
 	}
 	#endif
 	
 	FontCache = new LFontCache(this);	
 	SetScrollBars(false, false);
 }
 
 void LHtml::_Delete()
 {
 	LAssert(!d->IsParsing);
 
 	CssStore.Empty();
 	CssHref.Empty();
 	OpenTags.Length(0);
 	Source.Reset();
 	DeleteObj(Tag);
 	DeleteObj(FontCache);
 }
 
 LFont *LHtml::DefFont()
 {
 	return GetFont();
 }
 
 void LHtml::OnAddStyle(const char *MimeType, const char *Styles)
 {
 	if (Styles)
 	{
 		const char *c = Styles;
 		bool Status = CssStore.Parse(c);
 		if (Status)
 		{
 			d->StyleDirty = true;
 		}
 
 		#if 0 // def _DEBUG
 		bool LogCss = false;
 		if (!Status)
 		{
 			char p[MAX_PATH_LEN];
 			sprintf_s(p, sizeof(p), "c:\\temp\\css_parse_failure_%i.txt", LRand());
 			LFile f;
 			if (f.Open(p, O_WRITE))
 			{
 				f.SetSize(0);
 				if (CssStore.Error)
 					f.Print("Error: %s\n\n", CssStore.Error.Get());
 				f.Write(Styles, strlen(Styles));
 				f.Close();
 			}
 		}
 
 		if (LogCss)
 		{
 			LStringPipe p;
 			CssStore.Dump(p);
 			LAutoString a(p.NewStr());
 			LFile f;
 			if (f.Open("C:\\temp\\css.txt", O_WRITE))
 			{
 				f.Write(a, strlen(a));
 				f.Close();
 			}
 		}
 		#endif
 	}
 }
 
 void LHtml::ParseDocument(const char *Doc)
 {
 	if (!Tag)
 	{
 		Tag = new LTag(this, 0);
 	}
 
 	if (GetCss())
 		GetCss()->DeleteProp(LCss::PropBackgroundColor);
 	if (Tag)
 	{
 		Tag->TagId = ROOT;
 		OpenTags.Length(0);
 
 		if (IsHtml)
 		{
 			Parse(Tag, Doc);
 
 			// Add body tag if not specified...
 			LTag *Html = Tag->GetTagByName("html");
 			LTag *Body = Tag->GetTagByName("body");
 
 			if (!Html && !Body)
 			{
 				if ((Html = new LTag(this, 0)))
 					Html->SetTag("html");
 				if ((Body = new LTag(this, Html)))
 					Body->SetTag("body");
 				
 				Html->Attach(Body);
 
 				if (Tag->Text())
 				{
 					LTag *Content = new LTag(this, Body);
 					if (Content)
 					{
 						Content->TagId = CONTENT;
 						Content->Text(NewStrW(Tag->Text()));
 					}
 				}
 				while (Tag->Children.Length())
 				{
 					LTag *t = ToTag(Tag->Children.First());
 					Body->Attach(t, Body->Children.Length());
 				}
 				DeleteObj(Tag);
 				
 				Tag = Html;
 			}
 			else if (!Body)
 			{
 				if ((Body = new LTag(this, Html)))
 					Body->SetTag("body");
 					
 				for (unsigned i=0; i<Html->Children.Length(); i++)
 				{
 					LTag *t = ToTag(Html->Children[i]);
 					if (t->TagId != TAG_HEAD)
 					{
 						Body->Attach(t);
 						i--;
 					}
 				}
 				
 				Html->Attach(Body);
 			}
 			
 			if (Html && Body)
 			{
 				char16 *t = Tag->Text();
 				if (t)
 				{
 					if (ValidStrW(t))
 					{
 						LTag *Content = new LTag(this, 0);
 						if (Content)
 						{
 							Content->Text(NewStrW(Tag->Text()));
 							Body->Attach(Content, 0);
 						}
 					}
 					Tag->Text(0);
 				}
 
 				#if 0 // Enabling this breaks the test file 'gw2.html'.
 				for (LTag *t = Html->Tags.First(); t; )
 				{
 					if (t->Tag && t->Tag[0] == '!')
 					{
 						Tag->Attach(t, 0);
 						t = Html->Tags.Current();
 					}
 					else if (t->TagId != TAG_HEAD &&
 							t != Body)
 					{
 						if (t->TagId == TAG_HTML)
 						{
 							LTag *c;
 							while ((c = t->Tags.First()))
 							{
 								Html->Attach(c, 0);
 							}
 
 							t->Detach();
 							DeleteObj(t);
 						}
 						else
 						{
 							t->Detach();
 							Body->Attach(t);
 						}
 
 						t = Html->Tags.Current();
 					}
 					else
 					{
 						t = Html->Tags.Next();
 					}
 				}
 				#endif					
 
 				if (Environment)
 				{
 					const char *OnLoad;
 					if (Body->Get("onload", OnLoad))
 					{
 						Environment->OnExecuteScript(this, (char*)OnLoad);
 					}
 				}
 			}
 		}
 		else
 		{
 			Tag->ParseText(Source);
 		}
 	}
 
 	ViewWidth = -1;
 	if (Tag)
 		Tag->ResetCaches();
 	Invalidate();
 }
 
 bool LHtml::NameW(const char16 *s)
 {
 	LAutoPtr<char, true> utf(WideToUtf8(s));
 	return Name(utf);
 }
 
 const char16 *LHtml::NameW()
 {
 	LBase::Name(Source);
 	return LBase::NameW();
 }
 
 bool LHtml::Name(const char *s)
 {
 	int Uid = -1;
 	if (Environment)
 		Uid = Environment->NextUid();
 	if (Uid < 0)
 		Uid = GetDocumentUid() + 1;
 	SetDocumentUid(Uid);
 
 	_Delete();
 	_New();
 
 	IsHtml = false;
 
 	// Detect HTML
 	const char *c = s;
 	while ((c = strchr(c, '<')))
 	{
 		char *t = 0;
 		c = ParseName((char*) ++c, &t);
 		if (t && GetTagInfo(t))
 		{
 			DeleteArray(t);
 			IsHtml = true;
 			break;
 		}
 		DeleteArray(t);
 	}
 
 	// Parse
 	d->IsParsing = true;
 	ParseDocument(s);
 	d->IsParsing = false;
 
 	if (Tag && d->StyleDirty)
 	{
 		d->StyleDirty = false;
 		Tag->RestyleAll();
 	}
 
 	if (d->DeferredLoads == 0)
 	{
 		OnLoad();
 	}
 
 	Invalidate();	
 
 	return true;
 }
 
 const char *LHtml::Name()
 {
 	if (!Source && Tag)
 	{
 		LStringPipe s(1024);
 		Tag->CreateSource(s);
 		Source.Reset(s.NewStr());
 	}
 
 	return Source;
 }
 
 LMessage::Result LHtml::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_COPY:
 		{
 			Copy();
 			break;
 		}
 		case M_JOBS_LOADED:
 		{
 			bool Update = false;
 			int InitDeferredLoads = d->DeferredLoads;
 			
 			if (JobSem.Lock(_FL))
 			{
 				for (unsigned i=0; i<JobSem.Jobs.Length(); i++)
 				{
 					LDocumentEnv::LoadJob *j = JobSem.Jobs[i];
 					int MyUid = GetDocumentUid();
 
 					// LgiTrace("%s:%i - Receive job %p, %p\n", _FL, j, j->UserData);
 					
 					if (j->UserUid == MyUid &&
 						j->UserData != NULL)
 					{
 						Html1::LTag *r = static_cast<Html1::LTag*>(j->UserData);
 						
 						if (d->DeferredLoads > 0)
 							d->DeferredLoads--;
 						
 						// Check the tag is still in our tree...
 						if (Tag->HasChild(r))
 						{
 							// Process the returned data...
 							if (r->TagId == TAG_IMG)
 							{
 								if (j->pDC)
 								{
 									r->SetImage(j->Uri, j->pDC.Release());
 									ViewWidth = 0;
 									Update = true;
 								}
 								else if (j->Stream)
 								{
 									LAutoPtr<LSurface> pDC(GdcD->Load(dynamic_cast<LStream*>(j->Stream.Get())));
 									if (pDC)
 									{
 										r->SetImage(j->Uri, pDC.Release());
 										ViewWidth = 0;
 										Update = true;
 									}
 									else LgiTrace("%s:%i - Image decode failed for '%s'\n", _FL, j->Uri.Get());
 								}
 								else if (j->Status == LDocumentEnv::LoadJob::JobOk)
 									LgiTrace("%s:%i - Unexpected job type for '%s'\n", _FL, j->Uri.Get());
 							}
 							else if (r->TagId == TAG_LINK)
 							{
 								if (!CssHref.Find(j->Uri))
 								{
 									LStreamI *s = j->GetStream();
 									if (s)
 									{
 										s->ChangeThread();
 
 										int Size = (int)s->GetSize();
 										LAutoString Style(new char[Size+1]);
 										ssize_t rd = s->Read(Style, Size);
 										if (rd > 0)
 										{
 											Style[rd] = 0;
 											CssHref.Add(j->Uri, true);
 											OnAddStyle("text/css", Style);									
 											ViewWidth = 0;
 											Update = true;
 										}
 									}
 								}
 							}
 							else if (r->TagId == TAG_IFRAME)
 							{
 								// Remote IFRAME loading not support for security reasons.
 							}
 							else LgiTrace("%s:%i - Unexpected tag '%s' for URI '%s'\n", _FL,
 								r->Tag.Get(),
 								j->Uri.Get());
 						}
 						else
 						{
 							/*
 							Html1::LTag *p = ToTag(r->Parent);
 							while (p && p->Parent)
 								p = ToTag(p->Parent);
 							*/
 							LgiTrace("%s:%i - No child tag for job.\n", _FL);
 						}
 					}
 					// else it's from another (historical) HTML control, ignore
 				}
 				JobSem.Jobs.DeleteObjects();
 				JobSem.Unlock();
 			}
 			
 			if (InitDeferredLoads > 0 && d->DeferredLoads <= 0)
 			{
 				LAssert(d->DeferredLoads == 0);
 				d->DeferredLoads = 0;
 				OnLoad();
 			}
 
 			if (Update)
 			{
 				OnPosChange();
 				Invalidate();
 			}
 			break;
 		}
 	}
 
 	return LDocView::OnEvent(Msg);
 }
 
 int LHtml::OnNotify(LViewI *c, LNotification n)
 {
 	switch (c->GetId())
 	{
 		case IDC_VSCROLL:
 		{
 			int LineY = GetFont()->GetHeight();
 
 			if (Tag)
 				Tag->ClearToolTips();
 
 			if (n.Type == LNotifyScrollBarCreate && VScroll && LineY > 0)
 			{
 				int y = Y();
 				int p = MAX(y / LineY, 1);
 				int fy = d->Content.y / LineY;
 				VScroll->SetPage(p);
 				VScroll->SetRange(fy);
 			}
 			
 			Invalidate();
 			break;
 		}
 		default:
 		{
 			LTag *Ctrl = Tag ? Tag->FindCtrlId(c->GetId()) : NULL;
 			if (Ctrl)
 				return Ctrl->OnNotify(n);
 			break;
 		}
 	}
 
 	return LLayout::OnNotify(c, n);
 }
 
 void LHtml::OnPosChange()
 {
 	LLayout::OnPosChange();
 	if (ViewWidth != X())
 	{
 		Invalidate();
 	}
 }
 
 LPoint LHtml::Layout(bool ForceLayout)
 {
 	LRect Client = GetClient();
 	if (Tag && (ViewWidth != Client.X() || ForceLayout))
 	{
 		LFlowRegion f(this, Client, false);
 
 		// Flow text, width is different
 		Tag->OnFlow(&f, 0);
 		ViewWidth = Client.X();
 		d->Content.x = f.MAX.x + 1;
 		d->Content.y = f.MAX.y + 1;
 
 		// Set up scroll box
 		bool Sy = f.y2 > Y();
 		int LineY = GetFont()->GetHeight();
 
 		uint64 Now = LCurrentTime();
 		if (Now - d->SetScrollTime > 100)
 		{
 			d->SetScrollTime = Now;
 			SetScrollBars(false, Sy);
 			
 			if (Sy && VScroll && LineY > 0)
 			{
 				int y = Y();
 				int p = MAX(y / LineY, 1);
 				int fy = f.y2 / LineY;
 				VScroll->SetPage(p);
 				VScroll->SetRange(fy);
 			}
 		}
 		else
 		{
 			// LgiTrace("%s - Dropping SetScroll, loop detected: %i ms\n", GetClass(), (int)(Now - d->SetScrollTime));
 		}
 	}
 
 	return d->Content;
 }
 
 LPointF LHtml::GetDpiScale()
 {
 	LPointF Scale(1.0, 1.0);
 	auto Wnd = GetWindow();
 	if (Wnd)
 		Scale = Wnd->GetDpiScale();
 	return Scale;
 }
 
 void LHtml::OnPaint(LSurface *ScreenDC)
 {
 	// LProfile Prof("LHtml::OnPaint");
 
 	#if HTML_USE_DOUBLE_BUFFER
 	LRect Client = GetClient();
 	if (ScreenDC->IsScreen())
 	{
 		if (!MemDC ||
 			(MemDC->X() < Client.X() || MemDC->Y() < Client.Y()))
 		{
 			if (MemDC.Reset(new LMemDC))
 			{
 				int Sx = Client.X() + 10;
 				int Sy = Client.Y() + 10;
 				if (!MemDC->Create(Sx, Sy, System32BitColourSpace))
 				{
 					MemDC.Reset();
 				}
 			}
 		}
 		if (MemDC)
 		{
 			MemDC->ClipRgn(NULL);
 			#if 0//def _DEBUG
 			MemDC->Colour(LColour(255, 0, 255));
 			MemDC->Rectangle();
 			#endif
 		}
 	}
 	#endif
 
 	LSurface *pDC = MemDC ? MemDC : ScreenDC;
 
 	#if 0
 	Gtk::cairo_matrix_t mx;
 	Gtk::cairo_get_matrix(pDC->Handle(), &mx);
 	LPoint Offset;
 	WindowVirtualOffset(&Offset);
 	printf("\tHtml paint mx=%g,%g off=%i,%i\n",
 		mx.x0, mx.y0,
 		Offset.x, Offset.y);
 	#endif
 
 	LColour cBack;
 	if (GetCss())
 	{
 		LCss::ColorDef Bk = GetCss()->BackgroundColor();
 		if (Bk.Type == LCss::ColorRgb)
 			cBack = Bk;
 	}
 	if (!cBack.IsValid())
 		cBack = LColour(Enabled() ? L_WORKSPACE : L_MED);
 	pDC->Colour(cBack);
 	pDC->Rectangle();
 
 	if (Tag)
 	{
 		Layout();
 
 		if (VScroll)
 		{
 			int LineY = GetFont()->GetHeight();
 			int Vs = (int)VScroll->Value();
 			pDC->SetOrigin(0, Vs * LineY);
 		}
 
 		bool InSelection = false;
 		PaintStart = LCurrentTime();
 		d->MaxPaintTimeout = false;
 
 		Tag->OnPaint(pDC, InSelection, 0);
 
 		if (d->MaxPaintTimeout)
 		{
 			LgiTrace("%s:%i - Html max paint time reached: %i ms.\n", _FL, LCurrentTime() - PaintStart);
 		}
 	}
 
 	#if HTML_USE_DOUBLE_BUFFER
 	if (MemDC)
 	{
 		pDC->SetOrigin(0, 0);
 		ScreenDC->Blt(0, 0, MemDC);
 	}
 	#endif
 
 	if (d->OnLoadAnchor && VScroll)
 	{
 		LAutoString a = d->OnLoadAnchor;
 		GotoAnchor(a);
 		LAssert(d->OnLoadAnchor == 0);
 	}
 }
 
 bool LHtml::HasSelection()
 {
 	if (Cursor && Selection)
 	{
 		return	Cursor->Cursor >= 0 &&
 				Selection->Selection >= 0 &&
 				!(Cursor == Selection && Cursor->Cursor == Selection->Selection);
 	}
 
 	return false;
 }
 
 void LHtml::UnSelectAll()
 {
 	bool i = false;
 	if (Cursor)
 	{
 		Cursor->Cursor = -1;
 		Cursor = NULL;
 		i = true;
 	}
 	if (Selection)
 	{
 		Selection->Selection = -1;
 		Selection = NULL;
 		i = true;
 	}
 	if (i)
 	{
 		Invalidate();
 	}
 }
 
 void LHtml::SelectAll()
 {
 }
 
 LTag *LHtml::GetLastChild(LTag *t)
 {
 	if (t && t->Children.Length())
 	{
 		for (LTag *i = ToTag(t->Children.Last()); i; )
 		{
 			LTag *c = i->Children.Length() ? ToTag(i->Children.Last()) : NULL;
 			if (c)
 				i = c;
 			else
 				return i;
 		}
 	}
 
 	return 0;
 }
 
 LTag *LHtml::PrevTag(LTag *t)
 {
 	// This returns the previous tag in the tree as if all the tags were
 	// listed via recursion using "in order".
 
 	// Walk up the parent chain looking for a prev
 	for (LTag *p = t; p; p = ToTag(p->Parent))
 	{
 		// Does this tag have a parent?
 		if (p->Parent)
 		{
 			// Prev?
 			LTag *pp = ToTag(p->Parent);
 			ssize_t Idx = pp->Children.IndexOf(p);
 			LTag *Prev = Idx > 0 ? ToTag(pp->Children[Idx - 1]) : NULL;
 			if (Prev)
 			{
 				LTag *Last = GetLastChild(Prev);
 				return Last ? Last : Prev;
 			}
 			else
 			{
 				return ToTag(p->Parent);
 			}
 		}
 	}
 
 	return 0;
 }
 
 LTag *LHtml::NextTag(LTag *t)
 {
 	// This returns the next tag in the tree as if all the tags were
 	// listed via recursion using "in order".
 
 	// Does this have a child tag?
 	if (t->Children.Length() > 0)
 	{
 		return ToTag(t->Children.First());
 	}
 	else
 	{
 		// Walk up the parent chain
 		for (LTag *p = t; p; p = ToTag(p->Parent))
 		{
 			// Does this tag have a next?
 			if (p->Parent)
 			{
 				LTag *pp = ToTag(p->Parent);
 				size_t Idx = pp->Children.IndexOf(p);
 				
 				LTag *Next = pp->Children.Length() > Idx + 1 ? ToTag(pp->Children[Idx + 1]) : NULL;
 				if (Next)
 				{
 					return Next;
 				}
 			}
 		}
 	}
 
 	return 0;
 }
 
 int LHtml::GetTagDepth(LTag *Tag)
 {
 	// Returns the depth of the tag in the tree.
 	int n = 0;
 	for (LTag *t = Tag; t; t = ToTag(t->Parent))
 	{
 		n++;
 	}
 	return n;
 }
 
 bool LHtml::IsCursorFirst()
 {
 	if (!Cursor || !Selection)
 		return false;
 	return CompareTagPos(Cursor, Cursor->Cursor, Selection, Selection->Selection);
 }
 
 bool LHtml::CompareTagPos(LTag *a, ssize_t AIdx, LTag *b, ssize_t BIdx)
 {
 	// Returns true if the 'a' is before 'b' point.
 	if (!a || !b)
 		return false;
 
 	if (a == b)
 	{
 		return AIdx < BIdx;
 	}
 	else
 	{
 		LArray<LTag*> ATree, BTree;
 		for (LTag *t = a; t; t = ToTag(t->Parent))
 			ATree.AddAt(0, t);
 		for (LTag *t = b; t; t = ToTag(t->Parent))
 			BTree.AddAt(0, t);
 
 		ssize_t Depth = MIN(ATree.Length(), BTree.Length());
 		for (int i=0; i<Depth; i++)
 		{
 			LTag *at = ATree[i];
 			LTag *bt = BTree[i];
 			if (at != bt)
 			{
 				LAssert(i > 0);
 				LTag *p = ATree[i-1];
 				LAssert(BTree[i-1] == p);
 				ssize_t ai = p->Children.IndexOf(at);
 				ssize_t bi = p->Children.IndexOf(bt);
 				return ai < bi;
 			}
 		}		
 	}
 
 	return false;
 }
 
 void LHtml::SetLoadImages(bool i)
 {
 	if (i ^ GetLoadImages())
 	{
 		LDocView::SetLoadImages(i);
 		SendNotify(LNotifyShowImagesChanged);
 
 		if (GetLoadImages() && Tag)
 		{
 			Tag->LoadImages();
 		}
 	}
 }
 
 char *LHtml::GetSelection()
 {
 	char *s = 0;
 
 	if (Cursor && Selection)
 	{
 		LMemQueue p;
 		bool InSelection = false;
 		Tag->CopyClipboard(p, InSelection);
 
 		int Len = (int)p.GetSize();
 		if (Len > 0)
 		{
 			char16 *t = (char16*)p.New(sizeof(char16));
 			if (t)
 			{
 				size_t Len = StrlenW(t);
 				for (int i=0; i<Len; i++)
 				{
 					if (t[i] == 0xa0) t[i] = ' ';
 				}
 				s = WideToUtf8(t);
 				DeleteArray(t);
 			}
 		}
 	}
 
 	return s;
 }
 
 bool LHtml::SetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	if (!Name)
 		return false;
 	if (!_stricmp(Name, "ShowImages"))
 	{
 		SetLoadImages(Value.CastInt32() != 0);
 	}
 	else return false;
 	
 	return true;
 }
 
 bool LHtml::Copy()
 {
 	LAutoString s(GetSelection());
 	if (s)
 	{
 		RemoveZeroWidthCharacters(s);
 
 		if (HasHomoglyphs(s, -1))
 		{
 			if (LgiMsg(	this,
 						"Text contains homoglyph characters that maybe a phishing attack.\n"
 						"Do you really want to copy it?",
 						"Warning",
 						MB_YESNO) == IDNO)
 				return false;
 		}
 	
 		LClipBoard c(this);
 		
 		LAutoWString w;
 		#ifndef MAC
 		w.Reset(Utf8ToWide(s));
 		if (w) c.TextW(w);
 		#endif
 
 		c.Text(s, w == 0);
 
 		return true;
 	}
 	else LgiTrace("%s:%i - Error: no selection\n", _FL);
 
 	return false;
 }
 
 /*
 static bool FindCallback(LFindReplaceCommon *Dlg, bool Replace, void *User)
 {
 	LHtml *h = (LHtml*)User;
 	return h->OnFind(Dlg);
 }
 */
 
 void BuildTagList(LArray<LTag*> &t, LTag *Tag)
 {
 	t.Add(Tag);
 	for (unsigned i=0; i<Tag->Children.Length(); i++)
 	{
 		LTag *c = ToTag(Tag->Children[i]);
 		BuildTagList(t, c);
 	}
 }
 
 static void FormEncode(LStringPipe &p, const char *c)
 {
 	const char *s = c;
 	while (*c)
 	{
 		while (*c && *c != ' ')
 			c++;
 		
 		if (c > s)
 		{
 			p.Write(s, c - s);
 			c = s;
 		}
 		if (*c == ' ')
 		{
 			p.Write("+", 1);
 			s = c;
 		}
 		else break;
 	}
 }
 
 bool LHtml::OnSubmitForm(LTag *Form)
 {
 	if (!Form || !Environment)
 	{
 		LAssert(!"Bad param");
 		return false;
 	}
 
 	const char *Method = NULL;
 	const char *Action = NULL;
 	if (!Form->Get("method", Method) ||
 		!Form->Get("action", Action))
 	{
 		LAssert(!"Missing form action/method");
 		return false;
 	}
 		
 	LHashTbl<ConstStrKey<char,false>,char*> f;
 	Form->CollectFormValues(f);
 	bool Status = false;
 	if (!_stricmp(Method, "post"))
 	{
 		LStringPipe p(256);
 		bool First = true;
 
 		// const char *Field;
 		// for (char *Val = f.First(&Field); Val; Val = f.Next(&Field))
 		for (auto v : f)
 		{
 			if (First)
 				First = false;
 			else
 				p.Write("&", 1);
 			
 			FormEncode(p, v.key);
 			p.Write("=", 1);
 			FormEncode(p, v.value);
 		}
 		
 		LAutoPtr<const char, true> Data(p.NewStr());
 		Status = Environment->OnPostForm(this, Action, Data);
 	}
 	else if (!_stricmp(Method, "get"))
 	{
 		Status = Environment->OnNavigate(this, Action);
 	}
 	else
 	{
 		LAssert(!"Bad form method.");
 	}
 	
 	f.DeleteArrays();
 	return Status;
 }
 
 bool LHtml::OnFind(LFindReplaceCommon *Params)
 {
 	bool Status = false;
 
 	if (Params)
 	{
 		if (!Params->Find)
 			return Status;
 
 		d->FindText.Reset(Utf8ToWide(Params->Find));
 		d->MatchCase = Params->MatchCase;
 	}		
 
 	if (!Cursor)
 		Cursor = Tag;
 
 	if (Cursor && d->FindText)
 	{
 		LArray<LTag*> Tags;
 		BuildTagList(Tags, Tag);
 		ssize_t Start = Tags.IndexOf(Cursor);
 		for (unsigned i=1; i<Tags.Length(); i++)
 		{
 			ssize_t Idx = (Start + i) % Tags.Length();
 			LTag *s = Tags[Idx];
 
 			if (s->Text())
 			{
 				char16 *Hit;
 				
 				if (d->MatchCase)
 					Hit = StrstrW(s->Text(), d->FindText);
 				else
 					Hit = StristrW(s->Text(), d->FindText);
 				
 				if (Hit)
 				{
 					// found something...
 					UnSelectAll();
 
 					Selection = Cursor = s;
 					Cursor->Cursor = Hit - s->Text();
 					Selection->Selection = Cursor->Cursor + StrlenW(d->FindText);
 					OnCursorChanged();
 					
 					if (VScroll)
 					{
 						// Scroll the tag into view...
 						int y = s->AbsY();
 						int LineY = GetFont()->GetHeight();
 						int Val = y / LineY;
 						SetVScroll(Val);
 					}
 					
 					Invalidate();
 					Status = true;
 					break;
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 void LHtml::DoFind(std::function<void(bool)> Callback)
 {
 	LFindDlg *Dlg = new LFindDlg(this,
-		[&](auto dlg, auto action)
+		[this](auto dlg, auto action)
 		{
 			OnFind(dlg);
 			delete dlg;
 		});
 	
 	Dlg->DoModal(NULL);
 }
 
 bool LHtml::OnKey(LKey &k)
 {
 	bool Status = false;
 
 	if (k.Down())
 	{
 		int Dy = 0;
 		int LineY = GetFont()->GetHeight();
 		int Page = GetClient().Y() / LineY;
 
 		switch (k.vkey)
 		{
 			case LK_F3:
 			{
 				OnFind(NULL);
 				break;
 			}
 			#ifdef WIN32
 			case LK_INSERT:
 				goto DoCopy;
 			#endif
 			case LK_UP:
 			{
 				Dy = -1;
 				Status = true;
 				break;
 			}
 			case LK_DOWN:
 			{
 				Dy = 1;
 				Status = true;
 				break;
 			}
 			case LK_PAGEUP:
 			{
 				Dy = -Page;
 				Status = true;
 				break;
 			}
 			case LK_PAGEDOWN:
 			{
 				Dy = Page;
 				Status = true;
 				break;
 			}
 			case LK_HOME:
 			{
 				Dy = (int) (VScroll ? -VScroll->Value() : 0);
 				Status = true;
 				break;
 			}
 			case LK_END:
 			{
 				if (VScroll)
 				{
 					LRange r = VScroll->GetRange();
 					Dy = (int)(r.End() - Page);
 				}
 				Status = true;
 				break;
 			}
 			default:
 			{
 				switch (k.c16)
 				{
 					case 'f':
 					case 'F':
 					{
 						if (k.CtrlCmd())
 						{
 							DoFind(NULL);
 							Status = true;
 						}
 						break;
 					}
 					case 'c':
 					case 'C':
 					{
 						#ifdef WIN32
 						DoCopy:
 						#endif
 						if (k.CtrlCmd())
 						{
 							Copy();
 							Status = true;
 						}
 						break;
 					}
 				}
 				break;
 			}
 		}
 
 		if (Dy && VScroll)
 			SetVScroll(VScroll->Value() + Dy);
 	}
 
 	return Status;
 }
 
 int LHtml::ScrollY()
 {
 	return GetFont()->GetHeight() * (VScroll ? (int)VScroll->Value() : 0);
 }
 
 void LHtml::OnMouseClick(LMouse &m)
 {
 	Capture(m.Down());
 	SetPulse(m.Down() ? 200 : -1);
 
 	if (m.Down())
 	{
 		Focus(true);
 
 		int Offset = ScrollY();
 		bool TagProcessedClick = false;
 
 		LTagHit Hit;
 		if (Tag)
 		{
 			Tag->GetTagByPos(Hit, m.x, m.y + Offset, 0, false, DEBUG_TAG_BY_POS);
 			#if DEBUG_TAG_BY_POS
 			Hit.Dump("MouseClick");
 			#endif
 		}
 		
 		if (m.Left() && !m.IsContextMenu())
 		{
 			if (m.Double())
 			{
 				d->WordSelectMode = true;
 
 				if (Cursor)
 				{
 					// Extend the selection out to the current word's boundaries.
 					Selection = Cursor;
 					Selection->Selection = Cursor->Cursor;
 
 					if (Cursor->Text())
 					{
 						ssize_t Base = Cursor->GetTextStart();
 						char16 *Text = Cursor->Text() + Base;
 						while (Text[Cursor->Cursor])
 						{
 							char16 c = Text[Cursor->Cursor];
 
 							if (strchr(WordDelim, c) || StrchrW(WhiteW, c))
 								break;
 
 							Cursor->Cursor++;
 						}
 					}
 					if (Selection->Text())
 					{
 						ssize_t Base = Selection->GetTextStart();
 						char16 *Sel = Selection->Text() + Base;
 						while (Selection->Selection > 0)
 						{
 							char16 c = Sel[Selection->Selection - 1];
 
 							if (strchr(WordDelim, c) || StrchrW(WhiteW, c))
 								break;
 
 							Selection->Selection--;
 						}
 					}
 
 					Invalidate();
 					SendNotify(LNotifySelectionChanged);
 				}
 			}
 			else if (Hit.NearestText)
 			{
 				d->WordSelectMode = false;
 				UnSelectAll();
 
 				Cursor = Hit.NearestText;
 				Cursor->Cursor = Hit.Index;
 
 				#if DEBUG_SELECTION
 				LgiTrace("StartSelect Near='%20S' Idx=%i\n", Hit.NearestText->Text(), Hit.Index);
 				#endif
 
 				OnCursorChanged();
 				SendNotify(LNotifySelectionChanged);
 			}
 			else
 			{
 				#if DEBUG_SELECTION
 				LgiTrace("StartSelect no text hit %p, %p\n", Cursor, Selection);
 				#endif
 			}
 		}
 
 		if (Hit.NearestText && Hit.Near == 0)
 		{
 			TagProcessedClick = Hit.NearestText->OnMouseClick(m);
 		}
 		else if (Hit.Direct)
 		{
 			TagProcessedClick = Hit.Direct->OnMouseClick(m);
 		}
 		#ifdef _DEBUG
 		else if (m.Left() && m.Ctrl())
 		{
 			LgiMsg(this, "No tag under the cursor.", GetClass());
 		}
 		#endif
 
 		if (!TagProcessedClick &&
 			m.IsContextMenu())
 		{
 			LSubMenu RClick;
 
 			enum ContextMenuCmds
 			{
 				IDM_DUMP = 100,
 				IDM_COPY_SRC,
 				IDM_VIEW_SRC,
 				IDM_EXTERNAL,
 				IDM_COPY,
 				IDM_VIEW_IMAGES,
 			};
 			#define IDM_CHARSET_BASE	10000
 
 			RClick.AppendItem					(LLoadString(L_TEXTCTRL_COPY, "Copy"), IDM_COPY, HasSelection());
 			LMenuItem *Vs = RClick.AppendItem	(LLoadString(L_VIEW_SOURCE, "View Source"), IDM_VIEW_SRC, Source != 0);
 			RClick.AppendItem					(LLoadString(L_COPY_SOURCE, "Copy Source"), IDM_COPY_SRC, Source != 0);
 			LMenuItem *Load = RClick.AppendItem	(LLoadString(L_VIEW_IMAGES, "View External Images"), IDM_VIEW_IMAGES, true);
 			if (Load) Load->Checked(GetLoadImages());
 			RClick.AppendItem					(LLoadString(L_VIEW_IN_DEFAULT_BROWSER, "View in Default Browser"), IDM_EXTERNAL, Source != 0);
 			LSubMenu *Cs = RClick.AppendSub		(LLoadString(L_CHANGE_CHARSET, "Change Charset"));
 
 			if (Cs)
 			{
 				int n=0;
 				for (LCharset *c = LGetCsList(); c->Charset; c++, n++)
 				{
 					Cs->AppendItem(c->Charset, IDM_CHARSET_BASE + n, c->IsAvailable());
 				}
 			}
 			
 			if (!GetReadOnly() || // Is editor
 				#ifdef _DEBUG
 				1
 				#else
 				0
 				#endif
 				)
 			{
 				RClick.AppendSeparator();
 				RClick.AppendItem("Dump Layout", IDM_DUMP, Tag != 0);
 			}
 
 			if (Vs)
 			{
 				Vs->Checked(!IsHtml);
 			}
 			
 			if (OnContextMenuCreate(Hit, RClick) &&
 				GetMouse(m, true))
 			{
 				int Id = RClick.Float(this, m.x, m.y);
 				switch (Id)
 				{
 					case IDM_COPY:
 					{
 						Copy();
 						break;
 					}
 					case IDM_VIEW_SRC:
 					{
 						if (Vs)
 						{
 							DeleteObj(Tag);
 							IsHtml = !IsHtml;
 							ParseDocument(Source);
 						}
 						break;
 					}
 					case IDM_COPY_SRC:
 					{
 						if (Source)
 						{
 							LClipBoard c(this);
 							const char *ViewCs = GetCharset();
 							if (ViewCs)
 							{
 								LAutoWString w((char16*)LNewConvertCp(LGI_WideCharset, Source, ViewCs));
 								if (w)
 									c.TextW(w);
 							}
 							else c.Text(Source);
 						}
 						break;
 					}
 					case IDM_VIEW_IMAGES:
 					{
 						SetLoadImages(!GetLoadImages());
 						break;
 					}
 					case IDM_DUMP:
 					{
 						if (Tag)
 						{
 							LAutoWString s = Tag->DumpW();
 							if (s)
 							{
 								LClipBoard c(this);
 								c.TextW(s);
 							}
 						}
 						break;
 					}
 					case IDM_EXTERNAL:
 					{
 						if (!Source)
 						{
 							LgiTrace("%s:%i - No HTML source code.\n", _FL);
 							break;
 						}
 
 						char Path[MAX_PATH_LEN];
 						if (!LGetSystemPath(LSP_TEMP, Path, sizeof(Path)))
 						{
 							LgiTrace("%s:%i - Failed to get the system path.\n", _FL);
 							break;
 						}
 						
 						char f[32];
 						sprintf_s(f, sizeof(f), "_%i.html", LRand(1000000));
 						LMakePath(Path, sizeof(Path), Path, f);
 						
 						LFile F;
 						if (!F.Open(Path, O_WRITE))
 						{
 							LgiTrace("%s:%i - Failed to open '%s' for writing.\n", _FL, Path);
 							break;
 						}
 
 						LStringPipe Ex;
 						bool Error = false;
 						
 						F.SetSize(0);
 
 						LAutoWString SrcMem;
 						const char *ViewCs = GetCharset();
 						if (ViewCs)
 							SrcMem.Reset((char16*)LNewConvertCp(LGI_WideCharset, Source, ViewCs));
 						else
 							SrcMem.Reset(Utf8ToWide(Source));						
 
 						for (char16 *s=SrcMem; s && *s;)
 						{
 							char16 *cid = StristrW(s, L"cid:");
 							while (cid && !strchr("\'\"", cid[-1]))
 							{
 								cid = StristrW(cid+1, L"cid:");
 							}
 
 							if (cid)
 							{
 								char16 Delim = cid[-1];
 								char16 *e = StrchrW(cid, Delim);
 								if (e)
 								{
 									*e = 0;
 									if (StrchrW(cid, '\n'))
 									{
 										*e = Delim;
 										Error = true;
 										break;
 									}
 									else
 									{
 										char File[MAX_PATH_LEN] = "";
 										if (Environment)
 										{
 											LDocumentEnv::LoadJob *j = Environment->NewJob();
 											if (j)
 											{
 												j->Uri.Reset(WideToUtf8(cid));
 												j->Env = Environment;
 												j->Pref = LDocumentEnv::LoadJob::FmtFilename;
 												j->UserUid = GetDocumentUid();
 
 												LDocumentEnv::LoadType Result = Environment->GetContent(j);
 												if (Result == LDocumentEnv::LoadImmediate)
 												{
 													if (j->Filename)
 														strcpy_s(File, sizeof(File), j->Filename);
 												}
 												else if (Result == LDocumentEnv::LoadDeferred)
 												{
 													d->DeferredLoads++;
 												}
 												
 												DeleteObj(j);
 											}
 										}
 										
 										*e = Delim;
 										Ex.Push(s, cid - s);
 										if (File[0])
 										{
 											char *d;
 											while ((d = strchr(File, '\\')))
 											{
 												*d = '/';
 											}
 											
 											Ex.Push(L"file:///");
 											
 											LAutoWString w(Utf8ToWide(File));
 											Ex.Push(w);
 										}
 										s = e;
 									}
 								}
 								else
 								{
 									Error = true;
 									break;
 								}
 							}
 							else
 							{
 								Ex.Push(s);
 								break;
 							}
 						}
 
 						if (!Error)
 						{
 							int64 WideChars = Ex.GetSize() / sizeof(char16);
 							LAutoWString w(Ex.NewStrW());
 							
 							LAutoString u(WideToUtf8(w, WideChars));
 							if (u)
 								F.Write(u, strlen(u));
 							F.Close();
 							
 							LString Err;
 							if (!LExecute(Path, NULL, NULL, &Err))
 							{
 								LgiMsg(	this,
 										"Failed to open '%s'\n%s",
 										LAppInst ? LAppInst->LBase::Name() : GetClass(),
 										MB_OK,
 										Path,
 										Err.Get());
 							}
 						}
 						break;
 					}
 					default:
 					{
 						if (Id >= IDM_CHARSET_BASE)
 						{
 							LCharset *c = LGetCsList() + (Id - IDM_CHARSET_BASE);
 							if (c->Charset)
 							{
 								Charset = c->Charset;
 								OverideDocCharset = true;
 
 								char *Src = Source.Release();
 								_Delete();
 								_New();
 								Source.Reset(Src);
 								ParseDocument(Source);
 
 								Invalidate();
 
 								SendNotify(LNotifyCharsetChanged);
 							}								
 						}
 						else
 						{
 							OnContextMenuCommand(Hit, Id);
 						}
 						break;
 					}
 				}
 			}
 		}
 	}
 	else // Up Click
 	{
 		if (Selection &&
 			Cursor &&
 			Selection == Cursor &&
 			Selection->Selection == Cursor->Cursor)
 		{
 			Selection->Selection = -1;
 			Selection = 0;
 			SendNotify(LNotifySelectionChanged);
 
 			#if DEBUG_SELECTION
 			LgiTrace("NoSelect on release\n");
 			#endif
 		}
 	}
 }
 
 void LHtml::OnLoad()
 {
 	d->IsLoaded = true;
 	SendNotify(LNotifyDocLoaded);
 }
 
 LTag *LHtml::GetTagByPos(int x, int y, ssize_t *Index, LPoint *LocalCoords, bool DebugLog)
 {
 	LTag *Status = NULL;
 
 	if (Tag)
 	{
 		if (DebugLog)
 			LgiTrace("GetTagByPos starting...\n");
 
 		LTagHit Hit;
 		Tag->GetTagByPos(Hit, x, y, 0, DebugLog);
 
 		if (DebugLog)
 			LgiTrace("GetTagByPos Hit=%s, %i, %i...\n\n", Hit.Direct ? Hit.Direct->Tag.Get() : 0, Hit.Index, Hit.Near);
 		
 		Status = Hit.NearestText && Hit.Near == 0 ? Hit.NearestText : Hit.Direct;
 		if (Hit.NearestText && Hit.Near < 30)
 		{
 			if (Index) *Index = Hit.Index;
 			if (LocalCoords) *LocalCoords = Hit.LocalCoords;
 		}
 	}
 
 	return Status;
 }
 
 void LHtml::SetVScroll(int64 v)
 {
 	if (!VScroll)
 		return;
 	
 	if (Tag)
 		Tag->ClearToolTips();
 
 	VScroll->Value(v);
 	Invalidate();
 }
 
 bool LHtml::OnMouseWheel(double Lines)
 {
 	if (VScroll)
 		SetVScroll(VScroll->Value() + (int64)Lines);
 	return true;
 }
 
 LCursor LHtml::GetCursor(int x, int y)
 {
 	int Offset = ScrollY();
 	ssize_t Index = -1;
 	LPoint LocalCoords;
 	LTag *Tag = GetTagByPos(x, y + Offset, &Index, &LocalCoords);
 	if (Tag)
 	{
 		LString Uri;
 		if (LocalCoords.x >= 0 &&
 			LocalCoords.y >= 0 &&
 			Tag->IsAnchor(&Uri))
 		{
 			LRect c = GetClient();
 			c.Offset(-c.x1, -c.y1);
 			if (c.Overlap(x, y) && ValidStr(Uri))
 			{
 				return LCUR_PointingHand;
 			}
 		}
 	}
 	
 	return LCUR_Normal;
 }
 
 void LTag::ClearToolTips()
 {
 	if (TipId)
 	{
 		Html->Tip.DeleteTip(TipId);
 		TipId = 0;
 	}
 
 	for (auto c: Children)
 		ToTag(c)->ClearToolTips();
 }
 
 
 void LHtml::OnMouseMove(LMouse &m)
 {
 	if (!Tag)
 		return;
 
 	int Offset = ScrollY();
 	LTagHit Hit;
 	Tag->GetTagByPos(Hit, m.x, m.y + Offset, 0, false);
 	if (!Hit.Direct && !Hit.NearestText)
 		return;
 
 	LString Uri;
 	LTag *HitTag = Hit.NearestText && Hit.Near == 0 ? Hit.NearestText : Hit.Direct;
 	if (HitTag &&
 		HitTag->TipId == 0 &&
 		Hit.LocalCoords.x >= 0 &&
 		Hit.LocalCoords.y >= 0 &&
 		HitTag->IsAnchor(&Uri) &&
 		Uri)
 	{
 		if (!Tip.GetParent())
 		{
 			Tip.Attach(this);
 		}
 
 		LRect r = HitTag->GetRect(false);
 		r.Offset(0, -Offset);
 		if (!HitTag->TipId)
 			HitTag->TipId = Tip.NewTip(Uri, r);
 		// LgiTrace("NewTip: %s @ %s, ID=%i\n", Uri.Get(), r.GetStr(), HitTag->TipId);
 	}
 
 	if (IsCapturing() &&
 		Cursor &&
 		Hit.NearestText)
 	{
 		if (!Selection)
 		{
 			Selection = Cursor;
 			Selection->Selection = Cursor->Cursor;
 			Cursor = Hit.NearestText;
 			Cursor->Cursor = Hit.Index;
 			OnCursorChanged();
 			Invalidate();
 			
 			SendNotify(LNotifySelectionChanged);
 
 			#if DEBUG_SELECTION
 			LgiTrace("CreateSelection '%20S' %i\n", Hit.NearestText->Text(), Hit.Index);
 			#endif
 		}
 		else if ((Cursor != Hit.NearestText) ||
 				 (Cursor->Cursor != Hit.Index))
 		{
 			// Move the cursor to track the mouse
 			if (Cursor)
 			{
 				Cursor->Cursor = -1;
 			}
 
 			Cursor = Hit.NearestText;
 			Cursor->Cursor = Hit.Index;
 			#if DEBUG_SELECTION
 			LgiTrace("ExtendSelection '%20S' %i\n", Hit.NearestText->Text(), Hit.Index);
 			#endif
 
 			if (d->WordSelectMode && Cursor->Text())
 			{
 				ssize_t Base = Cursor->GetTextStart();
 				if (IsCursorFirst())
 				{
 					// Extend the cursor up the document to include the whole word
 					while (Cursor->Cursor > 0)
 					{
 						char16 c = Cursor->Text()[Base + Cursor->Cursor - 1];
 
 						if (strchr(WordDelim, c) || StrchrW(WhiteW, c))
 							break;
 
 						Cursor->Cursor--;
 					}
 				}
 				else
 				{
 					// Extend the cursor down the document to include the whole word
 					while (Cursor->Text()[Base + Cursor->Cursor])
 					{
 						char16 c = Cursor->Text()[Base + Cursor->Cursor];
 
 						if (strchr(WordDelim, c) || StrchrW(WhiteW, c))
 							break;
 
 						Cursor->Cursor++;
 					}
 				}
 			}
 
 			OnCursorChanged();
 			Invalidate();
 			SendNotify(LNotifySelectionChanged);
 		}
 	}
 }
 
 void LHtml::OnPulse()
 {
 	if (VScroll && IsCapturing())
 	{
 		int Fy = DefFont() ? DefFont()->GetHeight() : 16;
 		LMouse m;
 		if (GetMouse(m, false))
 		{
 			LRect c = GetClient();
 			int Lines = 0;
 			
 			if (m.y < c.y1)
 			{
 				// Scroll up
 				Lines = (c.y1 - m.y + Fy - 1) / -Fy;
 			}
 			else if (m.y > c.y2)
 			{
 				// Scroll down
 				Lines = (m.y - c.y2 + Fy - 1) / Fy;
 			}
 			
 			if (Lines && VScroll)
 				SetVScroll(VScroll->Value() +  Lines);
 		}
 	}
 }
 
 LRect *LHtml::GetCursorPos()
 {
 	return &d->CursorPos;
 }
 
 void LHtml::SetCursorVis(bool b)
 {
 	if (d->CursorVis ^ b)
 	{
 		d->CursorVis = b;
 		Invalidate();
 	}
 }
 
 bool LHtml::GetCursorVis()
 {
 	return d->CursorVis;
 }
 
 LDom *ElementById(LTag *t, char *id)
 {
 	if (t && id)
 	{
 		const char *i;
 		if (t->Get("id", i) && _stricmp(i, id) == 0)
 			return t;
 
 		for (unsigned i=0; i<t->Children.Length(); i++)
 		{
 			LTag *c = ToTag(t->Children[i]);
 			LDom *n = ElementById(c, id);
 			if (n) return n;
 		}
 	}
 
 	return 0;
 }
 
 LDom *LHtml::getElementById(char *Id)
 {
 	return ElementById(Tag, Id);
 }
 
 bool LHtml::GetLinkDoubleClick()
 {
 	return d->LinkDoubleClick;
 }
 
 void LHtml::SetLinkDoubleClick(bool b)
 {
 	d->LinkDoubleClick = b;
 }
 
 bool LHtml::GetFormattedContent(const char *MimeType, LString &Out, LArray<LDocView::ContentMedia> *Media)
 {
 	if (!MimeType)
 	{
 		LAssert(!"No MIME type for getting formatted content");
 		return false;
 	}
 
 	if (!_stricmp(MimeType, "text/html"))
 	{
 		// We can handle this type...
 		LArray<LTag*> Imgs;
 		if (Media)
 		{
 			// Find all the image tags...
 			Tag->Find(TAG_IMG, Imgs);
 
 			// Give them CID's if they don't already have them
 			for (unsigned i=0; i<Imgs.Length(); i++)
 			{
 				LTag *Img = Imgs[i];
 				if (!Img)
 					continue;
 				
 				const char *Cid = NULL, *Src;
 				if (Img->Get("src", Src) &&
 					!Img->Get("cid", Cid))
 				{
 					char id[256];
 					sprintf_s(id, sizeof(id), "%x.%x", (unsigned)LCurrentTime(), (unsigned)LRand());
 					Img->Set("cid", id);
 					Img->Get("cid", Cid);
 				}
 
 				if (Src && Cid)
 				{
 					LFile *f = new LFile;
 					if (f)
 					{
 						if (f->Open(Src, O_READ))
 						{
 							// Add the exported image stream to the media array
 							LDocView::ContentMedia &m = Media->New();
 							m.Id = Cid;
 							m.Stream.Reset(f);
 						}
 					}
 				}
 			}
 		}
 
 		// Export the HTML, including the CID's from the first step
 		Out = Name();
 	}
 	else if (!_stricmp(MimeType, "text/plain"))
 	{
 		// Convert DOM tree down to text instead...
 		LStringPipe p(512);
 		if (Tag)
 		{
 			LTag::TextConvertState State(&p);
 			Tag->ConvertToText(State);
 		}
 		Out = p.NewGStr();
 	}
 
 	return false;
 }
 
 void LHtml::OnContent(LDocumentEnv::LoadJob *Res)
 {
 	if (JobSem.Lock(_FL))
 	{
 		JobSem.Jobs.Add(Res);
 		JobSem.Unlock();		
 		PostEvent(M_JOBS_LOADED);
 	}
 }
 
 LHtmlElement *LHtml::CreateElement(LHtmlElement *Parent)
 {
 	return new LTag(this, Parent);
 }
 
 bool LHtml::GetVariant(const char *Name, LVariant &Value, const char *Array)
 {
 	if (!_stricmp(Name, "supportLists")) // Type: Bool
 		Value = false;
 	else if (!_stricmp(Name, "vml")) // Type: Bool
 		// Vector Markup Language
 		Value = false;
 	else if (!_stricmp(Name, "mso")) // Type: Bool
 		// mso = Microsoft Office
 		Value = false;
 	else
 		return false;
 
 	return true;
 }
 
 bool LHtml::EvaluateCondition(const char *Cond)
 {
 	if (!Cond)
 		return true;
 	
 	// This is a really bad attempt at writing an expression evaluator.
 	// I could of course use the scripting language but that would pull
 	// in a fairly large dependency on the HTML control. However user
 	// apps that already have that could reimplement this virtual function
 	// if they feel like it.
 	LArray<char*> Str;
 	for (const char *c = Cond; *c; )
 	{
 		if (IsAlpha(*c))
 		{
 			Str.Add(LTokStr(c));
 		}
 		else if (IsWhiteSpace(*c))
 		{
 			c++;
 		}
 		else
 		{
 			const char *e = c;
 			while (*e && !IsWhiteSpace(*e) && !IsAlpha(*e))
 				e++;
 			Str.Add(NewStr(c, e - c));
 			LAssert(e > c);
 			if (e > c)
 				c = e;
 			else
 				break;
 		}
 	}
 
 	bool Result = true;
 	bool Not = false;
 	for (unsigned i=0; i<Str.Length(); i++)
 	{
 		char *s = Str[i];
 		if (!_stricmp(s, "!"))
 			Not = true;
 		else
 		{
 			LVariant v;
 			if (GetValue(s, v))
 			{
 				Result = v.CastInt32() != 0;
 				if (Not) Result = !Result;
 			}
 			else
 			{
 				// If this fires: update LHtml::GetVariant with the variable.
 				// LgiTrace("%s:%i - Unsupported variable '%s'\n", _FL, s);
 			}
 			Not = false;
 		}
 	}
 	
 	Str.DeleteArrays();
 	
 	return Result;
 }
 
 bool LHtml::GotoAnchor(char *Name)
 {
 	if (Tag)
 	{
 		LTag *a = Tag->GetAnchor(Name);
 		if (a)
 		{
 			if (VScroll)
 			{
 				int LineY = GetFont()->GetHeight();
 				int Ay = a->AbsY();
 				int Scr = Ay / LineY;
 				SetVScroll(Scr);
 				VScroll->SendNotify();
 			}
 			else
 				d->OnLoadAnchor.Reset(NewStr(Name));
 		}
 	}
 
 	return false;
 }
 
 bool LHtml::GetEmoji()
 {
 	return d->DecodeEmoji;
 }
 
 void LHtml::SetEmoji(bool i)
 {
 	d->DecodeEmoji = i;
 }
 
 void LHtml::SetMaxPaintTime(int Ms)
 {
 	d->MaxPaintTime = Ms;
 }
 
 bool LHtml::GetMaxPaintTimeout()
 {
 	return d->MaxPaintTimeout;
 }
 
 ////////////////////////////////////////////////////////////////////////
 class LHtml_Factory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (_stricmp(Class, "LHtml") == 0)
 		{
 			return new LHtml(-1, 0, 0, 100, 100, new LDefaultDocumentEnv);
 		}
 
 		return 0;
 	}
 
 } LHtml_Factory;
 
 //////////////////////////////////////////////////////////////////////
 struct BuildContext
 {
 	LHtmlTableLayout *Layout;
 	LTag *Table;
 	LTag *TBody;
 	LTag *CurTr;
 	LTag *CurTd;
 	int cx, cy;
 	
 	BuildContext()
 	{
 		Layout = NULL;
 		cx = cy = 0;
 
 		Table = NULL;
 		TBody = NULL;
 		CurTr = NULL;
 		CurTd = NULL;
 	}
 
 	bool Build(LTag *t, int Depth)
 	{
 		bool RetReattach = false;
 		
 		switch (t->TagId)
 		{
 			case TAG_TABLE:
 			{
 				if (!Table)
 					Table = t;
 				else
 					return false;
 				break;
 			}
 			case TAG_TBODY:
 			{
 				if (TBody)
 					return false;
 				TBody = t;
 				break;
 			}
 			case TAG_TR:
 			{
 				CurTr = t;
 				break;
 			}
 			case TAG_TD:
 			{
 				CurTd = t;
 				if (t->Parent != CurTr)
 				{
 					if
 					(
 						!CurTr &&
 						(Table || TBody)
 					)
 					{
 						LTag *p = TBody ? TBody : Table;
 						CurTr = new LTag(p->Html, p);
 						if (CurTr)
 						{
 							CurTr->Tag.Reset(NewStr("tr"));
 							CurTr->TagId = TAG_TR;
 							
 
 							ssize_t Idx = t->Parent->Children.IndexOf(t);
 							t->Parent->Attach(CurTr, Idx);
 						}
 					}
 					
 					if (CurTr)
 					{
 						CurTr->Attach(t);
 						RetReattach = true;
 					}
 					else
 					{
 						LAssert(0);
 						return false;
 					}
 				}
 				
 				t->Cell->Pos.x = cx;
 				t->Cell->Pos.y = cy;
 				Layout->Set(t);
 				break;
 			}
 			default:
 			{
 				if (CurTd == t->Parent)
 					return false;
 				break;
 			}
 		}
 
 		for (unsigned n=0; n<t->Children.Length(); n++)
 		{
 			LTag *c = ToTag(t->Children[n]);
 			bool Reattached = Build(c, Depth+1);
 			if (Reattached)
 				n--;
 		}
 		
 		if (t->TagId == TAG_TR)
 		{
 			CurTr = NULL;
 			cy++;
 			cx = 0;
 			Layout->s.y = cy;
 		}
 		if (t->TagId == TAG_TD)
 		{
 			CurTd = NULL;
 			cx += t->Cell->Span.x;
 			Layout->s.x = MAX(cx, Layout->s.x);
 		}
 		
 		return RetReattach;
 	}
 };
 
 LHtmlTableLayout::LHtmlTableLayout(LTag *table)
 {
 	Table = table;
 	if (!Table)
 		return;
 
 	#if 0
 
 	BuildContext Ctx;
 	Ctx.Layout = this;
 	Ctx.Build(table, 0);
 
 	#else
 
 	int y = 0;
 	LTag *FakeRow = 0;
 	LTag *FakeCell = 0;
 
 	LTag *r;
 	for (size_t i=0; i<Table->Children.Length(); i++)
 	{
 		r = ToTag(Table->Children[i]);
 		if (r->Display() == LCss::DispNone)
 			continue;
 			
 		if (r->TagId == TAG_TR)
 		{
 			FakeRow = 0;
 			FakeCell = 0;
 		}
 		else if (r->TagId == TAG_TBODY)
 		{
 			ssize_t Index = Table->Children.IndexOf(r);
 			for (size_t n=0; n<r->Children.Length(); n++)
 			{
 				LTag *t = ToTag(r->Children[n]);
 				Table->Children.AddAt(++Index, t);
 				t->Parent = Table;
 				
 				/*
 				LgiTrace("Moving '%s'(%p) from TBODY(%p) into '%s'(%p)\n",
 					t->Tag, t,
 					r,
 					t->Parent->Tag, t->Parent);
 				*/
 			}
 			r->Children.Length(0);
 		}
 		else
 		{
 			if (!FakeRow)
 			{
 				if ((FakeRow = new LTag(Table->Html, 0)))
 				{
 					FakeRow->Tag.Reset(NewStr("tr"));
 					FakeRow->TagId = TAG_TR;
 
 					ssize_t Idx = Table->Children.IndexOf(r);
 					Table->Attach(FakeRow, Idx);
 				}
 			}
 			if (FakeRow)
 			{
 				if (!IsTableCell(r->TagId) && !FakeCell)
 				{
 					if ((FakeCell = new LTag(Table->Html, FakeRow)))
 					{
 						FakeCell->Tag.Reset(NewStr("td"));
 						FakeCell->TagId = TAG_TD;
 						if ((FakeCell->Cell = new LTag::TblCell))
 						{
 							FakeCell->Cell->Span.x = 1;
 							FakeCell->Cell->Span.y = 1;
 						}
 					}
 				}
 
 				ssize_t Idx = Table->Children.IndexOf(r);
 				r->Detach();
 
 				if (IsTableCell(r->TagId))
 				{
 					FakeRow->Attach(r);
 				}
 				else
 				{
 					LAssert(FakeCell != NULL);
 					FakeCell->Attach(r);
 				}
 				i = Idx - 1;
 			}
 		}
 	}
 
 	FakeCell = NULL;
 	for (size_t n=0; n<Table->Children.Length(); n++)
 	{
 		LTag *r = ToTag(Table->Children[n]);
 		if (r->TagId == TAG_TR)
 		{
 			int x = 0;
 			for (size_t i=0; i<r->Children.Length(); i++)
 			{
 				LTag *cell = ToTag(r->Children[i]);
 				if (!IsTableCell(cell->TagId))
 				{
 					if (!FakeCell)
 					{
 						// Make a fake TD cell
 						FakeCell = new LTag(Table->Html, NULL);
 						FakeCell->Tag.Reset(NewStr("td"));
 						FakeCell->TagId = TAG_TD;
 						if ((FakeCell->Cell = new LTag::TblCell))
 						{
 							FakeCell->Cell->Span.x = 1;
 							FakeCell->Cell->Span.y = 1;
 						}
 						
 						// Join the fake TD into the TR
 						r->Children[i] = FakeCell;
 						FakeCell->Parent = r;
 					}
 					else
 					{
 						// Not the first non-TD tag, so delete it from the TR. Only the
 						// fake TD will remain in the TR.
 						r->Children.DeleteAt(i--, true);
 					}
 					
 					// Insert the tag into it as a child
 					FakeCell->Children.Add(cell);
 					cell->Parent = FakeCell;
 					cell = FakeCell;
 				}
 				else
 				{
 					FakeCell = NULL;
 				}
 				
 				if (IsTableCell(cell->TagId))
 				{
 					if (cell->Display() == LCss::DispNone)
 						continue;
 						
 					while (Get(x, y))
 					{
 						x++;
 					}
 
 					cell->Cell->Pos.x = x;
 					cell->Cell->Pos.y = y;
 					Set(cell);
 					x += cell->Cell->Span.x;
 				}
 			}
 
 			y++;
 			FakeCell = NULL;
 		}
 	}
 	
 	#endif
 }
 
 void LHtmlTableLayout::Dump()
 {
 	int Sx, Sy;
 	GetSize(Sx, Sy);
 
 	LgiTrace("Table %i x %i cells.\n", Sx, Sy);
 	for (int x=0; x<Sx; x++)
 	{
 		LgiTrace("--- %-2i--- ", x);
 	}
 	LgiTrace("\n");
 
 	for (int y=0; y<Sy; y++)
 	{
 		int x;
 		for (x=0; x<Sx; x++)
 		{
 			LTag *t = Get(x, y);
 			LgiTrace("%-10p", t);
 		}
 		LgiTrace("\n");
 
 		for (x=0; x<Sx; x++)
 		{
 			LTag *t = Get(x, y);
 			char s[256] = "";
 			if (t)
 				sprintf_s(s, sizeof(s), "%i,%i-%i,%i", t->Cell->Pos.x, t->Cell->Pos.y, t->Cell->Span.x, t->Cell->Span.y);
 			LgiTrace("%-10s", s);
 		}
 		LgiTrace("\n");
 	}
 
 	LgiTrace("\n");
 }
 
 void LHtmlTableLayout::GetAll(List<LTag> &All)
 {
 	LHashTbl<PtrKey<void*>, bool> Added;
 	for (size_t y=0; y<c.Length(); y++)
 	{
 		CellArray &a = c[y];
 		for (size_t x=0; x<a.Length(); x++)
 		{
 			LTag *t = a[x];
 			if (t && !Added.Find(t))
 			{
 				Added.Add(t, true);
 				All.Insert(t);
 			}
 		}
 	}
 }
 
 void LHtmlTableLayout::GetSize(int &x, int &y)
 {
 	x = 0;
 	y = (int)c.Length();
 
 	for (size_t i=0; i<c.Length(); i++)
 	{
 		x = MAX(x, (int) c[i].Length());
 	}
 }
 
 LTag *LHtmlTableLayout::Get(int x, int y)
 {
 	if (y >= (int) c.Length())
 		return NULL;
 	
 	CellArray &a = c[y];
 	if (x >= (int) a.Length())
 		return NULL;
 	
 	return a[x];
 }
 
 bool LHtmlTableLayout::Set(LTag *t)
 {
 	if (!t)
 		return false;
 
 	for (int y=0; y<t->Cell->Span.y; y++)
 	{
 		for (int x=0; x<t->Cell->Span.x; x++)
 		{
 			// LAssert(!c[y][x]);
 			c[t->Cell->Pos.y + y][t->Cell->Pos.x + x] = t;
 		}
 	}
 
 	return true;
 }
 
 void LTagHit::Dump(const char *Desc)
 {
 	LArray<LTag*> d, n;
 	LTag *t = Direct;
 	unsigned i;
 	for (i=0; i<3 && t; t = ToTag(t->Parent), i++)
 	{
 		d.AddAt(0, t);
 	}
 	t = NearestText;
 	for (i=0; i<3 && t; t = ToTag(t->Parent), i++)
 	{
 		n.AddAt(0, t);
 	}
 	
 	LgiTrace("Hit: %s Direct: ", Desc);
 	for (i=0; i<d.Length(); i++)
 		LgiTrace(">%s", d[i]->Tag ? d[i]->Tag.Get() : "CONTENT");
 	LgiTrace(" Nearest: ");
 	for (i=0; i<n.Length(); i++)
 		LgiTrace(">%s", n[i]->Tag ? n[i]->Tag.Get() : "CONTENT");
 	LgiTrace(" Local: %ix%i Index: %i Block: %s '%.10S'\n",
 		LocalCoords.x, LocalCoords.y,
 		Index,
 		Block ? Block->GetStr() : NULL,
 		Block ? Block->Text + Index : NULL);
 }
 
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,5439 +1,5439 @@
 #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.NewGStr();
 		#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 = [&](bool ok)
+			auto DoSave = [this, OnStatus, FileName=LString(FileName)](bool ok)
 			{
 				Save(FileName);				
 				if (OnStatus)
 					OnStatus(ok);
 			};
 			
 			if (!FileName)
 			{
 				LFileSelect *Select = new LFileSelect;
 				Select->Parent(this);
 				Select->Save([&FileName, &DoSave](auto Select, auto ok)
 				{
 					if (ok)
 						FileName = Select->Name();					
 					DoSave(ok);
 					delete Select;
 				});
 			}
 			else DoSave(true);
 		}
 		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;
 			}
 		}
 	}
 
 	LAutoString LastFind8(SingleLineSelection ? GetSelection() : WideToUtf8(d->FindReplaceParams->LastFind));
 	LAutoString LastReplace8(WideToUtf8(d->FindReplaceParams->LastReplace));
 	
 	auto Dlg = new LReplaceDlg(this, [this, LastFind8, LastReplace8](LFindReplaceCommon *Dlg, int 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 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()));
 				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,5510 +1,5510 @@
 #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.NewGStr());
 
 	#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.NewGStr();
 		#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 = [&](bool ok)
+			auto DoSave = [this, OnStatus, FileName=LString(FileName)](bool ok)
 			{
 				Save(FileName);				
 				if (OnStatus)
 					OnStatus(ok);
 			};
 			
 			if (!FileName)
 			{
 				LFileSelect *Select = new LFileSelect;
 				Select->Parent(this);
 				Select->Save([&FileName, &DoSave](auto Select, auto ok)
 				{
 					if (ok)
 						FileName = Select->Name();					
 					DoSave(ok);
 					delete Select;
 				});
 			}
 			else DoSave(true);
 		}
 		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()));
 				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,3098 +1,3100 @@
 #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)
 {
 	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)
 		{
 			auto BlockLine = i - 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,
 					"Text contains homoglyph characters that maybe a phishing attack.\n"
 					"Do you really want to copy it?",
 					"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()
 {
-	LString Html;
-	LAutoWString Text;
-	LAutoPtr<LSurface> Img;
 	LClipBoard Cb(this);
 		
-	return Cb.Bitmap([&](auto bmp, auto str)
+	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([&](auto dlg, auto status)
+				Select->Save([this](auto dlg, auto status)
 				{
 					if (status)
-						FileName = dlg->Name();
+						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)
 	{
 		if (ctrlId == IDOK)
 		{
 			LString s = input->GetStr();
 			int64 i = s.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,
-							[&](auto dlg, auto ctrlId)
+							[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)
 			{
 				if (ctrlId == IDOK)
 				{
 					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/Graph.cpp b/src/common/Widgets/Graph.cpp
--- a/src/common/Widgets/Graph.cpp
+++ b/src/common/Widgets/Graph.cpp
@@ -1,1017 +1,1017 @@
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Graph.h"
 #include "lgi/common/DocView.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 #include <math.h>
 
 #define SELECTION_SIZE          2
 
 struct GraphAv
 {
 	uint64 Sum;
 	uint64 Count;
 };
 
 struct DataSeriesPriv
 {
 	LColour colour;
 	LArray<LGraph::Pair> values;
 };
 
 struct LGraphPriv
 {
 	constexpr static int AxisMarkPx = 8;
 
 	LGraph *View = NULL;
 	int XAxis = 0, YAxis = 0;
 	LVariantType XType, YType;
 	LVariant MaxX, MinX;
 	LVariant MaxY, MinY;
 	
 	LArray<LGraph::DataSeries*> Data;
 	
 	LGraph::Style Style;
 	LPoint MouseLoc;
 	bool ShowCursor = false;
 	LString LabelX, LabelY;
 	double Zoom = 1.0, Px = 0.0, Py = 0.0;
 	
 	// Averages
 	bool Average;
 	LArray<GraphAv> Ave;
 	int BucketSize;
 	
 	// Selection
 	LAutoPtr<LPoint> Select;
 	LArray<LGraph::Pair*> Selection;
 	
 	LGraphPriv(LGraph *view) : View(view)
 	{
 		#if 1
 		Style = LGraph::PointGraph;
 		#else
 		Style = LGraph::LineGraph;
 		#endif
 		Empty();
 	}
 
 	~LGraphPriv()
 	{
 		Empty();
 	}
 
 	void Empty()
 	{
 		Zoom = 1.0;
 		Px = 0.0;
 		Py = 0.0;
 		LabelX.Empty();
 		LabelY.Empty();
 		Average = false;
 		BucketSize = 500;
 		Data.DeleteObjects();
 		XType = GV_NULL;
 		YType = GV_NULL;
 		MinX.Empty();
 		MinY.Empty();
 		MaxX.Empty();
 		MaxY.Empty();
 	}
 
 	LVariantType GuessType(char *s)
 	{
 		bool Dot = false;
 		bool Num = false;
 		bool Alpha = false;
 		bool Delims = false;
 
 		while (s && *s)
 		{
 			if (IsAlpha(*s))
 				Alpha = true;
 			else if (IsDigit(*s))
 				Num = true;
 			else if (strchr("/\\-_:", *s))
 				Delims = true;
 			else if (*s == '.')
 				Dot = true;
 			s++;
 		}
 
 		if (Num)
 		{
 			if (Delims)
 				return GV_DATETIME;
 			if (Dot)
 				return GV_DOUBLE;
 			
 			return GV_INT64;
 		}
 		else
 		{
 			return GV_STRING;
 		}
 	}
 
 	bool Convert(LVariant &v, LVariantType type, char *in)
 	{
 		if (!in)
 			return false;
 		switch (type)
 		{
 			case GV_DOUBLE:
 				v = atof(in);
 				break;
 			case GV_DATETIME:
 			{
 				LDateTime dt;
 				dt.SetFormat(0);
 				dt.Set(in);
 				v = &dt;
 				break;
 			}
 			case GV_INT64:
 				v = (int64_t)atoi64(in);
 				break;
 			case GV_STRING:
 				v = in;
 				break;
 			default:
 				LAssert(!"Not impl.");
 				break;
 		}
 		return true;
 	}
 
 	int Compare(LVariant &a, LVariant &b)
 	{
 		// a - b
 		if (a.Type != b.Type)
 		{
 			LAssert(!"Only defined for comparing values of the same type.");
 			return 0;
 		}
 
 		switch (a.Type)
 		{
 			case GV_DOUBLE:
 			{
 				double d = a.Value.Dbl - b.Value.Dbl;
 				if (d < 0) return -1;
 				else if (d > 0) return 1;
 				break;
 			}
 			case GV_DATETIME:
 			{
 				return a.Value.Date->Compare(b.Value.Date);
 				break;
 			}
 			case GV_INT64:
 			{
 				int64 i = a.Value.Int64 - b.Value.Int64;
 				if (i < 0) return -1;
 				else if (i > 0) return 1;
 				break;
 			}
 			case GV_STRING:
 			{
 				return stricmp(a.Str(), b.Str());
 				break;
 			}
 			default:
 			{
 				LAssert(!"Not impl.");
 				break;
 			}
 		}
 
 		return 0;
 	}
 
 	LVariant ViewToData(int coord, int pixels, LVariant &min, LVariant &max)
 	{
 		LVariant r;
 
 		if (pixels <= 0)
 			return r;
 
 		switch (min.Type)
 		{
 			case GV_DATETIME:
 			{
 				uint64 Min, Max;
 				min.Value.Date->Get(Min);
 				max.Value.Date->Get(Max);				
 				
 				uint64 ts = Min + ( ((uint64)coord * (Max - Min)) / pixels); 
 				LDateTime dt;
 				dt.Set(ts);
 
 				r = &dt;
 				break;
 			}
 			case GV_INT64:
 			{
 				int64 Min, Max;
 				Min = min.CastInt64();
 				Max = max.CastInt64();
 
 				r = Min + (((int64)coord * (Max - Min)) / pixels);
 				break;
 			}
 			case GV_DOUBLE:
 			{
 				double Min, Max;
 				Min = min.CastDouble();
 				Max = max.CastDouble();
 
 				r = Min + (((double)coord * (Max - Min)) / pixels);
 				break;
 			}
 			default:
 				LAssert(0);
 				break;
 		}
 
 		return r;
 	}
 
 	int DataToView(LVariant &v, int pixels, LVariant &min, LVariant &max)
 	{
 		if (v.Type != min.Type ||
 			v.Type != max.Type)
 		{
 			LAssert(!"Incompatible types.");
 			return 0;
 		}
 
 		switch (v.Type)
 		{
 			case GV_DATETIME:
 			{
 				uint64 Min, Max, Val;
 				min.Value.Date->Get(Min);
 				max.Value.Date->Get(Max);
 				v.Value.Date->Get(Val);
 				int64 Range = Max - Min;
 				LAssert(Range > 0);
 
 				return (int) ((Val - Min) * (pixels - 1) / Range);
 				break;
 			}
 			case GV_INT64:
 			{
 				int64 Min, Max, Val;
 				Min = min.CastInt64();
 				Max = max.CastInt64();
 				Val = v.CastInt64();
 
 				int64 Range = Max - Min;
 				LAssert(Range > 0);
 
 				return (int) ((Val - Min) * (pixels - 1) / Range);
 				break;
 			}
 			case GV_DOUBLE:
 			{
 				double Min, Max, Val;
 				Min = min.CastDouble();
 				Max = max.CastDouble();
 				Val = v.CastDouble();
 
 				double Range = Max - Min;
 				LAssert(Range > 0);
 
 				return (int) ((Val - Min) * (pixels - 1) / Range);
 				break;
 			}
 			default:
 				LAssert(0);
 				break;
 		}
 
 		return 0;
 	}
 
 	LString DataToString(LVariant &v)
 	{
 		LString s;
 		switch (v.Type)
 		{
 			case GV_DATETIME:
 			{
 				if (v.Value.Date->Hours() ||
 					v.Value.Date->Minutes())
 					s = v.Value.Date->Get();
 				else
 					s = v.Value.Date->GetDate();
 				break;
 			}
 			case GV_INT64:
 			{
 				s.Printf(LPrintfInt64, v.CastInt64());
 				break;
 			}
 			case GV_INT32:
 			{
 				s.Printf("%" PRIi32, v.CastInt32());
 				break;
 			}
 			case GV_DOUBLE:
 			{
 				s.Printf("%g", v.CastDouble());
 				break;
 			}
 			default:
 			{
 				LAssert(!"Impl me.");
 				break;
 			}
 		}
 		return s;
 	}
 
 	void DrawAxis(LSurface *pDC, LRect &r, int xaxis, LVariant &min, LVariant &max, LString &label)
 	{
 		LVariant v = min;
 		bool First = true;
 		bool Loop = true;
 
 		if (min.Type == GV_NULL ||
 			max.Type == GV_NULL)
 			return;
 
 		int x = xaxis ? r.x1 : r.x2;
 		int y = xaxis ? r.y1 : r.y2;
 		int pixels = xaxis ? r.X() : r.Y();
 		int64 int_range = 0;
 		double dbl_inc = 0.0;
 		int64 int64_inc = 0;
 		int date_inc = 1;
 
 		auto Fnt = View->GetFont();
 		Fnt->Colour(L_TEXT, L_WORKSPACE);
 
 		LArray<LVariant> Values;
 		while (Loop)
 		{
 			Values.Add(v);
 			switch (v.Type)
 			{
 				default:
 				{
 					Loop = false;
 					return;
 					break;
 				}
 				case GV_DATETIME:
 				{
 					if (First)
 					{
 						uint64 s, e;
 						min.Value.Date->Get(s);
 						max.Value.Date->Get(e);
 						int64 period = e - s;
 						double days = (double)period / LDateTime::DayLength;
 						if (days > 7)
 							date_inc = (int) (days / 5);
 						else
 							date_inc = 1;
 						v.Value.Date->SetTime("0:0:0");
 					}
 					v.Value.Date->AddDays(date_inc);
 					Loop = *v.Value.Date < *max.Value.Date;
 					break;
 				}
 				case GV_INT64:
 				{
 					if (First)
 					{
 						int64 int64_range = max.CastInt64() - min.CastInt64();
 						int64 rng = int64_range;
 						int p = 0;
 						while (rng > 10)
 						{
 							p++;
 							rng /= 10;
 						}
 						while (rng < 1)
 						{
 							p--;
 							rng *= 10;
 						}
 						int64_inc = (int64) pow(10.0, p);
 						int64 d = (int64)((v.CastInt64() + int64_inc) / int64_inc);
 						v = d * int64_inc;
 					}
 					else
 					{
 						v = v.CastInt64() + int64_inc;
 					}
 					Loop = v.CastInt64() < max.CastInt64();
 					break;
 				}
 				case GV_DOUBLE:
 				{
 					if (First)
 					{
 						double dbl_range = max.CastDouble() - min.CastDouble();
 						double rng = dbl_range;
 						if (std::abs(rng - 0.0) > 0.0001)
 						{
 							int p = 0;
 							while (rng > 10)
 							{
 								p++;
 								rng /= 10;
 							}
 							while (rng < 1)
 							{
 								p--;
 								rng *= 10;
 							}
 							dbl_inc = pow(10.0, p);
 							int d = (int)((v.CastDouble() + dbl_inc) / dbl_inc);
 							v = (double)d * dbl_inc;
 						}
 						else v = 0.0;
 					}
 					else
 					{
 						v = v.CastDouble() + dbl_inc;
 					}
 					Loop = v.CastDouble() < max.CastDouble();
 					break;
 				}
 			}
 
 			First = false;
 		}
 		Values.Add(max);
 
 		for (int i=0; i<Values.Length(); i++)
 		{
 			v = Values[i];
 			auto Offset = DataToView(v, pixels, min, max);
 			int dx = (int)(x + (xaxis ? Offset : 0));
 			int dy = (int)(y - (xaxis ? 0 : Offset));
 
 			LString s = DataToString(v);
 
 			LDisplayString ds(LSysFont, s);
 			if (xaxis)
 				ds.Draw(pDC, dx - (ds.X()/2), dy + AxisMarkPx);
 			else
 				ds.Draw(pDC, dx - ds.X() - AxisMarkPx, dy - (ds.Y() / 2));
 
 			if (xaxis)
 				pDC->Line(dx, dy, dx, dy + 5);
 			else
 				pDC->Line(dx, dy, dx - 5, dy);
 		}
 
 		if (label)
 		{
 			LDisplayString ds(Fnt, label);
 			ds.Draw(pDC, r.Center().x, r.y2-ds.Y());
 		}
 	}
 
 	LColour GenerateColour()
 	{
 		LColour c;
 		c.SetHLS((uint16_t) (Data.Length() * 360 / 8), 255, 128);
 		c.ToRGB();
 		return c;
 	}
 };
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 LGraph::DataSeries::DataSeries(LGraphPriv *graphPriv, const char *name)
 {
 	d = new DataSeriesPriv;
 	priv = graphPriv;
 	Name(name);
 }
 
 LGraph::DataSeries::~DataSeries()
 {
 }
 
 LColour LGraph::DataSeries::GetColour()
 {
 	return d->colour;
 }
 
 void LGraph::DataSeries::SetColour(LColour c)
 {
 	d->colour = c;
 }
 
 bool LGraph::DataSeries::AddPair(char *x, char *y, void *UserData)
 {
 	if (!x || !y)
 		return false;
 
 	if (priv->XType == GV_NULL)
 		priv->XType = priv->GuessType(x);
 	if (priv->YType == GV_NULL)
 		priv->YType = priv->GuessType(y);
 
 	Pair &p = d->values.New();
 	p.UserData = UserData;
 	
 	if (priv->Convert(p.x, priv->XType, x))
 	{
 		if (priv->MaxX.IsNull() || priv->Compare(p.x, priv->MaxX) > 0)
 			priv->MaxX = p.x;
 		if (priv->MinX.IsNull() || priv->Compare(p.x, priv->MinX) < 0)
 			priv->MinX = p.x;
 	}
 	else
 	{
 		d->values.PopLast();
 		return false;
 	}
 
 	if (priv->Convert(p.y, priv->YType, y))
 	{
 		if (priv->MaxY.IsNull() || priv->Compare(p.y, priv->MaxY) > 0)
 			priv->MaxY = p.y;
 		if (priv->MinY.IsNull() || priv->Compare(p.y, priv->MinY) < 0)
 			priv->MinY = p.y;
 	}
 	else
 	{
 		d->values.PopLast();
 		return false;
 	}
 	
 	return true;
 }
 
 bool LGraph::DataSeries::SetDataSource(LDbRecordset *Rs, int XAxis, int YAxis)
 {
 	if (!Rs)
 		return false;
 
 	priv->XType = GV_NULL;
 	priv->YType = GV_NULL;
 
 	if (XAxis >= 0)
 		priv->XAxis = XAxis;
 	if (YAxis >= 0)
 		priv->YAxis = YAxis;
 
 	if (Rs->Fields() >= 2)
 	{
 		int Idx = 0;
 		for (bool b = Rs->MoveFirst(); b; b = Rs->MoveNext(), Idx++)
 		{
 			if (priv->XAxis < 0 || priv->YAxis < 0)
 			{
 				for (int i=0; i<Rs->Fields(); i++)
 				{
 					char *s = (*Rs)[i];
 					LVariantType t = priv->GuessType(s);
 					if (t != GV_NULL && t != GV_STRING)
 					{
 						if (priv->XAxis < 0)
 						{
 							priv->XAxis = i;
 							priv->XType = t;
 						}
 						else if (priv->YAxis < 0)
 						{
 							priv->YAxis = i;
 							priv->YType = t;
 						}
 						else break;
 					}
 				}
 			}			
 			
 			if (priv->XAxis >= 0 && priv->YAxis >= 0)
 				AddPair((*Rs)[priv->XAxis], (*Rs)[priv->YAxis]);
 		}
 	}
 
 	return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 LGraph::LGraph(int Id, int XAxis, int YAxis)
 {
 	d = new LGraphPriv(this);
 	d->XAxis = XAxis;
 	d->YAxis = YAxis;
 	SetPourLargest(true);
 }
 
 LGraph::~LGraph()
 {
 	DeleteObj(d);
 }
 
 void LGraph::Empty()
 {
 	d->Empty();
 	Invalidate();
 }
 
 LGraph::DataSeries *LGraph::GetData(const char *Name, bool Create)
 {
 	for (auto s: d->Data)
 		if (!Stricmp(s->Name(), Name))
 			return s;
 
 	if (!Create)
 		return NULL;
 
 	auto s = new DataSeries(d, Name);
 	if (!s)
 		return NULL;
 
 	s->SetColour(d->GenerateColour());
 	d->Data.Add(s);
 	return s;
 }
 
 LGraph::DataSeries *LGraph::GetDataAt(size_t index)
 {
 	return d->Data.IdxCheck(index) ? d->Data[index] : NULL;
 }
 
 size_t LGraph::GetDataLength()
 {
 	return d->Data.Length();
 }
 
 void LGraph::SetStyle(Style s)
 {
 	d->Style = s;
 	Invalidate();
 }
 
 LGraph::Style LGraph::GetStyle()
 {
 	return d->Style;
 }
 
 enum Msg
 {
 	IDM_LINE = 100,
 	IDM_POINT,
 	IDM_AVERAGE,
 	IDM_AVERAGE_SAVE,
 	IDM_SHOW_CURSOR,
 };
 
 void LGraph::OnMouseClick(LMouse &m)
 {
 	if (m.IsContextMenu())
 	{
 		LSubMenu s;
 		m.ToScreen();
 
 		auto CursorItem = s.AppendItem("Show Cursor", IDM_SHOW_CURSOR);
 		if (CursorItem) CursorItem->Checked(d->ShowCursor);
 
 		auto style = s.AppendSub("Style");
 		style->AppendItem("Line", IDM_LINE);
 		style->AppendItem("Point", IDM_POINT);
 		
 		auto a = s.AppendSub("Average");
 		auto i = a->AppendItem("Show", IDM_AVERAGE);
 		i->Checked(d->Average);
 		a->AppendItem("Save", IDM_AVERAGE_SAVE);
 
 		switch (s.Float(this, m.x, m.y))
 		{
 			case IDM_SHOW_CURSOR:
 				ShowCursor(!d->ShowCursor);
 				break;
 			case IDM_LINE:
 				SetStyle(LineGraph);
 				break;
 			case IDM_POINT:
 				SetStyle(PointGraph);
 				break;
 			case IDM_AVERAGE:
 				d->Average = !d->Average;
 				Invalidate();
 				break;
 			case IDM_AVERAGE_SAVE:
 			{
 				if (!d->Ave.Length())
 				{
 					LgiMsg(this, "No average calculated.", "LGraph");
 					break;
 				}
 
 				auto s = new LFileSelect(this);
 				s->Name("average.csv");
 				char Desktop[MAX_PATH_LEN];
 				LGetSystemPath(LSP_DESKTOP, Desktop, sizeof(Desktop));
 				s->InitialDir(Desktop);
-				s->Save([&](auto dlg, auto status)
+				s->Save([this](auto dlg, auto status)
 				{
 					if (status)
 					{
 						LFile o;
 						if (!o.Open(dlg->Name(), O_WRITE))
 						{
 							LgiMsg(this, "Failed to open file for writing.", "LGraph");
 							return;
 						}
 
 						o.SetSize(0);
 						switch (d->MinX.Type)
 						{
 							case GV_INT64:
 							{
 								auto XRange = d->MaxX.CastInt64() - d->MinX.CastInt64() + 1;
 								for (int b=0; b<d->BucketSize; b++)
 								{
 									GraphAv &g = d->Ave[b];
 									int64 x = d->MinX.CastInt64() + (((b * d->BucketSize) + (d->BucketSize >> 1)) / XRange);
 									int64 y = (g.Count) ? g.Sum / g.Count : 0;
 									o.Print(LPrintfInt64 "," LPrintfInt64 "\n", x, y);
 								}
 								break;
 							}
 							case GV_DOUBLE:
 							{
 								double XRange = d->MaxX.CastDouble() - d->MinX.CastDouble();
 								for (int b=0; b<d->BucketSize; b++)
 								{
 									GraphAv &g = d->Ave[b];
 									double x = d->MinX.CastDouble() + ( ((double)b+0.5) * XRange / d->BucketSize);
 									int64 y = (g.Count) ? g.Sum / g.Count : 0;
 									o.Print("%f," LPrintfInt64 "\n", x, y);
 								}
 								break;
 							}
 							default:
 								LAssert(0);
 								break;
 						}
 					}
 
 					delete dlg;
 				});
 				break;
 			}
 		}
 	}
 	else if (m.Left() && m.Down())
 	{
 		d->Select.Reset(new LPoint);
 		d->Select->x = m.x;
 		d->Select->y = m.y;
 		Invalidate();        
 	}
 }
 
 LArray<LGraph::Pair*> *LGraph::GetSelection()
 {
 	return &d->Selection;
 }
 
 bool LGraph::ShowCursor()
 {
 	return d->ShowCursor;
 }
 
 void LGraph::ShowCursor(bool show)
 {
 	if (show ^ d->ShowCursor)
 	{
 		d->ShowCursor = show;
 		Invalidate();
 	}
 }
 
 const char *LGraph::GetLabel(bool XAxis)
 {
 	if (XAxis)
 		return d->LabelX;
 	else
 		return d->LabelY;
 }
 
 void LGraph::SetLabel(bool XAxis, const char *Label)
 {
 	if (XAxis)
 		d->LabelX = Label;
 	else
 		d->LabelY = Label;
 	Invalidate();
 }
 
 LGraph::Range LGraph::GetRange(bool XAxis)
 {
 	Range r;
 	if (XAxis)
 	{
 		r.Min = d->MinX;
 		r.Max = d->MaxX;
 	}
 	else
 	{
 		r.Min = d->MinY;
 		r.Max = d->MaxY;
 	}
 	return r;
 }
 
 void LGraph::SetRange(bool XAxis, Range r)
 {
 	if (XAxis)
 	{
 		d->MinX = r.Min;
 		d->MaxX = r.Max;
 	}
 	else
 	{
 		d->MinY = r.Min;
 		d->MaxY = r.Max;
 	}
 	Invalidate();
 }
 
 void LGraph::OnMouseMove(LMouse &m)
 {
 	d->MouseLoc = m;
 	if (d->ShowCursor)
 		Invalidate();
 }
 
 bool LGraph::OnMouseWheel(double Lines)
 {
 	LMouse m;
 	GetMouse(m);
 
 	if (m.Ctrl())
 		d->Zoom -= Lines / 30;
 	else if (m.Shift())
 		d->Px -= Lines / (50 * d->Zoom);
 	else
 		d->Py -= Lines / (50 * d->Zoom);
 	Invalidate();
 
 	return true;
 }
 
 void LGraph::OnPaint(LSurface *pDC)
 {
 	LAutoPtr<LDoubleBuffer> DoubleBuf;
 	if (d->ShowCursor)
 		DoubleBuf.Reset(new LDoubleBuffer(pDC));
 
 	pDC->Colour(L_WORKSPACE);
 	pDC->Rectangle();
 
 	LColour cBorder(222, 222, 222);
 	LRect c = GetClient();
 	LRect data = c;
 	data.Inset(20, 20);
 	data.x2 -= 40;
 	data.SetSize((int)(d->Zoom * data.X()), (int)(d->Zoom * data.Y()));
 	data.Offset((int)(d->Px * data.X()), (int)(d->Py * data.Y()));
 	
 	LRect y = data;
 	y.x2 = y.x1 + 60;
 	data.x1 = y.x2 + 1;
 	LRect x = data;
 	x.y1 = x.y2 - 60;
 	y.y2 = data.y2 = x.y1 - 1;	
 	
 	pDC->Colour(cBorder);
 	pDC->Box(&data);
 
 	// Draw axis
 	d->DrawAxis(pDC, x, true, d->MinX, d->MaxX, d->LabelX);
 	d->DrawAxis(pDC, y, false, d->MinY, d->MaxY, d->LabelY);
 	
 	if (d->ShowCursor)
 	{
 		// Draw in cursor...
 		if (data.Overlap(d->MouseLoc))
 		{
 			// X axis cursor info
 			auto xCur = d->ViewToData(d->MouseLoc.x - data.x1, data.X(), d->MinX, d->MaxX);
 			pDC->VLine(d->MouseLoc.x, data.y1, data.y2 + d->AxisMarkPx);
 			LDisplayString dsX(GetFont(), d->DataToString(xCur));
 			dsX.Draw(pDC, d->MouseLoc.x - (dsX.X() >> 1), data.y2 + d->AxisMarkPx + dsX.Y());
 
 			// Y axis
 			auto yCur = d->ViewToData(data.y2 - d->MouseLoc.y, data.Y(), d->MinY, d->MaxY);
 			pDC->HLine(data.x1 - d->AxisMarkPx, data.x2, d->MouseLoc.y);
 			LDisplayString dsY(GetFont(), d->DataToString(yCur));
 			dsY.Draw(pDC, data.x1 - d->AxisMarkPx - dsY.X(), d->MouseLoc.y - (dsY.Y() >> 1));
 		}
 	}
 
 	// Draw data
 	int cx, cy, px, py;
 	pDC->Colour(LColour(0, 0, 222));
 
 	if (d->Average && !d->Ave.Length())
 	{
 		for (auto data: d->Data)
 		{
 			auto &values = data->d->values;
 			for (int i=0; i<values.Length(); i++)
 			{
 				Pair &p = values[i];
 				auto Bucket = d->DataToView(p.x, d->BucketSize, d->MinX, d->MaxX);
 				d->Ave[Bucket].Sum += p.y.CastInt64();
 				d->Ave[Bucket].Count++;
 			}
 		}
 	}
 	
 	switch (d->Style)
 	{
 		case LineGraph:
 		{
 			for (auto data: d->Data)
 			{
 				auto &values = data->d->values;
 				pDC->Colour(data->GetColour());
 				for (int i=0; i<values.Length(); i++)
 				{
 					Pair &p = values[i];
 					cx = x.x1 + (int)d->DataToView(p.x, x.X(), d->MinX, d->MaxX);
 					cy = y.y2 - (int)d->DataToView(p.y, y.Y(), d->MinY, d->MaxY);
 					if (i)
 						pDC->Line(cx, cy, px, py);
 					px = cx;
 					py = cy;
 				}
 			}
 			break;
 		}
 		case PointGraph:
 		{
 			for (auto data: d->Data)
 			{
 				auto &values = data->d->values;
 				pDC->Colour(data->GetColour());
 				for (int i=0; i<values.Length(); i++)
 				{
 					Pair &p = values[i];
 
 					int xmap = (int)d->DataToView(p.x, x.X(), d->MinX, d->MaxX);
 					int ymap = (int)d->DataToView(p.y, y.Y(), d->MinY, d->MaxY);
 					// LgiTrace("%s -> %i (%s, %s)\n", p.x.Value.Date->Get().Get(), xmap, d->MinX.Value.Date->Get().Get(), d->MaxX.Value.Date->Get().Get());
 					cx = x.x1 + xmap;
 					cy = y.y2 - ymap;
 					pDC->Set(cx, cy);
 				
 					if (d->Select &&
 						abs(d->Select->x - cx) < SELECTION_SIZE &&
 						abs(d->Select->y - cy) < SELECTION_SIZE)
 					{
 						d->Selection.Add(&p);
 					}
 				}
 			
 				if (d->Average)
 				{
 					int px = -1, py = -1;
 					pDC->Colour(LColour(255, 0, 0));
 					for (int b=0; b<d->BucketSize; b++)
 					{
 						if (d->Ave[b].Count)
 						{
 							int cx = x.x1 + (((b * x.X()) + (x.X() >> 1)) / d->BucketSize);
 							LVariant v = d->Ave[b].Sum / d->Ave[b].Count;
 							int cy = y.y2 - (int)d->DataToView(v, y.Y(), d->MinY, d->MaxY);
 						
 							if (py >= 0)
 							{
 								pDC->Line(cx, cy, px, py);
 							}	                    
 						
 							px = cx;
 							py = cy;
 						}
 					}
 				}
 			}
 
 			if (d->Select)
 			{
 				d->Select.Reset();
 				SendNotify();
 			}
 			break;
 		}
 	}
 }
 
diff --git a/src/common/Widgets/List.cpp b/src/common/Widgets/List.cpp
--- a/src/common/Widgets/List.cpp
+++ b/src/common/Widgets/List.cpp
@@ -1,2707 +1,2705 @@
 /*hdr
 **      FILE:           LList.cpp
 **      AUTHOR:         Matthew Allen
 **      DATE:           14/2/2000
 **      DESCRIPTION:    Lgi self-drawn listbox
 **
 **      Copyright (C) 2000 Matthew Allen
 **              fret@memecode.com
 */
 
 #include <math.h>
 #include <stdio.h>
 #include <ctype.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/SkinEngine.h"
 #include "lgi/common/List.h"
 #include "lgi/common/ScrollBar.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/CssTools.h"
 
 // Debug defines
 #define DEBUG_EDIT_LABEL				1
 
 // Number of pixels you have to move the mouse until a drag is initiated.
 #define DRAG_THRESHOLD					4
 
 // Switches for various profiling code..
 #define LList_POUR_PROFILE				1
 #define LList_ONPAINT_PROFILE			0
 
 // Options
 #define DOUBLE_BUFFER_PAINT				0
 
 #define ForAllItems(Var)				for (auto Var : Items)
 #define ForAllItemsReverse(Var)			Iterator<LListItem> ItemIter(&Items); for (LListItem *Var = ItemIter.Last(); Var; Var = ItemIter.Prev())
 #define VisibleItems()					CompletelyVisible // (LastVisible - FirstVisible + 1)
 #define MaxScroll()						MAX((int)Items.Length() - CompletelyVisible, 0)
 
 class LListPrivate
 {
 public:
 	// Mode
 	LListMode Mode;
 	int Columns;
 	int VisibleColumns;
 
 	// This is a pointer to a flag, that gets set when the object
 	// is deleted. Used to trap events deleting the window. If an
 	// event handler deletes the current window we can't touch any
 	// of the member variables anymore, so we need to know to quit/return
 	// ASAP.
 	bool *DeleteFlag;
 
 	// If this is true the ctrl is selecting lots of things
 	// and we only want to notify once.
 	bool NoSelectEvent;
 
 	// Drag'n'drop
 	LPoint DragStart;
 	int DragData;
 	
 	// Kayboard search
 	uint64 KeyLast;
 	char16 *KeyBuf;
 	
 	// Class
 	LListPrivate()
 	{
 		DragData = 0;
 		KeyBuf = 0;
 		DeleteFlag = 0;
 		Columns = 0;
 		VisibleColumns = 0;
 		Mode = LListDetails;
 		NoSelectEvent = false;
 	}
 	
 	~LListPrivate()
 	{
 		if (DeleteFlag)
 			*DeleteFlag = true;
 		DeleteArray(KeyBuf);
 	}
 };
 
 class LListItemPrivate
 {
 public:
 	bool Selected = false;
 	bool Visible = true;
 	int ListItem_Image = -1;
 	List<LListItemColumn> Cols;
 	LArray<char*> Str;
 	LArray<LDisplayString*> Display;
 	int16 LayoutColumn = -1;
 
 	LListItemPrivate()
 	{
 	}
 
 	~LListItemPrivate()
 	{
 		Cols.DeleteObjects();
 		EmptyStrings();
 		EmptyDisplay();
 	}
 
 	void EmptyStrings()
 	{
 		Str.DeleteArrays();
 	}
 
 	void EmptyDisplay()
 	{
 		Display.DeleteObjects();
 	}
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 LListItemColumn::LListItemColumn(LListItem *item, int col)
 {
 	_Column = col;
 	_Item = item;
 	_Value = 0;
 	_Item->d->Cols.Insert(this);
 }
 
 LList *LListItemColumn::GetList()
 {
 	return _Item ? _Item->Parent : 0;
 }
 
 LItemContainer *LListItemColumn::GetContainer()
 {
 	return GetList();
 }
 
 LListT *LListItemColumn::GetAllItems()
 {
 	return GetList() ? &GetList()->Items : 0;
 }
 
 void LListItemColumn::Value(int64 i)
 {
 	if (i != _Value)
 	{
 		_Value = i;
 		_Item->OnColumnNotify(_Column, _Value);
 	}
 }
 
 LListItemColumn *LListItemColumn::GetItemCol(LListItem *i, int Col)
 {
 	if (i)
 	{
 		for (auto c: i->d->Cols)
 		{
 			if (c->_Column == Col)
 			{
 				return c;
 			}
 		}
 	}
 
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // List item
-LListItem::LListItem()
+LListItem::LListItem(const char *initStr)
 {
 	d = new LListItemPrivate;
 	Pos.ZOff(-1, -1);
-	Parent = 0;
+	if (initStr)
+		SetText(initStr);
 }
 
 LListItem::~LListItem()
 {
 	if (Parent)
-	{
 		Parent->Remove(this);
-	}
-
 	DeleteObj(d);
 }
 
 void LListItem::SetImage(int i)
 {
 	d->ListItem_Image = i;
 }
 
 int LListItem::GetImage(int Flags)
 {
 	return d->ListItem_Image;
 }
 
 LItemContainer *LListItem::GetContainer()
 {
 	return Parent;
 }
 
 List<LListItemColumn> *LListItem::GetItemCols()
 {
 	return &d->Cols;
 }
 
 /*
 Calling this to store your data is optional. Just override the
 "GetText" function to return your own data to avoid duplication
 in memory.
 */
 bool LListItem::SetText(const char *s, int i)
 {
 	if (i < 0)
 		return false;
 	
 	// Delete any existing column
 	DeleteArray((char*&)d->Str[i]);
 	DeleteObj(d->Display[i]);
 
 	// Add new string in
 	d->Str[i] = NewStr(s);
 
 	if (Parent)
 		Parent->SendNotify(LNotifyItemChange);
 
 	return true;
 }
 
 // User can override this if they want to use their own data
 const char *LListItem::GetText(int i)
 {
 	return d->Str[i];
 }
 
 bool LListItem::Select()
 {
 	return d->Selected;
 }
 
 LRect *LListItem::GetPos(int Col)
 {
 	static LRect r;
 
 	r = Pos;
 
 	if (Parent->GetMode() == LListDetails)
 	{
 		if (Col >= 0)
 		{
 			LItemColumn *Column = 0;
 
 			int Cx = Parent->GetImageList() ? 16 : 0;
 			for (int c=0; c<Col; c++)
 			{
 				Column = Parent->ColumnAt(c);
 				if (Column)
 				{
 					Cx += Column->Width();
 				}
 			}
 			Column = Parent->ColumnAt(Col);
 
 			if (Column)
 			{
 				r.x1 = Cx;
 				r.x2 = Cx + Column->Width() - 1;
 			}
 		}
 	}
 	else
 	{
 		r.Offset(16, 0);
 	}
 
 	return &r;
 }
 
 void LListItem::Select(bool b)
 {
 	if (d->Selected != b)
 	{
 		d->Selected = b;
 		Update();
 		
 		if (Parent &&
 			d->Selected &&
 			!Parent->d->NoSelectEvent)
 		{
 			LArray<LListItem*> Items;
 			Items.Add(this);
 			Parent->OnItemSelect(Items);
 		}
 	}
 }
 
 void LListItem::ScrollTo()
 {
 	if (Parent)
 	{
 		if (Parent->GetMode() == LListDetails && Parent->VScroll)
 		{
 			ssize_t n = Parent->Items.IndexOf(this);
 			if (n < Parent->FirstVisible)
 			{
 				Parent->VScroll->Value(n);
 				Parent->Invalidate(&Parent->ItemsPos);
 			}
 			else if (n >= Parent->LastVisible)
 			{
 				Parent->VScroll->Value(n - (Parent->LastVisible - Parent->FirstVisible) + 1);
 				Parent->Invalidate(&Parent->ItemsPos);
 			}
 		}
 		else if (Parent->GetMode() == LListColumns && Parent->HScroll)
 		{
 			ssize_t n = Parent->Items.IndexOf(this);
 			if (n < Parent->FirstVisible)
 			{
 				Parent->HScroll->Value(d->LayoutColumn);
 				Parent->Invalidate(&Parent->ItemsPos);
 			}
 			else if (n >= Parent->LastVisible)
 			{
 				ssize_t Range = Parent->HScroll->Page();
 				
 				Parent->HScroll->Value(d->LayoutColumn - Range);
 				Parent->Invalidate(&Parent->ItemsPos);
 			}
 		}
 	}
 }
 
 void LListItem::Update()
 {
 	if (Parent)
 	{
 		if (Parent->Lock(_FL))
 		{
 			d->EmptyDisplay();
 
 			LPoint Info;
 			OnMeasure(&Info);
 
 			LRect r = Pos;
 			if (r.Valid())
 			{
 				if (Info.y != r.Y())
 				{
 					Pos.y2 = Pos.y1 + Info.y - 1;
 					Parent->PourAll();
 
 					r.y1 = MIN(r.y1, Pos.y1);
 					r.y2 = Parent->ItemsPos.y2;
 				}
 
 				Parent->Invalidate(&r);
 			}
 
 			Parent->Unlock();
 		}
 	}
 	else
 	{
 		d->EmptyDisplay();
 	}
 }
 
 void LListItem::OnMeasure(LPoint *Info)
 {
 	if (Info)
 	{
 		if (Parent &&
 			Parent->GetMode() == LListDetails)
 		{
 			Info->x = 1024;
 		}
 		else
 		{
 			LDisplayString *s = GetDs(0);
 			Info->x = 22 + (s ? s->X() : 0);
 		}
 		
 		LFont *f = Parent ? Parent->GetFont() : LSysFont;
 		Info->y = MAX(16, f->GetHeight() + 2); // the default height
 	}
 }
 
 bool LListItem::GridLines()
 {
 	return (Parent) ? Parent->GridLines : false;
 }
 
 void LListItem::OnMouseClick(LMouse &m)
 {
 	int Col = Parent ? Parent->ColumnAtX(m.x) : -1;
 	for (auto h: d->Cols)
 	{
 		if (Col == h->GetColumn())
 		{
 			h->OnMouseClick(m);
 		}
 	}
 }
 
 LDisplayString *LListItem::GetDs(int Col, int FitTo)
 {
 	if (!d->Display[Col])
 	{
 		LFont *f = GetFont();
 		if (!f && Parent) f = Parent->GetFont();
 		if (!f) f = LSysFont;
 
 		const char *Text = d->Str[Col] ? d->Str[Col] : GetText(Col);
 		LAssert((NativeInt)Text != 0xcdcdcdcd &&
 				  (NativeInt)Text != 0xfdfdfdfd);
 		d->Display[Col] = new LDisplayString(f, Text?Text:(char*)"");
 		if (d->Display[Col] && FitTo > 0)
 		{
 			d->Display[Col]->TruncateWithDots(FitTo);
 		}
 	}
 	return d->Display[Col];
 }
 
 void LListItem::ClearDs(int Col)
 {
 	if (Col >= 0)
 	{
 		DeleteObj(d->Display[Col]);
 	}
 	else
 	{
 		d->Display.DeleteObjects();
 	}
 }
 
 void LListItem::OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c)
 {
 	LSurface *&pDC = Ctx.pDC;
 	if (pDC && c)
 	{
 		LRect ng = Ctx; // non-grid area
 
 		if (c->InDrag())
 		{
 			pDC->Colour(DragColumnColour);
 			pDC->Rectangle(&ng);
 		}
 		else
 		{
 			LColour Background = Ctx.Back;
 
 			if (Parent->GetMode() == LListDetails &&
 				c->Mark() &&
 				!d->Selected)
 			{
 				Background = GdcMixColour(LColour(0, 24), Background, (double)1/32);
 			}
 
 			if (GridLines())
 			{
 				ng.x2--;
 				ng.y2--;
 			}
 
 			if (c->Type() == GIC_ASK_TEXT)
 			{
 				LDisplayString *Ds = GetDs(i, Ctx.X());
 				if (Ds)
 				{
 					Ds->GetFont()->TabSize(0);
 					Ds->GetFont()->Transparent(false);
 					Ds->GetFont()->Colour(Ctx.Fore, Background);
 					
 					switch (Ctx.Align.Type)
 					{
 						case LCss::AlignCenter:
 							Ds->Draw(pDC, ng.x1+((ng.X()-Ds->X())/2), ng.y1+1, &ng);
 							break;
 						case LCss::AlignRight:
 							Ds->Draw(pDC, ng.x2-Ds->X()-1, ng.y1+1, &ng);
 							break;
 						default: // Left or inherit
 							Ds->Draw(pDC, ng.x1+1, ng.y1+1, &ng);
 							break;
 					}
 				}
 				else
 				{
 					pDC->Colour(Background);
 					pDC->Rectangle(&ng);
 				}
 			}
 			else
 			{
 				pDC->Colour(Background);
 				pDC->Rectangle(&ng);
 
 				if (c->Type() == GIC_ASK_IMAGE &&
 					Parent->GetImageList())
 				{
 					int Img = GetImage();
 					if (Img >= 0)
 					{
 					    int CenterY = Ctx.y1 + ((Ctx.Y() - Parent->GetImageList()->TileY()) >> 1);
 					    LAssert(CenterY >= 0);
 					    
 						Parent->GetImageList()->Draw(pDC, Ctx.x1+1, CenterY, Img, Background);
 					}
 				}
 			}
 
 			if (GridLines())
 			{
 				pDC->Colour(L_LOW);
 				pDC->Line(Ctx.x1, Ctx.y2, Ctx.x2, Ctx.y2);
 				pDC->Line(Ctx.x2, Ctx.y1, Ctx.x2, Ctx.y2);
 			}
 		}
 	}
 }
 
 void LListItem::OnPaint(LItem::ItemPaintCtx &Ctx)
 {
 	if (!Parent || !d->Visible)
 	    return;
 
 	int x = Ctx.x1;
 	LAutoPtr<ItemPaintCtx> Prev;
 	if (GetCss())
 	{
 		Prev.Reset(new ItemPaintCtx(Ctx));
 		LCss::ColorDef Fill = GetCss()->Color();
 		if (Fill.Type == LCss::ColorRgb)
 			Ctx.Fore.Set(Fill.Rgb32, 32);
 		
 		if (!Select())
 		{
 			Fill = GetCss()->BackgroundColor();
 			if (Fill.Type == LCss::ColorRgb)
 				Ctx.Back.Set(Fill.Rgb32, 32);
 		}
 	}
 
 	// Icon?
 	if (Parent->IconCol)
 	{
 		LItem::ItemPaintCtx IcoCtx = Ctx;
 		IcoCtx.Set(x, Ctx.y1, x + Parent->IconCol->Width()-1, Ctx.y2);
 
 		// draw icon
 		OnPaintColumn(IcoCtx, -1, Parent->IconCol);
 		x = IcoCtx.x2 + 1;
 	}
 	
 	// draw columns
 	auto It = d->Cols.begin();
 	LListItemColumn *h = *It;
 	LItem::ItemPaintCtx ColCtx = Ctx;
 	
 	for (int i=0; i<Parent->Columns.Length(); i++)
 	{
 		LItemColumn *c = Parent->Columns[i];
 		if (Parent->GetMode() == LListColumns)
 			ColCtx.Set(x, Ctx.y1, Ctx.x2, Ctx.y2);
 		else
 			ColCtx.Set(x, Ctx.y1, x + c->Width()-1, Ctx.y2);
 		ColCtx.Align = c->TextAlign();
 		
 		OnPaintColumn(ColCtx, i, c);
 		if (h && i == h->GetColumn())
 		{
 			h->OnPaintColumn(ColCtx, i, c);
 			h = *(++It);
 		}
 		x = ColCtx.x2 + 1;
 		
 		if (Parent->GetMode() == LListColumns)
 			break;
 	}
 	
 	// after columns
 	if (x <= Ctx.x2)
 	{
 		Ctx.pDC->Colour(Ctx.Back);
 		Ctx.pDC->Rectangle(x, Ctx.y1, Ctx.x2, Ctx.y2);
 	}
 	
 	if (Prev)
 		Ctx = *Prev;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // List control
 LList::LList(int id, int x, int y, int cx, int cy, const char *name)
 	: ResObject(Res_ListView)
 {
 	d = new LListPrivate;
 	SetId(id);
 	Name(name);
 	
 	ItemsPos.ZOff(-1, -1);
 	Buf = 0;
 	GridLines = false;
 	FirstVisible = -1;
 	LastVisible = -1;
 	EditLabels = false;
 	MultiSelect(true);
 	CompletelyVisible = 0;
 	Keyboard = -1;
 	Sunken(true);
 	Name("LList");
 
 	#if WINNATIVE
 	SetStyle(GetStyle() | WS_TABSTOP);
 	SetDlgCode(DLGC_WANTARROWS);
 	Cursor = 0;
 	#endif
 	SetTabStop(true);
 
 	LRect r(x, y, x+cx, y+cy);
 	SetPos(r);
 	LResources::StyleElement(this);
 }
 
 LList::~LList()
 {
 	DeleteObj(Buf);
 	Empty();
 	EmptyColumns();
 	DeleteObj(d);
 }
 
 LListMode LList::GetMode()
 {
 	return d->Mode;
 }
 
 void LList::SetMode(LListMode m)
 {
 	if (d->Mode ^ m)
 	{
 		d->Mode = m;
 		
 		if (IsAttached())
 		{
 			PourAll();
 			Invalidate();
 		}
 	}
 }
 
 void LList::OnItemClick(LListItem *Item, LMouse &m)
 {
 	if (Item)
 		Item->OnMouseClick(m);
 }
 
 void LList::OnItemBeginDrag(LListItem *Item, LMouse &m)
 {
 	if (Item)
 		Item->OnBeginDrag(m);
 }
 
 void LList::OnItemSelect(LArray<LListItem*> &It)
 {
 	if (It.Length())
 	{
 		Keyboard = (int)Items.IndexOf(It[0]);
 		LAssert(Keyboard >= 0);
 		
 		LHashTbl<PtrKey<LListItem*>, bool> Sel;
 		for (int n=0; n<It.Length(); n++)
 		{
 			It[n]->OnSelect();
 			if (!MultiSelect())
 				Sel.Add(It[n], true);
 		}
 
 		if (!MultiSelect())
 		{
 			// deselect all other items
 			ForAllItems(i)
 			{
 				if (!Sel.Find(i))
 				{
 					if (i->d->Selected)
 					{
 					    /*
 						i->d->Selected = false;
 						i->Update();
 						*/
 						i->Select(false);
 					}
 				}
 			}
 		}
 	}
 
 	// Notify selection change
 	SendNotify(LNotifyItemSelect);
 }
 
 bool LItemContainer::DeleteColumn(LItemColumn *Col)
 {
 	bool Status = false;
 
 	if (Col &&
 		Lock(_FL))
 	{
 		if (Columns.HasItem(Col))
 		{
 			Columns.Delete(Col);
 			DeleteObj(Col);
 			UpdateAllItems();
 
 			SendNotify(LNotifyItemColumnsChanged);
 			Status = true;
 		}
 
 		Unlock();
 	}
 
 	return Status;
 }
 
 LMessage::Result LList::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		#ifdef WIN32
 		case WM_VSCROLL:
 		{
 			if (VScroll)
 				return VScroll->OnEvent(Msg);
 			break;
 		}
 		#endif
 	}
 
 	return LItemContainer::OnEvent(Msg);
 }
 
 int LList::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if
 	(
 		(Ctrl->GetId() == IDC_VSCROLL && VScroll)
 		||
 		(Ctrl->GetId() == IDC_HSCROLL && HScroll)
 	)
 	{
 		if (n.Type == LNotifyScrollBarCreate)
 			UpdateScrollBars();
 
 		Invalidate(&ItemsPos);
 	}
 
 	return LLayout::OnNotify(Ctrl, n);
 }
 
 LRect &LList::GetClientRect()
 {
 	static LRect r;
 
 	r = GetPos();
 	r.Offset(-r.x1, -r.y1);
 
 	return r;
 }
 
 LListItem *LList::HitItem(int x, int y, int *Index)
 {
 	int n=0;
 	ForAllItems(i)
 	{
 		if
 		(
 			(
 				// Is list mode we consider the item to have infinite width.
 				// This helps with multi-selection when the cursor falls outside
 				// the window's bounds but is still receiving mouse move messages
 				// because of mouse capture.
 				d->Mode == LListDetails
 				&&
 				y >= i->Pos.y1
 				&&
 				y <= i->Pos.y2
 			)
 			||
 			(
 				i->Pos.Overlap(x, y)
 			)
 		)
 		{
 			if (Index) *Index = n;
 			return i;
 		}
 		n++;
 	}
 
 	return NULL;
 }
 
 void LList::ClearDs(int Col)
 {
 	ForAllItems(i)
 	{
 		i->ClearDs(Col);
 	}
 }
 
 void LList::KeyScroll(int iTo, int iFrom, bool SelectItems)
 {
 	int Start = -1, End = -1, i = 0;
 	{
 		ForAllItems(n)
 		{
 			if (n->Select())
 			{
 				if (Start < 0)
 				{
 					Start = i;
 				}
 			}
 			else if (Start >= 0 &&
 					End < 0)
 			{
 				End = i - 1;
 			}
 
 			i++;
 		}
 
 		if (End < 0) End = i - 1;
 	}
 
 	if (Items.Length() == 0)
 		return;
 
 	iTo = limit(iTo, 0, (int)Items.Length()-1);
 	iFrom = limit(iFrom, 0, (int)Items.Length()-1);
 	LListItem *To = Items.ItemAt(iTo);
 	LListItem *From = Items.ItemAt(iFrom);
 	// int Inc = (iTo < iFrom) ? -1 : 1;
 
 	if (To && From && iTo != iFrom)
 	{
 		// LListItem *Item = 0;
 		if (SelectItems)
 		{
 			int OtherEnd = Keyboard == End ? Start : End;
 			int Min = MIN(OtherEnd, iTo);
 			int Max = MAX(OtherEnd, iTo);
 			i = 0;
 
 			d->NoSelectEvent = true;
 			LArray<LListItem*> Sel;
 			ForAllItems(n)
 			{
 				bool s = i>=Min && i<=Max;
 				n->Select(s);
 				if (s) Sel.Add(n);
 				i++;
 			}
 			d->NoSelectEvent = false;
 
 			OnItemSelect(Sel);
 		}
 		else
 		{
 			Select(To);
 		}
 
 		To->ScrollTo();
 
 		Keyboard = iTo;
 	}
 }
 
 bool LList::OnMouseWheel(double Lines)
 {
 	if (VScroll)
 	{
 		int64 Old = VScroll->Value();
 		VScroll->Value(Old + (int)Lines);
 		if (Old != VScroll->Value())
 		{
 			Invalidate(&ItemsPos);
 		}
 	}
 	
 	if (HScroll)
 	{
 		int64 Old = HScroll->Value();
 		HScroll->Value(Old + (int)(Lines / 3));
 		if (Old != HScroll->Value())
 		{
 			Invalidate(&ItemsPos);
 		}
 	}
 	
 	return true;
 }
 
 bool LList::OnKey(LKey &k)
 {
 	bool Status = false;
 	
 	LListItem *Item = GetSelected();
 	if (Item)
 	{
 		Status = Item->OnKey(k);
 	}
 
 	if (k.vkey != LK_UP && k.vkey != LK_DOWN && k.CtrlCmd())
 	{
 		switch (k.c16)
 		{
 			case 'A':
 			case 'a':
 			{
 				if (k.Down())
 					SelectAll();
 				Status = true;
 				break;
 			}
 		}
 	}
 	else
 	{
 		switch (k.vkey)
 		{
 			case LK_RETURN:
 			{
 				#if WINNATIVE
 				if (!k.IsChar)
 				#endif
 				{
 					if (k.Down())
 						SendNotify(LNotification(k));
 				}
 				break;
 			}
 			case LK_BACKSPACE:
 			case LK_DELETE:
 			case LK_ESCAPE:
 			{
 				if (k.Down())
 					SendNotify(LNotification(k));
 				break;
 			}
 			case LK_UP:
 			{
 				// int i = Value();
 				#ifdef MAC
 				if (k.Ctrl())
 					goto LList_PageUp;
 				else if (k.System())
 					goto LList_Home;
 				#endif
 				
 				if (k.Down())
 					KeyScroll(Keyboard-1, Keyboard, k.Shift());
 				Status = true;
 				break;
 			}
 			case LK_DOWN:
 			{
 				#ifdef MAC
 				if (k.Ctrl())
 					goto LList_PageDown;
 				else if (k.System())
 					goto LList_End;
 				#endif
 
 				if (k.Down())
 					KeyScroll(Keyboard+1, Keyboard, k.Shift());
 				Status = true;
 				break;
 			}
 			case LK_LEFT:
 			{
 				if (GetMode() == LListColumns)
 				{
 					if (k.Down())
 					{
 						LListItem *Hit = GetSelected();
 						if (Hit)
 						{
 							LListItem *To = 0;
 							int ToDist = 0x7fffffff;
 							
 							for (auto It = Items.begin(FirstVisible); It != Items.end(); ++It)
 							{
 								LListItem *i = *It;
 								if (!i->Pos.Valid())
 									break;
 
 								if (i->Pos.x2 < Hit->Pos.x1)
 								{
 									int Dx = i->Pos.x1 - Hit->Pos.x1;
 									int Dy = i->Pos.y1 - Hit->Pos.y1;
 									int IDist = Dx * Dx + Dy * Dy;
 									if (!To || IDist < ToDist)
 									{
 										To = i;
 										ToDist = IDist;
 									}
 								}
 							}
 							
 							if (!To && HScroll)
 							{
 								if (Hit->d->LayoutColumn == HScroll->Value() + 1)
 								{
 									// Seek back to the start of the column before the
 									// first visible column
 									for (auto it = Items.begin(FirstVisible); it.In(); it--)
 									{
 										LListItem *i = *it;
 										if (i->d->LayoutColumn < HScroll->Value())
 										{
 											it++;
 											break;
 										}
 									}
 									
 									// Now find the entry at the right height
 								}
 							}
 
 							if (To)
 							{
 								Select(0);
 								To->Select(true);
 								To->ScrollTo();
 							}
 						}
 					}
 					Status = true;
 				}
 				break;
 			}
 			case LK_RIGHT:
 			{
 				if (GetMode() == LListColumns)
 				{
 					if (k.Down())
 					{
 						LListItem *Hit = GetSelected();
 						if (Hit)
 						{
 							LListItem *To = 0;
 							int ToDist = 0x7fffffff;
 							
 							for (auto It = Items.begin(FirstVisible); It != Items.end(); ++It)
 							{
 								LListItem *i = *It;
 								if (!i->Pos.Valid())
 									break;
 								
 								if (i->Pos.x1 > Hit->Pos.x2)
 								{
 									int Dx = i->Pos.x1 - Hit->Pos.x1;
 									int Dy = i->Pos.y1 - Hit->Pos.y1;
 									int IDist = Dx * Dx + Dy * Dy;
 									if (!To || IDist < ToDist)
 									{
 										To = i;
 										ToDist = IDist;
 									}
 								}
 							}
 							
 							if (To)
 							{
 								Select(0);
 								To->Select(true);
 								To->ScrollTo();
 							}
 						}
 					}
 					Status = true;
 				}
 				break;
 			}
 			case LK_PAGEUP:
 			{
 				#ifdef MAC
 				LList_PageUp:
 				#endif
 				if (k.Down())
 				{
 					int Vis = VisibleItems();
 					Vis = MAX(Vis, 0);
 					KeyScroll(Keyboard-Vis, Keyboard, k.Shift());
 				}
 				Status = true;
 				break;
 			}
 			case LK_PAGEDOWN:
 			{
 				#ifdef MAC
 				LList_PageDown:
 				#endif
 				if (k.Down())
 				{
 					int Vis = VisibleItems();
 					Vis = MAX(Vis, 0);
 					KeyScroll(Keyboard+Vis, Keyboard, k.Shift());
 				}
 				Status = true;
 				break;
 			}
 			case LK_END:
 			{
 				#ifdef MAC
 				LList_End:
 				#endif
 				if (k.Down())
 					KeyScroll((int)Items.Length()-1, Keyboard, k.Shift());
 				Status = true;
 				break;
 			}
 			case LK_HOME:
 			{
 				#ifdef MAC
 				LList_Home:
 				#endif
 				if (k.Down())
 					KeyScroll(0, Keyboard, k.Shift());
 				Status = true;
 				break;
 			}
 			#ifdef VK_APPS
 			case VK_APPS:
 			{
 				if (k.Down())
 				{
 					LListItem *s = GetSelected();
 					if (s)
 					{
 						LRect *r = &s->Pos;
 						if (r)
 						{
 							LMouse m;
 							LListItem *FirstVisible = ItemAt((VScroll) ? (int)VScroll->Value() : 0);
 
 							m.x = 32 + ItemsPos.x1;
 							m.y = r->y1 + (r->Y() >> 1) - (FirstVisible ? FirstVisible->Pos.y1 : 0) + ItemsPos.y1;
 							
 							m.Target = this;
 							m.ViewCoords = true;
 							m.Down(true);
 							m.Right(true);
 							
 							OnMouseClick(m);
 						}
 						Status = true;
 					}
 				}
 				break;
 			}
 			#endif
 			default:
 			{
 				if
 				(
 					!Status
 					&&
 					k.IsChar
 					&&
 					(
 						IsDigit(k.c16)
 						||
 						IsAlpha(k.c16)
 						||
 						strchr("_.-", k.c16)
 					)
 				)
 				{
 					if (k.Down())
 					{
 						uint64 Now = LCurrentTime();
 						LStringPipe p;
 						if (d->KeyBuf && Now < d->KeyLast + 1500)
 						{
 							p.Push(d->KeyBuf);
 						}
 						DeleteArray(d->KeyBuf);
 						d->KeyLast = Now;
 						p.Push(&k.c16, 1);
 						d->KeyBuf = p.NewStrW();
 						if (d->KeyBuf)
 						{
 							char *c8 = WideToUtf8(d->KeyBuf);
 							if (c8)
 							{
 								int Col = 0;
 								bool Ascend = true;
 								for (int i=0; i<Columns.Length(); i++)
 								{
 									LItemColumn *c = Columns[i];
 									if (c->Mark())
 									{
 										Col = i;
 										if (c->Mark() == GLI_MARK_UP_ARROW)
 										{
 											Ascend = false;
 										}
 									}
 								}
 								
 								bool Selected = false;
 								auto It = Ascend ? Items.begin() : Items.rbegin();
 								for (; It.In(); Ascend ? ++It : --It)
 								{
 									LListItem *i = *It;
 									if (!Selected)
 									{
 										const char *t = i->GetText(Col);
 										if (t && stricmp(t, c8) >= 0)
 										{
 											i->Select(true);
 											i->ScrollTo();
 											Selected = true;
 										}
 										else
 										{
 											i->Select(false);
 										}
 									}
 									else
 									{
 										i->Select(false);
 									}
 								}
 								
 								DeleteArray(c8);
 							}
 						}
 					}
 					Status = true;
 				}
 				break;
 			}
 		}
 	}
 
 	return Status;
 }
 
 LCursor LList::GetCursor(int x, int y)
 {
 	LItemColumn *Resize, *Over;
 	HitColumn(x, y, Resize, Over);
 	if (Resize)
 		return LCUR_SizeHor;
 	
 	return LCUR_Normal;
 }
 
 void LList::OnMouseClick(LMouse &m)
 {
 	// m.Trace("LList::OnMouseClick");
 
 	if (Lock(_FL))
 	{
 		if (m.Down())
 		{
 			Focus(true);
 
 			DragMode = DRAG_NONE;
 			d->DragStart.x = m.x;
 			d->DragStart.y = m.y;
 
 			if (ColumnHeaders &&
 				ColumnHeader.Overlap(m.x, m.y))
 			{
 				// Clicked on a column heading
 				LItemColumn *Resize, *Over;
 				int Index = HitColumn(m.x, m.y, Resize, Over);
 
 				if (Resize)
 				{
 					if (m.Double())
 					{
 						if (m.CtrlCmd())
 						{
 							ResizeColumnsToContent();
 						}
 						else
 						{
 							ColSizes Sizes;
 							GetColumnSizes(Sizes);
 							
 							int AvailablePx = GetClient().X() - 5;
 							if (VScroll)
 								AvailablePx -= VScroll->X();
 
 							int ExpandPx = AvailablePx - (Sizes.FixedPx + Sizes.ResizePx);
 							if (ExpandPx > 0)
 							{
 								int MaxPx = Resize->GetContentSize() + DEFAULT_COLUMN_SPACING;
 								int AddPx = MIN(ExpandPx, MaxPx - Resize->Width());
 								if (AddPx > 0)
 								{
 									Resize->Width(Resize->Width() + AddPx);
 									ClearDs(Index);
 									Invalidate();
 								}
 							}
 						}
 					}
 					else
 					{
 						DragMode = RESIZE_COLUMN;
 						d->DragData = (int)Columns.IndexOf(Resize);
 						Capture(true);
 					}
 				}
 				else
 				{
 					DragMode = CLICK_COLUMN;
 					d->DragData = (int)Columns.IndexOf(Over);
 					if (Over)
 					{
 						Over->Value(true);
 						LRect r = Over->GetPos();
 						Invalidate(&r);
 						Capture(true);
 					}
 				}
 			}
 			else if (ItemsPos.Overlap(m.x, m.y))
 			{
 				// Clicked in the items area
 				bool HandlerHung = false;
 				int ItemIndex = -1;
 				LListItem *Item = HitItem(m.x, m.y, &ItemIndex);
 				// LViewI *Notify = Item ? (GetNotify()) ? GetNotify() : GetParent() : 0;
 				d->DragData = ItemIndex;
 
 				if (Item && Item->Select())
 				{
 					// Click on selected item
 					if (m.CtrlCmd())
 					{
 						Item->Select(false);
 						OnItemClick(Item, m);
 					}
 					else
 					{
 						// Could be drag'n'drop operation
 						// Or just a select
 						int64 StartHandler = LCurrentTime();
 
 						// this will get set if 'this' is deleted.
 						bool DeleteFlag = false;
 
 						// Setup the delete flag pointer
 						d->DeleteFlag = &DeleteFlag;
 
 						// Do the event... may delete 'this' object, or hang for a long time
 						OnItemClick(Item, m);
 
 						// If the object has been deleted... exit out of here NOW!
 						if (DeleteFlag)
 						{
 							return;
 						}
 
 						// Shut down the delete flag pointer... it'll point to invalid stack soon.
 						d->DeleteFlag = 0;
 
 						// Check if the handler hung for a long time...
 						uint64 Now = LCurrentTime();
 						HandlerHung = Now - StartHandler > 200;
 						if (!HandlerHung && !m.Double() && !m.IsContextMenu())
 						{
 							// Start d'n'd watcher pulse...
 							SetPulse(100);
 							Capture(true);
 							DragMode = CLICK_ITEM;
 						}
 						
 						if (!IsCapturing())
 						{
 							// If capture failed then we reset the dragmode...
 							DragMode = DRAG_NONE;
 						}
 					}
 				}
 				else
 				{
 					// Selection change
 					if (m.Shift() && MultiSelect())
 					{
 						int n = 0;
 						int a = MIN(ItemIndex, Keyboard);
 						int b = MAX(ItemIndex, Keyboard);
 						LArray<LListItem*> Sel;
 
 						ForAllItems(i)
 						{
 							bool s = n >= a && n <= b;
 							if (i->d->Selected ^ s)
 							{
 								i->d->Selected = s;
 								i->Update();
 							}
 							if (s) Sel.Add(i);
 							n++;
 						}
 
 						OnItemSelect(Sel);
 						Item->Select(true);
 					}
 					else
 					{
 						bool PostSelect = false;
 						bool SelectionChanged = false;
 
 						// Temporaily turn off selection events... 
 						// and just send one at the end.
 						// d->NoSelectEvent = true;
 						
 						ForAllItems(i)
 						{
 							if (Item == i) // clicked item
 							{
 								if (m.CtrlCmd())
 								{
 									// Toggle selected state
 									if (!i->Select())
 									{
 										Keyboard = (int)Items.IndexOf(i);
 									}
 
 									i->Select(!i->Select());
 									SelectionChanged = true;
 								}
 								else
 								{
 									// Select this after we have delselected everything else
 									PostSelect = true;
 								}
 							}
 							else if (!m.CtrlCmd() || !MultiSelect())
 							{
 								if (i->Select())
 								{
 									i->Select(false);
 									SelectionChanged = true;
 								}
 							}
 						}
 
 						if (PostSelect)
 						{
 							SelectionChanged |= Item->Select() == false;
 							Item->Select(true);
 							Keyboard = (int)Items.IndexOf(Item);
 						}
 
 						if (!m.CtrlCmd() && Items.Length() && !m.IsContextMenu())
 						{
 							DragMode = SELECT_ITEMS;
 							SetPulse(100);
 							Capture(true);
 						}
 
 						if (SelectionChanged)
 						{
 							SendNotify(LNotifyItemSelect);
 						}
 
 						// d->NoSelectEvent = false;
 					}
 
 					OnItemClick(Item, m);
 				}
 
 				if (!HandlerHung)
 				{
 					if (m.IsContextMenu())
 						SendNotify(LNotification(m, LNotifyItemContextMenu));
 					else if (Item || m.Double())
 						SendNotify(LNotification(m));
 					else
 						SendNotify(LNotification(m, LNotifyContainerClick));
 				}
 			}
 		}
 		else // Up Click
 		{
 			switch (DragMode)
 			{
 				case CLICK_COLUMN:
 				{
 					if (d->DragData < 0)
 						break;
 					
 					LItemColumn *c = Columns[d->DragData];
 					if (c)
 					{
 						c->Value(false);
 						
 						LRect cpos = c->GetPos();
 						Invalidate(&cpos);
 
 						if (cpos.Overlap(m.x, m.y))
 						{
 							OnColumnClick((int)Columns.IndexOf(c), m);
 						}
 					}
 					else
 					{
 						OnColumnClick(-1, m);
 					}
 					break;
 				}
 				case CLICK_ITEM:
 				{
 					// This code allows the user to change a larger selection
 					// down to a single item, by clicking on that item. This
 					// can't be done on the down click because the user may also
 					// be clicking the selected items to drag them somewhere and
 					// if we de-selected all but the clicked item on the down
 					// click they would never be able to drag and drop more than
 					// one item.
 					//
 					// However we also do not want this to select items after the
 					// contents of the list box have changed since the down click
 					LListItem *Item = Items.ItemAt(d->DragData);
 					if (Item)
 					{
 						bool Change = false;
 						
 						LArray<LListItem*> s;
 						ForAllItems(i)
 						{
 							bool Sel = Item == i;
 							if (Sel ^ i->Select())
 							{
 								Change = true;
 								i->Select(Sel);
 								if (Sel)
 								{
 									s.Add(i);
 								}
 							}
 						}
 						
 						if (Change)
 							OnItemSelect(s);
 					}
 					break;
 				}
 				case DRAG_COLUMN:
 				{
 					// End column drag
 					if (DragCol)
 					{
 						LRect DragPos = DragCol->GetPos();
 						LPoint p(DragPos.x1 + (DragPos.X()/2), 0);
 						PointToView(p);
 
 						int OldIndex = DragCol->GetIndex();
 						int Best = 100000000, NewIndex = OldIndex, i=0, delta;
 						for (i=0; i<Columns.Length(); i++)
 						{
 							LItemColumn *Col = Columns[i];
 							delta = abs(p.x - Col->GetPos().x1);
 							if (delta < Best)
 							{
 								Best = delta;
 								NewIndex = i - (i > OldIndex ? 1 : 0);
 							}
 						}
 						delta = abs(p.x - Columns.Last()->GetPos().x2);
 						if (delta < Best)
 						{
 							NewIndex = i;
 						}
 
 						LItemColumn *Col = DragCol->GetColumn();
 						if (OldIndex != NewIndex &&
 							OnColumnReindex(Col, OldIndex, NewIndex))
 						{
 							Columns.SetFixedLength(false);
 							Columns.Delete(Col, true);
 							Columns.AddAt(OldIndex < NewIndex ? NewIndex-1 : NewIndex, Col);
 							Columns.SetFixedLength(true);
 
 							UpdateAllItems();
 						}
 
 						DragCol->Quit();
 						DragCol = NULL;
 					}
 
 					Invalidate();
 					break;
 				}
 			}
 
 			LListItem *Item = HitItem(m.x, m.y);
 			if (Item)
 			{
 				OnItemClick(Item, m);
 			}
 
 			if (IsCapturing())
 			{
 				Capture(false);
 			}
 
 			DragMode = DRAG_NONE;
 		}
 
 		Unlock();
 	}
 }
 
 void LList::OnPulse()
 {
 	if (!Lock(_FL))
 		return;
 
 	if (IsCapturing())
 	{
 		LMouse m;
 		bool HasMs = GetMouse(m);
 		// m.Trace("LList::OnPulse");
 
 		if (HasMs && (m.y < 0 || m.y >= Y()))
 		{
 			switch (DragMode)
 			{
 				case SELECT_ITEMS:
 				{
 					int OverIndex = 0;
 					LListItem *Over = 0;
 
 					if (m.y < 0)
 					{
 						int Space = -m.y;
 
 						int n = FirstVisible - 1;
 						for (auto It = Items.begin(n); It != Items.end(); --It, n--)
 						{
 							LListItem *i = *It;
 							
 							LPoint Info;
 							i->OnMeasure(&Info);
 							if (Space > Info.y)
 							{
 								Space -= Info.y;
 							}
 							else
 							{
 								OverIndex = n;
 								Over = i;
 								break;
 							}
 						}
 
 						if (!Over)
 						{
 							Over = Items[0];
 							OverIndex = 0;
 						}
 					}
 					else if (m.y >= Y())
 					{
 						int Space = m.y - Y();
 						int n = LastVisible + 1;
 
 						for (auto It = Items.begin(n); It != Items.end(); ++It, n++)
 						{
 							LListItem *i = *It;
 							
 							LPoint Info;
 							i->OnMeasure(&Info);
 							if (Space > Info.y)
 							{
 								Space -= Info.y;
 							}
 							else
 							{
 								OverIndex = n;
 								Over = i;
 								break;
 							}
 						}
 
 						if (!Over)
 						{
 							Over = *Items.rbegin();
 							OverIndex = (int)Items.Length()-1;
 						}
 					}
 
 					int Min = MIN(d->DragData, OverIndex);
 					int Max = MAX(d->DragData, OverIndex);
 					int n = Min;
 
 					for (auto It = Items.begin(Min); It != Items.end() && n <= Max; ++It, n++)
 					{
 						LListItem *i = *It;
 						if (!i->Select())
 							i->Select(true);
 					}
 
 					if (Over)
 					{
 						Over->ScrollTo();
 					}
 					break;
 				}
 			}
 		}
 	}
 	else
 	{
 		DragMode = DRAG_NONE;
 		SetPulse();
 	}
 	
 	Unlock();
 }
 
 void LList::OnMouseMove(LMouse &m)
 {
 	if (!Lock(_FL))
 		return;
 
 	// m.Trace("LList::OnMouseMove");
 	switch (DragMode)
 	{
 		case DRAG_COLUMN:
 		{
 			if (DragCol)
 			{
 				LPoint p;
 				PointToScreen(p);
 
 				LRect r = DragCol->GetPos();
 				r.Offset(-p.x, -p.y); // to view co-ord
 
 				r.Offset(m.x - DragCol->GetOffset() - r.x1, 0);
 				if (r.x1 < 0) r.Offset(-r.x1, 0);
 				if (r.x2 > X()-1) r.Offset((X()-1)-r.x2, 0);
 
 				r.Offset(p.x, p.y); // back to screen co-ord
 				DragCol->SetPos(r, true);
 				r = DragCol->GetPos();
 			}
 			break;
 		}
 		case RESIZE_COLUMN:
 		{
 			LItemColumn *c = Columns[d->DragData];
 			if (c)
 			{
 				// int OldWidth = c->Width();
 				int NewWidth = m.x - c->GetPos().x1;
 
 				c->Width(MAX(NewWidth, 4));
 				ClearDs(d->DragData);
 				Invalidate();
 			}
 			break;
 		}
 		case CLICK_COLUMN:
 		{
 			if (d->DragData < 0 || d->DragData >= Columns.Length())
 				break;
 				
 			LItemColumn *c = Columns[d->DragData];
 			if (c)
 			{
 				if (abs(m.x - d->DragStart.x) > DRAG_THRESHOLD ||
 					abs(m.y - d->DragStart.y) > DRAG_THRESHOLD)
 				{
 					OnColumnDrag(d->DragData, m);
 				}
 				else
 				{
 					bool Over = c->GetPos().Overlap(m.x, m.y);
 					if (m.Down() && Over != c->Value())
 					{
 						c->Value(Over);
 						LRect r = c->GetPos();
 						Invalidate(&r);
 					}
 				}
 			}
 			break;
 		}
 		case SELECT_ITEMS:
 		{
 			int n=0;
 			// bool Selected = m.y < ItemsPos.y1;
 
 			if (IsCapturing())
 			{
 				if (MultiSelect())
 				{
 					int Over = -1;
 					
 					HitItem(m.x, m.y, &Over);
 					if (m.y < ItemsPos.y1 && FirstVisible == 0)
 					{
 						Over = 0;
 					}
 					else
 					{
 						int n = FirstVisible;
 						for (auto it = Items.begin(n); it != Items.end(); it++)
 						{
 							auto k = *it;
 							if (!k->OnScreen())
 								break;
 							if ((m.y >= k->Pos.y1) && (m.y <= k->Pos.y2))
 							{
 								Over = n;
 								break;
 							}
 							n++;
 						}
 					}
 
 					if (Over >= 0)
 					{
 						n = 0;
 
 						int Start = MIN(Over, d->DragData);
 						int End = MAX(Over, d->DragData);
 
 						ForAllItems(i)
 						{
 							i->Select(n >= Start && n <= End);
 							n++;
 						}
 					}
 				}
 				else
 				{
 					ForAllItems(i)
 					{
 						i->Select(i->Pos.Overlap(m.x, m.y));
 					}
 				}
 			}
 			break;
 		}
 		case CLICK_ITEM:
 		{
 			LListItem *Cur = Items.ItemAt(d->DragData);
 			if (Cur)
 			{
 				Cur->OnMouseMove(m);
 				
 				if (IsCapturing() &&
 					(abs(d->DragStart.x-m.x) > DRAG_THRESHOLD ||
 					abs(d->DragStart.y-m.y) > DRAG_THRESHOLD))
 				{
 					Capture(false);
 					OnItemBeginDrag(Cur, m);
 					DragMode = DRAG_NONE;
 				}
 			}
 			break;
 		}
 		default:
 		{
 			List<LListItem> s;
 			if (GetSelection(s))
 			{
 				for (auto c: s)
 				{
 					LMouse ms = m;
 					ms.x -= c->Pos.x1;
 					ms.y -= c->Pos.y1;
 					c->OnMouseMove(ms);
 				}
 			}
 			break;
 		}
 	}
 
 	Unlock();
 }
 
 int64 LList::Value()
 {
 	int n=0;
 	ForAllItems(i)
 	{
 		if (i->Select())
 		{
 			return n;
 		}
 		n++;
 	}
 	return -1;
 }
 
 void LList::Value(int64 Index)
 {
 	int n=0;
 	ForAllItems(i)
 	{
 		if (n == Index)
 		{
 			i->Select(true);
 			Keyboard = n;
 		}
 		else
 		{
 			i->Select(false);
 		}
 		n++;
 	}
 }
 
 void LList::SelectAll()
 {
 	if (Lock(_FL))
 	{
 		ForAllItems(i)
 		{
 			i->d->Selected = true;
 		}
 
 		Unlock();
 
 		Invalidate();
 	}
 }
 
 bool LList::Select(LListItem *Obj)
 {
 	bool Status = false;
 	ForAllItems(i)
 	{
 		i->Select(Obj == i);
 		if (Obj == i) Status = true;
 	}
 	return true;
 }
 
 LListItem *LList::GetSelected()
 {
 	LListItem *n = 0;
 
 	if (Lock(_FL))
 	{
 		ForAllItems(i)
 		{
 			if (i->Select())
 			{
 				n = i;
 				break;
 			}
 		}
 
 		Unlock();
 	}
 
 	return n;
 }
 
 bool LList::GetUpdateRegion(LListItem *i, LRegion &r)
 {
 	r.Empty();
 
 	if (d->Mode == LListDetails)
 	{
 		if (i->Pos.Valid())
 		{
 			LRect u = i->Pos;
 			u.y2 = ItemsPos.y2;
 			r.Union(&u);
 			
 			return true;
 		}
 	}
 	else if (d->Mode == LListColumns)
 	{
 		if (i->Pos.Valid())
 		{
 			LRect u = i->Pos;
 			u.y2 = ItemsPos.y2;
 			r.Union(&u);
 			
 			u.x1 = u.x2 + 1;
 			u.y1 = ItemsPos.y1;
 			r.Union(&u);
 			
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool LList::Insert(LListItem *i, int Index, bool Update)
 {
 	List<LListItem> l;
 	l.Insert(i);
 	return Insert(l, Index, Update);
 }
 
 bool LList::Insert(List<LListItem> &l, int Index, bool Update)
 {
 	bool Status = false;
 
 	if (Lock(_FL))
 	{
 		bool First = Items.Length() == 0;
 		
 		// Insert list of items
 		for (auto i: l)
 		{
 			if (i->Parent != this)
 			{
 				i->Parent = this;
 				i->Select(false);
 				Items.Insert(i, Index);
 				i->OnInsert();
 				if (Index >= 0) Index++;
 				
 				if (First)
 				{
 					First = false;
 					Keyboard = 0;
 					i->Select(true);
 				}
 			}
 		}
 
 		Status = true;
 
 		Unlock();
 
 		if (Update)
 		{
 			// Update screen
 			PourAll();
 			Invalidate();
 
 			// Notify
 			SendNotify(LNotifyItemInsert);
 		}
 	}
 
 	return Status;
 }
 
 bool LList::Delete(ssize_t Index)
 {
 	return Delete(Items.ItemAt(Index));
 }
 
 bool LList::Delete(LListItem *i)
 {
 	bool Status = false;
 	if (Lock(_FL))
 	{
 		if (Remove(i))
 		{
 			// Delete
 			DeleteObj(i);
 			Status = true;
 		}
 		Unlock();
 	}
 
 	return Status;
 }
 
 bool LList::Remove(LListItem *i)
 {
 	bool Status = false;
 
 	if (Lock(_FL))
 	{
 		if (i && i->GetList() == this)
 		{
 			LRegion Up;
 			bool Visible = GetUpdateRegion(i, Up);
 			bool Selected = i->Select();
 			int Index = (int)Items.IndexOf(i);
 			int64 Pos = (VScroll) ? VScroll->Value() : 0;
 
 			// Remove from list
 			Items.Delete(i);
 			i->OnRemove();
 			i->Parent = 0;
 			UpdateScrollBars();
 
 			// Update screen
 			if ((VScroll && VScroll->Value() != Pos) ||
 				Index < FirstVisible)
 			{
 				Invalidate(&ItemsPos);
 			}
 			else if (Visible)
 			{
 				Up.y2 = ItemsPos.y2;
 				Invalidate(&Up);
 			}
 
 			// Notify
 			LViewI *Note = GetNotify() ? GetNotify() : GetParent();
 			if (Note)
 			{
 				if (Selected)
 				{
 					LArray<LListItem*> s;
 					OnItemSelect(s);
 				}
 
 				LNotification n(LNotifyItemDelete);
 				Note->OnNotify(this, n);
 			}
 
 			Status = true;
 		}
 
 		Unlock();
 	}
 
 	return Status;
 }
 
 bool LList::HasItem(LListItem *Obj)
 {
 	return Items.HasItem(Obj);
 }
 
 int LList::IndexOf(LListItem *Obj)
 {
 	return (int)Items.IndexOf(Obj);
 }
 
 LListItem *LList::ItemAt(size_t Index)
 {
 	return Index < Items.Length() ? Items.ItemAt(Index) : NULL;
 }
 
 void LList::ScrollToSelection()
 {
 	if (VScroll)
 	{
 		int n=0;
 		int Vis = VisibleItems();
 		ForAllItems(i)
 		{
 			if (i->Select())
 			{
 				if (n < FirstVisible || n > LastVisible)
 				{
 					int k = n - (Vis/2);
 					VScroll->Value(MAX(k, 0));
 					Invalidate(&ItemsPos);
 					break;
 				}
 			}
 			n++;
 		}
 	}
 }
 
 void LList::Empty()
 {
 	if (Lock(_FL))
 	{
 		ForAllItems(i)
 		{
 			LAssert(i->Parent == this);
 			i->Parent = 0;
 			DeleteObj(i);
 		}
 		Items.Empty();
 		
 		FirstVisible = LastVisible = -1;
 		DragMode = DRAG_NONE;
 
 		if (VScroll)
 		{
 			VScroll->Value(0);
 			VScroll->SetRange(0);
 		}
 
 		Invalidate();
 		DeleteArray(d->KeyBuf);
 
 		Unlock();
 	}
 }
 
 void LList::RemoveAll()
 {
 	if (Lock(_FL))
 	{
 		if (Items.Length())
 		{
 			LArray<LListItem*> s;
 			OnItemSelect(s);
 		}
 
 		for (auto i: Items)
 		{
 			i->OnRemove();
 			i->Parent = 0;
 		}
 		Items.Empty();
 		FirstVisible = LastVisible = -1;
 		DragMode = DRAG_NONE;
 
 		if (VScroll)
 		{
 			// these have to be in this order because
 			// "SetLimits" can cause the VScroll object to
 			// be deleted and becoming NULL
 			VScroll->Value(0);
 			VScroll->SetRange(0);
 		}
 
 		Invalidate();
 		DeleteArray(d->KeyBuf);
 		Unlock();
 	}
 }
 
 void LList::OnPosChange()
 {
 	LLayout::OnPosChange();
 }
 
 void LList::UpdateScrollBars()
 {
 	static bool Processing = false;
 	
 	if (!Processing && InThread())
 	{
 		Processing = true;
 		
 		if (VScroll)
 		{
 			int Vis = VisibleItems();
 			int Max = MaxScroll();
 
 			if (VScroll->Value() > MAX(Max, 0))
 			{
 				VScroll->Value(Max);
 			}
 
 			VScroll->SetPage(Vis);
 			VScroll->SetRange(Items.Length());
 		}
 		
 		if (HScroll)
 		{
 			HScroll->SetPage(d->VisibleColumns);
 			HScroll->SetRange(d->Columns);
 		}
 		
 		Processing = false;
 	}
 }
 
 void LList::PourAll()
 {
 	#if LList_POUR_PROFILE
 	LProfile Prof("PourAll()", 100);
 	#endif
 
 	// Layout all the elements
 	LRect Client = GetClient();
 	LFont *Font = GetFont();
 
 	if (d->Mode == LListDetails)
 	{
 		if (ColumnHeaders)
 		{
 			ColumnHeader = Client;
 			ColumnHeader.y2 = ColumnHeader.y1 + Font->GetHeight() + 4;
 			ItemsPos = Client;
 			ItemsPos.y1 = ColumnHeader.y2 + 1;
 		}
 		else
 		{
 			ItemsPos = Client;
 			ColumnHeader.ZOff(-1, -1);
 		}
 		
 		int n = 0;
 		int y = ItemsPos.y1;
 		int Max = MaxScroll();
 		FirstVisible = (VScroll) ? (int)VScroll->Value() : 0;
 		if (FirstVisible > Max) FirstVisible = Max;
 		LastVisible = 0x7FFFFFFF;
 		CompletelyVisible = 0;
 		bool SomeHidden = false;
 
 		// Process visible flag
 		ForAllItems(i)
 		{
 			auto css = i->GetCss();
 			i->d->Visible = !css || css->Display() != LCss::DispNone;
 		}
 
 		#if LList_POUR_PROFILE
 		Prof.Add("List items");
 		#endif
 		ForAllItems(i)
 		{
 			if (!i->d->Visible)
 			{
 				i->Pos.Set(-1, -1, -2, -2);
 				SomeHidden = true;
 				continue; // Don't increment 'n'
 			}
 
 			if (n < FirstVisible || n > LastVisible)
 			{
 				i->Pos.Set(-1, -1, -2, -2);
 				SomeHidden = true;
 			}
 			else
 			{
 				LPoint Info;
 				
 				i->OnMeasure(&Info);
 				if (i->Pos.Valid() && Info.y != i->Pos.Y())
 				{
 					// This detects changes in item height and invalidates the items below this one.
 					LRect in(0, y+Info.y, X()-1, Y()-1);
 					Invalidate(&in);
 				}
 
 				i->Pos.Set(ItemsPos.x1, y, ItemsPos.x2, y+Info.y-1);
 				y = y+Info.y;
 
 				if (i->Pos.y2 > ItemsPos.y2)
 				{
 					LastVisible = n;
 					SomeHidden = true;
 				}
 				else
 				{
 					CompletelyVisible++;
 				}
 			}
 
 			n++;
 		}
 
 		if (LastVisible >= Items.Length())
 		{
 			LastVisible = (int)Items.Length() - 1;
 		}
 
 		SetScrollBars(false, SomeHidden);
 		UpdateScrollBars();
 	}
 	else if (d->Mode == LListColumns)
 	{
 		ColumnHeader.ZOff(-1, -1);
 		ItemsPos = Client;
 		FirstVisible = 0;
 
 		int CurX = 0;
 		int CurY = 0;
 		int MaxX = 16;
 		LArray<LListItem*> Col;
 		d->Columns = 1;
 		d->VisibleColumns = 0;
 		int64 ScrollX = HScroll ? HScroll->Value() : 0;
 		int64 OffsetY = HScroll ? 0 : LScrollBar::GetScrollSize();
 		FirstVisible = -1;
 		
 		int n = 0;
 		#if LList_POUR_PROFILE
 		Prof.Add("List cols");
 		#endif
 
 		ForAllItems(i)
 		{
 			LPoint Info;
 			i->OnMeasure(&Info);
 
 			if (d->Columns <= ScrollX ||
 				CurX > ItemsPos.X())
 			{
 				i->Pos.ZOff(-1, -1);
 				i->d->LayoutColumn = d->Columns;
 				
 				if (ItemsPos.y1 + CurY + Info.y > ItemsPos.y2 - OffsetY)
 				{
 					CurY = 0;
 					d->Columns++;
 					
 					if (d->Columns > ScrollX &&
 						CurX < ItemsPos.X())
 					{
 						goto FlowItem;
 					}
 				}
 			}
 			else
 			{
 				FlowItem:
 				if (ItemsPos.y1 + CurY + Info.y > ItemsPos.y2 - OffsetY)
 				{
 					// wrap to next column
 					for (int n=0; n<Col.Length(); n++)
 					{
 						Col[n]->Pos.x2 = CurX + MaxX - 1;
 					}
 					Col.Length(0);
 					
 					CurX += MaxX;
 					CurY = 0;
 					d->Columns++;
 					if (CurX < ItemsPos.X())
 					{
 						d->VisibleColumns++;
 					}
 				}
 				
 				if (FirstVisible < 0)
 					FirstVisible = n;
 				LastVisible = n;
 				
 				i->d->LayoutColumn = d->Columns;
 				i->Pos.ZOff(Info.x-1, Info.y-1);
 				i->Pos.Offset(ItemsPos.x1 + CurX, ItemsPos.y1 + CurY);
 				Col[Col.Length()] = i;
 				MaxX = MAX(MaxX, Info.x);
 				
 				CompletelyVisible++;
 			}
 
 			CurY += Info.y;
 			n++;
 		}
 		
 		d->VisibleColumns = MAX(1, d->VisibleColumns);
 
 		// pour remaining items...
 		for (n=0; n<Col.Length(); n++)
 		{
 			Col[n]->Pos.x2 = CurX + MaxX - 1;
 		}
 		Col.Length(0);
 		if (CurX + MaxX < ItemsPos.X())
 		{
 			d->VisibleColumns++;
 		}
 
 		// printf("%u - ScrollX=%i VisCol=%i Cols=%i\n", (uint32)LCurrentTime(), ScrollX, d->VisibleColumns, d->Columns);
 		SetScrollBars(d->VisibleColumns < d->Columns, false);
 		UpdateScrollBars();
 	}
 }
 
 static LColour Tint(LColour back, double amt)
 {
 	bool Darken = back.GetGray() >= 128;
 	LColour Mixer = Darken ? LColour::Black : LColour::White;
 	return back.Mix(Mixer, (float)(1.0f - amt));
 }
 
 void LList::OnPaint(LSurface *pDC)
 {
 	#if LList_ONPAINT_PROFILE
 	int Start = LCurrentTime(), t1, t2, t3, t4, t5;
 	#endif
 	
 	if (!Lock(_FL))
 		return;
 
 	LCssTools Tools(this);
 	LColour DisabledTint(L_MED);
 	LColour Workspace(L_WORKSPACE);
 	LColour NonFocusBack(L_NON_FOCUS_SEL_BACK);	
 	
 	LColour Fore = Enabled() ? Tools.GetFore() : Tools.GetFore().Mix(DisabledTint);
 	LColour Back = Tools.GetBack(&Workspace, 0);
 	double NonFocusBackAmt = (double)NonFocusBack.GetGray() / Workspace.GetGray();
 	if (!Enabled())
 		Back = Back.Mix(DisabledTint);
 	LColour SelFore(Focus() ? L_FOCUS_SEL_FORE : L_NON_FOCUS_SEL_FORE);
 	LColour SelBack(Focus() ? L_FOCUS_SEL_BACK : (Enabled() ? Tint(Back, NonFocusBackAmt) : DisabledTint));
 	PourAll();
 	
 	// printf("ListPaint SelFore=%s SelBack=%s Back=%s %f NonFocusBack=%s\n", SelFore.GetStr(), SelBack.GetStr(), Back.GetStr(), NonFocusBackAmt, NonFocusBack.GetStr());
 	
 	#if LList_ONPAINT_PROFILE
 	t1 = LCurrentTime();
 	#endif
 
 	// Check icon column status then draw
 	if (AskImage() && !IconCol)
 	{
 		IconCol.Reset(new LItemColumn(this, 0, 18));
 		if (IconCol)
 		{
 			IconCol->Resizable(false);
 			IconCol->Type(GIC_ASK_IMAGE);
 		}
 	}
 	else if (!AskImage())
 		IconCol.Reset();
 
 	PaintColumnHeadings(pDC);
 
 	#if LList_ONPAINT_PROFILE
 	t2 = LCurrentTime();
 	#endif
 
 	// Draw items
 	if (!Buf)
 		Buf = new LMemDC;
 	
 	LRect r = ItemsPos;
 	int n = FirstVisible;
 	int LastY = r.y1;
 	LCss::ColorDef Fill;
 	int LastSelected = -1;
 
 	LItem::ItemPaintCtx Ctx;
 	Ctx.pDC = pDC;
 
 	LRegion Rgn(ItemsPos);
 	if (Items.Length())
 	{
 		for (auto It = Items.begin(n); It != Items.end(); ++It, n++)
 		{
 			LListItem *i = *It;
 			if (i->Pos.Valid())
 			{
 				// Setup painting colours in the context
 				if (LastSelected ^ (int)i->Select())
 				{
 					if ((LastSelected = i->Select()))
 					{
 						Ctx.Fore = SelFore;
 						Ctx.Back = SelBack;
 					}
 					else
 					{
 						Ctx.Fore = Fore;
 						Ctx.Back = Back;
 					}
 				}
 
 				// tell the item what colour to use
 				#if DOUBLE_BUFFER_PAINT
 				if (Buf->X() < i->Pos.X() ||
 					Buf->Y() < i->Pos.Y())
 				{
 					Buf->Create(i->Pos.X(), i->Pos.Y(), GdcD->GetBits());
 				}
 
 				Ctx = i->Pos;
 				Ctx.r.Offset(-Ctx.r.x1, -Ctx.r.y1);
 				i->OnPaint(Ctx);
 				pDC->Blt(i->Pos.x1, i->Pos.y1, Buf, &Ctx.r);
 				#else
 				(LRect&)Ctx = i->Pos;
 				i->OnPaint(Ctx);
 				#endif
 				Rgn.Subtract(&i->Pos);
 
 				LastY = i->Pos.y2 + 1;
 			}
 		}
 	}
 		
 	pDC->Colour(Back);
 	for (LRect *w=Rgn.First(); w; w=Rgn.Next())
 	{
 		pDC->Rectangle(w);
 	}
 
 	Unlock();
 
 	#if LList_ONPAINT_PROFILE
 	int64 End = LCurrentTime();
 	printf("LList::OnPaint() pour=%i headers=%i items=%i\n", (int) (t1-Start), (int) (t2-t1), (int) (End-t2));
 	#endif
 }
 
 void LList::OnFocus(bool b)
 {
 	LListItem *s = GetSelected();
 	if (Items.Length())
 	{
 		if (!s)
 		{
 			s = Items[0];
 			if (s)
 				s->Select(true);
 		}
 
 		for (auto It = Items.begin(FirstVisible); It != Items.end(); ++It)
 		{
 			auto i = *It;
 			if (i->Pos.Valid() &&
 				i->d->Selected)
 			{
 				Invalidate(&i->Pos);
 			}
 		}
 	}
 
 	LLayout::OnFocus(b);
 	
 	if (!b && IsCapturing())
 	{
 		Capture(false);
 	}
 }
 
 void LList::UpdateAllItems()
 {
     if (Lock(_FL))
     {
 		bool needsRepour = false;
 
 	    ForAllItems(i)
 	    {
 			auto css = i->GetCss();
 			bool vis = !css || css->Display() != LCss::DispNone;
 			if (i->d->Visible != vis)
 				needsRepour = true;
 		    i->d->EmptyDisplay();
 	    }
 	    Unlock();
 
 		if (needsRepour)
 			PourAll();
 		Invalidate();
 	}	
 }
 
 int LList::GetContentSize(int Index)
 {
 	int Max = 0;
 
 	for (auto It = Items.begin(); It.In(); It++)
 	{
 		LListItem *i = *It;
 		LDisplayString *s = i->d->Display[Index];
 		LDisplayString *Mem = 0;
 		
 		// If no cached string, create it for the list item
 		if (!s || s->IsTruncated())
 		{
 			LFont *f = i->GetFont();
 			if (!f) f = GetFont();
 			if (!f) f = LSysFont;
 
 			const char *Text = i->d->Str[Index] ? i->d->Str[Index] : i->GetText(Index);
 			if (s && s->IsTruncated())
 			{
 				s = Mem = new LDisplayString(f, Text?Text:(char*)"");
 			}
 			else
 			{
 				s = i->d->Display[Index] = new LDisplayString(f, Text?Text:(char*)"");
 			}
 		}
 
 		// Measure it
 		if (s)
 		{
 			Max = MAX(Max, s->X());
 		}
 		
 		DeleteObj(Mem);
 	}
 	
 	// Measure the heading too
 	LItemColumn *Col = Columns[Index];
 	LFont *f = GetFont();
 	LAssert(f != 0);
 	if (f)
 	{
 		LDisplayString h(f, Col->Name());
 		int Hx = h.X() + (Col->Mark() ? 10 : 0);
 		Max = MAX(Max, Hx);
 	}
 
 	return Max;
 }
diff --git a/src/common/Widgets/Tree.cpp b/src/common/Widgets/Tree.cpp
--- a/src/common/Widgets/Tree.cpp
+++ b/src/common/Widgets/Tree.cpp
@@ -1,2261 +1,2240 @@
 #include <math.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Tree.h"
 #include "lgi/common/ScrollBar.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/Palette.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/CssTools.h"
 
 #define TREE_BLOCK          16
 #define DRAG_THRESHOLD		4
 #define DRAG_SCROLL_EDGE	20
 #define DRAG_SCROLL_X		8
 #define DRAG_SCROLL_Y		1
 
 #define TreeUpdateNow		false
 #define ForAll(Items)		for (auto c : Items)
 
 struct LTreeLocker
 {
 	LTree *t = NULL;
 	bool status = false;
 	LTreeLocker(LTree *tree, const char *file, int line) : t(tree)
 	{
 		if (t)
 			status = t->Lock(file, line);
 	}
 	~LTreeLocker()
 	{
 		if (status && t)
 			t->Unlock();
 	}
 };
 
 #define TREELOCK(ptr) LTreeLocker _lock(ptr, _FL);
 
 //////////////////////////////////////////////////////////////////////////////
 // Private class definitions for binary compatibility
 class LTreePrivate
 {
 public:
 	// Private data
-	int				LineFlags[4];
-	bool			LayoutDirty;
+	int				LineFlags[4] = {};
+	bool			LayoutDirty = true;
 	LPoint			Limit;
 	LPoint			LastClick;
 	LPoint			DragStart;
-	int				DragData;
-	LMemDC			*IconCache;
-	bool			InPour;
-	int64			DropSelectTime;
-    int8            IconTextGap;
-    int				LastLayoutPx;
-	LMouse			*CurrentClick;
-	LTreeItem		*ScrollTo;
+	int				DragData = 0;
+	LAutoPtr<LMemDC> IconCache;
+	bool			InPour = false;
+	int64			DropSelectTime = 0;
+    int8            IconTextGap = 0;
+    int				LastLayoutPx = -1;
+	LMouse			*CurrentClick = NULL;
+	LTreeItem		*ScrollTo = NULL;
     
     // Visual style
-	LTree::ThumbStyle Btns;
-	bool			JoiningLines;
+	LTree::ThumbStyle Btns = LTree::TreeTriangle;
+	bool			JoiningLines = false;
 
 	// Pointers into items... be careful to clear when deleting items...
-	LTreeItem		*LastHit;
+	LTreeItem		*LastHit = NULL;
 	List<LTreeItem>	Selection;
-	LTreeItem		*DropTarget;
-
-	LTreePrivate()
-	{
-		CurrentClick = NULL;
-		LastLayoutPx = -1;
-		DropSelectTime = 0;
-		InPour = false;
-		LastHit = 0;
-		DropTarget = 0;
-		IconCache = 0;
-		LayoutDirty = true;
-		IconTextGap = 0;
-		ScrollTo = NULL;
-		
-		Btns = LTree::TreeTriangle;
-		JoiningLines = false;
-	}
-	
-	~LTreePrivate()
-	{
-		DeleteObj(IconCache);
-	}
+	LTreeItem		*DropTarget = NULL;
 };
 
 class LTreeItemPrivate
 {
 	LArray<LDisplayString*> Ds;
 	LArray<uint32_t> ColPx;
 
 public:
 	LTreeItem *Item;
 	LRect Pos;
 	LRect Thumb;
 	LRect Text;
 	LRect Icon;
 	bool Open;
 	bool Selected;
 	bool Visible;
 	bool Last;
 	int Depth;
 	
 	LTreeItemPrivate(LTreeItem *it)
 	{
 		Item = it;
 		Ds = NULL;
 		Pos.ZOff(-1, -1);
 		Open = false;
 		Selected = false;
 		Visible = false;
 		Last = false;
 		Depth = 0;
 		Text.ZOff(-1, -1);
 		Icon.ZOff(-1, -1);
 	}
 
 	~LTreeItemPrivate()
 	{
 		Ds.DeleteObjects();
 	}
 
 	LDisplayString *GetDs(int Col, int FixPx)
 	{
 		if (!Ds[Col])
 		{
 			LFont *f = Item->GetTree() ? Item->GetTree()->GetFont() : LSysFont;
 			auto txt = Item->GetText(Col);
 			if (txt)
 			{			
 				Ds[Col] = new LDisplayString(f, Item->GetText(Col));
 				if (Ds[Col])
 				{
 					ColPx[Col] = Ds[Col]->X();
 					if (FixPx > 0)
 					{
 						Ds[Col]->TruncateWithDots(FixPx);
 					}
 				}
 			}
 		}
 		
 		return Ds[Col];
 	}
 	
 	void ClearDs(int Col = -1)
 	{
 		if (Col >= 0)
 		{
 			delete Ds[Col];
 			Ds[Col] = NULL;
 		}
 		else
 		{
 			Ds.DeleteObjects();
 		}
 	}
 
 	int GetColumnPx(int Col)
 	{
 		int BasePx = 0;
 		
 		GetDs(Col, 0);
 		if (Col == 0)
 		{
 			BasePx = (Depth + 1) * TREE_BLOCK;
 		}
 		
 		return ColPx[Col] + BasePx;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////
 LTreeNode::LTreeNode()
 {
 	Parent = NULL;
 	Tree = NULL;
 }
 
 LTreeNode::~LTreeNode()
 {
 }
 
 void LTreeNode::SetLayoutDirty()
 {
 	Tree->d->LayoutDirty = true;
 }
 
 void LTreeNode::_Visible(bool v)
 {
 	for (LTreeItem *i=GetChild(); i; i=i->GetNext())
 	{
 		LAssert(i != this);
 		i->OnVisible(v);
 		i->_Visible(v);
 	}
 }
 
 void LTreeNode::_ClearDs(int Col)
 {
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *c = *it; c; c = *++it)
 	{
 		c->_ClearDs(Col);
 	}
 }
 
 LItemContainer *LTreeItem::GetContainer()
 {
 	return Tree;
 }
 
 LTreeItem *LTreeNode::Insert(LTreeItem *Obj, ssize_t Idx)
 {
 	LAssert(Obj != this);
 
 	if (Obj && Obj->Tree)
 		Obj->Remove();
 	
 	LTreeItem *NewObj = Obj ? Obj : new LTreeItem;
 	if (NewObj)
 	{
 		NewObj->Parent = Item();
 		NewObj->_SetTreePtr(Tree);
 
 		Items.Delete(NewObj);
 		Items.Insert(NewObj, Idx);
 
 		if (Tree)
 		{
 			Tree->d->LayoutDirty = true;
 			if (Pos() && Pos()->Y() > 0)
 				Tree->_UpdateBelow(Pos()->y1);
 			else
 				Tree->Invalidate();
 		}
 	}
 
 	return NewObj;
 }
 
 void LTreeNode::Detach()
 {
 	if (Parent)
 	{
 		LTreeItem *It = Item();
 		if (It)
 		{
 			LAssert(Parent->Items.HasItem(It));
 			Parent->Items.Delete(It);
 		}
 		Parent = 0;
 	}
 	if (Tree)
 	{
 		Tree->d->LayoutDirty = true;
 		Tree->Invalidate();
 	}
 	if (Item())
 		Item()->_SetTreePtr(0);
 }
 
 void LTreeNode::Remove()
 {
 	int y = 0;
 	if (Parent)
 	{
 		LTreeItem *i = Item();
 		if (i && i->IsRoot())
 		{
 			LRect *p = Pos();
 			LTreeItem *Prev = GetPrev();
 			if (Prev)
 			{
 				y = Prev->d->Pos.y1;
 			}
 			else
 			{
 				y = p->y1;
 			}
 		}
 		else
 		{
 			y = Parent->d->Pos.y1;
 		}
 	}
 
 	LTree *t = Tree;
 
 	if (Item())
 		Item()->_Remove();
 
 	if (t)
 	{
 		t->_UpdateBelow(y);
 	}
 }
 
 bool LTreeNode::IsRoot()
 {
 	return Parent == 0 || (LTreeNode*)Parent == (LTreeNode*)Tree;
 }
 
 size_t LTreeNode::Length()
 {
 	return Items.Length();
 }
 
 bool LTreeNode::HasItem(LTreeItem *obj, bool recurse)
 {
 	if (!obj)
 		return false;
 	if (this == (LTreeNode*)obj)
 		return true;
 
 	for (auto i: Items)
 	{
 		if (i == obj)
 			return true;
 		if (recurse && i->HasItem(obj, recurse))
 			return true;
 	}
 
 	return false;
 }
 
 int LTreeNode::ForEach(std::function<void(LTreeItem*)> Fn)
 {
 	int Count = 0;
 	
 	for (auto t : Items)
 	{
 		Fn(t);
 		Count += t->ForEach(Fn);
 	}
 	
 	return Count + 1;
 }
 
 ssize_t LTreeNode::IndexOf()
 {
 	if (Parent)
 	{
 		return Parent->Items.IndexOf(Item());
 	}
 	else if (Tree)
 	{
 		return Tree->Items.IndexOf(Item());
 	}
 
 	return -1;
 }
 
 LTreeItem *LTreeNode::GetChild()
 {
 	return Items.Length() ? Items[0] : NULL;
 }
 
 LTreeItem *LTreeNode::GetPrev()
 {
 	List<LTreeItem> *l = (Parent) ? &Parent->Items : (Tree) ? &Tree->Items : 0;
 	if (l)
 	{
 		ssize_t Index = l->IndexOf(Item());
 		if (Index >= 0)
 		{
 			return l->ItemAt(Index-1);
 		}
 	}
 
 	return 0;
 }
 
 LTreeItem *LTreeNode::GetNext()
 {
 	List<LTreeItem> *l = (Parent) ? &Parent->Items : (Tree) ? &Tree->Items : 0;
 	if (l)
 	{
 		ssize_t Index = l->IndexOf(Item());
 		if (Index >= 0)
 		{
 			return l->ItemAt(Index+1);
 		}
 	}
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
-LTreeItem::LTreeItem()
+LTreeItem::LTreeItem(const char *initStr)
 {
 	d = new LTreeItemPrivate(this);
+	if (initStr)
+		SetText(initStr);
 }
 
 LTreeItem::~LTreeItem()
 {
 	if (Tree)
 	{
 		if (Tree->d->DropTarget == this)
-			Tree->d->DropTarget = 0;
+			Tree->d->DropTarget = NULL;
 
 		if (Tree->d->LastHit == this)
-			Tree->d->LastHit = 0;
+			Tree->d->LastHit = NULL;
 		
 		if (Tree->IsCapturing())
 			Tree->Capture(false);
 	}
 
 	int y = 0;
-	LTree *t = 0;
+	LTree *t = NULL;
 	if (Parent && (LTreeNode*)Parent != (LTreeNode*)Tree)
 	{
 		t = Tree;
 		y = Parent->d->Pos.y1;
 	}
 	else if ((LTreeNode*)this != (LTreeNode*)Tree)
 	{
 		t = Tree;
 		LTreeItem *p = GetPrev();
 		if (p)
 			y = p->d->Pos.y1;
 		else
 			y = d->Pos.y1;
 	}
 
 	_Remove();
 	while (Items.Length())
 	{
 		auto It = Items.begin();
 		delete *It;
 	}
 	DeleteObj(d);
 
 	if (t)
 		t->_UpdateBelow(y);
 }
 
 int LTreeItem::GetColumnSize(int Col)
 {
 	int Px = d->GetColumnPx(Col);
 	if (Expanded())
 	{
 		ForAll(Items)
 		{
 			int ChildPx = c->GetColumnSize(Col);
 			Px = MAX(ChildPx, Px);
 		}
 	}
 	return Px;
 }
 
 LRect *LTreeItem::Pos()
 {
 	return &d->Pos;
 }
 
 LPoint LTreeItem::_ScrollPos()
 {
 	LPoint p;
 	if (Tree) p = Tree->_ScrollPos();
 	return p;
 }
 
 LRect *LTreeItem::_GetRect(LTreeItemRect Which)
 {
 	switch (Which)
 	{
-		case TreeItemPos: return &d->Pos;
+		case TreeItemPos:   return &d->Pos;
 		case TreeItemThumb: return &d->Thumb;
-		case TreeItemText: return &d->Text;
-		case TreeItemIcon: return &d->Icon;
+		case TreeItemText:  return &d->Text;
+		case TreeItemIcon:  return &d->Icon;
 	}
 	
-	return 0;
+	return NULL;
 }
 
 bool LTreeItem::IsDropTarget()
 {
 	LTree *t = GetTree();
 	if (t && t->d && t->d->DropTarget == this)
 		return true;
 	
 	return false;
 }
 
 LRect *LTreeItem::GetPos(int Col)
 {
 	if (!d->Pos.Valid() && Tree)
 		Tree->_Pour();
 
 	static LRect r;
 
 	r = d->Pos;
 
 	if (Col >= 0)
 	{
 		LItemColumn *Column = 0;
 
 		int Cx = Tree->GetImageList() ? 16 : 0;
 		for (int c=0; c<Col; c++)
 		{
 			Column = Tree->ColumnAt(c);
 			if (Column)
 			{
 				Cx += Column->Width();
 			}
 		}
 		Column = Tree->ColumnAt(Col);
 
 		if (Column)
 		{
 			r.x1 = Cx;
 			r.x2 = Cx + Column->Width() - 1;
 		}
 	}
 
 	return &r;
 }
 
 void LTreeItem::_RePour()
 {
 	if (Tree)
 		Tree->_Pour();
 }
 
 void LTreeItem::ScrollTo()
 {
 	if (!Tree)
 		return;
 
 	if (Tree->VScroll)
 	{
 		LRect c = Tree->GetClient();
 		LRect p = d->Pos;
 		int y = d->Pos.Y() ? d->Pos.Y() : 16;
 		p.Offset(0, (int) (-Tree->VScroll->Value() * y));
 
 		if (p.y1 < c.y1)
 		{
 			int Lines = (c.y1 - p.y1 + y - 1) / y;
 			Tree->VScroll->Value(Tree->VScroll->Value() - Lines);
 		}
 		else if (p.y2 > c.y2)
 		{
 			int Lines = (p.y2 - c.y2 + y - 1) / y;
 			Tree->VScroll->Value(Tree->VScroll->Value() + Lines);
 		}
 	}
 	else
 	{
 		Tree->d->ScrollTo = this;
 		if (Tree->IsAttached())
 			Tree->PostEvent(M_SCROLL_TO);
 	}
 }
 
 void LTreeItem::_SetTreePtr(LTree *t)
 {
 	if (Tree && !t)
 	{
 		// Clearing tree pointer, must remove all references to this item that
 		// the tree might still have.
 		if (d->Selected)
 		{
 			Tree->d->Selection.Delete(this);
 			d->Selected = false;
 		}
 		if (Tree->d->LastHit == this)
 		{
 			Tree->d->LastHit = 0;
 		}
 		if (Tree->d->DropTarget == this)
 		{
 			Tree->d->DropTarget = 0;
 		}
 	}
 	Tree = t;
 
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *i=*it; i; i=*++it)
 	{
 		i->_SetTreePtr(t);
 	}
 }
 
 void LTreeItem::_Remove()
 {
 	if ((LTreeNode*)this != (LTreeNode*)Tree)
 	{
 		if (Parent)
 		{
 			LAssert(Parent->Items.HasItem(this));
 			Parent->Items.Delete(this);
 		}
 		else if (Tree)
 		{
 			LAssert(Tree->Items.HasItem(this));
 			Tree->Items.Delete(this);
 		}
 
 		if (Tree)
 		{
 			LAssert(Tree->d != NULL);
 			Tree->d->LayoutDirty = true;
 			
 			if (Tree->IsCapturing())
 				Tree->Capture(false);
 		}
 	}
 
 	Parent = 0;
 	_SetTreePtr(0);
 }
 
 void LTreeItem::_PourText(LPoint &Size)
 {
 	LFont *f = Tree ? Tree->GetFont() : LSysFont;
 	auto *Txt = GetText();
 	
 	#if defined(_WIN64) && defined(_DEBUG)
 	if ((void*)Txt == (void*)0xfeeefeeefeeefeee ||
 		(void*)Txt == (void*)0xcdcdcdcdcdcdcdcd)
 	{
 		LAssert(!"Yeah nah...");
 	}
 	#endif
 	
 	LDisplayString ds(f, Txt);
 	Size.x = ds.X() + 4;
 	Size.y = 0;
 }
 
 void LTreeItem::_PaintText(LItem::ItemPaintCtx &Ctx)
 {
 	const char *Text = GetText();
 	if (Text)
 	{
 		LDisplayString *Ds = d->GetDs(0, d->Text.X());
 		LFont *f = Tree ? Tree->GetFont() : LSysFont;
 
 		int Tab = f->TabSize();
 		f->TabSize(0);
 		f->Transparent(false);
 		f->Colour(Ctx.Fore, Ctx.TxtBack);
 		
 		if (Ds)
 		{
 			Ds->Draw(Ctx.pDC, d->Text.x1 + 2, d->Text.y1 + 1, &d->Text);
 			if (Ctx.x2 > d->Text.x2)
 			{
 				LRect r = Ctx;
 				r.x1 = d->Text.x2 + 1;
 				Ctx.pDC->Colour(Ctx.Back);
 				Ctx.pDC->Rectangle(&r);
 			}
 		}
 		
 		f->TabSize(Tab);
 	}
 	else
 	{
 		Ctx.pDC->Colour(Ctx.Back);
 		Ctx.pDC->Rectangle(&Ctx);
 	}
 }
 
 void LTreeItem::_Pour(LPoint *Limit, int ColumnPx, int Depth, bool Visible)
 {
 	auto css = GetCss(false);
 	auto display = css ? css->Display() != LCss::DispNone : true;
 
 	d->Visible = display && Visible;
 	d->Depth = Depth;
 
 	if (d->Visible)
 	{
 		LPoint TextSize;
 		_PourText(TextSize);
 		LImageList *ImgLst = Tree->GetImageList();
 		// int IconX = (ImgLst && GetImage() >= 0) ? ImgLst->TileX() + Tree->d->IconTextGap : 0;
 		int IconY = (ImgLst && GetImage() >= 0) ? ImgLst->TileY() : 0;
 		int Height = MAX(TextSize.y, IconY);
 		if (!Height)
 		    Height = 16;
 
 		LDisplayString *Ds = d->GetDs(0, 0);
 
 		d->Pos.ZOff(ColumnPx - 1, (Ds ? MAX(Height, Ds->Y()) : Height) - 1);
 		d->Pos.Offset(0, Limit->y);
 		if (!d->Pos.Valid())
 		{
-			printf("Invalid pos: %s, ColumnPx=%i\n", d->Pos.GetStr(), ColumnPx);
+			LgiTrace("%s:%i - Invalid pos: %s, ColumnPx=%i\n", _FL, d->Pos.GetStr(), ColumnPx);
 		}
 
 		Limit->x = MAX(Limit->x, d->Pos.x2 + 1);
 		Limit->y = MAX(Limit->y, d->Pos.y2 + 1);
 	}
 	else
 	{
 		d->Pos.ZOff(-1, -1);
 	}
 
 	LTreeItem *n;
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *i=*it; i; i=n)
 	{
 		n = *++it;
 		i->d->Last = n == 0;
 		i->_Pour(Limit, ColumnPx, Depth+1, d->Open && d->Visible);
 	}
 }
 
 void LTreeItem::_ClearDs(int Col)
 {
 	d->ClearDs(Col);	
 	LTreeNode::_ClearDs(Col);
 }
 
 const char *LTreeItem::GetText(int i)
 {
 	return Str[i];
 }
 
 bool LTreeItem::SetText(const char *s, int i)
 {
 	TREELOCK(Tree);
 
 	Str[i] = s;
 	if (Tree)
 		Update();
 
 	return true;
 }
 
 int LTreeItem::GetImage(int Flags)
 {
 	return Sys_Image;
 }
 
 void LTreeItem::SetImage(int i)
 {
 	Sys_Image = i;
 }
 
 void LTreeItem::Update()
 {
 	if (Tree)
 	{
 		LRect p = d->Pos;
 		p.x2 = 10000;
 		d->ClearDs();
 		Tree->_Update(&p, TreeUpdateNow);
 	}
 }
 
 bool LTreeItem::Select()
 {
 	return d->Selected;
 }
 
 void LTreeItem::Select(bool b)
 {
 	if (d->Selected != b)
 	{
 		d->Selected = b;
 		if (b)
 		{
 			LTreeItem *p = this;
 			while ((p = p->GetParent()))
 			{
 				p->Expanded(true);
 			}
 		}
 
 		Update();
 
 		if (b && Tree)
 		{
 			Tree->_OnSelect(this);
 			Tree->OnItemSelect(this);
 		}
 	}
 }
 
 bool LTreeItem::Expanded()
 {
 	return d->Open;
 }
 
 void LTreeItem::Expanded(bool b)
 {
 	if (d->Open != b)
 	{
 		d->Open = b;
 
 		if (Items.Length() > 0)
 		{
 			if (Tree)
 			{
 				Tree->d->LayoutDirty = true;
 				Tree->_UpdateBelow(d->Pos.y1);
 			}
 			OnExpand(b);
 		}
 	}
 }
 
 void LTreeItem::OnExpand(bool b)
 {
 	_Visible(b);
 }
 
 LTreeItem *LTreeItem::_HitTest(int x, int y, bool Debug)
 {
 	LTreeItem *Status = 0;
 
 	if (d->Pos.Overlap(x, y) &&
 		x > (d->Depth*TREE_BLOCK))
 	{
 		Status = this;
 	}
 
 	if (d->Open)
 	{
 		List<LTreeItem>::I it = Items.begin();
 		for (LTreeItem *i=*it; i && !Status; i=*++it)
 		{
 			Status = i->_HitTest(x, y, Debug);
 		}
 	}
 
 	return Status;
 }
 
 void LTreeItem::_MouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		if ((Items.Length() > 0 &&
 			d->Thumb.Overlap(m.x, m.y)) ||
 			m.Double())
 		{
 			Expanded(!Expanded());
 		}
 
 		LRect rText = d->Text;
 		if (Tree && Tree->Columns.Length() > 0)
 			rText.x2 = Tree->X();
 
 		if (rText.Overlap(m.x, m.y) ||
 			d->Icon.Overlap(m.x, m.y))
 		{
 			Select(true);
 
 			if (Tree)
 				Tree->OnItemClick(this, m);
 		}
 	}
 }
 
 void LTreeItem::OnPaint(ItemPaintCtx &Ctx)
 {
 	LAssert(Tree != NULL);
 	if (!d->Visible)
 		return;
 
 	// background up to text
 	LSurface *&pDC = Ctx.pDC;
 	pDC->Colour(Ctx.Back);
 	pDC->Rectangle(0, d->Pos.y1, (d->Depth*TREE_BLOCK)+TREE_BLOCK, d->Pos.y2);
 
 	// draw trunk
 	LRect Pos = d->Pos;
 	Pos.x2 = Pos.x1 + Ctx.ColPx[0] - 1;
 
 	int x = 0;
 	LColour Ws(L_WORKSPACE);
 	LColour Lines = Ws.Invert().Mix(Ws);
 
 	pDC->Colour(Lines);
 	if (Tree->d->JoiningLines)
 	{
 		for (int i=0; i<d->Depth; i++)
 		{
 			if (Tree->d->LineFlags[0] & (1 << i))
 				pDC->Line(x + 8, Pos.y1, x + 8, Pos.y2);
 			x += TREE_BLOCK;
 		}
 	}
 	else
 	{
 		x += TREE_BLOCK * d->Depth;
 	}
 
 	// draw node
 	int cy = Pos.y1 + (Pos.Y() >> 1);
 	if (Items.Length() > 0)
 	{
 		d->Thumb.ZOff(8, 8);
 		d->Thumb.Offset(x + 4, cy - 4);
 
 		switch (Tree->d->Btns)
 		{
 			case LTree::TreePlus:
 			{
 				// plus/minus symbol
 				pDC->Colour(L_LOW);
 				pDC->Box(&d->Thumb);
 				pDC->Colour(L_WHITE);
 				pDC->Rectangle(d->Thumb.x1+1, d->Thumb.y1+1, d->Thumb.x2-1, d->Thumb.y2-1);
 				pDC->Colour(L_SHADOW);
 				pDC->Line(	d->Thumb.x1+2,
 							d->Thumb.y1+4,
 							d->Thumb.x1+6,
 							d->Thumb.y1+4);
 
 				if (!d->Open)
 				{
 					// not open, so draw the cross bar making the '-' into a '+'
 					pDC->Colour(L_SHADOW);
 					pDC->Line(	d->Thumb.x1+4,
 								d->Thumb.y1+2,
 								d->Thumb.x1+4,
 								d->Thumb.y1+6);
 				}
 				break;
 			}
 			case LTree::TreeTriangle:
 			{
 				// Triangle style expander
 				pDC->Colour(Lines);
 
 				int Off = 2;
 				if (d->Open)
 				{
 					for (int y=0; y<d->Thumb.Y(); y++)
 					{
 						int x1 = d->Thumb.x1 + y;
 						int x2 = d->Thumb.x2 - y;
 						if (x2 < x1)
 							break;
 						pDC->HLine(x1, x2, d->Thumb.y1 + y + Off);
 					}
 				}
 				else
 				{
 					for (int x=0; x<d->Thumb.X(); x++)
 					{
 						int y1 = d->Thumb.y1 + x;
 						int y2 = d->Thumb.y2 - x;
 						if (y2 < y1)
 							break;
 						pDC->VLine(d->Thumb.x1 + x + Off, y1, y2);
 					}
 				}
 				break;
 			}
 		}
 
 		pDC->Colour(Lines);
 
 		if (Tree->d->JoiningLines)
 		{
 			if (Parent || IndexOf() > 0)
 				// draw line to item above
 				pDC->Line(x + 8, Pos.y1, x + 8, d->Thumb.y1-1);
 
 			// draw line to leaf beside
 			pDC->Line(d->Thumb.x2+1, cy, x + (TREE_BLOCK-1), cy);
 
 			if (!d->Last)
 				// draw line to item below
 				pDC->Line(x + 8, d->Thumb.y2+1, x + 8, Pos.y2);
 		}
 	}
 	else if (Tree->d->JoiningLines)
 	{
 		// leaf node
 		pDC->Colour(L_MED);
 		if (d->Last)
 			pDC->Rectangle(x + 8, Pos.y1, x + 8, cy);
 		else
 			pDC->Rectangle(x + 8, Pos.y1, x + 8, Pos.y2);
 
 		pDC->Rectangle(x + 8, cy, x + (TREE_BLOCK-1), cy);
 	}
 	x += TREE_BLOCK;
 
 	// draw icon
 	int Image = GetImage(Select());
 	LImageList *Lst = Tree->GetImageList();
 	if (Image >= 0 && Lst)
 	{
 		d->Icon.ZOff(Lst->TileX() + Tree->d->IconTextGap - 1, Pos.Y() - 1);
 		d->Icon.Offset(x, Pos.y1);
 
 		pDC->Colour(Ctx.Back);
 
 		if (Tree->d->IconCache)
 		{
 			// no flicker
 			LRect From;
 
 			From.ZOff(Lst->TileX()-1, Tree->d->IconCache->Y()-1);
 			From.Offset(Lst->TileX()*Image, 0);
 
 			pDC->Blt(d->Icon.x1, d->Icon.y1, Tree->d->IconCache, &From);
 
 			pDC->Rectangle(d->Icon.x1 + Lst->TileX(), d->Icon.y1, d->Icon.x2, d->Icon.y2);
 		}
 		else
 		{
 			// flickers...
 			int Px = d->Icon.y1 + ((Lst->TileY()-Pos.Y()) >> 1);
 			pDC->Rectangle(&d->Icon);
 			Tree->GetImageList()->Draw(pDC, d->Icon.x1, Px, Image, Ctx.Back);
 		}
 
 		x += d->Icon.X();
 	}
 
 	LColour SelFore(Tree->Focus() ? L_FOCUS_SEL_FORE : L_NON_FOCUS_SEL_FORE);
 	LColour SelBack(Tree->Focus() ? L_FOCUS_SEL_BACK : L_NON_FOCUS_SEL_BACK);
 
 	bool IsSelected = (Tree->d->DropTarget == this) || (Tree->d->DropTarget == NULL && Select());
 	LColour Fore = Ctx.Fore;
 	LColour TxtBack = Ctx.TxtBack;
 	auto Css = GetCss();
 	LCss::ColorDef f, b;
 	if (Css)
 	{
 		f = Css->Color();
 		b = Css->BackgroundColor();
 	}
 
 	// text: first column
 	Ctx.Fore = f.Type == LCss::ColorRgb ? (LColour)f : (IsSelected ? SelFore : Fore);
 	Ctx.TxtBack = b.Type == LCss::ColorRgb ? (LColour)b : (IsSelected ? SelBack : Ctx.Back);
 
 	auto ColourDiff = abs(Ctx.Fore.GetGray() - Ctx.TxtBack.GetGray());
 	if (ColourDiff < 32) // Check if the colours are too similar and then disambiguate...
 	{
 		// LgiTrace("%s %s are too similar %i\n", Ctx.Fore.GetStr(), Ctx.TxtBack.GetStr(), (int)ColourDiff);
 		Ctx.TxtBack = Ctx.TxtBack.Mix(L_WORKSPACE);
 	}
 
 	LPoint TextSize;
 	_PourText(TextSize);
 	d->Text.ZOff(TextSize.x-1, Pos.Y()-1);
 	d->Text.Offset(x, Pos.y1);
 	(LRect&)Ctx = d->Text;
 	Ctx.x2 = Ctx.ColPx[0] - 1;
 	_PaintText(Ctx);
 	x = Pos.x2 + 1;
 
 	// text: other columns
 	Ctx.Fore = f.Type == LCss::ColorRgb ? (LColour)f : Fore;
 	Ctx.TxtBack = b.Type == LCss::ColorRgb ? (LColour)b : Ctx.Back;
 	for (int i=1; i<Ctx.Columns; i++)
 	{
 		Ctx.Set(x, Pos.y1, x + Ctx.ColPx[i] - 1, Pos.y2);
 		OnPaintColumn(Ctx, i, Tree->Columns[i]);
 		x = Ctx.x2 + 1;
 	}
 	
 	Ctx.Fore = Fore;
 	Ctx.TxtBack = TxtBack;
 
 	// background after text
 	pDC->Colour(Ctx.Back);
 	pDC->Rectangle(x, Pos.y1, MAX(Tree->X(), Tree->d->Limit.x), Pos.y2);
 
 	// children
 	if (d->Open)
 	{
 		if (!d->Last)
 			Tree->d->LineFlags[0] |= 1 << d->Depth;
 
 		List<LTreeItem>::I it = Items.begin();
 		for (LTreeItem *i=*it; i; i=*++it)
 			i->OnPaint(Ctx);
 
 		Tree->d->LineFlags[0] &= ~(1 << d->Depth);
 	}
 }
 
 void LTreeItem::OnPaintColumn(LItem::ItemPaintCtx &Ctx, int i, LItemColumn *c)
 {
 	LDisplayString *ds = d->GetDs(i, Ctx.ColPx[i]);
 	if (ds)
 	{
 		// Draw the text in the context area:
 		LFont *f = ds->GetFont();
 		f->Colour(Ctx.Fore, Ctx.TxtBack);
 		ds->Draw(Ctx.pDC, Ctx.x1 + 2, Ctx.y1 + 1, &Ctx);
 	}
 	else
 	{
 		// No string, fill the space with background
 		Ctx.pDC->Colour(Ctx.Back);
 		Ctx.pDC->Rectangle(&Ctx);
 	}
 }		
 
 //////////////////////////////////////////////////////////////////////////////
 LTree::LTree(int id, int x, int y, int cx, int cy, const char *name) :
 	ResObject(Res_TreeView)
 {
 	d = new LTreePrivate;
 	SetId(id);
 	LRect e(x, y, x+cx, y+cy);
 	SetPos(e);
 	if (name) Name(name);
 	else Name("LGI.LTree");
 	Sunken(true);
 
 	Tree = this;
 	Lines = true;
 	Buttons = true;
 	LinesAtRoot = true;
 	EditLabels = false;
 	ColumnHeaders = false;
 	rItems.ZOff(-1, -1);
 
 	#if WINNATIVE
 	SetStyle(GetStyle() | WS_CHILD | WS_VISIBLE | WS_TABSTOP);
 	#endif
 	SetTabStop(true);
 	LResources::StyleElement(this);
 }
 
 LTree::~LTree()
 {
 	Empty();
 	DeleteObj(d);
 }
 
 // Internal tree methods
 List<LTreeItem>	*LTree::GetSelLst()
 {
 	return &d->Selection;
 }
 
 void LTree::_Update(LRect *r, bool Now)
 {
 	TREELOCK(this)
 
 	if (r)
 	{
 		LRect u = *r;
 		LPoint s = _ScrollPos();
 		LRect c = GetClient();
 		u.Offset(c.x1-s.x, c.y1-s.y);
 		Invalidate(&u, Now && !d->InPour);
 	}
 	else
 	{
 		Invalidate((LRect*)0, Now && !d->InPour);
 	}
 }
 
 void LTree::_UpdateBelow(int y, bool Now)
 {
 	TREELOCK(this)
 
 	LPoint s = _ScrollPos();
 	LRect c = GetClient();
 	LRect u(c.x1, y - s.y + c.y1, X()-1, Y()-1);
 	Invalidate(&u, Now);
 }
 
 void LTree::ClearDs(int Col)
 {
 	TREELOCK(this)
 
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *i=*it; i; i=*++it)
 		i->_ClearDs(Col);
 }
 
 LPoint LTree::_ScrollPos()
 {
 	TREELOCK(this)
 
 	LPoint Status;
 	Status.x = (HScroll) ? (int)HScroll->Value() : 0;
 	Status.y = (VScroll) ? (int)VScroll->Value() * TREE_BLOCK : 0;
 
 	return Status;
 }
 
 void LTree::_UpdateScrollBars()
 {
 	static bool Processing = false;
 	if (!Processing)
 	{
 		Processing = true;
 		
 		{
 			TREELOCK(this)
 			LPoint Old = _ScrollPos();
 			
 			LRect Client = GetClient();
 			bool x = d->Limit.x > Client.X();
 			bool y = d->Limit.y > Client.Y();
 			SetScrollBars(x, y);
 			Client = GetClient();
 
 			// x scroll... in pixels
 			if (HScroll)
 			{
 				HScroll->SetRange(d->Limit.x);
 				HScroll->SetPage(Client.X());
 
 				int Max = d->Limit.x - Client.X();
 				if (HScroll->Value() > Max)
 				{
 					HScroll->Value(Max+1);
 				}
 			}
 
 			// y scroll... in items
 			if (VScroll)
 			{
 				int All = (d->Limit.y + TREE_BLOCK - 1) / TREE_BLOCK;
 				int Visible = Client.Y() / TREE_BLOCK;
 
 				VScroll->SetRange(All);
 				VScroll->SetPage(Visible);
 
 				/* Why is this commented out? -fret Dec2018
 				int Max = All - Visible + 1;
 				if (VScroll->Value() > Max)
 					VScroll->Value(Max);
 				*/
 			}
 
 			LPoint New = _ScrollPos();
 			if (Old.x != New.x ||
 				Old.y != New.y)
 			{
 				Invalidate();
 			}
 		}
 
 		Processing = false;
 	}
 }
 
 void LTree::_OnSelect(LTreeItem *Item)
 {
 	TREELOCK(this)
 
 	if
 	(
 		!MultiSelect()
 		||
 		!d->CurrentClick
 		||
 		(
 			d->CurrentClick 
 			&&
 			!d->CurrentClick->Ctrl()
 		)
 	)
 	{
 		for (auto i: d->Selection)
 		{
 			if (i != Item)
 				i->Select(false);
 		}
 
 		d->Selection.Empty();
 	}
 	else
 	{
 		d->Selection.Delete(Item);
 	}
 
 	d->Selection.Insert(Item);
 }
 
 void LTree::_Pour()
 {
 	TREELOCK(this)
 
 	d->InPour = true;
 	d->Limit.x = rItems.x1;
 	d->Limit.y = rItems.y1;
 
 	int ColumnPx = 0;
 	if (Columns.Length())
 	{
 		for (int i=0; i<Columns.Length(); i++)
 		{
 			LItemColumn *c = Columns[i];
 			ColumnPx += c->Width();
 		}
 	}
 	else
 	{
 		ColumnPx = d->LastLayoutPx = GetClient().X();
 		if (ColumnPx < 16)
 			ColumnPx = 16;
 	}
 
 	LTreeItem *n;
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *i=*it; i; i=n)
 	{
 		n = *++it;
 		i->d->Last = n == 0;
 		i->_Pour(&d->Limit, ColumnPx, 0, true);
 	}
 
 	_UpdateScrollBars();
 	d->LayoutDirty = false;
 	d->InPour = false;
 }
 
 // External methods and events
 void LTree::OnItemSelect(LTreeItem *Item)
 {
 	if (!Item)
 		return;
 
 	TREELOCK(this)
 
 	Item->OnSelect();
 	SendNotify(LNotifyItemSelect);
 }
 
 void LTree::OnItemExpand(LTreeItem *Item, bool Expand)
 {
 	TREELOCK(this)
 
 	if (Item)
 		Item->OnExpand(Expand);
 }
 
 LTreeItem *LTree::GetAdjacent(LTreeItem *i, bool Down)
 {
 	TREELOCK(this)
 
 	LTreeItem *Ret = NULL;
 	if (i)
 	{
 		if (Down)
 		{
 			LTreeItem *n = i->GetChild();
 			
 			if (!n ||
 				!n->d->Visible)
 			{
 				for (n = i; n; )
 				{
 					LTreeItem *p = n->GetParent();
 					if (p)
 					{
 						ssize_t Index = n->IndexOf();
 						if (Index < (ssize_t)p->Items.Length()-1)
 						{
 							n = n->GetNext();
 							break;
 						}
 						else
 						{
 							n = p;
 						}
 					}
 					else
 					{
 						n = n->GetNext();
 						break;
 					}
 				}
 			}
 
 			Ret = n;
 		}
 		else
 		{
 			LTreeItem *p = i->GetParent() ? i->GetParent() : 0;
 			ssize_t Index = i->IndexOf();
 			if (p)
 			{
 				LTreeItem *n = p;
 				if (Index > 0)
 				{
 					n = i->GetPrev();
 					while (	n->GetChild() &&
 							n->GetChild()->d->Visible)
 					{
 						n = n->Items.ItemAt(n->Items.Length()-1);
 					}
 				}
 
 				Ret = n;
 			}
 			else if (Index > 0)
 			{
 				p = i->GetTree()->ItemAt(Index - 1);
 				while (p->GetChild() &&
 						p->GetChild()->d->Visible)
 				{
 					if (p->Items.Length())
 					{
 						p = p->Items.ItemAt(p->Items.Length()-1);
 					}
 					else break;
 				}
 				
 				Ret = p;
 			}
 		}
 	}
 	
 	return Ret;
 }
 
 bool LTree::OnKey(LKey &k)
 {
 	if (!Lock(_FL))
 		return false;
 	
 	bool Status = false;
 	LTreeItem *i = d->Selection[0];
 	if (!i)
 	{
 		i = Items[0];
 		if (i)
 			i->Select();
 	}
 
 	if (k.Down())
 	{
 		switch (k.vkey)
 		{
 			case LK_PAGEUP:
 			case LK_PAGEDOWN:
 			{
 				if (i && i->d->Pos.Y() > 0)
 				{
 					int Page = GetClient().Y() / i->d->Pos.Y();
 					for (int j=0; j<Page; j++)
 					{
 						LTreeItem *n = GetAdjacent(i, k.c16 == LK_PAGEDOWN);
 						if (n)
 						{
 							i = n;
 						}
 						else break;
 					}
 					if (i)
 					{
 						i->Select(true);
 						i->ScrollTo();
 					}
 				}
 				Status = true;
 				break;
 			}
 			case LK_HOME:
 			{
 				LTreeItem *i;
 				if ((i = Items[0]))
 				{
 					i->Select(true);
 					i->ScrollTo();
 				}
 				Status = true;
 				break;
 			}
 			case LK_END:
 			{
-				LTreeItem *n = i, *p = 0;
+				LTreeItem *n = i, *p = NULL;
 				while ((n = GetAdjacent(n, true)))
 				{
 					p = n;
 				}
 				if (p)
 				{
 					p->Select(true);
 					p->ScrollTo();
 				}
 				Status = true;
 				break;
 			}
 			case LK_LEFT:
 			{
 				if (i)
 				{
 					if (i->Items.Length() && i->Expanded())
 					{
 						i->Expanded(false);
 						break;
 					}
 					else
 					{
 						LTreeItem *p = i->GetParent();
 						if (p)
 						{
 							p->Select(true);
 							p->Expanded(false);
 							_Pour();
 							break;
 						}
 					}
 				}
 				// fall thru
 			}
 			case LK_UP:
 			{
 				LTreeItem *n = GetAdjacent(i, false);
 				if (n)
 				{
 					n->Select(true);
 					n->ScrollTo();
 				}
 				Status = true;
 				break;
 			}
 			case LK_RIGHT:
 			{
 				if (i)
 				{
 					i->Expanded(true);
 					if (d->LayoutDirty)
 					{
 						_Pour();
 						break;
 					}
 				}
 				// fall thru
 			}
 			case LK_DOWN:
 			{
 				LTreeItem *n = GetAdjacent(i, true);
 				if (n)
 				{
 					n->Select(true);
 					n->ScrollTo();
 				}
 				Status = true;
 				break;
 			}
 			case LK_DELETE:
 			{
 				if (k.Down())
 				{
 					Unlock(); // before potentially being deleted...?
 					SendNotify(LNotification(k));
 					// This might delete the item... so just return here.
 					return true;
 				}
 				break;
 			}
 			#ifdef VK_APPS
 			case VK_APPS:
 			{
 				LTreeItem *s = Selection();
 				if (s)
 				{
 					LRect *r = &s->d->Text;
 					if (r)
 					{
 						LMouse m;
 						m.x = r->x1 + (r->X() >> 1);
 						m.y = r->y1 + (r->Y() >> 1);
 						m.Target = this;
 						m.ViewCoords = true;
 						m.Down(true);
 						m.Right(true);
 						
 						s->OnMouseClick(m);
 					}
 				}
 				break;
 			}
 			#endif
 			default:
 			{
 				switch (k.c16)
 				{
 					case 'F':
 					case 'f':
 					{
 						if (k.Ctrl())
 							SendNotify(LNotifyContainerFind);
 						break;
 					}
 				}
 				break;
 			}
 		}
 	}
 
 	if (i && i != (LTreeItem*)this)
 	{
 		i->OnKey(k);
 	}
 
 	Unlock();
 	return Status;
 }
 
 LTreeItem *LTree::ItemAtPoint(int x, int y, bool Debug)
 {
 	TREELOCK(this)
 
 	LPoint s = _ScrollPos();
 
 	List<LTreeItem>::I it = Items.begin();
 	LTreeItem *Hit = NULL;
 	for (LTreeItem *i = *it; i; i=*++it)
 	{
 		Hit = i->_HitTest(s.x + x, s.y + y, Debug);
 		if (Hit)
 			break;
 	}
 
 	return Hit;
 }
 
 bool LTree::OnMouseWheel(double Lines)
 {
 	TREELOCK(this)
 
 	if (VScroll)
 		VScroll->Value(VScroll->Value() + (int)Lines);
 	
 	return true;
 }
 
 void LTree::OnMouseClick(LMouse &m)
 {
 	TREELOCK(this)
 
 	d->CurrentClick = &m;
 
 	if (m.Down())
 	{
 		DragMode = DRAG_NONE;
 
 		if (ColumnHeaders &&
 			ColumnHeader.Overlap(m.x, m.y))
 		{
 			d->DragStart.x = m.x;
 			d->DragStart.y = m.y;
 
 			// Clicked on a column heading
 			LItemColumn *Resize;
 			LItemColumn *Over = NULL;
 			HitColumn(m.x, m.y, Resize, Over);
 
 			if (Resize)
 			{
 				if (m.Double())
 				{
 					Resize->Width(Resize->GetContentSize() + DEFAULT_COLUMN_SPACING);
 					Invalidate();
 				}
 				else
 				{
 					DragMode = RESIZE_COLUMN;
 					d->DragData = (int)Columns.IndexOf(Resize);
 					Capture(true);
 				}
 			}
 			/*
 			else
 			{
 				DragMode = CLICK_COLUMN;
 				d->DragData = Columns.IndexOf(Over);
 				if (Over)
 				{
 					Over->Value(true);
 					LRect r = Over->GetPos();
 					Invalidate(&r);
 					Capture(true);
 				}
 			}
 			*/
 		}
 		else if (rItems.Overlap(m.x, m.y))
 		{
 			Focus(true);
 			Capture(true);
 			d->LastClick.x = m.x;
 			d->LastClick.y = m.y;
 
 			d->LastHit = ItemAtPoint(m.x, m.y, true);
 			if (d->LastHit)
 			{
 				LPoint c = _ScrollPos();
 				m.x += c.x;
 				m.y += c.y;
 				d->LastHit->_MouseClick(m);
 			}
 			else
 			{
 				SendNotify(LNotification(m, LNotifyContainerClick));
 			}
 		}
 	}
 	else if (IsCapturing())
 	{
 		Capture(false);
 
 		if (rItems.Overlap(m.x, m.y))
 		{
 			d->LastClick.x = m.x;
 			d->LastClick.y = m.y;
 
 			d->LastHit = ItemAtPoint(m.x, m.y);
 			if (d->LastHit)
 			{
 				LPoint c = _ScrollPos();
 				m.x += c.x;
 				m.y += c.y;
 				d->LastHit->_MouseClick(m);
 			}
 		}
 	}
 
 	d->CurrentClick = NULL;	
 }
 
 void LTree::OnMouseMove(LMouse &m)
 {
 	if (!IsCapturing())
 		return;
 
 	TREELOCK(this)
 
 	switch (DragMode)
 	{
 		/*
 		case DRAG_COLUMN:
 		{
 			if (DragCol)
 			{
 				LPoint p;
 				PointToScreen(p);
 
 				LRect r = DragCol->GetPos();
 				r.Offset(-p.x, -p.y); // to view co-ord
 
 				r.Offset(m.x - DragCol->GetOffset() - r.x1, 0);
 				if (r.x1 < 0) r.Offset(-r.x1, 0);
 				if (r.x2 > X()-1) r.Offset((X()-1)-r.x2, 0);
 
 				r.Offset(p.x, p.y); // back to screen co-ord
 				DragCol->SetPos(r, true);
 				r = DragCol->GetPos();
 			}
 			break;
 		}
 		*/
 		case RESIZE_COLUMN:
 		{
 			LItemColumn *c = Columns[d->DragData];
 			if (c)
 			{
 				// int OldWidth = c->Width();
 				int NewWidth = m.x - c->GetPos().x1;
 
 				c->Width(MAX(NewWidth, 4));
 				_ClearDs(d->DragData);
 				Invalidate();
 			}
 			break;
 		}
 		default:
 		{
 			if (rItems.Overlap(m.x, m.y))
 			{
 				if (abs(d->LastClick.x - m.x) > DRAG_THRESHOLD ||
 					abs(d->LastClick.y - m.y) > DRAG_THRESHOLD)
 				{
 					OnItemBeginDrag(d->LastHit, m);
 					Capture(false);
 				}
 			}
 			break;
 		}
 	}
 }
 
 void LTree::OnPosChange()
 {
 	TREELOCK(this)
 		
 	if (Columns.Length() == 0 &&
 		d->LastLayoutPx != GetClient().X())
 		d->LayoutDirty = true;
 	LLayout::OnPosChange();
 	_UpdateScrollBars();
 }
 
 void LTree::OnPaint(LSurface *pDC)
 {
 	TREELOCK(this)
 	LCssTools Tools(this);
 
 	#if 0 // coverage testing...
 	pDC->Colour(LColour(255, 0, 255));
 	pDC->Rectangle();
 	#endif
 
 	rItems = GetClient();
 	LFont *f = GetFont();
 	if (ShowColumnHeader())
 	{
 		ColumnHeader.ZOff(rItems.X()-1, f->GetHeight() + 4);
 		PaintColumnHeadings(pDC);
 		rItems.y1 = ColumnHeader.y2 + 1;
 	}
 	else
 	{
 		ColumnHeader.ZOff(-1, -1);
 	}
 
 	d->IconTextGap = GetFont()->GetHeight() / 6;
 	auto cText = LColour(L_TEXT);
 	auto cWs = LColour(L_WORKSPACE);
 	LColour Fore = Tools.GetFore(&cText);
 	LColour Background = Tools.GetBack(&cWs, 0);
 
 	// icon cache
 	if (GetImageList() &&
 		!d->IconCache)
 	{
 		int CacheHeight = MAX(LSysFont->GetHeight(), GetImageList()->Y());
 		
-		d->IconCache = new LMemDC;
-		if (d->IconCache &&
+		if (d->IconCache.Reset(new LMemDC) &&
 			d->IconCache->Create(GetImageList()->X(), CacheHeight, GdcD->GetColourSpace()))
 		{
 			if (d->IconCache->GetColourSpace() == CsIndex8)
 			{
 				d->IconCache->Palette(new LPalette(GdcD->GetGlobalColour()->GetPalette()));
 			}
 
 			d->IconCache->Colour(Background);
 			d->IconCache->Rectangle();
 			d->IconCache->Op(GDC_ALPHA);
 
 			GetImageList()->Lock();
 			int DrawY = (CacheHeight - GetImageList()->TileY()) >> 1;
 			LAssert(DrawY >= 0);
 			for (int i=0; i<GetImageList()->GetItems(); i++)
 			{
 				GetImageList()->Draw(d->IconCache, i * GetImageList()->TileX(), DrawY, i, Background);
 			}
 			GetImageList()->Unlock();
 			d->IconCache->Unlock();
 		}
 	}
 
 	// scroll
 	LPoint s = _ScrollPos();
 	int Ox, Oy;
 	pDC->GetOrigin(Ox, Oy);
 	pDC->SetOrigin(Ox + s.x, Oy + s.y);
 
 	// selection colour
 	LArray<int> ColPx;
 	LItem::ItemPaintCtx Ctx;
 	Ctx.pDC = pDC;
 	if (Columns.Length() > 0)
 	{
 		Ctx.Columns = (int)Columns.Length();
 		for (int i=0; i<Columns.Length(); i++)
 			ColPx[i] = Columns[i]->Width();
 	}
 	else
 	{
 		Ctx.Columns = 1;
 		ColPx[0] = rItems.X();
 	}
 	Ctx.ColPx = &ColPx[0];
 	Ctx.Fore = Fore;
 	Ctx.Back = Background;
 	Ctx.TxtBack = Background;
 	LColour SelFore(Focus() ? L_FOCUS_SEL_FORE : L_NON_FOCUS_SEL_FORE);
 	LColour SelBack(Focus() ? L_FOCUS_SEL_BACK : L_NON_FOCUS_SEL_BACK);
 
 	// layout items
 	if (d->LayoutDirty)
 	{
 		_Pour();
 	}
 
 	// paint items
 	ZeroObj(d->LineFlags);
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *i = *it; i; i=*++it)
 		i->OnPaint(Ctx);
 
 	pDC->SetOrigin(Ox, Oy);
 	if (d->Limit.y-s.y < rItems.Y())
 	{
 		// paint after items
 		pDC->Colour(Background);
 		pDC->Rectangle(rItems.x1, d->Limit.y - s.y, rItems.x2, rItems.y2);
 	}
 }
 
 int LTree::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_HSCROLL:
 		case IDC_VSCROLL:
 		{
 			TREELOCK(this)
 			if (n.Type == LNotifyScrollBarCreate)
 			{
 				_UpdateScrollBars();
 				if (VScroll)
 				{
 					if (HasItem(d->ScrollTo))
 						d->ScrollTo->ScrollTo();
 					d->ScrollTo = NULL;
 				}
 			}
 
 			Invalidate();
 			break;
 		}
 	}
 
 	return LLayout::OnNotify(Ctrl, n);
 }
 
 LMessage::Result LTree::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_SCROLL_TO:
 		{
 			LTreeItem *Item = (LTreeItem*)Msg->A();
 			if (!HasItem(Item))
 				break;
 			
 			if (VScroll)
 				Item->ScrollTo();
 			break;
 		}
 	}
 
 	return LItemContainer::OnEvent(Msg);
 }
 
 LTreeItem *LTree::Insert(LTreeItem *Obj, ssize_t Pos)
 {
 	TREELOCK(this)
 		
 	LTreeItem *NewObj = LTreeNode::Insert(Obj, Pos);
 	if (NewObj)
 		NewObj->_SetTreePtr(this);
 	
 	return NewObj;
 }
 
 bool LTree::HasItem(LTreeItem *Obj, bool Recurse)
 {
 	TREELOCK(this)
 	if (!Obj)
 		return false;
 	return LTreeNode::HasItem(Obj, Recurse);
 }
 
 bool LTree::Remove(LTreeItem *Obj)
 {
 	TREELOCK(this)
 		
 	bool Status = false;
 	if (Obj && Obj->Tree == this)
 	{
 		Obj->Remove();
 		Status = true;
 	}
 	
 	return Status;
 }
 
 void LTree::RemoveAll()
 {
 	TREELOCK(this)
 		
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *i=*it; i; i=*++it)
 		i->_Remove();
 
 	Invalidate();
 }
 
 void LTree::Empty()
 {
 	TREELOCK(this)
 		
 	LTreeItem *i;
 	while ((i = Items[0]))
 		Delete(i);	
 }
 
 bool LTree::Delete(LTreeItem *Obj)
 {
 	bool Status = false;
 	
 	TREELOCK(this)
 		
 	if (Obj)
 	{
 		LTreeItem *i;
 		while ((i = Obj->Items[0]))
 		{
 			Delete(i);
 		}
 		
 		Obj->Remove();
 		DeleteObj(Obj);
 		Status = true;
 	}
 	
 	return Status;
 }
 
 void LTree::OnPulse()
 {
 	TREELOCK(this)
 		
 	if (d->DropTarget)
 	{
 		int64 p = LCurrentTime() - d->DropSelectTime;
 		if (p >= 1000)
 		{
 			SetPulse();
 
 			if (!d->DropTarget->Expanded() &&
 				d->DropTarget->GetChild())
 			{
 				d->DropTarget->Expanded(true);
 			}
 		}
 	}	
 
 	if (InsideDragOp())
 	{
 		LMouse m;
 		if (GetMouse(m))
 		{
 			if (!m.Left() && !m.Right() && !m.Middle())
 			{
 				// Be robust against missing drag exit events (Mac specific?)
 				InsideDragOp(false);
 			}
 			else
 			{
 				LRect c = GetClient();
 				if (VScroll)
 				{
 					if (m.y < DRAG_SCROLL_EDGE)
 					{
 						// Scroll up...
 						VScroll->Value(VScroll->Value() - DRAG_SCROLL_Y);
 					}
 					else if (m.y > c.Y() - DRAG_SCROLL_EDGE)
 					{
 						// Scroll down...
 						VScroll->Value(VScroll->Value() + DRAG_SCROLL_Y);
 					}
 				}
 
 				if (HScroll)
 				{
 					if (m.x < DRAG_SCROLL_EDGE)
 					{
 						// Scroll left...
 						HScroll->Value(HScroll->Value() - DRAG_SCROLL_X);
 					}
 					else if (m.x > c.X() - DRAG_SCROLL_EDGE)
 					{
 						// Scroll right...
 						HScroll->Value(HScroll->Value() + DRAG_SCROLL_X);
 					}
 				}
 			}
 		}
 	}
 }
 
 int LTree::GetContentSize(int ColumnIdx)
 {
 	TREELOCK(this)
 		
 	int MaxPx = 0;
 	
 	List<LTreeItem>::I it = Items.begin();
 	for (LTreeItem *i = *it; i; i=*++it)
 	{
 		int ItemPx = i->GetColumnSize(ColumnIdx);
 		MaxPx = MAX(ItemPx, MaxPx);
 	}
 
 	return MaxPx;
 }
 
 LCursor LTree::GetCursor(int x, int y)
 {
 	TREELOCK(this)
 		
 	LItemColumn *Resize = NULL, *Over = NULL;
 	HitColumn(x, y, Resize, Over);
 
 	return (Resize) ? LCUR_SizeHor : LCUR_Normal;
 }
 
 void LTree::OnDragEnter()
 {
 	TREELOCK(this)
 		
 	InsideDragOp(true);
 	SetPulse(120);
 }
 
 void LTree::OnDragExit()
 {
 	TREELOCK(this)
 		
 	InsideDragOp(false);
 	SetPulse();
 	SelectDropTarget(0);
 }
 
 void LTree::SelectDropTarget(LTreeItem *Item)
 {
 	TREELOCK(this)
 		
 	if (Item != d->DropTarget)
 	{
 		bool Update = (d->DropTarget != 0) ^ (Item != 0);
 		LTreeItem *Old = d->DropTarget;
 		
 		d->DropTarget = Item;
 		if (Old)
 		{
 			Old->Update();
 		}
 
 		if (d->DropTarget)
 		{
 			d->DropTarget->Update();
 			d->DropSelectTime = LCurrentTime();
 		}
 
 		if (Update)
 		{
 			OnFocus(true);
 		}
 	}
 }
 
 bool LTree::Select(LTreeItem *Obj)
 {
 	TREELOCK(this)
 		
 	bool Status = false;
 	if (Obj && IsAttached())
 	{
 		Obj->Select(true);
 		Status = true;
 	}
 	else if (d->Selection.Length())
 	{		
 		d->Selection.Empty();
 		OnItemSelect(0);
 		Status = true;
 	}
 
 	return Status;
 }
 
 LTreeItem *LTree::Selection()
 {
 	TREELOCK(this)
 	return d->Selection[0];
 }
 
 bool LTree::ForAllItems(std::function<void(LTreeItem*)> Callback)
 {
 	TREELOCK(this)
 	return ForEach(Callback) > 0;
 }
 
 void LTree::OnItemClick(LTreeItem *Item, LMouse &m)
 {
 	if (!Item)
 		return;
 
 	TREELOCK(this)
 
 	Item->OnMouseClick(m);
 	if (!m.Ctrl() && !m.Shift())
 		SendNotify(LNotification(m));
 }
 
 void LTree::OnItemBeginDrag(LTreeItem *Item, LMouse &m)
 {
 	if (!Item)
 		return;
 
 	TREELOCK(this)
 	Item->OnBeginDrag(m);
 }
 
 void LTree::OnFocus(bool b)
 {
 	TREELOCK(this)
 
 	// errors during deletion of the control can cause 
 	// this to be called after the destructor
 	if (d)
 	{
 		List<LTreeItem>::I it = d->Selection.begin();
 		for (LTreeItem *i=*it; i; i=*++it)
 			i->Update();
 	}
 }
 
 static void LTreeItemUpdateAll(LTreeNode *n)
 {
 	for (LTreeItem *i=n->GetChild(); i; i=i->GetNext())
 	{
 		i->Update();
 		LTreeItemUpdateAll(i);
 	}
 }
 
 void LTree::UpdateAllItems()
 {
 	TREELOCK(this)
 
 	d->LayoutDirty = true;
 	LTreeItemUpdateAll(this);
 }
 
 void LTree::SetVisualStyle(ThumbStyle Btns, bool JoiningLines)
 {
 	TREELOCK(this)
 
 	d->Btns = Btns;
 	d->JoiningLines = JoiningLines;
 	Invalidate();
 }
 
diff --git a/src/win/Lgi/Printer.cpp b/src/win/Lgi/Printer.cpp
--- a/src/win/Lgi/Printer.cpp
+++ b/src/win/Lgi/Printer.cpp
@@ -1,326 +1,330 @@
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Base64.h"
 #include "lgi/common/Printer.h"
 
 ////////////////////////////////////////////////////////////////////
 class LPrinterPrivate
 {
 public:
 	PRINTDLG Info;
 	LString Err;
 	bool NeedsDC;
 
 	LPrinterPrivate()
 	{
 		NeedsDC = false;
 		ZeroObj(Info);
 		Info.lStructSize = sizeof(Info);
 	}
 };
 
 //////////////////////////////////////////////////////////////////////
 LPrinter::LPrinter()
 {
 	d = new LPrinterPrivate;
 }
 
 LPrinter::~LPrinter()
 {
 	DeleteObj(d);
 }
 
 LString LPrinter::GetErrorMsg()
 {
 	return d->Err;
 }
 
 #define PrintStatus(val) \
 	{ if (callback) callback(val); return; }
 
 void LPrinter::Print(LPrintEvents *Events, std::function<void(int)> callback, const char *PrintJobName, int Pages, LView *Parent)
 {
 	if (!Events)
 		PrintStatus(LPrintEvents::OnBeginPrintError);
 		
 	if
 	(
 		Parent
 		&&
 		(
 			!d->Info.hDevMode
 			||
 			!d->Info.hDevNames
 		)
 	)
 	{
 		d->NeedsDC = true;
 		bool r = Browse(Parent);
 		d->NeedsDC = false;
 		if (!r)
 			PrintStatus(LPrintEvents::OnBeginPrintError);
 	}
 	else
 	{
 		d->Info.hwndOwner = (Parent) ? Parent->Handle() : 0;
 		d->Info.Flags = PD_RETURNDC;
 		d->Info.hDC = 0;
 		if (!PrintDlg(&d->Info))
 			PrintStatus(LPrintEvents::OnBeginPrintError);
 	}
 
 	if (!d->Info.hDC)
 		PrintStatus(LPrintEvents::OnBeginPrintError);
 	
 	LString PrinterName;
 	if (d->Info.hDevNames)
 	{
 		DEVNAMES *Name = (DEVNAMES*)GlobalLock(d->Info.hDevNames);
 		if (Name)
 		{
 			// const char *Driver = (const char *)Name + Name->wDriverOffset;
 			const char *Device = (const char *)Name + Name->wDeviceOffset;
 			// const char *Output = (const char *)Name + Name->wOutputOffset;
 			// const char *Default = (const char *)Name + Name->wDefault;			
 			PrinterName = Device;			
 			GlobalUnlock(Name);
 		}
 	}
 
-	LPrintDC dc(d->Info.hDC, PrintJobName, PrinterName);
-	if (!dc.Handle())
+	auto dc = new LPrintDC(d->Info.hDC, PrintJobName, PrinterName);
+	if (!dc || !dc->Handle())
 	{
+		if (dc)
+			delete dc;
 		d->Err.Printf("%s:%i - StartDoc failed.\n", _FL);
 		PrintStatus(LPrintEvents::OnBeginPrintError);
 	}	
 	
-	Events->OnBeginPrint(&dc, [&](auto JobPages)
+	Events->OnBeginPrint(dc, [this, dc, Events, callback, PrintJobName=LString(PrintJobName), Pages](auto JobPages)
 	{
+		LAutoPtr<LPrintDC> ownDc(dc); // Make sure we free the dc
+
 		if (JobPages <= LPrintEvents::OnBeginPrintCancel)
 			PrintStatus(JobPages);
 
 		bool Status = false;
 		DOCINFO Info;
 		LAutoWString DocName(Utf8ToWide(PrintJobName ? PrintJobName : "Lgi Print Job"));
 
 		ZeroObj(Info);
 		Info.cbSize = sizeof(DOCINFO); 
 		Info.lpszDocName = DocName; 
 
 		if (Pages > 0)
 			JobPages = min(JobPages, Pages);
 		
 		auto PageRanges = Events->GetPageRanges();
 		for (int i=0; i<JobPages; i++)
 		{
 			if (!PageRanges || PageRanges->InRanges(i + 1))
 			{
-				if (StartPage(dc.Handle()) > 0)
+				if (StartPage(dc->Handle()) > 0)
 				{
-					Status |= Events->OnPrintPage(&dc, i);
-					EndPage(dc.Handle());
+					Status |= Events->OnPrintPage(dc, i);
+					EndPage(dc->Handle());
 				}
 				else
 				{
 					d->Err.Printf("%s:%i - StartPage failed.", _FL);
 					JobPages = LPrintEvents::OnBeginPrintError;
 					break;
 				}
 			}
 		}
 	
-		LString OutputFile = dc.GetOutputFileName();
+		LString OutputFile = dc->GetOutputFileName();
 		if (LFileExists(OutputFile))
 			LBrowseToFile(OutputFile);
 
 		PrintStatus(JobPages);
 	});	
 }
 
 bool LPrinter::Browse(LView *Parent)
 {
 	d->Info.hwndOwner = (Parent) ? Parent->Handle() : 0;
 	d->Info.Flags = PD_PRINTSETUP | PD_PAGENUMS;
 	if (d->NeedsDC)
 		d->Info.Flags |= PD_RETURNDC;
 	/*
 	if (d->Pages > 1)
 	{
 		d->Info.nMinPage = 1;
 		d->Info.nMaxPage = d->Pages;
 	}
 	*/
 
 	return PrintDlg(&d->Info) != 0;
 }
 
 /*
 bool GPrinter::GetPageRange(LArray<int> &p)
 {
 	if (d->Info.Flags & PD_PAGENUMS)
 	{
 		p[0] = d->Info.nFromPage;
 		p[1] = d->Info.nToPage;
 
 		return true;
 	}
 
 	return false;
 }
 */
 
 #define MAGIC_PRINTDLG					0xAAFF0100
 #define MAGIC_DEVMODE					0xAAFF0101
 #define MAGIC_DEVNAMES					0xAAFF0102
 
 bool LPrinter::Serialize(LString &Str, bool Write)
 {
 	int Size = sizeof(d->Info);
 	if (Write)
 	{
 		GMem DevMode(d->Info.hDevMode);
 		GMem DevNames(d->Info.hDevNames);
 		DEVMODE *Mode = (DEVMODE*) DevMode.Lock();
 		DEVNAMES *Names = (DEVNAMES*) DevNames.Lock();
 		LMemQueue Temp;
 		int32 m;
 
 		// Dlg
 		m = MAGIC_PRINTDLG;
 		Temp.Write(&m, sizeof(m));
 		m = sizeof(d->Info);
 		Temp.Write(&m, sizeof(m));
 		Temp.Write((uchar*)&d->Info, m);
 
 		// Mode
 		if (Mode)
 		{
 			m = MAGIC_DEVMODE;
 			Temp.Write(&m, sizeof(m));
 			m = (int32) DevMode.GetSize();
 			Temp.Write(&m, sizeof(m));
 			Temp.Write((uchar*) Mode, m);
 		}
 
 		// Names
 		if (Names)
 		{
 			m = MAGIC_DEVNAMES;
 			Temp.Write(&m, sizeof(m));
 			m = (int32) DevNames.GetSize();
 			Temp.Write(&m, sizeof(m));
 			Temp.Write((uchar*) Names, m);
 		}
 
 		DevMode.Detach();
 		DevNames.Detach();
 
 		// Convert to base64
 		auto BinLen = Temp.GetSize();
 		uchar *Bin = new uchar[BinLen];
 		if (Bin && Temp.Read(Bin, BinLen))
 		{
 			auto Base64Len = BufferLen_BinTo64(BinLen);
 			char *Base64 = new char[Base64Len+1];
 			if (Base64)
 			{
 				memset(Base64, 0, Base64Len+1);
 				ConvertBinaryToBase64(Base64, Base64Len, Bin, BinLen);
 				Str = Base64;
 			}
 			return true;
 		}
 	}
 	else
 	{
 		bool Status = false;
 
 		ZeroObj(d->Info);
 		d->Info.lStructSize = Size;
 		if (Str)
 		{
 			// Convert to binary
 			LMemQueue Temp;
 
 			auto Base64Len = Str.Length();
 			auto BinaryLen = BufferLen_64ToBin(Base64Len);
 			uchar *Binary = new uchar[BinaryLen];
 			if (Binary)
 			{
 				auto Len = ConvertBase64ToBinary(Binary, BinaryLen, Str, Base64Len);
 				Temp.Write(Binary, Len);
 
 				bool Done = false;
 				do
 				{
 					int Type = 0;
 					int Size = 0;
 
 					if (Temp.Read(&Type, sizeof(Type)) &&
 						Temp.Read(&Size, sizeof(Size)))
 					{
 						switch (Type)
 						{
 							case MAGIC_PRINTDLG:
 							{
 								if (Size == sizeof(d->Info))
 								{
 									Temp.Read((uchar*) &d->Info, Size);
 									d->Info.hDevMode = 0;
 									d->Info.hDevNames = 0;
 									Status = true;
 								}
 								else
 								{
 									// Grrrr: Error
 									Done = true;
 								}
 								break;
 							}
 							case MAGIC_DEVMODE:
 							{
 								GMem DevMode(Size);
 								DEVMODE *Mode = (DEVMODE*) DevMode.Lock();
 								if (Mode)
 								{
 									Temp.Read((uchar*)Mode, Size);
 									d->Info.hDevMode = DevMode.Handle();
 									DevMode.Detach();
 								}
 								break;
 							}
 							case MAGIC_DEVNAMES:
 							{
 								GMem DevNames(Size);
 								DEVNAMES *Names = (DEVNAMES*) DevNames.Lock();
 								if (Names)
 								{
 									Temp.Read((uchar*)Names, Size);
 									d->Info.hDevNames = DevNames.Handle();
 									DevNames.Detach();
 								}
 								break;
 							}
 							default:
 							{
 								// Eof
 								Done = true;
 								break;
 							}
 						}
 					}
 					else
 					{
 						Done = true;
 					}
 				}
 				while (!Done);
 
 				DeleteArray(Binary);
 			}
 		}
 
 		return Status;
 	}
 
 	return false;
 }
\ No newline at end of file