TypeKeyValue.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / Tools / System.Activities.Presentation / System / Activities / Presentation / View / TypeKeyValue.cs / 1305376 / TypeKeyValue.cs

                            namespace System.Activities.Presentation.View 
{
    using System;
    using System.Collections.ObjectModel;
    using System.ComponentModel; 
    using System.Windows;
    using System.Windows.Automation.Peers; 
    using System.Windows.Input; 

    //helper class, used to resolve generics. supports cascading generic type arguments (i.e. IList< IList < int > >) 
    internal class TypeKeyValue : INotifyPropertyChanged
    {
        string errorText;
        //generic type 
        Type genericType;
 
        bool isValid = true; 
        //generic's type generic parameters
        ObservableCollection < TypeKeyValue > subTypes = new ObservableCollection < TypeKeyValue >(); 
        //target type
        Type targetType;
        //type resolver reference
        Action < TypeKeyValue > typeChangedCallBack; 
        //if this type is selected
        bool isSelected; 
        Func filter; 
        ObservableCollection mostRecentlyUsedTypes;
        //if type presenter should skip the drop down list 
        bool browseTypeDirectly = true;

        public TypeKeyValue(Type genericType, Action < TypeKeyValue > typeChangedCallBack)
        { 
            this.GenericType = genericType;
            this.typeChangedCallBack = typeChangedCallBack; 
        } 

        public event PropertyChangedEventHandler PropertyChanged; 

        public string ErrorText
        {
            get { return this.errorText; } 
            set
            { 
                this.errorText = value; 
                OnPropertyChanged("ErrorText");
            } 
        }

        public Type GenericType
        { 
            get { return this.genericType; }
            set 
            { 
                this.genericType = value;
                OnPropertyChanged("GenericType"); 
            }
        }

        public bool IsSelected 
        {
            get { return this.isSelected; } 
            set 
            {
                this.isSelected = value; 
                OnPropertyChanged("IsSelected");
            }
        }
 
        public Func Filter
        { 
            get { return this.filter; } 
            set
            { 
                this.filter = value;
                OnPropertyChanged("Filter");
            }
        } 

        public ObservableCollection MostRecentlyUsedTypes 
        { 
            get { return this.mostRecentlyUsedTypes; }
            set 
            {
                this.mostRecentlyUsedTypes = value;
                OnPropertyChanged("MostRecentlyUsedTypes");
            } 
        }
 
        public bool BrowseTypeDirectly 
        {
            get { return this.browseTypeDirectly; } 
            set
            {
                this.browseTypeDirectly = value;
                OnPropertyChanged("BrowseTypeDirectly"); 
            }
        } 
 
        public bool IsValid
        { 
            get { return this.isValid; }
            set
            {
                this.isValid = value; 
                OnPropertyChanged("IsValid");
            } 
        } 

 
        public ObservableCollection < TypeKeyValue > SubTypes
        {
            get { return this.subTypes; }
        } 

        public Type TargetType 
        { 
            get { return this.targetType; }
            set 
            {
                this.targetType = value;
                //whenever target type changes, check if there are some generic parameters required
                LoadGenericTypes(); 
                OnPropertyChanged("TargetType");
                if (typeChangedCallBack != null) 
                { 
                    typeChangedCallBack(this);
                } 
            }
        }

        public Type GetConcreteType() 
        {
            Type result = null; 
            if (null != this.targetType) 
            {
                //do we have generic? 
                if (this.targetType.IsGenericTypeDefinition)
                {
                    //resolve all generic arguments
                    Type[] arguments = new Type[this.subTypes.Count]; 
                    bool isValid = true;
                    for (int i = 0; i < this.subTypes.Count && isValid; ++i) 
                    { 
                        arguments[i] = this.subTypes[i].GetConcreteType();
                        isValid = (null != arguments[i]); 
                    }
                    if (isValid)
                    {
                        //and create target type 
                        result = this.targetType.MakeGenericType(arguments);
                    } 
                } 
                else
                { 
                    result = targetType;
                }
            }
            return result; 
        }
 
        void LoadGenericTypes() 
        {
            this.subTypes.Clear(); 
            if (null != this.targetType && this.targetType.IsGenericTypeDefinition)
            {
                Type[] generics = this.targetType.GetGenericArguments();
                foreach (Type t in generics) 
                {
                    TypeKeyValue entry = new TypeKeyValue(t, typeChangedCallBack); 
                    this.subTypes.Add(entry); 
                    typeChangedCallBack(entry);
                } 
            }
        }

