The Labs \ Source Viewer \ SSCLI \ System.ComponentModel \ PropertyTabAttribute

  1. //------------------------------------------------------------------------------
  2. // <copyright file="PropertyTabAttribute.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2113:SecureLateBindingMethods", Scope = "member", Target = "System.ComponentModel.PropertyTabAttribute.get_TabClasses():System.Type[]")]
  16. namespace System.ComponentModel
  17. {
  18.    
  19.     using System;
  20.     using System.ComponentModel;
  21.     using System.Reflection;
  22.     using System.Security.Permissions;
  23.    
  24.     /// <devdoc>
  25.     /// <para> Identifies the property tab or tabs that should be displayed for the
  26.     /// specified class or classes.</para>
  27.     /// </devdoc>
  28.     [AttributeUsage(AttributeTargets.All)]
  29.     public class PropertyTabAttribute : Attribute
  30.     {
  31.         private PropertyTabScope[] tabScopes;
  32.         private Type[] tabClasses;
  33.         private string[] tabClassNames;
  34.        
  35.         /// <devdoc>
  36.         /// <para>
  37.         /// Basic constructor that creates a PropertyTabAttribute. Use this ctor to derive from this
  38.         /// attribute and specify multiple tab types by calling InitializeArrays.
  39.         /// </para>
  40.         /// </devdoc>
  41.         public PropertyTabAttribute()
  42.         {
  43.             tabScopes = new PropertyTabScope[0];
  44.             tabClassNames = new string[0];
  45.         }
  46.        
  47.         /// <devdoc>
  48.         /// <para>
  49.         /// Basic constructor that creates a property tab attribute that will create a tab
  50.         /// of the specified type.
  51.         /// </para>
  52.         /// </devdoc>
  53.         public PropertyTabAttribute(Type tabClass) : this(tabClass, PropertyTabScope.Component)
  54.         {
  55.         }
  56.        
  57.         /// <devdoc>
  58.         /// <para>
  59.         /// Basic constructor that creates a property tab attribute that will create a tab
  60.         /// of the specified type.
  61.         /// </para>
  62.         /// </devdoc>
  63.         public PropertyTabAttribute(string tabClassName) : this(tabClassName, PropertyTabScope.Component)
  64.         {
  65.         }
  66.        
  67.         /// <devdoc>
  68.         /// <para>
  69.         /// Basic constructor that creates a property tab attribute that will create a tab
  70.         /// of the specified type.
  71.         /// </para>
  72.         /// </devdoc>
  73.         public PropertyTabAttribute(Type tabClass, PropertyTabScope tabScope)
  74.         {
  75.            
  76.             this.tabClasses = new Type[] {tabClass};
  77.             if (tabScope < PropertyTabScope.Document) {
  78.                 throw new ArgumentException(SR.GetString(SR.PropertyTabAttributeBadPropertyTabScope), "tabScope");
  79.             }
  80.             this.tabScopes = new PropertyTabScope[] {tabScope};
  81.            
  82.         }
  83.        
  84.        
  85.         /// <devdoc>
  86.         /// <para>
  87.         /// Basic constructor that creates a property tab attribute that will create a tab
  88.         /// of the specified type.
  89.         /// </para>
  90.         /// </devdoc>
  91.         public PropertyTabAttribute(string tabClassName, PropertyTabScope tabScope)
  92.         {
  93.             this.tabClassNames = new string[] {tabClassName};
  94.             if (tabScope < PropertyTabScope.Document) {
  95.                 throw new ArgumentException(SR.GetString(SR.PropertyTabAttributeBadPropertyTabScope), "tabScope");
  96.             }
  97.             this.tabScopes = new PropertyTabScope[] {tabScope};
  98.         }
  99.        
  100.         /// <devdoc>
  101.         /// <para>Gets the types of tab that this attribute specifies.</para>
  102.         /// </devdoc>
  103.         public Type[] TabClasses {
  104.             get {
  105.                 if (tabClasses == null && tabClassNames != null) {
  106.                     tabClasses = new Type[tabClassNames.Length];
  107.                     for (int i = 0; i < tabClassNames.Length; i++) {
  108.                        
  109.                         int commaIndex = tabClassNames[i].IndexOf(',');
  110.                         string className = null;
  111.                         string assemblyName = null;
  112.                        
  113.                         if (commaIndex != -1) {
  114.                             className = tabClassNames[i].Substring(0, commaIndex).Trim();
  115.                             assemblyName = tabClassNames[i].Substring(commaIndex + 1).Trim();
  116.                         }
  117.                         else {
  118.                             className = tabClassNames[i];
  119.                         }
  120.                        
  121.                         tabClasses[i] = Type.GetType(className, false);
  122.                        
  123.                         if (tabClasses[i] == null) {
  124.                             if (assemblyName != null) {
  125.                                 Assembly a = Assembly.Load(assemblyName);
  126.                                 if (a != null) {
  127.                                     tabClasses[i] = a.GetType(className, true);
  128.                                 }
  129.                             }
  130.                             else {
  131.                                 throw new TypeLoadException(SR.GetString(SR.PropertyTabAttributeTypeLoadException, className));
  132.                             }
  133.                         }
  134.                     }
  135.                 }
  136.                 return tabClasses;
  137.             }
  138.         }
  139.        
  140.         /// <devdoc>
  141.         /// <para>[To be supplied.]</para>
  142.         /// </devdoc>
  143.         protected string[] TabClassNames {
  144.             get {
  145.                 if (tabClassNames != null) {
  146.                     return (string[])tabClassNames.Clone();
  147.                 }
  148.                 else {
  149.                     return null;
  150.                 }
  151.             }
  152.         }
  153.        
  154.         /// <devdoc>
  155.         /// <para>Gets the scopes of tabs for this System.ComponentModel.Design.PropertyTabAttribute, from System.ComponentModel.Design.PropertyTabScope.</para>
  156.         /// </devdoc>
  157.         public PropertyTabScope[] TabScopes {
  158.             get { return tabScopes; }
  159.         }
  160.         /// <internalonly/>
  161.         public override bool Equals(object other)
  162.         {
  163.             if (other is PropertyTabAttribute) {
  164.                 return Equals((PropertyTabAttribute)other);
  165.             }
  166.             return false;
  167.         }
  168.        
  169.         /// <internalonly/>
  170.         public bool Equals(PropertyTabAttribute other)
  171.         {
  172.             if (other == (object)this) {
  173.                 return true;
  174.             }
  175.             if (other.TabClasses.Length != TabClasses.Length || other.TabScopes.Length != TabScopes.Length) {
  176.                 return false;
  177.             }
  178.            
  179.             for (int i = 0; i < TabClasses.Length; i++) {
  180.                 if (TabClasses[i] != other.TabClasses[i] || TabScopes[i] != other.TabScopes[i]) {
  181.                     return false;
  182.                 }
  183.             }
  184.             return true;
  185.         }
  186.        
  187.        
  188.         /// <devdoc>
  189.         /// <para>
  190.         /// Returns the hashcode for this object.
  191.         /// </para>
  192.         /// </devdoc>
  193.         public override int GetHashCode()
  194.         {
  195.             return base.GetHashCode();
  196.         }
  197.        
  198.         /// <devdoc>
  199.         /// <para>
  200.         /// Utiliity function to set the types of tab classes this PropertyTabAttribute specifies.
  201.         /// </para>
  202.         /// </devdoc>
  203.         protected void InitializeArrays(string[] tabClassNames, PropertyTabScope[] tabScopes)
  204.         {
  205.             InitializeArrays(tabClassNames, null, tabScopes);
  206.         }
  207.        
  208.         /// <devdoc>
  209.         /// <para>
  210.         /// Utiliity function to set the types of tab classes this PropertyTabAttribute specifies.
  211.         /// </para>
  212.         /// </devdoc>
  213.         protected void InitializeArrays(Type[] tabClasses, PropertyTabScope[] tabScopes)
  214.         {
  215.             InitializeArrays(null, tabClasses, tabScopes);
  216.         }
  217.        
  218.        
  219.         private void InitializeArrays(string[] tabClassNames, Type[] tabClasses, PropertyTabScope[] tabScopes)
  220.         {
  221.            
  222.             if (tabClasses != null) {
  223.                 if (tabScopes != null && tabClasses.Length != tabScopes.Length) {
  224.                     throw new ArgumentException(SR.GetString(SR.PropertyTabAttributeArrayLengthMismatch));
  225.                 }
  226.                 this.tabClasses = (Type[])tabClasses.Clone();
  227.             }
  228.             else if (tabClassNames != null) {
  229.                 if (tabScopes != null && tabClasses.Length != tabScopes.Length) {
  230.                     throw new ArgumentException(SR.GetString(SR.PropertyTabAttributeArrayLengthMismatch));
  231.                 }
  232.                 this.tabClassNames = (string[])tabClassNames.Clone();
  233.                 this.tabClasses = null;
  234.             }
  235.             else if (this.tabClasses == null && this.tabClassNames == null) {
  236.                 throw new ArgumentException(SR.GetString(SR.PropertyTabAttributeParamsBothNull));
  237.             }
  238.            
  239.             if (tabScopes != null) {
  240.                 for (int i = 0; i < tabScopes.Length; i++) {
  241.                     if (tabScopes[i] < PropertyTabScope.Document) {
  242.                         throw new ArgumentException(SR.GetString(SR.PropertyTabAttributeBadPropertyTabScope));
  243.                     }
  244.                 }
  245.                 this.tabScopes = (PropertyTabScope[])tabScopes.Clone();
  246.             }
  247.             else {
  248.                 this.tabScopes = new PropertyTabScope[tabClasses.Length];
  249.                
  250.                 for (int i = 0; i < TabScopes.Length; i++) {
  251.                     this.tabScopes[i] = PropertyTabScope.Component;
  252.                 }
  253.             }
  254.         }
  255.     }
  256. }

Developer Fusion