diff --git a/src/common/Lgi/ViewCommon.cpp b/src/common/Lgi/ViewCommon.cpp
--- a/src/common/Lgi/ViewCommon.cpp
+++ b/src/common/Lgi/ViewCommon.cpp
@@ -1,2735 +1,2737 @@
 /// \file
 /// \author Matthew Allen <fret@memecode.com>
 #ifdef LINUX
 #include <unistd.h>
 #endif
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DragAndDrop.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/Css.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/EventTargetThread.h"
 #include "lgi/common/Popup.h"
 #include "lgi/common/CssTools.h"
 #include "ViewPriv.h"
 
 #if 0
 #define DEBUG_CAPTURE(...) printf(__VA_ARGS__)
 #else
 #define DEBUG_CAPTURE(...)
 #endif
 
 //////////////////////////////////////////////////////////////////////////////////////
 // Helper
 LPoint lgi_view_offset(LViewI *v, bool Debug = false)
 {
 	LPoint Offset;
 	
 	for (LViewI *p = v; p; p = p->GetParent())
 	{
 		if (dynamic_cast<LWindow*>(p))
 			break;
 		
 		LRect pos = p->GetPos();
 		LRect cli = p->GetClient(false);
 
 		if (Debug)
 		{
 			const char *cls = p->GetClass();
 			LgiTrace("	Off[%s] += %i,%i = %i,%i (%s)\n",
 					cls,
 					pos.x1, pos.y1,
 					Offset.x + pos.x1, Offset.y + pos.y1,
 					cli.GetStr());
 		}
 		
 		Offset.x += pos.x1 + cli.x1;
 		Offset.y += pos.y1 + cli.y1;
 	}
 	
 	return Offset;
 }
 
 LMouse &lgi_adjust_click(LMouse &Info, LViewI *Wnd, bool Capturing, bool Debug)
 {
 	static LMouse Temp;
 	 
 	Temp = Info;
 	if (Wnd)
 	{
 		if (Debug
 			#if 0
 			|| Capturing
 			#endif
 			)
 			LgiTrace("AdjustClick Target=%s -> Wnd=%s, Info=%i,%i\n",
 				Info.Target?Info.Target->GetClass():"",
 				Wnd?Wnd->GetClass():"",
 				Info.x, Info.y);
 
 		if (Temp.Target != Wnd)
 		{
 			if (Temp.Target)
 			{
 				auto *TargetWnd = Temp.Target->GetWindow();
 				auto *WndWnd = Wnd->GetWindow();
 				if (TargetWnd == WndWnd)
 				{
 					LPoint TargetOff = lgi_view_offset(Temp.Target, Debug);
 					if (Debug)
 						LgiTrace("	WndOffset:\n");
 					LPoint WndOffset = lgi_view_offset(Wnd, Debug);
 
 					Temp.x += TargetOff.x - WndOffset.x;
 					Temp.y += TargetOff.y - WndOffset.y;
 
 					#if 0
 					LRect c = Wnd->GetClient(false);
 					Temp.x -= c.x1;
 					Temp.y -= c.y1;
 					if (Debug)
 						LgiTrace("	CliOff -= %i,%i\n", c.x1, c.y1);
 					#endif
 
 					Temp.Target = Wnd;
 				}
 			}
 			else
 			{
 				LPoint Offset;
 				Temp.Target = Wnd;
 				if (Wnd->WindowVirtualOffset(&Offset))
 				{
 					LRect c = Wnd->GetClient(false);
 					Temp.x -= Offset.x + c.x1;
 					Temp.y -= Offset.y + c.y1;
 				}
 			}
 		}
 	}
 	
 	LAssert(Temp.Target != NULL);
 	
 	return Temp;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 // LView class methods
 LViewI *LView::_Capturing = 0;
 LViewI *LView::_Over = 0;
 
 #if LGI_VIEW_HASH
 
 struct ViewTbl : public LMutex
 {
 	typedef LHashTbl<PtrKey<LViewI*>, int> T;
 	
 private:
 	T Map;
 
 public:
 	ViewTbl() : Map(2000), LMutex("ViewTbl")
 	{
 	}
 
 	T *Lock()
 	{
 		if (!LMutex::Lock(_FL))
 			return NULL;
 		return &Map;
 	}
 }	ViewTblInst;
 
 bool LView::LockHandler(LViewI *v, LView::LockOp Op)
 {
 	ViewTbl::T *m = ViewTblInst.Lock();
 	if (!m)
 		return false;
 	int Ref = m->Find(v);
 	bool Status = false;
 	switch (Op)
 	{
 		case OpCreate:
 		{
 			if (Ref == 0)
 				Status = m->Add(v, 1);
 			else
 				LAssert(!"Already exists?");
 			break;
 		}
 		case OpDelete:
 		{
 			if (Ref == 1)
 				Status = m->Delete(v);
 			else
 				LAssert(!"Either locked or missing.");
 			break;
 		}
 		case OpExists:
 		{
 			Status = Ref > 0;
 			break;
 		}
 	}	
 	ViewTblInst.Unlock();
 	return Status;
 }
 
 #endif
 
 LView::LView(OsView view)
 {
 	#ifdef _DEBUG
     _Debug = false;
 	#endif
 
 	d = new LViewPrivate(this);
 	#ifdef LGI_SDL
 	_View = this;
 	#elif LGI_VIEW_HANDLE && !defined(HAIKU)
 	_View = view;
 	#endif
 	Pos.ZOff(-1, -1);
 	WndFlags = GWF_VISIBLE;
 
     #ifndef LGI_VIEW_HASH
         #error "LGI_VIEW_HASH needs to be defined"
     #elif LGI_VIEW_HASH
 	    LockHandler(this, OpCreate);
 	    // printf("Adding %p to hash\n", (LViewI*)this);
 	#endif
 }
 
 LView::~LView()
 {
 	if (d->SinkHnd >= 0)
 	{
 		LEventSinkMap::Dispatch.RemoveSink(this);
 		d->SinkHnd = -1;
 	}
 	
 	#if LGI_VIEW_HASH
 	LockHandler(this, OpDelete);
 	#endif
 
 	for (unsigned i=0; i<LPopup::CurrentPopups.Length(); i++)
 	{
 		LPopup *pu = LPopup::CurrentPopups[i];
 		if (pu->Owner == this)
 			pu->Owner = NULL;
 	}
 
 	_Delete();
 
 	// printf("%p::~LView delete %p th=%u\n", this, d, GetCurrentThreadId());
 	DeleteObj(d);	
 	// printf("%p::~LView\n", this);
 }
 
 int LView::AddDispatch()
 {
 	if (d->SinkHnd < 0)
 		d->SinkHnd = LEventSinkMap::Dispatch.AddSink(this);
 	return d->SinkHnd;
 }
 
 LString LView::CssStyles(const char *Set)
 {
 	if (Set)
 	{
 		d->Styles = Set;
 		d->CssDirty = true;
 	}
 	return d->Styles;
 }
 
 LString::Array *LView::CssClasses()
 {
 	return &d->Classes;
 }
 
 LArray<LViewI*> LView::IterateViews()
 {
 	LArray<LViewI*> a;
 	for (auto c: Children)
 		a.Add(c);
 	return a;
 }
 
 bool LView::AddView(LViewI *v, int Where)
 {
 	LAssert(!Children.HasItem(v));
 	bool Add = Children.Insert(v, Where);
 	if (Add)
 	{
 		LView *gv = v->GetGView();
 		if (gv && gv->_Window != _Window)
 		{
 			LAssert(!_InLock);
 			gv->_Window = _Window;
 		}
 		v->SetParent(this);
 		v->OnAttach();
 		OnChildrenChanged(v, true);
 	}
 	return Add;
 }
 
 bool LView::DelView(LViewI *v)
 {
 	bool Has = Children.HasItem(v);
 	bool b = Children.Delete(v);
 	if (Has)
 		OnChildrenChanged(v, false);
 	Has = Children.HasItem(v);
 	LAssert(!Has);
 	return b;
 }
 
 bool LView::HasView(LViewI *v)
 {
 	return Children.HasItem(v);
 }
 
 OsWindow LView::WindowHandle()
 {
 	auto w = GetWindow();
 	OsWindow h;
 	if (w)
 		h = w->WindowHandle();
 	return h;
 }
 
 LWindow *LView::GetWindow()
 {
 	if (!_Window)
 	{
 		// Walk up parent list and find someone who has a window
 		auto *w = d->GetParent();
 		for (; w; w = w->d ? w->d->GetParent() : NULL)
 		{
 			if (w->_Window)
 			{
 				LAssert(!_InLock);
 				_Window = w->_Window;
 				break;
 			}
 		}
 	}
 		
 	return dynamic_cast<LWindow*>(_Window);
 }
 
 bool LView::Lock(const char *file, int line, int TimeOut)
 {
 	#ifdef HAIKU
 
 		bool Debug = !Stricmp("LList", GetClass());
 		if (!d || !d->Hnd)
 		{
 			if (Debug)
 				printf("%s:%i - no handle %p %p\n", _FL, d, d ? d->Hnd : NULL);
 			return false;
 		}
 	
 		if (d->Hnd->Parent() == NULL)
 		{
 			if (Debug)
 				printf("%s:%p - Lock() no parent.\n", GetClass(), this);
 			return true;
 		}
 		
 		if (TimeOut >= 0)
 		{
 			auto r = d->Hnd->LockLooperWithTimeout(TimeOut * 1000);
 			if (r == B_OK)
 			{
 				_InLock++;
 				if (Debug)
 					printf("%s:%p - Lock() cnt=%i par=%p.\n", GetClass(), this, _InLock, d->Hnd->Parent());
 				return true;
 			}
 		
 			printf("%s:%i - Lock(%i) failed with %x.\n", _FL, TimeOut, r);
 			return false;
 		}
 	
 		auto r = d->Hnd->LockLooper();
 		if (r)
 		{
 			_InLock++;
 			
 			if (Debug)
 			{
 				auto w = WindowHandle();
 				printf("%s:%p - Lock() cnt=%i myThread=%i wndThread=%i.\n",
 					GetClass(),
 					this,
 					_InLock,
 					GetCurrentThreadId(),
 					w ? w->Thread() : -1);
 			}
 			return true;
 		}
 	
 		if (Debug)
 			printf("%s:%i - Lock(%s:%i) failed.\n", _FL, file, line);
 		return false;
 	#else
 		if (!_Window)
 			GetWindow();
 
 		_InLock++;
 		// LgiTrace("%s::%p Lock._InLock=%i %s:%i\n", GetClass(), this, _InLock, file, line);
 		if (_Window && _Window->_Lock)
 		{
 			if (TimeOut < 0)
 			{
 				return _Window->_Lock->Lock(file, line);
 			}
 			else
 			{
 				return _Window->_Lock->LockWithTimeout(TimeOut, file, line);
 			}
 		}
 
 		return true;
 	#endif
 }
 
 void LView::Unlock()
 {
 	#ifdef HAIKU
 		if (!d || !d->Hnd)
 		{
 			printf("%s:%i - Unlock() error, no hnd.\n", _FL);
 			return;
 		}
 	
 		if (!d->Hnd->Parent())
 		{
 			// printf("%s:%p - Unlock() no parent.\n", GetClass(), this);
 			return;
 		}
 	
 		if (_InLock > 0)
 		{
 			// printf("%s:%p - Calling UnlockLooper: %i.\n", GetClass(), this, _InLock);
 			d->Hnd->UnlockLooper();
 			_InLock--;
 			// printf("%s:%p - UnlockLooper done: %i.\n", GetClass(), this, _InLock);
 		}
 		else
 		{
 			printf("%s:%i - Unlock() without lock.\n", _FL);
 		}
 	#else
 		if (_Window &&
 			_Window->_Lock)
 		{
 			_Window->_Lock->Unlock();
 		}
 		_InLock--;
 		// LgiTrace("%s::%p Unlock._InLock=%i\n", GetClass(), this, _InLock);
 	#endif
 }
 
 void LView::OnMouseClick(LMouse &m)
 {
 }
 
 void LView::OnMouseEnter(LMouse &m)
 {
 }
 
 void LView::OnMouseExit(LMouse &m)
 {
 }
 
 void LView::OnMouseMove(LMouse &m)
 {
 }
 
 bool LView::OnMouseWheel(double Lines)
 {
 	return false;
 }
 
 bool LView::OnKey(LKey &k)
 {
 	return false;
 }
 
 void LView::OnAttach()
 {
 	List<LViewI>::I it = Children.begin();
 	for (LViewI *v = *it; v; v = *++it)
 	{
 		if (!v->GetParent())
 			v->SetParent(this);
 	}
 
 	#if 0 // defined __GTK_H__
 	if (_View && !DropTarget())
 	{
 		// If one of our parents is drop capable we need to set a dest here
 		LViewI *p;
 		for (p = GetParent(); p; p = p->GetParent())
 		{
 			if (p->DropTarget())
 			{
 				break;
 			}
 		}
 		if (p)
 		{
 			Gtk::gtk_drag_dest_set(	_View,
 									(Gtk::GtkDestDefaults)0,
 									NULL,
 									0,
 									Gtk::GDK_ACTION_DEFAULT);
 			// printf("%s:%i - Drop dest for '%s'\n", _FL, GetClass());
 		}
 		else
 		{
 			Gtk::gtk_drag_dest_unset(_View);
 			// printf("%s:%i - Not setting drop dest '%s'\n", _FL, GetClass());
 		}
 	}
 	#endif
 }
 
 void LView::OnCreate()
 {
 }
 
 void LView::OnDestroy()
 {
 }
 
 void LView::OnFocus(bool f)
 {
 	// printf("%s::OnFocus(%i)\n", GetClass(), f);
 }
 
 void LView::OnPulse()
 {
 }
 
 void LView::OnPosChange()
 {
 }
 
 bool LView::OnRequestClose(bool OsShuttingDown)
 {
 	return true;
 }
 
 int LView::OnHitTest(int x, int y)
 {
 	return -1;
 }
 
 void LView::OnChildrenChanged(LViewI *Wnd, bool Attaching)
 {
 }
 
 void LView::OnPaint(LSurface *pDC)
 {
 	auto c = GetClient();
 	LCssTools Tools(this);
 	Tools.PaintContent(pDC, c);
 }
 
 int LView::OnNotify(LViewI *Ctrl, LNotification Data)
 {
 	if (!Ctrl)
 		return 0;
 
 	if (Ctrl == (LViewI*)this && Data.Type == LNotifyActivate)
 	{
 		// Default activation is to focus the current control.
 		Focus(true);
 	}
 	else if (d && d->Parent)
 	{
 		// default behaviour is just to pass the 
 		// notification up to the parent
 
 		// FIXME: eventually we need to call the 'LNotification' parent fn...
 		return d->Parent->OnNotify(Ctrl, Data);
 	}
 
 	return 0;
 }
 
 int LView::OnCommand(int Cmd, int Event, OsView Wnd)
 {
 	return 0;
 }
 
 void LView::OnNcPaint(LSurface *pDC, LRect &r)
 {
 	int Border = Sunken() || Raised() ? _BorderSize : 0;
 	if (Border == 2)
 	{
 		LEdge e;
 		if (Sunken())
 			e = Focus() ? EdgeWin7FocusSunken : DefaultSunkenEdge;
 		else
 			e = DefaultRaisedEdge;
 
 		#if WINNATIVE
 		if (d->IsThemed)
 			DrawThemeBorder(pDC, r);
 		else
 		#endif
 			LWideBorder(pDC, r, e);
 	}
 	else if (Border == 1)
 	{
 		LThinBorder(pDC, r, Sunken() ? DefaultSunkenEdge : DefaultRaisedEdge);
 	}
 }
 
 #if LGI_COCOA || defined(__GTK_H__)
 
 	/*
 	uint64 nPaint = 0;
 	uint64 PaintTime = 0;
 	*/
 
 	void LView::_Paint(LSurface *pDC, LPoint *Offset, LRect *Update)
 	{
 		/*
 		uint64 StartTs = Update ? LCurrentTime() : 0;
 		d->InPaint = true;
 		*/
 
 		// Create temp DC if needed...
 		LAutoPtr<LSurface> Local;
 		if (!pDC)
 		{
 			if (!Local.Reset(new LScreenDC(this)))
 				return;
 			pDC = Local;
 		}
 
 		#if 0
 		// This is useful for coverage checking
 		pDC->Colour(LColour(255, 0, 255));
 		pDC->Rectangle();
 		#endif
 
 		// Non-Client drawing
 		LRect r;
 		if (Offset)
 		{
 			r = Pos;
 			r.Offset(Offset);
 		}
 		else
 		{
 			r = GetClient().ZeroTranslate();
 		}
 
 		pDC->SetClient(&r);
 		LRect zr1 = r.ZeroTranslate(), zr2 = zr1;
 		OnNcPaint(pDC, zr1);
 		pDC->SetClient(NULL);
 		if (zr2 != zr1)
 		{
 			r.x1 -= zr2.x1 - zr1.x1;
 			r.y1 -= zr2.y1 - zr1.y1;
 			r.x2 -= zr2.x2 - zr1.x2;
 			r.y2 -= zr2.y2 - zr1.y2;
 		}
 		LPoint o(r.x1, r.y1); // Origin of client
 
 		// Paint this view's contents...
 		pDC->SetClient(&r);
 
 		#if 0
 		if (_Debug)
 		{
 			#if defined(__GTK_H__)
 				Gtk::cairo_matrix_t matrix;
 				cairo_get_matrix(pDC->Handle(), &matrix);
 
 				double ex[4];
 				cairo_clip_extents(pDC->Handle(), ex+0, ex+1, ex+2, ex+3);
 				ex[0] += matrix.x0; ex[1] += matrix.y0; ex[2] += matrix.x0; ex[3] += matrix.y0;
 				LgiTrace("%s::_Paint, r=%s, clip=%g,%g,%g,%g - %g,%g\n",
 						GetClass(), r.GetStr(),
 						ex[0], ex[1], ex[2], ex[3],
 						matrix.x0, matrix.y0);
 			#elif LGI_COCOA
 				auto Ctx = pDC->Handle();
 				CGAffineTransform t = CGContextGetCTM(Ctx);
 				LRect cr = CGContextGetClipBoundingBox(Ctx);
 				printf("%s::_Paint() pos=%s transform=%g,%g,%g,%g-%g,%g clip=%s r=%s\n",
 						GetClass(),
 						GetPos().GetStr(),
 	  					t.a, t.b, t.c, t.d, t.tx, t.ty,
 						cr.GetStr(),
 						r.GetStr());
 			#endif
 		}
 		#endif
 
 		OnPaint(pDC);
 
 		pDC->SetClient(NULL);
 
 		// Paint all the children...
 		for (auto i : Children)
 		{
 			LView *w = i->GetGView();
 			if (w && w->Visible())
 			{
 				if (!w->Pos.Valid())
 					continue;
 
 				#if 0
 				if (w->_Debug)
 					LgiTrace("%s::_Paint %i,%i\n", w->GetClass(), o.x, o.y);
 				#endif
 				w->_Paint(pDC, &o);
 			}
 		}
 	}
 
 #else
 
 	void LView::_Paint(LSurface *pDC, LPoint *Offset, LRect *Update)
 	{
 		// Create temp DC if needed...
 		LAutoPtr<LSurface> Local;
 		if (!pDC)
 		{
 			Local.Reset(new LScreenDC(this));
 			pDC = Local;
 		}
 		if (!pDC)
 		{
 			printf("%s:%i - No context to draw in.\n", _FL);
 			return;
 		}
 
 		#if 0
 		// This is useful for coverage checking
 		pDC->Colour(LColour(255, 0, 255));
 		pDC->Rectangle();
 		#endif
 
 		bool HasClient = false;
 		LRect r(0, 0, Pos.X()-1, Pos.Y()-1), Client;
 		LPoint o;
 		if (Offset)
 			o = *Offset;
 
 		#if WINNATIVE
 		if (!_View)
 		#endif
 		{
 			// Non-Client drawing
 			Client = r;
 			OnNcPaint(pDC, Client);
 			HasClient = GetParent() && (Client != r);
 			if (HasClient)
 			{
 				Client.Offset(o.x, o.y);
 				pDC->SetClient(&Client);
 			}
 		}
 
 		r.Offset(o.x, o.y);
 
 		// Paint this view's contents
 		if (Update)
 		{
 			LRect OldClip = pDC->ClipRgn();
 			pDC->ClipRgn(Update);
 			OnPaint(pDC);
 			pDC->ClipRgn(OldClip.Valid() ? &OldClip : NULL);
 		}
 		else
 		{
 			OnPaint(pDC);
 		}
 
 		#if PAINT_VIRTUAL_CHILDREN
 		// Paint any virtual children
 		for (auto i : Children)
 		{
 			LView *w = i->GetGView();
 			if (w && w->Visible())
 			{
 				#if LGI_VIEW_HANDLE
 				if (!w->Handle())
 				#endif
 				{
 					LRect p = w->GetPos();
 					p.Offset(o.x, o.y);
 					if (HasClient)
 						p.Offset(Client.x1 - r.x1, Client.y1 - r.y1);
 					
 					LPoint co(p.x1, p.y1);
 					// LgiTrace("%s::_Paint %i,%i\n", w->GetClass(), p.x1, p.y1);
 					pDC->SetClient(&p);
 					w->_Paint(pDC, &co);
 					pDC->SetClient(NULL);
 				}
 			}
 		}
 		#endif
 
 		if (HasClient)
 			pDC->SetClient(0);
 	}
 
 #endif
 
 LViewI *LView::GetParent()
 {
 	ThreadCheck();
 	return d ? d->Parent : NULL;
 }
 
 void LView::SetParent(LViewI *p)
 {
 	ThreadCheck();
 	d->Parent = p ? p->GetGView() : NULL;
 	d->ParentI = p;
 }
 
 void LView::SendNotify(LNotification note)
 {
 	LViewI *n = d->Notify ? d->Notify : d->Parent;
 	if (n)
 	{
 		if (
 			#if LGI_VIEW_HANDLE && !defined(HAIKU)
 			!_View ||
 			#endif
 			InThread())
 		{
 			n->OnNotify(this, note);
 		}
 		else
 		{
 			// We are not in the same thread as the target window. So we post a message
 			// across to the view.
 			if (GetId() <= 0)
 			{
 				// We are going to generate a control Id to help the receiver of the
 				// M_CHANGE message find out view later on. The reason for doing this
 				// instead of sending a pointer to the object, is that the object 
 				// _could_ be deleted between the message being sent and being received.
 				// Which would result in an invalid memory access on that object.
 				LViewI *p = GetWindow();
 				if (!p)
 				{
 					// No window? Find the top most parent we can...
 					p = this;
 					while (p->GetParent())
 						p = p->GetParent();
 				}
 				if (p)
 				{
 					// Give the control a valid ID
 					int i;
 
 					for (i=10; i<1000; i++)
 					{
 						if (!p->FindControl(i))
 						{
 							printf("Giving the ctrl '%s' the id '%i' for SendNotify\n",
 								GetClass(),
 								i);
 							SetId(i);
 							break;
 						}
 					}
 				}
 				else
 				{
 					// Ok this is really bad... go random (better than nothing)
 					SetId(5000 + LRand(2000));
 				}
 			}
 			
             LAssert(GetId() > 0); // We must have a valid ctrl ID at this point, otherwise
 									// the receiver will never be able to find our object.
             
             // printf("Post M_CHANGE %i %i\n", GetId(), Data);
             n->PostEvent(M_CHANGE, (LMessage::Param) GetId(), (LMessage::Param) new LNotification(note));
 		}
 	}
 }
 
 LViewI *LView::GetNotify()
 {
 	ThreadCheck();
 	return d->Notify;
 }
 
 void LView::SetNotify(LViewI *p)
 {
 	ThreadCheck();
 	d->Notify = p;
 }
 
 #define ADJ_LEFT			1
 #define ADJ_RIGHT			2
 #define ADJ_UP				3
 #define ADJ_DOWN			4
 
 int IsAdjacent(LRect &a, LRect &b)
 {
 	if ( (a.x1 == b.x2 + 1) &&
 		!(a.y1 > b.y2 || a.y2 < b.y1))
 	{
 		return ADJ_LEFT;
 	}
 
 	if ( (a.x2 == b.x1 - 1) &&
 		!(a.y1 > b.y2 || a.y2 < b.y1))
 	{
 		return ADJ_RIGHT;
 	}
 
 	if ( (a.y1 == b.y2 + 1) &&
 		!(a.x1 > b.x2 || a.x2 < b.x1))
 	{
 		return ADJ_UP;
 	}
 
 	if ( (a.y2 == b.y1 - 1) &&
 		!(a.x1 > b.x2 || a.x2 < b.x1))
 	{
 		return ADJ_DOWN;
 	}
 
 	return 0;
 }
 
 LRect JoinAdjacent(LRect &a, LRect &b, int Adj)
 {
 	LRect t;
 
 	switch (Adj)
 	{
 		case ADJ_LEFT:
 		case ADJ_RIGHT:
 		{
 			t.y1 = MAX(a.y1, b.y1);
 			t.y2 = MIN(a.y2, b.y2);
 			t.x1 = MIN(a.x1, b.x1);
 			t.x2 = MAX(a.x2, b.x2);
 			break;
 		}
 		case ADJ_UP:
 		case ADJ_DOWN:
 		{
 			t.y1 = MIN(a.y1, b.y1);
 			t.y2 = MAX(a.y2, b.y2);
 			t.x1 = MAX(a.x1, b.x1);
 			t.x2 = MIN(a.x2, b.x2);
 			break;
 		}
 	}
 
 	return t;
 }
 
 LRect *LView::FindLargest(LRegion &r)
 {
 	ThreadCheck();
 
 	int Pixels = 0;
 	LRect *Best = 0;
 	static LRect Final;
 
 	// do initial run through the list to find largest single region
 	for (LRect *i = r.First(); i; i = r.Next())
 	{
 		int Pix = i->X() * i->Y();
 		if (Pix > Pixels)
 		{
 			Pixels = Pix;
 			Best = i;
 		}
 	}
 
 	if (Best)
 	{
 		Final = *Best;
 		Pixels = Final.X() * Final.Y();
 
 		int LastPixels = Pixels;
 		LRect LastRgn = Final;
 		int ThisPixels = Pixels;
 		LRect ThisRgn = Final;
 
 		LRegion TempList;
 		for (LRect *i = r.First(); i; i = r.Next())
 		{
 			TempList.Union(i);
 		}
 		TempList.Subtract(Best);
 
 		do
 		{
 			LastPixels = ThisPixels;
 			LastRgn = ThisRgn;
 
 			// search for adjoining rectangles that maybe we can add
 			for (LRect *i = TempList.First(); i; i = TempList.Next())
 			{
 				int Adj = IsAdjacent(ThisRgn, *i);
 				if (Adj)
 				{
 					LRect t = JoinAdjacent(ThisRgn, *i, Adj);
 					int Pix = t.X() * t.Y();
 					if (Pix > ThisPixels)
 					{
 						ThisPixels = Pix;
 						ThisRgn = t;
 
 						TempList.Subtract(i);
 					}
 				}
 			}
 		} while (LastPixels < ThisPixels);
 
 		Final = ThisRgn;
 	}
 	else return 0;
 
 	return &Final;
 }
 
 LRect *LView::FindSmallestFit(LRegion &r, int Sx, int Sy)
 {
 	ThreadCheck();
 
 	int X = 1000000;
 	int Y = 1000000;
 	LRect *Best = 0;
 
 	for (LRect *i = r.First(); i; i = r.Next())
 	{
 		if ((i->X() >= Sx && i->Y() >= Sy) &&
 			(i->X() < X || i->Y() < Y))
 		{
 			X = i->X();
 			Y = i->Y();
 			Best = i;
 		}
 	}
 
 	return Best;
 }
 
 LRect *LView::FindLargestEdge(LRegion &r, int Edge)
 {
 	LRect *Best = 0;
 	ThreadCheck();
 
 	for (LRect *i = r.First(); i; i = r.Next())
 	{
 		if (!Best)
 		{
 			Best = i;
 		}
 
 		if
 		(
 			((Edge & GV_EDGE_TOP) && (i->y1 < Best->y1))
 			||
 			((Edge & GV_EDGE_RIGHT) && (i->x2 > Best->x2))
 			||
 			((Edge & GV_EDGE_BOTTOM) && (i->y2 > Best->y2))
 			||
 			((Edge & GV_EDGE_LEFT) && (i->x1 < Best->x1))
 		)
 		{
 			Best = i;
 		}
 
 		if
 		(
 			(
 				((Edge & GV_EDGE_TOP) && (i->y1 == Best->y1))
 				||
 				((Edge & GV_EDGE_BOTTOM) && (i->y2 == Best->y2))
 			)
 			&&
 			(
 				i->X() > Best->X()
 			)
 		)
 		{
 			Best = i;
 		}
 
 		if
 		(
 			(
 				((Edge & GV_EDGE_RIGHT) && (i->x2 == Best->x2))
 				||
 				((Edge & GV_EDGE_LEFT) && (i->x1 == Best->x1))
 			)
 			&&
 			(
 				i->Y() > Best->Y()
 			)
 		)
 		{
 			Best = i;
 		}
 	}
 
 	return Best;
 }
 
 LViewI *LView::FindReal(LPoint *Offset)
 {
 	ThreadCheck();
 
 	if (Offset)
 	{
 		Offset->x = 0;
 		Offset->y = 0;
 	}
 
 	#if !LGI_VIEW_HANDLE
 	LViewI *w = GetWindow();
 	#endif
 	LViewI *p = d->Parent;
 	while (p &&
 		#if !LGI_VIEW_HANDLE
 		p != w
 		#else
 		!p->Handle()
 		#endif
 		)
 	{
 		if (Offset)
 		{
 			Offset->x += Pos.x1;
 			Offset->y += Pos.y1;
 		}
 
 		p = p->GetParent();
 	}
 	
 	if (p &&
 		#if !LGI_VIEW_HANDLE
 		p == w
 		#else
 		p->Handle()
 		#endif
 		)
 	{
 		return p;
 	}
 
 	return NULL;
 }
 
 bool LView::HandleCapture(LView *Wnd, bool c)
 {
 	ThreadCheck();
 	
 	DEBUG_CAPTURE("%s::HandleCapture(%i)=%i\n", GetClass(), c, (int)(_Capturing == Wnd));
 	if (c)
 	{
 		if (_Capturing == Wnd)
 		{
 			DEBUG_CAPTURE("    %s already has capture\n", _Capturing?_Capturing->GetClass():0);
 		}
 		else
 		{
 			DEBUG_CAPTURE("    _Capturing=%s -> %s\n", _Capturing?_Capturing->GetClass():0, Wnd?Wnd->GetClass():0);
 			_Capturing = Wnd;
 			
 			#if defined(__GTK_H__)
 			
 				if (d->CaptureThread)
 					d->CaptureThread->Cancel();
 				d->CaptureThread = new LCaptureThread(this);
 			
 			#elif WINNATIVE
 				
 				LPoint Offset;
 				LViewI *v = _Capturing->Handle() ? _Capturing : FindReal(&Offset);
 				HWND h = v ? v->Handle() : NULL;
 				if (h)
 					SetCapture(h);
 				else
 					LAssert(0);
 					
 			#elif defined(LGI_SDL)
 				
 				#if SDL_VERSION_ATLEAST(2, 0, 4)
 					SDL_CaptureMouse(SDL_TRUE);
 				#else
 					LAppInst->CaptureMouse(true);
 				#endif
 
 			#endif
 		}
 	}
 	else if (_Capturing)
 	{
 		DEBUG_CAPTURE("    _Capturing=%s -> NULL\n", _Capturing?_Capturing->GetClass():0);
 		_Capturing = NULL;
 		
 		#if defined(__GTK_H__)
 		
 			if (d->CaptureThread)
 			{
 				d->CaptureThread->Cancel();
 				d->CaptureThread = NULL; // It'll delete itself...
 			}
 		
 		#elif WINNATIVE
 
 			ReleaseCapture();
 
 		#elif defined(LGI_SDL)
 
 			#if SDL_VERSION_ATLEAST(2, 0, 4)
 				SDL_CaptureMouse(SDL_FALSE);
 			#else
 				LAppInst->CaptureMouse(false);
 			#endif
 
 		#endif
 	}
 
 	return true;
 }
 
 bool LView::IsCapturing()
 {
 	// DEBUG_CAPTURE("%s::IsCapturing()=%p==%p==%i\n", GetClass(), _Capturing, this, (int)(_Capturing == this));
 	return _Capturing == this;
 }
 
 bool LView::Capture(bool c)
 {
 	ThreadCheck();
 
 	DEBUG_CAPTURE("%s::Capture(%i)\n", GetClass(), c);
 	return HandleCapture(this, c);
 }
 
 bool LView::Enabled()
 {
 	ThreadCheck();
 
 	#if WINNATIVE
 	if (_View)
 		return IsWindowEnabled(_View) != 0;
 	#endif
 	
 	return !TestFlag(GViewFlags, GWF_DISABLED);
 }
 
 void LView::Enabled(bool i)
 {
 	ThreadCheck();
 
 	if (!i) SetFlag(GViewFlags, GWF_DISABLED);
 	else ClearFlag(GViewFlags, GWF_DISABLED);
 
 	#if LGI_VIEW_HANDLE && !defined(HAIKU)
 	if (_View)
 	{
 		#if WINNATIVE
 		EnableWindow(_View, i);
 		#elif defined LGI_CARBON
 		if (i)
 		{
 			OSStatus e = EnableControl(_View);
 			if (e) printf("%s:%i - Error enabling control (%i)\n", _FL, (int)e);
 		}
 		else
 		{
 			OSStatus e = DisableControl(_View);
 			if (e) printf("%s:%i - Error disabling control (%i)\n", _FL, (int)e);
 		}
 		#endif
 	}
 	#endif
 
 	Invalidate();
 }
 
 bool LView::Visible()
 {
 	// This is a read only operation... which is kinda thread-safe...
 	// ThreadCheck();
 
 	#if WINNATIVE
 
 	if (_View)
 
 	/*	This takes into account all the parent windows as well...
 		Which is kinda not what I want. I want this to reflect just
 		this window.
 		
 		return IsWindowVisible(_View);
 	*/
 		return (GetWindowLong(_View, GWL_STYLE) & WS_VISIBLE) != 0;	
 	
 	#endif
 
 	return TestFlag(GViewFlags, GWF_VISIBLE);
 }
 
 void LView::Visible(bool v)
 {
 	ThreadCheck();
 	
+	bool HasChanged = TestFlag(GViewFlags, GWF_VISIBLE) ^ v;
 	if (v) SetFlag(GViewFlags, GWF_VISIBLE);
 	else ClearFlag(GViewFlags, GWF_VISIBLE);
 
  	#if defined(HAIKU)
-	LLocker lck(d->Hnd, _FL);
-	if (!IsAttached() || lck.Lock())
-	{
-		const int attempts = 3;
-		// printf("%s/%p:Visible(%i) hidden=%i\n", GetClass(), this, v, d->Hnd->IsHidden());
-		if (v)
+		LLocker lck(d->Hnd, _FL);
+		if (!IsAttached() || lck.Lock())
 		{
-			bool parentHidden = false;
-			for (auto p = d->Hnd->Parent(); p; p = p->Parent())
+			const int attempts = 3;
+			// printf("%s/%p:Visible(%i) hidden=%i\n", GetClass(), this, v, d->Hnd->IsHidden());
+			if (v)
 			{
-				if (p->IsHidden())
+				bool parentHidden = false;
+				for (auto p = d->Hnd->Parent(); p; p = p->Parent())
+				{
+					if (p->IsHidden())
+					{
+						parentHidden = true;
+						break;
+					}
+				}
+				if (!parentHidden) // Don't try and show if one of the parent's is hidden.
 				{
-					parentHidden = true;
-					break;
+					for (int i=0; i<attempts && d->Hnd->IsHidden(); i++)
+					{
+						// printf("\t%p Show\n", this);
+						d->Hnd->Show();
+					}
+					if (d->Hnd->IsHidden())
+					{
+						printf("%s:%i - Failed to show %s.\n", _FL, GetClass());
+						for (auto p = d->Hnd->Parent(); p; p = p->Parent())
+							printf("\tparent: %s/%p ishidden=%i\n", p->Name(), p, p->IsHidden());
+					}
 				}
 			}
-			if (!parentHidden) // Don't try and show if one of the parent's is hidden.
+			else
 			{
-				for (int i=0; i<attempts && d->Hnd->IsHidden(); i++)
+				for (int i=0; i<attempts && !d->Hnd->IsHidden(); i++)
 				{
-					// printf("\t%p Show\n", this);
-					d->Hnd->Show();
+					// printf("\t%p Hide\n", this);
+					d->Hnd->Hide();
 				}
-				if (d->Hnd->IsHidden())
+				if (!d->Hnd->IsHidden())
 				{
-					printf("%s:%i - Failed to show %s.\n", _FL, GetClass());
+					printf("%s:%i - Failed to hide %s.\n", _FL, GetClass());
 					for (auto p = d->Hnd->Parent(); p; p = p->Parent())
 						printf("\tparent: %s/%p ishidden=%i\n", p->Name(), p, p->IsHidden());
 				}
 			}
+			// printf("\t%s/%p:Visible(%i) hidden=%i\n", GetClass(), this, v, d->Hnd->IsHidden());
+		}
+		else LgiTrace("%s:%i - Can't lock.\n", _FL);
+ 	#elif LGI_VIEW_HANDLE	
+		if (_View)
+		{
+			#if WINNATIVE
+
+				ShowWindow(_View, (v) ? SW_SHOWNORMAL : SW_HIDE);
+
+			#elif LGI_COCOA
+
+				LAutoPool Pool;
+				[_View.p setHidden:!v];
+
+			#elif LGI_CARBON
+			
+				Boolean is = HIViewIsVisible(_View);
+				if (v != is)
+				{
+					OSErr e = HIViewSetVisible(_View, v);
+					if (e) printf("%s:%i - HIViewSetVisible(%p,%i) failed with %i (class=%s)\n",
+									_FL, _View, v, e, GetClass());
+				}
+			
+			#endif
 		}
 		else
-		{
-			for (int i=0; i<attempts && !d->Hnd->IsHidden(); i++)
-			{
-				// printf("\t%p Hide\n", this);
-				d->Hnd->Hide();
-			}
-			if (!d->Hnd->IsHidden())
-			{
-				printf("%s:%i - Failed to hide %s.\n", _FL, GetClass());
-				for (auto p = d->Hnd->Parent(); p; p = p->Parent())
-					printf("\tparent: %s/%p ishidden=%i\n", p->Name(), p, p->IsHidden());
-			}
-		}
-		// printf("\t%s/%p:Visible(%i) hidden=%i\n", GetClass(), this, v, d->Hnd->IsHidden());
-	}
-	else LgiTrace("%s:%i - Can't lock.\n", _FL);
- 	#elif LGI_VIEW_HANDLE	
-	if (_View)
-	{
-		#if WINNATIVE
-
-			ShowWindow(_View, (v) ? SW_SHOWNORMAL : SW_HIDE);
-
-		#elif LGI_COCOA
-
-			LAutoPool Pool;
-			[_View.p setHidden:!v];
-
-		#elif LGI_CARBON
-		
-			Boolean is = HIViewIsVisible(_View);
-			if (v != is)
-			{
-				OSErr e = HIViewSetVisible(_View, v);
-				if (e) printf("%s:%i - HIViewSetVisible(%p,%i) failed with %i (class=%s)\n",
-								_FL, _View, v, e, GetClass());
-			}
-		
-		#endif
-	}
-	else
 	#endif
 	{
-		Invalidate();
+		if (HasChanged)
+			Invalidate();
 	}
 }
 
 bool LView::Focus()
 {
 	ThreadCheck();
 
 	bool Has = false;
 	
 	#if defined(__GTK_H__)
 	LWindow *w = GetWindow();
 	if (w)
 	{
 		bool Active = w->IsActive();
 		if (Active)
 			Has = w->GetFocus() == static_cast<LViewI*>(this);
 	}
 	#elif defined(HAIKU)
 	LLocker lck(d->Hnd, _FL);
 	if (lck.Lock())
 	{
 		Has = d->Hnd->IsFocus();
 		lck.Unlock();
 	}	
 	#elif defined(WINNATIVE)
 	if (_View)
 	{
 		HWND hFocus = GetFocus();
 		Has = hFocus == _View;
 	}
 	#elif LGI_COCOA
 	Has = TestFlag(WndFlags, GWF_FOCUS);
 	#elif LGI_CARBON
 	LWindow *w = GetWindow();
 	if (w)
 	{
 		ControlRef Cur;
 		OSErr e = GetKeyboardFocus(w->WindowHandle(), &Cur);
 		if (e)
 			LgiTrace("%s:%i - GetKeyboardFocus failed with %i\n", _FL, e);
 		else
 			Has = (Cur == _View);
 	}
   	#endif
 
 	#if !LGI_CARBON
 	if (Has)
 		SetFlag(WndFlags, GWF_FOCUS);
 	else
 		ClearFlag(WndFlags, GWF_FOCUS);
 	#endif
 	
 	return Has;
 }
 
 void LView::Focus(bool i)
 {
 	ThreadCheck();
 
 	if (i)
 		SetFlag(WndFlags, GWF_FOCUS);
 	else
 		ClearFlag(WndFlags, GWF_FOCUS);
 
 	auto *Wnd = GetWindow();
 	if (Wnd)
 	{
 		Wnd->SetFocus(this, i ? LWindow::GainFocus : LWindow::LoseFocus);
 	}
 
 	#if LGI_VIEW_HANDLE && !defined(HAIKU)
 	if (_View)
 	#endif
 	{
 		#if defined(HAIKU)
 		
 			_Focus(i);
 		
 		#elif defined(LGI_SDL) || defined(__GTK_H__)
 		
 			// Nop: Focus is all handled by Lgi's LWindow class.
 		
 		#elif WINNATIVE
 
 			if (i)
 			{
 
 				HWND hCur = GetFocus();
 				if (hCur != _View)
 				{
 					if (In_SetWindowPos)
 					{
 						assert(0);
 						LgiTrace("%s:%i - SetFocus %p (%-30s)\n", _FL, Handle(), Name());
 					}
 
 					SetFocus(_View);
 				}
 			}
 			else
 			{
 				if (In_SetWindowPos)
 				{
 					assert(0);
 					LgiTrace("%s:%i - SetFocus(%p)\n", _FL, GetDesktopWindow());
 				}
 
 				SetFocus(GetDesktopWindow());
 			}
 
 		#elif defined LGI_CARBON
 		
 			LViewI *Wnd = GetWindow();
 			if (Wnd && i)
 			{
 				OSErr e = SetKeyboardFocus(Wnd->WindowHandle(), _View, 1);
 				if (e)
 				{
 					// e = SetKeyboardFocus(Wnd->WindowHandle(), _View, kControlFocusNextPart);
 					// if (e)
 					{
 						HIViewRef p = HIViewGetSuperview(_View);
 						// errCouldntSetFocus
 						printf("%s:%i - SetKeyboardFocus failed: %i (%s, %p)\n", _FL, e, GetClass(), p);
 					}
 				}
 				// else printf("%s:%i - SetFocus v=%p(%s)\n", _FL, _View, GetClass());
 			}
 			else printf("%s:%i - no window?\n", _FL);
 		
 		#endif
 	}
 }
 
 LDragDropSource *LView::DropSource(LDragDropSource *Set)
 {
 	if (Set)
 		d->DropSource = Set;
 
 	return d->DropSource;
 }
 
 LDragDropTarget *LView::DropTarget(LDragDropTarget *Set)
 {
 	if (Set)
 		d->DropTarget = Set;
 
 	return d->DropTarget;
 }
 
 #if defined LGI_CARBON
 extern pascal OSStatus LgiViewDndHandler(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData);
 #endif
 
 #if defined __GTK_H__
 // Recursively add drag dest to all view and all children
 bool GtkAddDragDest(LViewI *v, bool IsTarget)
 {
 	if (!v) return false;
 	LWindow *w = v->GetWindow();
 	if (!w) return false;
 	auto wid = GtkCast(w->WindowHandle(), gtk_widget, GtkWidget);
 
 	if (IsTarget)
 	{
 		Gtk::gtk_drag_dest_set(	wid,
 								(Gtk::GtkDestDefaults)0,
 								NULL,
 								0,
 								Gtk::GDK_ACTION_DEFAULT);
 	}
 	else
 	{
 		Gtk::gtk_drag_dest_unset(wid);
 	}
 	
 	for (LViewI *c: v->IterateViews())
 		GtkAddDragDest(c, IsTarget);
 	
 	return true;
 }
 #endif
 
 bool LView::DropTarget(bool t)
 {
 	ThreadCheck();
 
 	bool Status = false;
 
 	if (t) SetFlag(GViewFlags, GWF_DROP_TARGET);
 	else ClearFlag(GViewFlags, GWF_DROP_TARGET);
 
 	#if WINNATIVE
 	
 		if (_View)
 		{
 			if (t)
 			{
 				if (!d->DropTarget)
 					DragAcceptFiles(_View, t);
 				else
 					Status = RegisterDragDrop(_View, (IDropTarget*) d->DropTarget) == S_OK;
 			}
 			else
 			{
 				if (_View && d->DropTarget)
 					Status = RevokeDragDrop(_View) == S_OK;
 			}
 		}
 
 	#elif defined MAC && !defined(LGI_SDL)
 
 		LWindow *Wnd = dynamic_cast<LWindow*>(GetWindow());
 		if (Wnd)
 		{
 			Wnd->SetDragHandlers(t);
 			if (!d->DropTarget)
 				d->DropTarget = t ? Wnd : 0;
 		}
 
 		#if LGI_COCOA
 
 			LWindow *w = GetWindow();
 			if (w)
 			{
 				OsWindow h = w->WindowHandle();
 				if (h)
 				{
 					NSMutableArray<NSString*> *a = [[NSMutableArray<NSString*> alloc] init];
 					if (a)
 					{
 						[a addObject:(NSString*)kUTTypeItem];
 						for (id item in NSFilePromiseReceiver.readableDraggedTypes)
 							[a addObject:item];
 						
 						[h.p.contentView registerForDraggedTypes:a];
 						[a release];
 					}
 				}
 			}
 
 		#elif LGI_CARBON
 	
 			if (t)
 			{
 				static EventTypeSpec DragEvents[] =
 				{
 					{ kEventClassControl, kEventControlDragEnter },
 					{ kEventClassControl, kEventControlDragWithin },
 					{ kEventClassControl, kEventControlDragLeave },
 					{ kEventClassControl, kEventControlDragReceive },
 				};
 				
 				if (!d->DndHandler)
 				{
 					OSStatus e = ::InstallControlEventHandler(	_View,
 																NewEventHandlerUPP(LgiViewDndHandler),
 																GetEventTypeCount(DragEvents),
 																DragEvents,
 																(void*)this,
 																&d->DndHandler);
 					if (e) LgiTrace("%s:%i - InstallEventHandler failed (%i)\n", _FL, e);
 				}
 				SetControlDragTrackingEnabled(_View, true);
 			}
 			else
 			{
 				SetControlDragTrackingEnabled(_View, false);
 			}
 	
 		#endif
 
 	#elif defined __GTK_H__
 
 		Status = GtkAddDragDest(this, t);
 		if (Status && !d->DropTarget)
 			d->DropTarget = t ? GetWindow() : 0;
 
 	#endif
 
 	return Status;
 }
 
 bool LView::Sunken()
 {
 	// ThreadCheck();
 
 	#if WINNATIVE
 	return TestFlag(d->WndExStyle, WS_EX_CLIENTEDGE);
 	#else
 	return TestFlag(GViewFlags, GWF_SUNKEN);
 	#endif
 }
 
 void LView::Sunken(bool i)
 {
 	ThreadCheck();
 
 	#if WINNATIVE
 	if (i) SetFlag(d->WndExStyle, WS_EX_CLIENTEDGE);
 	else ClearFlag(d->WndExStyle, WS_EX_CLIENTEDGE);
 	if (_View)
 	    SetWindowLong(_View, GWL_EXSTYLE, d->WndExStyle);
 	#else
 	if (i) SetFlag(GViewFlags, GWF_SUNKEN);
 	else ClearFlag(GViewFlags, GWF_SUNKEN);
 	#endif
 
 	if (i)
 	{
 		if (!_BorderSize)
 			_BorderSize = 2;
 	}
 	else _BorderSize = 0;
 }
 
 bool LView::Flat()
 {
 	// ThreadCheck();
 
 	#if WINNATIVE
 	return	!TestFlag(d->WndExStyle, WS_EX_CLIENTEDGE) &&
 			!TestFlag(d->WndExStyle, WS_EX_WINDOWEDGE);
 	#else
 	return !TestFlag(GViewFlags, GWF_SUNKEN) &&
 		   !TestFlag(GViewFlags, GWF_RAISED);
 	#endif
 }
 
 void LView::Flat(bool i)
 {
 	ThreadCheck();
 	
 	#if WINNATIVE
 	ClearFlag(d->WndExStyle, (WS_EX_CLIENTEDGE|WS_EX_WINDOWEDGE));
 	#else
 	ClearFlag(GViewFlags, (GWF_RAISED|GWF_SUNKEN));
 	#endif
 }
 
 bool LView::Raised()
 {
 	// ThreadCheck();
 	
 	#if WINNATIVE
 	return TestFlag(d->WndExStyle, WS_EX_WINDOWEDGE);
 	#else
 	return TestFlag(GViewFlags, GWF_RAISED);
 	#endif
 }
 
 void LView::Raised(bool i)
 {
 	ThreadCheck();
 
 	#if WINNATIVE
 	if (i) SetFlag(d->WndExStyle, WS_EX_WINDOWEDGE);
 	else ClearFlag(d->WndExStyle, WS_EX_WINDOWEDGE);
 	#else
 	if (i) SetFlag(GViewFlags, GWF_RAISED);
 	else ClearFlag(GViewFlags, GWF_RAISED);
 	#endif
 
 	if (i)
 	{
 		if (!!_BorderSize)
 			_BorderSize = 2;
 	}
 	else _BorderSize = 0;
 }
 
 int LView::GetId()
 {
 	// This is needed by SendNotify function which is thread safe.
 	// So no thread safety check here.
 	return d->CtrlId;
 }
 
 void LView::SetId(int i)
 {
 	// This is needed by SendNotify function which is thread safe.
 	// So no thread safety check here.
 	d->CtrlId = i;
 
 	#if WINNATIVE
 	if (_View)
 		SetWindowLong(_View, GWL_ID, d->CtrlId);
 	#elif defined __GTK_H__
 	#elif defined MAC
 	#endif
 }
 
 bool LView::GetTabStop()
 {
 	ThreadCheck();
 
 	#if WINNATIVE
 	return TestFlag(d->WndStyle, WS_TABSTOP);
 	#else
 	return d->TabStop;
 	#endif
 }
 
 void LView::SetTabStop(bool b)
 {
 	ThreadCheck();
 
 	#if WINNATIVE
 		if (b)
 			SetFlag(d->WndStyle, WS_TABSTOP);
 		else
 			ClearFlag(d->WndStyle, WS_TABSTOP);
 	#else
 		d->TabStop = b;
 	#endif
 }
 
 int64 LView::GetCtrlValue(int Id)
 {
 	ThreadCheck();
 
 	LViewI *w = FindControl(Id);
 	return (w) ? w->Value() : 0;
 }
 
 void LView::SetCtrlValue(int Id, int64 i)
 {
 	ThreadCheck();
 
 	LViewI *w = FindControl(Id);
 	if (w) w->Value(i);
 }
 
 const char *LView::GetCtrlName(int Id)
 {
 	ThreadCheck();
 
 	LViewI *w = FindControl(Id);
 	return (w) ? w->Name() : 0;
 }
 
 void LView::SetCtrlName(int Id, const char *s)
 {
 	if (!IsAttached() || InThread())
 	{
 		if (auto w = FindControl(Id))
 			w->Name(s);
 	}
 	else
 	{
 		PostEvent(	M_SET_CTRL_NAME,
 					(LMessage::Param)Id,
 					(LMessage::Param)new LString(s));
 	}
 }
 
 bool LView::GetCtrlEnabled(int Id)
 {
 	ThreadCheck();
 
 	LViewI *w = FindControl(Id);
 	return (w) ? w->Enabled() : 0;
 }
 
 void LView::SetCtrlEnabled(int Id, bool Enabled)
 {
 	if (!IsAttached() || InThread())
 	{
 		if (auto w = FindControl(Id))
 			w->Enabled(Enabled);
 	}
 	else
 	{
 		PostEvent(	M_SET_CTRL_ENABLE,
 					(LMessage::Param)Id,
 					(LMessage::Param)Enabled);
 	}
 }
 
 bool LView::GetCtrlVisible(int Id)
 {
 	ThreadCheck();
 
 	LViewI *w = FindControl(Id);
 	if (!w)
 		LgiTrace("%s:%i - Ctrl %i not found.\n", _FL, Id);
 	return (w) ? w->Visible() : 0;
 }
 
 void LView::SetCtrlVisible(int Id, bool v)
 {
 	if (!IsAttached() || InThread())
 	{
 		if (auto w = FindControl(Id))
 			w->Visible(v);
 	}
 	else
 	{
 		PostEvent(	M_SET_CTRL_VISIBLE,
 					(LMessage::Param)Id,
 					(LMessage::Param)v);
 	}
 }
 
 bool LView::AttachChildren()
 {
 	for (auto c: Children)
 	{
 		bool a = c->IsAttached();
 		if (!a)
 		{
 			if (!c->Attach(this))
 			{
 				LgiTrace("%s:%i - failed to attach %s\n", _FL, c->GetClass());
 				return false;
 			}
 		}
 	}
 
 	return true;
 }
 
 LFont *LView::GetFont()
 {
 	if (!d->Font &&
 		d->Css &&
 		LResources::GetLoadStyles())
 	{
 		LFontCache *fc = LAppInst->GetFontCache();
 		if (fc)
 		{
 			LFont *f = fc->GetFont(d->Css);
 			if (f)
 			{
 				if (d->FontOwnType == GV_FontOwned)
 					DeleteObj(d->Font);
 				d->Font = f;
 				d->FontOwnType = GV_FontCached;
 			}
 		}
 	}
 	
 	return d->Font ? d->Font : LSysFont;
 }
 
 void LView::SetFont(LFont *Font, bool OwnIt)
 {
 	bool Change = d->Font != Font;
 	if (Change)
 	{
 		if (d->FontOwnType == GV_FontOwned)
 		{
 			LAssert(d->Font != LSysFont);
 			DeleteObj(d->Font);
 		}
 
 		d->FontOwnType = OwnIt ? GV_FontOwned : GV_FontPtr;
 		d->Font = Font;
 
 		#if WINNATIVE
 		if (_View)
 			SendMessage(_View, WM_SETFONT, (WPARAM) (Font ? Font->Handle() : 0), 0);
 		#endif
 
 		for (LViewI *p = GetParent(); p; p = p->GetParent())
 		{
 			LTableLayout *Tl = dynamic_cast<LTableLayout*>(p);
 			if (Tl)
 			{
 				Tl->InvalidateLayout();
 				break;
 			}
 		}
 
 		Invalidate();
 	}
 }
 
 bool LView::IsOver(LMouse &m)
 {
 	return	(m.x >= 0) &&
 			(m.y >= 0) &&
 			(m.x < Pos.X()) &&
 			(m.y < Pos.Y());
 }
 
 bool LView::WindowVirtualOffset(LPoint *Offset)
 {
 	bool Status = false;
 
 	if (Offset)
 	{
 		Offset->x = 0;
 		Offset->y = 0;
 		
 		for (LViewI *Wnd = this; Wnd; Wnd = Wnd->GetParent())
 		{
 			#if !LGI_VIEW_HANDLE
 			auto IsWnd = dynamic_cast<LWindow*>(Wnd);
 			if (!IsWnd)
 			#else
 			if (!Wnd->Handle())
 			#endif
 			{
 				LRect r = Wnd->GetPos();
 				LViewI *Par = Wnd->GetParent();
 				if (Par)
 				{
 					LRect c = Par->GetClient(false);
 					Offset->x += r.x1 + c.x1;
 					Offset->y += r.y1 + c.y1;
 				}
 				else
 				{
 					Offset->x += r.x1;
 					Offset->y += r.y1;
 				}
 
 				Status = true;
 			}
 			else break;
 		}
 	}
 
 	return Status;
 }
 
 LString _ViewDesc(LViewI *v)
 {
 	LString s;
 	s.Printf("%s/%s/%i", v->GetClass(), v->Name(), v->GetId());
 	return s;
 }
 
 LViewI *LView::WindowFromPoint(int x, int y, int DebugDepth)
 {
 	char Tabs[64];
 	if (DebugDepth)
 	{
 		memset(Tabs, 9, DebugDepth);
 		Tabs[DebugDepth] = 0;
 		LgiTrace("%s%s %i\n", Tabs, _ViewDesc(this).Get(), Children.Length());
 	}
 
 	// We iterate over the child in reverse order because if they overlap the
 	// end of the list is on "top". So they should get the click or whatever
 	// before the the lower windows.
 	auto it = Children.rbegin();
 	int n = (int)Children.Length() - 1;
 	for (LViewI *c = *it; c; c = *--it)
 	{
 		LRect CPos = c->GetPos();
 		
 		if (CPos.Overlap(x, y) && c->Visible())
 		{
 			LRect CClient;
 			CClient = c->GetClient(false);
 
             int Ox = CPos.x1 + CClient.x1;
             int Oy = CPos.y1 + CClient.y1;
 			if (DebugDepth)
 			{
 				LgiTrace("%s[%i] %s Pos=%s Client=%s m(%i,%i)->(%i,%i)\n",
 						Tabs, n--,
 						_ViewDesc(c).Get(),
 						CPos.GetStr(),
 						CClient.GetStr(),
 						x, y,
 						x - Ox, y - Oy);
 			}
 
 			LViewI *Child = c->WindowFromPoint(x - Ox, y - Oy, DebugDepth ? DebugDepth  + 1 : 0);
 			if (Child)
 				return Child;
 		}
 		else if (DebugDepth)
 		{
 			LgiTrace("%s[%i] MISSED %s Pos=%s m(%i,%i)\n", Tabs, n--, _ViewDesc(c).Get(), CPos.GetStr(), x, y);
 		}
 	}
 
 	if (x >= 0 && y >= 0 && x < Pos.X() && y < Pos.Y())
 	{
 		return this;
 	}
 
 	return NULL;
 }
 
 LColour LView::StyleColour(int CssPropType, LColour Default, int Depth)
 {
 	LColour c = Default;
 
 	if ((CssPropType >> 8) == LCss::TypeColor)
 	{
 		LViewI *v = this;
 		for (int i=0; v && i<Depth; i++, v = v->GetParent())
 		{
 			auto Style = v->GetCss();
 			if (Style)
 			{
 				auto Colour = (LCss::ColorDef*) Style->PropAddress((LCss::PropType)CssPropType);
 				if (Colour)
 				{
 					if (Colour->Type == LCss::ColorRgb)
 					{
 						c.Set(Colour->Rgb32, 32);
 						break;
 					}
 					else if (Colour->Type == LCss::ColorTransparent)
 					{
 						c.Empty();
 						break;
 					}
 				}
 			}
 			
 			if (dynamic_cast<LWindow*>(v) ||
 				dynamic_cast<LPopup*>(v))
 				break;
 		}
 	}
 	
 	return c;
 }
 
 bool LView::InThread()
 {
 	#if WINNATIVE
 
 		HWND Hnd = _View;
 		for (LViewI *p = GetParent(); p && !Hnd; p = p->GetParent())
 		{
 			Hnd = p->Handle();
 		}
 		
 		auto CurThreadId = GetCurrentThreadId();
 		auto GuiThreadId = LAppInst->GetGuiThreadId();
 		DWORD ViewThread = Hnd ? GetWindowThreadProcessId(Hnd, NULL) : GuiThreadId;
 		return CurThreadId == ViewThread;
 	
 	#elif defined(HAIKU)
 
 		return true;
 
 	#else
 
 		OsThreadId Me = GetCurrentThreadId();
 		OsThreadId Gui = LAppInst ? LAppInst->GetGuiThreadId() : 0;
 		
 		#if 0
 		if (Gui != Me)
 		    LgiTrace("%s:%i - Out of thread:"
 				    #ifdef LGI_COCOA
 					"%llx, %llx"
 				    #else
 					"%x, %x"
 					#endif
 		    		"\n", _FL, Gui, Me);
 		#endif
 		
 		return Gui == Me;
 
 	#endif
 }
 
 bool LView::PostEvent(int Cmd, LMessage::Param a, LMessage::Param b, int64_t timeoutMs)
 {
 	#ifdef LGI_SDL
 
 		return LPostEvent(this, Cmd, a, b);
 
 	#elif defined(HAIKU)
 
 		if (!d || !d->Hnd)
 		{
 			// printf("%s:%i - Bad pointers %p %p\n", _FL, d, d ? d->Hnd : NULL);
 			return false;
 		}
 		
 		BWindow *bWnd = NULL;
 		LWindow *wnd = dynamic_cast<LWindow*>(this);
 		if (wnd)
 		{
 			bWnd = wnd->WindowHandle();
 		}
 		else
 		{
 			// Look for an attached view to lock...
 			for (LViewI *v = this; v; v = v->GetParent())
 			{
 				auto vhnd = v->Handle();
 				if (vhnd && ::IsAttached(vhnd))
 				{
 					bWnd = vhnd->Window();
 					break;
 				}
 			}
  		}
 
 		BMessage m(Cmd);
 		
 		auto r = m.AddInt64(LMessage::PropA, a);
 		if (r != B_OK)
 			printf("%s:%i - AddUInt64 failed.\n", _FL);
 		r = m.AddInt64(LMessage::PropB, b);
 		if (r != B_OK)
 			printf("%s:%i - AddUInt64 failed.\n", _FL);
 		r = m.AddPointer(LMessage::PropView, this);
 		if (r != B_OK)
 			printf("%s:%i - AddPointer failed.\n", _FL);
 
 		if (bWnd)
 		{
 			r = bWnd->PostMessage(&m);
 			if (r != B_OK)
 				printf("%s:%i - PostMessage failed.\n", _FL);				
 
 			return r == B_OK;
 		}
 
 		// Not attached yet...
 		d->MsgQue.Add(new BMessage(m));
 		// printf("%s:%i - PostEvent.MsgQue=%i\n", _FL, (int)d->MsgQue.Length());
 		
 		return true;
 
 	#elif WINNATIVE
 
 		if (!_View)
 			return false;
 
 		BOOL Res = ::PostMessage(_View, Cmd, a, b);
 		if (!Res)
 		{
 			auto Err = GetLastError();
 			int asd=0;
 		}
 
 		return Res != 0;
 
 	#elif !LGI_VIEW_HANDLE
 
 		return LAppInst->PostEvent(this, Cmd, a, b);
 
 	#else
 
 		if (_View)
 			return LPostEvent(_View, Cmd, a, b);
 
 		LAssert(0);
 		return false;
 
 	#endif
 }
 
 bool LView::Invalidate(LRegion *r, bool Repaint, bool NonClient)
 {
 	if (r)
 	{
 		for (int i=0; i<r->Length(); i++)
 		{
 			bool Last = i == r->Length()-1;
 			Invalidate((*r)[i], Last ? Repaint : false, NonClient);
 		}
 		
 		return true;
 	}
 	
 	return false;
 }
 
 LButton *FindDefault(LViewI *w)
 {
 	LButton *But = 0;
 
 	for (auto c: w->IterateViews())
 	{
 		But = dynamic_cast<LButton*>(c);
 		if (But && But->Default())
 		{
 			break;
 		}
 			
 		But = FindDefault(c);
 		if (But)
 		{
 			break;
 		}
 	}
 
 	return But;
 }
 
 bool LView::Name(const char *n)
 {
 	LBase::Name(n);
 
 	#if LGI_VIEW_HANDLE && !defined(HAIKU)
 	if (_View)
 	{
 		#if WINNATIVE
 		
 		auto Temp = LBase::NameW();
 		SetWindowTextW(_View, Temp ? Temp : L"");
 		
 		#endif
 	}
 	#endif
 
 	Invalidate();
 
 	return true;
 }
 
 const char *LView::Name()
 {
 	#if WINNATIVE
 	if (_View)
 	{
 		LView::NameW();
 	}
 	#endif
 
 	return LBase::Name();
 }
 
 bool LView::NameW(const char16 *n)
 {
 	LBase::NameW(n);
 
 	#if WINNATIVE
 	if (_View && n)
 	{
 		auto Txt = LBase::NameW();
 		SetWindowTextW(_View, Txt);
 	}
 	#endif
 
 	Invalidate();
 	return true;
 }
 
 const char16 *LView::NameW()
 {
 	#if WINNATIVE
 	if (_View)
 	{
 		int Length = GetWindowTextLengthW(_View);
 		if (Length > 0)
 		{
 			char16 *Buf = new char16[Length+1];
 			if (Buf)
 			{
 				Buf[0] = 0;
 				int Chars = GetWindowTextW(_View, Buf, Length+1);
 				Buf[Chars] = 0;
 				LBase::NameW(Buf);
 			}
 			DeleteArray(Buf);
 		}
 		else
 		{
 			LBase::NameW(0);
 		}
 	}
 	#endif
 
 	return LBase::NameW();
 }
 
 LViewI *LView::FindControl(int Id)
 {
 	LAssert(Id != -1);
 
 	if (GetId() == Id)
 	{
 		return this;
 	}
 
 	for (auto c : Children)
 	{
 		LViewI *Ctrl = c->FindControl(Id);
 		if (Ctrl)
 		{
 			return Ctrl;
 		}
 	}
 	return 0;
 }
 
 LPoint LView::GetMinimumSize()
 {
 	return d->MinimumSize;
 }
 
 void LView::SetMinimumSize(LPoint Size)
 {
 	d->MinimumSize = Size;
 
 	bool Change = false;
 	LRect p = Pos;
 	if (X() < d->MinimumSize.x)
 	{
 		p.x2 = p.x1 + d->MinimumSize.x - 1;
 		Change = true;
 	}
 	if (Y() < d->MinimumSize.y)
 	{
 		p.y2 = p.y1 + d->MinimumSize.y - 1;
 		Change = true;
 	}
 	if (Change)
 	{
 		SetPos(p);
 	}
 }
 
 bool LView::SetColour(LColour &c, bool Fore)
 {
 	LCss *css = GetCss(true);
 	if (!css)
 		return false;
 	
 	if (Fore)
 	{
 		if (c.IsValid())
 			css->Color(LCss::ColorDef(LCss::ColorRgb, c.c32()));
 		else
 			css->DeleteProp(LCss::PropColor);
 	}
 	else
 	{
 		if (c.IsValid())
 			css->BackgroundColor(LCss::ColorDef(LCss::ColorRgb, c.c32()));
 		else
 			css->DeleteProp(LCss::PropBackgroundColor);
 	}
 	
 	return true;
 }
 
 
 /*
 bool LView::SetCssStyle(const char *CssStyle)
 {
     if (!d->Css && !d->Css.Reset(new LCss))
 		return false;
     
     const char *Defs = CssStyle;
     bool b = d->Css->Parse(Defs, LCss::ParseRelaxed);
     if (b && d->FontOwnType == GV_FontCached)
     {
 		d->Font = NULL;
 		d->FontOwnType = GV_FontPtr;
     }
     
     return b;    
 }
 */
 
 void LView::SetCss(LCss *css)
 {
 	d->Css.Reset(css);
 }
 
 LCss *LView::GetCss(bool Create)
 {
     if (Create && !d->Css)
         d->Css.Reset(new LCss);
 
 	if (d->CssDirty && d->Css)
 	{
 		const char *Defs = d->Styles;
 		if (d->Css->Parse(Defs, LCss::ParseRelaxed))
 			d->CssDirty = false;
 	}
 
     return d->Css;
 }
 
 LPoint &LView::GetWindowBorderSize()
 {
 	static LPoint s;
 
 	ZeroObj(s);
 
 	#if WINNATIVE
 	if (_View)
 	{
 		RECT Wnd, Client;
 		GetWindowRect(Handle(), &Wnd);
 		GetClientRect(Handle(), &Client);
 		s.x = (Wnd.right-Wnd.left) - (Client.right-Client.left);
 		s.y = (Wnd.bottom-Wnd.top) - (Client.bottom-Client.top);
 	}
 	#elif defined __GTK_H__
 	#elif defined MAC
 	s.x = 0;
 	s.y = 22;
 	#endif
 
 	return s;
 }
 
 #ifdef _DEBUG
 
 #if defined(LGI_CARBON)
 
 	void DumpHiview(HIViewRef v, int Depth = 0)
 	{
 		char Sp[256];
 		memset(Sp, ' ', Depth << 2);
 		Sp[Depth<<2] = 0;
 
 		printf("%sHIView=%p", Sp, v);
 		if (v)
 		{
 			Boolean vis = HIViewIsVisible(v);
 			Boolean en = HIViewIsEnabled(v, NULL);
 			HIRect pos;
 			HIViewGetFrame(v, &pos);
 
 			char cls[128];
 			ZeroObj(cls);
 			GetControlProperty(v, 'meme', 'clas', sizeof(cls), NULL, cls);
 
 			printf(" vis=%i en=%i pos=%g,%g-%g,%g cls=%s",
 				vis, en,
 				pos.origin.x, pos.origin.y, pos.size.width, pos.size.height,
 				cls);
 		}
 		printf("\n");
 
 		for (HIViewRef c = HIViewGetFirstSubview(v); c; c = HIViewGetNextView(c))
 		{
 			DumpHiview(c, Depth + 1);
 		}
 	}
 
 #elif defined(__GTK_H__)
 
 	void DumpGtk(Gtk::GtkWidget *w, Gtk::gpointer Depth = NULL)
 	{
 		using namespace Gtk;
 		if (!w)
 			return;
 
 		char Sp[65] = {0};
 		if (Depth)
 			memset(Sp, ' ', *((int*)Depth)*2);
 
 		auto *Obj = G_OBJECT(w);
 		LViewI *View = (LViewI*) g_object_get_data(Obj, "LViewI");
 
 		GtkAllocation a;
 		gtk_widget_get_allocation(w, &a);
 		LgiTrace("%s%p(%s) = %i,%i-%i,%i\n", Sp, w, View?View->GetClass():G_OBJECT_TYPE_NAME(Obj), a.x, a.y, a.width, a.height);
 
 		if (GTK_IS_CONTAINER(w))
 		{
 			auto *c = GTK_CONTAINER(w);
 			if (c)
 			{
 				int Next = Depth ? *((int*)Depth)+1 : 1;
 				gtk_container_foreach(c, DumpGtk, &Next);
 			}
 		}
 	}
 
 #elif defined(HAIKU) || defined(WINDOWS)
 
 	template<typename T>
 	void _Dump(int Depth, T v)
 	{
 		LString Sp, Name;
 		Sp.Length(Depth<<1);
 		memset(Sp.Get(), ' ', Depth<<1);
 		Sp.Get()[Depth<<1] = 0;
 		
 		#if defined(HAIKU)
 			LRect Frame = v->Frame();
 			Name = v->Name();
 			bool IsHidden = v->IsHidden();
 		#else
 			RECT rc; GetWindowRect(v, &rc);
 			LRect Frame = rc;
 			wchar_t txt[256];
 			GetWindowTextW(v, txt, CountOf(txt));
 			Name = txt;
 			bool IsHidden = !(GetWindowLong(v, GWL_STYLE) & WS_VISIBLE);
 		#endif
 
 		LgiTrace("%s%p::%s frame=%s vis=%i\n",
 			Sp.Get(), v, Name.Get(), Frame.GetStr(), !IsHidden);
 
 		#if defined(HAIKU)
 		for (int32 i=0; i<v->CountChildren(); i++)
 			_Dump(Depth + 1, v->ChildAt(i));
 		#else
 		for (auto h = GetWindow(v, GW_CHILD); h; h = GetWindow(h, GW_HWNDNEXT))
 			_Dump(Depth + 1, h);
 		#endif
 	}
 
 #endif
 
 void LView::_Dump(int Depth)
 {
 	char Sp[65] = {0};
 	memset(Sp, ' ', Depth*2);
 	
 	#if 0
 	
 		char s[256];
 		sprintf_s(s, sizeof(s), "%s%p::%s %s (_View=%p)\n", Sp, this, GetClass(), GetPos().GetStr(), _View);
 		LgiTrace(s);
 		List<LViewI>::I i = Children.Start();
 		for (LViewI *c = *i; c; c = *++i)
 		{
 			LView *v = c->GetGView();
 			if (v)
 				v->_Dump(Depth+1);
 		}
 	
 	#elif defined(LGI_CARBON)
 	
 		DumpHiview(_View);
 
 	#elif defined(__GTK_H__)
 
 		// DumpGtk(_View);
 	
 	#elif !defined(MAC)
 	
 		#if defined(HAIKU)
 		LLocker lck(WindowHandle(), _FL);
 		if (lck.Lock())
 		#endif
 			::_Dump(0, WindowHandle());
 	
 	#endif
 }
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 static LArray<LViewFactory*> *AllFactories = NULL;
 #if defined(WIN32)
 static HANDLE FactoryEvent;
 #else
 static pthread_once_t FactoryOnce = PTHREAD_ONCE_INIT;
 static void GFactoryInitFactories()
 {
 	AllFactories = new LArray<LViewFactory*>;
 }
 #endif
 
 LViewFactory::LViewFactory()
 {
 	#if defined(WIN32)
 	char16 Name[64];
 	swprintf_s(Name, CountOf(Name), L"LgiFactoryEvent.%i", GetCurrentProcessId());
 	HANDLE h = CreateEventW(NULL, false, false, Name);
 	DWORD err = GetLastError();
 	if (err != ERROR_ALREADY_EXISTS)
 	{
 		FactoryEvent = h;
 		AllFactories = new LArray<LViewFactory*>;
 	}
 	else
 	{
 		LAssert(AllFactories != NULL);
 	}
 	#else
 	pthread_once(&FactoryOnce, GFactoryInitFactories);
 	#endif
 
 	if (AllFactories)
 		AllFactories->Add(this);
 }
 
 LViewFactory::~LViewFactory()
 {
 	if (AllFactories)
 	{
 		AllFactories->Delete(this);
 		if (AllFactories->Length() == 0)
 		{
 			DeleteObj(AllFactories);
 			#if defined(WIN32)
 			CloseHandle(FactoryEvent);
 			#endif
 		}
 	}
 }
 
 LView *LViewFactory::Create(const char *Class, LRect *Pos, const char *Text)
 {
 	if (ValidStr(Class) && AllFactories)
 	{
 		for (int i=0; i<AllFactories->Length(); i++)
 		{
 			LView *v = (*AllFactories)[i]->NewView(Class, Pos, Text);
 			if (v)
 			{
 				return v;
 			}
 		}
 	}
 
 	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 LView::ViewEventTarget::ViewEventTarget(LView *View, int Msg)
 {
 	LAssert(View != NULL);
 	view = View;
 	if (Msg)
 		Msgs.Add(Msg, true);
 	if (view)
 		view->d->EventTargets.Add(this);
 }
 
 LView::ViewEventTarget::~ViewEventTarget()
 {
 	if (view)
 		view->d->EventTargets.Delete(this);
 }
 
 bool LView::ViewEventTarget::PostEvent(int Cmd, LMessage::Param a, LMessage::Param b, int64_t TimeoutMs)
 {
 	if (view)
 		return view->PostEvent(Cmd, a, b, TimeoutMs);
 
 	return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 #ifdef _DEBUG
 
 #if defined(__GTK_H__)
 using namespace Gtk;
 #include "LgiWidget.h"
 #endif
 
 void LView::Debug()
 {
     _Debug = true;
 
 	#if defined LGI_COCOA
     d->ClassName = GetClass();
 	#endif
 }
 #endif
 
diff --git a/src/linux/Lgi/View.cpp b/src/linux/Lgi/View.cpp
--- a/src/linux/Lgi/View.cpp
+++ b/src/linux/Lgi/View.cpp
@@ -1,1122 +1,1150 @@
 /*hdr
 **      FILE:           LView.cpp
 **      AUTHOR:         Matthew Allen
 **      DATE:           23/4/98
 **      DESCRIPTION:    Linux LView Implementation
 **
 **      Copyright (C) 1998-2003, Matthew Allen
 **              fret@memecode.com
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DragAndDrop.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Popup.h"
 #include "lgi/common/Css.h"
 #include "lgi/common/EventTargetThread.h"
 #include "ViewPriv.h"
 
 using namespace Gtk;
 #include "LgiWidget.h"
 
 #define DEBUG_MOUSE_EVENTS			0
 
 #if 0
 #define DEBUG_INVALIDATE(...)		printf(__VA_ARGS__)
 #else
 #define DEBUG_INVALIDATE(...)
 #endif
 
 #define ADJ_LEFT					1
 #define ADJ_RIGHT					2
 #define ADJ_UP						3
 #define ADJ_DOWN					4
 
 #if GtkVer(2, 14)
 #else
 #define gtk_widget_get_window(widget) ((widget)->window)
 #endif
 
 struct CursorInfo
 {
 public:
 	LRect Pos;
 	LPoint HotSpot;
 }
 CursorMetrics[] =
 {
 	// up arrow
 	{ LRect(0, 0, 8, 15),			LPoint(4, 0) },
 	// cross hair
 	{ LRect(20, 0, 38, 18),			LPoint(29, 9) },
 	// hourglass
 	{ LRect(40, 0, 51, 15),			LPoint(45, 8) },
 	// I beam
 	{ LRect(60, 0, 66, 17),			LPoint(63, 8) },
 	// N-S arrow
 	{ LRect(80, 0, 91, 16),			LPoint(85, 8) },
 	// E-W arrow
 	{ LRect(100, 0, 116, 11),		LPoint(108, 5) },
 	// NW-SE arrow
 	{ LRect(120, 0, 132, 12),		LPoint(126, 6) },
 	// NE-SW arrow
 	{ LRect(140, 0, 152, 12),		LPoint(146, 6) },
 	// 4 way arrow
 	{ LRect(160, 0, 178, 18),		LPoint(169, 9) },
 	// Blank
 	{ LRect(0, 0, 0, 0),			LPoint(0, 0) },
 	// Vertical split
 	{ LRect(180, 0, 197, 16),		LPoint(188, 8) },
 	// Horizontal split
 	{ LRect(200, 0, 216, 17),		LPoint(208, 8) },
 	// Hand
 	{ LRect(220, 0, 233, 13),		LPoint(225, 0) },
 	// No drop
 	{ LRect(240, 0, 258, 18),		LPoint(249, 9) },
 	// Copy drop
 	{ LRect(260, 0, 279, 19),		LPoint(260, 0) },
 	// Move drop
 	{ LRect(280, 0, 299, 19),		LPoint(280, 0) },
 };
 
 // CursorData is a bitmap in an array of uint32's. This is generated from a graphics file:
 // ./Code/cursors.png
 //
 // The pixel values are turned into C code by a program called i.Mage:
 //	http://www.memecode.com/image.php
 //
 // Load the graphic into i.Mage and then go Edit->CopyAsCode
 // Then paste the text into the CursorData variable at the bottom of this file.
 //
 // This saves a lot of time finding and loading an external resouce, and even having to
 // bundle extra files with your application. Which have a tendancy to get lost along the
 // way etc.
 extern uint32_t CursorData[];
 LInlineBmp Cursors =
 {
 	300, 20, 8, CursorData
 };
 
 LCaptureThread *LViewPrivate::CaptureThread = NULL;
 
 ////////////////////////////////////////////////////////////////////////////
 void _lgi_yield()
 {
 	LAppInst->Yield();
 }
 
 bool LgiIsKeyDown(int Key)
 {
 	LAssert(0);
 	return false;
 }
 
 LKey::LKey(int vkey, uint32_t flags)
 {
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 LCaptureThread::LCaptureThread(LView *v) : LThread("CaptureThread")
 {
 	name = v->GetClass();
 	view = v->AddDispatch();
 	DeleteOnExit = true;
 	Run();
 }
 
 LCaptureThread::~LCaptureThread()
 {
 	Cancel();
 	// Don't wait.. the thread will exit and delete itself asnyronously.
 }
 
 int LCaptureThread::Main()
 {
 	while (!IsCancelled())
 	{
 		LSleep(EventMs);
 		if (!IsCancelled())
 			PostThreadEvent(view, M_CAPTURE_PULSE);
 	}
 	
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 LViewPrivate::LViewPrivate(LView *view) : View(view)
 {
 	PrevMouse.x = PrevMouse.y = -1;
 }
 
 LViewPrivate::~LViewPrivate()
 {
 	LAssert(PulseThread == 0);
 
 	if (Font && FontOwnType == GV_FontOwned)
 		DeleteObj(Font);
 }
 
 void LView::OnGtkRealize()
 {
 	if (!d->GotOnCreate)
 	{
 		d->GotOnCreate = true;
 		
 		if (d->WantsFocus)
 		{
 			d->WantsFocus = false;
 			if (GetWindow())
 				GetWindow()->SetFocus(this, LWindow::GainFocus);
 		}
 		
 		OnCreate();
 	}
 
 	for (auto c : Children)
 	{
 		auto gv = c->GetGView();
 		if (gv)
 			gv->OnGtkRealize();
 	}
 }
 
 void LView::_Focus(bool f)
 {
 	ThreadCheck();
 	
 	if (f)
 		SetFlag(WndFlags, GWF_FOCUS);
 	else
 		ClearFlag(WndFlags, GWF_FOCUS);
 
 	OnFocus(f);	
 	Invalidate();
 
 	if (f)
 	{
 		auto w = GetWindow();
 		if (w && w->_Root)
 			gtk_widget_grab_focus(w->_Root);
 		else
 			d->WantsFocus = f;
 	}
 }
 
 void LView::_Delete()
 {
 	ThreadCheck();
 	SetPulse();
 
 	// Remove static references to myself
 	if (_Over == this)
 		_Over = NULL;
 	if (_Capturing == this)
 		_Capturing = NULL;
 	
 	auto *Wnd = GetWindow();
 	if (Wnd && Wnd->GetFocus() == static_cast<LViewI*>(this))
 		Wnd->SetFocus(this, LWindow::ViewDelete);
 
 	if (LAppInst && LAppInst->AppWnd == this)
 		LAppInst->AppWnd = NULL;
 
 	// Hierarchy
 	LViewI *c;
 	while ((c = Children[0]))
 	{
 		if (c->GetParent() != (LViewI*)this)
 		{
 			printf("%s:%i - ~LView error, %s not attached correctly: %p(%s) Parent: %p(%s)\n",
 				_FL, c->GetClass(), c, c->Name(), c->GetParent(), c->GetParent() ? c->GetParent()->Name() : "");
 			Children.Delete(c);
 		}
 
 		DeleteObj(c);
 	}
 
 	Detach();
 
 	// Misc
 	Pos.ZOff(-1, -1);
 }
 
 LView *&LView::PopupChild()
 {
 	return d->Popup;
 }
 
 void LgiToGtkCursor(LViewI *v, LCursor c)
 {
 	static LCursor CurrentCursor = LCUR_Normal;
 
 	if (!v || c == CurrentCursor)
 		return;
 	
 	CurrentCursor = c;
 	GdkCursorType type = GDK_ARROW;
 	switch (c)
 	{
 		// No cursor
 		#ifdef GDK_BLANK_CURSOR
 		case LCUR_Blank:
 			type = GDK_BLANK_CURSOR;
 			break;
 		#endif
 		/// Normal arrow
 		case LCUR_Normal:
 			type = GDK_ARROW;
 			break;
 		/// Upwards arrow
 		case LCUR_UpArrow:
 			type = GDK_SB_UP_ARROW;
 			break;
 		/// Downwards arrow
 		case LCUR_DownArrow:
 			type = GDK_SB_DOWN_ARROW;
 			break;
 		/// Left arrow
 		case LCUR_LeftArrow:
 			type = GDK_SB_LEFT_ARROW;
 			break;
 		/// Right arrow
 		case LCUR_RightArrow:
 			type = GDK_SB_RIGHT_ARROW;
 			break;
 		/// Crosshair
 		case LCUR_Cross:
 			type = GDK_CROSSHAIR;
 			break;
 		/// Hourglass/watch
 		case LCUR_Wait:
 			type = GDK_WATCH;
 			break;
 		/// Ibeam/text entry
 		case LCUR_Ibeam:
 			type = GDK_XTERM;
 			break;
 		/// Vertical resize (|)
 		case LCUR_SizeVer:
 			type = GDK_DOUBLE_ARROW;
 			break;
 		/// Horizontal resize (-)
 		case LCUR_SizeHor:
 			type = GDK_SB_H_DOUBLE_ARROW;
 			break;
 		/// Diagonal resize (/)
 		case LCUR_SizeBDiag:
 			type = GDK_BOTTOM_LEFT_CORNER;
 			break;
 		/// Diagonal resize (\)
 		case LCUR_SizeFDiag:
 			type = GDK_BOTTOM_RIGHT_CORNER;
 			break;
 		/// All directions resize
 		case LCUR_SizeAll:
 			type = GDK_FLEUR;
 			break;
 		/// A pointing hand
 		case LCUR_PointingHand:
 			type = GDK_HAND2;
 			break;
 		/// A slashed circle
 		case LCUR_Forbidden:
 			type = GDK_X_CURSOR;
 			break;
 
 		default:
 			type = GDK_ARROW;
 			break;
 
 		/*			
 		case LCUR_SplitV:
 		case LCUR_SplitH:
 		case LCUR_DropCopy:
 		case LCUR_DropMove:
 			LAssert(0);
 			break;
 		*/
 	}
 	
 	OsView h = NULL;
 	auto *w = v->GetWindow();
 	if (w)
 		h = GTK_WIDGET(w->WindowHandle());
 	
 	LAssert(v->InThread());
 	auto wnd = gtk_widget_get_window(h);
 	// LAssert(wnd);
 	if (wnd)
 	{
 		if (type == GDK_ARROW)
 			gdk_window_set_cursor(wnd, NULL);
 		else
 		{
 			GdkCursor *cursor = gdk_cursor_new_for_display(gdk_display_get_default(), type);
 			if (cursor)
 				gdk_window_set_cursor(wnd, cursor);
 			else
 				gdk_window_set_cursor(wnd, NULL);
 		}
 	}
 }
 
 bool LView::_Mouse(LMouse &m, bool Move)
 {
 	ThreadCheck();
 	
 	#if 0
 	if (!Move)
 	{
 		m.Trace("_Mouse");
 		::LArray<LViewI*> _m;
 		for (LViewI *i=this; i; i=i->GetParent())
 		{
 			_m.Add(i);
 		}
 		for (int n=0; n<_m.Length(); n++)
 		{
 			LViewI *i=_m[_m.Length()-1-n];
 			char s[256];
 			ZeroObj(s);
 			memset(s, ' ', (n+1)*2);
 			LgiTrace("%s%s %s\n", s, i->GetClass(), i->GetPos().GetStr());
 		}
 	}
 	#endif
 
 	#if DEBUG_MOUSE_EVENTS
 	if (!Move)
 		LgiTrace("%s:%i - _Mouse([%i,%i], %i) View=%p/%s\n", _FL, m.x, m.y, Move, _Over, _Over ? _Over->GetClass() : NULL);
 	#endif
 
 	if
 	(
 		/*
 		!_View
 		||
 		*/
 		(
 			GetWindow()
 			&&
 			!GetWindow()->HandleViewMouse(this, m)
 		)
 	)
 	{
 		#if DEBUG_MOUSE_EVENTS
 		LgiTrace("%s:%i - HandleViewMouse consumed event, cls=%s\n", _FL, GetClass());
 		#endif
 		return false;
 	}
 
 	#if DEBUG_MOUSE_EVENTS
 	// if (!Move)
 		LgiTrace("%s:%i - _Capturing=%p/%s\n", _FL, _Capturing, _Capturing ? _Capturing->GetClass() : NULL);
 	#endif
 	if (Move)
 	{
 		auto *o = m.Target;
 		if (_Over != o)
 		{
 			#if DEBUG_MOUSE_EVENTS
 			// if (!o) WindowFromPoint(m.x, m.y, true);
 			LgiTrace("%s:%i - _Over changing from %p/%s to %p/%s\n", _FL,
 					_Over, _Over ? _Over->GetClass() : NULL,
 					o, o ? o->GetClass() : NULL);
 			#endif
 			if (_Over)
 				_Over->OnMouseExit(lgi_adjust_click(m, _Over));
 			_Over = o;
 			if (_Over)
 				_Over->OnMouseEnter(lgi_adjust_click(m, _Over));
 		}
 	}
 		
 	LView *Target = NULL;
 	if (_Capturing)
 		Target = dynamic_cast<LView*>(_Capturing);
 	else
 		Target = dynamic_cast<LView*>(_Over ? _Over : this);
 	if (!Target)
 		return false;
 
 	LRect Client = Target->LView::GetClient(false);
 	
 	m = lgi_adjust_click(m, Target, !Move);
 	if (!Client.Valid() || Client.Overlap(m.x, m.y) || _Capturing)
 	{
 		LgiToGtkCursor(Target, Target->GetCursor(m.x, m.y));
 
 		if (Move)
 		{
 			Target->OnMouseMove(m);
 		}
 		else
 		{
 			#if 0
 			if (!Move)
 			{
 				char Msg[256];
 				sprintf(Msg, "_Mouse Target %s", Target->GetClass());
 				m.Trace(Msg);
 			}
 			#endif
 			Target->OnMouseClick(m);
 		}
 	}
 	else if (!Move)
 	{
 		#if DEBUG_MOUSE_EVENTS
 		LgiTrace("%s:%i - Click outside %s %s %i,%i\n", _FL, Target->GetClass(), Client.GetStr(), m.x, m.y);
 		#endif
 	}
 	
 	return true;
 }
 
 const char *EventTypeToString(int i)
 {
 	switch (i)
 	{
 		case GDK_DELETE: return "GDK_DELETE";
 		case GDK_DESTROY: return "GDK_DESTROY";
 		case GDK_EXPOSE: return "GDK_EXPOSE";
 		case GDK_MOTION_NOTIFY: return "GDK_MOTION_NOTIFY";
 		case GDK_BUTTON_PRESS: return "GDK_BUTTON_PRESS";
 		case GDK_2BUTTON_PRESS: return "GDK_2BUTTON_PRESS";
 		case GDK_3BUTTON_PRESS: return "GDK_3BUTTON_PRESS";
 		case GDK_BUTTON_RELEASE: return "GDK_BUTTON_RELEASE";
 		case GDK_KEY_PRESS: return "GDK_KEY_PRESS";
 		case GDK_KEY_RELEASE: return "GDK_KEY_RELEASE";
 		case GDK_ENTER_NOTIFY: return "GDK_ENTER_NOTIFY";
 		case GDK_LEAVE_NOTIFY: return "GDK_LEAVE_NOTIFY";
 		case GDK_FOCUS_CHANGE: return "GDK_FOCUS_CHANGE";
 		case GDK_CONFIGURE: return "GDK_CONFIGURE";
 		case GDK_MAP: return "GDK_MAP";
 		case GDK_UNMAP: return "GDK_UNMAP";
 		case GDK_PROPERTY_NOTIFY: return "GDK_PROPERTY_NOTIFY";
 		case GDK_SELECTION_CLEAR: return "GDK_SELECTION_CLEAR";
 		case GDK_SELECTION_REQUEST: return "GDK_SELECTION_REQUEST";
 		case GDK_SELECTION_NOTIFY: return "GDK_SELECTION_NOTIFY";
 		case GDK_PROXIMITY_IN: return "GDK_PROXIMITY_IN";
 		case GDK_PROXIMITY_OUT: return "GDK_PROXIMITY_OUT";
 		case GDK_DRAG_ENTER: return "GDK_DRAG_ENTER";
 		case GDK_DRAG_LEAVE: return "GDK_DRAG_LEAVE";
 		case GDK_DRAG_MOTION: return "GDK_DRAG_MOTION";
 		case GDK_DRAG_STATUS: return "GDK_DRAG_STATUS";
 		case GDK_DROP_START: return "GDK_DROP_START";
 		case GDK_DROP_FINISHED: return "GDK_DROP_FINISHED";
 		case GDK_CLIENT_EVENT: return "GDK_CLIENT_EVENT";
 		case GDK_VISIBILITY_NOTIFY: return "GDK_VISIBILITY_NOTIFY";
 		case GDK_SCROLL: return "GDK_SCROLL";
 		case GDK_WINDOW_STATE: return "GDK_WINDOW_STATE";
 		case GDK_SETTING: return "GDK_SETTING";
 		case GDK_OWNER_CHANGE: return "GDK_OWNER_CHANGE";
 		case GDK_GRAB_BROKEN: return "GDK_GRAB_BROKEN";
 		case GDK_DAMAGE: return "GDK_DAMAGE";
 		case GDK_TOUCH_BEGIN: return "GDK_TOUCH_BEGIN";
 		case GDK_TOUCH_UPDATE: return "GDK_TOUCH_UPDATE";
 		case GDK_TOUCH_END: return "GDK_TOUCH_END";
 		case GDK_TOUCH_CANCEL: return "GDK_TOUCH_CANCEL";
 		case GDK_TOUCHPAD_SWIPE: return "GDK_TOUCHPAD_SWIPE";
 		case GDK_TOUCHPAD_PINCH: return "GDK_TOUCHPAD_PINCH";
 		#ifdef GDK_PAD_BUTTON_PRESS
 		case GDK_PAD_BUTTON_PRESS: return "GDK_PAD_BUTTON_PRESS";
 		#endif
 		#ifdef GDK_PAD_BUTTON_RELEASE
 		case GDK_PAD_BUTTON_RELEASE: return "GDK_PAD_BUTTON_RELEASE";
 		#endif
 		#ifdef GDK_PAD_RING
 		case GDK_PAD_RING: return "GDK_PAD_RING";
 		#endif
 		#ifdef GDK_PAD_STRIP
 		case GDK_PAD_STRIP: return "GDK_PAD_STRIP";
 		#endif
 		#ifdef GDK_PAD_GROUP_MODE
 		case GDK_PAD_GROUP_MODE: return "GDK_PAD_GROUP_MODE";
 		#endif
 	}
 	return "#error";
 }
 
 gboolean GtkViewCallback(GtkWidget *widget, GdkEvent *event, LView *This)
 {
 	#if 0
 	LgiTrace("GtkViewCallback, Event=%s, This=%p(%s\"%s\")\n",
 		EventTypeToString(event->type),
 		This, (NativeInt)This > 0x1000 ? This->GetClass() : 0, (NativeInt)This > 0x1000 ? This->Name() : 0);
 	#endif
 	
 	if (event->type < 0 || (int)event->type > 1000)
 	{
 		printf("%s:%i - CORRUPT EVENT %i\n", _FL, event->type);
 		return false;
 	}
 
 	return This->OnGtkEvent(widget, event);
 }
 
 gboolean LView::OnGtkEvent(GtkWidget *widget, GdkEvent *event)
 {
 	printf("LView::OnGtkEvent ?????\n");
 	return false;
 }
 
 LRect &LView::GetClient(bool ClientSpace)
 {
 	int Edge = (Sunken() || Raised()) ? _BorderSize : 0;
 
 	static LRect c;
 	if (ClientSpace)
 	{
 		c.ZOff(Pos.X() - 1 - (Edge<<1), Pos.Y() - 1 - (Edge<<1));
 	}
 	else
 	{
 		c.ZOff(Pos.X()-1, Pos.Y()-1);
 		c.Inset(Edge, Edge);
 	}
 	
 	return c;
 }
 
 void LView::Quit(bool DontDelete)
 {
 	ThreadCheck();
 	
 	if (DontDelete)
 	{
 		Visible(false);
 	}
 	else
 	{
 		delete this;
 	}
 }
 
 bool LView::SetPos(LRect &p, bool Repaint)
 {
 	if (Pos != p)
 	{
 		Pos = p;
 		OnPosChange();
 	}
 
 	return true;
 }
 
 LRect GtkGetPos(GtkWidget *w)
 {
 	GtkAllocation a = {0};
 	gtk_widget_get_allocation(w, &a);
 	return a;
 }
 
 bool LView::Invalidate(LRect *rc, bool Repaint, bool Frame)
 {
+	#if 0 // Debug where lots of invalidate calls are from
+		static uint64_t StartTs = 0;
+		static int Count = 0;
+		static LHashTbl<ConstStrKey<char,false>,int> Classes;
+		
+		Count++;
+		int count = Classes.Find(GetClass());
+		Classes.Add(GetClass(), count + 1);
+		
+		auto Now = LCurrentTime();
+		if (Now - StartTs >= 1000)
+		{
+			printf("Inval=%i:", Count);
+			for (auto p: Classes)
+				printf(" %s=%i", p.key, p.value);
+			printf("\n");
+				
+			StartTs = Now;
+			Count = 0;
+			Classes.Empty();
+			
+			if (!Stricmp(GetClass(), "LMdiChild"))
+			{
+				int asd=0;
+			}
+		}
+	#endif
+
 	auto *ParWnd = GetWindow();
 	if (!ParWnd)
 		return false; // Nothing we can do till we attach
 	if (!InThread())
 	{
 		DEBUG_INVALIDATE("%s::Invalidate out of thread\n", GetClass());
 		return PostEvent(M_INVALIDATE, NULL, (LMessage::Param)this);
 	}
 
 	LRect r;
 	if (rc)
 	{
 		r = *rc;
 	}
 	else
 	{
 		if (Frame)
 			r = Pos.ZeroTranslate();
 		else
 			r = GetClient().ZeroTranslate();
 	}
 
 	DEBUG_INVALIDATE("%s::Invalidate r=%s frame=%i\n", GetClass(), r.GetStr(), Frame);
 	if (!Frame)
 		r.Offset(_BorderSize, _BorderSize);
 
 	LPoint Offset;
 	WindowVirtualOffset(&Offset);
 	r.Offset(Offset.x, Offset.y);
 	DEBUG_INVALIDATE("	voffset=%i,%i = %s\n", Offset.x, Offset.y, r.GetStr());
 	if (!r.Valid())
 	{
 		DEBUG_INVALIDATE("	error: invalid\n");
 		return false;
 	}
 
 	static bool Repainting = false;
 	if (!Repainting)
 	{
 		Repainting = true;
 
 		GtkWidget *w = GTK_WIDGET(ParWnd->WindowHandle());
 		if (w)
 		{
 			GdkWindow *h;
 			if (gtk_widget_get_has_window(w) &&
 				(h = gtk_widget_get_window(w)))
 			{
 				GdkRectangle grc = r;
 				DEBUG_INVALIDATE("	gdk_window_invalidate_rect %i,%i %i,%i\n", grc.x, grc.y, grc.width, grc.height);
 				gdk_window_invalidate_rect(h, &grc, true);
 			}
 			else
 			{
 				DEBUG_INVALIDATE("	gtk_widget_queue_draw\n");
 				gtk_widget_queue_draw(w);
 			}
 		}
 
 		Repainting = false;
 	}
 	else
 	{
 		DEBUG_INVALIDATE("	error: repainting\n");
 	}
 
 	return true;
 }
 
 void LView::SetPulse(int Length)
 {
 	ThreadCheck();
 
 	DeleteObj(d->PulseThread);
 	if (Length > 0)
 		d->PulseThread = new LPulseThread(this, Length);
 }
 
 LMessage::Param LView::OnEvent(LMessage *Msg)
 {
 	ThreadCheck();
 	
 	int Id;
 	switch (Id = Msg->Msg())
 	{
 		case M_SET_CTRL_NAME:
 		{
 			LAutoPtr<LString> s((LString*)Msg->B());
 			SetCtrlName(Msg->A(), s ? *s : NULL);
 			break;
 		}
 		case M_SET_CTRL_ENABLE:
 		{
 			SetCtrlEnabled(Msg->A(), Msg->B());
 			break;
 		}
 		case M_SET_CTRL_VISIBLE:
 		{
 			SetCtrlVisible(Msg->A(), Msg->B());
 			break;
 		}
 		case M_INVALIDATE:
 		{
 			if ((LView*)this == (LView*)Msg->B())
 			{
 				LAutoPtr<LRect> r((LRect*)Msg->A());
 				Invalidate(r);
 			}
 			break;
 		}
 		case M_PULSE:
 		{
 			OnPulse();
 			break;
 		}
 		case M_CAPTURE_PULSE:
 		{
 			auto wnd = GetWindow();
 			if (!wnd)
 			{
 				printf("%s:%i - No window.\n", _FL);
 				break;
 			}
 			
 			LMouse m;
 			if (!wnd->GetMouse(m, true))
 			{
 				printf("%s:%i - GetMouse failed.\n", _FL);
 				break;
 			}
 			
 			auto c = wnd->GetPos();
 			if (c.Overlap(m))
 				break; // Over the window, so we'll get normal events...
 			if (!_Capturing)
 				break; // Don't care now, there is no window capturing...
 
 			if (d->PrevMouse.x < 0)
 			{
 				d->PrevMouse = m; // Initialize the previous mouse var.
 				break;
 			}
 
 			int mask = LGI_EF_LEFT | LGI_EF_MIDDLE | LGI_EF_RIGHT;
 			bool coordsChanged = m.x != d->PrevMouse.x || m.y != d->PrevMouse.y;
 			bool buttonsChanged = (m.Flags & mask) != (d->PrevMouse.Flags & mask);
 			if (!coordsChanged && !buttonsChanged)
 				break; // Nothing changed since last poll..
 
 			int prevFlags = d->PrevMouse.Flags;
 			d->PrevMouse = m;
 			
 			// Convert coords to local view...
 			m.Target = _Capturing;
 			#if 0
 			printf("%s:%i - Mouse(%i,%i) outside window(%s, %s).. %s\n",
 				_FL, m.x, m.y, c.GetStr(), wnd->Name(),
 				m.ToString().Get());
 			#endif
 			m.ToView();
 
 			// Process events...
 			if (coordsChanged)
 			{
 				// printf("Move event: %s\n", m.ToString().Get());
 				_Capturing->OnMouseMove(m);
 			}
 			/* This seems to happen anyway? Ok then... whatevs
 			if (buttonsChanged)
 			{
 				m.Flags &= ~mask; // clear any existing
 				m.Flags |= prevFlags & mask;
 				m.Down(false);
 				printf("Click event: %s, mask=%x flags=%x\n", m.ToString().Get(), mask, m.Flags);
 				_Capturing->OnMouseClick(m);
 			}
 			*/
 			break;
 		}
 		case M_CHANGE:
 		{
 			LViewI *Ctrl;
 			if (GetViewById(Msg->A(), Ctrl))
 				return OnNotify(Ctrl, Msg->B());
 			break;
 		}
 		case M_COMMAND:
 		{
 			return OnCommand(Msg->A(), 0, (OsView) Msg->B());
 		}
 		case M_THREAD_COMPLETED:
 		{
 			auto Th = (LThread*)Msg->A();
 			if (!Th)
 				break;
 
 			Th->OnComplete();
 			if (Th->GetDeleteOnExit())
 				delete Th;
 
 			return true;
 		}
 	}
 
 	return 0;
 }
 
 LPoint GtkGetOrigin(LWindow *w)
 {
 	auto Hnd = w->WindowHandle();
 	if (Hnd)
 	{
 		auto Wnd = gtk_widget_get_window(GTK_WIDGET(Hnd));
 		if (Wnd)
 		{
 			GdkRectangle rect;
 			gdk_window_get_frame_extents(Wnd, &rect);
 			return LPoint(rect.x, rect.y);
 			
 			/*
 			gint x = 0, y = 0;
 			gdk_window_get_origin(Wnd, &x, &y);
 			gdk_window_get_root_origin(Wnd, &x, &y);
 			return LPoint(x, y);
 			*/
 		}
 		else
 		{
 			LgiTrace("%s:%i - can't get Wnd for %s\n", _FL, G_OBJECT_TYPE_NAME(Hnd));
 		}
 	}
 	
 	return LPoint();
 }
 
 bool LView::PointToScreen(LPoint &p)
 {
 	ThreadCheck();
 
 	LPoint Offset;
 	WindowVirtualOffset(&Offset);
 	p += Offset;
 
 	auto w = GetWindow();
 	if (!w)
 		return false;
 	auto wnd = w->WindowHandle();
 	if (!wnd)
 		return false;
 
 	auto wid = GTK_WIDGET(wnd);
 	auto hnd = gtk_widget_get_window(wid);
 
 	gint x = 0, y = 0;
 	gdk_window_get_origin(hnd, &x, &y);
 
 	p.x += x;
 	p.y += y;
 	return true;
 }
 
 bool LView::PointToView(LPoint &p)
 {
 	ThreadCheck();
 
 	LPoint Offset;
 	WindowVirtualOffset(&Offset);
 	p -= Offset;
 
 	auto w = GetWindow();
 	if (!w)
 		return false;
 	auto wnd = w->WindowHandle();
 	if (!wnd)
 		return false;
 
 	auto wid = GTK_WIDGET(wnd);
 	auto hnd = gtk_widget_get_window(wid);
 
 	gint x = 0, y = 0;
 	gdk_window_get_origin(hnd, &x, &y);
 
 	p.x -= x;
 	p.y -= y;
 	return true;
 }
 
 bool LView::GetMouse(LMouse &m, bool ScreenCoords)
 {
 	bool Status = true;
 	ThreadCheck();
 
 	auto *w = GetWindow();
 	GdkModifierType mask = (GdkModifierType)0;
 	auto display = gdk_display_get_default();
 	auto deviceManager = gdk_display_get_device_manager(display);
 	auto device = gdk_device_manager_get_client_pointer(deviceManager);
 	gdouble axes[2] = {0};
 	
 	if (gdk_device_get_axis_use(device, 0) != GDK_AXIS_X)
 		gdk_device_set_axis_use(device, 0, GDK_AXIS_X);
 	if (gdk_device_get_axis_use(device, 1) != GDK_AXIS_Y)
 		gdk_device_set_axis_use(device, 1, GDK_AXIS_Y);
 
 	if (ScreenCoords || !w)
 	{
 		gdk_device_get_state(device, gdk_get_default_root_window(), axes, &mask);
 		m.x = (int)axes[0];
 		m.y = (int)axes[1];
 	}
 	else if (auto widget = GTK_WIDGET(w->WindowHandle()))
 	{
 		auto wnd = gtk_widget_get_window(widget);
 		gdk_device_get_state(device, wnd, axes, &mask);
 		
 		if (axes[0] == 0.0 || axes[0] > 10000)
 		{
 			// LgiTrace("%s:%i - gdk_device_get_state failed.\n", _FL);
 			Status = false;
 		}
 		else
 		{
 			LPoint p;
 			WindowVirtualOffset(&p);
 			m.x = (int)axes[0] - p.x - _BorderSize;
 			m.y = (int)axes[1] - p.y - _BorderSize;
 			// printf("GetMs %g,%g %i,%i %i,%i device=%p wnd=%p\n", axes[0], axes[1], p.x, p.y, m.x, m.y, device, wnd);
 		}
 	}
 
 	m.SetModifer(mask);
 	m.Left((mask & GDK_BUTTON1_MASK) != 0);
 	m.Middle((mask & GDK_BUTTON2_MASK) != 0);
 	m.Right((mask & GDK_BUTTON3_MASK) != 0);
 	m.Down(m.Left() || m.Middle() || m.Right());
 	m.ViewCoords = !ScreenCoords;
 	
 	return Status;
 }
 
 bool LView::IsAttached()
 {
 	auto w = GetWindow();
 	if (!w)
 		return false;
 
 	w = dynamic_cast<LWindow*>(this);
 	if (!w)
 	{
 		auto p = GetParent();
 		return d->GotOnCreate && p && p->HasView(this);
 	}
 
 	return w->IsAttached();
 }
 
 const char *LView::GetClass()
 {
 	return "LView";
 }
 
 bool LView::Attach(LViewI *parent)
 {
 	ThreadCheck();
 	
 	bool Status = false;
 
 	LView *Parent = d->GetParent();
 	LAssert(Parent == NULL || Parent == parent);
 
 	SetParent(parent);
 	Parent = d->GetParent();
 	
 	auto WndNull = _Window == NULL;
 	_Window = Parent ? Parent->_Window : this;
 
 	if (parent)
 	{
 		auto w = GetWindow();
 		if (w && TestFlag(WndFlags, GWF_FOCUS))
 			w->SetFocus(this, LWindow::GainFocus);
 
 		Status = true;
 
 		if (!Parent->HasView(this))
 		{
 			OnAttach();
 			if (!d->Parent->HasView(this))
 				d->Parent->AddView(this);
 			d->Parent->OnChildrenChanged(this, true);
 		}
 
 		if (_Window)
 			OnGtkRealize();
 	}
 	
 	return Status;
 }
 
 bool LView::Detach()
 {
 	ThreadCheck();
 	
 	// Detach view
 	if (_Window)
 	{
 		auto *Wnd = dynamic_cast<LWindow*>(_Window);
 		if (Wnd)
 			Wnd->SetFocus(this, LWindow::ViewDelete);
 		_Window = NULL;
 	}
 
 	LViewI *Par = GetParent();
 	if (Par)
 	{
 		// Events
 		Par->DelView(this);
 		Par->OnChildrenChanged(this, false);
 		Par->Invalidate(&Pos);
 	}
 	
 	d->Parent = 0;
 	d->ParentI = 0;
 
 	#if 0 // Windows is not doing a deep detach... so we shouldn't either?
 	{
 		int Count = Children.Length();
 		if (Count)
 		{
 			int Detached = 0;
 			LViewI *c, *prev = NULL;
 
 			while ((c = Children[0]))
 			{
 				LAssert(!prev || c != prev);
 				if (c->GetParent())
 					c->Detach();
 				else
 					Children.Delete(c);
 				Detached++;
 				prev = c;
 			}
 			LAssert(Count == Detached);
 		}
 	}
 	#endif
 
 	return true;
 }
 
 LCursor LView::GetCursor(int x, int y)
 {
 	return LCUR_Normal;
 }
 
 void LView::OnGtkDelete()
 {
 	List<LViewI>::I it = Children.begin();
 	for (LViewI *c = *it; c; c = *++it)
 	{
 		LView *v = c->GetGView();
 		if (v)
 			v->OnGtkDelete();
 	}
 }
 
 ///////////////////////////////////////////////////////////////////
 bool LgiIsMounted(char *Name)
 {
 	return false;
 }
 
 bool LgiMountVolume(char *Name)
 {
 	return false;
 }
 
 ////////////////////////////////
 uint32_t CursorData[] = {
 0x02020202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020102, 0x02020202, 0x02020202, 0x01010101, 0x01010101, 0x01010101, 0x02020202, 0x02020202, 0x02010101, 0x02010101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010102, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020102, 0x01020202, 0x02020202, 0x02020202, 0x02020202, 0x01010101, 0x01010101, 0x02020201, 0x02020202, 0x01010101, 0x01010101, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020102, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02010101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02010102, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x01010101, 0x02020202, 0x02020202, 0x02020101, 0x02020202, 
 0x02020202, 0x02020202, 0x02020202, 0x02020101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x01000000, 0x02020202, 0x02020202, 0x01000001, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020101, 0x01020202, 0x02020201, 0x02020202, 0x02020202, 0x00000102, 0x00000000, 0x02020201, 0x02020202, 0x00000001, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 
 0x02020202, 0x02020202, 0x00010102, 0x00000000, 0x02020101, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x00010001, 0x00010001, 0x01000001, 0x02020202, 0x02020202, 0x00010102, 0x02020101, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x02020201, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x00010202, 0x00000000, 0x02020201, 0x02020202, 0x00000001, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 
 0x00010202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x02010000, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x01000102, 0x00000100, 0x02010000, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x00000000, 0x02020100, 0x02020202, 0x02020202, 0x00010202, 0x02020100, 0x01020202, 0x02010000, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x02020201, 0x02020202, 0x00000001, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x00000000, 
 0x02020201, 0x02020202, 0x02020202, 0x01020202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x00010101, 0x01000000, 0x02020202, 0x00000001, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x00010202, 0x00000001, 0x02020100, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x00000000, 0x02010000, 0x02020202, 0x02020202, 0x00000102, 0x01010100, 0x01010101, 0x01000000, 0x02020202, 0x02020201, 0x00010202, 0x00000000, 0x02020201, 0x02020202, 
 0x00000001, 0x02010000, 0x02020202, 0x02020201, 0x02020202, 0x02020202, 0x01010102, 0x01010001, 0x02020101, 0x02020202, 0x02020202, 0x01020201, 0x02010000, 0x02020102, 0x02020202, 0x02020202, 0x01010101, 0x01010100, 0x02020201, 0x02020202, 0x02020202, 0x01000001, 0x02020101, 0x02020202, 0x02020202, 0x00010202, 0x01010000, 0x01020202, 0x00000001, 0x02020201, 0x00000001, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x02020201, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x01010101, 0x01000001, 0x01010101, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 
 0x00000000, 0x00000000, 0x02020201, 0x02020101, 0x00000102, 0x00000100, 0x02020201, 0x02020202, 0x01000001, 0x01000000, 0x01020202, 0x02020201, 0x02020202, 0x02020202, 0x02020201, 0x02010001, 0x02010202, 0x02020202, 0x01020202, 0x01020201, 0x02010000, 0x02010102, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x01010000, 0x02020101, 0x02020202, 0x00000102, 0x01000000, 0x02020202, 0x00000102, 0x02020100, 0x00000001, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 
 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x02020201, 0x02010001, 0x00000001, 0x00010201, 0x02020201, 0x02020202, 0x02010001, 0x00000001, 0x00010201, 0x02020201, 0x02020202, 0x01020202, 0x02020201, 0x02010001, 0x01010202, 0x02020202, 0x00010202, 0x01020201, 0x02010000, 0x01000102, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02010102, 0x00000001, 0x00000000, 0x02010000, 0x02020202, 0x00000102, 0x00000001, 0x02020201, 0x00010202, 0x02020100, 0x00000001, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 
 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x01010100, 0x01010101, 0x01000000, 0x02020202, 0x01000001, 0x01000000, 0x01020202, 0x02020201, 0x02020202, 0x02020101, 0x00000102, 0x00000100, 0x02020201, 0x02020202, 0x00010202, 0x02020201, 0x02010001, 0x00010202, 0x02020201, 0x00000102, 0x01010101, 0x01010000, 0x00000101, 0x02020201, 0x01010101, 0x01010101, 0x01010100, 0x01010101, 0x02020201, 0x01000001, 0x00000001, 0x00000000, 0x02010000, 0x02020202, 0x00000001, 0x00000101, 0x02020100, 0x00010202, 0x02010000, 0x00000001, 0x00000000, 0x02020201, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x02020201, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x02020201, 
 0x02020202, 0x02020202, 0x01010102, 0x01010101, 0x01010001, 0x01010101, 0x02020101, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02020100, 0x01020202, 0x02010000, 0x02020202, 0x00000001, 0x02010000, 0x02020202, 0x02020201, 0x02020202, 0x02020201, 0x00010202, 0x00000000, 0x02020201, 0x02020202, 0x00000102, 0x01010101, 0x01010001, 0x00010101, 0x02020100, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x02020100, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x02020201, 0x00000001, 0x00000000, 0x00000000, 0x02010000, 0x02020202, 0x01000001, 0x00010202, 0x02010000, 0x01020202, 0x02010000, 0x00000001, 0x00000000, 0x02020100, 0x02020202, 0x02020202, 
 0x00000001, 0x00000000, 0x02020100, 0x02020202, 0x02020202, 0x01010101, 0x01010100, 0x02020201, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x02010000, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x01020202, 0x02020100, 0x02020202, 0x00000001, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x02020201, 0x02020202, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x02010000, 0x00000102, 0x01010101, 0x01010000, 0x00000101, 0x02020201, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x02020201, 0x00000102, 0x00000000, 0x00000000, 0x02010000, 0x02020202, 0x01000001, 0x01020202, 
 0x01000000, 0x01020202, 0x02010000, 0x00000001, 0x00000000, 0x02010000, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x02010000, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x01010102, 0x01010101, 0x01010001, 0x01010101, 0x02020101, 0x01020202, 0x00000000, 0x02020201, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020101, 0x01020202, 0x02020201, 0x02020202, 0x00000001, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x00000000, 0x02020201, 0x02020202, 0x00000102, 0x01010101, 0x01010001, 0x00010101, 0x02020100, 0x00010202, 0x01020201, 0x02010000, 0x01000102, 0x02020202, 0x01010101, 0x01010101, 0x01010100, 0x01010101, 
 0x02020201, 0x00010202, 0x00000000, 0x00000000, 0x02010000, 0x02020202, 0x01000001, 0x02020202, 0x00000001, 0x01020201, 0x02010000, 0x00000001, 0x01000000, 0x02010101, 0x02020202, 0x02020202, 0x00000001, 0x01000000, 0x02010101, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x00010202, 0x01000001, 0x02020100, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x01010101, 0x01000001, 0x01010101, 0x02020202, 0x02020202, 0x02020202, 0x02020102, 0x01020202, 0x02020202, 0x02020202, 0x00000001, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x00000000, 0x02020201, 0x02020202, 0x00010202, 0x02020201, 0x02010001, 0x00010202, 0x02020201, 0x01020202, 
 0x01020201, 0x02010000, 0x02010102, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x00000000, 0x02010000, 0x02020202, 0x00000001, 0x02020201, 0x00000102, 0x00010100, 0x02010000, 0x00000001, 0x01000001, 0x01020202, 0x01010101, 0x01010101, 0x00000001, 0x01000001, 0x01020202, 0x01010101, 0x01010101, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x01000102, 0x01000001, 0x02010001, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x00000000, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01010101, 0x01010101, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x01010101, 0x01010101, 
 0x02020201, 0x02020202, 0x01020202, 0x02020201, 0x02010001, 0x01010202, 0x02020202, 0x02020202, 0x01020201, 0x02010000, 0x02020102, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x02020100, 0x02020202, 0x00000102, 0x02020201, 0x00010202, 0x00010000, 0x02020100, 0x01000001, 0x01000001, 0x01020202, 0x00000000, 0x01000000, 0x01000001, 0x01000001, 0x01020202, 0x00000000, 0x01000000, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x00010001, 0x00000000, 0x01000100, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x00000000, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 
 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020201, 0x02010001, 0x02010202, 0x02020202, 0x02020202, 0x01020202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x01010101, 0x01010100, 0x02020201, 0x02020202, 0x02020202, 0x00000102, 0x00000000, 0x02020201, 0x02020202, 0x00000102, 0x02020100, 0x01020202, 0x00000000, 0x02020100, 0x02010001, 0x00000102, 0x01020201, 0x01010000, 0x01000001, 0x02010001, 0x00000102, 0x01020201, 0x01010100, 0x01000001, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x01000000, 0x02020202, 0x02020202, 0x00010202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 
 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01010102, 0x01010001, 0x02020101, 0x02020202, 0x02020202, 0x01020202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x00000102, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x01010202, 0x01010101, 0x02020202, 0x02020202, 0x00010202, 0x01010000, 0x01020202, 0x00000001, 0x02020201, 0x02020101, 0x00000102, 0x01020201, 0x00000100, 0x01000100, 0x02020101, 0x00000102, 0x01020201, 0x01000100, 0x01000100, 0x01020202, 0x02020101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x01010101, 0x01010101, 0x01010101, 0x02020202, 
 0x02020202, 0x00010102, 0x02020101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x00000000, 0x02020201, 0x02020202, 0x02020202, 0x01020202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x00010202, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x00010101, 0x01000000, 0x02020202, 0x02020202, 0x00010202, 0x01020100, 0x00000100, 0x01000000, 0x02020202, 0x00010202, 0x01020100, 0x01000100, 0x01000100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 
 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01000001, 0x02010000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010102, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02010101, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x02020100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00000001, 0x00000000, 0x02010000, 0x02020202, 0x02020202, 0x00010202, 0x01020100, 0x00000100, 0x01000100, 0x02020202, 0x00010202, 0x01020100, 
 0x01000100, 0x01000100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010101, 0x02010101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02010001, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020201, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x00010102, 0x00000000, 0x02020101, 0x02020202, 
 0x02020202, 0x01020202, 0x01020201, 0x01010000, 0x01000001, 0x02020202, 0x01020202, 0x01020201, 0x01000100, 0x01000100, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020102, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020102, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 
 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x01010101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x01000000, 0x02020202, 0x02020202, 0x01020202, 0x00000000, 0x01000000, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 
 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x01020202, 0x01010101, 0x01010101, 0x02020202, 0x02020202, 0x01020202, 0x01010101, 0x01010101, 
 };