Implemented ILogical.

Perspex.Animation/PropertyTransitions.cs

@@ -4,6 +4,8 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
+using Perspex.Collections;
+
 namespace Perspex.Animation
 {
     public class PropertyTransitions : PerspexList<PropertyTransition>

Perspex.Base/Collections/IPerspexList.cs

@@ -0,0 +1,15 @@
+// -----------------------------------------------------------------------
+// <copyright file="IPerspexList.cs" company="Steven Kirk">
+// Copyright 2014 MIT Licence. See licence.md for more information.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Perspex.Collections
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public interface IPerspexList<T> : IList<T>, IList, IReadOnlyPerspexList<T>
+    {
+    }
+}

Perspex.Base/IReadOnlyPerspexList.cs → Perspex.Base/Collections/IReadOnlyPerspexList.cs

@@ -4,13 +4,13 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
-namespace Perspex
+namespace Perspex.Collections
 {
     using System.Collections.Generic;
     using System.Collections.Specialized;
     using System.ComponentModel;
 
-    public interface IReadOnlyPerspexList<T> : IReadOnlyList<T>, INotifyCollectionChanged, INotifyPropertyChanged
+    public interface IReadOnlyPerspexList<out T> : IReadOnlyList<T>, INotifyCollectionChanged, INotifyPropertyChanged
     {
     }
 }

Perspex.Base/PerspexList.cs → Perspex.Base/Collections/PerspexList.cs

@@ -4,7 +4,7 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
-namespace Perspex
+namespace Perspex.Collections
 {
     using System;
     using System.Collections;
@@ -13,7 +13,17 @@ namespace Perspex
     using System.ComponentModel;
     using System.Linq;
 
-    public class PerspexList<T> : IList<T>, IList, IReadOnlyPerspexList<T>, INotifyCollectionChanged, INotifyPropertyChanged
+    /// <summary>
+    /// A notifying list.
+    /// </summary>
+    /// <typeparam name="T">The type of the list items.</typeparam>
+    /// <remarks>
+    /// PerspexList is similar to <see cref="System.Collections.ObjectModel.ObservableCollection{T}"/>
+    /// except that when the <see cref="Clear"/> method is called, it notifies with a
+    /// <see cref="NotifyCollectionChangedAction.Remove"/> action, passing the items that were 
+    /// removed.
+    /// </remarks>
+    public class PerspexList<T> : IPerspexList<T>, INotifyCollectionChanged, INotifyPropertyChanged
     {
         private List<T> inner;
 

Perspex.Base/PerspexListExtensions.cs → Perspex.Base/Collections/PerspexListExtensions.cs

@@ -4,7 +4,7 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
-namespace Perspex
+namespace Perspex.Collections
 {
     using System;
     using System.Collections.Generic;

Perspex.Base/Collections/SingleItemPerspexList.cs

@@ -0,0 +1,113 @@
+// -----------------------------------------------------------------------
+// <copyright file="PerspexList.cs" company="Steven Kirk">
+// Copyright 2014 MIT Licence. See licence.md for more information.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Perspex.Collections
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using System.Linq;
+
+    /// <summary>
+    /// Implements the <see cref="IReadOnlyPerspexList{T}"/> interface for single items.
+    /// </summary>
+    /// <typeparam name="T">The type of the single item.</typeparam>
+    /// <remarks>
+    /// Classes such as Border can only ever have a single logical child, but they need to 
+    /// implement a list of logical children in their ILogical.LogicalChildren property using the
+    /// <see cref="IReadOnlyPerspexList{T}"/> interface. This class facilitates that 
+    /// without creating an actual <see cref="PerspexList{T}"/>.
+    /// </remarks>
+    public class SingleItemPerspexList<T> : IReadOnlyPerspexList<T> where T : class
+    {
+        private T item;
+
+        public SingleItemPerspexList()
+        {
+        }
+
+        public SingleItemPerspexList(T item)
+        {
+            this.item = item;
+        }
+
+        public T this[int index]
+        {
+            get
+            {
+                if (index < 0 || index >= this.Count)
+                {
+                    throw new ArgumentOutOfRangeException();
+                }
+
+                return item;
+            }
+        }
+
+        public int Count
+        {
+            get { return this.item != null ? 1 : 0; }
+        }
+
+        public T SingleItem
+        {
+            get
+            {
+                return this.item;
+            }
+
+            set
+            {
+                NotifyCollectionChangedEventArgs e = null;
+                bool countChanged = false;
+
+                if (value == null && this.item != null )
+                {
+                    e = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, this.item, 0);
+                    this.item = null;
+                    countChanged = true;
+                }
+                else if (value != null && this.item == null)
+                {
+                    e = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, this.item, 0);
+                    this.item = value;
+                    countChanged = true;
+                }
+                else
+                {
+                    e = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, value, this.item);
+                    this.item = value;
+                }
+
+                if (e != null && this.CollectionChanged != null)
+                {
+                    this.CollectionChanged(this, e);
+                }
+
+                if (countChanged && this.PropertyChanged != null)
+                {
+                    this.PropertyChanged(this, new PropertyChangedEventArgs("Count"));
+                }
+            }
+        }
+
+        public event NotifyCollectionChangedEventHandler CollectionChanged;
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return Enumerable.Repeat(this.item, this.Count).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}