        void OnPropertyChanged(string propertyName) 
        {
            if (null != PropertyChanged) 
            { 
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            } 
        }

    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
namespace System.Activities.Presentation.View 
{
    using System;
    using System.Collections.ObjectModel;
    using System.ComponentModel; 
    using System.Windows;
    using System.Windows.Automation.Peers; 
    using System.Windows.Input; 

    //helper class, used to resolve generics. supports cascading generic type arguments (i.e. IList< IList < int > >) 
    internal class TypeKeyValue : INotifyPropertyChanged
    {
        string errorText;
        //generic type 
        Type genericType;
 
        bool isValid = true; 
        //generic's type generic parameters
        ObservableCollection < TypeKeyValue > subTypes = new ObservableCollection < TypeKeyValue >(); 
        //target type
        Type targetType;
        //type resolver reference
        Action < TypeKeyValue > typeChangedCallBack; 
        //if this type is selected
        bool isSelected; 
        Func filter; 
        ObservableCollection mostRecentlyUsedTypes;
        //if type presenter should skip the drop down list 
        bool browseTypeDirectly = true;

        public TypeKeyValue(Type genericType, Action < TypeKeyValue > typeChangedCallBack)
        { 
            this.GenericType = genericType;
            this.typeChangedCallBack = typeChangedCallBack; 
        } 

        public event PropertyChangedEventHandler PropertyChanged; 

        public string ErrorText
        {
            get { return this.errorText; } 
            set
            { 
                this.errorText = value; 
                OnPropertyChanged("ErrorText");
            } 
        }

        public Type GenericType
        { 
            get { return this.genericType; }
            set 
            { 
                this.genericType = value;
                OnPropertyChanged("GenericType"); 
            }
        }

        public bool IsSelected 
        {
            get { return this.isSelected; } 
            set 
            {
                this.isSelected = value; 
                OnPropertyChanged("IsSelected");
            }
        }
 
        public Func Filter
        { 
            get { return this.filter; } 
            set
            { 
                this.filter = value;
                OnPropertyChanged("Filter");
            }
        } 

        public ObservableCollection MostRecentlyUsedTypes 
        { 
            get { return this.mostRecentlyUsedTypes; }
            set 
            {
                this.mostRecentlyUsedTypes = value;
                OnPropertyChanged("MostRecentlyUsedTypes");
            } 
        }
 
        public bool BrowseTypeDirectly 
        {
            get { return this.browseTypeDirectly; } 
            set
            {
                this.browseTypeDirectly = value;
                OnPropertyChanged("BrowseTypeDirectly"); 
            }
        } 
 
        public bool IsValid
        { 
            get { return this.isValid; }
            set
            {
                this.isValid = value; 
                OnPropertyChanged("IsValid");
            } 
        } 

 
        public ObservableCollection < TypeKeyValue > SubTypes
        {
            get { return this.subTypes; }
        } 

        public Type TargetType 
        { 
            get { return this.targetType; }
            set 
            {
                this.targetType = value;
                //whenever target type changes, check if there are some generic parameters required
                LoadGenericTypes(); 
                OnPropertyChanged("TargetType");
                if (typeChangedCallBack != null) 
                { 
                    typeChangedCallBack(this);
                } 
            }
        }

        public Type GetConcreteType() 
        {
            Type result = null; 
            if (null != this.targetType) 
            {
                //do we have generic? 
                if (this.targetType.IsGenericTypeDefinition)
                {
                    //resolve all generic arguments
                    Type[] arguments = new Type[this.subTypes.Count]; 
                    bool isValid = true;
                    for (int i = 0; i < this.subTypes.Count && isValid; ++i) 
                    { 
                        arguments[i] = this.subTypes[i].GetConcreteType();
                        isValid = (null != arguments[i]); 
                    }
                    if (isValid)
                    {
                        //and create target type 
                        result = this.targetType.MakeGenericType(arguments);
                    } 
                } 
                else
                { 
                    result = targetType;
                }
            }
            return result; 
        }
 
        void LoadGenericTypes() 
        {
            this.subTypes.Clear(); 
            if (null != this.targetType && this.targetType.IsGenericTypeDefinition)
            {
                Type[] generics = this.targetType.GetGenericArguments();
                foreach (Type t in generics) 
                {
                    TypeKeyValue entry = new TypeKeyValue(t, typeChangedCallBack); 
                    this.subTypes.Add(entry); 
                    typeChangedCallBack(entry);
                } 
            }
        }

        void OnPropertyChanged(string propertyName) 
        {
            if (null != PropertyChanged) 
            { 
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            } 
        }

    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK