public void UnregisterObject(ModelItem modelItem)
 {
     if (items.Exists((i) => i == modelItem))
     {
         modelItem.Dispose();
     }
 }

        // These methods are not used, but they are very useful when developing the Design experience
#if Development

        /// <summary>
        ///     Adds a default column for each property in the data source
        /// </summary>
        public static void GenerateColumns(ModelItem dataGridModelItem, EditingContext context)
        {
            using (ModelEditingScope scope = dataGridModelItem.BeginEdit(Properties.Resources.Generate_Columns))
            {

                // Set databinding related properties
                DataGridDesignHelper.SparseSetValue(dataGridModelItem.Properties[MyPlatformTypes.DataGrid.AutoGenerateColumnsProperty], false);

                // Get the datasource 
                object dataSource = dataGridModelItem.Properties[MyPlatformTypes.DataGrid.ItemsSourceProperty].ComputedValue;
                if (dataSource != null)
                {

                    foreach (ColumnInfo columnGenerationInfo in DataGridDesignHelper.GetColumnGenerationInfos(dataSource))
                    {

                        ModelItem dataGridColumn = null;

                        dataGridColumn = DataGridDesignHelper.CreateDefaultDataGridColumn(context, columnGenerationInfo);

                        if (dataGridColumn != null)
                        {
                            dataGridModelItem.Properties[MyPlatformTypes.DataGrid.ColumnsProperty].Collection.Add(dataGridColumn);
                        }
                    }
                }
                scope.Complete();
            }
        }

        /// <summary>
        /// Redirect the parent action.
        /// </summary>
        /// <param name="parent">The item being dragged in.</param>
        /// <param name="childType">The type of the item being dragged.</param>
        /// <returns>The new parent for the child.</returns>
        public override ModelItem RedirectParent(ModelItem parent, Type childType)
        {
            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            if (childType == null)
            {
                throw new ArgumentNullException("childType");
            }

            if (parent.Content != null && parent.Content.IsSet)
            {
                // if Expander has a content and if the content is a panel or a contentcontrol, let the content act as the parent
                ModelItem content = parent.Content.Value;
                if (content != null &&
                    (content.IsItemOfType(PlatformTypes.Panel.TypeId) ||
                     content.IsItemOfType(PlatformTypes.ContentControl.TypeId)))
                {
                    return content;
                }
                else
                {
                    _canParent = false;
                    return parent; // Expander has a content already but its neither Panel nor ContentControl.
                }
            }

            // Expander doesnt have any content and now Expander itself acts as the parent
            return base.RedirectParent(parent, childType);
        }

 /// <summary>
 /// Initializes the default values for the ModelItem.
 /// </summary>
 /// <param name="modelItem">The ModelItem.</param>
 public override void InitializeDefaults(ModelItem modelItem)
 {
     if (modelItem == null)
     {
         throw new ArgumentNullException("modelItem");
     }
 }

 /// <summary>
 /// Only one TabItem should have DesignTimeIsSelectedProperty set to true at a time.
 /// DesignTimeSelectedIndexProperty of TabControl should match with that of active tab.
 /// </summary>
 /// <param name="item">The ModelItem representing a TabItem.</param>
 private static void UpdateIsSelectedForOtherTabs(ModelItem item)
 {
     // item.Parent is Tabcontrol
     if (item.Parent != null && item.Parent.IsItemOfType(MyPlatformTypes.TabControl.TypeId))
     {
         if (item.Parent.Content != null)
         {
             ModelItemCollection tabItemCollection = item.Parent.Content.Collection;
             if (tabItemCollection != null && tabItemCollection.Count > 0)
             {
                 foreach (ModelItem tabItem in tabItemCollection)
                 {
                     if (tabItem != item)
                     { 
                         // set designer property for other tabItem in TabControl to false.
                         tabItem.SetDesignerProperty(DesignTimeIsSelectedProperty, false);
                     }
                     else
                     {
                         // This tabItem has been activated, update selectedIndex for Tabcontrol
                         tabItem.Parent.SetDesignerProperty(
                             TabControlDesignModeValueProvider.DesignTimeSelectedIndexProperty, 
                             tabItemCollection.IndexOf(tabItem));
                     }
                 }
             }
         }
     }
 }

 /// <summary>
 ///     Removes all columns from the DataGrid
 /// </summary>
 public static void RemoveColumns(ModelItem dataGridModelItem, EditingContext editingContext)
 {
     using (ModelEditingScope scope = dataGridModelItem.BeginEdit(Properties.Resources.Remove_Columns))
     {
         dataGridModelItem.Properties[MyPlatformTypes.DataGrid.ColumnsProperty].Collection.Clear();
         scope.Complete();
     }
 }

 // Set any property defaults here
 public override void InitializeDefaults(ModelItem item) 
 {
     if (item != null) 
     {
         DataGridHelper.SparseSetValue(item.Properties["Width"], 180.0);
         DataGridHelper.SparseSetValue(item.Properties["Height"], 170.0);
     }
 }

 /// <summary>
 /// Sets the default property values for AccordionItem.
 /// </summary>
 /// <param name="item">The AccordionItem ModelItem.</param>
 public override void InitializeDefaults(ModelItem item)
 {
     // <AccordionItem Content="AccordionItem" Header="AccordionItem" />
     string headerName = Extensions.GetMemberName<Silverlight::System.Windows.Controls.AccordionItem>(x => x.Header);
     string contentName = Extensions.GetMemberName<Silverlight::System.Windows.Controls.AccordionItem>(x => x.Content);
     item.Properties[headerName].SetValue(Properties.Resources.AccordionItem_Header);
     item.Properties[contentName].SetValue(Properties.Resources.AccordionItem_Content);
 }

        protected override void Activate(ModelItem item)
        {
            // Create and add a new adorner panel
            wheelSegmentsPanel = new WheelSegmentAdornerPanel(item);
            Adorners.Add(wheelSegmentsPanel);

            base.Activate(item);
        }

        /// <summary>
        /// Sets the default property values for Rating. 
        /// </summary>
        /// <param name="item">SSWCDC.Rating ModelItem.</param>
        public override void InitializeDefaults(ModelItem item)
        {
            string propertyName;

            // <inputToolkit:Rating ItemCount="5">
            propertyName = Extensions.GetMemberName<SSWC.Rating>(x => x.ItemCount);
            item.Properties[propertyName].SetValue(5);
        }

 internal static IEnumerable<ModelFile> GetModels(ModelItem m)
 {
     foreach (var a in m.files)
         yield return a;
     foreach (ModelItem a in m.dirs)
         foreach (var b in GetModels(a))
             yield return b;
 }

        public WheelPanelDesignTimeCanvas(ModelItem item)
        {
            _item = item;

            this.Loaded += WheelSegmentAdornerPanel_Loaded;
            this.SizeChanged += WheelPanelDesignTimeCanvas_SizeChanged;

            item.PropertyChanged += Item_PropertyChanged;
        }

        protected override void Activate(ModelItem item, DependencyObject view)
        {
            calendarModelItem = item;

            CreateAdornerPanel();
            PlaceAdornerPanel();
            SubscribeDesignerEvents();

            base.Activate(item, view);
        }

 public ModelOperationAdorner(ModelItem adorned)
     : base(adorned)
 {
     collection = new VisualCollection(this);
     collection.Add(tl = GetResizeThumb("LT"));
     collection.Add(tr = GetResizeThumb("RT"));
     collection.Add(bl = GetResizeThumb("LB"));
     collection.Add(br = GetResizeThumb("RB"));
     collection.Add(handler = GetMoveThumb());
 }

        // Set any property defaults here
        public override void InitializeDefaults(ModelItem item)
        {
            if (item != null)
            {
                DataGridDesignHelper.SparseSetValue(item.Properties[PlatformTypes.DataGrid.WidthProperty], 200.0);
                DataGridDesignHelper.SparseSetValue(item.Properties[PlatformTypes.DataGrid.HeightProperty], 200.0);

                DataGridDesignHelper.SparseSetValue(item.Properties[PlatformTypes.DataGrid.AutoGenerateColumnsProperty], false);
            }
        }

        /// <summary>
        ///     Creates a DataGridTemplateColumn ModelItem with default templates for this property
        /// </summary>
        internal static ModelItem CreateTemplateColumn(EditingContext context, ColumnInfo columnGenerationInfo, ModelItem dataGridColumn)
        {
            ModelItem displayDataTemplate = CreateDataTemplate(context, PlatformTypes.TextBlock.TypeId, PlatformTypes.TextBlock.TextProperty, columnGenerationInfo.PropertyInfo.Name);
            dataGridColumn.Properties[PlatformTypes.DataGridTemplateColumn.CellTemplateProperty].SetValue(displayDataTemplate);

            ModelItem editingDataTemplate = CreateDataTemplate(context, PlatformTypes.TextBox.TypeId, PlatformTypes.TextBox.TextProperty, columnGenerationInfo.PropertyInfo.Name);
            dataGridColumn.Properties[PlatformTypes.DataGridTemplateColumn.CellEditingTemplateProperty].SetValue(editingDataTemplate);

            return dataGridColumn;
        }

 // Set any property defaults here
 public override void InitializeDefaults(ModelItem item) 
 {
     if (item != null) 
     {
         // This will really cause a margin to be added.
         Size defaultsize = new Size(200, 200);
         DataGridHelper.SparseSetValue(item.Properties[FrameworkElement.WidthProperty], defaultsize.Width);
         DataGridHelper.SparseSetValue(item.Properties[FrameworkElement.HeightProperty], defaultsize.Height);
     }
 }

        /// <summary>
        /// Initializes default for the specified ModelItem.
        /// </summary>
        /// <param name="item">Specified ModelItem.</param>
        public override void InitializeDefaults(ModelItem item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            // Set properties
            item.Properties["Header"].SetValue(typeof(MenuItem).Name);
        }

        /// <summary>
        /// Sets the default property values for GridSplitter. 
        /// </summary>
        /// <param name="item">SSWC.GridSplitter ModelItem.</param>
        public override void InitializeDefaults(ModelItem item)
        {
            string propertyName;

            propertyName = Extensions.GetMemberName<SSWC.GridSplitter>(x => x.Width);
            item.Properties[propertyName].SetValue("10.0");

            propertyName = Extensions.GetMemberName<SSWC.GridSplitter>(x => x.Height);
            item.Properties[propertyName].SetValue("100.0");
        }

        /// <summary>
        /// TabControl initializer.
        /// </summary>
        /// <param name="item">Model item for a TabControl.</param>
        /// <param name="context">Editing context.</param>
        public override void InitializeDefaults(ModelItem item, EditingContext context)
        {
            // Use SparseSetValue to avoid setting values to their defaults
            Util.SparseSetValue(item.Properties[MyPlatformTypes.FrameworkElement.WidthProperty], 200d);
            Util.SparseSetValue(item.Properties[MyPlatformTypes.FrameworkElement.HeightProperty], 100d);

            // Add a default TabItem
            ModelItem newTabItem = ModelFactory.CreateItem(context, MyPlatformTypes.TabItem.TypeId, CreateOptions.InitializeDefaults);
            item.Content.Collection.Add(newTabItem);
        }