Perspex.Base/Perspex.Base.csproj

@@ -35,13 +35,15 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Binding.cs" />
+    <Compile Include="Collections\IPerspexList.cs" />
+    <Compile Include="Collections\IReadOnlyPerspexList.cs" />
+    <Compile Include="Collections\PerspexList.cs" />
+    <Compile Include="Collections\PerspexListExtensions.cs" />
+    <Compile Include="Collections\SingleItemPerspexList.cs" />
     <Compile Include="Contract.cs" />
     <Compile Include="Diagnostics\PerspexPropertyValue.cs" />
     <Compile Include="IDescription.cs" />
-    <Compile Include="PerspexListExtensions.cs" />
     <Compile Include="IObservableDescription.cs" />
-    <Compile Include="IReadOnlyPerspexList.cs" />
-    <Compile Include="PerspexList.cs" />
     <Compile Include="PerspexObject.cs" />
     <Compile Include="PerspexProperty.cs" />
     <Compile Include="PerspexPropertyChangedEventArgs.cs" />

Perspex.Controls.UnitTests/ContentControlTests.cs

@@ -7,6 +7,7 @@
 namespace Perspex.Controls.UnitTests
 {
     using System;
+    using System.Collections.Specialized;
     using System.Linq;
     using Microsoft.VisualStudio.TestTools.UnitTesting;
     using Moq;
@@ -92,6 +93,104 @@ namespace Perspex.Controls.UnitTests
             Assert.IsNull(child.TemplatedParent);
         }
 
