class/WindowsBase/System.Windows/DependencyProperty.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // (C) 2005 Iain McCoy
  21 //
  22 // Copyright (c) 2007 Novell, Inc. (http://www.novell.com)
  23 //
  24 // Authors:
  25 //      Iain McCoy (iain@mccoy.id.au)
  26 //      Chris Toshok (toshok@ximian.com)
  27 //
  28
  29 using System.Collections.Generic;
  30
  31 namespace System.Windows {
  32         public sealed class DependencyProperty {
  33                 private Dictionary<Type,PropertyMetadata> metadataByType = new Dictionary<Type,PropertyMetadata>();
  34
  35                 public static readonly object UnsetValue = new object ();
  36
  37                 private DependencyProperty (bool isAttached, string name, Type propertyType, Type ownerType,
  38                                             PropertyMetadata defaultMetadata,
  39                                             ValidateValueCallback validateValueCallback)
  40                 {
  41                         IsAttached = isAttached;
  42                         DefaultMetadata = (defaultMetadata == null ? new PropertyMetadata() : defaultMetadata);
  43                         Name = name;
  44                         OwnerType = ownerType;
  45                         PropertyType = propertyType;
  46                         ValidateValueCallback = validateValueCallback;
  47                 }
  48
  49                 internal bool IsAttached { get; set; }
  50                 public bool ReadOnly { get; private set; }
  51                 public PropertyMetadata DefaultMetadata { get; private set; }
  52                 public string Name { get; private set; }
  53                 public Type OwnerType { get; private set; }
  54                 public Type PropertyType { get; private set; }
  55                 public ValidateValueCallback ValidateValueCallback { get; private set; }
  56
  57                 public int GlobalIndex {
  58                         get { throw new NotImplementedException (); }
  59                 }
  60
  61
  62                 public DependencyProperty AddOwner(Type ownerType)
  63                 {
  64                         return AddOwner (ownerType, null);
  65                 }
  66
  67                 public DependencyProperty AddOwner(Type ownerType, PropertyMetadata typeMetadata)
  68                 {
  69                         if (typeMetadata == null) typeMetadata = new PropertyMetadata ();
  70                         OverrideMetadata (ownerType, typeMetadata);
  71
  72                         // MS seems to always return the same DependencyProperty
  73                         return this;
  74                 }
  75
  76                 public PropertyMetadata GetMetadata(Type forType)
  77                 {
  78                         if (metadataByType.ContainsKey (forType))
  79                                 return metadataByType[forType];
  80                         return null;
  81                 }
  82
  83                 public PropertyMetadata GetMetadata(DependencyObject d)
  84                 {
  85                         if (metadataByType.ContainsKey (d.GetType()))
  86                                 return metadataByType[d.GetType()];
  87                         return null;
  88                 }
  89
  90                 public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
  91                 {
  92                         if (metadataByType.ContainsKey (dependencyObjectType.SystemType))
  93                                 return metadataByType[dependencyObjectType.SystemType];
  94                         return null;
  95                 }
  96
  97
  98                 public bool IsValidType(object value)
  99                 {
 100                         return PropertyType.IsInstanceOfType (value);
 101                 }
 102
 103                 public bool IsValidValue(object value)
 104                 {
 105                         if (!IsValidType (value))
 106                                 return false;
 107                         if (ValidateValueCallback == null)
 108                                 return true;
 109                         return ValidateValueCallback (value);
 110                 }
 111
 112                 public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata)
 113                 {
 114                         if (forType == null)
 115                                 throw new ArgumentNullException ("forType");
 116                         if (typeMetadata == null)
 117                                 throw new ArgumentNullException ("typeMetadata");
 118
 119                         if (ReadOnly)
 120                                 throw new InvalidOperationException (String.Format ("Cannot override metadata on readonly property '{0}' without using a DependencyPropertyKey", Name));
 121
 122                         typeMetadata.DoMerge (DefaultMetadata, this, forType);
 123                         metadataByType.Add (forType, typeMetadata);
 124                 }
 125
 126                 public void OverrideMetadata (Type forType, PropertyMetadata typeMetadata, DependencyPropertyKey key)
 127                 {
 128                         if (forType == null)
 129                                 throw new ArgumentNullException ("forType");
 130                         if (typeMetadata == null)
 131                                 throw new ArgumentNullException ("typeMetadata");
 132
 133
 134                         // further checking?  should we check
 135                         // key.DependencyProperty == this?
 136
 137                         typeMetadata.DoMerge (DefaultMetadata, this, forType);
 138                         metadataByType.Add (forType, typeMetadata);
 139                 }
 140
 141                 public override string ToString ()
 142                 {
 143                         return Name;
 144                 }
 145
 146                 public override int GetHashCode ()
 147                 {
 148                         return Name.GetHashCode() ^ PropertyType.GetHashCode() ^ OwnerType.GetHashCode();
 149                 }
 150
 151                 public static DependencyProperty Register(string name, Type propertyType, Type ownerType)
 152                 {
 153                         return Register(name, propertyType, ownerType, null, null);
 154                 }
 155
 156                 public static DependencyProperty Register(string name, Type propertyType, Type ownerType,
 157                                                           PropertyMetadata typeMetadata)
 158                 {
 159                         return Register(name, propertyType, ownerType, typeMetadata, null);
 160                 }
 161
 162                 public static DependencyProperty Register(string name, Type propertyType, Type ownerType,
 163                                                           PropertyMetadata typeMetadata,
 164                                                           ValidateValueCallback validateValueCallback)
 165                 {
 166                         if (typeMetadata == null)
 167                                 typeMetadata = new PropertyMetadata();
 168
 169                         DependencyProperty dp = new DependencyProperty(false, name, propertyType, ownerType,
 170                                                                        typeMetadata, validateValueCallback);
 171                         DependencyObject.register(ownerType, dp);
 172
 173                         dp.OverrideMetadata (ownerType, typeMetadata);
 174
 175                         return dp;
 176                 }
 177
 178                 public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType)
 179                 {
 180                         return RegisterAttached(name, propertyType, ownerType, null, null);
 181                 }
 182
 183                 public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType,
 184                                                                   PropertyMetadata defaultMetadata)
 185                 {
 186                         return RegisterAttached(name, propertyType, ownerType, defaultMetadata, null);
 187                 }
 188
 189                 public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType,
 190                                                                   PropertyMetadata defaultMetadata,
 191                                                                   ValidateValueCallback validateValueCallback)
 192                 {
 193                         DependencyProperty dp = new DependencyProperty(true, name, propertyType, ownerType,
 194                                                                        defaultMetadata, validateValueCallback);
 195                         DependencyObject.register(ownerType, dp);
 196                         return dp;
 197                 }
 198
 199                 public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType,
 200                                                                              PropertyMetadata defaultMetadata)
 201                 {
 202                         throw new NotImplementedException("RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata)");
 203                 }
 204
 205                 public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType,
 206                                                                              PropertyMetadata defaultMetadata,
 207                                                                              ValidateValueCallback validateValueCallback)
 208                 {
 209                         throw new NotImplementedException("RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)");
 210                 }
 211
 212                 public static DependencyPropertyKey RegisterReadOnly(string name, Type propertyType, Type ownerType,
 213                                                                      PropertyMetadata typeMetadata)
 214                 {
 215                         return RegisterReadOnly (name, propertyType, ownerType, typeMetadata, null);
 216                 }
 217
 218
 219                 public static DependencyPropertyKey RegisterReadOnly(string name, Type propertyType, Type ownerType,
 220                                                                      PropertyMetadata typeMetadata,
 221                                                                      ValidateValueCallback validateValueCallback)
 222                 {
 223                         DependencyProperty prop = Register (name, propertyType, ownerType, typeMetadata, validateValueCallback);
 224                         prop.ReadOnly = true;
 225                         return new DependencyPropertyKey (prop);
 226                 }
 227
 228         }
 229 }