public GetMetadata ( System.Windows.DependencyObjectType dependencyObjectType ) : System.Windows.PropertyMetadata | ||
dependencyObjectType | System.Windows.DependencyObjectType | |
return | System.Windows.PropertyMetadata |
/// <summary> /// Creates a new dependency property descriptor. A note on perf: We don't /// pass the property descriptor down as the default member descriptor here. Doing /// so takes the attributes off of the property descriptor, which can be costly if they /// haven't been accessed yet. Instead, we wait until someone needs to access our /// Attributes property and demand create the attributes at that time. /// </summary> internal DependencyObjectPropertyDescriptor(DependencyProperty dp, Type ownerType) : base(string.Concat(dp.OwnerType.Name, ".", dp.Name), null) { _dp = dp; _componentType = ownerType; _metadata = _dp.GetMetadata(ownerType); }
// Token: 0x06000C65 RID: 3173 RVA: 0x0002E3C0 File Offset: 0x0002C5C0 internal static FrugalObjectList <DependencyProperty> InvalidateTreeDependentProperties(TreeChangeInfo info, FrameworkElement fe, FrameworkContentElement fce, Style selfStyle, Style selfThemeStyle, ref ChildRecord childRecord, bool isChildRecordValid, bool hasStyleChanged, bool isSelfInheritanceParent, bool wasSelfInheritanceParent) { DependencyObject dependencyObject = (fe != null) ? fe : fce; FrameworkObject frameworkObject = new FrameworkObject(fe, fce); FrugalObjectList <DependencyProperty> frugalObjectList = info.InheritablePropertiesStack.Peek(); int num = (frugalObjectList != null) ? frugalObjectList.Count : 0; FrugalObjectList <DependencyProperty> frugalObjectList2 = null; if (TreeWalkHelper.HasChildren(fe, fce)) { frugalObjectList2 = new FrugalObjectList <DependencyProperty>(num); } info.ResetInheritableValueIndexer(); for (int i = 0; i < num; i++) { DependencyProperty dependencyProperty = frugalObjectList[i]; PropertyMetadata metadata = dependencyProperty.GetMetadata(dependencyObject); if (metadata.IsInherited) { FrameworkPropertyMetadata frameworkPropertyMetadata = (FrameworkPropertyMetadata)metadata; bool flag = TreeWalkHelper.InvalidateTreeDependentProperty(info, dependencyObject, ref frameworkObject, dependencyProperty, frameworkPropertyMetadata, selfStyle, selfThemeStyle, ref childRecord, isChildRecordValid, hasStyleChanged, isSelfInheritanceParent, wasSelfInheritanceParent); if (flag && frugalObjectList2 != null && (!TreeWalkHelper.SkipNow(frameworkObject.InheritanceBehavior) || frameworkPropertyMetadata.OverridesInheritanceBehavior)) { frugalObjectList2.Add(dependencyProperty); } } } return(frugalObjectList2); }
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); }
public void CoerceValue(DependencyProperty dp) { PropertyMetadata pm = dp.GetMetadata(this); if (pm.CoerceValueCallback != null) { pm.CoerceValueCallback(this, GetValue(dp)); } }
//------------------------------------------------------ // // Constructors // //----------------------------------------------------- #region Constructors /// <summary> /// Creates a new dependency property descriptor. A note on perf: We don't /// pass the property descriptor down as the default member descriptor here. Doing /// so gets the attributes off of the property descriptor, which can be costly if they /// haven't been accessed yet. Instead, we wait until someone needs to access our /// Attributes property and demand create the attributes at that time. /// </summary> private DependencyPropertyDescriptor(PropertyDescriptor property, string name, Type componentType, DependencyProperty dp, bool isAttached) : base(name, null) { Debug.Assert(property != null || !isAttached, "Demand-load of property descriptor is only supported for direct properties"); _property = property; _componentType = componentType; _dp = dp; _isAttached = isAttached; _metadata = _dp.GetMetadata(componentType); }
// http://www.64bit-world.com/forums/microsoft-public-developer-winfx-avalon/10124-xamlpad-exe-nullreferencexception-winfx-ctp-sept.html public object GetValue(DependencyProperty property) { PropertyMetadata metadata = property.GetMetadata(this.GetType()); if (metadata.GetValueOverride != null) { return(metadata.GetValueOverride(this)); } return(GetValueCommon(property, metadata)); }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors /// <summary> /// Creates a new dependency property descriptor. A note on perf: We don't /// pass the property descriptor down as the default member descriptor here. Doing /// so takes the attributes off of the property descriptor, which can be costly if they /// haven't been accessed yet. Instead, we wait until someone needs to access our /// Attributes property and demand create the attributes at that time. /// </summary> internal DependencyObjectPropertyDescriptor(PropertyDescriptor property, DependencyProperty dp, Type objectType) : base(dp.Name, null) { _property = property; _dp = dp; Debug.Assert(property != null && dp != null); Debug.Assert(!(property is DependencyObjectPropertyDescriptor), "Wrapping a DP in a DP"); _componentType = property.ComponentType; _metadata = _dp.GetMetadata(objectType); }
private IDependencyPropertyValueEntry GetInitializedValueEntry(DependencyProperty dependencyProperty) { IDependencyPropertyValueEntry entry; if (!entries.TryGetValue(dependencyProperty, out entry)) { entry = CreateDependencyPropertyValueEntry(dependencyProperty, dependencyProperty.GetMetadata(GetType())); entries.Add(dependencyProperty, entry); } return(entry); }
// Token: 0x06000C71 RID: 3185 RVA: 0x0002EDAC File Offset: 0x0002CFAC internal static bool IsInheritanceNode(FrameworkContentElement fce, DependencyProperty dp, out InheritanceBehavior inheritanceBehavior) { inheritanceBehavior = InheritanceBehavior.Default; FrameworkPropertyMetadata frameworkPropertyMetadata = dp.GetMetadata(fce.DependencyObjectType) as FrameworkPropertyMetadata; if (frameworkPropertyMetadata != null) { if (fce.InheritanceBehavior != InheritanceBehavior.Default && !frameworkPropertyMetadata.OverridesInheritanceBehavior) { inheritanceBehavior = fce.InheritanceBehavior; } return(frameworkPropertyMetadata.Inherits); } return(false); }
// create dependency property entry and set its default and initial inherited value private IDependencyPropertyValueEntry CreateDependencyPropertyValueEntry(DependencyProperty dependencyProperty) { IDependencyPropertyValueEntry entry = new DependencyPropertyValueEntry(this, dependencyProperty); PropertyMetadata propertyMetadata = dependencyProperty.GetMetadata(GetType()); if (propertyMetadata.CoerceValueCallback != null) { entry = new CoercedDependencyPropertyValueEntry(entry, this, propertyMetadata.CoerceValueCallback); } entry.SetBaseValue((int)BaseValueSource.Default, propertyMetadata.DefaultValue); entry.ValueChanged += (sender, e) => RaisePropertyChanged(new DependencyPropertyChangedEventArgs(dependencyProperty, e.OldValue, e.NewValue)); return(entry); }
public DependencyPropertyValueEntry(DependencyObject dependencyObject, DependencyProperty dependencyProperty) { this.dependencyProperty = dependencyProperty; this.defaultValue = dependencyProperty.GetMetadata(dependencyObject.GetType()).DefaultValue; observableValue = new ObservableValue(); observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e); baseValues = new object[BaseValuePriorities]; for (int i = 0; i < baseValues.Length; i++) { baseValues[i] = ObservableValue.UnsetValue; } currentValue = ObservableValue.UnsetValue; animationValue = ObservableValue.UnsetValue; }
public ValueSource GetValueSource(DependencyProperty dependencyProperty) { IDependencyPropertyValueEntry entry; if (entries.TryGetValue(dependencyProperty, out entry)) { return(new ValueSource( (BaseValueSource)entry.GetBaseValuePriority(), entry.GetBaseValue(false) is IExpression || entry.GetCurrentValue(false) is IExpression, entry.GetCurrentValue(true) != ObservableValue.UnsetValue, entry.GetAnimationValue(true) != ObservableValue.UnsetValue, (entry is CoercedDependencyPropertyValueEntry) && ((CoercedDependencyPropertyValueEntry)entry).IsCoerced)); } PropertyMetadata propertyMetadata = dependencyProperty.GetMetadata(GetType()); BaseValueSource baseValueSource = propertyMetadata.Inherits && inheritanceParent != null ? BaseValueSource.Inherited : BaseValueSource.Default; return(new ValueSource(baseValueSource, false, false, false, false)); }
public AttachedBinding(DependencyObject target, FrameworkElement attachTarget, DependencyProperty bindingProperty, Type bindingType) { // basic checks if (target == null) throw new ArgumentNullException("target"); if (attachTarget == null) throw new ArgumentNullException("attachTarget"); if (bindingProperty == null) throw new ArgumentNullException("bindingProperty"); if (bindingType == null) throw new ArgumentNullException("bindingType"); // we save the reference to the source _target = new WeakReference(target); _attachTarget = new WeakReference(attachTarget); _bindingProperty = bindingProperty; // we get the default value object _defValue = bindingProperty.GetMetadata(bindingType).DefaultValue; // we attach the dp if (attachTarget != null) { // we create the attached property _attachedProperty = DependencyProperty.RegisterAttached(string.Format(DP_NAME_FROMAT, _indexer++), bindingType, attachTarget.GetType(), new PropertyMetadata(_defValue, OnPropertyChanged)); } else { attachTarget.Loaded += (s, e) => { // we create the binding property _attachedProperty = DependencyProperty.RegisterAttached( string.Format(DP_NAME_FROMAT, _indexer++), bindingType, attachTarget.GetType(), new PropertyMetadata(_defValue, OnPropertyChanged)); // and we if have binding then if (_binding != null) SetBinding(_binding); }; } }
public object GetValue(DependencyProperty dependencyProperty) { IDependencyPropertyValueEntry entry; if (!entries.TryGetValue(dependencyProperty, out entry)) { PropertyMetadata propertyMetadata = dependencyProperty.GetMetadata(GetType()); // no need to create a new entry if the value is not inherited or coerced if (!propertyMetadata.Inherits && (propertyMetadata.CoerceValueCallback == null || !dependencyProperty.IsAttached && !dependencyProperty.IsContainedBy(GetType()))) { return(propertyMetadata.DefaultValue); } entry = CreateDependencyPropertyValueEntry(dependencyProperty, propertyMetadata); entries.Add(dependencyProperty, entry); } return(entry.Value); }
public void SetValue(DependencyProperty property, object value) { PropertyMetadata metadata = property.GetMetadata(GetType()); if (metadata != null) { if (metadata.ReadOnly) { throw new InvalidOperationException(string.Format("DependencyProperty '{0}' has been declared read-only", property.Name)); } if (metadata.SetValueOverride != null) { metadata.SetValueOverride(this, value); return; } } SetValueCommon(property, metadata, value); }
// Token: 0x06000C6F RID: 3183 RVA: 0x0002ED04 File Offset: 0x0002CF04 internal static bool IsInheritanceNode(DependencyObject d, DependencyProperty dp, out InheritanceBehavior inheritanceBehavior) { inheritanceBehavior = InheritanceBehavior.Default; FrameworkPropertyMetadata frameworkPropertyMetadata = dp.GetMetadata(d.DependencyObjectType) as FrameworkPropertyMetadata; if (frameworkPropertyMetadata != null) { FrameworkObject frameworkObject = new FrameworkObject(d); if (!frameworkObject.IsValid) { return(false); } if (frameworkObject.InheritanceBehavior != InheritanceBehavior.Default && !frameworkPropertyMetadata.OverridesInheritanceBehavior) { inheritanceBehavior = frameworkObject.InheritanceBehavior; } if (frameworkPropertyMetadata.Inherits) { return(true); } } return(false); }
// Token: 0x06000C6D RID: 3181 RVA: 0x0002EB78 File Offset: 0x0002CD78 private static bool OnInheritablePropertyChanged(DependencyObject d, InheritablePropertyChangeInfo info, bool visitedViaVisualTree) { DependencyProperty property = info.Property; EffectiveValueEntry oldEntry = info.OldEntry; EffectiveValueEntry newEntry = info.NewEntry; InheritanceBehavior inheritanceBehavior; bool flag = TreeWalkHelper.IsInheritanceNode(d, property, out inheritanceBehavior); bool flag2 = TreeWalkHelper.IsForceInheritedProperty(property); if (!flag || (TreeWalkHelper.SkipNext(inheritanceBehavior) && !flag2)) { return(inheritanceBehavior == InheritanceBehavior.Default || flag2); } PropertyMetadata metadata = property.GetMetadata(d); EntryIndex entryIndex = d.LookupEntry(property.GlobalIndex); if (!d.IsSelfInheritanceParent) { DependencyObject frameworkParent = FrameworkElement.GetFrameworkParent(d); InheritanceBehavior inheritanceBehavior2 = InheritanceBehavior.Default; if (frameworkParent != null) { FrameworkObject frameworkObject = new FrameworkObject(frameworkParent, true); inheritanceBehavior2 = frameworkObject.InheritanceBehavior; } if (!TreeWalkHelper.SkipNext(inheritanceBehavior) && !TreeWalkHelper.SkipNow(inheritanceBehavior2)) { d.SynchronizeInheritanceParent(frameworkParent); } if (oldEntry.BaseValueSourceInternal == BaseValueSourceInternal.Unknown) { oldEntry = EffectiveValueEntry.CreateDefaultValueEntry(property, metadata.GetDefaultValue(d, property)); } } else { oldEntry = d.GetValueEntry(entryIndex, property, metadata, RequestFlags.RawEntry); } if (BaseValueSourceInternal.Inherited >= oldEntry.BaseValueSourceInternal) { if (visitedViaVisualTree && FrameworkElement.DType.IsInstanceOfType(d)) { DependencyObject parent = LogicalTreeHelper.GetParent(d); if (parent != null) { DependencyObject parent2 = VisualTreeHelper.GetParent(d); if (parent2 != null && parent2 != parent) { return(false); } } } return((d.UpdateEffectiveValue(entryIndex, property, metadata, oldEntry, ref newEntry, false, false, OperationType.Inherit) & (UpdateResult)5) == UpdateResult.ValueChanged); } if (flag2) { newEntry = new EffectiveValueEntry(property, FullValueSource.IsCoerced); return((d.UpdateEffectiveValue(d.LookupEntry(property.GlobalIndex), property, metadata, oldEntry, ref newEntry, false, false, OperationType.Inherit) & (UpdateResult)5) == UpdateResult.ValueChanged); } return(false); }
internal static void ApplyStyleOrTemplateValue( FrameworkObject fo, DependencyProperty dp) { EffectiveValueEntry newEntry = new EffectiveValueEntry(dp); newEntry.Value = DependencyProperty.UnsetValue; if (GetValueFromStyleOrTemplate(fo, dp, ref newEntry)) { DependencyObject target = fo.DO; target.UpdateEffectiveValue( target.LookupEntry(dp.GlobalIndex), dp, dp.GetMetadata(target.DependencyObjectType), new EffectiveValueEntry() /* oldEntry */, ref newEntry, false /* coerceWithDeferredReference */, false /* coerceWithCurrentValue */, OperationType.Unknown); } }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ // Create a new BindingExpression from the given Bind description internal static BindingExpression CreateBindingExpression(DependencyObject d, DependencyProperty dp, Binding binding, BindingExpressionBase parent) { FrameworkPropertyMetadata fwMetaData = dp.GetMetadata(d.DependencyObjectType) as FrameworkPropertyMetadata; if ((fwMetaData != null && !fwMetaData.IsDataBindingAllowed) || dp.ReadOnly) throw new ArgumentException(SR.Get(SRID.PropertyNotBindable, dp.Name), "dp"); // create the BindingExpression BindingExpression bindExpr = new BindingExpression(binding, parent); bindExpr.ResolvePropertyDefaultSettings(binding.Mode, binding.UpdateSourceTrigger, fwMetaData); // Two-way Binding with an empty path makes no sense if (bindExpr.IsReflective && binding.XPath == null && (binding.Path == null || String.IsNullOrEmpty(binding.Path.Path))) throw new InvalidOperationException(SR.Get(SRID.TwoWayBindingNeedsPath)); return bindExpr; }
// // This method // 1. Is a wrapper for property engine's GetExpression method // internal static Expression GetExpression( DependencyObject d, DependencyProperty dp) { FrameworkElement fe; FrameworkContentElement fce; Helper.DowncastToFEorFCE(d, out fe, out fce, false); // temporarily mark the element as "initialized", so that we always get // the desired expression (see GetInstanceValue). bool isInitialized = (fe != null) ? fe.IsInitialized : (fce != null) ? fce.IsInitialized : true; if (!isInitialized) { if (fe != null) fe.WriteInternalFlag(InternalFlags.IsInitialized, true); else if (fce != null) fce.WriteInternalFlag(InternalFlags.IsInitialized, true); } // get the desired expression Expression result = _getExpression(d, dp, dp.GetMetadata(d.DependencyObjectType)); // restore the initialized flag if (!isInitialized) { if (fe != null) fe.WriteInternalFlag(InternalFlags.IsInitialized, false); else if (fce != null) fce.WriteInternalFlag(InternalFlags.IsInitialized, false); } return result; }
/// <summary> /// Invalidates a property /// </summary> /// <param name="dp">Dependency property</param> //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 public void InvalidateProperty(DependencyProperty dp) { // Do not allow foreign threads access. // (This is a noop if this object is not assigned to a Dispatcher.) // this.VerifyAccess(); if (dp == null) { throw new ArgumentNullException("dp"); } EffectiveValueEntry newEntry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Unknown); UpdateEffectiveValue( LookupEntry(dp.GlobalIndex), dp, dp.GetMetadata(DependencyObjectType), new EffectiveValueEntry() /* oldEntry */, ref newEntry, false /* coerceWithDeferredReference */, false /* coerceWithControlReference */, OperationType.Unknown); }
/// <summary> /// Coerce a property value /// </summary> /// <param name="dp">Dependency property</param> public void CoerceValue(DependencyProperty dp) { // Do not allow foreign threads access. // (This is a noop if this object is not assigned to a Dispatcher.) // this.VerifyAccess(); EntryIndex entryIndex = LookupEntry(dp.GlobalIndex); PropertyMetadata metadata = dp.GetMetadata(DependencyObjectType); // if the property has a coerced-with-control value, apply the coercion // to that value. This is done by simply calling SetCurrentValue. if (entryIndex.Found) { EffectiveValueEntry entry = GetValueEntry(entryIndex, dp, metadata, RequestFlags.RawEntry); if (entry.IsCoercedWithCurrentValue) { SetCurrentValue(dp, entry.ModifiedValue.CoercedValue); return; } } // IsCoerced == true && value == UnsetValue indicates that we need to re-coerce this value EffectiveValueEntry newEntry = new EffectiveValueEntry(dp, FullValueSource.IsCoerced); UpdateEffectiveValue( entryIndex, dp, metadata, new EffectiveValueEntry() /* oldEntry */, ref newEntry, false /* coerceWithDeferredReference */, false /* coerceWithCurrentValue */, OperationType.Unknown); }
/// <summary> /// Return true if the given property is not set locally or from a style /// </summary> private static bool HasDefaultOrInheritedValueImpl(DependencyObject d, DependencyProperty dp, bool checkInherited, bool ignoreModifiers) { PropertyMetadata metadata = dp.GetMetadata(d); bool hasModifiers; BaseValueSourceInternal source = d.GetValueSource(dp, metadata, out hasModifiers); if (source == BaseValueSourceInternal.Default || (checkInherited && source == BaseValueSourceInternal.Inherited)) { if (ignoreModifiers) { // ignore modifiers on FE/FCE, for back-compat if (d is FrameworkElement || d is FrameworkContentElement) { hasModifiers = false; } } // a default or inherited value might be animated or coerced. We should // return false in that case - the hasModifiers flag tests this. // (An expression modifier can't apply to a default or inherited value.) return !hasModifiers; } return false; }
/// <summary> /// Determine if the current DependencyObject is a candidate for /// producing inheritable values /// </summary> /// <remarks> /// This is called by both InvalidateTree and GetValueCore /// </remarks> internal static bool IsInheritanceNode( DependencyObject d, DependencyProperty dp, out InheritanceBehavior inheritanceBehavior) { // Assume can continue search inheritanceBehavior = InheritanceBehavior.Default; // Get Framework metadata (if exists) FrameworkPropertyMetadata metadata = dp.GetMetadata(d.DependencyObjectType) as FrameworkPropertyMetadata; // Check for correct type of metadata if (metadata != null) { FrameworkObject fo = new FrameworkObject(d); if (fo.IsValid) { // If parent is a Framework type, then check if it is at a // tree separation boundary. Stop inheritance at the boundary unless // overridden by the medata.OverridesInheritanceBehavior flag. // GetValue from Parent only if instance is not a TreeSeparator // or fmetadata.OverridesInheritanceBehavior is set to override separated tree behavior if (fo.InheritanceBehavior != InheritanceBehavior.Default && !metadata.OverridesInheritanceBehavior) { // Hit a tree boundary inheritanceBehavior = fo.InheritanceBehavior; } } else { // If not a Framework type, then, this isn't an inheritance node. // Only Framework types know how to inherit return false; } // Check if metadata is marked as inheritable if (metadata.Inherits) { return true; } } // Not a framework type with inheritable metadata return false; }
void InitializeFeaturePage(Grid grid, DependencyProperty chooserProperty, TypographyFeaturePage page) { if (page == null) { grid.Children.Clear(); grid.RowDefinitions.Clear(); } else { // Get the property value and metadata. object value = GetValue(chooserProperty); var metadata = (TypographicPropertyMetadata)chooserProperty.GetMetadata(typeof(FontChooser)); // Look up the sample text. string sampleText = (metadata.SampleTextTag != null) ? LookupString(metadata.SampleTextTag) : _defaultSampleText; if (page == _currentFeaturePage) { // Update the state of the controls. for (int i = 0; i < page.Items.Length; ++i) { // Check the radio button if it matches the current property value. if (page.Items[i].Value.Equals(value)) { var radioButton = (RadioButton)grid.Children[i * 2]; radioButton.IsChecked = true; } // Apply properties to the sample text block. var sample = (TextBlock)grid.Children[i * 2 + 1]; sample.Text = sampleText; ApplyPropertiesToObjectExcept(sample, chooserProperty); sample.SetValue(metadata.TargetProperty, page.Items[i].Value); } } else { grid.Children.Clear(); grid.RowDefinitions.Clear(); // Add row definitions. for (int i = 0; i < page.Items.Length; ++i) { var row = new RowDefinition(); row.Height = GridLength.Auto; grid.RowDefinitions.Add(row); } // Add the controls. for (int i = 0; i < page.Items.Length; ++i) { string tag = page.Items[i].Tag; var radioContent = new TextBlock(new Run(LookupString(tag))); radioContent.TextWrapping = TextWrapping.Wrap; // Add the radio button. var radioButton = new RadioButton(); radioButton.Name = tag; radioButton.Content = radioContent; radioButton.Margin = new Thickness(5.0, 0.0, 0.0, 0.0); radioButton.VerticalAlignment = VerticalAlignment.Center; Grid.SetRow(radioButton, i); grid.Children.Add(radioButton); // Check the radio button if it matches the current property value. if (page.Items[i].Value.Equals(value)) { radioButton.IsChecked = true; } // Hook up the event. radioButton.Checked += featureRadioButton_Checked; // Add the block with sample text. var sample = new TextBlock(new Run(sampleText)); sample.Margin = new Thickness(5.0, 5.0, 5.0, 0.0); sample.TextWrapping = TextWrapping.WrapWithOverflow; ApplyPropertiesToObjectExcept(sample, chooserProperty); sample.SetValue(metadata.TargetProperty, page.Items[i].Value); Grid.SetRow(sample, i); Grid.SetColumn(sample, 1); grid.Children.Add(sample); } // Add borders between rows. for (int i = 0; i < page.Items.Length; ++i) { var border = new Border(); border.BorderThickness = new Thickness(0.0, 0.0, 0.0, 1.0); border.BorderBrush = SystemColors.ControlLightBrush; Grid.SetRow(border, i); Grid.SetColumnSpan(border, 2); grid.Children.Add(border); } } } _currentFeature = chooserProperty; _currentFeaturePage = page; }
// 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); }
/// <summary> /// Called by SetValue or ClearValue to verify that the property /// can be changed. /// </summary> private PropertyMetadata SetupPropertyChange(DependencyPropertyKey key, out DependencyProperty dp) { if ( key != null ) { dp = key.DependencyProperty; Debug.Assert(dp != null); dp.VerifyReadOnlyKey(key); // Get type-specific metadata for this property return dp.GetMetadata(DependencyObjectType); } else { throw new ArgumentNullException("key"); } }
public void SetValueBase(DependencyProperty property, object value) { PropertyMetadata metadata = property.GetMetadata(GetType()); SetValueCommon(property, metadata, value); }
[FriendAccessAllowed] // Built into Base, also used by Core & Framework. internal BaseValueSourceInternal GetValueSource(DependencyProperty dp, PropertyMetadata metadata, out bool hasModifiers, out bool isExpression, out bool isAnimated, out bool isCoerced, out bool isCurrent) { if (dp == null) { throw new ArgumentNullException("dp"); } EntryIndex entryIndex = LookupEntry(dp.GlobalIndex); if (entryIndex.Found) { EffectiveValueEntry entry = _effectiveValues[entryIndex.Index]; hasModifiers = entry.HasModifiers; isExpression = entry.IsExpression; isAnimated = entry.IsAnimated; isCoerced = entry.IsCoerced; isCurrent = entry.IsCoercedWithCurrentValue; return entry.BaseValueSourceInternal; } else { isExpression = false; isAnimated = false; isCoerced = false; isCurrent = false; if (dp.ReadOnly) { if (metadata == null) { metadata = dp.GetMetadata(DependencyObjectType); } GetReadOnlyValueCallback callback = metadata.GetReadOnlyValueCallback; if (callback != null) { BaseValueSourceInternal source; callback(this, out source); hasModifiers = false; return source; } } if (dp.IsPotentiallyInherited) { if (metadata == null) { metadata = dp.GetMetadata(DependencyObjectType); } if (metadata.IsInherited) { DependencyObject inheritanceParent = InheritanceParent; if (inheritanceParent != null && inheritanceParent.LookupEntry(dp.GlobalIndex).Found) { hasModifiers = false; return BaseValueSourceInternal.Inherited; } } } } hasModifiers = false; return BaseValueSourceInternal.Default; }
internal static void ApplyTemplatedParentValue( DependencyObject container, FrameworkObject child, int childIndex, ref FrugalStructList<ChildRecord> childRecordFromChildIndex, DependencyProperty dp, FrameworkElementFactory templateRoot) { EffectiveValueEntry newEntry = new EffectiveValueEntry(dp); newEntry.Value = DependencyProperty.UnsetValue; if (GetValueFromTemplatedParent( container, childIndex, child, dp, ref childRecordFromChildIndex, templateRoot, ref newEntry)) { DependencyObject target = child.DO; target.UpdateEffectiveValue( target.LookupEntry(dp.GlobalIndex), dp, dp.GetMetadata(target.DependencyObjectType), new EffectiveValueEntry() /* oldEntry */, ref newEntry, false /* coerceWithDeferredReference */, false /* coerceWithCurrentValue */, OperationType.Unknown); } }
/// <summary> /// Called by SetValue or ClearValue to verify that the property /// can be changed. /// </summary> private PropertyMetadata SetupPropertyChange(DependencyPropertyKey key, out DependencyProperty dp) { if ( key != null ) { dp = key.DependencyProperty; if ( dp != null ) { dp.VerifyReadOnlyKey(key); // Get type-specific metadata for this property return dp.GetMetadata(DependencyObjectType); } else { throw new ArgumentException(SR.Get(SRID.ReadOnlyKeyNotAuthorized, dp.Name)); } } else { throw new ArgumentNullException("key"); } }
static object GetDefaultValue(DependencyProperty dp) { return dp.GetMetadata(typeof(SmoothStreamingMediaElement)).DefaultValue; }
//+----------------------------------------------------------------------------------------------------------------------- // // SetDependencyValue // // We call this routine to set a DP value onto a DO, but it's virtual so that custom baml record readers // can do their own thing. This was added so that templates could set unshareable template child property // values into per-FE state. // //+----------------------------------------------------------------------------------------------------------------------- internal void SetDependencyValue(DependencyObject dependencyObject, DependencyProperty dependencyProperty, object value) { // We don't need to get the metadata if we aren't skipping journaled properties FrameworkPropertyMetadata metadata = ParserContext != null && ParserContext.SkipJournaledProperties ? dependencyProperty.GetMetadata(dependencyObject.DependencyObjectType) as FrameworkPropertyMetadata : null; // If the metadata is not null here, we are skipping journaled properties (if the metadata requires it) // NOTE: we do not journal expression. So even when the property is journalable but the value is expression, // we still want to set the value from parser. See corresponding code for avoiding saving expression in DataStream.SaveSubStreams. // Please see Windows OS bug # 1852349 for details. if ((metadata == null) || (!metadata.Journal) || (value is Expression)) { SetDependencyValueCore(dependencyObject, dependencyProperty, value); } }
[FriendAccessAllowed] // Built into Base, also used by Framework. internal void InvalidateSubProperty(DependencyProperty dp) { // when a sub property changes, send a Changed notification with old and new value being the same, and with // IsASubPropertyChange set to true NotifyPropertyChange(new DependencyPropertyChangedEventArgs(dp, dp.GetMetadata(DependencyObjectType), GetValue(dp))); }
// // 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); }
[FriendAccessAllowed] // Built into Base, also used by Core. internal EffectiveValueEntry GetValueEntry( EntryIndex entryIndex, DependencyProperty dp, PropertyMetadata metadata, RequestFlags requests) { EffectiveValueEntry entry; if (dp.ReadOnly) { if (metadata == null) { metadata = dp.GetMetadata(DependencyObjectType); } GetReadOnlyValueCallback getValueCallback = metadata.GetReadOnlyValueCallback; if (getValueCallback != null) { BaseValueSourceInternal valueSource; entry = new EffectiveValueEntry(dp); entry.Value = getValueCallback(this, out valueSource); entry.BaseValueSourceInternal = valueSource; return entry; } } if (entryIndex.Found) { if ((requests & RequestFlags.RawEntry) != 0) { entry = _effectiveValues[entryIndex.Index]; } else { entry = GetEffectiveValue( entryIndex, dp, requests); } } else { entry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Unknown); } if (entry.Value == DependencyProperty.UnsetValue) { if (dp.IsPotentiallyInherited) { if (metadata == null) { metadata = dp.GetMetadata(DependencyObjectType); } if (metadata.IsInherited) { DependencyObject inheritanceParent = InheritanceParent; if (inheritanceParent != null) { entryIndex = inheritanceParent.LookupEntry(dp.GlobalIndex); if (entryIndex.Found) { entry = inheritanceParent.GetEffectiveValue( entryIndex, dp, requests & RequestFlags.DeferredReferences); entry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited; } } } if (entry.Value != DependencyProperty.UnsetValue) { return entry; } } if ((requests & RequestFlags.SkipDefault) == 0) { if (dp.IsPotentiallyUsingDefaultValueFactory) { if (metadata == null) { metadata = dp.GetMetadata(DependencyObjectType); } if (((requests & (RequestFlags.DeferredReferences | RequestFlags.RawEntry)) != 0) && metadata.UsingDefaultValueFactory) { entry.BaseValueSourceInternal = BaseValueSourceInternal.Default; entry.Value = new DeferredMutableDefaultReference(metadata, this, dp); return entry; } } else if (!dp.IsDefaultValueChanged) { return EffectiveValueEntry.CreateDefaultValueEntry(dp, dp.DefaultMetadata.DefaultValue); } if (metadata == null) { metadata = dp.GetMetadata(DependencyObjectType); } return EffectiveValueEntry.CreateDefaultValueEntry(dp, metadata.GetDefaultValue(this, dp)); } } return entry; }
public DependencyPropertyValueEntry(DependencyObject dependencyObject, DependencyProperty dependencyProperty) { this.dependencyProperty = dependencyProperty; this.defaultValue = dependencyProperty.GetMetadata(dependencyObject.GetType()).DefaultValue; currentValue = new ObservableValue(); currentValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e); baseValues = new object[BaseValuePriorities]; for (int i = 0; i < baseValues.Length; i++) { baseValues[i] = ObservableValue.UnsetValue; } animationValue = ObservableValue.UnsetValue; }
/// <summary> /// Called by SetValue or ClearValue to verify that the property /// can be changed. /// </summary> private PropertyMetadata SetupPropertyChange(DependencyProperty dp) { if ( dp != null ) { if ( !dp.ReadOnly ) { // Get type-specific metadata for this property return dp.GetMetadata(DependencyObjectType); } else { throw new InvalidOperationException(SR.Get(SRID.ReadOnlyChangeNotAllowed, dp.Name)); } } else { throw new ArgumentNullException("dp"); } }
// create dependency property entry and set its default and initial inherited value private IDependencyPropertyValueEntry CreateDependencyPropertyValueEntry(DependencyProperty dependencyProperty) { IDependencyPropertyValueEntry entry = new DependencyPropertyValueEntry(this, dependencyProperty); PropertyMetadata propertyMetadata = dependencyProperty.GetMetadata(GetType()); if (propertyMetadata.CoerceValueCallback != null) { entry = new CoercedDependencyPropertyValueEntry(entry, this, propertyMetadata.CoerceValueCallback); } entry.SetBaseValue((int)BaseValueSource.Default, propertyMetadata.DefaultValue); entry.ValueChanged += (sender, e) => RaisePropertyChanged(new DependencyPropertyChangedEventArgs(dependencyProperty, e.OldValue, e.NewValue)); return entry; }
public void InvalidateProperty(DependencyProperty property) { InvalidateProperty(property, property.GetMetadata(GetType())); }
public object GetValueBase(DependencyProperty property) { return(GetValueCommon(property, property.GetMetadata(this.GetType()))); }
internal FreezableDefaultPromoter(DependencyObject owner, DependencyProperty property) { Debug.Assert(owner != null && property != null, "Caller is responsible for ensuring that owner and property are non-null."); Debug.Assert(!(owner is Freezable) || !((Freezable)owner).IsFrozen, "We should not be observing mutables on a frozen owner."); Debug.Assert(property.GetMetadata(owner.DependencyObjectType).UsingDefaultValueFactory, "How did we end up observing a mutable if we were not registered for the factory pattern?"); // We hang on to the property and owner so we can write the default // value back to the local store if it changes. See also // OnDefaultValueChanged. _owner = owner; _property = property; }
public void CoerceValue(DependencyProperty dp) { PropertyMetadata pm = dp.GetMetadata (this); if (pm.CoerceValueCallback != null) pm.CoerceValueCallback (this, GetValue (dp)); }
/// <summary> /// FrameworkContentElement variant of IsInheritanceNode /// </summary> internal static bool IsInheritanceNode( FrameworkContentElement fce, DependencyProperty dp, out InheritanceBehavior inheritanceBehavior) { // Assume can continue search inheritanceBehavior = InheritanceBehavior.Default; // Get Framework metadata (if exists) FrameworkPropertyMetadata metadata = dp.GetMetadata(fce.DependencyObjectType) as FrameworkPropertyMetadata; // Check for correct type of metadata if (metadata != null) { if (fce.InheritanceBehavior != InheritanceBehavior.Default && !metadata.OverridesInheritanceBehavior) { // Hit a tree boundary inheritanceBehavior = fce.InheritanceBehavior; } // Return true if metadata is marked as inheritable; false otherwise return metadata.Inherits; } // Not framework type metadata return false; }
public ValueSource GetValueSource(DependencyProperty dependencyProperty) { IDependencyPropertyValueEntry entry; if (entries.TryGetValue(dependencyProperty, out entry)) { return new ValueSource( (BaseValueSource)entry.GetBaseValuePriority(), entry.GetBaseValue(false) is IExpression || entry.GetCurrentValue(false) is IExpression, entry.GetCurrentValue(true) != ObservableValue.UnsetValue, entry.GetAnimationValue(true) != ObservableValue.UnsetValue, (entry is CoercedDependencyPropertyValueEntry) && ((CoercedDependencyPropertyValueEntry)entry).IsCoerced); } PropertyMetadata propertyMetadata = dependencyProperty.GetMetadata(GetType()); BaseValueSource baseValueSource = propertyMetadata.Inherits && inheritanceParent != null ? BaseValueSource.Inherited : BaseValueSource.Default; return new ValueSource(baseValueSource, false, false, false, false); }