protected override void OnApply(DependencyProperty dp, Type targetType)
{
doType = DependencyObjectType.FromSystemType(targetType);
propertyChangedCallbackInternal = PropertyChangedCallback;
PropertyChangedCallback = OnPropertyChanged;
base.OnApply(dp, targetType);
}
internal object GetDefaultValue(DependencyObjectType dependencyObjectType)
{
if (!IsDefaultValueChanged)
{
return(DefaultMetadata.DefaultValue);
}
return(GetMetadata(dependencyObjectType).DefaultValue);
}
internal object GetDefaultValue(Type forType)
{
if (!IsDefaultValueChanged)
{
return(DefaultMetadata.DefaultValue);
}
return(GetMetadata(DependencyObjectType.FromSystemTypeInternal(forType)).DefaultValue);
}
public static void RemovePropertyChanged(DependencyProperty dp, DependencyObjectType type,
DependencyPropertyChangedEventHandler handler)
{
var hcpm = dp.GetMetadata(type) as HandleChangesPropertyMetadata;
if (hcpm == null)
throw new ArgumentException();
hcpm.RemovePropertyChanged(type, handler);
}
/// <summary>Returns the metadata for this dependency property as it exists on a specified existing type. </summary>
/// <returns>A property metadata object.</returns>
/// <param name="forType">The specific type from which to retrieve the dependency property metadata.</param>
public PropertyMetadata GetMetadata(Type forType)
{
if (forType != null)
{
return(GetMetadata(DependencyObjectType.FromSystemType(forType)));
}
throw new ArgumentNullException("forType");
}
public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
{
if (metadataByType.ContainsKey(dependencyObjectType.SystemType))
{
return(metadataByType[dependencyObjectType.SystemType]);
}
return(null);
}
// Returns the list of class listeners for the given
// DType and RoutedEvent
// NOTE: Returns null if no matches found
// Helper method for GetClassListeners
// Invoked only when trying to build the event route
internal static RoutedEventHandlerInfoList GetDTypedClassListeners(
DependencyObjectType dType,
RoutedEvent routedEvent)
{
ClassHandlersStore classListenersLists;
int index;
// Class Forwarded
return(GetDTypedClassListeners(dType, routedEvent, out classListenersLists, out index));
}
public static DependencyObjectType FromSystemType(Type systemType)
{
if (typeMap.ContainsKey (systemType))
return typeMap[systemType];
DependencyObjectType dot;
typeMap[systemType] = dot = new DependencyObjectType (current_id++, systemType);
return dot;
}
public static DependencyObjectType FromSystemType(Type systemType)
{
if (typeMap.ContainsKey(systemType))
{
return(typeMap[systemType]);
}
DependencyObjectType dot;
typeMap[systemType] = dot = new DependencyObjectType(current_id++, systemType);
return(dot);
}
/// <summary>
/// Parameter validation for OverrideMetadata, includes code to force
/// all base classes of "forType" to register their metadata so we know
/// what we are overriding.
/// </summary>
private void SetupOverrideMetadata(
Type forType,
PropertyMetadata typeMetadata,
out DependencyObjectType dType,
out PropertyMetadata baseMetadata)
{
if (forType == null)
{
throw new ArgumentNullException("forType");
}
if (typeMetadata == null)
{
throw new ArgumentNullException("typeMetadata");
}
if (typeMetadata.Sealed)
{
throw new ArgumentException(SR.TypeMetadataAlreadyInUse);
}
if (!typeof(DependencyObject).IsAssignableFrom(forType))
{
throw new ArgumentException(SR.Format(SR.TypeMustBeDependencyObjectDerived, forType.Name));
}
// Ensure default value is a correct value (if it was supplied,
// otherwise, the default value will be taken from the base metadata
// which was already validated)
if (typeMetadata.IsDefaultValueModified)
{
// Will throw ArgumentException if fails.
ValidateMetadataDefaultValue(typeMetadata, PropertyType, Name, ValidateValueCallback);
}
// Force all base classes to register their metadata
dType = DependencyObjectType.FromSystemType(forType);
// Get metadata for the base type
baseMetadata = GetMetadata(dType.BaseType);
// Make sure overriding metadata is the same type or derived type of
// the base metadata
if (!baseMetadata.GetType().IsAssignableFrom(typeMetadata.GetType()))
{
throw new ArgumentException(SR.OverridingMetadataDoesNotMatchBaseMetadataType);
}
}
/// <summary> Returns the metadata for this dependency property as it exists on a specified type. </summary>
/// <returns>A property metadata object.</returns>
/// <param name="dependencyObjectType">A specific object that records the dependency object type from which the dependency property metadata is desired.</param>
public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
{
if (dependencyObjectType != null)
{
int num = _metadataMap.Count - 1;
if (num < 0)
{
return(_defaultMetadata);
}
int key;
object value;
if (num == 0)
{
_metadataMap.GetKeyValuePair(num, out key, out value);
while (dependencyObjectType.Id > key)
{
dependencyObjectType = dependencyObjectType.BaseType;
}
if (key == dependencyObjectType.Id)
{
return((PropertyMetadata)value);
}
}
else if (dependencyObjectType.Id != 0)
{
do
{
_metadataMap.GetKeyValuePair(num, out key, out value);
num--;
while (dependencyObjectType.Id < key && num >= 0)
{
_metadataMap.GetKeyValuePair(num, out key, out value);
num--;
}
while (dependencyObjectType.Id > key)
{
dependencyObjectType = dependencyObjectType.BaseType;
}
if (key == dependencyObjectType.Id)
{
return((PropertyMetadata)value);
}
}while (num >= 0);
}
}
return(_defaultMetadata);
}
/// <summary>
/// Determines whether the specifed object is an instance of the current DependencyObjectType
/// </summary>
/// <param name="dependencyObject">The object to compare with the current Type</param>
/// <returns>
/// true if the current DependencyObjectType is in the inheritance hierarchy of the
/// object represented by the o parameter. false otherwise.
/// </returns>
public bool IsInstanceOfType(DependencyObject dependencyObject)
{
if (dependencyObject != null)
{
DependencyObjectType dType = dependencyObject.DependencyObjectType;
do
{
if (dType.Id == Id)
{
return(true);
}
dType = dType._baseDType;
}while (dType != null);
}
return(false);
}
// Register a Class Handler
// NOTE: Handler Type must be the
// same as the one specified when
// registering the corresponding RoutedEvent
internal static void RegisterClassHandler(
Type classType,
RoutedEvent routedEvent,
Delegate handler,
bool handledEventsToo)
{
Debug.Assert(
typeof(UIElement).IsAssignableFrom(classType) ||
typeof(ContentElement).IsAssignableFrom(classType) ||
typeof(UIElement3D).IsAssignableFrom(classType),
"Class Handlers can be registered only for UIElement/ContentElement/UIElement3D and their sub types");
Debug.Assert(routedEvent.IsLegalHandler(handler),
"Handler Type mismatch");
ClassHandlersStore classListenersLists;
int index;
// We map the classType to a DType use DTypeMap for storage
DependencyObjectType dType = DependencyObjectType.FromSystemTypeInternal(classType);
// Get the updated EventHandlersStore for the given DType
GetDTypedClassListeners(dType, routedEvent, out classListenersLists, out index);
// Reuired to update storage
lock (Synchronized)
{
// Add new routed event handler and get the updated set of handlers
RoutedEventHandlerInfoList updatedClassListeners =
classListenersLists.AddToExistingHandlers(index, handler, handledEventsToo);
// Update Sub Classes
ItemStructList <DependencyObjectType> keys = _dTypedClassListeners.ActiveDTypes;
for (int i = 0; i < keys.Count; i++)
{
if (keys.List[i].IsSubclassOf(dType) == true)
{
classListenersLists = (ClassHandlersStore)_dTypedClassListeners[keys.List[i]];
classListenersLists.UpdateSubClassHandlers(routedEvent, updatedClassListeners);
}
}
}
}
/// <summary>
/// After parameters have been validated for OverrideMetadata, this
/// method is called to actually update the data structures.
/// </summary>
private void ProcessOverrideMetadata(
Type forType,
PropertyMetadata typeMetadata,
DependencyObjectType dType,
PropertyMetadata baseMetadata)
{
// Store per-Type metadata for this property. Locks only on Write.
// Datastructure guaranteed to be valid for non-locking readers
lock (Synchronized)
{
if (DependencyProperty.UnsetValue == _metadataMap[dType.Id])
{
_metadataMap[dType.Id] = typeMetadata;
}
else
{
throw new ArgumentException(SR.Format(SR.TypeMetadataAlreadyRegistered, forType.Name));
}
}
// Merge base's metadata into this metadata
// CALLBACK
typeMetadata.InvokeMerge(baseMetadata, this);
// Type metadata may no longer change (calls OnApply)
typeMetadata.Seal(this, forType);
if (typeMetadata.IsInherited)
{
_packedData |= Flags.IsPotentiallyInherited;
}
if (typeMetadata.DefaultValueWasSet() && (typeMetadata.DefaultValue != DefaultMetadata.DefaultValue))
{
_packedData |= Flags.IsDefaultValueChanged;
}
if (typeMetadata.UsingDefaultValueFactory)
{
_packedData |= Flags.IsPotentiallyUsingDefaultValueFactory;
}
}
/// <summary>
/// Determines whether the current DependencyObjectType derives from the
/// specified DependencyObjectType
/// </summary>
/// <param name="dependencyObjectType">The DependencyObjectType to compare
/// with the current DependencyObjectType</param>
/// <returns>
/// true if the DependencyObjectType represented by the dType parameter and the
/// current DependencyObjectType represent classes, and the class represented
/// by the current DependencyObjectType derives from the class represented by
/// c; otherwise, false. This method also returns false if dType and the
/// current Type represent the same class.
/// </returns>
public bool IsSubclassOf(DependencyObjectType dependencyObjectType)
{
// Check for null and return false, since this type is never a subclass of null.
if (dependencyObjectType != null)
{
// A DependencyObjectType isn't considered a subclass of itself, so start with base type
DependencyObjectType dType = _baseDType;
while (dType != null)
{
if (dType.Id == dependencyObjectType.Id)
{
return(true);
}
dType = dType._baseDType;
}
}
return(false);
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
/// <summary>
/// Returns true if the dependency object passed to the method is a type,
/// subtype or implememts the interface of any of the the types contained
/// in this object.
/// </summary>
internal override bool IsBrowsable(DependencyObject d, DependencyProperty dp)
{
if (d == null)
{
throw new ArgumentNullException("d");
}
if (dp == null)
{
throw new ArgumentNullException("dp");
}
// Get the dependency object type for our target type.
// We cannot assume the user didn't do something wrong and
// feed us a type that is not a dependency object, but that is
// rare enough that it is worth the try/catch here rather than
// a double IsAssignableFrom (one here, and one in DependencyObjectType).
// We still use a flag here rather than checking for a null
// _dTargetType so that a bad property that throws won't consistently
// slow the system down with ArgumentExceptions.
if (!_dTargetTypeChecked)
{
try
{
_dTargetType = DependencyObjectType.FromSystemType(_targetType);
}
catch (ArgumentException)
{
}
_dTargetTypeChecked = true;
}
if (_dTargetType != null && _dTargetType.IsInstanceOfType(d))
{
return(true);
}
return(false);
}
// ------------------------------------------------
//
// Methods
//
// ------------------------------------------------
#region Methods
/// <summary>
/// Returns a resource for the given key type from the system resources collection.
/// </summary>
/// <param name="key">The resource id to search for.</param>
/// <returns>The resource if it exists, null otherwise.</returns>
//[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
internal static object FindThemeStyle(DependencyObjectType key)
{
// Find a cached theme style
object resource = _themeStyleCache[key];
if (resource != null)
{
// Found a cached value
if (resource == _specialNull)
{
// We cached a null, set it to a real null
return null; // Null resource found
}
return resource;
}
// Find the resource from the system resources collection
resource = FindResourceInternal(key.SystemType);
// The above read operation was lock free. Writing
// to the cache will need a lock though
lock (ThemeDictionaryLock)
{
if (resource != null)
{
// Cache the value
_themeStyleCache[key] = resource;
}
else
{
// Record nulls so we don't bother doing lookups for them later
// Any theme changes will clear these values
_themeStyleCache[key] = _specialNull;
}
}
return resource;
}
public object this[DependencyObjectType dType]
{
get
{
if (dType.Id < _entryCount)
{
return _entries[dType.Id];
}
else
{
if (_overFlow != null)
{
return _overFlow[dType];
}
return null;
}
}
set
{
if (dType.Id < _entryCount)
{
_entries[dType.Id] = value;
}
else
{
if (_overFlow == null)
{
_overFlow = new Hashtable();
}
_overFlow[dType] = value;
}
_activeDTypes.Add(dType);
}
}
public bool IsSubclassOf(DependencyObjectType dependencyObjectType)
{
return systemType.IsSubclassOf (dependencyObjectType.SystemType);
}
/// <summary>
/// Reteive metadata for a DependencyObject type described by the
/// given DependencyObjectType
/// </summary>
//CASRemoval:[StrongNameIdentityPermission(SecurityAction.LinkDemand, PublicKey = BuildInfo.WCP_PUBLIC_KEY_STRING)]
public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
{
// All static constructors for this DType and all base types have already
// been run. If no overriden metadata was provided, then look up base types.
// If no metadata found on base types, then return default
if (null != dependencyObjectType)
{
// Do we in fact have any overrides at all?
int index = _metadataMap.Count - 1;
int Id;
object value;
if (index < 0)
{
// No overrides or it's the base class
return _defaultMetadata;
}
else if (index == 0)
{
// Only 1 override
_metadataMap.GetKeyValuePair(index, out Id, out value);
// If there is overriden metadata, then there is a base class with
// lower or equal Id of this class, or this class is already a base class
// of the overridden one. Therefore dependencyObjectType won't ever
// become null before we exit the while loop
while (dependencyObjectType.Id > Id)
{
dependencyObjectType = dependencyObjectType.BaseType;
}
if (Id == dependencyObjectType.Id)
{
// Return the override
return (PropertyMetadata)value;
}
// Return default metadata
}
else
{
// We have more than 1 override for this class, so we will have to loop through
// both the overrides and the class Id
if (0 != dependencyObjectType.Id)
{
do
{
// Get the Id of the most derived class with overridden metadata
_metadataMap.GetKeyValuePair(index, out Id, out value);
--index;
// If the Id of this class is less than the override, then look for an override
// with an equal or lower Id until we run out of overrides
while ((dependencyObjectType.Id < Id) && (index >= 0))
{
_metadataMap.GetKeyValuePair(index, out Id, out value);
--index;
}
// If there is overriden metadata, then there is a base class with
// lower or equal Id of this class, or this class is already a base class
// of the overridden one. Therefore dependencyObjectType won't ever
// become null before we exit the while loop
while (dependencyObjectType.Id > Id)
{
dependencyObjectType = dependencyObjectType.BaseType;
}
if (Id == dependencyObjectType.Id)
{
// Return the override
return (PropertyMetadata)value;
}
}
while (index >= 0);
}
}
}
return _defaultMetadata;
}
// The caller must wrap this routine inside a locked block.
// This recursive routine manipulates the static hashtable DTypeFromCLRType
// and it must not be allowed to do this across multiple threads
// simultaneously.
private static DependencyObjectType FromSystemTypeRecursive(Type systemType)
{
DependencyObjectType dType;
// Map a CLR Type to a DependencyObjectType
if (!DTypeFromCLRType.TryGetValue(systemType, out dType))
{
// No DependencyObjectType found, create
dType = new DependencyObjectType();
// Store CLR type
dType._systemType = systemType;
// Store reverse mapping
DTypeFromCLRType[systemType] = dType;
// Establish base DependencyObjectType and base property count
if (systemType != typeof(DependencyObject))
{
// Get base type
dType._baseDType = FromSystemTypeRecursive(systemType.BaseType);
}
// Store DependencyObjectType zero-based Id
dType._id = DTypeCount++;
}
return dType;
}
/// <summary>
/// Initializes the <see cref="LineSeries2D"/> class.
/// </summary>
static LineSeries2D()
{
dependencyType = DependencyObjectType.FromSystemType(typeOfThis);
}
public PropertyMetadata GetMetadata(DependencyObjectType type)
{
return GetMetadata(type.SystemType);
}
/// <summary>
/// Initializes the <see cref="SeriesPoint"/> class.
/// </summary>
static SeriesPoint()
{
dependencyType = DependencyObjectType.FromSystemType(typeOfThis);
}
static ContentControl()
{
FrameworkElement.DefaultStyleKeyProperty.OverrideMetadata(typeof (ContentControl), (PropertyMetadata) new FrameworkPropertyMetadata((object) typeof (ContentControl)));
ContentControl._dType = DependencyObjectType.FromSystemTypeInternal(typeof (ContentControl));
}
/// <summary>
/// Parameter validation for OverrideMetadata, includes code to force
/// all base classes of "forType" to register their metadata so we know
/// what we are overriding.
/// </summary>
private void SetupOverrideMetadata(
Type forType,
PropertyMetadata typeMetadata,
out DependencyObjectType dType,
out PropertyMetadata baseMetadata )
{
if (forType == null)
{
throw new ArgumentNullException("forType");
}
if (typeMetadata == null)
{
throw new ArgumentNullException("typeMetadata");
}
if (typeMetadata.Sealed)
{
throw new ArgumentException(SR.Get(SRID.TypeMetadataAlreadyInUse));
}
if (!typeof(DependencyObject).IsAssignableFrom(forType))
{
throw new ArgumentException(SR.Get(SRID.TypeMustBeDependencyObjectDerived, forType.Name));
}
// Ensure default value is a correct value (if it was supplied,
// otherwise, the default value will be taken from the base metadata
// which was already validated)
if (typeMetadata.IsDefaultValueModified)
{
// Will throw ArgumentException if fails.
ValidateMetadataDefaultValue( typeMetadata, PropertyType, Name, ValidateValueCallback );
}
// Force all base classes to register their metadata
dType = DependencyObjectType.FromSystemType(forType);
// Get metadata for the base type
baseMetadata = GetMetadata(dType.BaseType);
// Make sure overriding metadata is the same type or derived type of
// the base metadata
if (!baseMetadata.GetType().IsAssignableFrom(typeMetadata.GetType()))
{
throw new ArgumentException(SR.Get(SRID.OverridingMetadataDoesNotMatchBaseMetadataType));
}
}
/// <summary>
/// After parameters have been validated for OverrideMetadata, this
/// method is called to actually update the data structures.
/// </summary>
private void ProcessOverrideMetadata(
Type forType,
PropertyMetadata typeMetadata,
DependencyObjectType dType,
PropertyMetadata baseMetadata)
{
// Store per-Type metadata for this property. Locks only on Write.
// Datastructure guaranteed to be valid for non-locking readers
lock (Synchronized)
{
if (DependencyProperty.UnsetValue == _metadataMap[dType.Id])
{
_metadataMap[dType.Id] = typeMetadata;
}
else
{
throw new ArgumentException(SR.Get(SRID.TypeMetadataAlreadyRegistered, forType.Name));
}
}
// Merge base's metadata into this metadata
// CALLBACK
typeMetadata.InvokeMerge(baseMetadata, this);
// Type metadata may no longer change (calls OnApply)
typeMetadata.Seal(this, forType);
if (typeMetadata.IsInherited)
{
_packedData |= Flags.IsPotentiallyInherited;
}
if (typeMetadata.DefaultValueWasSet() && (typeMetadata.DefaultValue != DefaultMetadata.DefaultValue))
{
_packedData |= Flags.IsDefaultValueChanged;
}
if (typeMetadata.UsingDefaultValueFactory)
{
_packedData |= Flags.IsPotentiallyUsingDefaultValueFactory;
}
}
static AnimatedImage()
{
dependencyType = DependencyObjectType.FromSystemType(typeOfThis);
}
private void ProcessOverrideMetadata(Type forType, PropertyMetadata typeMetadata, DependencyObjectType dType, PropertyMetadata baseMetadata)
{
lock (Synchronized) {
if (UnsetValue != _metadataMap[dType.Id])
{
throw new ArgumentException(SR.Get("TypeMetadataAlreadyRegistered", forType.Name));
}
_metadataMap[dType.Id] = typeMetadata;
}
typeMetadata.InvokeMerge(baseMetadata, this);
typeMetadata.Seal(this, forType);
if (typeMetadata.IsInherited)
{
_packedData |= Flags.IsPotentiallyInherited;
}
if (typeMetadata.DefaultValueWasSet() && typeMetadata.DefaultValue != DefaultMetadata.DefaultValue)
{
_packedData |= Flags.IsDefaultValueChanged;
}
if (typeMetadata.UsingDefaultValueFactory)
{
_packedData |= Flags.IsPotentiallyUsingDefaultValueFactory;
}
}
private void SetupOverrideMetadata(Type forType, PropertyMetadata typeMetadata, out DependencyObjectType dType, out PropertyMetadata baseMetadata)
{
if (forType == null)
{
throw new ArgumentNullException("forType");
}
if (typeMetadata == null)
{
throw new ArgumentNullException("typeMetadata");
}
if (typeMetadata.Sealed)
{
throw new ArgumentException(SR.Get("TypeMetadataAlreadyInUse"));
}
if (!typeof(DependencyObject).IsAssignableFrom(forType))
{
throw new ArgumentException(SR.Get("TypeMustBeDependencyObjectDerived", forType.Name));
}
if (typeMetadata.IsDefaultValueModified)
{
ValidateMetadataDefaultValue(typeMetadata, PropertyType, Name, ValidateValueCallback);
}
dType = DependencyObjectType.FromSystemType(forType);
baseMetadata = GetMetadata(dType.BaseType);
if (!baseMetadata.GetType().IsAssignableFrom(typeMetadata.GetType()))
{
throw new ArgumentException(SR.Get("OverridingMetadataDoesNotMatchBaseMetadataType"));
}
}
// Token: 0x06000C59 RID: 3161 RVA: 0x0002DFDC File Offset: 0x0002C1DC
internal FrugalObjectList <DependencyProperty> CreateParentInheritableProperties(DependencyObject d, DependencyObject parent, bool isAddOperation)
{
if (parent == null)
{
return(new FrugalObjectList <DependencyProperty>(0));
}
DependencyObjectType dependencyObjectType = d.DependencyObjectType;
EffectiveValueEntry[] array = null;
uint num = 0U;
uint num2 = 0U;
if (!parent.IsSelfInheritanceParent)
{
DependencyObject inheritanceParent = parent.InheritanceParent;
if (inheritanceParent != null)
{
array = inheritanceParent.EffectiveValues;
num = inheritanceParent.EffectiveValuesCount;
num2 = inheritanceParent.InheritableEffectiveValuesCount;
}
}
else
{
array = parent.EffectiveValues;
num = parent.EffectiveValuesCount;
num2 = parent.InheritableEffectiveValuesCount;
}
FrugalObjectList <DependencyProperty> frugalObjectList = new FrugalObjectList <DependencyProperty>((int)num2);
if (num2 == 0U)
{
return(frugalObjectList);
}
this._rootInheritableValues = new InheritablePropertyChangeInfo[num2];
int num3 = 0;
FrameworkObject frameworkObject = new FrameworkObject(parent);
for (uint num4 = 0U; num4 < num; num4 += 1U)
{
EffectiveValueEntry effectiveValueEntry = array[(int)num4];
DependencyProperty dependencyProperty = DependencyProperty.RegisteredPropertyList.List[effectiveValueEntry.PropertyIndex];
if (dependencyProperty != null && dependencyProperty.IsPotentiallyInherited)
{
PropertyMetadata metadata = dependencyProperty.GetMetadata(parent.DependencyObjectType);
if (metadata != null && metadata.IsInherited)
{
FrameworkPropertyMetadata frameworkPropertyMetadata = (FrameworkPropertyMetadata)metadata;
if (!TreeWalkHelper.SkipNow(frameworkObject.InheritanceBehavior) || frameworkPropertyMetadata.OverridesInheritanceBehavior)
{
frugalObjectList.Add(dependencyProperty);
EffectiveValueEntry valueEntry = d.GetValueEntry(d.LookupEntry(dependencyProperty.GlobalIndex), dependencyProperty, dependencyProperty.GetMetadata(dependencyObjectType), RequestFlags.DeferredReferences);
EffectiveValueEntry newEntry;
if (isAddOperation)
{
newEntry = effectiveValueEntry;
if (newEntry.BaseValueSourceInternal != BaseValueSourceInternal.Default || newEntry.HasModifiers)
{
newEntry = newEntry.GetFlattenedEntry(RequestFlags.FullyResolved);
newEntry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited;
}
}
else
{
newEntry = default(EffectiveValueEntry);
}
this._rootInheritableValues[num3++] = new InheritablePropertyChangeInfo(d, dependencyProperty, valueEntry, newEntry);
if ((ulong)num2 == (ulong)((long)num3))
{
break;
}
}
}
}
}
return(frugalObjectList);
}
// Returns the list of class listeners for the given
// DType and RoutedEvent
// NOTE: Returns null if no matches found
// Helper method for GetClassListeners
// Invoked when trying to build the event route
// as well as when registering a new class handler
internal static RoutedEventHandlerInfoList GetDTypedClassListeners(
DependencyObjectType dType,
RoutedEvent routedEvent,
out ClassHandlersStore classListenersLists,
out int index)
{
// Get the ClassHandlersStore for the given DType
classListenersLists = (ClassHandlersStore)_dTypedClassListeners[dType];
RoutedEventHandlerInfoList handlers;
if (classListenersLists != null)
{
// Get the handlers for the given DType and RoutedEvent
index = classListenersLists.GetHandlersIndex(routedEvent);
if (index != -1)
{
handlers = classListenersLists.GetExistingHandlers(index);
return handlers;
}
}
lock (Synchronized)
{
// Search the DTypeMap for the list of matching RoutedEventHandlerInfo
handlers = GetUpdatedDTypedClassListeners(dType, routedEvent, out classListenersLists, out index);
}
return handlers;
}
public PropertyMetadata GetMetadata(DependencyObjectType type)
{
return(GetMetadata(type.SystemType));
}
// Returns the list of class listeners for the given
// DType and RoutedEvent
// NOTE: Returns null if no matches found
// Helper method for GetClassListeners
// Invoked only when trying to build the event route
internal static RoutedEventHandlerInfoList GetDTypedClassListeners(
DependencyObjectType dType,
RoutedEvent routedEvent)
{
ClassHandlersStore classListenersLists;
int index;
// Class Forwarded
return GetDTypedClassListeners(dType, routedEvent, out classListenersLists, out index);
}
private void RemovePropertyChanged(DependencyObjectType type, DependencyPropertyChangedEventHandler handler)
{
if (type != doType && !type.IsSubclassOf(doType))
throw new ArgumentException();
handlers.RemoveHandler(type, handler);
}
public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
{
if (metadataByType.ContainsKey (dependencyObjectType.SystemType))
return metadataByType[dependencyObjectType.SystemType];
return null;
}
/// <summary>
/// Reteive metadata for a DependencyObject type described by the
/// given DependencyObjectType
/// </summary>
public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
{
// All static constructors for this DType and all base types have already
// been run. If no overriden metadata was provided, then look up base types.
// If no metadata found on base types, then return default
if (null != dependencyObjectType)
{
// Do we in fact have any overrides at all?
int index = _metadataMap.Count - 1;
int Id;
object value;
if (index < 0)
{
// No overrides or it's the base class
return(_defaultMetadata);
}
else if (index == 0)
{
// Only 1 override
_metadataMap.GetKeyValuePair(index, out Id, out value);
// If there is overriden metadata, then there is a base class with
// lower or equal Id of this class, or this class is already a base class
// of the overridden one. Therefore dependencyObjectType won't ever
// become null before we exit the while loop
while (dependencyObjectType.Id > Id)
{
dependencyObjectType = dependencyObjectType.BaseType;
}
if (Id == dependencyObjectType.Id)
{
// Return the override
return((PropertyMetadata)value);
}
// Return default metadata
}
else
{
// We have more than 1 override for this class, so we will have to loop through
// both the overrides and the class Id
if (0 != dependencyObjectType.Id)
{
do
{
// Get the Id of the most derived class with overridden metadata
_metadataMap.GetKeyValuePair(index, out Id, out value);
--index;
// If the Id of this class is less than the override, then look for an override
// with an equal or lower Id until we run out of overrides
while ((dependencyObjectType.Id < Id) && (index >= 0))
{
_metadataMap.GetKeyValuePair(index, out Id, out value);
--index;
}
// If there is overriden metadata, then there is a base class with
// lower or equal Id of this class, or this class is already a base class
// of the overridden one. Therefore dependencyObjectType won't ever
// become null before we exit the while loop
while (dependencyObjectType.Id > Id)
{
dependencyObjectType = dependencyObjectType.BaseType;
}
if (Id == dependencyObjectType.Id)
{
// Return the override
return((PropertyMetadata)value);
}
}while (index >= 0);
}
}
}
return(_defaultMetadata);
}
// Returns a RoutedEvents that match
// the name and ownerType input params
// If not found returns null
internal static RoutedEvent GetRoutedEventFromName(
string name,
Type ownerType,
bool includeSupers)
{
if ((ownerType == typeof(DependencyObject)) || ownerType.IsSubclassOf(typeof(DependencyObject)))
{
// Search DTypeMap
DependencyObjectType dType = DependencyObjectType.FromSystemTypeInternal(ownerType);
while (dType != null)
{
// Get the ItemList of RoutedEvents for the given DType
FrugalObjectList <RoutedEvent> ownerRoutedEventList = (FrugalObjectList <RoutedEvent>)_dTypedRoutedEventList[dType];
if (ownerRoutedEventList != null)
{
// Check for RoutedEvent with matching name in the ItemList
for (int i = 0; i < ownerRoutedEventList.Count; i++)
{
RoutedEvent routedEvent = ownerRoutedEventList[i];
if (routedEvent.Name.Equals(name))
{
// Return if found match
return(routedEvent);
}
}
}
// If not found match yet check for BaseType if specified to do so
dType = includeSupers ? dType.BaseType : null;
}
}
else
{
// Search Hashtable
while (ownerType != null)
{
// Get the ItemList of RoutedEvents for the given OwnerType
FrugalObjectList <RoutedEvent> ownerRoutedEventList = (FrugalObjectList <RoutedEvent>)_ownerTypedRoutedEventList[ownerType];
if (ownerRoutedEventList != null)
{
// Check for RoutedEvent with matching name in the ItemList
for (int i = 0; i < ownerRoutedEventList.Count; i++)
{
RoutedEvent routedEvent = ownerRoutedEventList[i];
if (routedEvent.Name.Equals(name))
{
// Return if found match
return(routedEvent);
}
}
}
// If not found match yet check for BaseType if specified to do so
ownerType = includeSupers?ownerType.BaseType : null;
}
}
// No match found
return(null);
}
/// <summary>
/// Initializes the <see cref="Chart"/> class.
/// </summary>
static Chart()
{
DefaultStyleKeyProperty.OverrideMetadata(typeof(Chart), new FrameworkPropertyMetadata(typeof(Chart)));
dependencyType = DependencyObjectType.FromSystemType(typeOfThis);
}
// Helper method for GetDTypedClassListeners
// Returns updated list of class listeners for the given
// DType and RoutedEvent
// NOTE: Returns null if no matches found
// Invoked when trying to build the event route
// as well as when registering a new class handler
private static RoutedEventHandlerInfoList GetUpdatedDTypedClassListeners(
DependencyObjectType dType,
RoutedEvent routedEvent,
out ClassHandlersStore classListenersLists,
out int index)
{
// Get the ClassHandlersStore for the given DType
classListenersLists = (ClassHandlersStore)_dTypedClassListeners[dType];
RoutedEventHandlerInfoList handlers;
if (classListenersLists != null)
{
// Get the handlers for the given DType and RoutedEvent
index = classListenersLists.GetHandlersIndex(routedEvent);
if (index != -1)
{
handlers = classListenersLists.GetExistingHandlers(index);
return(handlers);
}
}
// Since matching handlers were not found at this level
// browse base classes to check for registered class handlers
DependencyObjectType tempDType = dType;
ClassHandlersStore tempClassListenersLists = null;
RoutedEventHandlerInfoList tempHandlers = null;
int tempIndex = -1;
while (tempIndex == -1 && tempDType.Id != _dependencyObjectType.Id)
{
tempDType = tempDType.BaseType;
tempClassListenersLists = (ClassHandlersStore)_dTypedClassListeners[tempDType];
if (tempClassListenersLists != null)
{
// Get the handlers for the DType and RoutedEvent
tempIndex = tempClassListenersLists.GetHandlersIndex(routedEvent);
if (tempIndex != -1)
{
tempHandlers = tempClassListenersLists.GetExistingHandlers(tempIndex);
}
}
}
if (classListenersLists == null)
{
if (dType.SystemType == typeof(UIElement) || dType.SystemType == typeof(ContentElement))
{
classListenersLists = new ClassHandlersStore(80); // Based on the number of class handlers for these classes
}
else
{
classListenersLists = new ClassHandlersStore(1);
}
_dTypedClassListeners[dType] = classListenersLists;
}
index = classListenersLists.CreateHandlersLink(routedEvent, tempHandlers);
return(tempHandlers);
}
// Helper method for GetDTypedClassListeners
// Returns updated list of class listeners for the given
// DType and RoutedEvent
// NOTE: Returns null if no matches found
// Invoked when trying to build the event route
// as well as when registering a new class handler
private static RoutedEventHandlerInfoList GetUpdatedDTypedClassListeners(
DependencyObjectType dType,
RoutedEvent routedEvent,
out ClassHandlersStore classListenersLists,
out int index)
{
// Get the ClassHandlersStore for the given DType
classListenersLists = (ClassHandlersStore)_dTypedClassListeners[dType];
RoutedEventHandlerInfoList handlers;
if (classListenersLists != null)
{
// Get the handlers for the given DType and RoutedEvent
index = classListenersLists.GetHandlersIndex(routedEvent);
if (index != -1)
{
handlers = classListenersLists.GetExistingHandlers(index);
return handlers;
}
}
// Since matching handlers were not found at this level
// browse base classes to check for registered class handlers
DependencyObjectType tempDType = dType;
ClassHandlersStore tempClassListenersLists = null;
RoutedEventHandlerInfoList tempHandlers = null;
int tempIndex = -1;
while (tempIndex == -1 && tempDType.Id != _dependencyObjectType.Id)
{
tempDType = tempDType.BaseType;
tempClassListenersLists = (ClassHandlersStore)_dTypedClassListeners[tempDType];
if (tempClassListenersLists != null)
{
// Get the handlers for the DType and RoutedEvent
tempIndex = tempClassListenersLists.GetHandlersIndex(routedEvent);
if (tempIndex != -1)
{
tempHandlers = tempClassListenersLists.GetExistingHandlers(tempIndex);
}
}
}
if (classListenersLists == null)
{
if (dType.SystemType == typeof(UIElement) || dType.SystemType == typeof(ContentElement))
{
classListenersLists = new ClassHandlersStore(80); // Based on the number of class handlers for these classes
}
else
{
classListenersLists = new ClassHandlersStore(1);
}
_dTypedClassListeners[dType] = classListenersLists;
}
index = classListenersLists.CreateHandlersLink(routedEvent, tempHandlers);
return tempHandlers;
}
/// <summary>
/// Determines whether the current DependencyObjectType derives from the
/// specified DependencyObjectType
/// </summary>
/// <param name="dependencyObjectType">The DependencyObjectType to compare
/// with the current DependencyObjectType</param>
/// <returns>
/// true if the DependencyObjectType represented by the dType parameter and the
/// current DependencyObjectType represent classes, and the class represented
/// by the current DependencyObjectType derives from the class represented by
/// c; otherwise, false. This method also returns false if dType and the
/// current Type represent the same class.
/// </returns>
public bool IsSubclassOf(DependencyObjectType dependencyObjectType)
{
// Check for null and return false, since this type is never a subclass of null.
if (dependencyObjectType != null)
{
// A DependencyObjectType isn't considered a subclass of itself, so start with base type
DependencyObjectType dType = _baseDType;
while (dType != null)
{
if (dType.Id == dependencyObjectType.Id)
{
return true;
}
dType = dType._baseDType;
}
}
return false;
}
//
// This method
// 1. Is called from AncestorChange InvalidateTree.
// 2. It is used to create the InheritableProperties on the given node.
// 3. It also accumulates oldValues for the inheritable properties that are about to be invalidated
//
internal FrugalObjectList <DependencyProperty> CreateParentInheritableProperties(
DependencyObject d,
DependencyObject parent,
bool isAddOperation)
{
Debug.Assert(d != null, "Must have non-null current node");
if (parent == null)
{
return(new FrugalObjectList <DependencyProperty>(0));
}
DependencyObjectType treeObjDOT = d.DependencyObjectType;
// See if we have a cached value.
EffectiveValueEntry[] parentEffectiveValues = null;
uint parentEffectiveValuesCount = 0;
uint inheritablePropertiesCount = 0;
// If inheritable properties aren't cached on you then use the effective
// values cache on the parent to discover those inherited properties that
// may need to be invalidated on the children nodes.
if (!parent.IsSelfInheritanceParent)
{
DependencyObject inheritanceParent = parent.InheritanceParent;
if (inheritanceParent != null)
{
parentEffectiveValues = inheritanceParent.EffectiveValues;
parentEffectiveValuesCount = inheritanceParent.EffectiveValuesCount;
inheritablePropertiesCount = inheritanceParent.InheritableEffectiveValuesCount;
}
}
else
{
parentEffectiveValues = parent.EffectiveValues;
parentEffectiveValuesCount = parent.EffectiveValuesCount;
inheritablePropertiesCount = parent.InheritableEffectiveValuesCount;
}
FrugalObjectList <DependencyProperty> inheritableProperties = new FrugalObjectList <DependencyProperty>((int)inheritablePropertiesCount);
if (inheritablePropertiesCount == 0)
{
return(inheritableProperties);
}
_rootInheritableValues = new InheritablePropertyChangeInfo[(int)inheritablePropertiesCount];
int inheritableIndex = 0;
FrameworkObject foParent = new FrameworkObject(parent);
for (uint i = 0; i < parentEffectiveValuesCount; i++)
{
// Add all the inheritable properties from the effectiveValues
// cache to the TreeStateCache on the parent
EffectiveValueEntry entry = parentEffectiveValues[i];
DependencyProperty dp = DependencyProperty.RegisteredPropertyList.List[entry.PropertyIndex];
// There are UncommonFields also stored in the EffectiveValues cache. We need to exclude those.
if ((dp != null) && dp.IsPotentiallyInherited)
{
PropertyMetadata metadata = dp.GetMetadata(parent.DependencyObjectType);
if (metadata != null && metadata.IsInherited)
{
Debug.Assert(!inheritableProperties.Contains(dp), "EffectiveValues cache must not contains duplicate entries for the same DP");
FrameworkPropertyMetadata fMetadata = (FrameworkPropertyMetadata)metadata;
// Children do not need to inherit properties across a tree boundary
// unless the property is set to override this behavior.
if (!TreeWalkHelper.SkipNow(foParent.InheritanceBehavior) || fMetadata.OverridesInheritanceBehavior)
{
inheritableProperties.Add(dp);
EffectiveValueEntry oldEntry;
EffectiveValueEntry newEntry;
oldEntry = d.GetValueEntry(
d.LookupEntry(dp.GlobalIndex),
dp,
dp.GetMetadata(treeObjDOT),
RequestFlags.DeferredReferences);
if (isAddOperation)
{
// set up the new value
newEntry = entry;
if ((newEntry.BaseValueSourceInternal != BaseValueSourceInternal.Default) || newEntry.HasModifiers)
{
newEntry = newEntry.GetFlattenedEntry(RequestFlags.FullyResolved);
newEntry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited;
}
}
else
{
newEntry = new EffectiveValueEntry();
}
_rootInheritableValues[inheritableIndex++] =
new InheritablePropertyChangeInfo(d, dp, oldEntry, newEntry);
if (inheritablePropertiesCount == inheritableIndex)
{
// no more inheritable properties, bail early
break;
}
}
}
}
}
return(inheritableProperties);
}
/// <summary>
/// Texts the box.
/// </summary>
static NumericTextBox()
{
dependencyType = DependencyObjectType.FromSystemType(typeOfThis);
}
[FriendAccessAllowed] // Built into Base, also used by Core & Framework.
internal object GetDefaultValue(DependencyObjectType dependencyObjectType)
{
if (!IsDefaultValueChanged)
{
return DefaultMetadata.DefaultValue;
}
return GetMetadata(dependencyObjectType).DefaultValue;
}
public bool IsSubclassOf(DependencyObjectType dependencyObjectType)
{
return(systemType.IsSubclassOf(dependencyObjectType.SystemType));
}
internal static void SetDependencyObjectType(this DependencyObject element, DependencyObjectType type)
{
element.SetValue(RadRoutedEventHelper.DependencyObjectTypeProperty, type);
}
