// Token: 0x060003AF RID: 943 RVA: 0x0000A87B File Offset: 0x00008A7B internal ValueSource(BaseValueSourceInternal source, bool isExpression, bool isAnimated, bool isCoerced, bool isCurrent) { this._baseValueSource = (BaseValueSource)source; this._isExpression = isExpression; this._isAnimated = isAnimated; this._isCoerced = isCoerced; this._isCurrent = isCurrent; }
/// <summary> /// Prepare the element to display the item. This may involve /// applying styles, setting bindings, etc. /// </summary> protected override void PrepareContainerForItemOverride(DependencyObject element, object item) { base.PrepareContainerForItemOverride(element, item); // For certain known types, automatically change their default style // to point to a ToolBar version. FrameworkElement fe = element as FrameworkElement; if (fe != null) { Type feType = fe.GetType(); ResourceKey resourceKey = null; if (feType == typeof(Button)) { resourceKey = ButtonStyleKey; } else if (feType == typeof(ToggleButton)) { resourceKey = ToggleButtonStyleKey; } else if (feType == typeof(Separator)) { resourceKey = SeparatorStyleKey; } else if (feType == typeof(CheckBox)) { resourceKey = CheckBoxStyleKey; } else if (feType == typeof(RadioButton)) { resourceKey = RadioButtonStyleKey; } else if (feType == typeof(ComboBox)) { resourceKey = ComboBoxStyleKey; } else if (feType == typeof(TextBox)) { resourceKey = TextBoxStyleKey; } else if (feType == typeof(Menu)) { resourceKey = MenuStyleKey; } if (resourceKey != null) { bool hasModifiers; BaseValueSourceInternal vs = fe.GetValueSource(StyleProperty, null, out hasModifiers); if (vs <= BaseValueSourceInternal.ImplicitReference) { fe.SetResourceReference(StyleProperty, resourceKey); } fe.DefaultStyleKey = resourceKey; } } }
internal static bool IsFocusable(DependencyObject element) { // CODE if (element == null) { return(false); } UIElement uie = element as UIElement; if (uie != null) { if (uie.IsVisible == false) { return(false); } } if ((bool)element.GetValue(UIElement.IsEnabledProperty) == false) { return(false); } // CODE bool hasModifiers = false; BaseValueSourceInternal valueSource = element.GetValueSource(UIElement.FocusableProperty, null, out hasModifiers); bool focusable = (bool)element.GetValue(UIElement.FocusableProperty); if (!focusable && valueSource == BaseValueSourceInternal.Default && !hasModifiers) { // The Focusable property was not explicitly set to anything. // The default value is generally false, but true in a few cases. if (FocusManager.GetIsFocusScope(element)) { // Focus scopes are considered focusable, even if // the Focusable property is false. return(true); } else if (uie != null && uie.InternalVisualParent == null) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(uie); if (presentationSource != null) { // A UIElements that is the root of a PresentationSource is considered focusable. return(true); } } } return(focusable); }
/// <summary> /// Callback on visiting each node in the descendency /// during an inheritable property change /// </summary> private static bool OnInheritablePropertyChanged( DependencyObject d, InheritablePropertyChangeInfo info, bool visitedViaVisualTree) { Debug.Assert(d != null, "Must have non-null current node"); DependencyProperty dp = info.Property; bool inheritanceNode = IsInheritanceNode(d, dp); if (inheritanceNode) { BaseValueSourceInternal oldValueSource = BaseValueSourceInternal.Default; INTERNAL_PropertyStorage storage; if (INTERNAL_PropertyStore.TryGetInheritedPropertyStorage(d, dp, false, out storage)) { oldValueSource = storage.BaseValueSourceInternal; } // If the oldValueSource is of lower precedence than Inheritance // only then do we need to Invalidate the property if (BaseValueSourceInternal.Inherited >= oldValueSource) { if (visitedViaVisualTree && typeof(FrameworkElement).IsInstanceOfType(d)) { DependencyObject logicalParent = ((FrameworkElement)d).Parent; if (logicalParent != null) { DependencyObject visualParent = VisualTreeHelper.GetParent(d); if (visualParent != null && visualParent != logicalParent) { return(false); } } } return(d.SetInheritedValue(dp, info.NewValue, false)); } else { if (storage == null) { // get the storage if we didn't to it ealier. INTERNAL_PropertyStore.TryGetInheritedPropertyStorage(d, dp, true, out storage); } // set the inherited value so that it is known if at some point, // the value of higher precedence that is currently used is removed. // we know that the value of the property is not changing, so we can // skip the call to UpdateEffectiveValue(...) storage.InheritedValue = info.NewValue; return(false); } } return(false); }
internal static bool IsFocusable(DependencyObject element) { // This should really be its own property, but it is hard to do efficiently. if (element == null) { return(false); } UIElement uie = element as UIElement; if (uie != null) { if (uie.IsVisible == false) { return(false); } } if ((bool)element.GetValue(UIElement.IsEnabledProperty) == false) { return(false); } // There are too many conflicting desires for whether or not // an element is focusable. We need to differentiate between // a false default value, and the user specifying false // explicitly. // bool hasModifiers = false; BaseValueSourceInternal valueSource = element.GetValueSource(UIElement.FocusableProperty, null, out hasModifiers); bool focusable = (bool)element.GetValue(UIElement.FocusableProperty); if (!focusable && valueSource == BaseValueSourceInternal.Default && !hasModifiers) { // The Focusable property was not explicitly set to anything. // The default value is generally false, but true in a few cases. if (FocusManager.GetIsFocusScope(element)) { // Focus scopes are considered focusable, even if // the Focusable property is false. return(true); } else if (uie != null && uie.InternalVisualParent == null) { PresentationSource presentationSource = PresentationSource.CriticalFromVisual(uie); if (presentationSource != null) { // A UIElements that is the root of a PresentationSource is considered focusable. return(true); } } } return(focusable); }
internal ValueSource(BaseValueSourceInternal source, bool isExpression, bool isAnimated, bool isCoerced, bool isCurrent) { // this cast is justified because the public BaseValueSource enum // values agree with the internal BaseValueSourceInternal enum values. _baseValueSource = (BaseValueSource)source; _isExpression = isExpression; _isAnimated = isAnimated; _isCoerced = isCoerced; _isCurrent = isCurrent; }
// Token: 0x06000BB2 RID: 2994 RVA: 0x0002AF78 File Offset: 0x00029178 internal override object GetValue(BaseValueSourceInternal valueSource) { object syncRoot = ((ICollection)Application.Current.Resources).SyncRoot; object value; lock (syncRoot) { value = base.GetValue(valueSource); } return(value); }
// Token: 0x06004A4F RID: 19023 RVA: 0x0014F910 File Offset: 0x0014DB10 internal override object GetValue(BaseValueSourceInternal valueSource) { string textInternal = TextRangeBase.GetTextInternal(this._textContainer.Start, this._textContainer.End); TextBox textBox = this._textContainer.Parent as TextBox; if (textBox != null) { textBox.OnDeferredTextReferenceResolved(this, textInternal); } return(textInternal); }
/// <summary>Prepares the specified element to display the specified item. </summary> /// <param name="element">The element that will display the item.</param> /// <param name="item">The item to display.</param> // Token: 0x06005828 RID: 22568 RVA: 0x00186958 File Offset: 0x00184B58 protected override void PrepareContainerForItemOverride(DependencyObject element, object item) { base.PrepareContainerForItemOverride(element, item); FrameworkElement frameworkElement = element as FrameworkElement; if (frameworkElement != null) { Type type = frameworkElement.GetType(); ResourceKey resourceKey = null; if (type == typeof(Button)) { resourceKey = ToolBar.ButtonStyleKey; } else if (type == typeof(ToggleButton)) { resourceKey = ToolBar.ToggleButtonStyleKey; } else if (type == typeof(Separator)) { resourceKey = ToolBar.SeparatorStyleKey; } else if (type == typeof(CheckBox)) { resourceKey = ToolBar.CheckBoxStyleKey; } else if (type == typeof(RadioButton)) { resourceKey = ToolBar.RadioButtonStyleKey; } else if (type == typeof(ComboBox)) { resourceKey = ToolBar.ComboBoxStyleKey; } else if (type == typeof(TextBox)) { resourceKey = ToolBar.TextBoxStyleKey; } else if (type == typeof(Menu)) { resourceKey = ToolBar.MenuStyleKey; } if (resourceKey != null) { bool flag; BaseValueSourceInternal valueSource = frameworkElement.GetValueSource(FrameworkElement.StyleProperty, null, out flag); if (valueSource <= BaseValueSourceInternal.ImplicitReference) { frameworkElement.SetResourceReference(FrameworkElement.StyleProperty, resourceKey); } frameworkElement.DefaultStyleKey = resourceKey; } } }
//------------------------------------------------------ // // Internal Methods // //----------------------------------------------------- #region Internal Methods // Does the real work to calculate the current TextProperty value. internal override object GetValue(BaseValueSourceInternal valueSource) { string s = TextRangeBase.GetTextInternal(_textContainer.Start, _textContainer.End); TextBox tb = _textContainer.Parent as TextBox; if (tb != null) { tb.OnDeferredTextReferenceResolved(this, s); } return s; }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal Methods // Does the real work to calculate the current TextProperty value. internal override object GetValue(BaseValueSourceInternal valueSource) { string s = TextRangeBase.GetTextInternal(_textContainer.Start, _textContainer.End); TextBox tb = _textContainer.Parent as TextBox; if (tb != null) { tb.OnDeferredTextReferenceResolved(this, s); } return(s); }
private static object GetActualWidth(DependencyObject d, out BaseValueSourceInternal source) { var uiElement = d as UIElement; if (uiElement != null && uiElement.hasWidthEverChanged) { source = BaseValueSourceInternal.Local; return(uiElement.RenderSize.Width); } else { source = BaseValueSourceInternal.Default; return(default(double)); } }
// Token: 0x06000CF7 RID: 3319 RVA: 0x00030004 File Offset: 0x0002E204 internal static Collection <VisualStateGroup> GetVisualStateGroupsInternal(FrameworkElement obj) { if (obj == null) { throw new ArgumentNullException("obj"); } bool flag; BaseValueSourceInternal valueSource = obj.GetValueSource(VisualStateManager.VisualStateGroupsProperty, null, out flag); if (valueSource != BaseValueSourceInternal.Default) { return(obj.GetValue(VisualStateManager.VisualStateGroupsProperty) as Collection <VisualStateGroup>); } return(null); }
internal InheritablePropertyChangeInfo( DependencyObject rootElement, DependencyProperty property, object oldValue, BaseValueSourceInternal oldValueSource, object newValue, BaseValueSourceInternal newValueSource) { _rootElement = rootElement; _property = property; _oldValue = oldValue; _oldValueSource = oldValueSource; _newValue = newValue; _newValueSource = newValueSource; }
/// <summary>Prepares an item for display in the <see cref="T:System.Windows.Controls.Primitives.StatusBar" />.</summary> /// <param name="element">The item to display in the <see cref="T:System.Windows.Controls.Primitives.StatusBar" />.</param> /// <param name="item">The content of the item to display.</param> // Token: 0x0600601A RID: 24602 RVA: 0x001AF44C File Offset: 0x001AD64C protected override void PrepareContainerForItemOverride(DependencyObject element, object item) { base.PrepareContainerForItemOverride(element, item); Separator separator = element as Separator; if (separator != null) { bool flag; BaseValueSourceInternal valueSource = separator.GetValueSource(FrameworkElement.StyleProperty, null, out flag); if (valueSource <= BaseValueSourceInternal.ImplicitReference) { separator.SetResourceReference(FrameworkElement.StyleProperty, StatusBar.SeparatorStyleKey); } separator.DefaultStyleKey = StatusBar.SeparatorStyleKey; } }
// Token: 0x060064BF RID: 25791 RVA: 0x001C40E4 File Offset: 0x001C22E4 private static bool HasDefaultOrInheritedValueImpl(DependencyObject d, DependencyProperty dp, bool checkInherited, bool ignoreModifiers) { PropertyMetadata metadata = dp.GetMetadata(d); bool flag; BaseValueSourceInternal valueSource = d.GetValueSource(dp, metadata, out flag); if (valueSource == BaseValueSourceInternal.Default || (checkInherited && valueSource == BaseValueSourceInternal.Inherited)) { if (ignoreModifiers && (d is FrameworkElement || d is FrameworkContentElement)) { flag = false; } return(!flag); } return(false); }
/// <summary> /// Prepare the element to display the item. This may involve /// applying styles, setting bindings, etc. /// </summary> protected override void PrepareContainerForItemOverride(DependencyObject element, object item) { base.PrepareContainerForItemOverride(element, item); Separator separator = element as Separator; if (separator != null) { bool hasModifiers; BaseValueSourceInternal vs = separator.GetValueSource(StyleProperty, null, out hasModifiers); if (vs <= BaseValueSourceInternal.ImplicitReference) { separator.SetResourceReference(StyleProperty, SeparatorStyleKey); } separator.DefaultStyleKey = SeparatorStyleKey; } }
/// <summary> /// Return the source of the value for the given property. /// </summary> public static ValueSource GetValueSource(DependencyObject dependencyObject, DependencyProperty dependencyProperty) { if (dependencyObject == null) { throw new ArgumentNullException(nameof(dependencyObject)); } if (dependencyProperty == null) { throw new ArgumentNullException(nameof(dependencyProperty)); } dependencyObject.VerifyAccess(); bool hasModifiers, isExpression, isAnimated, isCoerced, isCurrent; BaseValueSourceInternal source = dependencyObject.GetValueSource(dependencyProperty, null, out hasModifiers, out isExpression, out isAnimated, out isCoerced, out isCurrent); return(new ValueSource(source, isExpression, isAnimated, isCoerced, isCurrent)); }
internal static Collection <VisualStateGroup> GetVisualStateGroupsInternal(FrameworkElement obj) { if (obj == null) { throw new ArgumentNullException("obj"); } // We don't want to get the default value because it will create/return an empty colleciton. bool hasModifiers; BaseValueSourceInternal source = obj.GetValueSource(VisualStateGroupsProperty, null, out hasModifiers); if (source != BaseValueSourceInternal.Default) { return(obj.GetValue(VisualStateManager.VisualStateGroupsProperty) as Collection <VisualStateGroup>); } return(null); }
private static void ComputeEffectiveValue(INTERNAL_PropertyStorage storage, out object effectiveValue, out BaseValueSourceInternal kind) { if (!storage.IsAnimatedOverLocal && storage.LocalValue != DependencyProperty.UnsetValue) { effectiveValue = storage.LocalValue; kind = BaseValueSourceInternal.Local; } else if (storage.IsAnimatedOverLocal && storage.AnimatedValue != DependencyProperty.UnsetValue) { effectiveValue = storage.AnimatedValue; kind = BaseValueSourceInternal.Animated; } else if (storage.ImplicitReferenceValue != DependencyProperty.UnsetValue) { effectiveValue = storage.ImplicitReferenceValue; kind = BaseValueSourceInternal.ImplicitReference; } else if (storage.LocalStyleValue != DependencyProperty.UnsetValue) { effectiveValue = storage.LocalStyleValue; kind = BaseValueSourceInternal.LocalStyle; } else if (storage.ThemeStyleValue != DependencyProperty.UnsetValue) { effectiveValue = storage.ThemeStyleValue; kind = BaseValueSourceInternal.ThemeStyle; } else if (storage.InheritedValue != DependencyProperty.UnsetValue) { effectiveValue = storage.InheritedValue; kind = BaseValueSourceInternal.Inherited; } else // Property default value { effectiveValue = storage.TypeMetadata.DefaultValue; kind = BaseValueSourceInternal.Default; } }
// Token: 0x06004DB8 RID: 19896 RVA: 0x0015EAE8 File Offset: 0x0015CCE8 private static object CoerceCursor(DependencyObject o, object value) { GridSplitter gridSplitter = (GridSplitter)o; bool flag; BaseValueSourceInternal valueSource = gridSplitter.GetValueSource(FrameworkElement.CursorProperty, null, out flag); if (value == null && valueSource == BaseValueSourceInternal.Default) { GridResizeDirection effectiveResizeDirection = gridSplitter.GetEffectiveResizeDirection(); if (effectiveResizeDirection == GridResizeDirection.Columns) { return(Cursors.SizeWE); } if (effectiveResizeDirection == GridResizeDirection.Rows) { return(Cursors.SizeNS); } } return(value); }
private static object CoerceCursor(DependencyObject o, object value) { GridSplitter splitter = (GridSplitter)o; bool hasModifiers; BaseValueSourceInternal vs = splitter.GetValueSource(CursorProperty, null, out hasModifiers); if (value == null && vs == BaseValueSourceInternal.Default) { switch (splitter.GetEffectiveResizeDirection()) { case GridResizeDirection.Columns: return(Cursors.SizeWE); case GridResizeDirection.Rows: return(Cursors.SizeNS); } } return(value); }
/// <summary>Returns a structure that reports various metadata and property system characteristics of a specified dependency property on a particular <see cref="T:System.Windows.DependencyObject" />.</summary> /// <param name="dependencyObject">The element that contains the <paramref name="dependencyProperty" /> to report information for.</param> /// <param name="dependencyProperty">The identifier for the dependency property to report information for.</param> /// <returns>A <see cref="T:System.Windows.ValueSource" /> structure that reports the specific information.</returns> // Token: 0x060003B9 RID: 953 RVA: 0x0000A968 File Offset: 0x00008B68 public static ValueSource GetValueSource(DependencyObject dependencyObject, DependencyProperty dependencyProperty) { if (dependencyObject == null) { throw new ArgumentNullException("dependencyObject"); } if (dependencyProperty == null) { throw new ArgumentNullException("dependencyProperty"); } dependencyObject.VerifyAccess(); bool flag; bool isExpression; bool isAnimated; bool isCoerced; bool isCurrent; BaseValueSourceInternal valueSource = dependencyObject.GetValueSource(dependencyProperty, null, out flag, out isExpression, out isAnimated, out isCoerced, out isCurrent); return(new ValueSource(valueSource, isExpression, isAnimated, isCoerced, isCurrent)); }
// Token: 0x06000BA4 RID: 2980 RVA: 0x0002ADF0 File Offset: 0x00028FF0 internal override object GetValue(BaseValueSourceInternal valueSource) { if (this._dictionary != null) { bool flag; object value = this._dictionary.GetValue(this._keyOrValue, out flag); if (flag) { this._keyOrValue = value; this.RemoveFromDictionary(); } bool flag2 = valueSource == BaseValueSourceInternal.ThemeStyle || valueSource == BaseValueSourceInternal.ThemeStyleTrigger || valueSource == BaseValueSourceInternal.Style || valueSource == BaseValueSourceInternal.TemplateTrigger || valueSource == BaseValueSourceInternal.StyleTrigger || valueSource == BaseValueSourceInternal.ParentTemplate || valueSource == BaseValueSourceInternal.ParentTemplateTrigger; if (flag2) { StyleHelper.SealIfSealable(value); } this.OnInflated(); return(value); } return(this._keyOrValue); }
// Token: 0x06000BB5 RID: 2997 RVA: 0x0002B024 File Offset: 0x00029224 internal override object GetValue(BaseValueSourceInternal valueSource) { object themeDictionaryLock = SystemResources.ThemeDictionaryLock; object result; lock (themeDictionaryLock) { if (base.Dictionary != null) { object key = this.Key; SystemResources.IsSystemResourcesParsing = true; bool flag2; object value; try { value = base.Dictionary.GetValue(key, out flag2); if (flag2) { this.Value = value; base.Dictionary = null; } } finally { SystemResources.IsSystemResourcesParsing = false; } if ((key is Type || key is ResourceKey) && this._canCacheAsThemeResource && flag2) { SystemResources.CacheResource(key, value, false); } result = value; } else { result = this.Value; } } return(result); }
internal override object GetValue(BaseValueSourceInternal valueSource) { bool flag; if (this.dictionary == null) { return(this.keyOrValue); } object value = this.dictionary.GetValue(this.keyOrValue, out flag); if (!this.CheckIfShared || flag) { this.keyOrValue = value; this.RemoveFromDictionary(); } if (valueSource == BaseValueSourceInternal.ThemeStyle || valueSource == BaseValueSourceInternal.ThemeStyleTrigger || valueSource == BaseValueSourceInternal.Style || valueSource == BaseValueSourceInternal.TemplateTrigger || valueSource == BaseValueSourceInternal.StyleTrigger || valueSource == BaseValueSourceInternal.ParentTemplate || valueSource == BaseValueSourceInternal.ParentTemplateTrigger) { StyleHelper.SealIfSealable(value); } this.OnInflated(); return(value); }
private static void ComputeEffectiveValue(INTERNAL_PropertyStorage storage, out object effectiveValue, out BaseValueSourceInternal kind) { /*if ((effectiveValue = storage.VisualStateValue) != INTERNAL_NoValue.NoValue) * { * kind = KindOfValue.VisualState; * } * else */ if (!storage.IsAnimatedOverLocal && (effectiveValue = storage.LocalValue) != DependencyProperty.UnsetValue) { kind = BaseValueSourceInternal.Local; } else if (storage.IsAnimatedOverLocal && (effectiveValue = storage.AnimatedValue) != DependencyProperty.UnsetValue) { kind = BaseValueSourceInternal.Animated; } else if ((effectiveValue = storage.LocalStyleValue) != DependencyProperty.UnsetValue) { kind = BaseValueSourceInternal.LocalStyle; } else if ((effectiveValue = storage.ImplicitStyleValue) != DependencyProperty.UnsetValue) { kind = BaseValueSourceInternal.ImplicitStyle; } else if ((effectiveValue = storage.InheritedValue) != DependencyProperty.UnsetValue) { kind = BaseValueSourceInternal.Inherited; } else // Property default value { effectiveValue = storage.TypeMetadata.DefaultValue; kind = BaseValueSourceInternal.Default; } }
internal override object GetValue(BaseValueSourceInternal valueSource) { return Value; }
internal override object GetValue(BaseValueSourceInternal valueSource) { lock (SystemResources.ThemeDictionaryLock) { // If the value cache is invalid fetch the value from // the dictionary else just retun the cached value if (Dictionary != null) { bool canCache; object key = Key; object value; SystemResources.IsSystemResourcesParsing = true; try { value = Dictionary.GetValue(key, out canCache); if (canCache) { // Note that we are replacing the _keyorValue field // with the value and nuking the _dictionary field. Value = value; Dictionary = null; } } finally { SystemResources.IsSystemResourcesParsing = false; } // Only cache keys that would be located by FindResourceInternal if ((key is Type || key is ResourceKey) && canCache) { SystemResources.CacheResource(key, value, false /*isTraceEnabled*/); } return value; } return Value; } }
internal EffectiveValueEntry(DependencyProperty dp, BaseValueSourceInternal valueSource) { _propertyIndex = (short)dp.GlobalIndex; _value = DependencyProperty.UnsetValue; _source = (FullValueSource)valueSource; }
internal override object GetValue(BaseValueSourceInternal valueSource) { return _sourceMetadata.GetDefaultValue(_sourceObject, _sourceProperty); }
private static void UpdateEffectiveValue(INTERNAL_PropertyStorage storage, object newValue, BaseValueSourceInternal newValueSource, bool coerceWithCurrentValue, bool coerceValue, bool clearValue, bool propagateChanges) { global::System.Diagnostics.Debug.Assert((coerceWithCurrentValue == coerceValue && !coerceValue) || coerceValue != coerceWithCurrentValue); bool isCoerceOperation = coerceValue || coerceWithCurrentValue; BaseValueSourceInternal oldBaseValueSource = storage.BaseValueSourceInternal; object oldValue; BindingExpression currentExpr = null; // Compute new value object effectiveValue; BaseValueSourceInternal effectiveValueKind; if (isCoerceOperation) { // Source and base value are unchanged during coercion operation effectiveValue = newValue; effectiveValueKind = oldBaseValueSource; // Get old value before it gets overriden oldValue = GetEffectiveValue(storage); } else { ComputeEffectiveValue(storage, out effectiveValue, out effectiveValueKind); // Check for early exit if effective value is not impacted (if we are doing // a coerce operation, we have to go through the update process) if (effectiveValueKind == oldBaseValueSource && newValueSource < effectiveValueKind) { // value source remains the same. // Exit if the newly set value is of lower precedence than the effective value. return; } // Get old value before it gets overriden oldValue = GetEffectiveValue(storage); currentExpr = (storage.IsExpression || storage.IsExpressionFromStyle) ? storage.ModifiedValue.BaseValue as BindingExpression : null; #if USEASSERT // If the current base value is a BindingExpression, it should have been detached by now // Or is the same instance as 'effectiveValue' (this occurs when we update a property bound to a // BindingExpression) global::System.Diagnostics.Debug.Assert(currentExpr == null || !currentExpr.IsAttached || object.ReferenceEquals(currentExpr, effectiveValue), "Binding expression should be detached."); #endif storage.ResetValue(); // Update the base value source storage.BaseValueSourceInternal = effectiveValueKind; } object computedValue; if (!isCoerceOperation) { BindingExpression newExpr = effectiveValue as BindingExpression; if (newExpr == null) { computedValue = storage.Property.PropertyType == typeof(string) ? effectiveValue?.ToString() : effectiveValue; storage.Value = computedValue; } else { #if USEASSERT global::System.Diagnostics.Debug.Assert(effectiveValueKind == BaseValueSourceInternal.Local || effectiveValueKind == BaseValueSourceInternal.LocalStyle); #endif // If the new BindingExpression is the same as the current one, // the BindingExpression is already attached bool isNewBinding = !object.ReferenceEquals(currentExpr, newExpr); if (isNewBinding) { if (newExpr.IsAttached) { throw new InvalidOperationException(string.Format("Cannot attach an instance of '{0}' multiple times", typeof(BindingExpression))); } newExpr.OnAttached(storage.Owner); storage.Value = newExpr; // Set the new base value } if (effectiveValueKind == BaseValueSourceInternal.Local) { storage.SetExpressionValue(storage.TypeMetadata.DefaultValue, newExpr); } else { storage.SetExpressionFromStyleValue(storage.TypeMetadata.DefaultValue, newExpr); } // 1- 'isNewBinding == true' means that we are attaching a new BindingExpression. // 2- 'newValue is BindingExpression == true' means that we are re-evaluating a BindingEpression // (usually by calling RefreshBindingExpressionCommon) // 3- Otherwise we are trying to change the value of a TwoWay binding. // In that case we have to preserve the BindingExpression (this is not the case if the first two // situations), hence the following line : computedValue = isNewBinding || newValue is BindingExpression?newExpr.GetValue(storage.Property, storage.Owner.GetType()) : newValue; computedValue = storage.Property.PropertyType == typeof(string) ? computedValue?.ToString() : computedValue; storage.ModifiedValue.ExpressionValue = computedValue; } } else { computedValue = coerceWithCurrentValue ? newValue : GetCoercionBaseValue(storage); if (coerceValue) { storage.ResetCoercedValue(); } } // Coerce to current value if (coerceWithCurrentValue) { object baseValue = GetCoercionBaseValue(storage); ProcessCoerceValue(storage, ref computedValue, oldValue, baseValue, true); } // Coerce Value // We don't want to coerce the value if it's being reset to the property's default value if (storage.TypeMetadata.CoerceValueCallback != null && !(clearValue && storage.FullValueSource == (FullValueSource)BaseValueSourceInternal.Default)) { object baseValue = GetCoercionBaseValue(storage); ProcessCoerceValue(storage, ref computedValue, oldValue, baseValue, false); } // Reset old value inheritance context if (oldBaseValueSource == BaseValueSourceInternal.Local) { // Notes: // - Inheritance context is only handled by local value // - We use null instead of the actual DependencyProperty // as the parameter is ignored in the current implentation. storage.Owner.RemoveSelfAsInheritanceContext(oldValue, null /*storage.Property*/); } // Set new value inheritance context if (effectiveValueKind == BaseValueSourceInternal.Local) { // Check above storage.Owner.ProvideSelfAsInheritanceContext(computedValue, null /*storage.Property*/); } if (!ArePropertiesEqual(oldValue, computedValue, storage.Property.PropertyType)) { // Raise the PropertyChanged event if (!storage.TypeMetadata.Inherits || ShouldRaisePropertyChanged(storage)) { OnPropertyChanged(storage, oldValue, computedValue); } // Propagate to children if property is inherited if (storage.TypeMetadata.Inherits && propagateChanges) { CascadeInheritedPropertyToChildren(storage, computedValue); } } // Update the source of the Binding, in case the previous value of a property was a Binding and the Mode was "TwoWay": if (currentExpr != null && currentExpr.ParentBinding.Mode == BindingMode.TwoWay) //note: we know that oldBindingExpression.IsUpdating is false because oldBindingExpression is only set in that case (otherwise, it is null). { currentExpr.TryUpdateSourceObject(computedValue); } }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal Methods // Deferences a property value on demand. internal abstract object GetValue(BaseValueSourceInternal valueSource);
private static object GetIsVisible(DependencyObject d, out BaseValueSourceInternal source) { source = BaseValueSourceInternal.Local; return ((UIElement3D)d).IsVisible ? BooleanBoxes.TrueBox : BooleanBoxes.FalseBox; }
internal EffectiveValueEntry(DependencyProperty dp, BaseValueSourceInternal valueSource) { _propertyIndex = (short) dp.GlobalIndex; _value = DependencyProperty.UnsetValue; _source = (FullValueSource) valueSource; }
//------------------------------------------------------ // // Internal Methods // //----------------------------------------------------- #region Internal Methods // Does the real work to calculate the current SelectedIndexProperty value. internal override object GetValue(BaseValueSourceInternal valueSource) { return _selector.InternalSelectedIndex; }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal Methods // Does the real work to calculate the current TextProperty value. internal override object GetValue(BaseValueSourceInternal valueSource) { return TextRangeBase.GetTextInternal(_run.ContentStart, _run.ContentEnd); }
internal override object GetValue(BaseValueSourceInternal valueSource) { return(_sourceMetadata.GetDefaultValue(_sourceObject, _sourceProperty)); }
private static object GetActualWidth(DependencyObject d, out BaseValueSourceInternal source) { FrameworkElement frameworkElement = (FrameworkElement) d; if (frameworkElement.HasWidthEverChanged) { source = BaseValueSourceInternal.Local; return (object) frameworkElement.RenderSize.Width; } else { source = BaseValueSourceInternal.Default; return (object) 0.0; } }
[FriendAccessAllowed] // Built into Base, also used by Core and Framework. internal void SetEffectiveValue(EntryIndex entryIndex, DependencyProperty dp, int targetIndex, PropertyMetadata metadata, object value, BaseValueSourceInternal valueSource) { Debug.Assert(value != DependencyProperty.UnsetValue, "Value to be set cannot be UnsetValue"); Debug.Assert(valueSource != BaseValueSourceInternal.Unknown, "ValueSource cannot be Unknown"); // For thread-safety, sealed DOs can't modify _effectiveValues. Debug.Assert(!DO_Sealed, "A Sealed DO cannot be modified"); if (metadata != null && metadata.IsInherited && valueSource != BaseValueSourceInternal.Inherited && !IsSelfInheritanceParent) { SetIsSelfInheritanceParent(); entryIndex = CheckEntryIndex(entryIndex, dp.GlobalIndex); } EffectiveValueEntry entry; if (entryIndex.Found) { entry = _effectiveValues[entryIndex.Index]; } else { entry = new EffectiveValueEntry(); entry.PropertyIndex = targetIndex; InsertEntry(entry, entryIndex.Index); if (metadata != null && metadata.IsInherited) { InheritableEffectiveValuesCount++; } } bool hasExpressionMarker = (value == ExpressionInAlternativeStore); if (!hasExpressionMarker && entry.HasExpressionMarker && (valueSource == BaseValueSourceInternal.ThemeStyle || valueSource == BaseValueSourceInternal.ThemeStyleTrigger || valueSource == BaseValueSourceInternal.Style || valueSource == BaseValueSourceInternal.TemplateTrigger || valueSource == BaseValueSourceInternal.StyleTrigger || valueSource == BaseValueSourceInternal.ParentTemplate || valueSource == BaseValueSourceInternal.ParentTemplateTrigger)) { entry.BaseValueSourceInternal = valueSource; entry.SetExpressionValue(value, ExpressionInAlternativeStore); entry.ResetAnimatedValue(); entry.ResetCoercedValue(); } else if (entry.IsExpression && entry.ModifiedValue.ExpressionValue == Expression.NoValue) { // we now have a value for an expression that is "hiding" - save it // as the expression value entry.SetExpressionValue(value, entry.ModifiedValue.BaseValue); } else { Debug.Assert(entry.BaseValueSourceInternal != BaseValueSourceInternal.Local || valueSource == BaseValueSourceInternal.Local, "No one but another local value can stomp over an existing local value. The only way is to clear the entry"); entry.BaseValueSourceInternal = valueSource; entry.ResetValue(value, hasExpressionMarker); } Debug.Assert(dp == null || (dp.GlobalIndex == entry.PropertyIndex), "EffectiveValueEntry & DependencyProperty do not match"); _effectiveValues[entryIndex.Index] = entry; }
internal override object GetValue(BaseValueSourceInternal valueSource) { // If the _value cache is invalid fetch the value from // the dictionary else just retun the cached value if (_dictionary != null) { bool canCache; object value = _dictionary.GetValue(_keyOrValue, out canCache); if (canCache) { // Note that we are replacing the _keyorValue field // with the value and nuking the _dictionary field. _keyOrValue = value; RemoveFromDictionary(); } // Freeze if this value originated from a style or template bool freezeIfPossible = valueSource == BaseValueSourceInternal.ThemeStyle || valueSource == BaseValueSourceInternal.ThemeStyleTrigger || valueSource == BaseValueSourceInternal.Style || valueSource == BaseValueSourceInternal.TemplateTrigger || valueSource == BaseValueSourceInternal.StyleTrigger || valueSource == BaseValueSourceInternal.ParentTemplate || valueSource == BaseValueSourceInternal.ParentTemplateTrigger; // This is to freeze values produced by deferred // references within styles and templates if (freezeIfPossible) { StyleHelper.SealIfSealable(value); } // tell any listeners (e.g. ResourceReferenceExpressions) // that the value has been inflated OnInflated(); return value; } return _keyOrValue; }
internal override object GetValue(BaseValueSourceInternal valueSource) { lock (((ICollection)Application.Current.Resources).SyncRoot) { return base.GetValue(valueSource); } }
internal override object GetValue(BaseValueSourceInternal valueSource) { bool flag; if (this.dictionary == null) { return this.keyOrValue; } object value = this.dictionary.GetValue(this.keyOrValue, out flag); if (!this.CheckIfShared || flag) { this.keyOrValue = value; this.RemoveFromDictionary(); } if (valueSource == BaseValueSourceInternal.ThemeStyle || valueSource == BaseValueSourceInternal.ThemeStyleTrigger || valueSource == BaseValueSourceInternal.Style || valueSource == BaseValueSourceInternal.TemplateTrigger || valueSource == BaseValueSourceInternal.StyleTrigger || valueSource == BaseValueSourceInternal.ParentTemplate || valueSource == BaseValueSourceInternal.ParentTemplateTrigger) { StyleHelper.SealIfSealable(value); } this.OnInflated(); return value; }
private static object GetActualHeight(DependencyObject d, out BaseValueSourceInternal source) { FrameworkElement fe = (FrameworkElement) d; if (fe.HasHeightEverChanged) { source = BaseValueSourceInternal.Local; return fe.RenderSize.Height; } else { source = BaseValueSourceInternal.Default; return 0d; } }