+        [TestMethod]
+        public void Setting_Content_Should_Set_Child_Controls_Parent()
+        {
+            var target = new ContentControl();
+            var child = new Control();
+
+            target.Content = child;
+
+            Assert.AreEqual(child.Parent, target);
+            Assert.AreEqual(((ILogical)child).LogicalParent, target);
+        }
+
+        [TestMethod]
+        public void Clearing_Content_Should_Clear_Child_Controls_Parent()
+        {
+            var target = new ContentControl();
+            var child = new Control();
+
+            target.Content = child;
+            target.Content = null;
+
+            Assert.IsNull(child.Parent);
+            Assert.IsNull(((ILogical)child).LogicalParent);
+        }
+
+        [TestMethod]
+        public void Setting_Content_To_Control_Should_Make_Control_Appear_In_LogicalChildren()
+        {
+            var target = new ContentControl();
+            var child = new Control();
+
+            target.Content = child;
+
+            CollectionAssert.AreEqual(new[] { child }, ((ILogical)target).LogicalChildren.ToList());
+        }
+
+        [TestMethod]
+        public void Clearing_Content_Should_Remove_From_LogicalChildren()
+        {
+            var contentControl = new ContentControl();
+            var child = new Control();
+
+            contentControl.Content = child;
+            contentControl.Content = null;
+
+            CollectionAssert.AreEqual(new ILogical[0], ((ILogical)contentControl).LogicalChildren.ToList());
+        }
+
+        [TestMethod]
+        public void Setting_Content_Should_Fire_LogicalChildren_CollectionChanged()
+        {
+            var contentControl = new ContentControl();
+            var child = new Control();
+            var called = false;
+
+            ((ILogical)contentControl).LogicalChildren.CollectionChanged += (s, e) =>
+                called = e.Action == NotifyCollectionChangedAction.Add;
+
+            contentControl.Content = child;
+
+            Assert.IsTrue(called);
+        }
+
+        [TestMethod]
+        public void Clearing_Content_Should_Fire_LogicalChildren_CollectionChanged()
+        {
+            var contentControl = new ContentControl();
+            var child = new Control();
+            var called = false;
+
+            contentControl.Content = child;
+
+            ((ILogical)contentControl).LogicalChildren.CollectionChanged += (s, e) =>
+                called = e.Action == NotifyCollectionChangedAction.Remove;
+
+            contentControl.Content = null;
+
+            Assert.IsTrue(called);
+        }
+
+        [TestMethod]
+        public void Changing_Content_Should_Fire_LogicalChildren_CollectionChanged()
+        {
+            var contentControl = new ContentControl();
+            var child1 = new Control();
+            var child2 = new Control();
+            var called = false;
+
+            contentControl.Content = child1;
+
+            ((ILogical)contentControl).LogicalChildren.CollectionChanged += (s, e) =>
+                called = e.Action == NotifyCollectionChangedAction.Replace;
+
+            contentControl.Content = child2;
+
+            Assert.IsTrue(called);
+        }
+
         private void ApplyTemplate(ILayoutable control)
         {
             control.Measure(new Size(100, 100));

Perspex.Controls.UnitTests/DecoratorTests.cs

@@ -0,0 +1,114 @@
+// -----------------------------------------------------------------------
+// <copyright file="DecoratorTests.cs" company="Steven Kirk">
+// Copyright 2013 MIT Licence. See licence.md for more information.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Perspex.Controls.UnitTests
+{
+    using System.Collections.Specialized;
+    using System.Linq;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    [TestClass]
+    public class DecoratorTests
+    {
+        [TestMethod]
+        public void Setting_Content_Should_Set_Child_Controls_Parent()
+        {
+            var decorator = new Decorator();
+            var child = new Control();
+
+            decorator.Content = child;
+
+            Assert.AreEqual(child.Parent, decorator);
+            Assert.AreEqual(((ILogical)child).LogicalParent, decorator);
+        }
+
+        [TestMethod]
+        public void Clearing_Content_Should_Clear_Child_Controls_Parent()
+        {
+            var decorator = new Decorator();
+            var child = new Control();
+
+            decorator.Content = child;
+            decorator.Content = null;
+
+            Assert.IsNull(child.Parent);
+            Assert.IsNull(((ILogical)child).LogicalParent);
+        }
+
+        [TestMethod]
+        public void Content_Control_Should_Appear_In_LogicalChildren()
+        {
+            var decorator = new Decorator();
+            var child = new Control();
+
+            decorator.Content = child;
+
+            CollectionAssert.AreEqual(new[] { child }, ((ILogical)decorator).LogicalChildren.ToList());
+        }
+
+        [TestMethod]
+        public void Clearing_Content_Should_Remove_From_LogicalChildren()
+        {
+            var decorator = new Decorator();
+            var child = new Control();
+
+            decorator.Content = child;
+            decorator.Content = null;
+
+            CollectionAssert.AreEqual(new ILogical[0], ((ILogical)decorator).LogicalChildren.ToList());
+        }
+
+        [TestMethod]
+        public void Setting_Content_Should_Fire_LogicalChildren_CollectionChanged()
+        {
+            var decorator = new Decorator();
+            var child = new Control();
+            var called = false;
+
+            ((ILogical)decorator).LogicalChildren.CollectionChanged += (s, e) => 
+                called = e.Action == NotifyCollectionChangedAction.Add;
+
+            decorator.Content = child;
+
+            Assert.IsTrue(called);
+        }
+
+        [TestMethod]
+        public void Clearing_Content_Should_Fire_LogicalChildren_CollectionChanged()
+        {
+            var decorator = new Decorator();
+            var child = new Control();
+            var called = false;
+
+            decorator.Content = child;
+
+            ((ILogical)decorator).LogicalChildren.CollectionChanged += (s, e) =>
+                called = e.Action == NotifyCollectionChangedAction.Remove;
+
+            decorator.Content = null;
+
+            Assert.IsTrue(called);
+        }
+
+        [TestMethod]
+        public void Changing_Content_Should_Fire_LogicalChildren_CollectionChanged()
+        {
+            var decorator = new Decorator();
+            var child1 = new Control();
+            var child2 = new Control();
+            var called = false;
+
+            decorator.Content = child1;
+
+            ((ILogical)decorator).LogicalChildren.CollectionChanged += (s, e) =>
+                called = e.Action == NotifyCollectionChangedAction.Replace;
+
+            decorator.Content = child2;
+
+            Assert.IsTrue(called);
+        }
+    }
+}

Perspex.Controls.UnitTests/PanelTests.cs

@@ -0,0 +1,82 @@
+// -----------------------------------------------------------------------
+// <copyright file="PanelTests.cs" company="Steven Kirk">
+// Copyright 2013 MIT Licence. See licence.md for more information.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Perspex.Controls.UnitTests
+{
+    using System.Linq;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    [TestClass]
+    public class PanelTests
+    {
+        [TestMethod]
+        public void Adding_Control_To_Panel_Should_Set_Child_Controls_Parent()
+        {
+            var panel = new Panel();
+            var child = new Control();
+
+            panel.Children.Add(child);
+
+            Assert.AreEqual(child.Parent, panel);
+            Assert.AreEqual(((ILogical)child).LogicalParent, panel);
+        }
+
+        [TestMethod]
+        public void Removing_Control_From_Panel_Should_Clear_Child_Controls_Parent()
+        {
+            var panel = new Panel();
+            var child = new Control();
+
+            panel.Children.Add(child);
+            panel.Children.Remove(child);
+
+            Assert.IsNull(child.Parent);
+            Assert.IsNull(((ILogical)child).LogicalParent);
+        }
+
+        [TestMethod]
+        public void Clearing_Panel_Children_Should_Clear_Child_Controls_Parent()
+        {
+            var panel = new Panel();
+            var child1 = new Control();
+            var child2 = new Control();
+
+            panel.Children.Add(child1);
+            panel.Children.Add(child2);
+            panel.Children.Clear();
+
+            Assert.IsNull(child1.Parent);
+            Assert.IsNull(((ILogical)child1).LogicalParent);
+            Assert.IsNull(child2.Parent);
+            Assert.IsNull(((ILogical)child2).LogicalParent);
+        }
+
+        [TestMethod]
+        public void Child_Control_Should_Appear_In_Panel_Children()
+        {
+            var panel = new Panel();
+            var child = new Control();
+
+            panel.Children.Add(child);
+
+            CollectionAssert.AreEqual(new[] { child }, panel.Children);
+            CollectionAssert.AreEqual(new[] { child }, ((ILogical)panel).LogicalChildren.ToList());
+        }
+
+        [TestMethod]
+        public void Removing_Child_Control_Should_Remove_From_Panel_Children()
+        {
+            var panel = new Panel();
+            var child = new Control();
+
+            panel.Children.Add(child);
+            panel.Children.Remove(child);
+
+            CollectionAssert.AreEqual(new Control[0], panel.Children);
+            CollectionAssert.AreEqual(new ILogical[0], ((ILogical)panel).LogicalChildren.ToList());
+        }
+    }
+}

Perspex.Controls.UnitTests/Perspex.Controls.UnitTests.csproj

@@ -65,6 +65,8 @@
   </Choose>
   <ItemGroup>
     <Compile Include="ContentControlTests.cs" />
+    <Compile Include="DecoratorTests.cs" />
+    <Compile Include="PanelTests.cs" />
     <Compile Include="ControlTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TemplatedControlTests.cs" />

Perspex.Controls/ColumnDefinitions.cs

@@ -4,6 +4,8 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
+using Perspex.Collections;
+
 namespace Perspex.Controls
 {
     public class ColumnDefinitions : PerspexList<ColumnDefinition>

Perspex.Controls/ContentControl.cs

@@ -6,10 +6,12 @@
 
 namespace Perspex.Controls
 {
+    using System;
+    using Perspex.Collections;
     using Perspex.Controls.Primitives;
     using Perspex.Layout;
 
-    public class ContentControl : TemplatedControl
+    public class ContentControl : TemplatedControl, ILogical
     {
         public static readonly PerspexProperty<object> ContentProperty =
             PerspexProperty.Register<ContentControl, object>("Content");
@@ -20,12 +22,40 @@ namespace Perspex.Controls
         public static readonly PerspexProperty<VerticalAlignment> VerticalContentAlignmentProperty =
             PerspexProperty.Register<ContentControl, VerticalAlignment>("VerticalContentAlignment");
 
+        private SingleItemPerspexList<ILogical> logicalChild = new SingleItemPerspexList<ILogical>();
+
+        public ContentControl()
+        {
+            this.GetObservableWithHistory(ContentProperty).Subscribe(x =>
+            {
+                var control1 = x.Item1 as Control;
+                var control2 = x.Item2 as Control;
+
+                if (control1 != null)
+                {
+                    control1.Parent = null;
+                }
+
+                if (control2 != null)
+                {
+                    control2.Parent = this;
+                }
+
+                this.logicalChild.SingleItem = control2;
+            });
+        }
+
         public object Content
         {
             get { return this.GetValue(ContentProperty); }
             set { this.SetValue(ContentProperty, value); }
         }
 
+        IReadOnlyPerspexList<ILogical> ILogical.LogicalChildren
+        {
+            get { return this.logicalChild; }
+        }
+
         public HorizontalAlignment HorizontalContentAlignment
         {
             get { return this.GetValue(HorizontalContentAlignmentProperty); }

Perspex.Controls/Control.cs

@@ -7,8 +7,10 @@
 namespace Perspex.Controls
 {
     using System;
+    using System.Collections.Generic;
+    using System.Linq;
     using System.Reactive.Linq;
-    using Perspex.Animation;
+    using Perspex.Collections;
     using Perspex.Input;
     using Perspex.Interactivity;
     using Perspex.Media;
@@ -16,7 +18,7 @@ namespace Perspex.Controls
     using Perspex.Styling;
     using Splat;
 
-    public class Control : InputElement, IStyleable, IStyleHost
+    public class Control : InputElement, ILogical, IStyleable, IStyleHost
     {
         public static readonly PerspexProperty<Brush> BorderBrushProperty =
             PerspexProperty.Register<Control, Brush>("BorderBrush");
@@ -27,6 +29,9 @@ namespace Perspex.Controls
         public static readonly PerspexProperty<Brush> ForegroundProperty =
             PerspexProperty.Register<Control, Brush>("Foreground", new SolidColorBrush(0xff000000), inherits: true);
 
+        public static readonly PerspexProperty<Control> ParentProperty =
+            PerspexProperty.Register<Control, Control>("Parent");
+
         public static readonly PerspexProperty<ITemplatedControl> TemplatedParentProperty =
             PerspexProperty.Register<Control, ITemplatedControl>("TemplatedParent", inherits: true);
 
@@ -143,12 +148,28 @@ namespace Perspex.Controls
             }
         }
 
+        public Control Parent
+        {
+            get { return this.GetValue(ParentProperty); }
+            internal set { this.SetValue(ParentProperty, value); }
+        }
+
         public ITemplatedControl TemplatedParent
         {
             get { return this.GetValue(TemplatedParentProperty); }
             internal set { this.SetValue(TemplatedParentProperty, value); }
         }
 
+        ILogical ILogical.LogicalParent
+        {
+            get { return this.Parent; }
+        }
+
+        IReadOnlyPerspexList<ILogical> ILogical.LogicalChildren
+        {
+            get { throw new NotImplementedException(); }
+        }
+
         public void BringIntoView()
         {
             this.BringIntoView(new Rect(this.ActualSize));

Perspex.Controls/Controls.cs

@@ -7,6 +7,7 @@
 namespace Perspex.Controls
 {
     using System.Collections.Generic;
+    using Perspex.Collections;
 
     public class Controls : PerspexList<Control>
     {

Perspex.Controls/DataTemplates.cs

@@ -13,6 +13,7 @@ namespace Perspex.Controls
     using System.Linq;
     using System.Reactive;
     using System.Reactive.Subjects;
+    using Perspex.Collections;
 
     public class DataTemplates : PerspexList<DataTemplate>
     {

Perspex.Controls/Decorator.cs

@@ -10,9 +10,10 @@ namespace Perspex.Controls
     using System.Collections.Generic;
     using System.Linq;
     using System.Reactive.Linq;
+    using Perspex.Collections;
     using Perspex.Layout;
 
-    public class Decorator : Control, IVisual
+    public class Decorator : Control, IVisual, ILogical
     {
         public static readonly PerspexProperty<Control> ContentProperty =
             PerspexProperty.Register<Decorator, Control>("Content");
@@ -20,16 +21,25 @@ namespace Perspex.Controls
         public static readonly PerspexProperty<Thickness> PaddingProperty =
             PerspexProperty.Register<Decorator, Thickness>("Padding");
 
+        private SingleItemPerspexList<ILogical> logicalChild = new SingleItemPerspexList<ILogical>();
+
         public Decorator()
         {
-            this.GetObservable(ContentProperty).Subscribe(x =>
+            this.GetObservableWithHistory(ContentProperty).Subscribe(x =>
             {
-                this.ClearVisualChildren();
+                if (x.Item1 != null)
+                {
+                    this.RemoveVisualChild(x.Item1);
+                    x.Item1.Parent = null;
+                }
 
-                if (x != null)
+                if (x.Item2 != null)
                 {
-                    this.AddVisualChild(x);
+                    this.AddVisualChild(x.Item2);
+                    x.Item2.Parent = this;
                 }
+
+                this.logicalChild.SingleItem = x.Item2;
             });
         }
 
@@ -45,6 +55,11 @@ namespace Perspex.Controls
             set { this.SetValue(PaddingProperty, value); }
         }
 
+        IReadOnlyPerspexList<ILogical> ILogical.LogicalChildren
+        {
+            get { return this.logicalChild; }
+        }
+
         protected override Size ArrangeOverride(Size finalSize)
         {
             Control content = this.Content;

Perspex.Controls/Grid.cs

@@ -9,6 +9,7 @@ namespace Perspex.Controls
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using Perspex.Collections;
 
     public class Grid : Panel
     {

Perspex.Controls/ILogical.cs

@@ -0,0 +1,27 @@
+// -----------------------------------------------------------------------
+// <copyright file="ILogical.cs" company="Steven Kirk">
+// Copyright 2014 MIT Licence. See licence.md for more information.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Perspex.Controls
+{
+    using System.Collections.Generic;
+    using Perspex.Collections;
+
+    /// <summary>
+    /// Represents a node in the logical tree.
+    /// </summary>
+    public interface ILogical
+    {
+        /// <summary>
+        /// Gets the logical parent.
+        /// </summary>
+        ILogical LogicalParent { get; }
+
+        /// <summary>
+        /// Gets the logical children.
+        /// </summary>
+        IReadOnlyPerspexList<ILogical> LogicalChildren { get;  }
+    }
+}

Perspex.Controls/Panel.cs

@@ -9,11 +9,12 @@ namespace Perspex.Controls
     using System;
     using System.Collections.Specialized;
     using System.Linq;
+    using Perspex.Collections;
 
     /// <summary>
     /// Base class for controls that can contain multiple children.
     /// </summary>
-    public class Panel : Control
+    public class Panel : Control, ILogical
     {
         private Controls children;
 
@@ -54,6 +55,11 @@ namespace Perspex.Controls
             }
         }
 
+        IReadOnlyPerspexList<ILogical> ILogical.LogicalChildren
+        {
+            get { return this.children; }
+        }
+
         private void ChildrenChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
             // TODO: Handle Move and Replace.
@@ -61,10 +67,22 @@ namespace Perspex.Controls
             {
                 case NotifyCollectionChangedAction.Add:
                     this.AddVisualChildren(e.NewItems.OfType<Visual>());
+
+                    foreach (var child in e.NewItems.OfType<Control>())
+                    {
+                        child.Parent = this;
+                    }
+
                     break;
 
                 case NotifyCollectionChangedAction.Remove:
                     this.RemoveVisualChildren(e.OldItems.OfType<Visual>());
+
+                    foreach (var child in e.OldItems.OfType<Control>())
+                    {
+                        child.Parent = null;
+                    }
+
                     break;
 
                 case NotifyCollectionChangedAction.Reset:

Perspex.Controls/Perspex.Controls.csproj

@@ -36,6 +36,7 @@
   <ItemGroup>
     <Compile Include="Border.cs" />
     <Compile Include="Button.cs" />
+    <Compile Include="ILogical.cs" />
     <Compile Include="RadioButton.cs" />
     <Compile Include="CheckBox.cs" />
     <Compile Include="ColumnDefinition.cs" />

Perspex.Controls/RowDefinitions.cs

@@ -6,6 +6,8 @@
 
 namespace Perspex.Controls
 {
+    using Perspex.Collections;
+
     public class RowDefinitions : PerspexList<RowDefinition>
     {
     }

Perspex.SceneGraph/IVisual.cs

@@ -7,6 +7,7 @@
 namespace Perspex
 {
     using System.Collections.Generic;
+    using Perspex.Collections;
     using Perspex.Media;
 
     /// <summary>

Perspex.SceneGraph/Visual.cs

@@ -12,6 +12,7 @@ namespace Perspex
     using System.Linq;
     using System.Reactive.Linq;
     using Perspex.Animation;
+    using Perspex.Collections;
     using Perspex.Media;
     using Perspex.Rendering;
     using Splat;

Perspex.Styling/Styles.cs

@@ -6,6 +6,8 @@
 
 namespace Perspex.Styling
 {
+    using Perspex.Collections;
+
     public class Styles : PerspexList<IStyle>, IStyle
     {
         public void Attach(IStyleable control)

TestApplication/Program.cs

@@ -2,6 +2,7 @@
 using System.Reactive.Linq;
 using Perspex;
 using Perspex.Animation;
+using Perspex.Collections;
 using Perspex.Controls;
 using Perspex.Controls.Primitives;
 using Perspex.Controls.Shapes;