// Token: 0x06003E37 RID: 15927 RVA: 0x0011D778 File Offset: 0x0011B978 internal static PropertyRecord[] GetPropertyRecordArray(DependencyObject d) { LocalValueEnumerator localValueEnumerator = d.GetLocalValueEnumerator(); PropertyRecord[] array = new PropertyRecord[localValueEnumerator.Count]; int num = 0; localValueEnumerator.Reset(); while (localValueEnumerator.MoveNext()) { LocalValueEntry localValueEntry = localValueEnumerator.Current; DependencyProperty property = localValueEntry.Property; if (!property.ReadOnly) { array[num].Property = property; array[num].Value = d.GetValue(property); num++; } } PropertyRecord[] array2; if (localValueEnumerator.Count != num) { array2 = new PropertyRecord[num]; for (int i = 0; i < num; i++) { array2[i] = array[i]; } } else { array2 = array; } return(array2); }
public override void Render(DrawingContext dc, Point screenPoint) { LocalValueEnumerator enumerator = GetLocalValueEnumerator(); foreach (var marker in markers) { enumerator.Reset(); while (enumerator.MoveNext()) { marker.SetValue(enumerator.Current.Property, enumerator.Current.Value); } marker.Render(dc, screenPoint); } }
// Gets an array of PropertyRecords from a DependencyObject's LocalValueEnumerator. // The array is safe to cache, LocalValueEnumerators are not. internal static PropertyRecord[] GetPropertyRecordArray(DependencyObject d) { LocalValueEnumerator valuesEnumerator = d.GetLocalValueEnumerator(); PropertyRecord[] records = new PropertyRecord[valuesEnumerator.Count]; int count = 0; valuesEnumerator.Reset(); while (valuesEnumerator.MoveNext()) { DependencyProperty dp = valuesEnumerator.Current.Property; if (!dp.ReadOnly) { // LocalValueEntry.Value can be an Expression, which we can't duplicate when we // undo, so we copy over the current value from DependencyObject.GetValue instead. records[count].Property = dp; records[count].Value = d.GetValue(dp); count++; } } PropertyRecord[] trimmedResult; if (valuesEnumerator.Count != count) { trimmedResult = new PropertyRecord[count]; for (int i = 0; i < count; i++) { trimmedResult[i] = records[i]; } } else { trimmedResult = records; } return(trimmedResult); }
// Copies a LocalValueEnumerator properties into an array of DependencyProperty. // This method is useful because LocalValueEnumerator does not support // setting or clearing local values while enumerating. private DependencyProperty[] LocalValueEnumeratorToArray(LocalValueEnumerator valuesEnumerator) { DependencyProperty[] properties; int count; properties = new DependencyProperty[valuesEnumerator.Count]; count = 0; valuesEnumerator.Reset(); while (valuesEnumerator.MoveNext()) { properties[count++] = valuesEnumerator.Current.Property; } return properties; }
/// <summary> /// Sets local values on the text element scoping position. /// </summary> /// <param name="position"> /// A position scoped by the element on which to set the property. /// </param> /// <param name="values"> /// Values to set. /// </param> /// <exception cref="System.InvalidOperationException"> /// Throws InvalidOperationException if position is not scoped by a /// text element or if a property value may not be applied on the /// scoping text element. /// </exception> internal void SetValues(TextPointer position, LocalValueEnumerator values) { TextElement textElement; LocalValueEntry property; // VerifyAccess(); if (position == null) { throw new ArgumentNullException("position"); } // LocalValueEnumerator is a struct. // if (values == null) // { // throw new ArgumentNullException("values"); // } EmptyDeadPositionList(); ValidateSetValue(position); BeginChange(); try { textElement = position.Parent as TextElement; Invariant.Assert(textElement != null); values.Reset(); while (values.MoveNext()) { property = values.Current; // if (property.Property.Name == "CachedSource") { continue; } // If the property is readonly on the text element, then we shouldn't // try to copy the property value. if (property.Property.ReadOnly) { continue; } // Don't copy over Run.Text. This will get automatically invalidated by TextContainer // when the Run's text content is set. Setting this property now will cause TextContainer // changes that get us into trouble in the middle of undo. if (property.Property == Run.TextProperty) { continue; } BindingExpressionBase expr = property.Value as BindingExpressionBase; if (expr != null) { // We can't duplicate a binding so copy over the current value instead. textElement.SetValue(property.Property, expr.Value); } else { textElement.SetValue(property.Property, property.Value); } } } finally { EndChange(); } }