/// <summary> /// Modifies the source data before passing it to the target for display in the UI. /// </summary> /// <param name="value">The source data being passed to the target.</param> /// <param name="targetType">The <see cref="Type"/> of data expected by the target dependency property.</param> /// <param name="parameter">An optional parameter to be used in the converter logic.</param> /// <param name="culture">The culture of the conversion.</param> /// <returns>The value to be passed to the target dependency property.</returns> public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value == null) { return(null); } object result = null; Type resourceType = value.GetType(); // Simplest cases: The target type is object or same as the input. if (targetType.Equals(typeof(System.Object)) || resourceType.Equals(targetType)) { return(value); } // Register missing type converters - this class will do this only once per appdomain. RegisterMissingTypeConverters.Register(); // Is the type already known? if (!TypeConverters.ContainsKey(targetType)) { var c = TypeDescriptor.GetConverter(targetType); if (targetType == typeof(Thickness)) { c = new TypeConverters.ThicknessConverter(); } // Get the type converter and store it in the dictionary (even if it is NULL). TypeConverters.Add(targetType, c); } // Get the converter. TypeConverter conv = TypeConverters[targetType]; // No converter or not convertable? if ((conv == null) || !conv.CanConvertFrom(resourceType)) { return(null); } // Finally, try to convert the value. try { result = conv.ConvertFrom(value); } catch { result = null; } return(result); }
/// <summary> /// Modifies the source data before passing it to the target for display in the UI. /// </summary> /// <param name="value">The source data being passed to the target.</param> /// <param name="targetType">The <see cref="Type"/> of data expected by the target dependency property.</param> /// <param name="parameter">An optional parameter to be used in the converter logic.</param> /// <param name="culture">The culture of the conversion.</param> /// <returns>The value to be passed to the target dependency property.</returns> public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value == null) return null; object result = null; Type resourceType = value.GetType(); // Simplest cases: The target type is object or same as the input. if (targetType.Equals(typeof(System.Object)) || resourceType.Equals(targetType)) return value; // Register missing type converters - this class will do this only once per appdomain. RegisterMissingTypeConverters.Register(); // Is the type already known? if (!TypeConverters.ContainsKey(targetType)) { var c = TypeDescriptor.GetConverter(targetType); if (targetType == typeof(Thickness)) c = new TypeConverters.ThicknessConverter(); // Get the type converter and store it in the dictionary (even if it is NULL). TypeConverters.Add(targetType, c); } // Get the converter. TypeConverter conv = TypeConverters[targetType]; // No converter or not convertable? if ((conv == null) || !conv.CanConvertFrom(resourceType)) return null; // Finally, try to convert the value. try { result = conv.ConvertFrom(value); } catch { result = null; } return result; }
/// <summary> /// Modifies the source data before passing it to the target for display in the UI. /// </summary> /// <param name="value">The source data being passed to the target.</param> /// <param name="targetType">The <see cref="Type"/> of data expected by the target dependency property.</param> /// <param name="parameter">An optional parameter to be used in the converter logic.</param> /// <param name="culture">The culture of the conversion.</param> /// <returns>The value to be passed to the target dependency property.</returns> public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value == null) return null; object result = null; Type resourceType = value.GetType(); // Simplest cases: The target type is object or same as the input. if (targetType.Equals(typeof(System.Object)) || resourceType.Equals(targetType)) return value; #if SILVERLIGHT // Is the type already known? if (!TypeConverters.ContainsKey(targetType)) { if (typeof(Enum).IsAssignableFrom(targetType)) { TypeConverters.Add(targetType, new TypeConverters.EnumConverter(targetType)); } else { Type converterType = null; var attributes = targetType.GetCustomAttributes(typeof(TypeConverterAttribute), false); if (attributes.Length == 1) { var converterAttribute = (TypeConverterAttribute)attributes[0]; converterType = Type.GetType(converterAttribute.ConverterTypeName); } if (converterType == null) { // Find a suitable "common" converter. if (targetType == typeof(double)) converterType = typeof(TypeConverters.DoubleConverter); else if (targetType == typeof(Thickness)) converterType = typeof(TypeConverters.ThicknessConverter); else if (targetType == typeof(Brush)) converterType = typeof(TypeConverters.BrushConverter); else return value; } // Get the type converter and store it in the dictionary (even if it is NULL). TypeConverters.Add(targetType, Activator.CreateInstance(converterType) as TypeConverter); } } #else // Register missing type converters - this class will do this only once per appdomain. RegisterMissingTypeConverters.Register(); // Is the type already known? if (!TypeConverters.ContainsKey(targetType)) { var c = TypeDescriptor.GetConverter(targetType); if (targetType == typeof(Thickness)) c = new TypeConverters.ThicknessConverter(); // Get the type converter and store it in the dictionary (even if it is NULL). TypeConverters.Add(targetType, c); } #endif // Get the converter. TypeConverter conv = TypeConverters[targetType]; // No converter or not convertable? if ((conv == null) || !conv.CanConvertFrom(resourceType)) return null; // Finally, try to convert the value. try { result = conv.ConvertFrom(value); } catch { result = null; } return result; }
/// <summary> /// Modifies the source data before passing it to the target for display in the UI. /// </summary> /// <param name="value">The source data being passed to the target.</param> /// <param name="targetType">The <see cref="Type"/> of data expected by the target dependency property.</param> /// <param name="parameter">An optional parameter to be used in the converter logic.</param> /// <param name="culture">The culture of the conversion.</param> /// <returns>The value to be passed to the target dependency property.</returns> public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value == null) { return(null); } object result = null; Type resourceType = value.GetType(); // Simplest cases: The target type is object or same as the input. if (targetType.Equals(typeof(System.Object)) || resourceType.Equals(targetType)) { return(value); } #if SILVERLIGHT // Is the type already known? if (!TypeConverters.ContainsKey(targetType)) { if (typeof(Enum).IsAssignableFrom(targetType)) { TypeConverters.Add(targetType, new TypeConverters.EnumConverter(targetType)); } else { Type converterType = null; var attributes = targetType.GetCustomAttributes(typeof(TypeConverterAttribute), false); if (attributes.Length == 1) { var converterAttribute = (TypeConverterAttribute)attributes[0]; converterType = Type.GetType(converterAttribute.ConverterTypeName); } if (converterType == null) { // Find a suitable "common" converter. if (targetType == typeof(double)) { converterType = typeof(TypeConverters.DoubleConverter); } else if (targetType == typeof(Thickness)) { converterType = typeof(TypeConverters.ThicknessConverter); } else if (targetType == typeof(Brush)) { converterType = typeof(TypeConverters.BrushConverter); } else { return(value); } } // Get the type converter and store it in the dictionary (even if it is NULL). TypeConverters.Add(targetType, Activator.CreateInstance(converterType) as TypeConverter); } } #else // Register missing type converters - this class will do this only once per appdomain. RegisterMissingTypeConverters.Register(); // Is the type already known? if (!TypeConverters.ContainsKey(targetType)) { var c = TypeDescriptor.GetConverter(targetType); if (targetType == typeof(Thickness)) { c = new TypeConverters.ThicknessConverter(); } // Get the type converter and store it in the dictionary (even if it is NULL). TypeConverters.Add(targetType, c); } #endif // Get the converter. TypeConverter conv = TypeConverters[targetType]; // No converter or not convertable? if ((conv == null) || !conv.CanConvertFrom(resourceType)) { return(null); } // Finally, try to convert the value. try { result = conv.ConvertFrom(value); } catch { result = null; } return(result); }