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,2689 +1,2689 @@
 /// \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();
 	auto h = w ? w->WindowHandle() : NULL;
 	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
 		if (!d || !d->Hnd)
 		{
 			// printf("%s:%i - no handle %p %p\n", _FL, d, d ? d->Hnd : NULL);
 			return false;
 		}
 	
 		if (d->Hnd->Parent() == NULL)
 		{
 			// 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++;
 				// 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++;
 			// printf("%s:%p - Lock() cnt=%i par=%p.\n", GetClass(), this, _InLock, d->Hnd->Parent());
 			return true;
 		}
 	
-		printf("%s:%i - Lock(%s:%i) failed.\n", _FL, file, line);
+		// 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();
 	
 	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)
 		{
 			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.
 			{
 				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());
 				}
 			}
 		}
 		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();
 	}
 }
 
 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);
 	
 	#else
 	
 		#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;
 }
 
 #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/haiku/View.cpp b/src/haiku/View.cpp
--- a/src/haiku/View.cpp
+++ b/src/haiku/View.cpp
@@ -1,1130 +1,1133 @@
 /*hdr
 **      FILE:           LView.cpp
 **      AUTHOR:         Matthew Allen
 **      DATE:           29/11/2021
 **      DESCRIPTION:    Haiku LView Implementation
 **
 **      Copyright (C) 2021, 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 "ViewPriv.h"
 #include <Cursor.h>
 
 #define DEBUG_MOUSE_EVENTS			0
 
 #if 0
 #define DEBUG_INVALIDATE(...)		printf(__VA_ARGS__)
 #else
 #define DEBUG_INVALIDATE(...)
 #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
 };
 
 ////////////////////////////////////////////////////////////////////////////
 void _lgi_yield()
 {
 	LAppInst->Yield();
 }
 
 void *IsAttached(BView *v)
 {
 	auto pview = v->Parent();
 	auto pwnd = v->Window();
 	return pwnd ? (void*)pwnd : (void*)pview;
 }
 
 bool LgiIsKeyDown(int Key)
 {
 	LAssert(0);
 	return false;
 }
 
 LKey::LKey(int Vkey, uint32_t flags)
 {
 	vkey = Vkey;
 	Flags = flags;
 	IsChar = false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 template<typename Parent = BView>
 struct LBView : public Parent
 {
 	LViewPrivate *d = NULL;
 	static uint32 MouseButtons;
 
 	LBView(LViewPrivate *priv) :
 		d(priv),
 		Parent
 		(
 			"",
 			B_FULL_UPDATE_ON_RESIZE | 
 			B_WILL_DRAW |
 			B_NAVIGABLE |
 			B_FRAME_EVENTS
 		)
 	{
 		Parent::SetName(d->View->GetClass());
 	}
 	
 	~LBView()
 	{
 		if (d)
 			d->Hnd = NULL;
 	}		
 
 	void AttachedToWindow()
 	{
 		if (d)
 			d->View->OnCreate();
 	}
 	
 	LKey ConvertKey(const char *bytes, int32 numBytes)
 	{
 		LKey k;
 		
 		uint8_t *utf = (uint8_t*)bytes;
 		ssize_t len = numBytes;
 		auto w = LgiUtf8To32(utf, len);
 
 		key_info KeyInfo;
 		if (get_key_info(&KeyInfo) == B_OK)
 		{
 			k.Ctrl(TestFlag(KeyInfo.modifiers, B_CONTROL_KEY));
 			k.Alt(TestFlag(KeyInfo.modifiers, B_MENU_KEY));
 			k.Shift(TestFlag(KeyInfo.modifiers, B_SHIFT_KEY));
 			k.System(TestFlag(KeyInfo.modifiers, B_COMMAND_KEY));
 		}
 
 		#if 0
 		LString::Array a;
 		for (int i=0; i<numBytes; i++)
 			a.New().Printf("%i(%x)", (uint8_t)bytes[i], (uint8_t)bytes[i]);
 		if (KeyInfo.modifiers & B_CONTROL_KEY)
 			a.New() = "B_CONTROL_KEY";
 		if (KeyInfo.modifiers & B_MENU_KEY)
 			a.New() = "B_MENU_KEY";
 		if (KeyInfo.modifiers & B_SHIFT_KEY)
 			a.New() = "B_SHIFT_KEY";
 		if (KeyInfo.modifiers & B_COMMAND_KEY)
 			a.New() = "B_COMMAND_KEY";
 		printf("ConvertKey(%s)=%i\n", LString(",").Join(a).Get(), w);
 		#endif
 		
 		if (KeyInfo.modifiers & B_COMMAND_KEY)
 			// Currently Alt+Key issues a command key, but only the "up" down.
 			// Most of the Lgi apps are expecting at least a "down" key first.
 			// So just set the "up" event to "down" here.
 			k.Down(true);		
 		
 		if (w)
 		{
 			if (w == B_FUNCTION_KEY)
 			{
 				auto bmsg = Parent::Window()->CurrentMessage();
 				if (bmsg)
 				{
 					int32 key = 0;
 					if (bmsg->FindInt32("key", &key) == B_OK)
 					{
 						// Translate the function keys into the LGI address space...
 						switch (key)
 						{
 							case B_F1_KEY: w = LK_F1; break;
 							case B_F2_KEY: w = LK_F2; break;
 							case B_F3_KEY: w = LK_F3; break;
 							case B_F4_KEY: w = LK_F4; break;
 							case B_F5_KEY: w = LK_F5; break;
 							case B_F6_KEY: w = LK_F6; break;
 							case B_F7_KEY: w = LK_F7; break;
 							case B_F8_KEY: w = LK_F8; break;
 							case B_F9_KEY: w = LK_F9; break;
 							case B_F10_KEY: w = LK_F10; break;
 							case B_F11_KEY: w = LK_F11; break;
 							case B_F12_KEY: w = LK_F12; break;
 							default:
 								printf("%s:%i - Upsupported key %i.\n", _FL, key);
 								break;
 						}
 					}
 					else printf("%s:%i - No 'key' in BMessage.\n", _FL);
 				}
 				else printf("%s:%i - No BMessage.\n", _FL);
 			}
 
 			k.c16 = k.vkey = w;
 			
 		}
 
 		k.IsChar =
 			!(
 				k.System()
 				||
 				k.Alt()
 			)
 			&&
 			(
 				(k.c16 >= ' ' && k.c16 < LK_DELETE)
 				||
 				k.c16 == LK_BACKSPACE
 				||
 				k.c16 == LK_TAB
 				||
 				k.c16 == LK_RETURN
 			);
 
 		return k;
 	}
 	
 	void KeyDown(const char *bytes, int32 numBytes)
 	{
 		if (!d) return;
 		
 		auto k = ConvertKey(bytes, numBytes);
 		k.Down(true);
 
 		auto wnd = d->View->GetWindow();
 		if (wnd)
 			wnd->HandleViewKey(d->View, k);
 		else
 			d->View->OnKey(k);
 	}
 	
 	void KeyUp(const char *bytes, int32 numBytes)
 	{
 		if (!d) return;
 
 		auto k = ConvertKey(bytes, numBytes);
 		auto wnd = d->View->GetWindow();
 		if (wnd)
 			wnd->HandleViewKey(d->View, k);
 		else
 			d->View->OnKey(k);
 	}
 
 	void FrameMoved(BPoint newPosition)
 	{
 		if (!d) return;
 		d->View->Pos = Parent::Frame();
 		d->View->OnPosChange();
 	}
 
 	void FrameResized(float newWidth, float newHeight)
 	{
 		if (!d) return;
 		d->View->Pos = Parent::Frame();
 		d->View->OnPosChange();
 	}
 
 	void MessageReceived(BMessage *message)
 	{
 		if (!d) return;
 		void *v = NULL;
 		if (message->FindPointer(LMessage::PropView, &v) == B_OK)
 		{
 			// Proxy'd event for child view...
 			((LView*)v)->OnEvent((LMessage*)message);
 			return;
 		}
 		else d->View->OnEvent((LMessage*)message);
 		
 		if (message->what == B_MOUSE_WHEEL_CHANGED)
 		{
 			float x = 0.0f, y = 0.0f;
 			message->FindFloat("be:wheel_delta_x", &x);
 			message->FindFloat("be:wheel_delta_y", &y);
 			d->View->OnMouseWheel(y * 3.0f);
 		}
 		else if (message->what == M_SET_SCROLL)
 		{
 			return;
 		}
 		
 		Parent::MessageReceived(message);
 	}
 
 	void Draw(BRect updateRect)
 	{
 		if (!d) return;
 		LScreenDC dc(d->View);
 		LPoint off(0,0);
 		d->View->_Paint(&dc, &off, NULL);
 	}
 
 	LMouse ConvertMouse(BPoint where, bool down = false)
 	{
 		LMouse m;
 		BPoint loc;
 		uint32 buttons = 0;
 		
 		m.Target = d->View;
 		
 		m.x = where.x;
 		m.y = where.y;
 		
 		if (down)
 		{
 			m.Down(true);
 			Parent::GetMouse(&loc, &buttons, false);
 			MouseButtons = buttons; // save for up click
 		}
 		else
 		{
 			buttons = MouseButtons;
 		}
 		
 		if (buttons & B_PRIMARY_MOUSE_BUTTON) m.Left(true);
 		if (buttons & B_TERTIARY_MOUSE_BUTTON) m.Middle(true);
 		if (buttons & B_SECONDARY_MOUSE_BUTTON) m.Right(true);
 		
 		uint32 mod = modifiers();
 		if (mod & B_SHIFT_KEY) m.Shift(true);
 		if (mod & B_OPTION_KEY) m.Alt(true);
 		if (mod & B_CONTROL_KEY) m.Ctrl(true);
 		if (mod & B_COMMAND_KEY) m.System(true);
 		
 		return m;
 	}
 	
 	void MouseDown(BPoint where)
 	{
 		if (!d) return;
 		static uint64_t lastClick = 0;
 		bigtime_t interval = 0;
 		status_t r = get_click_speed(&interval);
 		auto now = LCurrentTime();
 		bool doubleClick = now-lastClick < (interval/1000);
 		lastClick = now;
 		
 		LMouse m = ConvertMouse(where, true);
 		m.Double(doubleClick);
 		d->View->_Mouse(m, false);
 	}
 	
 	void MouseUp(BPoint where) 
 	{
 		if (!d) return;
 		LMouse m = ConvertMouse(where);
 		m.Down(false);
 		d->View->_Mouse(m, false);
 	}
 	
 	void MouseMoved(BPoint where, uint32 code, const BMessage *dragMessage)
 	{
 		if (!d) return;
 		LMouse m = ConvertMouse(where);
 		m.Down(	m.Left() ||
 				m.Middle() ||
 				m.Right());
 		m.IsMove(true);
 		d->View->_Mouse(m, true);
 	}
 
 	void MakeFocus(bool focus=true)
 	{
 		if (!d) return;
 		Parent::MakeFocus(focus);
 		d->View->OnFocus(focus);
 	}
 };
 
 template<typename Parent>
 uint32 LBView<Parent>::MouseButtons = 0;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 LViewPrivate::LViewPrivate(LView *view) :
 	View(view),
 	Hnd(new LBView<BView>(this))
 {
 }
 
 LViewPrivate::~LViewPrivate()
 {
 	View->d = NULL;
 
 	MsgQue.DeleteObjects();
 
 	if (Font && FontOwnType == GV_FontOwned)
 		DeleteObj(Font);
 
 	if (Hnd)
 	{
 		auto *bv = dynamic_cast<LBView<BView>*>(Hnd);
 		// printf("%p::~LViewPrivate View=%p bv=%p th=%u\n", this, View, bv, GetCurrentThreadId());
 		if (bv)
 			bv->d = NULL;
 
 		auto Wnd = Hnd->Window();
 		bool locked = false;
 
 		if (Wnd)
 			locked = Wnd->LockLooper();
 			
 		if (Hnd->Parent())
 			Hnd->RemoveSelf();
 		
 		DeleteObj(Hnd);
 
 		if (Wnd && locked)
 			Wnd->UnlockLooper();
 	}
 }
 
 void LView::_Focus(bool f)
 {
 	ThreadCheck();
 	
 	if (f)
 		SetFlag(WndFlags, GWF_FOCUS);
 	else
 		ClearFlag(WndFlags, GWF_FOCUS);
 
 	LLocker lck(d->Hnd, _FL);
 	if (lck.Lock())
 	{
 		d->Hnd->MakeFocus(f);
 		lck.Unlock();
 	}
 
 	// OnFocus will be called by the LBview handler...
 	Invalidate();
 }
 
 void LView::_Delete()
 {
 	SetPulse();
 
 	// Remove static references to myself
 	if (_Over == this)
 		_Over = 0;
 	if (_Capturing == this)
 		_Capturing = 0;
 	
 	auto *Wnd = GetWindow();
 	if (Wnd && Wnd->GetFocus() == static_cast<LViewI*>(this))
 		Wnd->SetFocus(this, LWindow::ViewDelete);
 
 	if (LAppInst && LAppInst->AppWnd == this)
 	{
 		LAppInst->AppWnd = 0;
 	}
 
 	// 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;
 }
 
 BCursorID LgiToHaiku(LCursor c)
 {
 	switch (c)
 	{
 		#define _(l,h) case l: return h;
 		_(LCUR_Blank, B_CURSOR_ID_NO_CURSOR)
 		_(LCUR_Normal, B_CURSOR_ID_SYSTEM_DEFAULT)
 		_(LCUR_UpArrow, B_CURSOR_ID_RESIZE_NORTH)
 		_(LCUR_DownArrow, B_CURSOR_ID_RESIZE_SOUTH)
 		_(LCUR_LeftArrow, B_CURSOR_ID_RESIZE_WEST)
 		_(LCUR_RightArrow, B_CURSOR_ID_RESIZE_EAST)
 		_(LCUR_Cross, B_CURSOR_ID_CROSS_HAIR)
 		_(LCUR_Wait, B_CURSOR_ID_PROGRESS)
 		_(LCUR_Ibeam, B_CURSOR_ID_I_BEAM)
 		_(LCUR_SizeVer, B_CURSOR_ID_RESIZE_NORTH_SOUTH)
 		_(LCUR_SizeHor, B_CURSOR_ID_RESIZE_EAST_WEST)
 		_(LCUR_SizeBDiag, B_CURSOR_ID_RESIZE_NORTH_WEST_SOUTH_EAST)
 		_(LCUR_SizeFDiag, B_CURSOR_ID_RESIZE_NORTH_EAST_SOUTH_WEST)
 		_(LCUR_PointingHand, B_CURSOR_ID_GRAB)
 		_(LCUR_Forbidden, B_CURSOR_ID_NOT_ALLOWED)
 		_(LCUR_DropCopy, B_CURSOR_ID_COPY)
 		_(LCUR_DropMove, B_CURSOR_ID_MOVE)
 		// _(LCUR_SizeAll,
 		// _(LCUR_SplitV,
 		// _(LCUR_SplitH,
 		#undef _
 	}
 	
 	return B_CURSOR_ID_SYSTEM_DEFAULT;
 }
 
 bool LView::_Mouse(LMouse &m, bool Move)
 {
 	ThreadCheck();
 	
 	#if DEBUG_MOUSE_EVENTS
 	if (!Move)
 		LgiTrace("%s:%i - %s\n", _FL, m.ToString().Get());
 	#endif
 
 	if
 	(
 		GetWindow()
 		&&
 		!GetWindow()->HandleViewMouse(this, m)
 	)
 	{
 		#if DEBUG_MOUSE_EVENTS
 		LgiTrace("%s:%i - HandleViewMouse consumed event, cls=%s\n", _FL, GetClass());
 		#endif
 		return false;
 	}
 
 	#if 0 //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));
 		}
 		
 		int cursor = GetCursor(m.x, m.y);
 		if (cursor >= 0)
 		{
 			BCursorID haikuId = LgiToHaiku((LCursor)cursor);
 			static BCursorID curId = B_CURSOR_ID_SYSTEM_DEFAULT;
 			if (curId != haikuId)
 			{
 				curId = haikuId;
 				
 				LLocker lck(Handle(), _FL);
 				if (lck.Lock())
 				{
 					Handle()->SetViewCursor(new BCursor(curId));
 					lck.Unlock();
 				}
 			}
 		}
 	}
 		
 	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)
 	{
 		if (Move)
 			Target->OnMouseMove(m);
 		else
 			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;
 }
 
 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;
 }
 
 LViewI *LView::FindControl(OsView hCtrl)
 {
 	if (d->Hnd == hCtrl)
 	{
 		return this;
 	}
 
 	for (auto i : Children)
 	{
 		LViewI *Ctrl = i->FindControl(hCtrl);
 		if (Ctrl)
 		{
 			return Ctrl;
 		}
 	}
 	return 0;
 }
 
 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;
 
 		LLocker lck(d->Hnd, _FL);
 		if (lck.Lock())
 		{
 			d->Hnd->ResizeTo(Pos.X(), Pos.Y());
 			d->Hnd->MoveTo(Pos.x1, Pos.y1);
 			lck.Unlock();
 		}
 
 		OnPosChange();
 	}
 
 	return true;
 }
 
 bool LView::Invalidate(LRect *rc, bool Repaint, bool Frame)
 {
 	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;
 
 		if (d->Hnd)
 		{
 			LLocker lck(d->Hnd, _FL);
 			if (lck.Lock())
 				d->Hnd->Invalidate();
 		}
 
 		Repainting = false;
 	}
 	else
 	{
 		DEBUG_INVALIDATE("	error: repainting\n");
 	}
 
 	return true;
 }
 
 void LView::SetPulse(int Length)
 {
 	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_HANDLE_IN_THREAD:
 		{
 			LMessage::InThreadCb *Cb = NULL;
 			if (Msg->FindPointer(LMessage::PropCallback, (void**)&Cb) == B_OK)
 			{
 				// printf("M_HANDLE_IN_THREAD before call..\n");
 				(*Cb)();
 				// printf("M_HANDLE_IN_THREAD after call..\n");
 				delete Cb;
 				// printf("M_HANDLE_IN_THREAD after delete..\n");
 			}
 			else printf("%s:%i - No Callback.\n", _FL);
 			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_CHANGE:
 		{
 			LViewI *Ctrl = NULL;
 			if (GetViewById(Msg->A(), Ctrl))
 			{
 				LNotification n((LNotifyType)Msg->B());
 				return OnNotify(Ctrl, n);
 			}
 			break;
 		}
 		case M_COMMAND:
 		{
 			// printf("M_COMMAND %i\n", (int)Msg->A());
 			return OnCommand(Msg->A(), 0, 0);
 		}
 		case M_THREAD_COMPLETED:
 		{
 			auto Th = (LThread*)Msg->A();
 			if (!Th)
 				break;
 
 			Th->OnComplete();
 			if (Th->GetDeleteOnExit())
 				delete Th;
 
 			return true;
 		}
 	}
 
 	return 0;
 }
 
 OsView LView::Handle() const
 {
 	if (!d)
 	{
 		printf("%s:%i - No priv?\n", _FL);
 		return NULL;
 	}
 	
 	return d->Hnd;
 }
 
 bool LView::PointToScreen(LPoint &p)
 {
 	if (!Handle())
 	{
 		LgiTrace("%s:%i - No handle.\n", _FL);
 		return false;
 	}
 
 	LPoint Offset;
 	WindowVirtualOffset(&Offset);
 	// printf("p=%i,%i offset=%i,%i\n", p.x, p.y, Offset.x, Offset.y);
 	p += Offset;
 	// printf("p=%i,%i\n", p.x, p.y);
 
 	LLocker lck(Handle(), _FL);
 	if (!lck.Lock())
 	{
 		LgiTrace("%s:%i - Can't lock.\n", _FL);
 		return false;
 	}
 	
 	BPoint pt = Handle()->ConvertToScreen(BPoint(p.x, p.y));
 	// printf("pt=%g,%g\n", pt.x, pt.y);
 	p.x = pt.x;
 	p.y = pt.y;
 	// printf("p=%i,%i\n\n", p.x, p.y);
 
 	return true;
 }
 
 bool LView::PointToView(LPoint &p)
 {
 	if (!Handle())
 	{
 		LgiTrace("%s:%i - No handle.\n", _FL);
 		return false;
 	}
 
 	LPoint Offset;
 	WindowVirtualOffset(&Offset);
 	p -= Offset;
 
 	LLocker lck(Handle(), _FL);
 	if (!lck.Lock())
 	{
 		LgiTrace("%s:%i - Can't lock.\n", _FL);
 		return false;
 	}
 	
 	BPoint pt = Handle()->ConvertFromScreen(BPoint(Offset.x, Offset.y));
 	Offset.x = pt.x;
 	Offset.y = pt.y;
 
 	return true;
 }
 
 bool LView::GetMouse(LMouse &m, bool ScreenCoords)
 {
 	LLocker Locker(d->Hnd, _FL);
 	if (!Locker.Lock())
 		return false;
 
 	// get mouse state
 	BPoint Cursor;
 	uint32 Buttons;
 	
 	d->Hnd->GetMouse(&Cursor, &Buttons);
 	if (ScreenCoords)
 		d->Hnd->ConvertToScreen(&Cursor);
 	
 	// position
 	m.x = Cursor.x;
 	m.y = Cursor.y;
 
 	// buttons
 	m.Left(TestFlag(Buttons, B_PRIMARY_MOUSE_BUTTON));
 	m.Middle(TestFlag(Buttons, B_TERTIARY_MOUSE_BUTTON));
 	m.Right(TestFlag(Buttons, B_SECONDARY_MOUSE_BUTTON));
 
 	// key states
 	key_info KeyInfo;
 	if (get_key_info(&KeyInfo) == B_OK)
 	{
 		m.Ctrl(TestFlag(KeyInfo.modifiers, B_CONTROL_KEY));
 		m.Alt(TestFlag(KeyInfo.modifiers, B_MENU_KEY));
 		m.Shift(TestFlag(KeyInfo.modifiers, B_SHIFT_KEY));
 	}
 	
 	return true;
 }
 
 bool LView::IsAttached()
 {
 	bool attached = false;
 	
 	LLocker lck(d->Hnd, _FL);
 	if (lck.Lock())
 	{
 		auto pview = d->Hnd->Parent();
 		auto pwnd = d->Hnd->Window();
 		attached = pview != NULL || pwnd != NULL;
 	}
 	
 	return attached;
 }
 
 const char *LView::GetClass()
 {
 	return "LView";
 }
 
 bool LView::Attach(LViewI *parent)
 {
 	bool Status = false;
 	bool Debug = false; // !Stricmp(GetClass(), "LScrollBar");
 
 	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)
 	{
 		LgiTrace("%s:%i - No parent window.\n", _FL);
 	}
 	else
 	{
 		auto w = GetWindow();
 		if (w && TestFlag(WndFlags, GWF_FOCUS))
 			w->SetFocus(this, LWindow::GainFocus);
 
 		auto bview = parent->Handle();
 		if (bview)
 		{
 			LLocker lck(bview, _FL);
 			if (lck.Lock())
 			{
 				if (Debug)
 					LgiTrace("%s:%i - Attaching %s to view %s\n",
 						_FL, GetClass(), parent->GetClass());
 
 				d->Hnd->SetName(GetClass());
 				if (::IsAttached(d->Hnd))
 					d->Hnd->RemoveSelf();
 				bview->AddChild(d->Hnd);
 
 				d->Hnd->ResizeTo(Pos.X(), Pos.Y());
 				d->Hnd->MoveTo(Pos.x1, Pos.y1);
 				
 				bool ShowView = TestFlag(GViewFlags, GWF_VISIBLE) && d->Hnd->IsHidden();
 				if (Debug)
 					LgiTrace("%s:%i - IsHidden=%i ShowView=%i\n", _FL, d->Hnd->IsHidden(), ShowView);
 				if (ShowView)
 					d->Hnd->Show();
 
+				if (TestFlag(WndFlags, GWF_FOCUS))
+					d->Hnd->MakeFocus();
+
 				Status = true;
 				
 				if (d->MsgQue.Length())
 				{
 					printf("%s:%i - %s.Attach msgQue=%i\n", _FL, GetClass(), (int)d->MsgQue.Length());
 					for (auto bmsg: d->MsgQue)
 						d->Hnd->Window()->PostMessage(bmsg);
 					d->MsgQue.DeleteObjects();
 				}
 
 				if (Debug)
 					LgiTrace("%s:%i - Attached %s/%p to view %s/%p, success\n",
 						_FL,
 						GetClass(), d->Hnd,
 						parent->GetClass(), bview);
 			}
 			else
 			{
 				if (Debug)
 					LgiTrace("%s:%i - Error attaching %s to view %s, can't lock.\n",
 						_FL, GetClass(), parent->GetClass());
 			}
 		}
 
 		if (!Parent->HasView(this))
 		{
 			OnAttach();
 			if (!d->Parent->HasView(this))
 				d->Parent->AddView(this);
 			d->Parent->OnChildrenChanged(this, true);
 		}
 	}
 	
 	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;
 }
 
 ///////////////////////////////////////////////////////////////////
 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, 
 };