[reflection] Coop handles icalls in System.Reflection and System.RuntimeTypeHandle...

[mono.git] / mcs / class / referencesource / System.Activities.Presentation / System.Activities.Presentation / System / Activities / Presentation / Base / Interaction / Model / ModelItem.cs

//------------------------------------------------------------------------------
// <copyright file="ModelItem.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Activities.Presentation.Model 
{

    using System;
    using System.ComponentModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Windows;
    using System.Collections.Generic;

    // <summary>
    // The ModelItem class represents a single item in the editing model.  An
    // item can be anything from a Window or Control down to a color or integer.
    //
    // You may access the item�s properties through its Properties collection
    // and make changes to the values of the properties.
    //
    // A ModelItem is essentially a wrapper around the designer�s underlying
    // data model.  You can access the underlying model through the
    // GetCurrentValue method.  Note that you should never make any serializable
    // changes to an object returned from the GetCurrentValue method:  it will
    // not be reflected back in the designer�s serialization or undo systems.
    // </summary>
    public abstract class ModelItem : INotifyPropertyChanged 
    {

        // <summary>
        // Creates a new ModelItem.
        // </summary>
        protected ModelItem() 
        {
        }

        // <summary>
        // Implements INotifyPropertyChanged.  This can be used to tell when a property
        // on the model changes.  It is also useful because INotifyPropertyChanged can
        // be used by the data binding features of WPF.
        //
        // You should take care to disconnect events from items when you are finished
        // when them.  Otherwise you can prevent the item from garbage collecting.
        // </summary>
        public abstract event PropertyChangedEventHandler PropertyChanged;

        // <summary>
        // Returns the attributes declared on this item.
        // </summary>
        public abstract AttributeCollection Attributes { get; }

        // <summary>
        // If this item's ItemType declares a ContentPropertyAttribute,
        // that property will be exposed here.  Otherwise, this will
        // return null.
        // </summary>
        public abstract ModelProperty Content { get; }

        // <summary>
        // Returns the type of object the item represents.
        // </summary>
        public abstract Type ItemType { get; }

        // <summary>
        // This property represents the name or ID of the item.  Not
        // all items need to have names so this may return null.  Also,
        // depending on the type of item and where it sits in the
        // hierarchy, it may not always be legal to set the name on
        // an item.  If this item's ItemType declares a
        // RuntimeNamePropertyAttribute, this Name property will be
        // a direct mapping to the property dictated by that attribute.
        // </summary>
        public abstract string Name { get; set; }

        // <summary>
        // Returns the item that is the parent of this item.
        // If an item is contained in a collection or dictionary
        // the collection or dictionary is skipped, returning the
        // object owns the collection or dictionary.
        // </summary>
        public abstract ModelItem Parent { get; }

        // <summary>
        // Returns the al the parents of this item.
        // </summary>
        public abstract IEnumerable<ModelItem> Parents { get; }

        // <summary>
        // Returns the item that is the root of this tree.
        // If there is no root yet, as this isn't part of a tree
        // returns null.
        // </summary>
        public abstract ModelItem Root { get; }

        // <summary>
        // Returns the public properties on this object.  The set of
        // properties returned may change based on attached
        // properties or changes to the editing scope.
        // </summary>
        public abstract ModelPropertyCollection Properties { get; }

        // <summary>
        // Returns the property that provided this value. If the item represents
        // the root of the object graph, this will return null.  If an item is a
        // member of a collection or dictionary, the property returned from Source
        // will be a pseudo-property provided by the collection or dictionary.
        // For other values, the Source property returns the property where the
        // value was actually set.  Therefore, if a value is being inherited,
        // Source allows you to find out who originally provided the value.
        // </summary>
        public abstract ModelProperty Source { get; }


        // <summary>
        // Returns all the properties that hold this value.
        // </summary>
        public abstract IEnumerable<ModelProperty> Sources { get; }

        // <summary>
        // Returns the visual or visual3D representing the UI for this item.  This
        // may return null if there is no view for this object.
        // </summary>
        public abstract DependencyObject View { get; }

        // <summary>
        // If you are doing multiple operations on an object or group of objects
        // you may call BeginEdit.  Once an editing scope is open, all changes
        // across all objects will be saved into the scope.
        //
        // Editing scopes are global to the designer.  An editing scope may be
        // created for any item in the designer; you do not need to create an
        // editing scope for the specific item you are changing.
        //
        // Editing scopes can be nested, but must be committed in order.
        // </summary>
        // <returns>
        // An editing scope that must be either completed or reverted.
        // </returns>
        public abstract ModelEditingScope BeginEdit();

        // <summary>
        // If you are doing multiple operations on an object or group of objects
        // you may call BeginEdit.  Once an editing scope is open, all changes
        // across all objects will be saved into the scope.
        //
        // Editing scopes are global to the designer.  An editing scope may be
        // created for any item in the designer; you do not need to create an
        // editing scope for the specific item you are changing.
        //
        // Editing scopes can be nested, but must be committed in order.
        // </summary>
        // <param name="description">
        // An optional description that describes the change.  This will be set
        // into the editing scope�s Description property.
        // </param>
        // <returns>
        // An editing scope that must be either completed or reverted.
        // </returns>
        public abstract ModelEditingScope BeginEdit(string description);

        // <summary>
        // If you are doing multiple operations on an object or group of objects
        // you may call BeginEdit.  Once an editing scope is open, all changes
        // across all objects will be saved into the scope.
        //
        // Editing scopes are global to the designer.  An editing scope may be
        // created for any item in the designer; you do not need to create an
        // editing scope for the specific item you are changing.
        //
        // Editing scopes can be nested, but must be committed in order.
        // </summary>
        // <param name="shouldApplyChangesImmediately">
        // A flag to control whether changes should take effect immediately.
        // </param>
        // <returns>
        // An editing scope that must be either completed or reverted.
        // </returns>
        // <exception cref="NotImplementedException">
        // If the derived class doesn't override this method.
        // </exception>
        // <exception cref="InvalidOperationException">
        // If shouldApplyChangesImmediately == true but the outer editing scope is not null.
        // </exception>
        public virtual ModelEditingScope BeginEdit(bool shouldApplyChangesImmediately)
        {
            throw FxTrace.Exception.AsError(new NotImplementedException());
        }

        // <summary>
        // If you are doing multiple operations on an object or group of objects
        // you may call BeginEdit.  Once an editing scope is open, all changes
        // across all objects will be saved into the scope.
        //
        // Editing scopes are global to the designer.  An editing scope may be
        // created for any item in the designer; you do not need to create an
        // editing scope for the specific item you are changing.
        //
        // Editing scopes can be nested, but must be committed in order.
        // </summary>
        // <param name="description">
        // An optional description that describes the change.  This will be set
        // into the editing scope�s Description property.
        // </param>
        // <param name="shouldApplyChangesImmediately">
        // A flag to control whether changes should take effect immediately.
        // </param>
        // <returns>
        // An editing scope that must be either completed or reverted.
        // </returns>
        // <exception cref="NotImplementedException">
        // If the derived class doesn't override this method.
        // </exception>
        // <exception cref="InvalidOperationException">
        // If shouldApplyChangesImmediately == true but the outer editing scope is not null.
        // </exception>
        public virtual ModelEditingScope BeginEdit(string description, bool shouldApplyChangesImmediately)
        {
            throw FxTrace.Exception.AsError(new NotImplementedException());
        }

        // <summary>
        // Returns the current value of the underlying model object the ModelItem
        // is wrapping.  You can inspect this object, but you should not make any
        // changes to it.  Changes made to the object returned will not be incorporated
        // into the designer.  The GetCurrentValue method may return either an existing
        // or new cloned instance of the object.
        // </summary>
        // <returns>
        // Returns the current value of the underlying model object the ModelItem is wrapping.
        // </returns>
        public abstract object GetCurrentValue();

        // <summary>
        // Returns string representation of the ModelItem which is the string representation 
        // of underlying object the ModelItem is wrapping.
        // </summary>
        // <returns>
        // Returns string representation of the ModelItem.
        // </returns>        
        public override string ToString()
        {                        
            object instance = this.GetCurrentValue();
            if (instance != null)
            {
                return instance.ToString();
            }
            else 
            {
                return base.ToString();
            }
        }

        internal virtual event PropertyReferenceChangedEventHandler PropertyReferenceChanged;

        internal virtual void OnPropertyReferenceChanged(string targetProperty)
        {
            if (this.PropertyReferenceChanged != null)
            {
                this.PropertyReferenceChanged(this, new PropertyReferenceChangedEventArgs(targetProperty));
            }
        }
    }
}