public void SetChildBounds(IWidgetBackend widget, Rectangle bounds)
        {
            FrameworkElement element = widget.NativeWidget as FrameworkElement;
            if (element == null)
                throw new ArgumentException ();

            SWC.Canvas.SetTop (element, bounds.Top);
            SWC.Canvas.SetLeft (element, bounds.Left);

            // We substract the widget margin here because the size we are assigning is the actual size, not including the WPF marings
            var h = bounds.Height - ((WidgetBackend)widget).Frontend.Margin.VerticalSpacing;
            var w = bounds.Width - ((WidgetBackend)widget).Frontend.Margin.HorizontalSpacing;

            h = (h > 0) ? h : 0;
            w = (w > 0) ? w : 0;

            // Measure the widget again using the allocation constraints. This is necessary
            // because WPF widgets my cache some measurement information based on the
            // constraints provided in the last Measure call (which when calculating the
            // preferred size is normally set to infinite.
            element.InvalidateMeasure ();
            element.Measure (new System.Windows.Size (w, h));
            element.Height = h;
            element.Width = w;
            element.UpdateLayout ();
        }

		public void SetContent(IWidgetBackend widget)
		{
			if (widget == null)
				RadioButton.Content = null;
			else
				RadioButton.Content = widget.NativeWidget;
		}

        public void SetChildBounds(IWidgetBackend widget, Rectangle bounds)
        {
            FrameworkElement element = widget.NativeWidget as FrameworkElement;
            if (element == null)
                throw new ArgumentException ();

            SWC.Canvas.SetTop (element, bounds.Top);
            SWC.Canvas.SetLeft (element, bounds.Left);

            var h = bounds.Height;
            var w = bounds.Width;

            h = (h > 0) ? h : 0;
            w = (w > 0) ? w : 0;

            // Measure the widget again using the allocation constraints. This is necessary
            // because WPF widgets my cache some measurement information based on the
            // constraints provided in the last Measure call (which when calculating the
            // preferred size is normally set to infinite.
            element.InvalidateMeasure ();
            element.Measure (new System.Windows.Size (w, h));
            element.Height = h;
            element.Width = w;
            element.UpdateLayout ();
        }

 public void SetAllocation(IWidgetBackend [] widget, Rectangle [] rect)
 {
     for (int i = 0; i < widget.Length; i++) {
         var e = GetFrameworkElement (widget [i]);
         e.Arrange (DataConverter.ToWpfRect (rect [i]));
     }
 }

		public void SetContent (IWidgetBackend widget)
		{
			if (widget == null)
				CheckBox.Content = null;
			else
				CheckBox.Content = widget.NativeWidget;
		}

 public void SetChild(IWidgetBackend child)
 {
     var w = (IGtkWidgetBackend) child;
     if (alignment.Child != null)
         alignment.Remove (alignment.Child);
     alignment.Child = w.Widget;
 }

		public void SetContent(IWidgetBackend child)
		{
			if (child == null)
				Widget.Content = null;
			else
				Widget.Content = child.NativeWidget;
		}

        public void RemoveChild(IWidgetBackend widget)
        {
            UIElement element = widget.NativeWidget as UIElement;
            if (element == null)
                throw new ArgumentException ();

            Canvas.Children.Remove (element);
        }

		public void SetChild (IWidgetBackend child)
		{
			if (alignment.Child != null) {
				WidgetBackend.RemoveChildPlacement (alignment.Child);
				alignment.Remove (alignment.Child);
			}
			alignment.Child = WidgetBackend.GetWidgetWithPlacement (child);
		}

        public void SetChild(IWidgetBackend child)
        {
            if (widget != null)
                rootPanel.Children.Remove(widget);
            widget = ((IWpfWidgetBackend)child).Widget;

            DockPanel.SetDock (widget, Dock.Bottom);
            rootPanel.Children.Add(widget);
        }

 public void SetContent(IWidgetBackend widget)
 {
     var newWidget = GetWidget (widget);
     var oldWidget = Widget.Child;
     if (oldWidget == null)
         Widget.Child = newWidget;
     else
         GtkEngine.ReplaceChild (oldWidget, newWidget);
 }

 public void Init(IWindowFrameBackend parent, IWidgetBackend child, Xwt.Popover.Position orientation)
 {
     popover = new PopoverWindow ((Gtk.Widget)child.NativeWidget, orientation);
     popover.TransientFor = ((WindowFrameBackend)parent).Window;
     popover.DestroyWithParent = true;
     popover.Hidden += (o, args) => {
         if (Closed != null)
             Closed (this, EventArgs.Empty);
     };
 }

		public void SetPanel (int panel, IWidgetBackend widget, bool resize, bool shrink)
		{
			if (panel == 1) {
				RemoveChildPlacement (Widget.Child1);
				Widget.Pack1 (GetWidgetWithPlacement (widget), resize, shrink);
			} else {
				RemoveChildPlacement (Widget.Child2);
				Widget.Pack2 (GetWidgetWithPlacement (widget), resize, shrink);
			}
		}

 public void SetAllocation(IWidgetBackend[] widgets, Rectangle[] rects)
 {
     bool changed = false;
     for (int n=0; n<widgets.Length; n++) {
         var w = GetWidget (widgets[n]);
         if (Widget.SetAllocation (w, rects[n]))
             changed = true;
     }
     if (changed && !Widget.IsReallocating)
         Widget.QueueResize ();
 }

		public void SetContent (IWidgetBackend widget)
		{
			if (widget != null) {
				child = (Widget)((WidgetBackend)widget).Frontend;
				UserControl.Content = widget.NativeWidget;
			}
			else {
				child = null;
				UserControl.Content = null;
			}
		}

 public void Run(IWidgetBackend referenceWidget)
 {
     var reference = ((WidgetBackend)referenceWidget).Frontend;
     var position = new Point (reference.ScreenBounds.Center.X, popover.ArrowPosition == Popover.Position.Top ? reference.ScreenBounds.Bottom : reference.ScreenBounds.Top);
     popover.ShowAll ();
     popover.GrabFocus ();
     int w, h;
     popover.GetSize (out w, out h);
     popover.Move ((int)position.X - w / 2, (int)position.Y);
     popover.SizeAllocated += (o, args) => { popover.Move ((int)position.X - args.Allocation.Width / 2, (int)position.Y); popover.GrabFocus (); };
 }

		public void AddChild (IWidgetBackend widget, Rectangle bounds)
		{
			UIElement element = widget.NativeWidget as UIElement;
			if (element == null)
				throw new ArgumentException ();

			if (!Canvas.Children.Contains (element))
				Canvas.Children.Add (element);

			SetChildBounds (widget, bounds);
		}

		public void SetChildBounds (IWidgetBackend widget, Rectangle bounds)
		{
			int i = children.IndexOf (widget);
			if (i == -1) {
				children.Add (widget);
				childrenBounds.Add (bounds);
			}
			else {
				childrenBounds[i] = bounds;
			}
			Canvas.SetAllocation (children.ToArray (), childrenBounds.ToArray ());
		}

		public void SetHeaderContent (IWidgetBackend backend)
		{
			if (toolbar.Child != null) {
				WidgetBackend.RemoveChildPlacement (toolbar.Child);
				toolbar.Remove (toolbar.Child);
			}
			if (backend != null) {
				toolbar.Child = WidgetBackend.GetWidgetWithPlacement (backend);
				toolbar.Show ();
			} else {
				toolbar.Hide ();
			}
		}

        public void RemoveChild(IWidgetBackend widget)
        {
            UIElement element = widget.NativeWidget as UIElement;
            if (element == null)
                throw new ArgumentException ();

            Canvas.Children.Remove (element);
            int i = children.IndexOf (widget);
            if (i != -1) {
                children.RemoveAt (i);
                childrenBounds.RemoveAt (i);
            }
        }