split graphic objects dirRearangeDirs

38 files changed, 8466 insertions, 0 deletions

diff --git a/src/GraphicObjects/Base/Border.cs b/src/GraphicObjects/Base/Border.cs
new file mode 100644
index 00000000..672d5ab8
--- /dev/null
+++ b/src/GraphicObjects/Base/Border.cs
@@ -0,0 +1,100 @@
+//
+// Border.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Crow
+{
+	public class Border : Container
+	{
+		#region CTOR
+		public Border () : base(){}
+		#endregion
+
+		#region private fields
+		int _borderWidth;
+		#endregion
+
+		#region public properties
+		[XmlAttributeAttribute()][DefaultValue(1)]
+		public virtual int BorderWidth {
+			get { return _borderWidth; }
+			set {
+				_borderWidth = value;
+				RegisterForGraphicUpdate ();
+			}
+		}
+		#endregion
+
+		#region GraphicObject override
+		[XmlIgnore]public override Rectangle ClientRectangle {
+			get {
+				Rectangle cb = base.ClientRectangle;
+				cb.Inflate (- BorderWidth);
+				return cb;
+			}
+		}
+
+		protected override int measureRawSize (LayoutingType lt)
+		{
+			int tmp = base.measureRawSize (lt);
+			return tmp < 0 ? tmp : tmp + 2 * BorderWidth;
+		}
+		protected override void onDraw (Cairo.Context gr)
+		{
+			Rectangle rBack = new Rectangle (Slot.Size);
+
+			//rBack.Inflate (-Margin);
+//			if (BorderWidth > 0) 
+//				rBack.Inflate (-BorderWidth / 2);			
+
+			Background.SetAsSource (gr, rBack);
+			CairoHelpers.CairoRectangle(gr, rBack, CornerRadius);
+			gr.Fill ();
+
+			if (BorderWidth > 0) {				
+				Foreground.SetAsSource (gr, rBack);
+				CairoHelpers.CairoRectangle(gr, rBack, CornerRadius, BorderWidth);
+			}
+
+			gr.Save ();
+			if (ClipToClientRect) {
+				//clip to client zone
+				CairoHelpers.CairoRectangle (gr, ClientRectangle,Math.Max(0.0, CornerRadius-Margin));
+				gr.Clip ();
+			}
+
+			if (child != null)
+				child.Paint (ref gr);
+			gr.Restore ();
+		}		
+		#endregion
+	}
+}
+
diff --git a/src/GraphicObjects/Base/Button.cs b/src/GraphicObjects/Base/Button.cs
new file mode 100644
index 00000000..75f43014
--- /dev/null
+++ b/src/GraphicObjects/Base/Button.cs
@@ -0,0 +1,124 @@
+//
+// Button.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+//using OpenTK.Graphics.OpenGL;
+
+using System.Diagnostics;
+
+using System.Xml.Serialization;
+using Cairo;
+using System.ComponentModel;
+
+namespace Crow
+{
+    public class Button : TemplatedContainer
+    {
+		string image;
+		bool isPressed;
+		Container _contentContainer;
+
+		#region CTOR
+        public Button() : base()
+        {}
+		#endregion
+
+		public event EventHandler Pressed;
+		public event EventHandler Released;
+
+		#region TemplatedContainer overrides
+		public override GraphicObject Content {
+			get {
+				return _contentContainer == null ? null : _contentContainer.Child;
+			}
+			set {
+				if (_contentContainer != null)
+					_contentContainer.SetChild(value);
+			}
+		}
+		protected override void loadTemplate(GraphicObject template = null)
+		{
+			base.loadTemplate (template);
+
+			_contentContainer = this.child.FindByName ("Content") as Container;
+		}
+		#endregion
+
+		#region GraphicObject Overrides
+		public override void onMouseDown (object sender, MouseButtonEventArgs e)
+		{
+			IsPressed = true;
+
+			base.onMouseDown (sender, e);
+
+			//TODO:remove
+			NotifyValueChanged ("State", "pressed");
+		}
+		public override void onMouseUp (object sender, MouseButtonEventArgs e)
+		{
+			IsPressed = false;
+
+			base.onMouseUp (sender, e);
+
+			//TODO:remove
+			NotifyValueChanged ("State", "normal");
+		}
+		#endregion
+
+		[XmlAttributeAttribute][DefaultValue("#Crow.Images.button.svg")]
+		public string Image {
+			get { return image; }
+			set {
+				if (image == value)
+					return;
+				image = value;
+				NotifyValueChanged ("Image", image);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public bool IsPressed
+		{
+			get { return isPressed; }
+			set
+			{
+				if (isPressed == value)
+					return;
+
+				isPressed = value;
+
+				NotifyValueChanged ("IsPressed", isPressed);
+
+				if (isPressed)
+					Pressed.Raise (this, null);
+				else
+					Released.Raise (this, null);
+			}
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/CheckBox.cs b/src/GraphicObjects/Base/CheckBox.cs
new file mode 100644
index 00000000..0a40d269
--- /dev/null
+++ b/src/GraphicObjects/Base/CheckBox.cs
@@ -0,0 +1,71 @@
+//
+// CheckBox.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.ComponentModel;
+using System.Xml.Serialization;
+
+namespace Crow
+{
+	public class CheckBox : TemplatedControl
+	{
+		bool isChecked;
+
+		#region CTOR
+		public CheckBox() : base()
+		{}
+		#endregion
+
+		public event EventHandler Checked;
+		public event EventHandler Unchecked;
+
+		[XmlAttributeAttribute()][DefaultValue(false)]
+		public bool IsChecked
+		{
+			get { return isChecked; }
+			set
+			{
+				if (isChecked == value)
+					return;
+
+				isChecked = value;
+
+				NotifyValueChanged ("IsChecked", value);
+
+				if (isChecked)
+					Checked.Raise (this, null);
+				else
+					Unchecked.Raise (this, null);
+			}
+		}
+
+		public override void onMouseClick (object sender, MouseButtonEventArgs e)
+		{
+			IsChecked = !IsChecked;
+			base.onMouseClick (sender, e);
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/ComboBox.cs b/src/GraphicObjects/Base/ComboBox.cs
new file mode 100644
index 00000000..15b49dbe
--- /dev/null
+++ b/src/GraphicObjects/Base/ComboBox.cs
@@ -0,0 +1,55 @@
+//
+// ComboBox.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+
+namespace Crow
+{
+	public class ComboBox : ListBox
+    {		
+		#region CTOR
+		public ComboBox() : base(){	}	
+		#endregion
+
+		Size minimumPopupSize = "10,10";
+		[XmlIgnore]public Size MinimumPopupSize{
+			get { return minimumPopupSize; }
+			set {
+				minimumPopupSize = value;
+				NotifyValueChanged ("MinimumPopupSize", minimumPopupSize);
+			}
+		}
+
+		public override void OnLayoutChanges (LayoutingType layoutType)
+		{
+			base.OnLayoutChanges (layoutType);
+
+			if (layoutType == LayoutingType.Width)
+				MinimumPopupSize = new Size (this.Slot.Width, minimumPopupSize.Height);			
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/Container.cs b/src/GraphicObjects/Base/Container.cs
new file mode 100644
index 00000000..aac35946
--- /dev/null
+++ b/src/GraphicObjects/Base/Container.cs
@@ -0,0 +1,109 @@
+//
+// Container.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.Reflection;
+using System.ComponentModel;
+using System.Linq;
+using System.Threading;
+
+namespace Crow
+{
+    public class Container : PrivateContainer, IXmlSerializable
+    {
+		#region CTOR
+		public Container()
+			: base()
+		{
+		}
+		#endregion
+
+		[XmlIgnore]
+		public GraphicObject Child {
+			get { return child; }
+			set { child = value; }
+		}
+		public virtual void SetChild(GraphicObject _child)
+		{
+			base.SetChild (_child);
+		}
+
+		#region IXmlSerializable
+
+        public override System.Xml.Schema.XmlSchema GetSchema()
+        {
+            return null;
+        }
+        public override void ReadXml(System.Xml.XmlReader reader)
+        {
+			//only read attributes in GraphicObject IXmlReader implementation
+            base.ReadXml(reader);
+
+
+            using (System.Xml.XmlReader subTree = reader.ReadSubtree())
+            {
+                subTree.Read(); //skip current node
+                subTree.Read(); //read first child
+
+                if (!subTree.IsStartElement())
+                    return;
+
+                Type t = Type.GetType("Crow." + subTree.Name);
+				if (t == null) {
+					Assembly a = Assembly.GetEntryAssembly ();
+					foreach (Type expT in a.GetExportedTypes ()) {
+						if (expT.Name == subTree.Name) {
+							t = expT;
+							break;
+						}
+					}
+				}
+				GraphicObject go = (GraphicObject)Activator.CreateInstance(t);
+
+				(go as IXmlSerializable).ReadXml(subTree);
+
+				SetChild(go);
+
+                subTree.Read();//closing tag
+            }
+        }
+        public override void WriteXml(System.Xml.XmlWriter writer)
+        {
+            base.WriteXml(writer);
+
+            if (Child == null)
+                return;
+
+            writer.WriteStartElement(Child.GetType().Name);
+            (Child as IXmlSerializable).WriteXml(writer);
+            writer.WriteEndElement();
+        }
+    
+		#endregion
+	}
+}
+
diff --git a/src/GraphicObjects/Base/Expandable.cs b/src/GraphicObjects/Base/Expandable.cs
new file mode 100644
index 00000000..1cb36450
--- /dev/null
+++ b/src/GraphicObjects/Base/Expandable.cs
@@ -0,0 +1,141 @@
+//
+// Expandable.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.ComponentModel;
+using System.Xml.Serialization;
+
+namespace Crow
+{
+    public class Expandable : TemplatedContainer
+    {
+		#region CTOR
+		public Expandable() : base()
+		{
+		}
+		#endregion
+
+		#region Private fields
+		bool _isExpanded;
+		string image;
+		Container _contentContainer;
+		#endregion
+
+		#region Event Handlers
+		public event EventHandler Expand;
+		public event EventHandler Collapse;
+		#endregion
+
+		public BooleanTestOnInstance GetIsExpandable;
+
+		public void onClickForExpand (object sender, MouseButtonEventArgs e)
+		{
+			IsExpanded = !IsExpanded;
+		}
+
+		public override GraphicObject Content {
+			get {
+				return _contentContainer == null ? null : _contentContainer.Child;
+			}
+			set {
+				_contentContainer.SetChild(value);
+				NotifyValueChanged ("HasContent", HasContent);
+			}
+		}
+		//TODO: move loadTemplate and ResolveBinding in TemplatedContainer
+		protected override void loadTemplate(GraphicObject template = null)
+		{
+			base.loadTemplate (template);
+
+			_contentContainer = this.child.FindByName ("Content") as Container;
+		}
+
+		#region Public properties
+		[XmlAttributeAttribute][DefaultValue("#Crow.Images.Icons.expandable.svg")]
+		public string Image {
+			get { return image; }
+			set {
+				if (image == value)
+					return;
+				image = value;
+				NotifyValueChanged ("Image", image);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(false)]
+        public bool IsExpanded
+        {
+			get { return _isExpanded; }
+            set
+            {
+				if (value == _isExpanded)
+					return;
+
+				_isExpanded = value;
+
+				bool isExp = IsExpandable;
+				NotifyValueChanged ("IsExpandable", isExp);
+				if (!(HasContent & isExp))
+					_isExpanded = false;
+
+				NotifyValueChanged ("IsExpanded", _isExpanded);
+
+				if (_isExpanded)
+					onExpand (this, null);
+				else
+					onCollapse (this, null);
+            }
+        }
+		[XmlIgnore]public bool HasContent {
+			get { return _contentContainer == null ? false : _contentContainer.Child != null; }
+		}
+		[XmlIgnore]public bool IsExpandable {
+			get {
+				try {
+					return GetIsExpandable == null ? true : GetIsExpandable (this);
+				} catch (Exception ex) {
+					System.Diagnostics.Debug.WriteLine ("Not Expandable error: " + ex.ToString ());
+					return false;
+				}
+			}
+		}
+		#endregion
+
+		public virtual void onExpand(object sender, EventArgs e)
+		{
+			if (_contentContainer != null)
+				_contentContainer.Visible = true;
+
+			Expand.Raise (this, e);
+		}
+		public virtual void onCollapse(object sender, EventArgs e)
+		{
+			if (_contentContainer != null)
+				_contentContainer.Visible = false;
+
+			Collapse.Raise (this, e);
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/GenericStack.cs b/src/GraphicObjects/Base/GenericStack.cs
new file mode 100644
index 00000000..cecdaffd
--- /dev/null
+++ b/src/GraphicObjects/Base/GenericStack.cs
@@ -0,0 +1,228 @@
+//
+// GenericStack.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Xml.Serialization;
+using System;
+
+namespace Crow
+{
+	public class GenericStack : Group
+    {
+		#region CTOR
+		public GenericStack()
+			: base()
+		{            
+		}
+		#endregion
+
+		#region Private fields
+        int _spacing;
+        Orientation _orientation;
+		#endregion
+
+		#region Public Properties
+        [XmlAttributeAttribute()][DefaultValue(2)]
+        public int Spacing
+        {
+			get { return _spacing; }
+            set { 
+				if (_spacing == value)
+					return;
+				_spacing = value; 
+				NotifyValueChanged ("Spacing", Spacing);
+				RegisterForLayouting (LayoutingType.Sizing|LayoutingType.ArrangeChildren);
+			}
+        }
+        [XmlAttributeAttribute()][DefaultValue(Orientation.Horizontal)]
+        public virtual Orientation Orientation
+        {
+            get { return _orientation; }
+            set { _orientation = value; }
+        }
+		#endregion
+
+		#region GraphicObject Overrides
+		public override bool ArrangeChildren { get { return true; } }
+		public override void ChildrenLayoutingConstraints (ref LayoutingType layoutType)
+		{
+			//Prevent child repositionning in the direction of stacking
+			if (Orientation == Orientation.Horizontal)
+				layoutType &= (~LayoutingType.X);
+			else
+				layoutType &= (~LayoutingType.Y);			
+		}
+		protected override int measureRawSize (LayoutingType lt)
+		{
+			int totSpace = 0;
+			for (int i = 0; i < Children.Count; i++) {
+				if (Children [i].Visible)
+					totSpace += Spacing;
+			}
+			if (totSpace > 0)
+				totSpace -= Spacing;
+			if (lt == LayoutingType.Width) {
+				if (Orientation == Orientation.Horizontal)
+					return contentSize.Width + totSpace + 2 * Margin;
+			}else if (Orientation == Orientation.Vertical)
+				return contentSize.Height + totSpace + 2 * Margin;							
+			
+			return base.measureRawSize (lt);
+		}
+		public virtual void ComputeChildrenPositions()
+		{
+			int d = 0;
+			if (Orientation == Orientation.Horizontal) {
+				foreach (GraphicObject c in Children) {
+					if (!c.Visible)
+						continue;
+					c.Slot.X = d;
+					d += c.Slot.Width + Spacing;
+				}
+			} else {
+				foreach (GraphicObject c in Children) {
+					if (!c.Visible)
+						continue;					
+					c.Slot.Y = d;
+					d += c.Slot.Height + Spacing;
+				}
+			}
+			IsDirty = true;
+		}
+		GraphicObject stretchedGO = null;
+		public override bool UpdateLayout (LayoutingType layoutType)
+        {
+			RegisteredLayoutings &= (~layoutType);
+
+			if (layoutType == LayoutingType.ArrangeChildren) {
+				//allow 1 child to have size to 0 if stack has fixed or streched size policy,
+				//this child will occupy remaining space
+				//if stack size policy is Fit, no child may have stretch enabled
+				//in the direction of stacking.
+				ComputeChildrenPositions ();
+
+				//if no layouting remains in queue for item, registre for redraw
+				if (RegisteredLayoutings == LayoutingType.None && IsDirty)
+					CurrentInterface.EnqueueForRepaint (this);
+
+				return true;
+			}
+
+			return base.UpdateLayout(layoutType);
+        }
+
+		public override void OnChildLayoutChanges (object sender, LayoutingEventArgs arg)
+		{
+			GraphicObject go = sender as GraphicObject;
+			//Debug.WriteLine ("child layout change: " + go.LastSlots.ToString() + " => " + go.Slot.ToString());
+			switch (arg.LayoutType) {
+			case LayoutingType.Width:
+				if (Orientation == Orientation.Horizontal) {
+					if (go.Width == Measure.Stretched) {
+						if (stretchedGO == null && Width != Measure.Fit)
+							stretchedGO = go;
+						else if (stretchedGO != go) {
+							go.Slot.Width = 0;
+							go.Width = Measure.Fit;
+							return;
+						}
+					} else
+						contentSize.Width += go.Slot.Width - go.LastSlots.Width;
+
+					if (stretchedGO != null) {
+						int newW = Math.Max (
+							           this.ClientRectangle.Width - contentSize.Width - Spacing * (Children.Count - 1),
+							           stretchedGO.MinimumSize.Width);
+						if (stretchedGO.MaximumSize.Width > 0)
+							newW = Math.Min (newW, stretchedGO.MaximumSize.Width);
+						if (newW != stretchedGO.Slot.Width) {							
+							stretchedGO.Slot.Width = newW;
+							stretchedGO.IsDirty = true;
+#if DEBUG_LAYOUTING
+					Debug.WriteLine ("\tAdjusting Width of " + stretchedGO.ToString());
+#endif
+							stretchedGO.LayoutChanged -= OnChildLayoutChanges;
+							stretchedGO.OnLayoutChanges (LayoutingType.Width);
+							stretchedGO.LayoutChanged += OnChildLayoutChanges;
+							stretchedGO.LastSlots.Width = stretchedGO.Slot.Width;
+						}
+					}
+					
+					if (Width == Measure.Fit)
+						this.RegisterForLayouting (LayoutingType.Width);
+					
+					this.RegisterForLayouting (LayoutingType.ArrangeChildren);
+					return;
+				}
+				break;
+			case LayoutingType.Height:
+				if (Orientation == Orientation.Vertical) {
+					if (go.Height == Measure.Stretched) {
+						if (stretchedGO == null && Height != Measure.Fit)
+							stretchedGO = go;
+						else if (stretchedGO != go){
+							go.Slot.Height = 0;
+							go.Height = Measure.Fit;
+							return;
+						}
+					} else
+						contentSize.Height += go.Slot.Height - go.LastSlots.Height;
+					
+					if (stretchedGO != null) {
+						int newH = Math.Max (
+							this.ClientRectangle.Height - contentSize.Height - Spacing * (Children.Count - 1),
+							stretchedGO.MinimumSize.Height);
+						if (stretchedGO.MaximumSize.Height > 0)
+							newH = Math.Min (newH, stretchedGO.MaximumSize.Height);
+						if (newH != stretchedGO.Slot.Height) {
+							stretchedGO.Slot.Height = newH;
+							stretchedGO.IsDirty = true;
+#if DEBUG_LAYOUTING
+					Debug.WriteLine ("\tAdjusting Height of " + stretchedGO.ToString());
+#endif
+							stretchedGO.LayoutChanged -= OnChildLayoutChanges;
+							stretchedGO.OnLayoutChanges (LayoutingType.Height);
+							stretchedGO.LayoutChanged += OnChildLayoutChanges;
+							stretchedGO.LastSlots.Height = stretchedGO.Slot.Height;
+						}
+					}
+
+					if (Height == Measure.Fit)
+						this.RegisterForLayouting (LayoutingType.Height);
+
+					this.RegisterForLayouting (LayoutingType.ArrangeChildren);
+					return;
+				}
+				break;
+			}
+			base.OnChildLayoutChanges (sender, arg);
+		}
+		#endregion
+
+    
+	}
+}
diff --git a/src/GraphicObjects/Base/GraphicObject.cs b/src/GraphicObjects/Base/GraphicObject.cs
new file mode 100644
index 00000000..2afbe336
--- /dev/null
+++ b/src/GraphicObjects/Base/GraphicObject.cs
@@ -0,0 +1,1555 @@
+//
+// GraphicObject.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Xml.Serialization;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using Cairo;
+using System.Linq;
+using System.Diagnostics;
+using System.IO;
+
+namespace Crow
+{
+	public class GraphicObject : IXmlSerializable, ILayoutable, IValueChange, ICloneable
+	{
+		internal static ulong currentUid = 0;
+		internal ulong uid = 0;
+
+		Interface currentInterface = null;
+
+		[XmlIgnore]public Interface CurrentInterface {
+			get {
+				if (currentInterface == null) {
+					currentInterface = Interface.CurrentInterface;
+					Initialize ();
+				}
+				return currentInterface;
+			}
+			set {
+				currentInterface = value;
+			}
+		}
+
+		Rectangles clipping = new Rectangles();
+		public Rectangles Clipping { get { return clipping; }}
+
+		#region IValueChange implementation
+		public event EventHandler<ValueChangeEventArgs> ValueChanged;
+		public virtual void NotifyValueChanged(string MemberName, object _value)
+		{
+			//Debug.WriteLine ("Value changed: {0}->{1} = {2}", this, MemberName, _value);
+			ValueChanged.Raise(this, new ValueChangeEventArgs(MemberName, _value));
+		}
+		#endregion
+
+		#region CTOR
+		public GraphicObject ()
+		{
+			#if DEBUG
+			uid = currentUid;
+			currentUid++;
+			#endif
+		}
+		#endregion
+
+		/// <summary>
+		/// Initialize this Graphic object instance by setting style and default values and loading template if required
+		/// </summary>
+		public virtual void Initialize(){
+			if (currentInterface == null)
+				currentInterface = Interface.CurrentInterface;
+			loadDefaultValues ();
+		}
+		#region private fields
+		LayoutingType registeredLayoutings = LayoutingType.All;
+		ILayoutable logicalParent;
+		ILayoutable parent;
+		string name;
+		Fill background = Color.Transparent;
+		Fill foreground = Color.White;
+		Font font = "droid, 10";
+		Measure width, height;
+		int left, top;
+		double cornerRadius = 0;
+		int margin = 0;
+		bool focusable = false;
+		bool hasFocus = false;
+		bool isActive = false;
+		bool mouseRepeat;
+		protected bool isVisible = true;
+		bool isEnabled = true;
+		VerticalAlignment verticalAlignment = VerticalAlignment.Center;
+		HorizontalAlignment horizontalAlignment = HorizontalAlignment.Center;
+		Size maximumSize = "0,0";
+		Size minimumSize = "0,0";
+		bool cacheEnabled = false;
+		bool clipToClientRect = true;
+		protected object dataSource;
+		string style;
+		object tag;
+		#endregion
+
+		#region public fields
+		/// <summary>
+		/// Current size and position computed during layouting pass
+		/// </summary>
+		public Rectangle Slot = new Rectangle ();
+		/// <summary>
+		/// keep last slot components for each layouting pass to track
+		/// changes and trigger update of other component accordingly
+		/// </summary>
+		public Rectangle LastSlots;
+		/// <summary>
+		/// keep last slot painted on screen to clear traces if moved or resized
+		/// TODO: we should ensure the whole parsed widget tree is the last painted
+		/// version to clear effective oldslot if parents have been moved or resized.
+		/// IDEA is to add a ScreenCoordinates function that use only lastPaintedSlots
+		/// </summary>
+		public Rectangle LastPaintedSlot;
+		/// <summary>Prevent requeuing multiple times the same widget</summary>
+		public bool IsQueueForRedraw = false;
+		/// <summary>drawing Cache, if null, a redraw is done, cached or not</summary>
+		public byte[] bmp;
+		public bool IsDirty = true;
+		/// <summary>
+		/// This size is computed on each child' layout changes.
+		/// In stacking widget, it is used to compute the remaining space for the stretched
+		/// widget inside the stack, which is never added to the contentSize, instead, its size
+		/// is deducted from (parent.ClientRectangle - contentSize)
+		/// </summary>
+		internal Size contentSize;
+		#endregion
+
+		#region ILayoutable
+		[XmlIgnore]public LayoutingType RegisteredLayoutings { get { return registeredLayoutings; } set { registeredLayoutings = value; } }
+		//TODO: it would save the recurent cost of a cast in event bubbling if parent type was GraphicObject
+		//		or we could add to the interface the mouse events
+		/// <summary>
+		/// Parent in the graphic tree, used for rendering and layouting
+		/// </summary>
+		[XmlIgnore]public virtual ILayoutable Parent {
+			get { return parent; }
+			set {
+				if (parent == value)
+					return;
+				DataSourceChangeEventArgs e = new DataSourceChangeEventArgs (parent, value);
+				lock (this)
+					parent = value;
+
+				onParentChanged (this, e);
+			}
+		}
+		[XmlIgnore]public ILayoutable LogicalParent {
+			get { return logicalParent == null ? Parent : logicalParent; }
+			set {
+				if (logicalParent == value)
+					return;
+				if (logicalParent != null)
+					(logicalParent as GraphicObject).DataSourceChanged -= onLogicalParentDataSourceChanged;
+				DataSourceChangeEventArgs dsce = new DataSourceChangeEventArgs (LogicalParent, null);
+				logicalParent = value;
+				dsce.NewDataSource = LogicalParent;
+				if (logicalParent != null)
+					(logicalParent as GraphicObject).DataSourceChanged += onLogicalParentDataSourceChanged;
+				onLogicalParentChanged (this, dsce);
+			}
+		}
+		[XmlIgnore]public virtual Rectangle ClientRectangle {
+			get {
+				Rectangle cb = Slot.Size;
+				cb.Inflate ( - Margin);
+				return cb;
+			}
+		}
+		public virtual Rectangle ContextCoordinates(Rectangle r){
+			GraphicObject go = Parent as GraphicObject;
+			if (go == null)
+				return r + Parent.ClientRectangle.Position;
+			return go.CacheEnabled ?
+				r + Parent.ClientRectangle.Position :
+				Parent.ContextCoordinates (r);
+		}
+		public virtual Rectangle ScreenCoordinates (Rectangle r){
+			return
+				Parent.ScreenCoordinates(r) + Parent.getSlot().Position + Parent.ClientRectangle.Position;
+		}
+		public virtual Rectangle getSlot () { return Slot;}
+		#endregion
+
+		#region EVENT HANDLERS
+		public event EventHandler<MouseWheelEventArgs> MouseWheelChanged;
+		public event EventHandler<MouseButtonEventArgs> MouseUp;
+		public event EventHandler<MouseButtonEventArgs> MouseDown;
+		public event EventHandler<MouseButtonEventArgs> MouseClick;
+		public event EventHandler<MouseButtonEventArgs> MouseDoubleClick;
+		public event EventHandler<MouseMoveEventArgs> MouseMove;
+		public event EventHandler<MouseMoveEventArgs> MouseEnter;
+		public event EventHandler<MouseMoveEventArgs> MouseLeave;
+		public event EventHandler<KeyboardKeyEventArgs> KeyDown;
+		public event EventHandler<KeyboardKeyEventArgs> KeyUp;
+		public event EventHandler<KeyPressEventArgs> KeyPress;
+		public event EventHandler Focused;
+		public event EventHandler Unfocused;
+		public event EventHandler Enabled;
+		public event EventHandler Disabled;
+		public event EventHandler<LayoutingEventArgs> LayoutChanged;
+		public event EventHandler<DataSourceChangeEventArgs> DataSourceChanged;
+		public event EventHandler<DataSourceChangeEventArgs> ParentChanged;
+		public event EventHandler<DataSourceChangeEventArgs> LogicalParentChanged;
+		#endregion
+
+		#region public properties
+		/// <summary>Random value placeholder</summary>
+		[XmlAttributeAttribute]
+		public object Tag {
+			get { return tag; }
+			set {
+				if (tag == value)
+					return;
+				tag = value;
+				NotifyValueChanged ("Tag", tag);
+			}
+		}
+		/// <summary>
+		/// If enabled, resulting bitmap of graphic object is cached in an byte array
+		/// speeding up rendering of complex object. Default is enabled.
+		/// </summary>
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public virtual bool CacheEnabled {
+			get { return cacheEnabled; }
+			set {
+				if (cacheEnabled == value)
+					return;
+				cacheEnabled = value;
+				NotifyValueChanged ("CacheEnabled", cacheEnabled);
+			}
+		}
+		/// <summary>
+		/// If true, rendering of GraphicObject is clipped inside client rectangle
+		/// </summary>
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public virtual bool ClipToClientRect {
+			get { return clipToClientRect; }
+			set {
+				if (clipToClientRect == value)
+					return;
+				clipToClientRect = value;
+				NotifyValueChanged ("ClipToClientRect", clipToClientRect);
+				this.RegisterForRedraw ();
+			}
+		}
+		/// <summary>
+		/// Name is used in binding to reference other GraphicObjects inside the graphic tree
+		/// </summary>
+		[XmlAttributeAttribute][DefaultValue(null)]
+		public virtual string Name {
+			get {
+				#if DEBUG
+				return string.IsNullOrEmpty(name) ? this.GetType().Name + uid.ToString () : name;
+				#else
+				return name;
+				#endif
+			}
+			set {
+				if (name == value)
+					return;
+				name = value;
+				NotifyValueChanged("Name", name);
+			}
+		}
+		[XmlAttributeAttribute	()][DefaultValue(VerticalAlignment.Center)]
+		public virtual VerticalAlignment VerticalAlignment {
+			get { return verticalAlignment; }
+			set {
+				if (verticalAlignment == value)
+					return;
+
+				verticalAlignment = value;
+				NotifyValueChanged("VerticalAlignment", verticalAlignment);
+				RegisterForLayouting (LayoutingType.Y);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(HorizontalAlignment.Center)]
+		public virtual HorizontalAlignment HorizontalAlignment {
+			get { return horizontalAlignment; }
+			set {
+				if (horizontalAlignment == value)
+					return;
+				horizontalAlignment = value;
+				NotifyValueChanged("HorizontalAlignment", horizontalAlignment);
+				RegisterForLayouting (LayoutingType.X);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(0)]
+		public virtual int Left {
+			get { return left; }
+			set {
+				if (left == value)
+					return;
+				left = value;
+				NotifyValueChanged ("Left", left);
+				this.RegisterForLayouting (LayoutingType.X);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(0)]
+		public virtual int Top {
+			get { return top; }
+			set {
+				if (top == value)
+					return;
+				top = value;
+				NotifyValueChanged ("Top", top);
+				this.RegisterForLayouting (LayoutingType.Y);
+			}
+		}
+		/// <summary>
+		/// When set to True, the <see cref="T:Crow.GraphicObject"/>'s width and height will be set to Fit.
+		/// </summary>
+		[XmlAttributeAttribute()][DefaultValue(false)]
+		public virtual bool Fit {
+			get { return Width == Measure.Fit && Height == Measure.Fit ? true : false; }
+			set {
+				if (value == Fit)
+					return;
+
+				Width = Height = Measure.Fit;
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("Inherit")]
+		public virtual Measure Width {
+			get {
+				return width.Units == Unit.Inherit ?
+					Parent is GraphicObject ? (Parent as GraphicObject).WidthPolicy :
+					Measure.Stretched : width;
+			}
+			set {
+				if (width == value)
+					return;
+				if (value.IsFixed) {
+					if (value < MinimumSize.Width || (value > MaximumSize.Width && MaximumSize.Width > 0))
+						return;
+				}
+				Measure lastWP = WidthPolicy;
+				width = value;
+				NotifyValueChanged ("Width", width);
+				if (WidthPolicy != lastWP) {
+					NotifyValueChanged ("WidthPolicy", WidthPolicy);
+					//contentSize in Stacks are only update on childLayoutChange, and the single stretched
+					//child of the stack is not counted in contentSize, so when changing size policy of a child
+					//we should adapt contentSize
+					//TODO:check case when child become stretched, and another stretched item already exists.
+					if (parent is GenericStack) {//TODO:check if I should test Group instead
+						if ((parent as GenericStack).Orientation == Orientation.Horizontal) {
+							if (lastWP == Measure.Fit)
+								(parent as GenericStack).contentSize.Width -= this.LastSlots.Width;
+							else
+								(parent as GenericStack).contentSize.Width += this.LastSlots.Width;
+						}
+					}
+				}
+
+				this.RegisterForLayouting (LayoutingType.Width);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("Inherit")]
+		public virtual Measure Height {
+			get {
+				return height.Units == Unit.Inherit ?
+					Parent is GraphicObject ? (Parent as GraphicObject).HeightPolicy :
+					Measure.Stretched : height;
+			}
+			set {
+				if (height == value)
+					return;
+				if (value.IsFixed) {
+					if (value < MinimumSize.Height || (value > MaximumSize.Height && MaximumSize.Height > 0))
+						return;
+				}
+				Measure lastHP = HeightPolicy;
+				height = value;
+				NotifyValueChanged ("Height", height);
+				if (HeightPolicy != lastHP) {
+					NotifyValueChanged ("HeightPolicy", HeightPolicy);
+					if (parent is GenericStack) {
+						if ((parent as GenericStack).Orientation == Orientation.Vertical) {
+							if (lastHP == Measure.Fit)
+								(parent as GenericStack).contentSize.Height -= this.LastSlots.Height;
+							else
+								(parent as GenericStack).contentSize.Height += this.LastSlots.Height;
+						}
+					}
+				}
+
+				this.RegisterForLayouting (LayoutingType.Height);
+			}
+		}
+		/// <summary>
+		/// Used for binding on dimensions, this property will never hold fixed size, but instead only
+		/// Fit or Stretched
+		/// </summary>
+		[XmlIgnore]public virtual Measure WidthPolicy { get {
+				return Width.IsFit ? Measure.Fit : Measure.Stretched; } }
+		/// <summary>
+		/// Used for binding on dimensions, this property will never hold fixed size, but instead only
+		/// Fit or Stretched
+		/// </summary>
+		[XmlIgnore]public virtual Measure HeightPolicy { get {
+				return Height.IsFit ? Measure.Fit : Measure.Stretched; } }
+		[XmlAttributeAttribute()][DefaultValue(false)]
+		public virtual bool Focusable {
+			get { return focusable; }
+			set {
+				if (focusable == value)
+					return;
+				focusable = value;
+				NotifyValueChanged ("Focusable", focusable);
+			}
+		}
+		[XmlIgnore]public virtual bool HasFocus {
+			get { return hasFocus; }
+			set {
+				if (value == hasFocus)
+					return;
+
+				hasFocus = value;
+				if (hasFocus)
+					onFocused (this, null);
+				else
+					onUnfocused (this, null);
+				NotifyValueChanged ("HasFocus", hasFocus);
+			}
+		}
+		[XmlIgnore]public virtual bool IsActive {
+			get { return isActive; }
+			set {
+				if (value == isActive)
+					return;
+
+				isActive = value;
+				NotifyValueChanged ("IsActive", isActive);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(false)]
+		public virtual bool MouseRepeat {
+			get { return mouseRepeat; }
+			set {
+				if (mouseRepeat == value)
+					return;
+				mouseRepeat = value;
+				NotifyValueChanged ("MouseRepeat", mouseRepeat);
+			}
+		}
+		bool clearBackground = false;
+		[XmlAttributeAttribute()][DefaultValue("Transparent")]
+		public virtual Fill Background {
+			get { return background; }
+			set {
+				if (background == value)
+					return;
+				clearBackground = false;
+				if (value == null)
+					return;
+				background = value;
+				NotifyValueChanged ("Background", background);
+				RegisterForRedraw ();
+				if (background is SolidColor) {
+					if ((Background as SolidColor).Equals (Color.Clear))
+						clearBackground = true;
+				}
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("White")]
+		public virtual Fill Foreground {
+			get { return foreground; }
+			set {
+				if (foreground == value)
+					return;
+				foreground = value;
+				NotifyValueChanged ("Foreground", foreground);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("sans,10")]
+		public virtual Font Font {
+			get { return font; }
+			set {
+				if (value == font)
+					return;
+				font = value;
+				NotifyValueChanged ("Font", font);
+				RegisterForGraphicUpdate ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(0.0)]
+		public virtual double CornerRadius {
+			get { return cornerRadius; }
+			set {
+				if (value == cornerRadius)
+					return;
+				cornerRadius = value;
+				NotifyValueChanged ("CornerRadius", cornerRadius);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(0)]
+		public virtual int Margin {
+			get { return margin; }
+			set {
+				if (value == margin)
+					return;
+				margin = value;
+				NotifyValueChanged ("Margin", margin);
+				RegisterForGraphicUpdate ();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public virtual bool Visible {
+			get { return isVisible; }
+			set {
+				if (value == isVisible)
+					return;
+
+				isVisible = value;
+
+				if (isVisible)
+					RegisterForLayouting (LayoutingType.Sizing);
+				else {
+					lock (CurrentInterface.UpdateMutex) {
+						Slot.Width = 0;
+						LayoutChanged.Raise (this, new LayoutingEventArgs (LayoutingType.Width));
+						Slot.Height = 0;
+						LayoutChanged.Raise (this, new LayoutingEventArgs (LayoutingType.Height));
+						if (this.parent != null)
+							CurrentInterface.EnqueueForRepaint (this);
+						LastSlots.Width = LastSlots.Height = 0;
+					}
+				}
+
+				//trigger a mouse to handle possible hover changes
+				CurrentInterface.ProcessMouseMove (CurrentInterface.Mouse.X, CurrentInterface.Mouse.Y);
+
+				NotifyValueChanged ("Visible", isVisible);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public virtual bool IsEnabled {
+			get { return isEnabled; }
+			set {
+				if (value == isEnabled)
+					return;
+
+				isEnabled = value;
+
+				if (isEnabled)
+					onEnable (this, null);
+				else
+					onDisable (this, null);
+
+				NotifyValueChanged ("IsEnabled", isEnabled);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("1,1")]
+		public virtual Size MinimumSize {
+			get { return minimumSize; }
+			set {
+				if (value == minimumSize)
+					return;
+
+				minimumSize = value;
+
+				NotifyValueChanged ("MinimumSize", minimumSize);
+				RegisterForLayouting (LayoutingType.Sizing);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("0,0")]
+		public virtual Size MaximumSize {
+			get { return maximumSize; }
+			set {
+				if (value == maximumSize)
+					return;
+
+				maximumSize = value;
+
+				NotifyValueChanged ("MaximumSize", maximumSize);
+				RegisterForLayouting (LayoutingType.Sizing);
+			}
+		}
+		/// <summary>
+		/// Seek first logical tree upward if logicalParent is set, or seek graphic tree for
+		/// a not null dataSource that will be active for all descendants having dataSource=null
+		/// </summary>
+		[XmlAttributeAttribute][DefaultValue(null)]
+		public virtual object DataSource {
+			set {
+				if (DataSource == value)
+					return;
+
+				DataSourceChangeEventArgs dse = new DataSourceChangeEventArgs (DataSource, null);
+				dataSource = value;
+				dse.NewDataSource = DataSource;
+
+				OnDataSourceChanged (this, dse);
+
+				NotifyValueChanged ("DataSource", DataSource);
+			}
+			get {
+				return dataSource == null ?
+					LogicalParent == null ? null :
+					LogicalParent is GraphicObject ? (LogicalParent as GraphicObject).DataSource : null :
+					dataSource;
+			}
+		}
+		protected virtual void onLogicalParentDataSourceChanged(object sender, DataSourceChangeEventArgs e){
+			if (localDataSourceIsNull)
+				OnDataSourceChanged (this, e);
+		}
+		internal bool localDataSourceIsNull { get { return dataSource == null; } }
+		internal bool localLogicalParentIsNull { get { return logicalParent == null; } }
+
+		public virtual void OnDataSourceChanged(object sender, DataSourceChangeEventArgs e){
+			DataSourceChanged.Raise (this, e);
+			#if DEBUG_BINDING
+			Debug.WriteLine("New DataSource for => {0} \n\t{1}=>{2}", this.ToString(),e.OldDataSource,e.NewDataSource);
+			#endif
+		}
+
+		[XmlAttributeAttribute]
+		public virtual string Style {
+			get { return style; }
+			set {
+				if (value == style)
+					return;
+
+				style = value;
+
+				NotifyValueChanged ("Style", style);
+			}
+		}
+		#endregion
+
+		#region Default and Style Values loading
+		/// <summary> Loads the default values from XML attributes default </summary>
+		public void loadDefaultValues()
+		{
+			#if DEBUG_LOAD
+			Debug.WriteLine ("LoadDefValues for " + this.ToString ());
+			#endif
+
+			Type thisType = this.GetType ();
+
+			if (!string.IsNullOrEmpty (Style)) {
+				if (Interface.DefaultValuesLoader.ContainsKey (Style)) {
+					Interface.DefaultValuesLoader [Style] (this);
+					return;
+				}
+			} else {
+				if (Interface.DefaultValuesLoader.ContainsKey (thisType.FullName)) {
+					Interface.DefaultValuesLoader [thisType.FullName] (this);
+					return;
+				} else if (!Interface.Styling.ContainsKey (thisType.FullName)) {
+					if (Interface.DefaultValuesLoader.ContainsKey (thisType.Name)) {
+						Interface.DefaultValuesLoader [thisType.Name] (this);
+						return;
+					}
+				}
+			}
+
+			List<Style> styling = new List<Style>();
+
+			//Search for a style matching :
+			//1: Full class name, with full namespace
+			//2: class name
+			//3: style may have been registered with their ressource ID minus .style extention
+			//   those files being placed in a Styles folder
+			string styleKey = Style;
+			if (!string.IsNullOrEmpty (Style)) {
+				if (Interface.Styling.ContainsKey (Style)) {
+					styling.Add (Interface.Styling [Style]);
+				}
+			}
+			if (Interface.Styling.ContainsKey (thisType.FullName)) {
+				styling.Add (Interface.Styling [thisType.FullName]);
+				if (string.IsNullOrEmpty (styleKey))
+					styleKey = thisType.FullName;
+			}
+			if (Interface.Styling.ContainsKey (thisType.Name)) {
+				styling.Add (Interface.Styling [thisType.Name]);
+				if (string.IsNullOrEmpty (styleKey))
+					styleKey = thisType.Name;
+			}
+
+			if (string.IsNullOrEmpty (styleKey))
+				styleKey = thisType.FullName;
+
+
+			//Reflexion being very slow compared to dyn method or delegates,
+			//I compile the initial values coded in the CustomAttribs of the class,
+			//all other instance of this type would not longer use reflexion to init properly
+			//but will fetch the  dynamic initialisation method compiled for this precise type
+			//TODO:measure speed gain.
+			#region Delfault values Loading dynamic compilation
+			DynamicMethod dm = null;
+			ILGenerator il = null;
+
+			dm = new DynamicMethod("dyn_loadDefValues",
+				MethodAttributes.Family | MethodAttributes.FamANDAssem | MethodAttributes.NewSlot,
+				CallingConventions.Standard,
+				typeof(void),new Type[] {CompilerServices.TObject},thisType,true);
+
+			il = dm.GetILGenerator(256);
+			il.DeclareLocal(CompilerServices.TObject);
+			il.Emit(OpCodes.Nop);
+			//set local GraphicObject to root object passed as 1st argument
+			il.Emit (OpCodes.Ldarg_0);
+			il.Emit (OpCodes.Stloc_0);
+
+			foreach (EventInfo ei in thisType.GetEvents(BindingFlags.Public | BindingFlags.Instance)) {
+				string expression;
+				if (!getDefaultEvent(ei, styling, out expression))
+					continue;
+				//TODO:dynEventHandler could be cached somewhere, maybe a style instanciator class holding the styling delegate and bound to it.
+				foreach (string exp in CompilerServices.splitOnSemiColumnOutsideAccolades(expression)) {
+					string trimed = exp.Trim();
+					if (trimed.StartsWith ("{", StringComparison.OrdinalIgnoreCase)){
+						il.Emit (OpCodes.Ldloc_0);//load this as 1st arg of event Add
+
+						//push eventInfo as 1st arg of compile
+						il.Emit (OpCodes.Ldloc_0);
+						il.Emit (OpCodes.Call, CompilerServices.miGetType);
+						il.Emit (OpCodes.Ldstr, ei.Name);//push event name
+						il.Emit (OpCodes.Call, CompilerServices.miGetEvent);
+						//push expression as 2nd arg of compile
+						il.Emit (OpCodes.Ldstr, trimed.Substring (1, trimed.Length - 2));
+						//push null as 3rd arg, currentNode, not known when instanciing
+						il.Emit (OpCodes.Ldnull);
+						il.Emit (OpCodes.Callvirt, CompilerServices.miCompileDynEventHandler);
+						il.Emit (OpCodes.Castclass, ei.EventHandlerType);
+						il.Emit (OpCodes.Callvirt, ei.AddMethod);
+					}else
+						Debug.WriteLine("error in styling, event not handled : " + trimed);
+				}
+			}
+
+			foreach (PropertyInfo pi in thisType.GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
+				if (pi.GetSetMethod () == null)
+					continue;
+				object defaultValue;
+				if (!getDefaultValue (pi, styling, out defaultValue))
+					continue;
+
+				CompilerServices.EmitSetValue (il, pi, defaultValue);
+			}
+			il.Emit(OpCodes.Ret);
+			#endregion
+
+			try {
+				Interface.DefaultValuesLoader[styleKey] = (Interface.LoaderInvoker)dm.CreateDelegate(typeof(Interface.LoaderInvoker));
+				Interface.DefaultValuesLoader[styleKey] (this);
+			} catch (Exception ex) {
+				throw new Exception ("Error applying style <" + styleKey + ">:", ex);
+			}
+		}
+		bool getDefaultEvent(EventInfo ei, List<Style> styling,
+			out string expression){
+			expression = "";
+			if (styling.Count > 0){
+				for (int i = 0; i < styling.Count; i++) {
+					if (styling[i].ContainsKey (ei.Name)){
+						expression = (string)styling[i] [ei.Name];
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+		bool getDefaultValue(PropertyInfo pi, List<Style> styling,
+			out object defaultValue){
+			defaultValue = null;
+			string name = "";
+
+			XmlIgnoreAttribute xia = (XmlIgnoreAttribute)pi.GetCustomAttribute (typeof(XmlIgnoreAttribute));
+			if (xia != null)
+				return false;
+			XmlAttributeAttribute xaa = (XmlAttributeAttribute)pi.GetCustomAttribute (typeof(XmlAttributeAttribute));
+			if (xaa != null) {
+				if (string.IsNullOrEmpty (xaa.AttributeName))
+					name = pi.Name;
+				else
+					name = xaa.AttributeName;
+			}
+
+			int styleIndex = -1;
+			if (styling.Count > 0){
+				for (int i = 0; i < styling.Count; i++) {
+					if (styling[i].ContainsKey (name)){
+						styleIndex = i;
+						break;
+					}
+				}
+			}
+			if (styleIndex >= 0){
+				if (pi.PropertyType.IsEnum)//maybe should be in parser..
+					defaultValue = Enum.Parse(pi.PropertyType, (string)styling[styleIndex] [name], true);
+				else
+					defaultValue = styling[styleIndex] [name];
+			}else {
+				DefaultValueAttribute dv = (DefaultValueAttribute)pi.GetCustomAttribute (typeof (DefaultValueAttribute));
+				if (dv == null)
+					return false;
+				defaultValue = dv.Value;
+			}
+			return true;
+		}
+		#endregion
+
+		public virtual GraphicObject FindByName(string nameToFind){
+			return string.Equals(nameToFind, name, StringComparison.Ordinal) ? this : null;
+		}
+		public virtual bool Contains(GraphicObject goToFind){
+			return false;
+		}
+
+		#region Queuing
+		/// <summary>
+		/// Register old and new slot for clipping
+		/// </summary>
+		public virtual void ClippingRegistration(){
+			IsQueueForRedraw = false;
+			if (Parent == null)
+				return;
+			Parent.RegisterClip (LastPaintedSlot);
+			Parent.RegisterClip (Slot);
+		}
+		/// <summary>
+		/// Add clip rectangle to this.clipping and propagate up to root
+		/// </summary>
+		/// <param name="clip">Clip rectangle</param>
+		public virtual void RegisterClip(Rectangle clip){
+			if (CacheEnabled && !IsDirty)
+				Clipping.AddRectangle (clip + ClientRectangle.Position);
+			if (Parent == null)
+				return;
+			GraphicObject p = Parent as GraphicObject;
+			if (p?.IsDirty == true && p?.CacheEnabled == true)
+				return;
+			Parent.RegisterClip (clip + Slot.Position + ClientRectangle.Position);
+		}
+		/// <summary> Full update, taking care of sizing policy </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void RegisterForGraphicUpdate ()
+		{
+			IsDirty = true;
+			if (Width.IsFit || Height.IsFit)
+				RegisterForLayouting (LayoutingType.Sizing);
+			else if (RegisteredLayoutings == LayoutingType.None)
+				CurrentInterface.EnqueueForRepaint (this);
+		}
+		/// <summary> query an update of the content, a redraw </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void RegisterForRedraw ()
+		{
+			IsDirty = true;
+			if (RegisteredLayoutings == LayoutingType.None)
+				CurrentInterface.EnqueueForRepaint (this);
+		}
+		#endregion
+
+		#region Layouting
+
+		/// <summary> return size of content + margins </summary>
+		protected virtual int measureRawSize (LayoutingType lt) {
+			return lt == LayoutingType.Width ?
+				contentSize.Width + 2 * Margin: contentSize.Height + 2 * Margin;
+		}
+		/// <summary> By default in groups, LayoutingType.ArrangeChildren is reset </summary>
+		public virtual void ChildrenLayoutingConstraints(ref LayoutingType layoutType){
+		}
+		public virtual bool ArrangeChildren { get { return false; } }
+		public virtual void RegisterForLayouting(LayoutingType layoutType){
+			if (Parent == null)
+				return;
+			lock (CurrentInterface.LayoutMutex) {
+				//prevent queueing same LayoutingType for this
+				layoutType &= (~RegisteredLayoutings);
+
+				if (layoutType == LayoutingType.None)
+					return;
+				//dont set position for stretched item
+				if (Width == Measure.Stretched)
+					layoutType &= (~LayoutingType.X);
+				if (Height == Measure.Stretched)
+					layoutType &= (~LayoutingType.Y);
+
+				if (!ArrangeChildren)
+					layoutType &= (~LayoutingType.ArrangeChildren);
+
+				//apply constraints depending on parent type
+				if (Parent is GraphicObject)
+					(Parent as GraphicObject).ChildrenLayoutingConstraints (ref layoutType);
+
+//				//prevent queueing same LayoutingType for this
+//				layoutType &= (~RegisteredLayoutings);
+
+				if (layoutType == LayoutingType.None)
+					return;
+
+				//enqueue LQI LayoutingTypes separately
+				if (layoutType.HasFlag (LayoutingType.Width))
+					CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.Width, this));
+				if (layoutType.HasFlag (LayoutingType.Height))
+					CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.Height, this));
+				if (layoutType.HasFlag (LayoutingType.X))
+					CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.X, this));
+				if (layoutType.HasFlag (LayoutingType.Y))
+					CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.Y, this));
+				if (layoutType.HasFlag (LayoutingType.ArrangeChildren))
+					CurrentInterface.LayoutingQueue.Enqueue (new LayoutingQueueItem (LayoutingType.ArrangeChildren, this));
+			}
+		}
+
+		/// <summary> trigger dependant sizing component update </summary>
+		public virtual void OnLayoutChanges(LayoutingType  layoutType)
+		{
+			#if DEBUG_LAYOUTING
+			CurrentInterface.currentLQI.Slot = LastSlots;
+			CurrentInterface.currentLQI.NewSlot = Slot;
+			Debug.WriteLine ("\t\t{0} => {1}",LastSlots,Slot);
+			#endif
+
+			switch (layoutType) {
+			case LayoutingType.Width:
+				RegisterForLayouting (LayoutingType.X);
+				break;
+			case LayoutingType.Height:
+				RegisterForLayouting (LayoutingType.Y);
+				break;
+			}
+			LayoutChanged.Raise (this, new LayoutingEventArgs (layoutType));
+		}
+		internal protected void raiseLayoutChanged(LayoutingEventArgs e){
+			LayoutChanged.Raise (this, e);
+		}
+		/// <summary> Update layout component only one at a time, this is where the computation of alignement
+		/// and size take place.
+		/// The redrawing will only be triggered if final slot size has changed </summary>
+		/// <returns><c>true</c>, if layouting was possible, <c>false</c> if conditions were not
+		/// met and LQI has to be re-queued</returns>
+		public virtual bool UpdateLayout (LayoutingType layoutType)
+		{
+			//unset bit, it would be reset if LQI is re-queued
+			registeredLayoutings &= (~layoutType);
+
+			switch (layoutType) {
+			case LayoutingType.X:
+				if (Left == 0) {
+
+					if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Width) ||
+					    RegisteredLayoutings.HasFlag (LayoutingType.Width))
+						return false;
+
+					switch (HorizontalAlignment) {
+					case HorizontalAlignment.Left:
+						Slot.X = 0;
+						break;
+					case HorizontalAlignment.Right:
+						Slot.X = Parent.ClientRectangle.Width - Slot.Width;
+						break;
+					case HorizontalAlignment.Center:
+						Slot.X = Parent.ClientRectangle.Width / 2 - Slot.Width / 2;
+						break;
+					}
+				} else
+					Slot.X = Left;
+
+				if (LastSlots.X == Slot.X)
+					break;
+
+				IsDirty = true;
+
+				OnLayoutChanges (layoutType);
+
+				LastSlots.X = Slot.X;
+				break;
+			case LayoutingType.Y:
+				if (Top == 0) {
+
+					if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Height) ||
+					    RegisteredLayoutings.HasFlag (LayoutingType.Height))
+						return false;
+
+					switch (VerticalAlignment) {
+					case VerticalAlignment.Top://this could be processed even if parent Height is not known
+						Slot.Y = 0;
+						break;
+					case VerticalAlignment.Bottom:
+						Slot.Y = Parent.ClientRectangle.Height - Slot.Height;
+						break;
+					case VerticalAlignment.Center:
+						Slot.Y = Parent.ClientRectangle.Height / 2 - Slot.Height / 2;
+						break;
+					}
+				} else
+					Slot.Y = Top;
+
+				if (LastSlots.Y == Slot.Y)
+					break;
+
+				IsDirty = true;
+
+				OnLayoutChanges (layoutType);
+
+				LastSlots.Y = Slot.Y;
+				break;
+			case LayoutingType.Width:
+				if (Visible) {
+					if (Width.IsFixed)
+						Slot.Width = Width;
+					else if (Width == Measure.Fit) {
+						Slot.Width = measureRawSize (LayoutingType.Width);
+					} else if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Width))
+						return false;
+					else if (Width == Measure.Stretched)
+						Slot.Width = Parent.ClientRectangle.Width;
+					else
+						Slot.Width = (int)Math.Round ((double)(Parent.ClientRectangle.Width * Width) / 100.0);
+
+					if (Slot.Width < 0)
+						return false;
+
+					//size constrain
+					if (Slot.Width < MinimumSize.Width) {
+						Slot.Width = MinimumSize.Width;
+						//NotifyValueChanged ("WidthPolicy", Measure.Stretched);
+					} else if (Slot.Width > MaximumSize.Width && MaximumSize.Width > 0) {
+						Slot.Width = MaximumSize.Width;
+						//NotifyValueChanged ("WidthPolicy", Measure.Stretched);
+					}
+				} else
+					Slot.Width = 0;
+
+				if (LastSlots.Width == Slot.Width)
+					break;
+
+				IsDirty = true;
+
+				OnLayoutChanges (layoutType);
+
+				LastSlots.Width = Slot.Width;
+				break;
+			case LayoutingType.Height:
+				if (Visible) {
+					if (Height.IsFixed)
+						Slot.Height = Height;
+					else if (Height == Measure.Fit) {
+						Slot.Height = measureRawSize (LayoutingType.Height);
+					} else if (Parent.RegisteredLayoutings.HasFlag (LayoutingType.Height))
+						return false;
+					else if (Height == Measure.Stretched)
+						Slot.Height = Parent.ClientRectangle.Height;
+					else
+						Slot.Height = (int)Math.Round ((double)(Parent.ClientRectangle.Height * Height) / 100.0);
+
+					if (Slot.Height < 0)
+						return false;
+
+					//size constrain
+					if (Slot.Height < MinimumSize.Height) {
+						Slot.Height = MinimumSize.Height;
+						//NotifyValueChanged ("HeightPolicy", Measure.Stretched);
+					} else if (Slot.Height > MaximumSize.Height && MaximumSize.Height > 0) {
+						Slot.Height = MaximumSize.Height;
+						//NotifyValueChanged ("HeightPolicy", Measure.Stretched);
+					}
+				} else
+					Slot.Height = 0;
+
+				if (LastSlots.Height == Slot.Height)
+					break;
+
+				IsDirty = true;
+
+				OnLayoutChanges (layoutType);
+
+				LastSlots.Height = Slot.Height;
+				break;
+			}
+
+			//if no layouting remains in queue for item, registre for redraw
+			if (this.registeredLayoutings == LayoutingType.None && IsDirty)
+				CurrentInterface.EnqueueForRepaint (this);
+
+			return true;
+		}
+		#endregion
+
+		#region Rendering
+		/// <summary> This is the common overridable drawing routine to create new widget </summary>
+		protected virtual void onDraw(Context gr)
+		{
+			Rectangle rBack = new Rectangle (Slot.Size);
+
+			Background.SetAsSource (gr, rBack);
+			CairoHelpers.CairoRectangle(gr,rBack,cornerRadius);
+			gr.Fill ();
+		}
+
+		/// <summary>
+		/// Internal drawing context creation on a cached surface limited to slot size
+		/// this trigger the effective drawing routine </summary>
+		protected virtual void RecreateCache ()
+		{
+			int stride = 4 * Slot.Width;
+
+			int bmpSize = Math.Abs (stride) * Slot.Height;
+			bmp = new byte[bmpSize];
+			IsDirty = false;
+			using (ImageSurface draw =
+                new ImageSurface(bmp, Format.Argb32, Slot.Width, Slot.Height, stride)) {
+				using (Context gr = new Context (draw)) {
+					gr.Antialias = Interface.Antialias;
+					onDraw (gr);
+				}
+				draw.Flush ();
+			}
+		}
+		protected virtual void UpdateCache(Context ctx){
+			Rectangle rb = Slot + Parent.ClientRectangle.Position;
+			using (ImageSurface cache = new ImageSurface (bmp, Format.Argb32, Slot.Width, Slot.Height, 4 * Slot.Width)) {
+				if (clearBackground) {
+						ctx.Save ();
+						ctx.Operator = Operator.Clear;
+						ctx.Rectangle (rb);
+						ctx.Fill ();
+						ctx.Restore ();
+				}
+				ctx.SetSourceSurface (cache, rb.X, rb.Y);
+				ctx.Paint ();
+			}
+			//Clipping.clearAndClip (ctx);
+			Clipping.Reset();
+		}
+		/// <summary> Chained painting routine on the parent context of the actual cached version
+		/// of the widget </summary>
+		public virtual void Paint (ref Context ctx)
+		{
+			//TODO:this test should not be necessary
+			if (Slot.Height < 0 || Slot.Width < 0 || parent == null)
+				return;
+			lock (this) {
+				if (cacheEnabled) {
+					if (Slot.Width > Interface.MaxCacheSize || Slot.Height > Interface.MaxCacheSize)
+						cacheEnabled = false;
+				}
+
+				if (cacheEnabled) {
+					if (IsDirty)
+						RecreateCache ();
+
+					UpdateCache (ctx);
+					if (!isEnabled)
+						paintDisabled (ctx, Slot + Parent.ClientRectangle.Position);
+				} else {
+					Rectangle rb = Slot + Parent.ClientRectangle.Position;
+					ctx.Save ();
+
+					ctx.Translate (rb.X, rb.Y);
+
+					onDraw (ctx);
+					if (!isEnabled)
+						paintDisabled (ctx, Slot);
+
+					ctx.Restore ();
+				}
+				LastPaintedSlot = Slot;
+			}
+		}
+		void paintDisabled(Context gr, Rectangle rb){
+			gr.Operator = Operator.Xor;
+			gr.SetSourceRGBA (0.6, 0.6, 0.6, 0.3);
+			gr.Rectangle (rb);
+			gr.Fill ();
+			gr.Operator = Operator.Over;
+		}
+		#endregion
+
+        #region Keyboard handling
+		public virtual void onKeyDown(object sender, KeyboardKeyEventArgs e){
+			KeyDown.Raise (sender, e);
+		}
+		public virtual void onKeyUp(object sender, KeyboardKeyEventArgs e){
+			KeyUp.Raise (sender, e);
+		}
+		public virtual void onKeyPress(object sender, KeyPressEventArgs e){
+			KeyPress.Raise (sender, e);
+		}
+        #endregion
+
+		#region Mouse handling
+		public virtual bool MouseIsIn(Point m)
+		{
+			try {
+				if (!(Visible & isEnabled))
+					return false;
+				if (ScreenCoordinates (Slot).ContainsOrIsEqual (m)) {
+					Scroller scr = Parent as Scroller;
+					if (scr == null) {
+						if (Parent is GraphicObject)
+							return (Parent as GraphicObject).MouseIsIn (m);
+						else return true;
+					}
+					return scr.MouseIsIn (scr.savedMousePos);
+				}
+			} catch (Exception ex) {
+				return false;
+			}
+			return false;
+		}
+		public virtual void checkHoverWidget(MouseMoveEventArgs e)
+		{
+			if (CurrentInterface.HoverWidget != this) {
+				CurrentInterface.HoverWidget = this;
+				onMouseEnter (this, e);
+			}
+
+			this.onMouseMove (this, e);//without this, window border doesn't work, should be removed
+		}
+		public virtual void onMouseMove(object sender, MouseMoveEventArgs e)
+		{
+			//bubble event to the top
+			GraphicObject p = Parent as GraphicObject;
+			if (p != null)
+				p.onMouseMove(sender,e);
+
+			MouseMove.Raise (this, e);
+		}
+		public virtual void onMouseDown(object sender, MouseButtonEventArgs e){
+			if (CurrentInterface.eligibleForDoubleClick == this && CurrentInterface.clickTimer.ElapsedMilliseconds < Interface.DoubleClick)
+				onMouseDoubleClick (this, e);
+			else
+				currentInterface.clickTimer.Restart();
+			CurrentInterface.eligibleForDoubleClick = null;
+
+			if (CurrentInterface.ActiveWidget == null)
+				CurrentInterface.ActiveWidget = this;
+			if (this.Focusable && !Interface.FocusOnHover) {
+				BubblingMouseButtonEventArg be = e as BubblingMouseButtonEventArg;
+				if (be.Focused == null) {
+					be.Focused = this;
+					CurrentInterface.FocusedWidget = this;
+				}
+			}
+			//bubble event to the top
+			GraphicObject p = Parent as GraphicObject;
+			if (p != null)
+				p.onMouseDown(sender,e);
+
+			MouseDown.Raise (this, e);
+		}
+		public virtual void onMouseUp(object sender, MouseButtonEventArgs e){
+			//bubble event to the top
+			GraphicObject p = Parent as GraphicObject;
+			if (p != null)
+				p.onMouseUp(sender,e);
+
+			MouseUp.Raise (this, e);
+
+			if (MouseIsIn (e.Position) && IsActive) {
+				if (CurrentInterface.clickTimer.ElapsedMilliseconds < Interface.DoubleClick)
+					CurrentInterface.eligibleForDoubleClick = this;
+				onMouseClick (this, e);
+			}
+		}
+		public virtual void onMouseClick(object sender, MouseButtonEventArgs e){
+			GraphicObject p = Parent as GraphicObject;
+			if (p != null)
+				p.onMouseClick(sender,e);
+			MouseClick.Raise (this, e);
+		}
+		public virtual void onMouseDoubleClick(object sender, MouseButtonEventArgs e){
+			GraphicObject p = Parent as GraphicObject;
+			if (p != null)
+				p.onMouseDoubleClick(sender,e);
+			MouseDoubleClick.Raise (this, e);
+		}
+		public virtual void onMouseWheel(object sender, MouseWheelEventArgs e){
+			GraphicObject p = Parent as GraphicObject;
+			if (p != null)
+				p.onMouseWheel(sender,e);
+
+			MouseWheelChanged.Raise (this, e);
+		}
+		public virtual void onMouseEnter(object sender, MouseMoveEventArgs e)
+		{
+			#if DEBUG_FOCUS
+			Debug.WriteLine("MouseEnter => " + this.ToString());
+			#endif
+			MouseEnter.Raise (this, e);
+		}
+		public virtual void onMouseLeave(object sender, MouseMoveEventArgs e)
+		{
+			#if DEBUG_FOCUS
+			Debug.WriteLine("MouseLeave => " + this.ToString());
+			#endif
+			MouseLeave.Raise (this, e);
+		}
+		#endregion
+
+		protected virtual void onFocused(object sender, EventArgs e){
+			#if DEBUG_FOCUS
+			Debug.WriteLine("Focused => " + this.ToString());
+			#endif
+			Focused.Raise (this, e);
+		}
+		protected virtual void onUnfocused(object sender, EventArgs e){
+			#if DEBUG_FOCUS
+			Debug.WriteLine("UnFocused => " + this.ToString());
+			#endif
+			Unfocused.Raise (this, e);
+		}
+		public virtual void onEnable(object sender, EventArgs e){
+			Enabled.Raise (this, e);
+		}
+		public virtual void onDisable(object sender, EventArgs e){
+			Disabled.Raise (this, e);
+		}
+		protected virtual void onParentChanged(object sender, DataSourceChangeEventArgs e) {
+			ParentChanged.Raise (this, e);
+			if (logicalParent == null)
+				LogicalParentChanged.Raise (this, e);
+		}
+		protected virtual void onLogicalParentChanged(object sender, DataSourceChangeEventArgs e) {
+			LogicalParentChanged.Raise (this, e);
+		}
+		#region IXmlSerializable
+		public virtual System.Xml.Schema.XmlSchema GetSchema ()
+		{
+			return null;
+		}
+//		void affectMember(string name, string value){
+//			Type thisType = this.GetType ();
+//
+//			if (string.IsNullOrEmpty (value))
+//				return;
+//
+//			MemberInfo mi = thisType.GetMember (name).FirstOrDefault();
+//			if (mi == null) {
+//				Debug.WriteLine ("XML: Unknown attribute in " + thisType.ToString() + " : " + name);
+//				return;
+//			}
+//			if (mi.MemberType == MemberTypes.Event) {
+//				this.Bindings.Add (new Binding (new MemberReference(this, mi), value));
+//				return;
+//			}
+//			if (mi.MemberType == MemberTypes.Property) {
+//				PropertyInfo pi = mi as PropertyInfo;
+//
+//				if (pi.GetSetMethod () == null) {
+//					Debug.WriteLine ("XML: Read only property in " + thisType.ToString() + " : " + name);
+//					return;
+//				}
+//
+//				XmlAttributeAttribute xaa = (XmlAttributeAttribute)pi.GetCustomAttribute (typeof(XmlAttributeAttribute));
+//				if (xaa != null) {
+//					if (!string.IsNullOrEmpty (xaa.AttributeName))
+//						name = xaa.AttributeName;
+//				}
+//				if (value.StartsWith("{",StringComparison.Ordinal)) {
+//					//binding
+//					if (!value.EndsWith("}", StringComparison.Ordinal))
+//						throw new Exception (string.Format("XML:Malformed binding: {0}", value));
+//
+//					this.Bindings.Add (new Binding (new MemberReference(this, pi), value.Substring (1, value.Length - 2)));
+//					return;
+//				}
+//				if (pi.GetCustomAttribute (typeof(XmlIgnoreAttribute)) != null)
+//					return;
+//				if (xaa == null)//not define as xmlAttribute
+//					return;
+//
+//				if (pi.PropertyType == typeof(string)) {
+//					pi.SetValue (this, value, null);
+//					return;
+//				}
+//
+//				if (pi.PropertyType.IsEnum) {
+//					pi.SetValue (this, Enum.Parse (pi.PropertyType, value), null);
+//				} else {
+//					MethodInfo me = pi.PropertyType.GetMethod ("Parse", new Type[] { typeof(string) });
+//					pi.SetValue (this, me.Invoke (null, new string[] { value }), null);
+//				}
+//			}
+//		}
+		public virtual void ReadXml (System.Xml.XmlReader reader)
+		{
+			if (reader.HasAttributes) {
+
+				style = reader.GetAttribute ("Style");
+
+				loadDefaultValues ();
+
+				while (reader.MoveToNextAttribute ()) {
+					if (reader.Name == "Style")
+						continue;
+
+					//affectMember (reader.Name, reader.Value);
+				}
+				reader.MoveToElement ();
+			}else
+				loadDefaultValues ();
+		}
+		public virtual void WriteXml (System.Xml.XmlWriter writer)
+		{
+			foreach (PropertyInfo pi in this.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
+				if (pi.GetSetMethod () == null)
+					continue;
+
+				bool isAttribute = false;
+				bool hasDefaultValue = false;
+				bool ignore = false;
+				string name = "";
+				object value = null;
+				Type valueType = null;
+
+
+				MemberInfo mi = pi.GetGetMethod ();
+
+				if (mi == null)
+					continue;
+
+				value = pi.GetValue (this, null);
+				valueType = pi.PropertyType;
+				name = pi.Name;
+
+
+
+				object[] att = pi.GetCustomAttributes (false);
+
+				foreach (object o in att) {
+					XmlAttributeAttribute xaa = o as XmlAttributeAttribute;
+					if (xaa != null) {
+						isAttribute = true;
+						if (string.IsNullOrEmpty (xaa.AttributeName))
+							name = pi.Name;
+						else
+							name = xaa.AttributeName;
+						continue;
+					}
+
+					XmlIgnoreAttribute xia = o as XmlIgnoreAttribute;
+					if (xia != null) {
+						ignore = true;
+						continue;
+					}
+
+					DefaultValueAttribute dv = o as DefaultValueAttribute;
+					if (dv != null) {
+						if (dv.Value.Equals (value))
+							hasDefaultValue = true;
+						if (dv.Value.ToString () == value.ToString ())
+							hasDefaultValue = true;
+
+						continue;
+					}
+
+
+				}
+
+				if (hasDefaultValue || ignore || value==null)
+					continue;
+
+				if (isAttribute)
+					writer.WriteAttributeString (name, value.ToString ());
+				else {
+					if (valueType.GetInterface ("IXmlSerializable") == null)
+						continue;
+
+					(pi.GetValue (this, null) as IXmlSerializable).WriteXml (writer);
+				}
+			}
+			foreach (EventInfo ei in this.GetType().GetEvents()) {
+				FieldInfo fi = this.GetType().GetField(ei.Name,
+					BindingFlags.NonPublic |
+					BindingFlags.Instance |
+					BindingFlags.GetField);
+
+				Delegate dg = (System.Delegate)fi.GetValue (this);
+
+				if (dg == null)
+					continue;
+
+				foreach (Delegate d in dg.GetInvocationList()) {
+					if (!d.Method.Name.StartsWith ("<"))//Skipping empty handler, not clear it's trikky
+						writer.WriteAttributeString (ei.Name, d.Method.Name);
+				}
+			}
+		}
+		#endregion
+
+		#region ICloneable implementation
+		public object Clone ()
+		{
+			Type type = this.GetType ();
+			GraphicObject result = (GraphicObject)Activator.CreateInstance (type);
+			result.CurrentInterface = CurrentInterface;
+
+			foreach (PropertyInfo pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
+				if (pi.GetSetMethod () == null)
+					continue;
+
+				if (pi.GetCustomAttribute<XmlIgnoreAttribute> () != null)
+					continue;
+				if (pi.Name == "DataSource")
+					continue;
+
+				pi.SetValue(result, pi.GetValue(this));
+			}
+			return result;
+		}
+		#endregion
+		/// <summary>
+		/// full GraphicTree clone with binding definition
+		/// </summary>
+
+		public override string ToString ()
+		{
+			string tmp ="";
+
+			if (Parent != null)
+				tmp = Parent.ToString () + tmp;
+			#if DEBUG_LAYOUTING
+			return Name == "unamed" ? tmp + "." + this.GetType ().Name + uid.ToString(): tmp + "." + Name;
+			#else
+			return Name == "unamed" ? tmp + "." + this.GetType ().Name : tmp + "." + Name;
+			#endif
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/Group.cs b/src/GraphicObjects/Base/Group.cs
new file mode 100644
index 00000000..d00449cb
--- /dev/null
+++ b/src/GraphicObjects/Base/Group.cs
@@ -0,0 +1,408 @@
+//
+// Group.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Xml.Serialization;
+using Cairo;
+using OpenTK.Input;
+using System.Diagnostics;
+using System.Reflection;
+
+
+namespace Crow
+{
+	public class Group : GraphicObject, IXmlSerializable
+    {
+		#region CTOR
+		public Group()
+			: base(){}
+		#endregion
+
+		#region EVENT HANDLERS
+		public event EventHandler<EventArgs> ChildrenCleared;
+		#endregion
+
+		internal GraphicObject largestChild = null;
+		internal GraphicObject tallestChild = null;
+
+        bool _multiSelect = false;
+		List<GraphicObject> children = new List<GraphicObject>();
+
+        public virtual List<GraphicObject> Children {
+			get { return children; }
+		}
+		[XmlAttributeAttribute()][DefaultValue(false)]
+        public bool MultiSelect
+        {
+            get { return _multiSelect; }
+            set { _multiSelect = value; }
+        }
+		public virtual void AddChild(GraphicObject g){
+			lock (children) {
+				g.Parent = this;
+				Children.Add (g);
+			}
+			g.RegisteredLayoutings = LayoutingType.None;
+			g.RegisterForLayouting (LayoutingType.Sizing | LayoutingType.ArrangeChildren);
+			g.LayoutChanged += OnChildLayoutChanges;
+		}
+        public virtual void RemoveChild(GraphicObject child)        
+		{
+			child.LayoutChanged -= OnChildLayoutChanges;
+			//child.Parent = null;
+			lock (children)
+            	Children.Remove(child);
+
+			if (child == largestChild && Width == Measure.Fit)
+				searchLargestChild ();
+			if (child == tallestChild && Height == Measure.Fit)
+				searchTallestChild ();
+			
+			this.RegisterForLayouting (LayoutingType.Sizing | LayoutingType.ArrangeChildren);
+        }
+		public virtual void ClearChildren()
+		{
+			lock (children) {
+				while (Children.Count > 0) {
+					GraphicObject g = Children [Children.Count - 1];
+					g.LayoutChanged -= OnChildLayoutChanges;
+					g.Parent = null;
+					Children.RemoveAt (Children.Count - 1);
+				}
+			}
+
+			resetChildrenMaxSize ();
+
+			this.RegisterForLayouting (LayoutingType.Sizing);
+			ChildrenCleared.Raise (this, new EventArgs ());
+		}
+
+		public void putWidgetOnTop(GraphicObject w)
+		{
+			if (Children.Contains(w))
+			{
+				lock (children) {
+					Children.Remove (w);
+					Children.Add (w);
+				}
+			}
+		}
+		public void putWidgetOnBottom(GraphicObject w)
+		{
+			if (Children.Contains(w))
+			{
+				lock (children) {
+					Children.Remove (w);
+					Children.Insert (0, w);
+				}
+			}
+		}
+
+		#region GraphicObject overrides
+		public override void OnDataSourceChanged (object sender, DataSourceChangeEventArgs e)
+		{
+			base.OnDataSourceChanged (this, e);
+			lock (children) {
+				foreach (GraphicObject g in children)
+					if (g.localDataSourceIsNull & g.localLogicalParentIsNull)
+						g.OnDataSourceChanged (sender, e);
+			}
+		}
+		public override GraphicObject FindByName (string nameToFind)
+		{
+			if (Name == nameToFind)
+				return this;
+			GraphicObject tmp = null;
+			lock (children) {
+				foreach (GraphicObject w in Children) {
+					tmp = w.FindByName (nameToFind);
+					if (tmp != null)
+						break;
+				}
+			}
+			return tmp;
+		}
+		public override bool Contains (GraphicObject goToFind)
+		{
+			foreach (GraphicObject w in Children) {
+				if (w == goToFind)
+					return true;
+				if (w.Contains (goToFind))
+					return true;
+			}
+			return false;
+		}
+		protected override int measureRawSize (LayoutingType lt)
+		{
+			if (Children.Count > 0) {
+				if (lt == LayoutingType.Width) {
+					if (largestChild == null)
+						searchLargestChild ();
+					if (largestChild == null) {
+						//if still null, not possible to determine a width
+						//because all children are stretched, force first one to fit
+						Children [0].Width = Measure.Fit;
+						return -1;//cancel actual sizing to let child computation take place
+					}
+				} else {
+					if (tallestChild == null)
+						searchTallestChild ();
+					if (tallestChild == null) {
+						Children [0].Height = Measure.Fit;
+						return -1;
+					}
+				}
+			}
+			return base.measureRawSize (lt);
+		}
+			
+		public override void OnLayoutChanges (LayoutingType layoutType)
+		{
+			base.OnLayoutChanges (layoutType);
+
+			//position smaller objects in group when group size is fit
+			switch (layoutType) {
+			case LayoutingType.Width:
+				foreach (GraphicObject c in Children){
+					if (c.Width.Units == Unit.Percent)
+						c.RegisterForLayouting (LayoutingType.Width);
+					else
+						c.RegisterForLayouting (LayoutingType.X);
+				}
+				break;
+			case LayoutingType.Height:
+				foreach (GraphicObject c in Children) {
+					if (c.Height.Units == Unit.Percent)
+						c.RegisterForLayouting (LayoutingType.Height);
+					else
+						c.RegisterForLayouting (LayoutingType.Y);
+				}
+				break;
+			}
+		}
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+
+			gr.Save ();
+
+			if (ClipToClientRect) {
+				//clip to client zone
+				CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
+				gr.Clip ();
+			}
+
+			lock (children) {
+				foreach (GraphicObject g in Children) {
+					g.Paint (ref gr);
+				}
+			}
+			gr.Restore ();
+		}
+		protected override void UpdateCache (Context ctx)
+		{
+			Rectangle rb = Slot + Parent.ClientRectangle.Position;
+
+			using (ImageSurface cache = new ImageSurface (bmp, Format.Argb32, Slot.Width, Slot.Height, 4 * Slot.Width)) {
+				Context gr = new Context (cache);
+
+				if (Clipping.count > 0) {
+					Clipping.clearAndClip (gr);
+					base.onDraw (gr);
+
+					//clip to client zone
+					CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
+					gr.Clip ();
+
+					lock (Children) {
+						foreach (GraphicObject c in Children) {
+							if (!c.Visible)
+								continue;
+							if (Clipping.intersect (c.Slot + ClientRectangle.Position))
+								c.Paint (ref gr);
+						}
+					}
+
+					#if DEBUG_CLIP_RECTANGLE
+					Clipping.stroke (gr, Color.Amaranth.AdjustAlpha (0.8));
+					#endif
+				}
+				gr.Dispose ();
+
+				ctx.SetSourceSurface (cache, rb.X, rb.Y);
+				ctx.Paint ();
+			}
+			Clipping.Reset();
+		}
+		#endregion
+
+		public virtual void OnChildLayoutChanges (object sender, LayoutingEventArgs arg)
+		{
+			GraphicObject g = sender as GraphicObject;
+
+			switch (arg.LayoutType) {
+			case LayoutingType.Width:
+				if (Width != Measure.Fit)
+					return;
+				if (g.Slot.Width > contentSize.Width) {
+					largestChild = g;
+					contentSize.Width = g.Slot.Width;
+				} else if (g == largestChild)
+					searchLargestChild ();
+
+				this.RegisterForLayouting (LayoutingType.Width);
+				break;
+			case LayoutingType.Height:
+				if (Height != Measure.Fit)
+					return;
+				if (g.Slot.Height > contentSize.Height) {
+					tallestChild = g;
+					contentSize.Height = g.Slot.Height;
+				} else if (g == tallestChild)
+					searchTallestChild ();
+
+				this.RegisterForLayouting (LayoutingType.Height);
+				break;
+			}
+		}
+		//TODO: x,y position should be taken in account for computation of width and height
+		void resetChildrenMaxSize(){
+			largestChild = null;
+			tallestChild = null;
+			contentSize = 0;
+		}
+		void searchLargestChild(){
+			#if DEBUG_LAYOUTING
+			Debug.WriteLine("\tSearch largest child");
+			#endif
+			largestChild = null;
+			contentSize.Width = 0;
+			for (int i = 0; i < Children.Count; i++) {
+				if (!Children [i].Visible)
+					continue;
+				if (children [i].RegisteredLayoutings.HasFlag (LayoutingType.Width))
+					continue;
+				if (Children [i].Slot.Width > contentSize.Width) {
+					contentSize.Width = Children [i].Slot.Width;
+					largestChild = Children [i];
+				}
+			}
+		}
+		void searchTallestChild(){
+			#if DEBUG_LAYOUTING
+			Debug.WriteLine("\tSearch tallest child");
+			#endif
+			tallestChild = null;
+			contentSize.Height = 0;
+			for (int i = 0; i < Children.Count; i++) {
+				if (!Children [i].Visible)
+					continue;
+				if (children [i].RegisteredLayoutings.HasFlag (LayoutingType.Height))
+					continue;
+				if (Children [i].Slot.Height > contentSize.Height) {
+					contentSize.Height = Children [i].Slot.Height;
+					tallestChild = Children [i];
+				}
+			}
+		}
+
+	
+		#region Mouse handling
+		public override void checkHoverWidget (MouseMoveEventArgs e)
+		{
+			if (CurrentInterface.HoverWidget != this) {
+				CurrentInterface.HoverWidget = this;
+				onMouseEnter (this, e);
+			}
+			for (int i = Children.Count - 1; i >= 0; i--) {
+				if (Children[i].MouseIsIn(e.Position))
+				{
+					Children[i].checkHoverWidget (e);
+					return;
+				}
+			}
+			base.checkHoverWidget (e);
+		}
+		#endregion
+
+
+		#region IXmlSerializable
+
+        public override System.Xml.Schema.XmlSchema GetSchema()
+        {
+            return null;
+        }
+        public override void ReadXml(System.Xml.XmlReader reader)
+        {
+            base.ReadXml(reader);
+
+            using (System.Xml.XmlReader subTree = reader.ReadSubtree())
+            {
+                subTree.Read();
+
+                while (!subTree.EOF)
+                {
+                    subTree.Read();
+
+                    if (!subTree.IsStartElement())
+                        break;
+
+                    Type t = Type.GetType("Crow." + subTree.Name);
+					if (t == null) {
+						Assembly a = Assembly.GetEntryAssembly ();
+						foreach (Type expT in a.GetExportedTypes ()) {
+							if (expT.Name == subTree.Name) {
+								t = expT;
+								break;
+							}
+						}
+					}
+					if (t == null)
+						throw new Exception (subTree.Name + " type not found");
+                    GraphicObject go = (GraphicObject)Activator.CreateInstance(t);
+                    (go as IXmlSerializable).ReadXml(subTree);                    
+                    AddChild(go);
+                }
+            }
+        }
+        public override void WriteXml(System.Xml.XmlWriter writer)
+        {
+            base.WriteXml(writer);
+
+            foreach (GraphicObject go in Children)
+            {
+                writer.WriteStartElement(go.GetType().Name);
+                (go as IXmlSerializable).WriteXml(writer);
+                writer.WriteEndElement();
+            }
+        }
+    
+		#endregion
+
+	}
+}
diff --git a/src/GraphicObjects/Base/GroupBox.cs b/src/GraphicObjects/Base/GroupBox.cs
new file mode 100644
index 00000000..9cabbb51
--- /dev/null
+++ b/src/GraphicObjects/Base/GroupBox.cs
@@ -0,0 +1,58 @@
+//
+// GroupBox.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+    public class GroupBox : TemplatedContainer
+    {
+		Container _contentContainer;
+
+		#region CTOR
+		public GroupBox() : base(){}
+		#endregion
+
+		#region Template overrides
+		public override GraphicObject Content {
+			get {
+				return _contentContainer == null ? null : _contentContainer.Child;
+			}
+			set {
+				_contentContainer.SetChild(value);
+			}
+		}
+		protected override void loadTemplate(GraphicObject template = null)
+		{
+			base.loadTemplate (template);
+
+			_contentContainer = this.child.FindByName ("Content") as Container;
+		}
+		#endregion
+	}
+}
diff --git a/src/GraphicObjects/Base/HorizontalStack.cs b/src/GraphicObjects/Base/HorizontalStack.cs
new file mode 100644
index 00000000..620dab22
--- /dev/null
+++ b/src/GraphicObjects/Base/HorizontalStack.cs
@@ -0,0 +1,48 @@
+//
+// HorizontalStack.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Serialization;
+
+namespace Crow
+{
+    public class HorizontalStack : GenericStack
+    {
+        public HorizontalStack()
+            : base()
+        {            
+        }
+
+        [XmlIgnore]
+        public override Orientation Orientation
+        {
+            get { return Orientation.Horizontal; }
+        }
+    }
+}
diff --git a/src/GraphicObjects/Base/Image.cs b/src/GraphicObjects/Base/Image.cs
new file mode 100644
index 00000000..6a4c590d
--- /dev/null
+++ b/src/GraphicObjects/Base/Image.cs
@@ -0,0 +1,181 @@
+//
+// Image.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using Cairo;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.Diagnostics;
+
+
+namespace Crow
+{
+	public class Image : GraphicObject
+	{
+		Picture _pic;
+		string _svgSub;
+		bool scaled, keepProps;
+		double opacity;
+
+		#region Public properties
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public virtual bool Scaled {
+			get { return scaled; }
+			set {
+				if (scaled == value)
+					return;
+				scaled = value;
+				NotifyValueChanged ("Scaled", scaled);
+				if (_pic == null)
+					return;
+				_pic.Scaled = scaled;
+				RegisterForGraphicUpdate ();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public virtual bool KeepProportions {
+			get { return keepProps; }
+			set {
+				if (keepProps == value)
+					return;
+				keepProps = value;
+				NotifyValueChanged ("KeepProportions", keepProps);
+				if (_pic == null)
+					return;
+				_pic.KeepProportions = keepProps;
+				RegisterForGraphicUpdate ();
+			}
+		}
+        [XmlAttributeAttribute]
+		public string Path {
+			get { return _pic == null ? "" : _pic.Path; }
+			set {
+				if (value == Path)
+					return;
+				try {
+					if (string.IsNullOrEmpty(value))
+						Picture = null;
+					else {
+						lock(CurrentInterface.LayoutMutex){
+							LoadImage (value);
+						}
+					}
+				} catch (Exception ex) {
+					Debug.WriteLine (ex.Message);
+					_pic = null;
+				}
+				NotifyValueChanged ("Path", Path);
+			}
+		}
+		[XmlAttributeAttribute]
+		public string SvgSub {
+			get { return _svgSub; }
+			set {
+				if (_svgSub == value)
+					return;
+				_svgSub = value;
+				RegisterForGraphicUpdate ();
+			}
+		}
+		[XmlAttributeAttribute]
+		public Picture Picture {
+			get { return _pic; }
+			set {
+				if (_pic == value)
+					return;
+				_pic = value;
+				NotifyValueChanged ("Picture", _pic);
+				RegisterForGraphicUpdate ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(1.0)]
+		public virtual double Opacity {
+			get { return opacity; }
+			set {
+				if (opacity == value)
+					return;
+				opacity = value;
+				NotifyValueChanged ("Faded", opacity);
+				RegisterForRedraw ();
+			}
+		}
+		#endregion
+
+		#region CTOR
+		public Image () : base()
+		{
+		}
+		#endregion
+
+		#region Image Loading
+		public void LoadImage (string path)
+		{
+			Picture pic;
+			if (path.EndsWith (".svg", true, System.Globalization.CultureInfo.InvariantCulture))
+				pic = new SvgPicture ();
+			else
+				pic = new BmpPicture ();
+
+			pic.LoadImage (path);
+			pic.Scaled = scaled;
+			pic.KeepProportions = keepProps;
+
+			Picture = pic;
+		}
+		#endregion
+
+		#region GraphicObject overrides
+		protected override int measureRawSize (LayoutingType lt)
+		{
+			if (_pic == null)
+				return 2 * Margin;
+				//_pic = "#Crow.Images.Icons.IconAlerte.svg";
+			//TODO:take scalling in account
+			if (lt == LayoutingType.Width)
+				return _pic.Dimensions.Width + 2 * Margin;
+			else
+				return _pic.Dimensions.Height + 2 * Margin;
+		}
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+
+			if (_pic == null)
+				return;
+
+			_pic.Paint (gr, ClientRectangle, _svgSub);
+
+			if (Opacity<1.0) {
+				gr.SetSourceRGBA (0.0, 0.0, 0.0, 1.0-Opacity);
+				gr.Operator = Operator.DestOut;
+				gr.Rectangle (ClientRectangle);
+				gr.Fill ();
+				gr.Operator = Operator.Over;
+			}
+		}
+		#endregion
+	}
+}
diff --git a/src/GraphicObjects/Base/Label.cs b/src/GraphicObjects/Base/Label.cs
new file mode 100644
index 00000000..64ee9688
--- /dev/null
+++ b/src/GraphicObjects/Base/Label.cs
@@ -0,0 +1,825 @@
+//
+// Label.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Diagnostics;
+using Cairo;
+using System.Text.RegularExpressions;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+    public class Label : GraphicObject
+    {
+		#region CTOR
+		public Label()
+		{
+
+		}
+		public Label(string _text)
+			: base()
+		{
+			Text = _text;
+		}
+		#endregion
+
+		public event EventHandler<TextChangeEventArgs> TextChanged;
+
+		public virtual void OnTextChanged(Object sender, TextChangeEventArgs e)
+		{
+			NotifyValueChanged ("Text", Text);
+			TextChanged.Raise (this, e);
+		}
+        //TODO:change protected to private
+
+		#region private and protected fields
+		string _text = "label";
+        Alignment _textAlignment;
+		bool horizontalStretch;
+		bool verticalStretch;
+		bool _selectable;
+		bool _multiline;
+		Color selBackground;
+		Color selForeground;
+		Point mouseLocalPos = -1;//mouse coord in widget space, filled only when clicked
+		int _currentCol;        //0 based cursor position in string
+		int _currentLine;
+		Point _selBegin = -1;	//selection start (row,column)
+		Point _selRelease = -1;	//selection end (row,column)
+		double textCursorPos;   //cursor position in cairo units in widget client coord.
+		double SelStartCursorPos = -1;
+		double SelEndCursorPos = -1;
+		bool SelectionInProgress = false;
+
+        protected Rectangle rText;
+		protected float widthRatio = 1f;
+		protected float heightRatio = 1f;
+		protected FontExtents fe;
+		protected TextExtents te;
+		#endregion
+
+		[XmlAttributeAttribute][DefaultValue("BlueGray")]
+		public virtual Color SelectionBackground {
+			get { return selBackground; }
+			set {
+				if (value == selBackground)
+					return;
+				selBackground = value;
+				NotifyValueChanged ("SelectionBackground", selBackground);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue("White")]
+		public virtual Color SelectionForeground {
+			get { return selForeground; }
+			set {
+				if (value == selForeground)
+					return;
+				selForeground = value;
+				NotifyValueChanged ("SelectionForeground", selForeground);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(Alignment.Left)]
+		public Alignment TextAlignment
+        {
+            get { return _textAlignment; }
+            set {
+				if (value == _textAlignment)
+					return;
+				_textAlignment = value;
+				RegisterForRedraw ();
+				NotifyValueChanged ("TextAlignment", _textAlignment);
+			}
+        }
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public virtual bool HorizontalStretch {
+			get { return horizontalStretch; }
+			set {
+				if (horizontalStretch == value)
+					return;
+				horizontalStretch = value;
+				RegisterForRedraw ();
+				NotifyValueChanged ("HorizontalStretch", horizontalStretch);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public virtual bool VerticalStretch {
+			get { return verticalStretch; }
+			set {
+				if (verticalStretch == value)
+					return;
+				verticalStretch = value;
+				RegisterForRedraw ();
+				NotifyValueChanged ("VerticalStretch", verticalStretch);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue("label")]
+        public string Text
+        {
+            get {
+				return lines == null ?
+					_text : lines.Aggregate((i, j) => i + Interface.LineBreak + j);
+			}
+            set
+            {
+				if (string.Equals (value, _text, StringComparison.Ordinal))
+                    return;
+
+                _text = value;
+
+				if (string.IsNullOrEmpty(_text))
+					_text = "";
+
+				lines = getLines;
+
+				OnTextChanged (this, new TextChangeEventArgs (Text));
+				RegisterForGraphicUpdate ();
+            }
+        }
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public bool Selectable
+		{
+			get { return _selectable; }
+			set
+			{
+				if (value == _selectable)
+					return;
+				_selectable = value;
+				NotifyValueChanged ("Selectable", _selectable);
+				SelBegin = -1;
+				SelRelease = -1;
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public bool Multiline
+		{
+			get { return _multiline; }
+			set
+			{
+				if (value == _multiline)
+					return;
+				_multiline = value;
+				NotifyValueChanged ("Multiline", _multiline);
+				RegisterForGraphicUpdate();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(0)]
+		public int CurrentColumn{
+			get { return _currentCol; }
+			set {
+				if (value == _currentCol)
+					return;
+				if (value < 0)
+					_currentCol = 0;
+				else if (value > lines [_currentLine].Length)
+					_currentCol = lines [_currentLine].Length;
+				else
+					_currentCol = value;
+				NotifyValueChanged ("CurrentColumn", _currentCol);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(0)]
+		public int CurrentLine{
+			get { return _currentLine; }
+			set {
+				if (value == _currentLine)
+					return;
+				if (value >= lines.Count)
+					_currentLine = lines.Count-1;
+				else if (value < 0)
+					_currentLine = 0;
+				else
+					_currentLine = value;
+				//force recheck of currentCol for bounding
+				int cc = _currentCol;
+				_currentCol = 0;
+				CurrentColumn = cc;
+				NotifyValueChanged ("CurrentLine", _currentLine);
+			}
+		}
+		[XmlIgnore]public Point CurrentPosition {
+			get { return new Point(_currentCol, CurrentLine); }
+		}
+		//TODO:using HasFocus for drawing selection cause SelBegin and Release binding not to work
+		/// <summary>
+		/// Selection begin position in char units
+		/// </summary>
+		[XmlAttributeAttribute][DefaultValue("-1")]
+		public Point SelBegin {
+			get {
+				return _selBegin;
+			}
+			set {
+				if (value == _selBegin)
+					return;
+				_selBegin = value;
+				NotifyValueChanged ("SelBegin", _selBegin);
+				NotifyValueChanged ("SelectedText", SelectedText);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue("-1")]
+		public Point SelRelease {
+			get {
+				return _selRelease;
+			}
+			set {
+				if (value == _selRelease)
+					return;
+				_selRelease = value;
+				NotifyValueChanged ("SelRelease", _selRelease);
+				NotifyValueChanged ("SelectedText", SelectedText);
+			}
+		}
+		/// <summary>
+		/// return char at CurrentLine, CurrentColumn
+		/// </summary>
+		[XmlIgnore]protected Char CurrentChar
+		{
+			get {
+				return lines [CurrentLine] [CurrentColumn];
+			}
+		}
+		/// <summary>
+		/// ordered selection start and end positions in char units
+		/// </summary>
+		[XmlIgnore]protected Point selectionStart
+		{
+			get {
+				return SelRelease < 0 || SelBegin.Y < SelRelease.Y ? SelBegin :
+					SelBegin.Y > SelRelease.Y ? SelRelease :
+					SelBegin.X < SelRelease.X ? SelBegin : SelRelease;
+			}
+		}
+		[XmlIgnore]public Point selectionEnd
+		{
+			get {
+				return SelRelease < 0 || SelBegin.Y > SelRelease.Y ? SelBegin :
+					SelBegin.Y < SelRelease.Y ? SelRelease :
+					SelBegin.X > SelRelease.X ? SelBegin : SelRelease;
+			}
+		}
+		[XmlIgnore]public string SelectedText
+		{
+			get {
+
+				if (SelRelease < 0 || SelBegin < 0)
+					return "";
+				if (selectionStart.Y == selectionEnd.Y)
+					return lines [selectionStart.Y].Substring (selectionStart.X, selectionEnd.X - selectionStart.X);
+				string tmp = "";
+				tmp = lines [selectionStart.Y].Substring (selectionStart.X);
+				for (int l = selectionStart.Y + 1; l < selectionEnd.Y; l++) {
+					tmp += Interface.LineBreak + lines [l];
+				}
+				tmp += Interface.LineBreak + lines [selectionEnd.Y].Substring (0, selectionEnd.X);
+				return tmp;
+			}
+		}
+		[XmlIgnore]public bool selectionIsEmpty
+		{ get { return SelRelease < 0; } }
+
+		List<string> lines;
+		List<string> getLines {
+			get {
+				return _multiline ?
+					Regex.Split (_text, "\r\n|\r|\n|\\\\n").ToList() :
+					new List<string>(new string[] { _text });
+			}
+		}
+		/// <summary>
+		/// Moves cursor one char to the left.
+		/// </summary>
+		/// <returns><c>true</c> if move succeed</returns>
+		public bool MoveLeft(){
+			int tmp = _currentCol - 1;
+			if (tmp < 0) {
+				if (_currentLine == 0)
+					return false;
+				CurrentLine--;
+				CurrentColumn = int.MaxValue;
+			} else
+				CurrentColumn = tmp;
+			return true;
+		}
+		/// <summary>
+		/// Moves cursor one char to the right.
+		/// </summary>
+		/// <returns><c>true</c> if move succeed</returns>
+		public bool MoveRight(){
+			int tmp = _currentCol + 1;
+			if (tmp > lines [_currentLine].Length){
+				if (CurrentLine == lines.Count - 1)
+					return false;
+				CurrentLine++;
+				CurrentColumn = 0;
+			} else
+				CurrentColumn = tmp;
+			return true;
+		}
+		public void GotoWordStart(){
+			CurrentColumn--;
+			//skip white spaces
+			while (!char.IsLetterOrDigit (this.CurrentChar) && CurrentColumn > 0)
+				CurrentColumn--;
+			while (char.IsLetterOrDigit (lines [CurrentLine] [CurrentColumn]) && CurrentColumn > 0)
+				CurrentColumn--;
+			if (!char.IsLetterOrDigit (this.CurrentChar))
+				CurrentColumn++;
+		}
+		public void GotoWordEnd(){
+			//skip white spaces
+			if (CurrentColumn >= lines [CurrentLine].Length - 1)
+				return;
+			while (!char.IsLetterOrDigit (this.CurrentChar) && CurrentColumn < lines [CurrentLine].Length-1)
+				CurrentColumn++;
+			while (char.IsLetterOrDigit (this.CurrentChar) && CurrentColumn < lines [CurrentLine].Length-1)
+				CurrentColumn++;
+			if (char.IsLetterOrDigit (this.CurrentChar))
+				CurrentColumn++;
+		}
+		public void DeleteChar()
+		{
+			if (selectionIsEmpty) {
+				if (CurrentColumn == 0) {
+					if (CurrentLine == 0 && lines.Count == 1)
+						return;
+					CurrentLine--;
+					CurrentColumn = lines [CurrentLine].Length;
+					lines [CurrentLine] += lines [CurrentLine + 1];
+					lines.RemoveAt (CurrentLine + 1);
+
+					OnTextChanged (this, new TextChangeEventArgs (Text));
+					return;
+				}
+				CurrentColumn--;
+				lines [CurrentLine] = lines [CurrentLine].Remove (CurrentColumn, 1);
+			} else {
+				int linesToRemove = selectionEnd.Y - selectionStart.Y + 1;
+				int l = selectionStart.Y;
+
+				if (linesToRemove > 0) {
+					lines [l] = lines [l].Remove (selectionStart.X, lines [l].Length - selectionStart.X) +
+						lines [selectionEnd.Y].Substring (selectionEnd.X, lines [selectionEnd.Y].Length - selectionEnd.X);
+					l++;
+					for (int c = 0; c < linesToRemove-1; c++)
+						lines.RemoveAt (l);
+					CurrentLine = selectionStart.Y;
+					CurrentColumn = selectionStart.X;
+				} else
+					lines [l] = lines [l].Remove (selectionStart.X, selectionEnd.X - selectionStart.X);
+				CurrentColumn = selectionStart.X;
+				SelBegin = -1;
+				SelRelease = -1;
+			}
+			OnTextChanged (this, new TextChangeEventArgs (Text));
+		}
+		/// <summary>
+		/// Insert new string at caret position, should be sure no line break is inside.
+		/// </summary>
+		/// <param name="str">String.</param>
+		protected void Insert(string str)
+		{
+			if (!selectionIsEmpty)
+				this.DeleteChar ();
+			if (_multiline) {
+				string[] strLines = Regex.Split (str, "\r\n|\r|\n|" + @"\\n").ToArray();
+				lines [CurrentLine] = lines [CurrentLine].Insert (CurrentColumn, strLines[0]);
+				CurrentColumn += strLines[0].Length;
+				for (int i = 1; i < strLines.Length; i++) {
+					InsertLineBreak ();
+					lines [CurrentLine] = lines [CurrentLine].Insert (CurrentColumn, strLines[i]);
+					CurrentColumn += strLines[i].Length;
+				}
+			} else {
+				lines [CurrentLine] = lines [CurrentLine].Insert (CurrentColumn, str);
+				CurrentColumn += str.Length;
+			}
+			OnTextChanged (this, new TextChangeEventArgs (Text));
+		}
+		/// <summary>
+		/// Insert a line break.
+		/// </summary>
+		protected void InsertLineBreak()
+		{
+			lines.Insert(CurrentLine + 1, lines[CurrentLine].Substring(CurrentColumn));
+			lines [CurrentLine] = lines [CurrentLine].Substring (0, CurrentColumn);
+			CurrentLine++;
+			CurrentColumn = 0;
+			OnTextChanged (this, new TextChangeEventArgs (Text));
+		}
+
+		#region GraphicObject overrides
+		protected override int measureRawSize(LayoutingType lt)
+        {
+			if (lines == null)
+				lines = getLines;
+
+			using (ImageSurface img = new ImageSurface (Format.Argb32, 10, 10)) {
+				using (Context gr = new Context (img)) {
+					//Cairo.FontFace cf = gr.GetContextFontFace ();
+
+					gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+					gr.SetFontSize (Font.Size);
+
+
+					fe = gr.FontExtents;
+					te = new TextExtents();
+
+					if (lt == LayoutingType.Height){
+						int lc = lines.Count;
+						//ensure minimal height = text line height
+						if (lc == 0)
+							lc = 1;
+
+						return (int)Math.Ceiling(fe.Height * lc) + Margin * 2;
+					}
+					try {
+						foreach (string s in lines) {
+							string l = s.Replace("\t", new String (' ', Interface.TabSize));
+
+							TextExtents tmp = gr.TextExtents (l);
+
+							if (tmp.XAdvance > te.XAdvance)
+								te = tmp;
+						}
+					} catch (Exception ex) {
+						return -1;
+					}
+					return (int)Math.Ceiling (te.XAdvance) + Margin * 2;
+				}
+			}
+        }
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+
+			gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+			gr.SetFontSize (Font.Size);
+			gr.FontOptions = Interface.FontRenderingOptions;
+			gr.Antialias = Interface.Antialias;
+
+			rText = new Rectangle(new Size(
+				measureRawSize(LayoutingType.Width), measureRawSize(LayoutingType.Height)));
+			rText.Width -= 2 * Margin;
+			rText.Height -= 2 * Margin;
+
+			widthRatio = 1f;
+			heightRatio = 1f;
+
+			Rectangle cb = ClientRectangle;
+
+			rText.X = cb.X;
+			rText.Y = cb.Y;
+
+			if (horizontalStretch) {
+				widthRatio = (float)cb.Width / (float)rText.Width;
+				if (!verticalStretch)
+					heightRatio = widthRatio;
+			}
+
+			if (verticalStretch) {
+				heightRatio = (float)cb.Height / (float)rText.Height;
+				if (!horizontalStretch)
+					widthRatio = heightRatio;
+			}
+
+			rText.Width = (int)(widthRatio * (float)rText.Width);
+			rText.Height = (int)(heightRatio * (float)rText.Height);
+
+			switch (TextAlignment)
+			{
+			case Alignment.TopLeft:     //ok
+				rText.X = cb.X;
+				rText.Y = cb.Y;
+				break;
+			case Alignment.Top:   //ok
+				rText.Y = cb.Y;
+				rText.X = cb.X + cb.Width / 2 - rText.Width / 2;
+				break;
+			case Alignment.TopRight:    //ok
+				rText.Y = cb.Y;
+				rText.X = cb.Right - rText.Width;
+				break;
+			case Alignment.Left://ok
+				rText.X = cb.X;
+				rText.Y = cb.Y + cb.Height / 2 - rText.Height / 2;
+				break;
+			case Alignment.Right://ok
+				rText.X = cb.X + cb.Width - rText.Width;
+				rText.Y = cb.Y + cb.Height / 2 - rText.Height / 2;
+				break;
+			case Alignment.Bottom://ok
+				rText.X = cb.Width / 2 - rText.Width / 2;
+				rText.Y = cb.Height - rText.Height;
+				break;
+			case Alignment.BottomLeft://ok
+				rText.X = cb.X;
+				rText.Y = cb.Bottom - rText.Height;
+				break;
+			case Alignment.BottomRight://ok
+				rText.Y = cb.Bottom - rText.Height;
+				rText.X = cb.Right - rText.Width;
+				break;
+			case Alignment.Center://ok
+				rText.X = cb.X + cb.Width / 2 - rText.Width / 2;
+				rText.Y = cb.Y + cb.Height / 2 - rText.Height / 2;
+				break;
+			}
+
+			gr.FontMatrix = new Matrix(widthRatio * (float)Font.Size, 0, 0, heightRatio * (float)Font.Size, 0, 0);
+			fe = gr.FontExtents;
+
+			#region draw text cursor
+			if (HasFocus && Selectable)
+			{
+				if (mouseLocalPos >= 0)
+				{
+					computeTextCursor(gr);
+
+					if (SelectionInProgress)
+					{
+						if (SelBegin < 0){
+							SelBegin = new Point(CurrentColumn, CurrentLine);
+							SelStartCursorPos = textCursorPos;
+							SelRelease = -1;
+						}else{
+							SelRelease = new Point(CurrentColumn, CurrentLine);
+							if (SelRelease == SelBegin)
+								SelRelease = -1;
+							else
+								SelEndCursorPos = textCursorPos;
+						}
+					}else
+						computeTextCursorPosition(gr);
+				}else
+					computeTextCursorPosition(gr);
+
+				Foreground.SetAsSource (gr);
+				gr.LineWidth = 1.0;
+				gr.MoveTo (0.5 + textCursorPos + rText.X, rText.Y + CurrentLine * fe.Height);
+				gr.LineTo (0.5 + textCursorPos + rText.X, rText.Y + (CurrentLine + 1) * fe.Height);
+				gr.Stroke();
+			}
+			#endregion
+
+			//****** debug selection *************
+//			if (SelRelease >= 0) {
+//				new SolidColor(Color.DarkGreen).SetAsSource(gr);
+//				Rectangle R = new Rectangle (
+//					             rText.X + (int)SelEndCursorPos - 3,
+//					             rText.Y + (int)(SelRelease.Y * fe.Height),
+//					             6,
+//					             (int)fe.Height);
+//				gr.Rectangle (R);
+//				gr.Fill ();
+//			}
+//			if (SelBegin >= 0) {
+//				new SolidColor(Color.DarkRed).SetAsSource(gr);
+//				Rectangle R = new Rectangle (
+//					rText.X + (int)SelStartCursorPos - 3,
+//					rText.Y + (int)(SelBegin.Y * fe.Height),
+//					6,
+//					(int)fe.Height);
+//				gr.Rectangle (R);
+//				gr.Fill ();
+//			}
+			//*******************
+
+			for (int i = 0; i < lines.Count; i++) {
+				string l = lines [i].Replace ("\t", new String (' ', Interface.TabSize));
+				int lineLength = (int)gr.TextExtents (l).XAdvance;
+				Rectangle lineRect = new Rectangle (
+					rText.X,
+					rText.Y + (int)Math.Ceiling(i * fe.Height),
+					lineLength,
+					(int)Math.Ceiling(fe.Height));
+
+//				if (TextAlignment == Alignment.Center ||
+//					TextAlignment == Alignment.Top ||
+//					TextAlignment == Alignment.Bottom)
+//					lineRect.X += (rText.Width - lineLength) / 2;
+//				else if (TextAlignment == Alignment.Right ||
+//					TextAlignment == Alignment.TopRight ||
+//					TextAlignment == Alignment.BottomRight)
+//					lineRect.X += (rText.Width - lineLength);
+				if (string.IsNullOrWhiteSpace (l))
+					continue;
+
+				Foreground.SetAsSource (gr);
+				gr.MoveTo (lineRect.X, rText.Y + fe.Ascent + fe.Height * i);
+				gr.ShowText (l);
+				gr.Fill ();
+
+				if (Selectable) {
+					if (SelRelease >= 0 && i >= selectionStart.Y && i <= selectionEnd.Y) {
+						gr.SetSourceColor (selBackground);
+
+						Rectangle selRect = lineRect;
+
+						int cpStart = (int)SelStartCursorPos,
+						cpEnd = (int)SelEndCursorPos;
+
+						if (SelBegin.Y > SelRelease.Y) {
+							cpStart = cpEnd;
+							cpEnd = (int)SelStartCursorPos;
+						}
+
+						if (i == selectionStart.Y) {
+							selRect.Width -= cpStart;
+							selRect.Left += cpStart;
+						}
+						if (i == selectionEnd.Y)
+							selRect.Width -= (lineLength - cpEnd);
+
+						gr.Rectangle (selRect);
+						gr.FillPreserve ();
+						gr.Save ();
+						gr.Clip ();
+						gr.SetSourceColor (SelectionForeground);
+						gr.MoveTo (lineRect.X, rText.Y + fe.Ascent + fe.Height * i);
+						gr.ShowText (l);
+						gr.Fill ();
+						gr.Restore ();
+					}
+				}
+			}
+		}
+		#endregion
+
+		#region Mouse handling
+		void updatemouseLocalPos(Point mpos){
+			mouseLocalPos = mpos - ScreenCoordinates(Slot).TopLeft - ClientRectangle.TopLeft;
+			if (mouseLocalPos.X < 0)
+				mouseLocalPos.X = 0;
+			if (mouseLocalPos.Y < 0)
+				mouseLocalPos.Y = 0;
+		}
+		public override void onMouseEnter (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseEnter (sender, e);
+			if (Selectable)
+				CurrentInterface.MouseCursor = XCursor.Text;
+		}
+		public override void onMouseLeave (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseLeave (sender, e);
+			CurrentInterface.MouseCursor = XCursor.Default;
+		}
+		protected override void onFocused (object sender, EventArgs e)
+		{
+			base.onFocused (sender, e);
+
+			if (!_selectable)
+				return;
+			SelBegin = new Point(0,0);
+			SelRelease = new Point (lines.LastOrDefault ().Length, lines.Count-1);
+			RegisterForRedraw ();
+		}
+		protected override void onUnfocused (object sender, EventArgs e)
+		{
+			base.onUnfocused (sender, e);
+
+			SelBegin = -1;
+			SelRelease = -1;
+			RegisterForRedraw ();
+		}
+		public override void onMouseMove (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseMove (sender, e);
+
+			if (!(SelectionInProgress && HasFocus && _selectable))
+				return;
+
+			updatemouseLocalPos (e.Position);
+
+			RegisterForRedraw();
+		}
+		public override void onMouseDown (object sender, MouseButtonEventArgs e)
+		{
+			if (this.HasFocus && _selectable){
+				updatemouseLocalPos (e.Position);
+				SelBegin = -1;
+				SelRelease = -1;
+				SelectionInProgress = true;
+				RegisterForRedraw();//TODO:should put it in properties
+			}
+
+			//done at the end to set 'hasFocus' value after testing it
+			base.onMouseDown (sender, e);
+		}
+		public override void onMouseUp (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseUp (sender, e);
+
+			if (!SelectionInProgress)
+				return;
+
+			updatemouseLocalPos (e.Position);
+			SelectionInProgress = false;
+			RegisterForRedraw ();
+		}
+		public override void onMouseDoubleClick (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseDoubleClick (sender, e);
+
+			GotoWordStart ();
+			SelBegin = CurrentPosition;
+			GotoWordEnd ();
+			SelRelease = CurrentPosition;
+			SelectionInProgress = false;
+			RegisterForRedraw ();
+		}
+		#endregion
+
+		/// <summary>
+		/// Update Current Column, line and TextCursorPos
+		/// from mouseLocalPos
+		/// </summary>
+		void computeTextCursor(Context gr)
+		{
+			TextExtents te;
+
+			double cPos = 0f;
+
+			CurrentLine = (int)(mouseLocalPos.Y / fe.Height);
+
+			//fix cu
+			if (CurrentLine >= lines.Count)
+				CurrentLine = lines.Count - 1;
+
+			for (int i = 0; i < lines[CurrentLine].Length; i++)
+			{
+				string c = lines [CurrentLine].Substring (i, 1);
+				if (c == "\t")
+					c = new string (' ', Interface.TabSize);
+
+				te = gr.TextExtents(c);
+
+				double halfWidth = te.XAdvance / 2;
+
+				if (mouseLocalPos.X <= cPos + halfWidth)
+				{
+					CurrentColumn = i;
+					textCursorPos = cPos;
+					mouseLocalPos = -1;
+					return;
+				}
+
+				cPos += te.XAdvance;
+			}
+			CurrentColumn = lines[CurrentLine].Length;
+			textCursorPos = cPos;
+
+			//reset mouseLocalPos
+			mouseLocalPos = -1;
+		}
+		/// <summary> Computes offsets in cairo units </summary>
+		void computeTextCursorPosition(Context gr)
+		{
+			if (SelBegin >= 0)
+				SelStartCursorPos = GetXFromTextPointer (gr, SelBegin);
+			if (SelRelease >= 0)
+				SelEndCursorPos = GetXFromTextPointer (gr, SelRelease);
+			textCursorPos = GetXFromTextPointer (gr, new Point(CurrentColumn, CurrentLine));
+		}
+		/// <summary> Compute x offset in cairo unit from text position </summary>
+		double GetXFromTextPointer(Context gr, Point pos)
+		{
+			try {
+				string l = lines [pos.Y].Substring (0, pos.X).
+					Replace ("\t", new String (' ', Interface.TabSize));
+				return gr.TextExtents (l).XAdvance;
+			} catch{
+				return -1;
+			}
+		}
+    }
+}
diff --git a/src/GraphicObjects/Base/ListBox.cs b/src/GraphicObjects/Base/ListBox.cs
new file mode 100644
index 00000000..f66edf61
--- /dev/null
+++ b/src/GraphicObjects/Base/ListBox.cs
@@ -0,0 +1,47 @@
+//
+// ListBox.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.IO;
+using System.Diagnostics;
+using System.Xml;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Crow
+{
+	public class ListBox : TemplatedGroup
+	{
+		#region CTOR
+		public ListBox () : base() {}
+		#endregion
+
+	}
+}
+
diff --git a/src/GraphicObjects/Base/Menu.cs b/src/GraphicObjects/Base/Menu.cs
new file mode 100644
index 00000000..50494815
--- /dev/null
+++ b/src/GraphicObjects/Base/Menu.cs
@@ -0,0 +1,76 @@
+//
+// Menu.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+	public class Menu : TemplatedGroup
+	{
+		#region CTOR
+		public Menu () : base() {}
+		#endregion
+
+		Orientation orientation;
+		bool autoOpen = false;
+
+		#region Public properties
+		[XmlAttributeAttribute][DefaultValue(Orientation.Horizontal)]
+		public Orientation Orientation {
+			get { return orientation; }
+			set {
+				if (orientation == value)
+					return;
+				orientation = value;
+				NotifyValueChanged ("Orientation", orientation);
+			}
+		}
+		[XmlIgnore]public bool AutomaticOpenning
+		{
+			get { return autoOpen; }
+			set	{ autoOpen = value;	}
+		}
+		#endregion
+
+		public override void AddItem (GraphicObject g)
+		{			
+			base.AddItem (g);
+
+			if (orientation == Orientation.Horizontal)
+				g.NotifyValueChanged ("PopDirection", Alignment.Bottom);
+			else
+				g.NotifyValueChanged ("PopDirection", Alignment.Right);
+		}
+		public override void onMouseLeave (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseLeave (sender, e);
+			AutomaticOpenning = false;
+		}
+	}
+}
+
diff --git a/src/GraphicObjects/Base/MenuItem.cs b/src/GraphicObjects/Base/MenuItem.cs
new file mode 100644
index 00000000..0d99a2eb
--- /dev/null
+++ b/src/GraphicObjects/Base/MenuItem.cs
@@ -0,0 +1,174 @@
+//
+// MenuItem.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+	public class MenuItem : Menu
+	{
+		#region CTOR
+		public MenuItem () : base() {}
+		#endregion
+
+		public event EventHandler Open;
+		public event EventHandler Close;
+
+		string caption;
+		Command command;
+		Picture icon;
+		bool isOpened;
+		Measure popWidth, popHeight;
+
+		#region Public properties
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public bool IsOpened {
+			get { return isOpened; }
+			set {
+				if (isOpened == value)
+					return;
+				isOpened = value;
+				NotifyValueChanged ("IsOpened", isOpened);
+
+				if (isOpened) {
+					onOpen (this, null);
+					(LogicalParent as Menu).AutomaticOpenning = true;
+				}else
+					onClose (this, null);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(null)]
+		public virtual Command Command {
+			get { return command; }
+			set {
+				if (command == value)
+					return;
+
+				if (command != null) {
+					command.raiseAllValuesChanged ();
+					command.ValueChanged -= Command_ValueChanged;
+				}
+
+				command = value;
+
+				if (command != null) {
+					command.ValueChanged += Command_ValueChanged;
+					command.raiseAllValuesChanged ();
+				}
+
+				NotifyValueChanged ("Command", command);
+			}
+		}
+		[XmlAttributeAttribute]
+		public override bool IsEnabled {
+			get { return Command == null ? base.IsEnabled : Command.CanExecute; }
+			set { base.IsEnabled = value; }
+		}
+		[XmlAttributeAttribute]
+		public override string Caption {
+			get { return Command == null ? base.Caption : Command.Caption; }
+			set { base.Caption = value; }
+		}
+		[XmlAttributeAttribute]
+		public Picture Icon {
+			get { return Command == null ? icon : Command.Icon;; }
+			set {
+				if (icon == value)
+					return;
+				icon = value;
+				if (command == null)
+					NotifyValueChanged ("Icon", icon);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("Fit")]
+		public virtual Measure PopWidth {
+			get { return popWidth; }
+			set {
+				if (popWidth == value)
+					return;
+				popWidth = value;
+				NotifyValueChanged ("PopWidth", popWidth);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("Fit")]
+		public virtual Measure PopHeight {
+			get { return popHeight; }
+			set {
+				if (popHeight == value)
+					return;
+				popHeight = value;
+				NotifyValueChanged ("PopHeight", popHeight);
+			}
+		}
+		#endregion
+
+		public override void AddItem (GraphicObject g)
+		{
+			base.AddItem (g);
+			g.NotifyValueChanged ("PopDirection", Alignment.Right);
+		}
+
+		void Command_ValueChanged (object sender, ValueChangeEventArgs e)
+		{
+			string mName = e.MemberName;
+			if (mName == "CanExecute")
+				mName = "IsEnabled";
+			NotifyValueChanged (mName, e.NewValue);
+		}
+		void onMI_Click (object sender, MouseButtonEventArgs e)
+		{
+			if (command != null)
+				command.Execute ();
+			if(!IsOpened)
+				(LogicalParent as Menu).AutomaticOpenning = false;
+		}
+		protected virtual void onOpen (object sender, EventArgs e){
+			Open.Raise (this, null);
+		}
+		protected virtual void onClose (object sender, EventArgs e){
+			Close.Raise (this, null);
+		}
+		public override bool MouseIsIn (Point m)
+		{
+			return IsEnabled ? base.MouseIsIn (m) || child.MouseIsIn (m) : false;
+		}
+		public override void onMouseEnter (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseEnter (sender, e);
+			if ((LogicalParent as Menu).AutomaticOpenning && items.Children.Count>0)
+				IsOpened = true;
+		}
+		public override void onMouseLeave (object sender, MouseMoveEventArgs e)
+		{
+			if (IsOpened)
+				IsOpened = false;
+			base.onMouseLeave (this, e);
+		}
+	}
+}
+
diff --git a/src/GraphicObjects/Base/MessageBox.cs b/src/GraphicObjects/Base/MessageBox.cs
new file mode 100644
index 00000000..d8ce1dae
--- /dev/null
+++ b/src/GraphicObjects/Base/MessageBox.cs
@@ -0,0 +1,150 @@
+//
+// MessageBox.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+	public class MessageBox : Window
+	{
+		public enum Type {
+			Information,
+			YesNo,
+			Alert,
+			Error
+		}
+		public MessageBox (): base(){}
+
+		protected override void loadTemplate (GraphicObject template)
+		{
+			base.loadTemplate (template);
+			NotifyValueChanged ("MsgIcon", "#Crow.Images.Icons.Informations.svg");
+		}
+		string message, okMessage, cancelMessage;
+		Type msgType = Type.Information;
+
+		public event EventHandler Ok;
+		public event EventHandler Cancel;
+
+		[XmlAttributeAttribute][DefaultValue("Informations")]
+		public virtual string Message
+		{
+			get { return message; }
+			set {
+				if (message == value)
+					return;
+				message = value;
+				NotifyValueChanged ("Message", message);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue("Ok")]
+		public virtual string OkMessage
+		{
+			get { return okMessage; }
+			set {
+				if (okMessage == value)
+					return;
+				okMessage = value;
+				NotifyValueChanged ("OkMessage", okMessage);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue("Cancel")]
+		public virtual string CancelMessage
+		{
+			get { return cancelMessage; }
+			set {
+				if (cancelMessage == value)
+					return;
+				cancelMessage = value;
+				NotifyValueChanged ("CancelMessage", cancelMessage);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue("Information")]
+		public virtual Type MsgType
+		{
+			get { return msgType; }
+			set {
+				if (msgType == value)
+					return;
+				msgType = value;
+				NotifyValueChanged ("MsgType", msgType);
+				switch (msgType) {
+				case Type.Information:
+					NotifyValueChanged ("MsgIcon", "#Crow.Images.Icons.Informations.svg");
+					Caption = "Informations";
+					OkMessage = "Ok";
+					CancelMessage = "Cancel";
+					break;
+				case Type.YesNo:
+					NotifyValueChanged ("MsgIcon", "#Crow.Icons.question.svg");
+					Caption = "Choice";
+					OkMessage = "Yes";
+					CancelMessage = "No";
+					break;
+				case Type.Alert:
+					NotifyValueChanged ("MsgIcon", "#Crow.Images.Icons.IconAlerte.svg");
+					Caption = "Alert";
+					OkMessage = "Ok";
+					CancelMessage = "Cancel";
+					break;
+				case Type.Error:
+					NotifyValueChanged ("MsgIcon", "#Crow.Images.Icons.exit.svg");
+					Caption = "Error";
+					OkMessage = "Ok";
+					CancelMessage = "Cancel";
+					break;
+				}
+			}
+		}
+		void onOkButtonClick (object sender, EventArgs e)
+		{
+			Ok.Raise (this, null);
+			close ();
+		}
+		void onCancelButtonClick (object sender, EventArgs e)
+		{
+			Cancel.Raise (this, null);
+			close ();
+		}
+		public static MessageBox Show (Type msgBoxType, string message, string okMsg = "", string cancelMsg = ""){
+			lock (Interface.CurrentInterface.UpdateMutex) {
+				MessageBox mb = new MessageBox ();
+				mb.Initialize ();
+				mb.CurrentInterface.AddWidget (mb);
+				mb.MsgType = msgBoxType;
+				mb.Message = message;
+				if (!string.IsNullOrEmpty(okMsg))
+					mb.OkMessage = okMsg;
+				if (!string.IsNullOrEmpty(cancelMsg))
+					mb.CancelMessage = cancelMsg;
+				return mb;
+			}
+		}
+	}
+}
+
diff --git a/src/GraphicObjects/Base/NumericControl.cs b/src/GraphicObjects/Base/NumericControl.cs
new file mode 100644
index 00000000..9b511831
--- /dev/null
+++ b/src/GraphicObjects/Base/NumericControl.cs
@@ -0,0 +1,125 @@
+//
+// NumericControl.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+	public abstract class NumericControl : TemplatedControl
+	{
+		#region CTOR
+		public NumericControl () : base()
+		{
+		}
+		public NumericControl(double minimum, double maximum, double step)
+			: base()
+		{
+		}
+		#endregion
+
+		#region private fields
+		double _actualValue, minValue, maxValue, smallStep, bigStep;
+		#endregion
+
+		#region public properties
+		[XmlAttributeAttribute()][DefaultValue(0.0)]
+		public virtual double Minimum {
+			get { return minValue; }
+			set {
+				if (minValue == value)
+					return;
+
+				minValue = value;
+				NotifyValueChanged ("Minimum", minValue);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(100.0)]
+		public virtual double Maximum
+		{
+			get { return maxValue; }
+			set {
+				if (maxValue == value)
+					return;
+
+				maxValue = value;
+				NotifyValueChanged ("Maximum", maxValue);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(1.0)]
+		public virtual double SmallIncrement
+		{
+			get { return smallStep; }
+			set {
+				if (smallStep == value)
+					return;
+
+				smallStep = value;
+				NotifyValueChanged ("SmallIncrement", smallStep);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(5.0)]
+		public virtual double LargeIncrement
+		{
+			get { return bigStep; }
+			set {
+				if (bigStep == value)
+					return;
+
+				bigStep = value;
+				NotifyValueChanged ("LargeIncrement", bigStep);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(0.0)]
+		public double Value
+		{
+			get { return _actualValue; }
+			set
+			{
+				if (value == _actualValue)
+					return;
+
+				if (value < minValue)
+					_actualValue = minValue;
+				else if (value > maxValue)
+					_actualValue = maxValue;
+				else                    
+					_actualValue = value;
+
+				NotifyValueChanged("Value",  _actualValue);
+				RegisterForGraphicUpdate();
+			}
+		}
+		#endregion
+
+	}
+}
+
diff --git a/src/GraphicObjects/Base/Popper.cs b/src/GraphicObjects/Base/Popper.cs
new file mode 100644
index 00000000..d3f2e7c8
--- /dev/null
+++ b/src/GraphicObjects/Base/Popper.cs
@@ -0,0 +1,245 @@
+//
+// Popper.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using OpenTK.Input;
+
+namespace Crow
+{
+    public class Popper : TemplatedContainer
+    {
+		#region CTOR
+		public Popper() : base()
+		{
+		}
+		#endregion
+
+		bool _isPopped, _canPop;
+		Alignment popDirection;
+		GraphicObject _content;
+		Measure popWidth, popHeight;
+
+		public event EventHandler Popped;
+		public event EventHandler Unpoped;
+
+		#region Public Properties
+		[XmlAttributeAttribute()][DefaultValue("Fit")]
+		public virtual Measure PopWidth {
+			get { return popWidth; }
+			set {
+				if (popWidth == value)
+					return;
+				popWidth = value;
+				NotifyValueChanged ("PopWidth", popWidth);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("Fit")]
+		public virtual Measure PopHeight {
+			get { return popHeight; }
+			set {
+				if (popHeight == value)
+					return;
+				popHeight = value;
+				NotifyValueChanged ("PopHeight", popHeight);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(false)]
+		public bool IsPopped
+		{
+			get { return _isPopped; }
+			set
+			{
+				if (value == _isPopped)
+					return;
+
+				_isPopped = value;
+				NotifyValueChanged ("IsPopped", _isPopped);
+
+				if (_isPopped)
+					onPop (this, null);
+				else
+					onUnpop (this, null);
+
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(true)]
+		public bool CanPop
+		{
+			get { return _canPop; }
+			set
+			{
+				if (value == _canPop)
+					return;
+
+				_canPop = value;
+				NotifyValueChanged ("CanPop", _canPop);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(Alignment.Bottom)]
+		public virtual Alignment PopDirection {
+			get { return popDirection; }
+			set {
+				if (popDirection == value)
+					return;
+				popDirection = value;
+				NotifyValueChanged ("PopDirection", popDirection);
+			}
+		}
+		#endregion
+
+		public override GraphicObject Content {
+			get { return _content; }
+			set {
+				if (_content != null) {
+					_content.LogicalParent = null;
+					_content.LayoutChanged -= _content_LayoutChanged;
+				}
+
+				_content = value;
+
+				if (_content == null)
+					return;
+
+				_content.LogicalParent = this;
+				_content.HorizontalAlignment = HorizontalAlignment.Left;
+				_content.VerticalAlignment = VerticalAlignment.Top;
+				_content.LayoutChanged += _content_LayoutChanged;
+			}
+		}
+		void positionContent(LayoutingType lt){
+			ILayoutable tc = Content.Parent;
+			if (tc == null)
+				return;
+			Rectangle r = this.ScreenCoordinates (this.Slot);
+			if (lt == LayoutingType.X) {
+				if (popDirection.HasFlag (Alignment.Right)) {
+					if (r.Right + Content.Slot.Width > tc.ClientRectangle.Right)
+						Content.Left = r.Left - Content.Slot.Width;
+					else
+						Content.Left = r.Right;
+				} else if (popDirection.HasFlag (Alignment.Left)) {
+					if (r.Left - Content.Slot.Width < tc.ClientRectangle.Left)
+						Content.Left = r.Right;
+					else
+						Content.Left = r.Left - Content.Slot.Width;
+				} else {
+					if (Content.Slot.Width < tc.ClientRectangle.Width) {
+						if (r.Left + Content.Slot.Width > tc.ClientRectangle.Right)
+							Content.Left = tc.ClientRectangle.Right - Content.Slot.Width;
+						else
+							Content.Left = r.Left;
+					} else
+						Content.Left = 0;
+				}
+			}else if (lt == LayoutingType.Y) {
+				if (Content.Slot.Height < tc.ClientRectangle.Height) {
+					if (PopDirection.HasFlag (Alignment.Bottom)) {
+						if (r.Bottom + Content.Slot.Height > tc.ClientRectangle.Bottom)
+							Content.Top = r.Top - Content.Slot.Height;
+						else
+							Content.Top = r.Bottom;
+					} else if (PopDirection.HasFlag (Alignment.Top)) {
+						if (r.Top - Content.Slot.Height < tc.ClientRectangle.Top)
+							Content.Top = r.Bottom;
+						else
+							Content.Top = r.Top - Content.Slot.Height;
+					} else
+						Content.Top = r.Top;
+				}else
+					Content.Top = 0;
+			}
+		}
+		protected void _content_LayoutChanged (object sender, LayoutingEventArgs e)
+		{
+			if (e.LayoutType.HasFlag (LayoutingType.Width))
+				positionContent (LayoutingType.X);
+			if (e.LayoutType.HasFlag(LayoutingType.Height))
+				positionContent (LayoutingType.Y);
+		}
+
+		#region GraphicObject overrides
+		public override void onMouseClick (object sender, MouseButtonEventArgs e)
+		{
+			if (_canPop)
+				IsPopped = !IsPopped;
+			base.onMouseClick (this, e);
+		}
+		public override void onMouseLeave (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseLeave (this, e);
+			IsPopped = false;
+		}
+		public override bool MouseIsIn (Point m)
+		{
+			bool isInContent = false;
+			if (Content != null) {
+				if (Content.Parent != null)
+					isInContent = Content.MouseIsIn (m);
+			}
+			return base.MouseIsIn (m) || isInContent;
+		}
+		public override void checkHoverWidget (MouseMoveEventArgs e)
+		{
+			if (CurrentInterface.HoverWidget != this) {
+				CurrentInterface.HoverWidget = this;
+				onMouseEnter (this, e);
+			}
+			if (Content != null){
+				if (Content.Parent != null) {
+					if (Content.MouseIsIn (e.Position)) {
+						Content.checkHoverWidget (e);
+						return;
+					}
+				}
+			}
+			base.checkHoverWidget (e);
+		}
+		#endregion
+
+		public virtual void onPop(object sender, EventArgs e)
+		{
+			if (Content != null) {
+				Content.Visible = true;
+				if (Content.Parent == null)
+					CurrentInterface.AddWidget (Content, true);
+				if (Content.LogicalParent != this)
+					Content.LogicalParent = this;
+				CurrentInterface.PutOnTop (Content, true);
+				_content_LayoutChanged (this, new LayoutingEventArgs (LayoutingType.Sizing));
+			}
+			Popped.Raise (this, e);
+		}
+		public virtual void onUnpop(object sender, EventArgs e)
+		{
+			if (Content != null) {
+				Content.Visible = false;
+			}
+			Unpoped.Raise (this, e);
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/PrivateContainer.cs b/src/GraphicObjects/Base/PrivateContainer.cs
new file mode 100644
index 00000000..65eacabb
--- /dev/null
+++ b/src/GraphicObjects/Base/PrivateContainer.cs
@@ -0,0 +1,207 @@
+//
+// PrivateContainer.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using Cairo;
+
+namespace Crow
+{
+	/// <summary>
+	/// Implement drawing and layouting for a single child, but
+	/// does not implement IXmlSerialisation to allow reuse of container
+	/// behaviour for widgets that have other xml hierarchy: example
+	/// TemplatedControl may have 3 children (template,templateItem,content) but
+	/// behave exactely as a container for layouting and drawing
+	/// </summary>
+	public class PrivateContainer : GraphicObject
+	{
+		#region CTOR
+		public PrivateContainer()
+			: base()
+		{
+		}
+		#endregion
+
+		protected GraphicObject child;
+
+		internal virtual void SetChild(GraphicObject _child)
+		{
+
+			if (child != null) {
+				contentSize = new Size (0, 0);
+				child.LayoutChanged -= OnChildLayoutChanges;
+				child.Parent = null;
+				this.RegisterForGraphicUpdate ();
+			}
+
+			child = _child as GraphicObject;
+
+			if (child != null) {
+				child.Parent = this;
+				child.LayoutChanged += OnChildLayoutChanges;
+				contentSize = child.Slot.Size;
+				child.RegisteredLayoutings = LayoutingType.None;
+				child.RegisterForLayouting (LayoutingType.Sizing);
+			}
+		}
+
+		#region GraphicObject Overrides
+
+		public override GraphicObject FindByName (string nameToFind)
+		{
+			if (Name == nameToFind)
+				return this;
+
+			return child == null ? null : child.FindByName (nameToFind);
+		}
+		public override bool Contains (GraphicObject goToFind)
+		{
+			return child == goToFind ? true : 
+				child == null ? false : child.Contains(goToFind);
+		}
+		public override void OnDataSourceChanged (object sender, DataSourceChangeEventArgs e)
+		{
+			base.OnDataSourceChanged (this, e);
+			if (child != null)
+			if (child.localDataSourceIsNull & child.localLogicalParentIsNull)
+					child.OnDataSourceChanged (sender, e);
+		}
+		public override bool UpdateLayout (LayoutingType layoutType)
+		{
+			if (child != null) {
+				//force sizing to fit if sizing on children and child has stretched size
+				switch (layoutType) {
+				case LayoutingType.Width:
+					if (Width == Measure.Fit && child.Width.Units == Unit.Percent)
+						child.Width = Measure.Fit;
+					break;
+				case LayoutingType.Height:
+					if (Height == Measure.Fit && child.Height.Units == Unit.Percent)
+						child.Height = Measure.Fit;
+					break;
+				}
+			}
+			return base.UpdateLayout (layoutType);
+		}
+		public override void OnLayoutChanges (LayoutingType layoutType)
+		{
+			base.OnLayoutChanges (layoutType);
+
+			if (child == null)
+				return;
+			
+			LayoutingType ltChild = LayoutingType.None;
+
+			if (layoutType == LayoutingType.Width) {
+				if (child.Width.Units == Unit.Percent) {
+					ltChild |= LayoutingType.Width;
+					if (child.Width.Value < 100 && child.Left == 0)
+						ltChild |= LayoutingType.X;
+				} else if (child.Left == 0)
+					ltChild |= LayoutingType.X;
+			} else if (layoutType == LayoutingType.Height) {
+				if (child.Height.Units == Unit.Percent) {
+					ltChild |= LayoutingType.Height;
+					if (child.Height.Value < 100 && child.Top == 0)
+						ltChild |= LayoutingType.Y;
+				} else if (child.Top == 0)
+						ltChild |= LayoutingType.Y;
+			}
+			if (ltChild == LayoutingType.None)
+				return;
+			child.RegisterForLayouting (ltChild);
+		}
+		public virtual void OnChildLayoutChanges (object sender, LayoutingEventArgs arg)
+		{			
+			GraphicObject g = sender as GraphicObject;
+
+			if (arg.LayoutType == LayoutingType.Width) {
+				if (Width != Measure.Fit)
+					return;
+				contentSize.Width = g.Slot.Width;
+				this.RegisterForLayouting (LayoutingType.Width);
+			}else if (arg.LayoutType == LayoutingType.Height){
+				if (Height != Measure.Fit)
+					return;
+				contentSize.Height = g.Slot.Height;
+				this.RegisterForLayouting (LayoutingType.Height);
+			}
+		}
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+
+			gr.Save ();
+
+			if (ClipToClientRect) {
+				//clip to client zone
+				CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
+				gr.Clip ();
+			}
+
+			if (child != null) {
+				if (child.Visible)
+					child.Paint (ref gr);
+			}
+			gr.Restore ();
+		}
+		protected override void UpdateCache (Context ctx)
+		{
+			Rectangle rb = Slot + Parent.ClientRectangle.Position;
+
+			using (ImageSurface cache = new ImageSurface (bmp, Format.Argb32, Slot.Width, Slot.Height, 4 * Slot.Width)) {
+				Context gr = new Context (cache);
+
+				if (Clipping.count > 0) {
+					Clipping.clearAndClip (gr);
+
+					onDraw (gr);
+				}
+					
+				gr.Dispose ();
+
+				ctx.SetSourceSurface (cache, rb.X, rb.Y);
+				ctx.Paint ();
+			}
+			Clipping.Reset();
+		}
+		#endregion
+
+		#region Mouse handling
+		public override void checkHoverWidget (MouseMoveEventArgs e)
+		{
+			base.checkHoverWidget (e);
+			if (child != null) 
+				if (child.MouseIsIn (e.Position)) 
+					child.checkHoverWidget (e);
+		}
+		#endregion
+
+	}
+}
+
diff --git a/src/GraphicObjects/Base/ProgressBar.cs b/src/GraphicObjects/Base/ProgressBar.cs
new file mode 100644
index 00000000..34366ca7
--- /dev/null
+++ b/src/GraphicObjects/Base/ProgressBar.cs
@@ -0,0 +1,67 @@
+//
+// ProgressBar.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Cairo;
+using System.Diagnostics;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+	
+	public class ProgressBar : NumericControl
+    {
+		#region CTOR
+		public ProgressBar() : base(){}
+		#endregion
+
+		protected override void loadTemplate (GraphicObject template)
+		{
+			
+		}
+
+		#region GraphicObject overrides
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+
+			if (Maximum == 0)
+				return;
+
+			Rectangle rBack = ClientRectangle;
+			rBack.Width = (int)((double)rBack.Width / Maximum * Value);
+			Foreground.SetAsSource (gr, rBack);
+
+			CairoHelpers.CairoRectangle(gr,rBack,CornerRadius);
+			gr.Fill();
+		}
+		#endregion
+    }
+}
diff --git a/src/GraphicObjects/Base/RadioButton.cs b/src/GraphicObjects/Base/RadioButton.cs
new file mode 100644
index 00000000..993ead59
--- /dev/null
+++ b/src/GraphicObjects/Base/RadioButton.cs
@@ -0,0 +1,82 @@
+//
+// RadioButton.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.ComponentModel;
+using System.Xml.Serialization;
+
+namespace Crow
+{
+    public class RadioButton : TemplatedControl
+    {		        
+		bool isChecked;
+
+		#region CTOR
+		public RadioButton() : base(){}	
+		#endregion
+
+		public event EventHandler Checked;
+		public event EventHandler Unchecked;
+
+		#region GraphicObject overrides
+		public override void onMouseClick (object sender, MouseButtonEventArgs e)
+		{						
+			Group pg = Parent as Group;
+			if (pg != null) {
+				for (int i = 0; i < pg.Children.Count; i++) {
+					RadioButton c = pg.Children [i] as RadioButton;
+					if (c == null)
+						continue;
+					c.IsChecked = (c == this);
+				}
+			} else
+				IsChecked = !IsChecked;
+
+			base.onMouseClick (sender, e);
+		}
+		#endregion
+
+        [XmlAttributeAttribute()][DefaultValue(false)]
+        public bool IsChecked
+        {
+			get { return isChecked; }
+            set
+            {
+				if (isChecked == value)
+					return;
+				
+				isChecked = value;
+
+				NotifyValueChanged ("IsChecked", value);
+
+				if (isChecked)
+					Checked.Raise (this, null);
+				else
+					Unchecked.Raise (this, null);
+            }
+        }
+	}
+}
diff --git a/src/GraphicObjects/Base/ScrollBar.cs b/src/GraphicObjects/Base/ScrollBar.cs
new file mode 100644
index 00000000..91ce50ef
--- /dev/null
+++ b/src/GraphicObjects/Base/ScrollBar.cs
@@ -0,0 +1,68 @@
+//
+// ScrollBar.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using OpenTK.Input;
+
+namespace Crow
+{
+	public class ScrollBar : NumericControl
+	{
+		Orientation _orientation;
+
+		#region CTOR
+		public ScrollBar() : base()	{}
+		#endregion
+
+		[XmlAttributeAttribute()][DefaultValue(Orientation.Vertical)]
+		public virtual Orientation Orientation
+		{
+			get { return _orientation; }
+			set {				
+				if (_orientation == value)
+					return;
+				_orientation = value;
+				NotifyValueChanged ("Orientation", _orientation);
+				RegisterForGraphicUpdate ();
+			}
+		}
+		public void onScrollBack (object sender, MouseButtonEventArgs e)
+		{
+			Value -= SmallIncrement;
+		}
+		public void onScrollForth (object sender, MouseButtonEventArgs e)
+		{
+			Value += SmallIncrement;
+		}
+
+		public void onSliderValueChange(object sender, ValueChangeEventArgs e){
+			if (e.MemberName == "Value")
+				Value = Convert.ToDouble(e.NewValue);
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/Scroller.cs b/src/GraphicObjects/Base/Scroller.cs
new file mode 100644
index 00000000..640fcfe8
--- /dev/null
+++ b/src/GraphicObjects/Base/Scroller.cs
@@ -0,0 +1,239 @@
+//
+// Scroller.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.Diagnostics;
+using Cairo;
+
+namespace Crow
+{
+	public class Scroller : Container
+	{
+		bool _verticalScrolling;
+		bool _horizontalScrolling;
+		bool _scrollbarVisible;
+		double _scrollX = 0.0;
+		double _scrollY = 0.0;
+		int scrollSpeed;
+
+		public event EventHandler<ScrollingEventArgs> Scrolled;
+
+		#region public properties
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public bool VerticalScrolling {
+			get { return _verticalScrolling; }
+			set { _verticalScrolling = value; }
+		}
+
+		[XmlAttributeAttribute][DefaultValue(false)]
+        public bool HorizontalScrolling {
+			get { return _horizontalScrolling; }
+			set { _horizontalScrolling = value; }
+		}
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public bool ScrollbarVisible {
+			get { return _scrollbarVisible; }
+			set { _scrollbarVisible = value; }
+		}
+		[XmlAttributeAttribute][DefaultValue(0.0)]
+		public double ScrollX {
+			get {
+				return _scrollX;
+			}
+			set {
+				if (_scrollX == value)
+					return;
+				if (value < 0.0)
+					_scrollX = 0.0;
+				else if (value > Child.Slot.Width - ClientRectangle.Width)
+					_scrollX = Math.Max(0.0, Child.Slot.Width - ClientRectangle.Width);
+				else
+					_scrollX = value;
+				NotifyValueChanged("ScrollX", _scrollX);
+				RegisterForRedraw ();
+				Scrolled.Raise (this, new ScrollingEventArgs (Orientation.Horizontal));
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(0.0)]
+		public double ScrollY {
+			get {
+				return _scrollY;
+			}
+			set {
+				if (_scrollY == value)
+					return;
+				if (value < 0.0)
+					_scrollY = 0.0;
+				else if (value > Child.Slot.Height - ClientRectangle.Height)
+					_scrollY = Math.Max(0.0,Child.Slot.Height - ClientRectangle.Height);
+				else
+					_scrollY = value;
+				NotifyValueChanged("ScrollY", _scrollY);
+				RegisterForRedraw ();
+				Scrolled.Raise (this, new ScrollingEventArgs (Orientation.Vertical));
+			}
+		}
+
+		[XmlIgnore]
+		public int MaximumScroll {
+			get {
+				try {
+					return VerticalScrolling ?
+						Math.Max(Child.Slot.Height - ClientRectangle.Height,0) :
+						Math.Max(Child.Slot.Width - ClientRectangle.Width,0);
+				} catch {
+					return 0;
+				}
+			}
+		}
+
+		[XmlAttributeAttribute][DefaultValue(30)]
+		public int ScrollSpeed {
+			get { return scrollSpeed; }
+			set {
+				scrollSpeed = value;
+				NotifyValueChanged("ScrollSpeed", scrollSpeed);
+			}
+		}
+		#endregion
+
+        public Scroller()
+            : base(){}
+
+		#region GraphicObject Overrides
+		public override void OnLayoutChanges (LayoutingType layoutType)
+		{
+			base.OnLayoutChanges (layoutType);
+
+			NotifyValueChanged("MaximumScroll", MaximumScroll);
+		}
+		void OnChildLayoutChanges (object sender, LayoutingEventArgs arg)
+		{
+			//Debug.WriteLine ("scroller childLayoutChanges");
+			int maxScroll = MaximumScroll;
+			//Debug.WriteLine ("maxscroll={0}", maxScroll);
+			if (_verticalScrolling) {
+				if (arg.LayoutType == LayoutingType.Height) {
+					if (maxScroll < ScrollY) {
+						//Debug.WriteLine ("scrolly={0} maxscroll={1}", ScrollY, maxScroll);
+						ScrollY = maxScroll;
+					}
+					NotifyValueChanged("MaximumScroll", maxScroll);
+				}
+			} else if (arg.LayoutType == LayoutingType.Width) {
+				if (maxScroll < ScrollX) {
+					//Debug.WriteLine ("scrolly={0} maxscroll={1}", ScrollY, maxScroll);
+					ScrollX = maxScroll;
+				}
+				NotifyValueChanged("MaximumScroll", maxScroll);
+			}
+		}
+		void onChildListCleared(object sender, EventArgs e){
+			ScrollY = 0;
+			ScrollX = 0;
+		}
+		public override void SetChild (GraphicObject _child)
+		{
+			GraphicObject c = child as GraphicObject;
+			Group g = child as Group;
+			if (c != null) {
+				c.LayoutChanged -= OnChildLayoutChanges;
+				if (g != null)
+					g.ChildrenCleared -= onChildListCleared;
+			}
+			c = _child as GraphicObject;
+			g = _child as Group;
+			if (c != null) {
+				c.LayoutChanged += OnChildLayoutChanges;
+				if (g != null)
+					g.ChildrenCleared += onChildListCleared;
+			}
+			base.SetChild (_child);
+		}
+		public override Rectangle ScreenCoordinates (Rectangle r)
+		{
+			return base.ScreenCoordinates (r) - new Point((int)ScrollX,(int)ScrollY);
+		}
+		protected override void onDraw (Context gr)
+		{
+			Rectangle rBack = new Rectangle (Slot.Size);
+
+			Background.SetAsSource (gr, rBack);
+			CairoHelpers.CairoRectangle(gr,rBack, CornerRadius);
+			gr.Fill ();
+
+			gr.Save ();
+			if (ClipToClientRect) {
+				//clip to scrolled client zone
+				CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
+				gr.Clip ();
+			}
+
+			gr.Translate (-ScrollX, -ScrollY);
+			if (child != null)
+				child.Paint (ref gr);
+			gr.Restore ();
+		}
+
+		#region Mouse handling
+		internal Point savedMousePos;
+		public override bool MouseIsIn (Point m)
+		{
+			return Visible ? base.ScreenCoordinates(Slot).ContainsOrIsEqual (m) : false;
+		}
+		public override void checkHoverWidget (MouseMoveEventArgs e)
+		{
+			savedMousePos = e.Position;
+			Point m = e.Position - new Point ((int)ScrollX, (int)ScrollY);
+			base.checkHoverWidget (new MouseMoveEventArgs(m.X,m.Y,e.XDelta,e.YDelta));
+		}
+		public override void onMouseWheel (object sender, MouseWheelEventArgs e)
+		{
+			if (Child == null)
+				return;
+
+			if (VerticalScrolling )
+				ScrollY -= e.Delta * ScrollSpeed;
+			if (HorizontalScrolling )
+				ScrollX -= e.Delta * ScrollSpeed;
+		}
+		public override void onMouseMove (object sender, MouseMoveEventArgs e)
+		{
+			savedMousePos.X += e.XDelta;
+			savedMousePos.Y += e.YDelta;
+			base.onMouseMove (sender, new MouseMoveEventArgs(savedMousePos.X,savedMousePos.Y,e.XDelta,e.YDelta));
+		}
+		public override void RegisterClip (Rectangle clip)
+		{
+			base.RegisterClip (clip - new Point((int)ScrollX,(int)ScrollY));
+		}
+		#endregion
+
+		#endregion
+    }
+}
diff --git a/src/GraphicObjects/Base/Slider.cs b/src/GraphicObjects/Base/Slider.cs
new file mode 100644
index 00000000..36f7e731
--- /dev/null
+++ b/src/GraphicObjects/Base/Slider.cs
@@ -0,0 +1,219 @@
+//
+// Slider.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using Cairo;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Crow
+{
+	public class Slider : NumericControl
+    {
+		#region CTOR
+		public Slider() : base()
+		{}
+		public Slider(double minimum, double maximum, double step)
+			: base(minimum,maximum,step)
+		{
+		}
+		#endregion
+
+		#region implemented abstract members of TemplatedControl
+
+		protected override void loadTemplate (GraphicObject template = null)
+		{
+			
+		}
+
+		#endregion
+
+		#region private fields
+        Rectangle cursor;
+		int _cursorSize;
+		Fill _cursorColor;
+		Orientation _orientation;
+		bool holdCursor = false;
+		#endregion
+
+		protected double unity;
+
+		#region Public properties
+		[XmlAttributeAttribute()][DefaultValue("vgradient|0:White|0,1:LightGray|0,9:LightGray|1:DimGray")]
+		public virtual Fill CursorColor {
+			get { return _cursorColor; }
+			set {
+				if (_cursorColor == value)
+					return;
+				_cursorColor = value;
+				RegisterForRedraw ();
+				NotifyValueChanged ("CursorColor", _cursorColor);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(20)]
+		public virtual int CursorSize {
+			get { return _cursorSize; }
+			set {
+				if (_cursorSize == value)
+					return;
+				_cursorSize = value;
+				RegisterForGraphicUpdate ();
+				NotifyValueChanged ("CursorSize", _cursorSize);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(Orientation.Horizontal)]
+		public virtual Orientation Orientation
+		{
+			get { return _orientation; }
+			set { 
+				if (_orientation == value)
+					return;
+				_orientation = value; 
+
+				RegisterForLayouting (LayoutingType.All);
+				NotifyValueChanged ("Orientation", _orientation);
+			}
+		}
+		#endregion
+
+		[XmlAttributeAttribute()][DefaultValue(10.0)]
+		public override double Maximum {
+			get { return base.Maximum; }
+			set {				
+				if (value == base.Maximum)
+					return;
+				base.Maximum = value;
+				LargeIncrement = base.Maximum / 10.0;
+				SmallIncrement = LargeIncrement / 5.0;
+			}
+		}
+
+		#region GraphicObject Overrides
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+			if (Maximum <= 0)
+				return;
+
+			computeCursorPosition ();
+
+			Rectangle r = ClientRectangle;
+			PointD pStart;
+			PointD pEnd;
+			if (_orientation == Orientation.Horizontal) {
+				pStart = r.TopLeft + new Point (_cursorSize / 2, r.Height / 2);
+				pEnd = r.TopRight + new Point (-_cursorSize / 2, r.Height / 2);
+			} else {
+				pStart = r.TopLeft + new Point (r.Width / 2, _cursorSize / 2);
+				pEnd = r.BottomLeft + new Point (r.Width / 2,- _cursorSize / 2);
+			}
+
+			DrawGraduations (gr, pStart,pEnd);
+
+			DrawCursor (gr, cursor);
+		}
+		#endregion
+
+		protected virtual void DrawGraduations(Context gr, PointD pStart, PointD pEnd)
+		{
+			Foreground.SetAsSource (gr);
+
+			gr.LineWidth = 1;
+			gr.MoveTo(pStart);
+			gr.LineTo(pEnd);
+
+			gr.Stroke();
+
+		}
+		protected virtual void DrawCursor(Context gr, Rectangle _cursor)
+		{
+			CursorColor.SetAsSource (gr, _cursor);
+			CairoHelpers.CairoRectangle (gr, _cursor, CornerRadius);
+			gr.Fill();
+		}
+
+        void computeCursorPosition()
+        {            
+            Rectangle r = ClientRectangle;
+			PointD p1; 
+
+			if (_orientation == Orientation.Horizontal) {
+				cursor = new Rectangle (new Size (_cursorSize, (int)(r.Height)));
+				p1 = r.TopLeft + new Point (_cursorSize / 2, r.Height / 2);
+				unity = (double)(r.Width - _cursorSize) / (Maximum - Minimum);
+				cursor.TopLeft = new Point (r.Left + (int)(Value * unity),
+					(int)(p1.Y - cursor.Height / 2));
+			} else {
+				cursor = new Rectangle (new Size ((int)(r.Width), _cursorSize));
+				p1 = r.TopLeft + new Point (r.Width / 2, _cursorSize / 2);
+				unity = (double)(r.Height - _cursorSize) / (Maximum - Minimum);
+				cursor.TopLeft = new Point ((int)(p1.X - r.Width / 2),
+					r.Top + (int)(Value * unity));				
+			}
+			cursor.Inflate (-1);
+        }
+        
+		#region mouse handling
+		public override void onMouseDown (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseDown (sender, e);
+
+			Rectangle cursInScreenCoord = ScreenCoordinates (cursor + Slot.Position);
+			if (cursInScreenCoord.ContainsOrIsEqual (e.Position))
+				holdCursor = true;
+			else if (_orientation == Orientation.Horizontal) {
+				if (e.Position.X < cursInScreenCoord.Left)
+					Value -= LargeIncrement;
+				else
+					Value += LargeIncrement;
+			} else {
+				if (e.Position.Y < cursInScreenCoord.Top)
+					Value -= LargeIncrement;
+				else
+					Value += LargeIncrement;
+			}
+		}
+		public override void onMouseUp (object sender,MouseButtonEventArgs e)
+		{
+			base.onMouseUp (sender, e);
+
+			holdCursor = false;
+		}
+		public override void onMouseMove (object sender, MouseMoveEventArgs e)
+		{
+			if (holdCursor) {
+				if (_orientation == Orientation.Horizontal)
+					Value += (double)e.XDelta / unity;
+				else
+					Value += (double)e.YDelta / unity;
+			}
+			
+			base.onMouseMove (sender, e);
+		}
+		#endregion
+    }
+}
diff --git a/src/GraphicObjects/Base/Spinner.cs b/src/GraphicObjects/Base/Spinner.cs
new file mode 100644
index 00000000..1bf93a37
--- /dev/null
+++ b/src/GraphicObjects/Base/Spinner.cs
@@ -0,0 +1,55 @@
+//
+// Spinner.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+
+namespace Crow
+{
+	public class Spinner : NumericControl
+	{
+		#region CTOR
+		public Spinner () : base()
+		{
+		}
+		public Spinner (double minimum, double maximum, double step) : 
+		base (minimum, maximum, step)
+		{
+
+		}
+		#endregion
+
+		void onUp (object sender, MouseButtonEventArgs e)
+		{
+			Value += this.SmallIncrement;
+		}
+		void onDown (object sender, MouseButtonEventArgs e)
+		{
+			Value -= this.SmallIncrement;
+		}
+
+	}
+}
+
diff --git a/src/GraphicObjects/Base/Splitter.cs b/src/GraphicObjects/Base/Splitter.cs
new file mode 100644
index 00000000..2f5dd15b
--- /dev/null
+++ b/src/GraphicObjects/Base/Splitter.cs
@@ -0,0 +1,218 @@
+//
+// Splitter.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+	public class Splitter : GraphicObject
+	{
+		#region CTOR
+		public Splitter (): base(){}
+		#endregion
+
+		int thickness;
+
+		[XmlAttributeAttribute][DefaultValue(1)]
+		public virtual int Thickness {
+			get { return thickness; }
+			set {
+				if (thickness == value)
+					return;
+				thickness = value; 
+				NotifyValueChanged ("Thickness", thickness);
+				RegisterForLayouting (LayoutingType.Sizing);
+				RegisterForGraphicUpdate ();
+			}
+		}
+
+		Unit u1, u2;
+		int init1 = -1, init2 = -1, delta = 0, min1, min2, max1 , max2;
+		GraphicObject go1 = null, go2 = null;
+
+		void initSplit(Measure m1, int size1, Measure m2, int size2){
+			if (m1 != Measure.Stretched) {
+				init1 = size1;
+				u1 = m1.Units;
+			}
+			if (m2 != Measure.Stretched) {
+				init2 = size2;
+				u2 = m2.Units;
+			}
+		}
+		void convertSizeInPix(GraphicObject g1){
+
+		}
+
+		#region GraphicObject override
+		public override ILayoutable Parent {
+			get { return base.Parent; }
+			set {
+				if (value != null) {			
+					GenericStack gs = value as GenericStack;
+					if (gs == null)
+						throw new Exception ("Splitter may only be chil of stack");
+					
+				}
+				base.Parent = value;
+			}
+		}
+		public override void onMouseEnter (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseEnter (sender, e);
+			if ((Parent as GenericStack).Orientation == Orientation.Horizontal)
+				CurrentInterface.MouseCursor = XCursor.H;
+			else
+				CurrentInterface.MouseCursor = XCursor.V;
+		}
+		public override void onMouseLeave (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseLeave (sender, e);
+			CurrentInterface.MouseCursor = XCursor.Default;
+		}
+		public override void onMouseDown (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseDown (sender, e);
+			go1 = go2 = null;
+			init1 = init2 = -1;
+			delta = 0;
+
+			GenericStack gs = Parent as GenericStack;
+			int ptrSplit = gs.Children.IndexOf (this);
+			if (ptrSplit == 0 || ptrSplit == gs.Children.Count - 1)
+				return;
+
+			go1 = gs.Children [ptrSplit - 1];
+			go2 = gs.Children [ptrSplit + 1];
+
+			if (gs.Orientation == Orientation.Horizontal) {
+				initSplit (go1.Width, go1.Slot.Width, go2.Width, go2.Slot.Width);
+				min1 = go1.MinimumSize.Width;
+				min2 = go2.MinimumSize.Width;
+				max1 = go1.MaximumSize.Width;
+				max2 = go2.MaximumSize.Width;
+				if (init1 >= 0)
+					go1.Width = init1;
+				if (init2 >= 0)
+					go2.Width = init2;
+			} else {
+				initSplit (go1.Height, go1.Slot.Height, go2.Height, go2.Slot.Height);
+				min1 = go1.MinimumSize.Height;
+				min2 = go2.MinimumSize.Height;
+				max1 = go1.MaximumSize.Height;
+				max2 = go2.MaximumSize.Height;
+				if (init1 >= 0)
+					go1.Height = init1;
+				if (init2 >= 0)
+					go2.Height = init2;
+			}
+		}
+		public override void onMouseMove (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseMove (sender, e);
+
+			if (!IsActive)
+				return;
+
+			GenericStack gs = Parent as GenericStack;
+			int newDelta = delta, size1 = init1 , size2 = init2;
+			if (gs.Orientation == Orientation.Horizontal) {
+				newDelta -= e.XDelta;
+				if (size1 < 0)
+					size1 = go1.Slot.Width + delta;
+				if (size2 < 0)
+					size2 = go2.Slot.Width - delta;
+			} else {
+				newDelta -= e.YDelta;
+				if (size1 < 0)
+					size1 = go1.Slot.Height + delta;
+				if (size2 < 0)
+					size2 = go2.Slot.Height - delta;
+			}
+
+			if (size1 - newDelta < min1 || (max1 > 0 && size1 - newDelta > max1) ||
+				size2 + newDelta < min2 || (max2 > 0 && size2 + newDelta > max2))
+				return;
+
+			delta = newDelta;
+
+			if (gs.Orientation == Orientation.Horizontal) {
+				if (init1 >= 0)
+					go1.Width = init1 - delta;
+				if (init2 >= 0)
+					go2.Width = init2 + delta;
+			} else {
+				if (init1 >= 0)
+					go1.Height = init1 - delta;
+				if (init2 >= 0)
+					go2.Height = init2 + delta;
+			}
+		}
+		public override void onMouseUp (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseUp (sender, e);
+
+			GenericStack gs = Parent as GenericStack;
+
+			if (init1 >= 0 && u1 == Unit.Percent) {
+				if (gs.Orientation == Orientation.Horizontal)
+					go1.Width = new Measure ((int)Math.Ceiling (
+						go1.Width.Value * 100.0 / (double)gs.Slot.Width), Unit.Percent);
+				else
+					go1.Height = new Measure ((int)Math.Ceiling (
+						go1.Height.Value * 100.0 / (double)gs.Slot.Height), Unit.Percent);
+			}
+			if (init2 >= 0 && u2 == Unit.Percent) {
+				if (gs.Orientation == Orientation.Horizontal)
+					go2.Width = new Measure ((int)Math.Floor (
+						go2.Width.Value * 100.0 / (double)gs.Slot.Width), Unit.Percent);
+				else
+					go2.Height = new Measure ((int)Math.Floor (
+						go2.Height.Value * 100.0 / (double)gs.Slot.Height), Unit.Percent);
+			}
+		}
+		public override bool UpdateLayout (LayoutingType layoutType)
+		{
+			GenericStack gs = Parent as GenericStack;
+			if (layoutType == LayoutingType.Width){
+				if (gs.Orientation == Orientation.Horizontal)
+					Width = thickness;
+				else
+					Width = Measure.Stretched;
+			} else if (layoutType == LayoutingType.Height){
+				if (gs.Orientation == Orientation.Vertical)
+					Height = thickness;
+				else
+					Height = Measure.Stretched;
+			}
+			return base.UpdateLayout (layoutType);
+		}
+		#endregion
+	}
+}
+
diff --git a/src/GraphicObjects/Base/TabItem.cs b/src/GraphicObjects/Base/TabItem.cs
new file mode 100644
index 00000000..7dac5472
--- /dev/null
+++ b/src/GraphicObjects/Base/TabItem.cs
@@ -0,0 +1,210 @@
+//
+// TabItem.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Crow
+{
+	public class TabItem : TemplatedContainer
+	{
+		#region CTOR
+		public TabItem () : base() {}
+		#endregion
+
+		#region Private fields
+		string caption;
+		Container _contentContainer;
+		GraphicObject _tabTitle;
+		int tabOffset;
+		bool isSelected;
+		Measure tabThickness;
+		#endregion
+
+		#region TemplatedControl overrides
+		public override GraphicObject Content {
+			get {
+				return _contentContainer == null ? null : _contentContainer.Child;
+			}
+			set {
+				if (Content != null) {
+					Content.LogicalParent = null;
+					_contentContainer.SetChild (null);
+				}
+				_contentContainer.SetChild(value);
+				if (value != null)
+					value.LogicalParent = this;
+			}
+		}
+		protected override void loadTemplate(GraphicObject template = null)
+		{
+			base.loadTemplate (template);
+
+			_contentContainer = this.child.FindByName ("Content") as Container;
+			_tabTitle = this.child.FindByName ("TabTitle");
+		}
+		internal GraphicObject TabTitle { get { return _tabTitle; }}
+		#endregion
+
+		[XmlAttributeAttribute][DefaultValue("18")]
+		public virtual Measure TabThickness {
+			get { return tabThickness; }
+			set {
+				if (tabThickness == value)
+					return;
+				tabThickness = value;
+				NotifyValueChanged ("TabThickness", tabThickness);
+				RegisterForGraphicUpdate ();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(0)]
+		public virtual int TabOffset {
+			get { return tabOffset; }
+			set {
+				if (tabOffset == value)
+					return;
+				tabOffset = value;
+				NotifyValueChanged ("TabOffset", tabOffset);
+
+				RegisterForLayouting (LayoutingType.X);
+				RegisterForGraphicUpdate ();
+			}
+		}
+
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public virtual bool IsSelected {
+			get { return isSelected; }
+			set {
+				if (isSelected == value)
+					return;
+				isSelected = value;
+				NotifyValueChanged ("IsSelected", isSelected);
+			}
+		}
+		protected override void onDraw (Cairo.Context gr)
+		{
+			gr.Save ();
+
+			int spacing = (Parent as TabView).Spacing;
+
+			gr.MoveTo (0.5, TabTitle.Slot.Bottom-0.5);
+			gr.LineTo (TabTitle.Slot.Left - spacing, TabTitle.Slot.Bottom-0.5);
+			gr.CurveTo (
+				TabTitle.Slot.Left - spacing / 2, TabTitle.Slot.Bottom-0.5,
+				TabTitle.Slot.Left - spacing / 2, 0.5,
+				TabTitle.Slot.Left, 0.5);
+			gr.LineTo (TabTitle.Slot.Right, 0.5);
+			gr.CurveTo (
+				TabTitle.Slot.Right + spacing / 2, 0.5,
+				TabTitle.Slot.Right + spacing / 2, TabTitle.Slot.Bottom-0.5,
+				TabTitle.Slot.Right + spacing, TabTitle.Slot.Bottom-0.5);
+			gr.LineTo (Slot.Width-0.5, TabTitle.Slot.Bottom-0.5);
+
+
+			gr.LineTo (Slot.Width-0.5, Slot.Height-0.5);
+			gr.LineTo (0.5, Slot.Height-0.5);
+			gr.ClosePath ();
+			gr.LineWidth = 2;
+			Foreground.SetAsSource (gr);
+			gr.StrokePreserve ();
+
+			gr.Clip ();
+			base.onDraw (gr);
+			gr.Restore ();
+		}
+
+		#region Mouse Handling
+		public override bool MouseIsIn (Point m)
+		{
+			if (!Visible)
+				return false;
+
+			bool mouseIsInTitle = TabTitle.ScreenCoordinates (TabTitle.Slot).ContainsOrIsEqual (m);
+			if (!IsSelected)
+				return mouseIsInTitle;
+
+			return _contentContainer.ScreenCoordinates (_contentContainer.Slot).ContainsOrIsEqual (m)
+				|| mouseIsInTitle;
+		}
+		bool holdCursor = false;
+		public override void onMouseDown (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseDown (sender, e);
+			holdCursor = true;
+		}
+		public override void onMouseUp (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseUp (sender, e);
+			holdCursor = false;
+			(Parent as TabView).UpdateLayout (LayoutingType.ArrangeChildren);
+		}
+		public override void onMouseMove (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseMove (sender, e);
+
+			if (!(HasFocus&&holdCursor))
+				return;
+			TabView tv = Parent as TabView;
+			TabItem previous = null, next = null;
+			int tmp = TabOffset + e.XDelta;
+			if (tmp < tv.Spacing)
+				TabOffset = tv.Spacing;
+			else if (tmp > Parent.getSlot ().Width - TabTitle.Slot.Width - tv.Spacing)
+				TabOffset = Parent.getSlot ().Width - TabTitle.Slot.Width - tv.Spacing;
+			else{
+				int idx = tv.Children.IndexOf (this);
+				if (idx > 0 && e.XDelta < 0) {
+					previous = tv.Children [idx - 1] as TabItem;
+
+					if (tmp < previous.TabOffset + previous.TabTitle.Slot.Width / 2) {
+						tv.Children.RemoveAt (idx);
+						tv.Children.Insert (idx - 1, this);
+						tv.SelectedTab = idx - 1;
+						tv.UpdateLayout (LayoutingType.ArrangeChildren);
+					}
+
+				}else if (idx < tv.Children.Count - 1 && e.XDelta > 0) {
+					next = tv.Children [idx + 1] as TabItem;
+					if (tmp > next.TabOffset - next.TabTitle.Slot.Width / 2){
+						tv.Children.RemoveAt (idx);
+						tv.Children.Insert (idx + 1, this);
+						tv.SelectedTab = idx + 1;
+						tv.UpdateLayout (LayoutingType.ArrangeChildren);
+					}
+				}
+				TabOffset = tmp;
+			}
+		}
+		public void butCloseTabClick (object sender, MouseButtonEventArgs e){
+			(Parent as TabView).RemoveChild(this);
+		}
+		#endregion
+
+	}
+}
+
diff --git a/src/GraphicObjects/Base/TabView.cs b/src/GraphicObjects/Base/TabView.cs
new file mode 100644
index 00000000..ecf38f10
--- /dev/null
+++ b/src/GraphicObjects/Base/TabView.cs
@@ -0,0 +1,210 @@
+//
+// TabView.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using Cairo;
+using System.Diagnostics;
+
+namespace Crow
+{	
+	public class TabView : Group
+	{
+		#region CTOR
+		public TabView () : base() {}
+		#endregion
+
+		#region Private fields
+		int _spacing;
+		Measure tabThickness;
+		Orientation _orientation;
+		int selectedTab = 0;
+		#endregion
+
+
+		#region public properties
+		[XmlAttributeAttribute()][DefaultValue(Orientation.Horizontal)]
+		public virtual Orientation Orientation
+		{
+			get { return _orientation; }
+			set {
+				if (_orientation == value)
+					return;
+				_orientation = value;
+				NotifyValueChanged ("Orientation", _orientation);
+				if (_orientation == Orientation.Horizontal)
+					NotifyValueChanged ("TabOrientation", Orientation.Vertical);
+				else
+					NotifyValueChanged ("TabOrientation", Orientation.Horizontal);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(16)]
+		public int Spacing
+		{
+			get { return _spacing; }
+			set {
+				if (_spacing == value)
+					return;
+				_spacing = value;
+				NotifyValueChanged ("Spacing", Spacing);
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue(0)]
+		public virtual int SelectedTab {
+			get { return selectedTab; }
+			set {
+				if (selectedTab < Children.Count && SelectedTab >= 0)
+					(Children [selectedTab] as TabItem).IsSelected = false;
+
+				selectedTab = value;
+
+				if (selectedTab < Children.Count && SelectedTab >= 0)
+					(Children [selectedTab] as TabItem).IsSelected = true;
+
+				NotifyValueChanged ("SelectedTab", selectedTab);
+				RegisterForRedraw ();
+			}
+		}
+		#endregion
+
+		public override void AddChild (GraphicObject child)
+		{
+			TabItem ti = child as TabItem;
+			if (ti == null)
+				throw new Exception ("TabView control accept only TabItem as child.");
+
+			ti.MouseDown += Ti_MouseDown;
+
+			if (Children.Count == 0) {
+				ti.IsSelected = true;
+				SelectedTab = 0;
+			}
+
+			base.AddChild (child);
+		}
+		public override void RemoveChild (GraphicObject child)
+		{
+			base.RemoveChild (child);
+			if (selectedTab > Children.Count - 1)
+				SelectedTab--;
+			else
+				SelectedTab = selectedTab;
+		}
+		public override bool ArrangeChildren { get { return true; } }
+		public override bool UpdateLayout (LayoutingType layoutType)
+		{
+			RegisteredLayoutings &= (~layoutType);
+
+			if (layoutType == LayoutingType.ArrangeChildren) {
+				int curOffset = Spacing;
+				for (int i = 0; i < Children.Count; i++) {
+					if (!Children [i].Visible)
+						continue;
+					TabItem ti = Children [i] as TabItem;
+					ti.TabOffset = curOffset;
+					if (Orientation == Orientation.Horizontal) {
+						if (ti.TabTitle.RegisteredLayoutings.HasFlag (LayoutingType.Width))
+							return false;
+						curOffset += ti.TabTitle.Slot.Width + Spacing;
+					} else {
+						if (ti.TabTitle.RegisteredLayoutings.HasFlag (LayoutingType.Height))
+							return false;
+						curOffset += ti.TabTitle.Slot.Height + Spacing;
+					}
+				}
+
+				//if no layouting remains in queue for item, registre for redraw
+				if (RegisteredLayoutings == LayoutingType.None && IsDirty)
+					CurrentInterface.EnqueueForRepaint (this);
+
+				return true;
+			}
+
+			return base.UpdateLayout(layoutType);
+		}
+		protected override void onDraw (Context gr)
+		{
+			Rectangle rBack = new Rectangle (Slot.Size);
+
+			Background.SetAsSource (gr, rBack);
+			CairoHelpers.CairoRectangle(gr,rBack, CornerRadius);
+			gr.Fill ();
+
+			gr.Save ();
+
+			if (ClipToClientRect) {
+				//clip to client zone
+				CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
+				gr.Clip ();
+			}
+
+			for (int i = 0; i < Children.Count; i++) {
+				if (i == SelectedTab)
+					continue;
+				Children [i].Paint (ref gr);
+			}
+
+			if (SelectedTab < Children.Count && SelectedTab >= 0)
+				Children [SelectedTab].Paint (ref gr);
+
+			gr.Restore ();
+		}
+
+		#region Mouse handling
+		public override void checkHoverWidget (MouseMoveEventArgs e)
+		{
+			if (CurrentInterface.HoverWidget != this) {
+				CurrentInterface.HoverWidget = this;
+				onMouseEnter (this, e);
+			}
+
+			if (SelectedTab > Children.Count - 1)
+				return;
+
+			if (((Children[SelectedTab] as TabItem).Content.Parent as GraphicObject).MouseIsIn(e.Position))
+			{
+				Children[SelectedTab].checkHoverWidget (e);
+				return;
+			}
+			for (int i = Children.Count - 1; i >= 0; i--) {
+				TabItem ti = Children [i] as TabItem;
+				if (ti.TabTitle.MouseIsIn(e.Position))
+				{
+					Children[i].checkHoverWidget (e);
+					return;
+				}
+			}
+		}
+		#endregion
+
+		void Ti_MouseDown (object sender, MouseButtonEventArgs e)
+		{
+			SelectedTab = Children.IndexOf (sender as GraphicObject);
+		}
+	}
+}
+
diff --git a/src/GraphicObjects/Base/TemplatedContainer.cs b/src/GraphicObjects/Base/TemplatedContainer.cs
new file mode 100644
index 00000000..1ab8cf7d
--- /dev/null
+++ b/src/GraphicObjects/Base/TemplatedContainer.cs
@@ -0,0 +1,128 @@
+//
+// TemplatedContainer.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.Xml;
+using System.Reflection;
+
+namespace Crow
+{
+	public abstract class TemplatedContainer : TemplatedControl
+	{
+		#region CTOR
+		public TemplatedContainer () : base(){}
+		#endregion
+
+		[XmlAttributeAttribute]public virtual GraphicObject Content{ get; set;}
+
+		#region GraphicObject overrides
+		public override GraphicObject FindByName (string nameToFind)
+		{
+			if (Name == nameToFind)
+				return this;
+
+			return Content == null ? null : Content.FindByName (nameToFind);
+		}
+		public override bool Contains (GraphicObject goToFind)
+		{
+			if (Content == null)
+				return base.Contains (goToFind);
+
+			if (Content == goToFind)
+				return true;
+			return Content.Contains (goToFind);
+		}
+		#endregion
+
+		#region IXmlSerialisation Overrides
+		public override void ReadXml(System.Xml.XmlReader reader)
+		{
+			using (System.Xml.XmlReader subTree = reader.ReadSubtree ()) {
+				subTree.Read ();
+				string tmp = subTree.ReadOuterXml ();
+
+				//seek for template tag
+				using (XmlReader xr = new XmlTextReader (tmp, XmlNodeType.Element, null)) {
+					xr.Read ();
+					base.ReadXml (xr);
+				}
+				//process content
+				using (XmlReader xr = new XmlTextReader (tmp, XmlNodeType.Element, null)) {
+					xr.Read (); //skip current node
+
+					while (!xr.EOF) {
+						xr.Read (); //read first child
+
+						if (!xr.IsStartElement ())
+							continue;
+
+						if (xr.Name == "Template"){
+							xr.Skip ();
+							if (!xr.IsStartElement ())
+								continue;
+						}
+
+						Type t = Type.GetType ("Crow." + xr.Name);
+						if (t == null) {
+							Assembly a = Assembly.GetEntryAssembly ();
+							foreach (Type expT in a.GetExportedTypes ()) {
+								if (expT.Name == xr.Name) {
+									t = expT;
+									break;
+								}
+							}
+						}
+						if (t == null)
+							throw new Exception (xr.Name + " type not found");
+
+						GraphicObject go = (GraphicObject)Activator.CreateInstance (t);
+
+						(go as IXmlSerializable).ReadXml (xr);
+
+						Content = go;
+
+						xr.Read (); //closing tag
+					}
+
+				}
+			}
+		}
+		public override void WriteXml(System.Xml.XmlWriter writer)
+		{
+			base.WriteXml(writer);
+
+			if (Content == null)
+				return;
+			//TODO: if template is not the default one, we have to save it
+			writer.WriteStartElement(Content.GetType().Name);
+			(Content as IXmlSerializable).WriteXml(writer);
+			writer.WriteEndElement();
+		}
+		#endregion
+	}
+}
+
diff --git a/src/GraphicObjects/Base/TemplatedControl.cs b/src/GraphicObjects/Base/TemplatedControl.cs
new file mode 100644
index 00000000..082d0426
--- /dev/null
+++ b/src/GraphicObjects/Base/TemplatedControl.cs
@@ -0,0 +1,210 @@
+//
+// TemplatedControl.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.IO;
+using System.Xml;
+using System.Diagnostics;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+
+namespace Crow
+{
+	public abstract class TemplatedControl : PrivateContainer, IXmlSerializable
+	{
+		#region CTOR
+		public TemplatedControl () : base()
+		{
+		}
+		#endregion
+
+		string _template;
+		string caption;
+
+		[XmlAttributeAttribute][DefaultValue(null)]
+		public string Template {
+			get { return _template; }
+			set {
+				if (Template == value)
+					return;
+				_template = value;
+
+				if (string.IsNullOrEmpty(_template))
+					loadTemplate ();
+				else
+					loadTemplate (CurrentInterface.Load (_template));
+			}
+		}
+		[XmlAttributeAttribute()][DefaultValue("Templated Control")]
+		public virtual string Caption {
+			get { return caption; }
+			set {
+				if (caption == value)
+					return;
+				caption = value;
+				NotifyValueChanged ("Caption", caption);
+			}
+		}
+		#region GraphicObject overrides
+		public override void Initialize ()
+		{
+			loadTemplate ();
+			base.Initialize ();
+		}
+		public override GraphicObject FindByName (string nameToFind)
+		{
+			//prevent name searching in template
+			return nameToFind == this.Name ? this : null;
+		}
+		protected override void onDraw (Cairo.Context gr)
+		{
+			//onDraw is overrided to prevent default drawing of background, template top container
+			//may have a binding to root background or a fixed one.
+			//this allow applying root background to random template's component
+			gr.Save ();
+
+			if (ClipToClientRect) {
+				//clip to client zone
+				CairoHelpers.CairoRectangle (gr, ClientRectangle, CornerRadius);
+				gr.Clip ();
+			}
+
+			if (child != null)
+				child.Paint (ref gr);
+			gr.Restore ();
+		}
+		#endregion
+
+		protected virtual void loadTemplate(GraphicObject template = null)
+		{
+			if (template == null) {
+				if (!Interface.DefaultTemplates.ContainsKey (this.GetType ().FullName))
+					throw new Exception (string.Format ("No default template found for '{0}'", this.GetType ().FullName));
+				this.SetChild (CurrentInterface.Load (Interface.DefaultTemplates[this.GetType ().FullName]));
+			}else
+				this.SetChild (template);
+		}
+
+		//TODO:IXmlSerializable is not used anymore
+		#region IXmlSerializable
+		public override System.Xml.Schema.XmlSchema GetSchema(){ return null; }
+		public override void ReadXml(System.Xml.XmlReader reader)
+		{
+			//Template could be either an attribute containing path or expressed inlined
+			//as a Template Element
+			using (System.Xml.XmlReader subTree = reader.ReadSubtree())
+			{
+				subTree.Read ();
+
+				string template = reader.GetAttribute ("Template");
+				string tmp = subTree.ReadOuterXml ();
+
+				//Load template from path set as attribute in templated control
+				if (string.IsNullOrEmpty (template)) {
+					//seek for template tag first
+					using (XmlReader xr = new XmlTextReader (tmp, XmlNodeType.Element, null)) {
+						//load template first if inlined
+
+						xr.Read (); //read first child
+						xr.Read (); //skip root node
+
+						while (!xr.EOF) {
+							if (!xr.IsStartElement ()) {
+								xr.Read ();
+								continue;
+							}
+							if (xr.Name == "ItemTemplate") {
+								string dataType = "default", datas = "", itemTmp;
+								while (xr.MoveToNextAttribute ()) {
+									if (xr.Name == "DataType")
+										dataType = xr.Value;
+									else if (xr.Name == "Data")
+										datas = xr.Value;
+								}
+								xr.MoveToElement ();
+								itemTmp = xr.ReadInnerXml ();
+
+//								if (ItemTemplates == null)
+//									ItemTemplates = new Dictionary<string, ItemTemplate> ();
+//
+//								using (IMLReader iTmp = new IMLReader (null, itemTmp)) {
+//									ItemTemplates [dataType] =
+//										new ItemTemplate (iTmp.RootType, iTmp.GetLoader (), dataType, datas);
+//								}
+//								if (!string.IsNullOrEmpty (datas))
+//									ItemTemplates [dataType].CreateExpandDelegate(this);
+
+								continue;
+							}
+							if (xr.Name == "Template") {
+								xr.Read ();
+
+								Type t = Type.GetType ("Crow." + xr.Name);
+								if (t == null) {
+									Assembly a = Assembly.GetEntryAssembly ();
+									foreach (Type expT in a.GetExportedTypes ()) {
+										if (expT.Name == xr.Name) {
+											t = expT;
+											break;
+										}
+									}
+								}
+								GraphicObject go = (GraphicObject)Activator.CreateInstance (t);
+								(go as IXmlSerializable).ReadXml (xr);
+
+								loadTemplate (go);
+								continue;
+							}
+							xr.ReadInnerXml ();
+						}
+					}
+				} else
+					loadTemplate (CurrentInterface.Load (template));
+
+				//if no template found, load default one
+				if (this.child == null)
+					loadTemplate ();
+
+				//normal xml read
+				using (XmlReader xr = new XmlTextReader (tmp, XmlNodeType.Element, null)) {
+					xr.Read ();
+					base.ReadXml(xr);
+				}
+			}
+		}
+		public override void WriteXml(System.Xml.XmlWriter writer)
+		{
+			//TODO:
+			throw new NotImplementedException();
+		}
+		#endregion
+	}
+}
+
diff --git a/src/GraphicObjects/Base/TemplatedGroup.cs b/src/GraphicObjects/Base/TemplatedGroup.cs
new file mode 100644
index 00000000..e4447168
--- /dev/null
+++ b/src/GraphicObjects/Base/TemplatedGroup.cs
@@ -0,0 +1,489 @@
+//
+// TemplatedGroup.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.Xml;
+using System.Reflection;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Collections;
+using System.Threading;
+using System.Linq;
+
+namespace Crow
+{
+	public abstract class TemplatedGroup : TemplatedControl
+	{
+		#region CTOR
+		public TemplatedGroup () : base(){}
+		#endregion
+
+		protected Group items;
+		string _itemTemplate, _dataTest;
+
+		#region events
+		public event EventHandler<SelectionChangeEventArgs> SelectedItemChanged;
+		public event EventHandler Loaded;
+		#endregion
+
+		IList data;
+		int _selectedIndex = -1;
+		Color selBackground, selForeground;
+
+		int itemPerPage = 50;
+		CrowThread loadingThread = null;
+		volatile bool cancelLoading = false;
+
+		bool isPaged = false;
+
+		#region Templating
+		//TODO: dont instantiate ItemTemplates if not used
+		//but then i should test if null in msil gen
+		public Dictionary<string, ItemTemplate> ItemTemplates = new Dictionary<string, Crow.ItemTemplate>();
+
+		/// <summary>
+		/// Default item template
+		/// </summary>
+		[XmlAttributeAttribute][DefaultValue("#Crow.Templates.ItemTemplate.goml")]
+		public string ItemTemplate {
+			get { return _itemTemplate; }
+			set {
+				if (value == _itemTemplate)
+					return;
+
+				_itemTemplate = value;
+
+				//TODO:reload list with new template?
+				NotifyValueChanged("ItemTemplate", _itemTemplate);
+			}
+		}
+		protected override void loadTemplate(GraphicObject template = null)
+		{
+			base.loadTemplate (template);
+
+			items = this.child.FindByName ("ItemsContainer") as Group;
+			if (items == null)
+				throw new Exception ("TemplatedGroup template Must contain a Group named 'ItemsContainer'");
+			if (items.Children.Count == 0)
+				NotifyValueChanged ("HasChildren", false);
+			else
+				NotifyValueChanged ("HasChildren", true);
+		}
+		/// <summary>
+		/// Use to define condition on Data item for selecting among ItemTemplates.
+		/// Default value is 'TypeOf' for selecting Template depending on Type of Data.
+		/// Other possible values are properties of Data
+		/// </summary>
+		/// <value>The data property test.</value>
+		[XmlAttributeAttribute][DefaultValue("TypeOf")]
+		public string DataTest {
+			get { return _dataTest; }
+			set {
+				if (value == _dataTest)
+					return;
+
+				_dataTest = value;
+
+				NotifyValueChanged("DataTest", _dataTest);
+			}
+		}
+		#endregion
+
+		public virtual List<GraphicObject> Items{
+			get {
+				return isPaged ? items.Children.SelectMany(x => (x as Group).Children).ToList()
+				: items.Children;
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(-1)]public int SelectedIndex{
+			get { return _selectedIndex; }
+			set {
+				if (value == _selectedIndex)
+					return;
+
+				if (_selectedIndex >= 0 && Items.Count > _selectedIndex) {
+					Items[_selectedIndex].Foreground = Color.Transparent;
+					Items[_selectedIndex].Background = Color.Transparent;
+				}
+
+				_selectedIndex = value;
+
+				if (_selectedIndex >= 0 && Items.Count > _selectedIndex) {
+					Items[_selectedIndex].Foreground = SelectionForeground;
+					Items[_selectedIndex].Background = SelectionBackground;
+				}
+
+				NotifyValueChanged ("SelectedIndex", _selectedIndex);
+				NotifyValueChanged ("SelectedItem", SelectedItem);
+				SelectedItemChanged.Raise (this, new SelectionChangeEventArgs (SelectedItem));
+			}
+		}
+		[XmlIgnore]public virtual object SelectedItem{
+			get { return data == null ? null : _selectedIndex < 0 ? null : data[_selectedIndex]; }
+		}
+		[XmlIgnore]public bool HasItems {
+			get { return Items.Count > 0; }
+		}
+		[XmlAttributeAttribute]public IList Data {
+			get { return data; }
+			set {
+				if (value == data)
+					return;
+
+				cancelLoadingThread ();
+
+				data = value;
+
+				NotifyValueChanged ("Data", data);
+
+				lock (CurrentInterface.LayoutMutex)
+					ClearItems ();
+
+				if (data == null)
+					return;
+
+				loadingThread = new CrowThread (this, loading);
+				loadingThread.Finished += (object sender, EventArgs e) => (sender as TemplatedGroup).Loaded.Raise (sender, e);
+				loadingThread.Start ();
+
+				NotifyValueChanged ("SelectedIndex", _selectedIndex);
+				NotifyValueChanged ("SelectedItem", SelectedItem);
+				SelectedItemChanged.Raise (this, new SelectionChangeEventArgs (SelectedItem));
+				NotifyValueChanged ("HasItems", HasItems);
+			}
+		}
+
+		[XmlAttributeAttribute][DefaultValue("SteelBlue")]
+		public virtual Color SelectionBackground {
+			get { return selBackground; }
+			set {
+				if (value == selBackground)
+					return;
+				selBackground = value;
+				NotifyValueChanged ("SelectionBackground", selBackground);
+				RegisterForRedraw ();
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue("White")]
+		public virtual Color SelectionForeground {
+			get { return selForeground; }
+			set {
+				if (value == selForeground)
+					return;
+				selForeground = value;
+				NotifyValueChanged ("SelectionForeground", selForeground);
+				RegisterForRedraw ();
+			}
+		}
+
+		protected void raiseSelectedItemChanged(){
+			SelectedItemChanged.Raise (this, new SelectionChangeEventArgs (SelectedItem));
+		}
+
+
+		public virtual void AddItem(GraphicObject g){
+			items.AddChild (g);
+			g.LogicalParent = this;
+			NotifyValueChanged ("HasChildren", true);
+		}
+		public virtual void RemoveItem(GraphicObject g)
+		{
+			g.LogicalParent = null;
+			items.RemoveChild (g);
+			if (items.Children.Count == 0)
+				NotifyValueChanged ("HasChildren", false);
+		}
+
+		public virtual void ClearItems()
+		{
+			_selectedIndex = -1;
+			NotifyValueChanged ("SelectedIndex", _selectedIndex);
+			NotifyValueChanged ("SelectedItem", null);
+
+			items.ClearChildren ();
+			NotifyValueChanged ("HasChildren", false);
+		}
+
+
+		#region GraphicObject overrides
+		public override GraphicObject FindByName (string nameToFind)
+		{
+			if (Name == nameToFind)
+				return this;
+
+			foreach (GraphicObject w in Items) {
+				GraphicObject r = w.FindByName (nameToFind);
+				if (r != null)
+					return r;
+			}
+			return null;
+		}
+		public override bool Contains (GraphicObject goToFind)
+		{
+			foreach (GraphicObject w in Items) {
+				if (w == goToFind)
+					return true;
+				if (w.Contains (goToFind))
+					return true;
+			}
+			return base.Contains(goToFind);
+		}
+//		public override void ClearBinding ()
+//		{
+//			if (items != null)
+//				items.ClearBinding ();
+//
+//			base.ClearBinding ();
+//		}
+//		public override void ResolveBindings ()
+//		{
+//			base.ResolveBindings ();
+//			if (items != null)
+//				items.ResolveBindings ();
+//		}
+		#endregion
+
+		#region IXmlSerialisation Overrides
+		public override void ReadXml(System.Xml.XmlReader reader)
+		{
+			using (System.Xml.XmlReader subTree = reader.ReadSubtree ()) {
+				subTree.Read ();
+				string tmp = subTree.ReadOuterXml ();
+
+				//seek for template tag
+				using (XmlReader xr = new XmlTextReader (tmp, XmlNodeType.Element, null)) {
+					xr.Read ();
+					base.ReadXml (xr);
+				}
+				//process content
+				using (XmlReader xr = new XmlTextReader (tmp, XmlNodeType.Element, null)) {
+					xr.Read (); //skip current node
+
+					while (!xr.EOF) {
+						xr.Read (); //read first child
+
+						if (!xr.IsStartElement ())
+							continue;
+
+						if (xr.Name == "Template" || Name == "ItemTemplate"){
+							xr.Skip ();
+							if (!xr.IsStartElement ())
+								continue;
+						}
+
+						Type t = Type.GetType ("Crow." + xr.Name);
+						if (t == null) {
+							Assembly a = Assembly.GetEntryAssembly ();
+							foreach (Type expT in a.GetExportedTypes ()) {
+								if (expT.Name == xr.Name) {
+									t = expT;
+									break;
+								}
+							}
+						}
+						if (t == null)
+							throw new Exception (xr.Name + " type not found");
+
+						GraphicObject go = (GraphicObject)Activator.CreateInstance (t);
+
+						(go as IXmlSerializable).ReadXml (xr);
+
+						AddItem (go);
+
+						xr.Read (); //closing tag
+					}
+
+				}
+			}
+		}
+		public override void WriteXml(System.Xml.XmlWriter writer)
+		{
+			throw new NotImplementedException ();
+		}
+		#endregion
+
+		void loading(){
+			if (ItemTemplates == null)
+				ItemTemplates = new Dictionary<string, ItemTemplate> ();
+			if (!ItemTemplates.ContainsKey ("default"))
+				ItemTemplates ["default"] = Interface.GetItemTemplate (ItemTemplate);
+
+			for (int i = 1; i <= (data.Count / itemPerPage) + 1; i++) {
+				if (cancelLoading)
+					return;
+				loadPage (i);
+				Thread.Sleep (1);
+			}
+		}
+		void cancelLoadingThread(){
+			if (loadingThread != null)
+				loadingThread.Cancel ();
+		}
+		void loadPage(int pageNum)
+		{
+			#if DEBUG_LOAD
+			Stopwatch loadingTime = new Stopwatch ();
+			loadingTime.Start ();
+			#endif
+
+			Group page;
+			if (typeof(Wrapper).IsAssignableFrom (items.GetType ())) {
+				page = items;
+				itemPerPage = int.MaxValue;
+			} else if (typeof(GenericStack).IsAssignableFrom (items.GetType ())) {
+				GenericStack gs = new GenericStack ();
+				gs.CurrentInterface = items.CurrentInterface;
+				gs.Initialize ();
+				gs.Orientation = (items as GenericStack).Orientation;
+				gs.Width = items.Width;
+				gs.Height = items.Height;
+				gs.VerticalAlignment = items.VerticalAlignment;
+				gs.HorizontalAlignment = items.HorizontalAlignment;
+				page = gs;
+				page.Name = "page" + pageNum;
+				isPaged = true;
+			} else {
+				page = Activator.CreateInstance (items.GetType ()) as Group;
+				page.Name = "page" + pageNum;
+				isPaged = true;
+			}
+
+			for (int i = (pageNum - 1) * itemPerPage; i < pageNum * itemPerPage; i++) {
+				if (i >= data.Count)
+					break;
+				if (cancelLoading)
+					return;
+
+				loadItem (i, page);
+			}
+
+			if (page == items)
+				return;
+			lock (CurrentInterface.LayoutMutex)
+				items.AddChild (page);
+
+			#if DEBUG_LOAD
+			loadingTime.Stop ();
+			Debug.WriteLine("Listbox {2} Loading: {0} ticks \t, {1} ms",
+			loadingTime.ElapsedTicks,
+			loadingTime.ElapsedMilliseconds, this.ToString());
+			#endif
+		}
+		string getItempKey(Type dataType, object o){
+			try {
+				return dataType.GetProperty (_dataTest).GetGetMethod ().Invoke (o, null).ToString();
+			} catch (Exception ex) {
+				return dataType.FullName;
+			}
+		}
+		protected void loadItem(int i, Group page){
+			if (data [i] == null)//TODO:surely a threading sync problem
+				return;
+			GraphicObject g = null;
+			ItemTemplate iTemp = null;
+			Type dataType = data [i].GetType ();
+			string itempKey = dataType.FullName;
+
+			if (_dataTest != "TypeOf")
+				itempKey = getItempKey (dataType, data [i]);
+
+			if (ItemTemplates.ContainsKey (itempKey))
+				iTemp = ItemTemplates [itempKey];
+			else {
+				foreach (string it in ItemTemplates.Keys) {
+					Type t = Type.GetType (it);
+					if (t == null) {
+						Assembly a = Assembly.GetEntryAssembly ();
+						foreach (Type expT in a.GetExportedTypes ()) {
+							if (expT.Name == it) {
+								t = expT;
+								break;
+							}
+						}
+					}
+					if (t == null)
+						continue;
+					if (t.IsAssignableFrom (dataType)) {//TODO:types could be cached
+						iTemp = ItemTemplates [it];
+						break;
+					}
+				}
+				if (iTemp == null)
+					iTemp = ItemTemplates ["default"];
+			}
+
+			lock (CurrentInterface.LayoutMutex) {
+				g = iTemp.CreateInstance(CurrentInterface);
+				page.AddChild (g);
+				//g.LogicalParent = this;
+				registerItemClick (g);
+			}
+
+			if (iTemp.Expand != null && g is Expandable) {
+				(g as Expandable).Expand += iTemp.Expand;
+				(g as Expandable).GetIsExpandable = iTemp.HasSubItems;
+			}
+
+			g.DataSource = data [i];
+		}
+		protected virtual void registerItemClick(GraphicObject g){
+			g.MouseClick += itemClick;
+		}
+//		protected void _list_LayoutChanged (object sender, LayoutingEventArgs e)
+//		{
+//			#if DEBUG_LAYOUTING
+//			Debug.WriteLine("list_LayoutChanged");
+//			#endif
+//			if (_gsList.Orientation == Orientation.Horizontal) {
+//				if (e.LayoutType == LayoutingType.Width)
+//					_gsList.Width = approxSize;
+//			} else if (e.LayoutType == LayoutingType.Height)
+//				_gsList.Height = approxSize;
+//		}
+		int approxSize
+		{
+			get {
+				if (data == null)
+					return -1;
+				GenericStack page1 = items.FindByName ("page1") as GenericStack;
+				if (page1 == null)
+					return -1;
+
+				return page1.Orientation == Orientation.Horizontal ?
+					data.Count < itemPerPage ?
+					-1:
+					(int)Math.Ceiling ((double)page1.Slot.Width / (double)itemPerPage * (double)(data.Count+1)):
+					data.Count < itemPerPage ?
+					-1:
+					(int)Math.Ceiling ((double)page1.Slot.Height / (double)itemPerPage * (double)(data.Count+1));
+			}
+		}
+		internal virtual void itemClick(object sender, MouseButtonEventArgs e){
+			SelectedIndex = data.IndexOf((sender as GraphicObject).DataSource);
+		}
+	}
+}
diff --git a/src/GraphicObjects/Base/TextBox.cs b/src/GraphicObjects/Base/TextBox.cs
new file mode 100644
index 00000000..0cbee9f8
--- /dev/null
+++ b/src/GraphicObjects/Base/TextBox.cs
@@ -0,0 +1,228 @@
+//
+// TextBox.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using Cairo;
+using System.Diagnostics;
+using System.Xml.Serialization;
+
+namespace Crow
+{
+    public class TextBox : Label
+    {
+		#region CTOR
+		public TextBox()
+		{ }
+		public TextBox(string _initialValue)
+			: base(_initialValue)
+		{
+
+		}
+		#endregion
+
+		#region GraphicObject overrides
+		[XmlIgnore]public override bool HasFocus   //trigger update when lost focus to errase text beam
+        {
+            get
+            {
+                return base.HasFocus;
+            }
+            set
+            {
+                base.HasFocus = value;
+                RegisterForRedraw();
+            }
+        }
+
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+			FontExtents fe = gr.FontExtents;
+		}
+		#endregion
+			
+        #region Keyboard handling
+		public override void onKeyDown (object sender, KeyboardKeyEventArgs e)
+		{
+			base.onKeyDown (sender, e);
+
+			Key key = e.Key;
+
+			switch (key)
+			{
+			case Key.Back:
+				if (CurrentPosition == 0)
+					return;
+				this.DeleteChar();
+				break;
+			case Key.Clear:
+				break;
+			case Key.Delete:
+				if (selectionIsEmpty) {
+					if (!MoveRight ())
+						return;
+				}else if (e.Shift)
+					CurrentInterface.Clipboard = this.SelectedText;
+				this.DeleteChar ();
+				break;
+			case Key.Enter:
+			case Key.KeypadEnter:
+				if (!selectionIsEmpty)
+					this.DeleteChar ();
+				if (Multiline)
+					this.InsertLineBreak ();
+				else
+					OnTextChanged(this,new TextChangeEventArgs(Text));
+				break;
+			case Key.Escape:
+				Text = "";
+				CurrentColumn = 0;
+				SelRelease = -1;
+				break;
+			case Key.Home:
+				if (e.Shift) {
+					if (selectionIsEmpty)
+						SelBegin = new Point (CurrentColumn, CurrentLine);
+					if (e.Control)
+						CurrentLine = 0;
+					CurrentColumn = 0;
+					SelRelease = new Point (CurrentColumn, CurrentLine);
+					break;
+				}
+				SelRelease = -1;
+				if (e.Control)
+					CurrentLine = 0;
+				CurrentColumn = 0;
+				break;
+			case Key.End:
+				if (e.Shift) {
+					if (selectionIsEmpty)
+						SelBegin = CurrentPosition;
+					if (e.Control)
+						CurrentLine = int.MaxValue;
+					CurrentColumn = int.MaxValue;
+					SelRelease = CurrentPosition;
+					break;
+				}
+				SelRelease = -1;
+				if (e.Control)
+					CurrentLine = int.MaxValue;
+				CurrentColumn = int.MaxValue;
+				break;
+			case Key.Insert:
+				if (e.Shift)
+					this.Insert (CurrentInterface.Clipboard);
+				else if (e.Control && !selectionIsEmpty)
+					CurrentInterface.Clipboard = this.SelectedText;
+				break;
+			case Key.Left:
+				if (e.Shift) {
+					if (selectionIsEmpty)
+						SelBegin = new Point(CurrentColumn, CurrentLine);
+					if (e.Control)
+						GotoWordStart ();
+					else if (!MoveLeft ())
+						return;
+					SelRelease = CurrentPosition;
+					break;
+				}
+				SelRelease = -1;
+				if (e.Control)
+					GotoWordStart ();
+				else
+					MoveLeft();
+				break;
+			case Key.Right:
+				if (e.Shift) {
+					if (selectionIsEmpty)
+						SelBegin = CurrentPosition;
+					if (e.Control)
+						GotoWordEnd ();
+					else if (!MoveRight ())
+						return;
+					SelRelease = CurrentPosition;
+					break;
+				}
+				SelRelease = -1;
+				if (e.Control)
+					GotoWordEnd ();
+				else
+					MoveRight ();
+				break;
+			case Key.Up:
+				if (e.Shift) {
+					if (selectionIsEmpty)
+						SelBegin = CurrentPosition;
+					CurrentLine--;
+					SelRelease = CurrentPosition;
+					break;
+				}
+				SelRelease = -1;
+				CurrentLine--;
+				break;
+			case Key.Down:
+				if (e.Shift) {
+					if (selectionIsEmpty)
+						SelBegin = CurrentPosition;
+					CurrentLine++;
+					SelRelease = CurrentPosition;
+					break;
+				}
+				SelRelease = -1;
+				CurrentLine++;				
+				break;
+			case Key.Menu:
+				break;
+			case Key.NumLock:
+				break;
+			case Key.PageDown:				
+				break;
+			case Key.PageUp:
+				break;
+			case Key.RWin:
+				break;
+			case Key.Tab:
+				this.Insert ("\t");
+				break;
+			default:
+				break;
+			}
+			RegisterForGraphicUpdate();
+		}
+		public override void onKeyPress (object sender, KeyPressEventArgs e)
+		{
+			base.onKeyPress (sender, e);
+
+			this.Insert (e.KeyChar.ToString());
+
+			SelRelease = -1;
+			SelBegin = new Point(CurrentColumn, SelBegin.Y);
+
+			RegisterForGraphicUpdate();
+		}
+        #endregion
+	} 
+}
diff --git a/src/GraphicObjects/Base/TextRun.cs b/src/GraphicObjects/Base/TextRun.cs
new file mode 100644
index 00000000..a312ca1e
--- /dev/null
+++ b/src/GraphicObjects/Base/TextRun.cs
@@ -0,0 +1,315 @@
+//
+// TextRun.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Diagnostics;
+using Cairo;
+using System.Text.RegularExpressions;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+namespace Crow
+{
+	public class TextRun : GraphicObject
+	{
+		#region CTOR
+		public TextRun ()
+		{
+
+		}
+		public TextRun (string _text)
+			: base ()
+		{
+			Text = _text;
+		}
+		#endregion
+
+		//TODO:change protected to private
+
+		#region private and protected fields
+		protected string _text = "label";
+		Alignment _textAlignment = Alignment.Left;
+		bool horizontalStretch = false;
+		bool verticalStretch = false;
+		bool _multiline;
+		bool wordWrap;
+		protected Rectangle rText;
+		protected float widthRatio = 1f;
+		protected float heightRatio = 1f;
+		protected FontExtents fe;
+		protected TextExtents te;
+		#endregion
+
+
+		[XmlAttributeAttribute ()]
+		[DefaultValue (Alignment.Left)]
+		public Alignment TextAlignment {
+			get { return _textAlignment; }
+			set { _textAlignment = value; }
+		}
+		[XmlAttributeAttribute ()]
+		[DefaultValue (false)]
+		public virtual bool HorizontalStretch {
+			get { return horizontalStretch; }
+			set {
+				if (horizontalStretch == value)
+					return;
+				horizontalStretch = value;
+				RegisterForRedraw ();
+				NotifyValueChanged ("HorizontalStretch", horizontalStretch);
+			}
+		}
+		[XmlAttributeAttribute ()]
+		[DefaultValue (false)]
+		public virtual bool VerticalStretch {
+			get { return verticalStretch; }
+			set {
+				if (verticalStretch == value)
+					return;
+				verticalStretch = value;
+				RegisterForRedraw ();
+				NotifyValueChanged ("VerticalStretch", verticalStretch);
+			}
+		}
+		[XmlAttributeAttribute ()]
+		[DefaultValue ("label")]
+		public string Text {
+			get {
+				return lines == null ?
+					_text : lines.Aggregate ((i, j) => i + Interface.LineBreak + j);
+			}
+			set {
+				if (_text == value)
+					return;
+
+				RegisterForGraphicUpdate ();
+
+				_text = value;
+
+				if (string.IsNullOrEmpty (_text))
+					_text = "";
+
+				lines = getLines;
+			}
+		}
+		[XmlAttributeAttribute ()]
+		[DefaultValue (false)]
+		public bool Multiline {
+			get { return _multiline; }
+			set {
+				_multiline = value;
+				RegisterForGraphicUpdate ();
+			}
+		}
+		[XmlAttributeAttribute ()]
+		[DefaultValue (false)]
+		public bool WordWrap {
+			get {
+				return wordWrap;
+			}
+			set {
+				if (wordWrap == value)
+					return;
+				wordWrap = value;
+				RegisterForGraphicUpdate ();
+			}
+		}
+
+		List<string> lines;
+		List<string> getLines {
+			get {
+				return _multiline ?
+					Regex.Split (_text, "\r\n|\r|\n").ToList () :
+					new List<string> (new string [] { _text });
+			}
+		}
+
+		#region GraphicObject overrides
+		protected override int measureRawSize (LayoutingType lt)
+		{
+			if (lines == null)
+				lines = getLines;
+
+			using (ImageSurface img = new ImageSurface (Format.Argb32, 10, 10)) {
+				using (Context gr = new Context (img)) {
+					//Cairo.FontFace cf = gr.GetContextFontFace ();
+
+					gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+					gr.SetFontSize (Font.Size);
+
+
+					fe = gr.FontExtents;
+					te = new TextExtents ();
+
+					if (lt == LayoutingType.Height) {
+						int lc = lines.Count;
+						//ensure minimal height = text line height
+						if (lc == 0)
+							lc = 1;
+
+						return (int)(fe.Height * lc) + Margin * 2;
+					}
+
+					foreach (string s in lines) {
+						string l = s.Replace("\t", new String (' ', Interface.TabSize));
+						TextExtents tmp = gr.TextExtents (l);
+						if (tmp.XAdvance > te.XAdvance)
+							te = tmp;
+					}
+					return (int)Math.Ceiling (te.XAdvance) + Margin * 2;
+				}
+			}
+		}
+		protected override void onDraw (Context gr)
+		{
+			base.onDraw (gr);
+
+			gr.SelectFontFace (Font.Name, Font.Slant, Font.Wheight);
+			gr.SetFontSize (Font.Size);
+			gr.FontOptions = Interface.FontRenderingOptions;
+			gr.Antialias = Interface.Antialias;
+
+			rText = new Rectangle (new Size (
+				measureRawSize (LayoutingType.Width), measureRawSize (LayoutingType.Height)));
+			rText.Width -= 2 * Margin;
+			rText.Height -= 2 * Margin;
+
+			widthRatio = 1f;
+			heightRatio = 1f;
+
+			Rectangle cb = ClientRectangle;
+
+			//ignore text alignment if size to content = true
+			//or if text size is larger than client bounds
+			if (Width < 0 || Height < 0 || rText.Width > cb.Width) {
+				rText.X = cb.X;
+				rText.Y = cb.Y;
+			} else {
+				if (horizontalStretch) {
+					widthRatio = (float)cb.Width / rText.Width;
+					if (!verticalStretch)
+						heightRatio = widthRatio;
+				}
+				if (verticalStretch) {
+					heightRatio = (float)cb.Height / rText.Height;
+					if (!horizontalStretch)
+						widthRatio = heightRatio;
+				}
+
+				rText.Width = (int)(widthRatio * cb.Width);
+				rText.Height = (int)(heightRatio * cb.Height);
+
+				switch (TextAlignment) {
+				case Alignment.TopLeft:     //ok
+					rText.X = cb.X;
+					rText.Y = cb.Y;
+					break;
+				case Alignment.Top:   //ok						
+					rText.Y = cb.Y;
+					rText.X = cb.X + cb.Width / 2 - rText.Width / 2;
+					break;
+				case Alignment.TopRight:    //ok
+					rText.Y = cb.Y;
+					rText.X = cb.Right - rText.Width;
+					break;
+				case Alignment.Left://ok
+					rText.X = cb.X;
+					rText.Y = cb.Y + cb.Height / 2 - rText.Height / 2;
+					break;
+				case Alignment.Right://ok
+					rText.X = cb.X + cb.Width - rText.Width;
+					rText.Y = cb.Y + cb.Height / 2 - rText.Height / 2;
+					break;
+				case Alignment.Bottom://ok
+					rText.X = cb.Width / 2 - rText.Width / 2;
+					rText.Y = cb.Height - rText.Height;
+					break;
+				case Alignment.BottomLeft://ok
+					rText.X = cb.X;
+					rText.Y = cb.Bottom - rText.Height;
+					break;
+				case Alignment.BottomRight://ok
+					rText.Y = cb.Bottom - rText.Height;
+					rText.X = cb.Right - rText.Width;
+					break;
+				case Alignment.Center://ok
+					rText.X = cb.X + cb.Width / 2 - rText.Width / 2;
+					rText.Y = cb.Y + cb.Height / 2 - rText.Height / 2;
+					break;
+				}
+			}
+
+			gr.FontMatrix = new Matrix (widthRatio * Font.Size, 0, 0, heightRatio * Font.Size, 0, 0);
+
+
+			int curLineCount = 0;
+			for (int i = 0; i < lines.Count; i++) {
+				string l = lines [i].Replace ("\t", new String (' ', Interface.TabSize));
+				List<string> wl = new List<string> ();
+				int lineLength = (int)gr.TextExtents (l).XAdvance;
+
+				if (wordWrap && lineLength > cb.Width) {
+					string tmpLine = "";
+					int curChar = 0;
+					while (curChar < l.Length) {
+						tmpLine += l [curChar];
+						if ((int)gr.TextExtents (tmpLine).XAdvance > cb.Width) {
+							tmpLine = tmpLine.Remove (tmpLine.Length - 1);
+							wl.Add (tmpLine);
+							tmpLine = "";
+							continue;
+						}
+						curChar++;
+					}
+					wl.Add (tmpLine);
+				} else
+					wl.Add (l);
+
+				foreach (string ll in wl) {
+					lineLength = (int)gr.TextExtents (ll).XAdvance;
+
+
+					if (string.IsNullOrWhiteSpace (ll)) {
+						curLineCount++;
+						continue;
+					}
+
+					Foreground.SetAsSource (gr);
+					gr.MoveTo (rText.X, rText.Y + fe.Ascent + fe.Height * curLineCount);
+
+					gr.ShowText (ll);
+					gr.Fill ();
+
+					curLineCount++;
+				}
+			}
+		}
+		#endregion
+	}
+}
diff --git a/src/GraphicObjects/Base/TreeView.cs b/src/GraphicObjects/Base/TreeView.cs
new file mode 100644
index 00000000..6549f148
--- /dev/null
+++ b/src/GraphicObjects/Base/TreeView.cs
@@ -0,0 +1,120 @@
+//
+// TreeView.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.Diagnostics;
+using System.ComponentModel;
+
+namespace Crow
+{
+	//treeview expect expandable child (or not)
+	//if their are expandable, some functions and events are added
+	public class TreeView : TemplatedGroup
+	{
+		GraphicObject selectedItemContainer = null;
+		bool isRoot;
+
+		#region CTOR
+		public TreeView () : base()
+		{
+		}
+		#endregion
+
+		[XmlAttributeAttribute()][DefaultValue(false)]
+		public virtual bool IsRoot {
+			get { return isRoot; }
+			set {
+				if (isRoot == value)
+					return;
+				isRoot = value;
+				NotifyValueChanged ("IsRoot", isRoot);
+			}
+		}
+		[XmlIgnore]public override object SelectedItem {
+			get {
+				return selectedItemContainer == null ?
+					"" : selectedItemContainer.DataSource;
+			}
+		}
+
+		protected override void registerItemClick (GraphicObject g)
+		{
+			//register ItemClick on the Root node
+			TreeView tv = this as TreeView;
+			while (!tv.IsRoot) {
+				ILayoutable tmp = tv.Parent;
+				while (!(tmp is TreeView)) {
+					tmp = tmp.Parent;
+				}
+				tv = tmp as TreeView;
+			}
+			g.MouseClick += tv.itemClick;
+		}
+		internal override void itemClick (object sender, MouseButtonEventArgs e)
+		{
+			GraphicObject tmp = sender as GraphicObject;
+			if (!tmp.HasFocus)
+				return;
+			if (selectedItemContainer != null) {
+				selectedItemContainer.Foreground = Color.Transparent;
+				selectedItemContainer.Background = Color.Transparent;
+			}
+			selectedItemContainer = tmp;
+			selectedItemContainer.Foreground = SelectionForeground;
+			selectedItemContainer.Background = SelectionBackground;
+			NotifyValueChanged ("SelectedItem", SelectedItem);
+			raiseSelectedItemChanged ();
+		}
+
+		void onExpandAll_MouseClick (object sender, MouseButtonEventArgs e)
+		{
+			ExpandAll ();
+		}
+
+		public void ExpandAll(){
+			foreach (Group grp in items.Children) {
+				foreach (GraphicObject go in grp.Children) {
+					Expandable exp = go as Expandable;
+					if (exp == null)
+						continue;
+					TreeView subTV = exp.FindByName ("List") as TreeView;
+					if (subTV == null)
+						continue;
+					EventHandler handler = null;
+					handler = delegate(object sender, EventArgs e) {
+						TreeView tv = sender as TreeView;
+						tv.Loaded -= handler;
+						tv.ExpandAll ();
+					};
+					subTV.Loaded += handler;
+					exp.IsExpanded = true;
+				}
+			}
+		}
+	}
+}
+
diff --git a/src/GraphicObjects/Base/VerticalStack.cs b/src/GraphicObjects/Base/VerticalStack.cs
new file mode 100644
index 00000000..d5d0236b
--- /dev/null
+++ b/src/GraphicObjects/Base/VerticalStack.cs
@@ -0,0 +1,49 @@
+//
+// VerticalStack.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Crow
+{
+    public class VerticalStack : GenericStack
+    {
+        public VerticalStack()
+            : base()
+        {
+        }
+
+        [System.Xml.Serialization.XmlIgnore]
+        public override Orientation Orientation
+        {
+            get { return Orientation.Vertical; }            
+        }
+
+
+    }
+}
diff --git a/src/GraphicObjects/Base/Window.cs b/src/GraphicObjects/Base/Window.cs
new file mode 100644
index 00000000..e2820528
--- /dev/null
+++ b/src/GraphicObjects/Base/Window.cs
@@ -0,0 +1,399 @@
+//
+// Window.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Xml.Serialization;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Crow
+{
+	public class Window : TemplatedContainer
+	{
+		enum Direction
+		{
+			None,
+			N,
+			S,
+			E,
+			W,
+			NW,
+			NE,
+			SW,
+			SE,
+		}
+
+		string _icon;
+		bool _resizable;
+		bool _movable;
+		bool hoverBorder = false;
+		bool alwaysOnTop = false;
+
+		Rectangle savedBounds;
+		bool _minimized = false;
+
+		Container _contentContainer;
+		Direction currentDirection = Direction.None;
+
+		#region Events
+		public event EventHandler Closing;
+		public event EventHandler Maximized;
+		public event EventHandler Unmaximized;
+		public event EventHandler Minimize;
+		#endregion
+
+		#region CTOR
+		public Window () : base() {
+			
+		}
+		#endregion
+
+		#region TemplatedContainer overrides
+		public override GraphicObject Content {
+			get { return _contentContainer == null ? null : _contentContainer.Child; }
+			set { _contentContainer.SetChild(value); }
+		}
+		protected override void loadTemplate(GraphicObject template = null)
+		{
+			base.loadTemplate (template);
+			_contentContainer = this.child.FindByName ("Content") as Container;
+
+			NotifyValueChanged ("ShowNormal", false);
+			NotifyValueChanged ("ShowMinimize", true);
+			NotifyValueChanged ("ShowMaximize", true);
+		}
+		#endregion
+
+		#region public properties
+		[XmlAttributeAttribute][DefaultValue("#Crow.Images.Icons.crow.png")]
+		public string Icon {
+			get { return _icon; } 
+			set {
+				if (_icon == value)
+					return;
+				_icon = value;
+				NotifyValueChanged ("Icon", _icon);
+			}
+		} 
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public bool Resizable {
+			get {
+				return _resizable;
+			}
+			set {
+				if (_resizable == value)
+					return;
+				_resizable = value;
+				NotifyValueChanged ("Resizable", _resizable);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(true)]
+		public bool Movable {
+			get {
+				return _movable;
+			}
+			set {
+				if (_movable == value)
+					return;
+				_movable = value;
+				NotifyValueChanged ("Movable", _movable);
+			}
+		}
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public bool IsMinimized {
+			get { return _minimized; }
+			set{
+				if (value == IsMinimized)
+					return;
+
+				_minimized = value;
+				_contentContainer.Visible = !_minimized;
+
+				NotifyValueChanged ("IsMinimized", _minimized);
+			}
+		}
+		[XmlIgnore]public bool IsMaximized {
+			get { return Width == Measure.Stretched & Height == Measure.Stretched & !_minimized; }
+		}
+		[XmlIgnore]public bool IsNormal {
+			get { return !(IsMaximized|_minimized); }
+		}
+		[XmlAttributeAttribute][DefaultValue(false)]
+		public bool AlwaysOnTop {
+			get {
+				return alwaysOnTop;
+			}
+			set {
+				if (alwaysOnTop == value)
+					return;
+				alwaysOnTop = value;
+				if (alwaysOnTop) {
+					CurrentInterface.PutOnTop (this);
+					CurrentInterface.TopWindows++;
+				}else
+					CurrentInterface.TopWindows--;
+				NotifyValueChanged ("AlwaysOnTop", alwaysOnTop);
+			}
+		}
+//		[XmlAttributeAttribute()][DefaultValue(WindowState.Normal)]
+//		public virtual WindowState State {
+//			get { return _state; }
+//			set {
+//				if (_state == value)
+//					return;
+//				_state = value;
+//				NotifyValueChanged ("State", _state);
+//				NotifyValueChanged ("IsNormal", IsNormal);
+//				NotifyValueChanged ("IsMaximized", IsMaximized);
+//				NotifyValueChanged ("IsMinimized", IsMinimized);
+//				NotifyValueChanged ("IsNotMinimized", IsNotMinimized);
+//			}
+//		} 
+		#endregion
+
+		#region GraphicObject Overrides
+		public override void onMouseMove (object sender, MouseMoveEventArgs e)
+		{
+			base.onMouseMove (sender, e);
+
+			Interface otkgw = CurrentInterface;
+
+			if (!hoverBorder) {
+				currentDirection = Direction.None;
+				CurrentInterface.MouseCursor = XCursor.Default;
+				return;
+			}
+
+			if (this.HasFocus && _movable) {
+				if (e.Mouse.IsButtonDown (MouseButton.Left)) {
+					int currentLeft = this.Left;
+					int currentTop = this.Top;
+					int currentWidth, currentHeight;
+
+					if (currentLeft == 0) {
+						currentLeft = this.Slot.Left;
+						this.Left = currentLeft;
+					}
+					if (currentTop == 0) {
+						currentTop = this.Slot.Top;
+						this.Top = currentTop;
+					}
+					if (this.Width.IsFixed)
+						currentWidth = this.Width;
+					else
+						currentWidth = this.Slot.Width;
+				
+					if (this.Height.IsFixed)
+						currentHeight = this.Height;
+					else
+						currentHeight = this.Slot.Height;
+
+					switch (currentDirection) {
+					case Direction.None:
+						this.Left = currentLeft + e.XDelta;				
+						this.Top = currentTop + e.YDelta;
+						break;
+					case Direction.N:
+						this.Height = currentHeight - e.YDelta;
+						if (this.Height == currentHeight - e.YDelta)
+							this.Top = currentTop + e.YDelta;
+						break;
+					case Direction.S:
+						this.Height = currentHeight + e.YDelta;
+						break;
+					case Direction.W:
+						this.Width = currentWidth - e.XDelta;
+						if (this.Width == currentWidth - e.XDelta)
+							this.Left = currentLeft + e.XDelta;
+						break;
+					case Direction.E:
+						this.Width = currentWidth + e.XDelta;
+						break;
+					case Direction.NW:
+						this.Height = currentHeight - e.YDelta;
+						if (this.Height == currentHeight - e.YDelta)
+							this.Top = currentTop + e.YDelta;
+						this.Width = currentWidth - e.XDelta;
+						if (this.Width == currentWidth - e.XDelta)
+							this.Left = currentLeft + e.XDelta;
+						break;
+					case Direction.NE:
+						this.Height = currentHeight - e.YDelta;
+						if (this.Height == currentHeight - e.YDelta)
+							this.Top = currentTop + e.YDelta;
+						this.Width = currentWidth + e.XDelta;
+						break;
+					case Direction.SW:
+						this.Width = currentWidth - e.XDelta;
+						if (this.Width == currentWidth - e.XDelta)
+							this.Left = currentLeft + e.XDelta;
+						this.Height = currentHeight + e.YDelta;
+						break;
+					case Direction.SE:
+						this.Height = currentHeight + e.YDelta;
+						this.Width = currentWidth + e.XDelta;
+						break;
+					}
+					return;
+				}
+			}
+			if (Resizable) {
+				Direction lastDir = currentDirection;
+
+				if (Math.Abs (e.Position.Y - this.Slot.Y) < Interface.BorderThreshold) {
+					if (Math.Abs (e.Position.X - this.Slot.X) < Interface.BorderThreshold)
+						currentDirection = Direction.NW;
+					else if (Math.Abs (e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
+						currentDirection = Direction.NE;
+					else
+						currentDirection = Direction.N;
+				} else if (Math.Abs (e.Position.Y - this.Slot.Bottom) < Interface.BorderThreshold) {
+					if (Math.Abs (e.Position.X - this.Slot.X) < Interface.BorderThreshold)
+						currentDirection = Direction.SW;
+					else if (Math.Abs (e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
+						currentDirection = Direction.SE;
+					else
+						currentDirection = Direction.S;
+				} else if (Math.Abs (e.Position.X - this.Slot.X) < Interface.BorderThreshold)
+					currentDirection = Direction.W;
+				else if (Math.Abs (e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
+					currentDirection = Direction.E;
+				else
+					currentDirection = Direction.None;
+
+				if (currentDirection != lastDir) {
+					switch (currentDirection) {
+					case Direction.None:
+						otkgw.MouseCursor = XCursor.Default;
+						break;
+					case Direction.N:
+						otkgw.MouseCursor = XCursor.V;
+						break;
+					case Direction.S:
+						otkgw.MouseCursor = XCursor.V;
+						break;
+					case Direction.E:
+						otkgw.MouseCursor = XCursor.H;
+						break;
+					case Direction.W:
+						otkgw.MouseCursor = XCursor.H;
+						break;
+					case Direction.NW:
+						otkgw.MouseCursor = XCursor.NW;
+						break;
+					case Direction.NE:
+						otkgw.MouseCursor = XCursor.NE;
+						break;
+					case Direction.SW:
+						otkgw.MouseCursor = XCursor.SW;
+						break;
+					case Direction.SE:
+						otkgw.MouseCursor = XCursor.SE;
+						break;
+					}
+				}				
+			}				
+		}
+		public override void onMouseDown (object sender, MouseButtonEventArgs e)
+		{
+			base.onMouseDown (sender, e);
+		}
+		#endregion
+
+		protected void onMaximized (object sender, EventArgs e){
+			lock (CurrentInterface.LayoutMutex) {
+				if (!IsMinimized)
+					savedBounds = this.LastPaintedSlot;
+				this.Left = this.Top = 0;
+				this.RegisterForLayouting (LayoutingType.Positioning);
+				this.Width = this.Height = Measure.Stretched;
+				IsMinimized = false;
+				Resizable = false;
+				NotifyValueChanged ("ShowNormal", true);
+				NotifyValueChanged ("ShowMinimize", true);
+				NotifyValueChanged ("ShowMaximize", false);
+			}
+
+			Maximized.Raise (sender, e);
+
+
+
+		}
+		protected void onUnmaximized (object sender, EventArgs e){
+			lock (CurrentInterface.LayoutMutex) {
+				this.Left = savedBounds.Left;
+				this.Top = savedBounds.Top;
+				this.Width = savedBounds.Width;
+				this.Height = savedBounds.Height;
+				IsMinimized = false;
+				Resizable = true;
+				NotifyValueChanged ("ShowNormal", false);
+				NotifyValueChanged ("ShowMinimize", true);
+				NotifyValueChanged ("ShowMaximize", true);
+			}
+
+			Unmaximized.Raise (sender, e);
+		}
+		protected void onMinimized (object sender, EventArgs e){
+			lock (CurrentInterface.LayoutMutex) {
+				if (IsNormal)
+					savedBounds = this.LastPaintedSlot;
+				Width = 200;
+				Height = 20;
+				Resizable = false;
+				IsMinimized = true;
+				NotifyValueChanged ("ShowNormal", true);
+				NotifyValueChanged ("ShowMinimize", false);
+				NotifyValueChanged ("ShowMaximize", true);
+			}
+
+			Minimize.Raise (sender, e);
+		}
+		protected void onBorderMouseLeave (object sender, MouseMoveEventArgs e)
+		{
+			hoverBorder = false;
+			currentDirection = Direction.None;
+			CurrentInterface.MouseCursor = XCursor.Default;
+		}
+		protected void onBorderMouseEnter (object sender, MouseMoveEventArgs e)
+		{
+			hoverBorder = true;
+		}
+
+
+		protected void butQuitPress (object sender, MouseButtonEventArgs e)
+		{
+			CurrentInterface.MouseCursor = XCursor.Default;
+			close ();
+		}
+
+		protected void close(){
+			Closing.Raise (this, null);
+			CurrentInterface.DeleteWidget (this);
+		}
+	}
+}
+
diff --git a/src/GraphicObjects/Base/Wrapper.cs b/src/GraphicObjects/Base/Wrapper.cs
new file mode 100644
index 00000000..8b282ebb
--- /dev/null
+++ b/src/GraphicObjects/Base/Wrapper.cs
@@ -0,0 +1,233 @@
+//
+// Wrapper.cs
+//
+// Author:
+//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2013-2017 Jean-Philippe Bruyère
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+
+namespace Crow
+{
+	public class Wrapper : GenericStack
+	{
+		public Wrapper () : base()
+		{}
+
+		#region Group Overrides
+		public override void ChildrenLayoutingConstraints (ref LayoutingType layoutType)
+		{
+			layoutType &= (~LayoutingType.Positioning);
+		}
+		public override void ComputeChildrenPositions()
+		{
+			int dx = 0;
+			int dy = 0;
+
+			if (Orientation == Orientation.Vertical) {
+				int tallestChild = 0;
+				foreach (GraphicObject c in Children) {
+					if (!c.Visible)
+						continue;
+					if (dx + c.Slot.Width > ClientRectangle.Width) {
+						dx = 0;
+						dy += tallestChild + Spacing;
+						c.Slot.X = dx;
+						c.Slot.Y = dy;
+						tallestChild = c.Slot.Height;
+					} else {
+						if (tallestChild < c.Slot.Height)
+							tallestChild = c.Slot.Height;
+						c.Slot.X = dx;
+						c.Slot.Y = dy;
+					}
+					dx += c.Slot.Width + Spacing;
+				}
+			} else {
+				int largestChild = 0;
+				foreach (GraphicObject c in Children) {
+					if (!c.Visible)
+						continue;
+					if (dy + c.Slot.Height > ClientRectangle.Height) {
+						dy = 0;
+						dx += largestChild + Spacing;
+						c.Slot.X = dx;
+						c.Slot.Y = dy;
+						largestChild = c.Slot.Width;
+					} else {
+						if (largestChild < c.Slot.Width)
+							largestChild = c.Slot.Width;
+						c.Slot.X = dx;
+						c.Slot.Y = dy;
+					}
+					dy += c.Slot.Height + Spacing;
+				}
+			}
+			IsDirty = true;
+		}
+		public override void OnChildLayoutChanges (object sender, LayoutingEventArgs arg)
+		{
+			//children can't stretch in a wrapper
+			GraphicObject go = sender as GraphicObject;
+			//System.Diagnostics.Debug.WriteLine ("wrapper child layout change: " + go.LastSlots.ToString() + " => " + go.Slot.ToString());
+			switch (arg.LayoutType) {
+			case LayoutingType.Width:
+				if (Orientation == Orientation.Horizontal && go.Width.Units == Unit.Percent){
+					go.Width = Measure.Fit;
+					return;
+				}
+				this.RegisterForLayouting (LayoutingType.Width);
+				break;
+			case LayoutingType.Height:
+				if (Orientation == Orientation.Vertical && go.Height.Units == Unit.Percent) {
+					go.Height = Measure.Fit;
+					return;
+				}
+				this.RegisterForLayouting (LayoutingType.Height);
+				break;
+			default:
+				return;
+			}
+			this.RegisterForLayouting (LayoutingType.ArrangeChildren);
+		}
+		#endregion
+
+		#region GraphicObject Overrides
+		protected override int measureRawSize (LayoutingType lt)
+		{
+			int tmp = 0;
+			//Wrapper can't fit in the opposite direction of the wrapper, this func is called only if Fit
+			if (lt == LayoutingType.Width) {
+				if (Orientation == Orientation.Vertical) {
+					Width = Measure.Stretched;
+					return -1;
+				} else if (RegisteredLayoutings.HasFlag (LayoutingType.Height))
+					return -1;
+				else {
+					int dy = 0;
+					int largestChild = 0;
+					lock (Children) {
+						foreach (GraphicObject c in Children) {
+							if (!c.Visible)
+								continue;
+							if (c.Height.Units == Unit.Percent &&
+								c.RegisteredLayoutings.HasFlag (LayoutingType.Height))
+								return -1;
+							if (dy + c.Slot.Height > ClientRectangle.Height) {
+								dy = 0;
+								tmp += largestChild + Spacing;
+								largestChild = c.Slot.Width;
+							} else if (largestChild < c.Slot.Width)
+								largestChild = c.Slot.Width;
+
+							dy += c.Slot.Height + Spacing;
+						}
+						if (dy == 0)
+							tmp -= Spacing;
+						return tmp + largestChild + 2 * Margin;
+					}
+				}
+			} else if (Orientation == Orientation.Horizontal) {
+				Height = Measure.Stretched;
+				return -1;
+			} else if (RegisteredLayoutings.HasFlag (LayoutingType.Width))
+				return -1;
+			else {
+				int dx = 0;
+				int tallestChild = 0;
+				lock (Children) {
+					foreach (GraphicObject c in Children) {
+						if (!c.Visible)
+							continue;
+						if (c.Width.Units == Unit.Percent &&
+							c.RegisteredLayoutings.HasFlag (LayoutingType.Width))
+							return -1;
+						if (dx + c.Slot.Width > ClientRectangle.Width) {
+							dx = 0;
+							tmp += tallestChild + Spacing;
+							tallestChild = c.Slot.Height;
+						} else if (tallestChild < c.Slot.Height)
+							tallestChild = c.Slot.Height;
+
+						dx += c.Slot.Width + Spacing;
+					}
+					if (dx == 0)
+						tmp -= Spacing;
+					return tmp + tallestChild + 2 * Margin;
+				}
+			}
+		}
+
+		public override bool UpdateLayout (LayoutingType layoutType)
+		{
+			RegisteredLayoutings &= (~layoutType);
+
+			if (layoutType == LayoutingType.ArrangeChildren) {
+				if ((RegisteredLayoutings & LayoutingType.Sizing) != 0)
+					return false;
+
+				ComputeChildrenPositions ();
+
+				//if no layouting remains in queue for item, registre for redraw
+				if (RegisteredLayoutings == LayoutingType.None && IsDirty)
+					CurrentInterface.EnqueueForRepaint (this);
+
+				return true;
+			}
+
+			return base.UpdateLayout(layoutType);
+		}
+		public override void OnLayoutChanges (LayoutingType layoutType)
+		{
+			#if DEBUG_LAYOUTING
+			CurrentInterface.currentLQI.Slot = LastSlots;
+			CurrentInterface.currentLQI.Slot = Slot;
+			#endif
+			switch (layoutType) {
+			case LayoutingType.Width:
+				foreach (GraphicObject c in Children) {
+					if (c.Width.Units == Unit.Percent)
+						c.RegisterForLayouting (LayoutingType.Width);
+				}
+				if (Height == Measure.Fit)
+					RegisterForLayouting (LayoutingType.Height);
+				RegisterForLayouting (LayoutingType.X);
+				break;
+			case LayoutingType.Height:
+				foreach (GraphicObject c in Children) {
+					if (c.Height.Units == Unit.Percent)
+						c.RegisterForLayouting (LayoutingType.Height);
+				}
+				if (Width == Measure.Fit)
+					RegisterForLayouting (LayoutingType.Width);
+				RegisterForLayouting (LayoutingType.Y);
+				break;
+			default:
+				return;
+			}
+			RegisterForLayouting (LayoutingType.ArrangeChildren);
+			raiseLayoutChanged (new LayoutingEventArgs (layoutType));
+		}
+		#endregion
+	}
+}
+