private static object ConvertToPropertyType(object value, DependencyProperty dp, BindingExression be, IDataContextProvider source) { if (be.Log) { _logger.Debug("value: " + value); } if (be.Converter != null) { return(ApplyConverter(dp, be, value, source)); } if (value == null || (value as string) == string.Empty || value == DependencyProperty.UnsetValue) { return(dp.GetDefaultValue()); } var converter = TypeDescriptor.GetConverter(value.GetType()); if (dp.PropertyType is IEnumerable <object> && value is MultiArticleField) { return(((MultiArticleField)value).Items.Values); } if (dp.PropertyType.IsInstanceOfType(value)) { return(value); } if (dp.PropertyType == typeof(object)) { return(value); } return(converter.ConvertTo(value, dp.PropertyType)); }
object ConvertToType(DependencyProperty dp, object value) { try { if (!PropertyPathWalker.IsPathBroken && Binding.Converter != null) { value = Binding.Converter.Convert( value, Property.PropertyType, Binding.ConverterParameter, GetConverterCulture() ); } if (value == DependencyProperty.UnsetValue || PropertyPathWalker.IsPathBroken) { value = Binding.FallbackValue ?? dp.GetDefaultValue(Target); } else if (value == null) { value = Binding.TargetNullValue; if (value == null && IsBoundToAnyDataContext && string.IsNullOrEmpty(Binding.Path.Path)) { value = dp.GetDefaultValue(Target); } } else { string format = Binding.StringFormat; if (!string.IsNullOrEmpty(format)) { if (!format.Contains("{0")) { format = "{0:" + format + "}"; } value = string.Format(GetConverterCulture(), format, value); } } if (value != null) { value = ConvertFromSourceToTarget(value); } } catch (Exception ex) { return(MoonlightTypeConverter.ConvertObject(dp, Binding.FallbackValue, Target.GetType(), true)); } return(value); }
internal override object GetValue(DependencyProperty dp) { if (cached) { return(cachedValue); } cached = true; if (PropertyPathWalker.IsPathBroken) { cachedValue = null; } else { cachedValue = PropertyPathWalker.Value; } try { cachedValue = ConvertToType(dp, cachedValue); } catch { cachedValue = dp.GetDefaultValue(Target); } return(cachedValue); }
// Helper method to update this panel's state related to children rendering order handling private void RecomputeZState() { int count = (_uiElementCollection != null) ? _uiElementCollection.Count : 0; bool isDiverse = false; bool lutRequired = false; int zIndexDefaultValue = (int)ZIndexProperty.GetDefaultValue(DependencyObjectType); int consonant = zIndexDefaultValue; System.Collections.Generic.List <Int64> stableKeyValues = null; if (count > 0) { if (_uiElementCollection[0] != null) { consonant = (int)_uiElementCollection[0].GetValue(ZIndexProperty); } if (count > 1) { stableKeyValues = new System.Collections.Generic.List <Int64>(count); stableKeyValues.Add((Int64)consonant << 32); int prevZ = consonant; int i = 1; do { int z = _uiElementCollection[i] != null ? (int)_uiElementCollection[i].GetValue(ZIndexProperty) : zIndexDefaultValue; // this way of calculating values of stableKeyValues required to // 1) workaround the fact that Array.Sort is not stable (does not preserve the original // order of elements if the keys are equal) // 2) avoid O(N^2) performance of Array.Sort, which is QuickSort, which is known to become O(N^2) // on sorting N eqial keys stableKeyValues.Add(((Int64)z << 32) + i); // look-up-table is required iff z's are not monotonically increasing function of index. // in other words if stableKeyValues[i] >= stableKeyValues[i-1] then calculated look-up-table // is guaranteed to be degenerated... lutRequired |= z < prevZ; prevZ = z; isDiverse |= (z != consonant); } while (++i < count); } } if (lutRequired) { stableKeyValues.Sort(); if (_zLut == null || _zLut.Length != count) { _zLut = new int[count]; } for (int i = 0; i < count; ++i) { _zLut[i] = (int)(stableKeyValues[i] & 0xffffffff); } } else { _zLut = null; } IsZStateDiverse = isDiverse; _zConsonant = consonant; IsZStateDirty = false; }
private int[] _zLut; // look up table for converting from logical to visual indices /// <summary> /// Default DependencyObject constructor /// </summary> /// <remarks> /// Automatic determination of current Dispatcher. Use alternative constructor /// that accepts a Dispatcher for best performance. /// </remarks> protected Panel() : base() { _zConsonant = (int)ZIndexProperty.GetDefaultValue(DependencyObjectType); }