/// <summary> /// Static ctor for Int16Animation establishes /// dependency properties, using as much shared data as possible. /// </summary> static Int16Animation() { Type typeofProp = typeof(Int16?); Type typeofThis = typeof(Int16Animation); PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed); ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue); FromProperty = DependencyProperty.Register( "From", typeofProp, typeofThis, new PropertyMetadata((Int16?)null, propCallback), validateCallback); ToProperty = DependencyProperty.Register( "To", typeofProp, typeofThis, new PropertyMetadata((Int16?)null, propCallback), validateCallback); ByProperty = DependencyProperty.Register( "By", typeofProp, typeofThis, new PropertyMetadata((Int16?)null, propCallback), validateCallback); EasingFunctionProperty = DependencyProperty.Register( "EasingFunction", typeof(IEasingFunction), typeofThis); }
public void SetValue(DependencyProperty dp, object value) { if (IsSealed) { throw new InvalidOperationException("Cannot manipulate property values on a sealed DependencyObject"); } //if (!dp.IsValidType (value)) // throw new ArgumentException ("value not of the correct type for this DependencyProperty"); ValidateValueCallback validate = dp.ValidateValueCallback; if (validate != null && !validate(value)) { throw new Exception("Value does not validate"); } object oldValue = null; if (properties.ContainsKey(dp)) { oldValue = properties[dp]; } properties[dp] = value; if (oldValue != null) { OnPropertyChanged(new DependencyPropertyChangedEventArgs(dp, oldValue, value)); } }
public static DependencyProperty Register( string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { PropertyMetadata defaultMetadata; if (typeMetadata == null) { defaultMetadata = typeMetadata = new PropertyMetadata(); } else { defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue); } DependencyProperty dp = new DependencyProperty( false, name, propertyType, ownerType, defaultMetadata, validateValueCallback); DependencyObject.Register(ownerType, dp); dp.OverrideMetadata(ownerType, typeMetadata); return dp; }
private DependencyProperty(bool isAttached, string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { if (defaultMetadata == null) { defaultMetadata = new PropertyMetadata(); } if (defaultMetadata.DefaultValue == null) { var defaultValue = AutoDefaultValue(propertyType); if (validateValueCallback != null && !validateValueCallback(defaultValue)) { throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Failed to auto generate default value."), "defaultMetadata"); } defaultMetadata.DefaultValue = defaultValue; } _globalIndex = System.Threading.Interlocked.Increment(ref _lastGlobalIndex); IsAttached = isAttached; DefaultMetadata = defaultMetadata; Name = name; OwnerType = ownerType; PropertyType = propertyType; ValidateValueCallback = validateValueCallback; }
static PlaneDP() { FrameworkPropertyMetadata fpm = new FrameworkPropertyMetadata(); fpm.PropertyChangedCallback = ChangedCB; fpm.BindsTwoWayByDefault = true; fpm.DefaultValue = 0; PropertyChangedCallback pcc = ChangedCB; PropertyMetadata pm = new PropertyMetadata(0, (o, d) => { MessageBox.Show("Changed 1"); }, (o, d) => { /* MessageBox.Show("Changed 2");*/ return(0); } ); // FrameworkPropertyMetadata fpm = new FrameworkPropertyMetadata(0, FrameworkPropertyMetadataOptions.None, (o, d) => { }, (o,d)=>{ return false; }); ValidateValueCallback validate = new ValidateValueCallback(value => { return((int)value >= 0); }); AltitudeProperty = DependencyProperty.Register( name: "Altitude", propertyType: typeof(int), ownerType: typeof(PlaneDP) , typeMetadata: fpm, validateValueCallback: validate); //MaxDistanceProperty = DependencyProperty.Register("Distance", typeof(int), typeof(PlaneDP), fpm, validate); //FuelLevelProperty = DependencyProperty.Register("FuelLevel",typeof(int), typeof(PlaneDP), fpm, validate); // CurrentLoadProperty = DependencyProperty.Register("Load", typeof(int), typeof(PlaneDP), fpm, validate); PlaneDP.ExceedEvent = EventManager.RegisterRoutedEvent( "Exceed", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(SampleDP)); }
/// <summary> /// Static ctor for QuaternionAnimation establishes /// dependency properties, using as much shared data as possible. /// </summary> static QuaternionAnimation() { Type typeofProp = typeof(Quaternion?); Type typeofThis = typeof(QuaternionAnimation); PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed); ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue); FromProperty = DependencyProperty.Register( "From", typeofProp, typeofThis, new PropertyMetadata((Quaternion?)null, propCallback), validateCallback); ToProperty = DependencyProperty.Register( "To", typeofProp, typeofThis, new PropertyMetadata((Quaternion?)null, propCallback), validateCallback); ByProperty = DependencyProperty.Register( "By", typeofProp, typeofThis, new PropertyMetadata((Quaternion?)null, propCallback), validateCallback); EasingFunctionProperty = DependencyProperty.Register( "EasingFunction", typeof(IEasingFunction), typeofThis); }
private static DependencyProperty Register( string propName, Type ownerType, PropertyMetadata typeMetadata = null, ValidateValueCallback validateValueCallback = null) { PropertyInfo property = ownerType.GetProperty(propName); if (property == null) { throw new DependencyHelperException($"'{propName}'속성을 찾을 수 없습니다."); } if (typeMetadata == null && validateValueCallback == null) { return(DependencyProperty.Register(propName, property.PropertyType, ownerType)); } else if (typeMetadata != null) { if (validateValueCallback == null) { return(DependencyProperty.Register(propName, property.PropertyType, ownerType, typeMetadata)); } else { return(DependencyProperty.Register(propName, property.PropertyType, ownerType, typeMetadata, validateValueCallback)); } } throw new ArgumentException(); }
public static DependencyProperty Register( string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { PropertyMetadata defaultMetadata; if (typeMetadata == null) { defaultMetadata = typeMetadata = new PropertyMetadata(); } else { defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue); } DependencyProperty dp = new DependencyProperty( false, name, propertyType, ownerType, defaultMetadata, validateValueCallback); DependencyObject.Register(ownerType, dp); dp.OverrideMetadata(ownerType, typeMetadata); return(dp); }
public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { // TODO: What should differ for attached properties??? return(Register(name, propertyType, ownerType, defaultMetadata, validateValueCallback)); }
private DependencyProperty(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { _name = name; _propertyType = propertyType; _ownerType = ownerType; _defaultMetadata = defaultMetadata; _validateValueCallback = validateValueCallback; Flags flags = default(Flags); lock (Synchronized) { flags = (Flags)GetUniqueGlobalIndex(ownerType, name); RegisteredPropertyList.Add(this); } if (propertyType.IsValueType) { flags |= Flags.IsValueType; } if (propertyType == typeof(object)) { flags |= Flags.IsObjectType; } if (typeof(Freezable).IsAssignableFrom(propertyType)) { flags |= Flags.IsFreezableType; } if (propertyType == typeof(string)) { flags |= Flags.IsStringType; } _packedData = flags; }
void CreateReadOnlyDependencyProperty( bool isAttached, T identifier, string name, Type propertyType, FrameworkPropertyMetadata metaData, ValidateValueCallback validateValueCallback) { DependencyPropertyKey propertyKey; if (isAttached) { propertyKey = DependencyProperty.RegisterAttachedReadOnly( name, propertyType, OwnerType, metaData, validateValueCallback); } else { propertyKey = DependencyProperty.RegisterReadOnly( name, propertyType, OwnerType, metaData, validateValueCallback); } _readOnlyProperties.Add(identifier, propertyKey); DependencyProperty property = propertyKey.DependencyProperty; Properties.Add(identifier, property); }
/// <summary> Initializes a new instance of the BusinessValueMetadata class with the specified settings and callbacks. /// </summary> /// <param name="settings"></param> /// <param name="validateValueCallback">A reference to a callback that should perform any custom validation of the business value value beyond typical type validation.</param> /// <param name="valueChangedCallback">A reference to a handler implementation that the property system will call whenever the effective value of the property changes.</param> /// <param name="coerceValueCallback">A reference to a handler implementation will be called whenever the property system calls CoerceValue for the business value.</param> public BusinessValueMetadata(IValueSettings settings, ValidateValueCallback validateValueCallback, BusinessValueChangedCallback valueChangedCallback, CoerceValueCallback coerceValueCallback) { _settings = settings; _validateValueCallback = validateValueCallback; _valueChangedCallback = valueChangedCallback; _coerceValueCallback = coerceValueCallback; }
static CornerRadiusAnimation() { Type typeofProp = typeof(CornerRadius?); Type typeofThis = typeof(CornerRadiusAnimation); PropertyChangedCallback propCallback = new PropertyChangedCallback(AnimationFunction_Changed); ValidateValueCallback validateCallback = new ValidateValueCallback(ValidateFromToOrByValue); FromProperty = DependencyProperty.Register( "From", typeofProp, typeofThis, new PropertyMetadata((CornerRadius?)null, propCallback), validateCallback); ToProperty = DependencyProperty.Register( "To", typeofProp, typeofThis, new PropertyMetadata((CornerRadius?)null, propCallback), validateCallback); ByProperty = DependencyProperty.Register( "By", typeofProp, typeofThis, new PropertyMetadata((CornerRadius?)null, propCallback), validateCallback); }
internal FunctionalProperty(string name, Type propertyType, Type ownerType, FunctionalPropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { Name = name; PropertyType = propertyType; OwnerType = ownerType; DefaultMetadata = typeMetadata; ValidateValueCallback = validateValueCallback; }
private static RadPropertyMetadata AutoGeneratePropertyMetadata( Type propertyType, ValidateValueCallback validateValueCallback, string name, Type ownerType) { return(new RadPropertyMetadata(RadProperty.AutoGenerateDefaultValue(propertyType))); }
public static DependencyPropertyKey RegisterAttachedReadOnly( string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { throw new NotImplementedException("RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)"); }
/// <summary> Initializes a new instance of the <see cref="ViewModelProperty"/> class. /// </summary> /// <param name="name">The name of the property</param> /// <param name="propertyType">Type of the property.</param> /// <param name="ownerType">Type of the owner.</param> /// <param name="typeMetadata">The type metadata.</param> /// <param name="validateValueCallback">The validate value callback.</param> /// <param name="readOnly">if set to <c>true</c> [read only].</param> /// <remarks></remarks> protected ViewModelProperty(string name, Type propertyType, Type ownerType, ViewModelMetadata typeMetadata, ValidateValueCallback validateValueCallback, bool readOnly) { _Name = name; _PropertyType = propertyType; _OwnerType = ownerType; _DefaultMetadata = typeMetadata; _ValidateValueCallback = validateValueCallback; _ReadOnly = readOnly; }
public static DependencyPropertyKey RegisterReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { DependencyProperty prop = Register(name, propertyType, ownerType, typeMetadata, validateValueCallback); prop.ReadOnly = true; return(new DependencyPropertyKey(prop)); }
// Methods static LinearGradientBrushAnimation() { Type propertyType = typeof(LinearGradientBrush); Type ownerType = typeof(LinearGradientBrushAnimation); PropertyChangedCallback propertyChangedCallback = new PropertyChangedCallback(LinearGradientBrushAnimation.AnimationFunction_Changed); ValidateValueCallback validateValueCallback = new ValidateValueCallback(LinearGradientBrushAnimation.ValidateValues); FromProperty = DependencyProperty.Register("From", propertyType, ownerType, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); ToProperty = DependencyProperty.Register("To", propertyType, ownerType, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); }
public static DependencyProperty <AnyType> Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { DependencyProperty <AnyType> retVal = new DependencyProperty <AnyType>(name, propertyType, ownerType, typeMetadata, validateValueCallback); dependencyPropertyList.Add(retVal); return(retVal); }
public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { DependencyProperty dp = new DependencyProperty(true, name, propertyType, ownerType, defaultMetadata, validateValueCallback); DependencyObject.register(ownerType, dp); return(dp); }
public static RadProperty RegisterAttached( string name, Type propertyType, Type ownerType, RadPropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { RadProperty.RegisterParameterValidation(name, propertyType, ownerType); return(RadProperty.RegisterCommon(name, propertyType, ownerType, AttachedPropertyUsage.Anywhere, typeMetadata, validateValueCallback)); }
private DependencyProperty(string aName, Type aPropertyType, Type anOwnerType, PropertyMetadata aTypeMetadata, ValidateValueCallback aValidateValueCallback) { name = aName; propertyType = aPropertyType; ownerType = anOwnerType; typeMetadata = aTypeMetadata; validateValueCallback = aValidateValueCallback; }
private DependencyProperty(bool isAttached, string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { IsAttached = isAttached; DefaultMetadata = (defaultMetadata == null ? new PropertyMetadata() : defaultMetadata); Name = name; OwnerType = ownerType; PropertyType = propertyType; ValidateValueCallback = validateValueCallback; }
private DependencyProperty (bool isAttached, string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { IsAttached = isAttached; DefaultMetadata = (defaultMetadata == null ? new PropertyMetadata() : defaultMetadata); Name = name; OwnerType = ownerType; PropertyType = propertyType; ValidateValueCallback = validateValueCallback; }
private DependencyProperty(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { _name = name; _propertyType = propertyType; _ownerType = ownerType; _defaultMetadata = defaultMetadata; _validateValueCallback = validateValueCallback; _properties[name + ownerType] = this; }
///<exception cref="ArgumentException"></exception> public static DependencyPropertyKey RegisterReadOnly <TOwner, TProperty>( Expression <Func <TOwner, TProperty> > propertyExpression, PropertyMetadata propertyMetadata = null, ValidateValueCallback validateValueCallback = null) { var name = PropertyNameExtractor.Extract(propertyExpression); var propertyKey = DependencyProperty.RegisterReadOnly( name, typeof(TProperty), typeof(TOwner), propertyMetadata, validateValueCallback); return(propertyKey); }
public static DependencyPropertyKey RegisterReadOnly <TOwner>( Expression <Func <TOwner, object> > property, PropertyMetadata metadata, ValidateValueCallback validateValueCallback) { return(DependencyProperty.RegisterReadOnly(typeof(TOwner).GetPropertyName(property), typeof(TOwner).GetPropertyType(property), typeof(TOwner), metadata, validateValueCallback)); }
// Token: 0x0600173A RID: 5946 RVA: 0x00071F14 File Offset: 0x00070114 static ThicknessAnimation() { Type typeFromHandle = typeof(Thickness?); Type typeFromHandle2 = typeof(ThicknessAnimation); PropertyChangedCallback propertyChangedCallback = new PropertyChangedCallback(ThicknessAnimation.AnimationFunction_Changed); ValidateValueCallback validateValueCallback = new ValidateValueCallback(ThicknessAnimation.ValidateFromToOrByValue); ThicknessAnimation.FromProperty = DependencyProperty.Register("From", typeFromHandle, typeFromHandle2, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); ThicknessAnimation.ToProperty = DependencyProperty.Register("To", typeFromHandle, typeFromHandle2, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); ThicknessAnimation.ByProperty = DependencyProperty.Register("By", typeFromHandle, typeFromHandle2, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); ThicknessAnimation.EasingFunctionProperty = DependencyProperty.Register("EasingFunction", typeof(IEasingFunction), typeFromHandle2); }
public void Should_Set_ValidateValueCallback() { ValidateValueCallback validateValueCallback = v => { return(true); }; DependencyProperty dp = DependencyProperty.Register( "Register_Should_Set_ValidateValueCallback", typeof(string), typeof(TestClass1), null, validateValueCallback); Assert.AreEqual(validateValueCallback, dp.ValidateValueCallback); }
static CornerAnimation() { var propertyType = typeof(CornerRadius?); var ownerType = typeof(CornerAnimation); PropertyChangedCallback propertyChangedCallback = AnimationFunction_Changed; ValidateValueCallback validateValueCallback = ValidateFromToOrByValue; FromProperty = DependencyProperty.Register("From", propertyType, ownerType, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); ToProperty = DependencyProperty.Register("To", propertyType, ownerType, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); ByProperty = DependencyProperty.Register("By", propertyType, ownerType, new PropertyMetadata(null, propertyChangedCallback), validateValueCallback); EasingFunctionProperty = DependencyProperty.Register("EasingFunction", typeof(IEasingFunction), ownerType); }
public void Should_Throw_ArgumentException_If_DefaultValid_Is_Invalid() { ValidateValueCallback validateValueCallback = v => { return(false); }; DependencyProperty dp = DependencyProperty.Register( "Register_Should_Throw_ArgumentException_If_DefaultValid_Is_Invalid", typeof(string), typeof(TestClass1), new PropertyMetadata("foobar"), validateValueCallback); }
private DependencyProperty(ValidateValueCallback validateValueCallback, PropertyMetadata defaultMetadata, Type ownerType, Type propertyType, string name, bool readOnly = false) { if (!ownerType.IsSubclassOf(typeof(DependencyObject))) { throw new ArgumentException($"ownerType 必须是继承于DependencyObject,ownerType类型{ownerType.FullName}"); } ValidateValueCallback = validateValueCallback; DefaultMetadata = defaultMetadata ?? throw new ArgumentException("defaultMetadata 不能为Null"); OwnerType = ownerType; PropertyType = propertyType; Name = name; GlobalIndex = ++id; ReadOnly = readOnly; }
/// <summary> /// Simple registration, metadata, validation, and a read-only property /// key. Calling this version restricts the property such that it can /// only be set via the corresponding overload of DependencyObject.SetValue. /// </summary> public static DependencyPropertyKey RegisterReadOnly( string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { RegisterParameterValidation(name, propertyType, ownerType); PropertyMetadata defaultMetadata = null; if (typeMetadata != null && typeMetadata.DefaultValueWasSet()) { defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue); } else { defaultMetadata = AutoGeneratePropertyMetadata(propertyType, validateValueCallback, name, ownerType); } // We create a DependencyPropertyKey at this point with a null property // and set that in the _readOnlyKey field. This is so the property is // marked as requiring a key immediately. If something fails in the // initialization path, the property is still marked as needing a key. // This is better than the alternative of creating and setting the key // later, because if that code fails the read-only property would not // be marked read-only. The intent of this mildly convoluted code // is so we fail securely. DependencyPropertyKey authorizationKey = new DependencyPropertyKey(null); // No property yet, use null as placeholder. DependencyProperty property = RegisterCommon(name, propertyType, ownerType, defaultMetadata, validateValueCallback); property._readOnlyKey = authorizationKey; authorizationKey.SetDependencyProperty(property); if (typeMetadata == null) { // No metadata specified, generate one so we can specify the authorized key. typeMetadata = AutoGeneratePropertyMetadata(propertyType, validateValueCallback, name, ownerType); } // Authorize registering type for read-only access, create key. #pragma warning suppress 6506 // typeMetadata is never null, since we generate default metadata if none is provided. // Apply type-specific metadata to owner type only property.OverrideMetadata(ownerType, typeMetadata, authorizationKey); return(authorizationKey); }
public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { PropertyMetadata defaultMetadata = null; if (typeMetadata != null && typeMetadata.DefaultValue != null) defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue); DependencyProperty dp = RegisterCommon(name, propertyType, ownerType, defaultMetadata, validateValueCallback); if (typeMetadata != null) dp.OverrideMetadata(ownerType, typeMetadata); else if (propertyType.IsValueType) dp.DefaultMetadata.DefaultValue = Activator.CreateInstance(propertyType); dp.ReadOnly = false; return dp; }
private DependencyProperty( bool isAttached, string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { if (defaultMetadata == null) { throw new ArgumentNullException("defaultMetadata"); } this.IsAttached = isAttached; this.DefaultMetadata = defaultMetadata; this.Name = name; this.OwnerType = ownerType; this.PropertyType = propertyType; this.ValidateValueCallback = validateValueCallback; }
/// <summary> /// Register a Dependency Property /// </summary> /// <param name="name">Name of property</param> /// <param name="propertyType">Type of the property</param> /// <param name="ownerType">Type that is registering the property</param> /// <param name="typeMetadata">Metadata to use if current type doesn't specify type-specific metadata</param> /// <param name="validateValueCallback">Provides additional value validation outside automatic type validation</param> /// <returns>Dependency Property</returns> public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { RegisterParameterValidation(name, propertyType, ownerType); // Register an attached property PropertyMetadata defaultMetadata = null; if (typeMetadata != null && typeMetadata.DefaultValueWasSet()) { defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue); } DependencyProperty property = RegisterCommon(name, propertyType, ownerType, defaultMetadata, validateValueCallback); if (typeMetadata != null) { // Apply type-specific metadata to owner type only property.OverrideMetadata(ownerType, typeMetadata); } return property; }
private DependencyProperty(bool isAttached, string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { if (defaultMetadata == null) defaultMetadata = new PropertyMetadata(); if (defaultMetadata.DefaultValue == null) { var defaultValue = AutoDefaultValue(propertyType); if (validateValueCallback != null && !validateValueCallback(defaultValue)) throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Failed to auto generate default value."), "defaultMetadata"); defaultMetadata.DefaultValue = defaultValue; } _globalIndex = System.Threading.Interlocked.Increment(ref _lastGlobalIndex); IsAttached = isAttached; DefaultMetadata = defaultMetadata; Name = name; OwnerType = ownerType; PropertyType = propertyType; ValidateValueCallback = validateValueCallback; }
public static FunctionalProperty Register(string name, Type propertyType, Type ownerType, FunctionalPropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { return FunctionalPropertyManager.Instance.Register(name, propertyType, ownerType, typeMetadata, validateValueCallback); }
internal static DependencyProperty RegisterProperty( string name, Type propertyType, Type ownerType, object defaultValue, PropertyChangedCallback changed, ValidateValueCallback validate, bool isIndependentlyAnimated, CoerceValueCallback coerced) { // Override metadata for this particular object type. This defines // the methods that will be called when property actions (setting, // getting, invalidating) are taken for this specific object type. UIPropertyMetadata propertyMetadata; // If this property is animated using a property resource, we create // AnimatablePropertyMetadata instead of UIPropertyMetadata. if (isIndependentlyAnimated) { propertyMetadata = new IndependentlyAnimatedPropertyMetadata(defaultValue); } else { propertyMetadata = new UIPropertyMetadata(defaultValue); } propertyMetadata.PropertyChangedCallback = changed; if (coerced != null) { propertyMetadata.CoerceValueCallback = coerced; } // Register property with passed in default metadata. The type of // defaultMetadata will determine whether this property is animatable. DependencyProperty dp = DependencyProperty.Register( name, propertyType, ownerType, propertyMetadata, validate); return dp; }
private static void ValidateDefaultValueCommon( object defaultValue, Type propertyType, string propertyName, ValidateValueCallback validateValueCallback, bool checkThreadAffinity) { // Ensure default value is the correct type if (!IsValidType(defaultValue, propertyType)) { throw new ArgumentException(SR.Get(SRID.DefaultValuePropertyTypeMismatch, propertyName)); } // An Expression used as default value won't behave as expected since // it doesn't get evaluated. We explicitly fail it here. if (defaultValue is Expression ) { throw new ArgumentException(SR.Get(SRID.DefaultValueMayNotBeExpression)); } if (checkThreadAffinity) { // If the default value is a DispatcherObject with thread affinity // we cannot accept it as a default value. If it implements ISealable // we attempt to seal it; if not we throw an exception. Types not // deriving from DispatcherObject are allowed - it is up to the user to // make any custom types free-threaded. DispatcherObject dispatcherObject = defaultValue as DispatcherObject; if (dispatcherObject != null && dispatcherObject.Dispatcher != null) { // Try to make the DispatcherObject free-threaded if it's an // ISealable. ISealable valueAsISealable = dispatcherObject as ISealable; if (valueAsISealable != null && valueAsISealable.CanSeal) { Invariant.Assert (!valueAsISealable.IsSealed, "A Sealed ISealable must not have dispatcher affinity"); valueAsISealable.Seal(); Invariant.Assert(dispatcherObject.Dispatcher == null, "ISealable.Seal() failed after ISealable.CanSeal returned true"); } else { throw new ArgumentException(SR.Get(SRID.DefaultValueMustBeFreeThreaded, propertyName)); } } } // After checking for correct type, check default value against // validator (when one is given) if ( validateValueCallback != null && !validateValueCallback(defaultValue)) { throw new ArgumentException(SR.Get(SRID.DefaultValueInvalid, propertyName)); } }
public static DependencyPropertyKey RegisterReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { DependencyProperty prop = Register (name, propertyType, ownerType, typeMetadata, validateValueCallback); prop.ReadOnly = true; return new DependencyPropertyKey (prop); }
public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { throw new NotImplementedException("RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)"); }
public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { DependencyProperty dp = new DependencyProperty(true, name, propertyType, ownerType, defaultMetadata, validateValueCallback); DependencyObject.register(ownerType, dp); return dp; }
private static DependencyProperty RegisterCommon(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { FromNameKey key = new FromNameKey(name, ownerType); lock (Synchronized) { if (PropertyFromName.Contains(key)) { throw new ArgumentException(SR.Get(SRID.PropertyAlreadyRegistered, name, ownerType.Name)); } } // Establish default metadata for all types, if none is provided if (defaultMetadata == null) { defaultMetadata = AutoGeneratePropertyMetadata( propertyType, validateValueCallback, name, ownerType ); } else // Metadata object is provided. { // If the defaultValue wasn't specified auto generate one if (!defaultMetadata.DefaultValueWasSet()) { defaultMetadata.DefaultValue = AutoGenerateDefaultValue(propertyType); } ValidateMetadataDefaultValue( defaultMetadata, propertyType, name, validateValueCallback ); } // Create property DependencyProperty dp = new DependencyProperty(name, propertyType, ownerType, defaultMetadata, validateValueCallback); // Seal (null means being used for default metadata, calls OnApply) defaultMetadata.Seal(dp, null); if (defaultMetadata.IsInherited) { dp._packedData |= Flags.IsPotentiallyInherited; } if (defaultMetadata.UsingDefaultValueFactory) { dp._packedData |= Flags.IsPotentiallyUsingDefaultValueFactory; } // Map owner type to this property // Build key lock (Synchronized) { PropertyFromName[key] = dp; } if( TraceDependencyProperty.IsEnabled ) { TraceDependencyProperty.TraceActivityItem( TraceDependencyProperty.Register, dp, dp.OwnerType ); } return dp; }
// Validate the default value in the given metadata private static void ValidateMetadataDefaultValue( PropertyMetadata defaultMetadata, Type propertyType, string propertyName, ValidateValueCallback validateValueCallback ) { // If we are registered to use the DefaultValue factory we can // not validate the DefaultValue at registration time, so we // early exit. if (defaultMetadata.UsingDefaultValueFactory) { return; } ValidateDefaultValueCommon(defaultMetadata.DefaultValue, propertyType, propertyName, validateValueCallback, /*checkThreadAffinity = */ true); }
private static DependencyProperty RegisterCommon(bool isAttached, string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback, bool isReadOnly) { var comparer = GetComparer(propertyType); if (defaultMetadata != null && propertyType.IsValueType && defaultMetadata.DefaultValue == DependencyProperty.UnsetValue) defaultMetadata = defaultMetadata.OverrideMetadata(Activator.CreateInstance(propertyType), validateValueCallback, comparer); if (validateValueCallback == null) { if (isReadOnly && defaultMetadata == null) defaultMetadata = GenerateDefaultMetadata(propertyType, comparer); else if (defaultMetadata != null) defaultMetadata = defaultMetadata.OverrideMetadata(null, comparer); } else if (defaultMetadata != null) { var isDefaultValueValid = validateValueCallback(defaultMetadata.DefaultValue); if (!isDefaultValueValid) throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Default value for '{0}' property is not valid because ValidateValueCallback failed.", name)); defaultMetadata = defaultMetadata.OverrideMetadata(validateValueCallback, comparer); } else { defaultMetadata = GenerateDefaultMetadata(propertyType, comparer); var isDefaultValueValid = validateValueCallback(defaultMetadata.DefaultValue); if (!isDefaultValueValid) throw new ArgumentException( string.Format( CultureInfo.InvariantCulture, "Cannot automatically generate a valid default value for property '{0}'. Specify a default value explicitly when owner type '{1}' is registering this DependencyProperty.", name, ownerType)); defaultMetadata = defaultMetadata.OverrideMetadata(validateValueCallback, comparer); } DependencyProperty dp; // if we do not need extended metadata then fallback to System.Windows.PropertyMetadata. if (!isReadOnly && validateValueCallback == null && defaultMetadata != null && defaultMetadata.CoerceValueCallback == null && !HasSupportedFlags(defaultMetadata.Flags)) { var simpleMetadata = new System.Windows.PropertyMetadata(defaultMetadata.DefaultValue, defaultMetadata.PropertyChangedCallback); dp = Register(isAttached, name, propertyType, ownerType, simpleMetadata); } else { dp = Register(isAttached, name, propertyType, ownerType, defaultMetadata); RememberMetadata(dp, defaultMetadata); } if (isReadOnly) readonlyDP.Add(dp); return dp; }
/// <summary> /// Registers an attached property with the specified property name, property type, owner type, and property metadata. /// </summary> /// <param name="name"> /// The name of the dependency property to register. /// </param> /// <param name="propertyType"> /// The type of the property. /// </param> /// <param name="ownerType"> /// The owner type that is registering the dependency property. /// </param> /// <param name="typeMetadata"> /// Property metadata for the dependency property. /// </param> /// <param name="validateValueCallback"> /// Callback that validates the new value for the dependency property. /// </param> /// <returns> /// A dependency property identifier that should be used to set the value of a public static readonly field in your class. That identifier is then used to reference the dependency property later, for operations such as setting its value programmatically or obtaining metadata. /// </returns> public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { #if WPF return DependencyProperty.RegisterAttached(name, propertyType, ownerType, typeMetadata, validateValueCallback); #else return RegisterCommon(true, name, propertyType, ownerType, typeMetadata, validateValueCallback, false); #endif }
private static DependencyProperty RegisterCommon(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { if (string.IsNullOrWhiteSpace(name)) throw new ArgumentNullException("name"); if (propertyType == null) throw new ArgumentNullException("propertyType"); if (ownerType == null) throw new ArgumentNullException("ownerType"); FromNameKey key = new FromNameKey(name, ownerType); if (_PropertyFromName.Contains(key)) throw new ArgumentException("The property \"" + name + "\" is exists for \"" + ownerType.FullName + "\""); if (typeMetadata == null) typeMetadata = new PropertyMetadata(); DependencyProperty dp = new DependencyProperty(); dp.Name = name; dp.PropertyType = propertyType; dp.OwnerType = ownerType; dp.DefaultMetadata = typeMetadata; dp.ValidateValueCallback = validateValueCallback; _PropertyFromName.Add(key, dp); return dp; }
public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { DependencyProperty dp = RegisterAttached(name, propertyType, ownerType, typeMetadata, validateValueCallback); dp.ReadOnly = true; DependencyPropertyKey key = new DependencyPropertyKey(dp); return key; }
public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { DependencyProperty dp = RegisterCommon(name, propertyType, ownerType, typeMetadata, validateValueCallback); if (propertyType.IsValueType && dp.DefaultMetadata.DefaultValue == null) dp.DefaultMetadata.DefaultValue = Activator.CreateInstance(propertyType); dp.ReadOnly = false; return dp; }
internal DependencyPropertyKey(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { _dependencyProperty = DependencyProperty.Register(name, propertyType, ownerType, defaultMetadata, validateValueCallback); }
/// <summary> /// Registers a read-only dependency property with the specified property name, property type, owner type, and property metadata. /// </summary> /// <param name="name"> /// The name of the dependency property to register. /// </param> /// <param name="propertyType"> /// The type of the property. /// </param> /// <param name="ownerType"> /// The owner type that is registering the dependency property. /// </param> /// <param name="typeMetadata"> /// Property metadata for the dependency property. /// </param> /// <param name="validateValueCallback"> /// Callback that validates the new value for the dependency property. /// </param> /// <returns> /// A dependency property identifier that should be used to set the value of a public static readonly field in your class. That identifier is then used to reference the dependency property later, for operations such as setting its value programmatically or obtaining metadata. /// </returns> public static DependencyPropertyKey RegisterReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback) { #if WPF return DependencyProperty.RegisterReadOnly(name, propertyType, ownerType, typeMetadata, validateValueCallback); #else var dp = RegisterCommon(false, name, propertyType, ownerType, typeMetadata, validateValueCallback, true); return new DependencyPropertyKey(dp); #endif }
/// <summary> /// Simple registration, metadata, validation, and a read-only property /// key. Calling this version restricts the property such that it can /// only be set via the corresponding overload of DependencyObject.SetValue. /// </summary> public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { RegisterParameterValidation(name, propertyType, ownerType); // Establish default metadata for all types, if none is provided if (defaultMetadata == null) { defaultMetadata = AutoGeneratePropertyMetadata( propertyType, validateValueCallback, name, ownerType ); } // We create a DependencyPropertyKey at this point with a null property // and set that in the _readOnlyKey field. This is so the property is // marked as requiring a key immediately. If something fails in the // initialization path, the property is still marked as needing a key. // This is better than the alternative of creating and setting the key // later, because if that code fails the read-only property would not // be marked read-only. The intent of this mildly convoluted code // is so we fail securely. DependencyPropertyKey authorizedKey = new DependencyPropertyKey(null); DependencyProperty property = RegisterCommon( name, propertyType, ownerType, defaultMetadata, validateValueCallback); property._readOnlyKey = authorizedKey; authorizedKey.SetDependencyProperty(property); return authorizedKey; }
private DependencyProperty(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { _name = name; _propertyType = propertyType; _ownerType = ownerType; _defaultMetadata = defaultMetadata; _validateValueCallback = validateValueCallback; Flags packedData; lock (Synchronized) { packedData = (Flags) GetUniqueGlobalIndex(ownerType, name); RegisteredPropertyList.Add(this); } if (propertyType.IsValueType) { packedData |= Flags.IsValueType; } if (propertyType == typeof(object)) { packedData |= Flags.IsObjectType; } if (typeof(Freezable).IsAssignableFrom(propertyType)) { packedData |= Flags.IsFreezableType; } if (propertyType == typeof(string)) { packedData |= Flags.IsStringType; } _packedData = packedData; }
/// <summary> /// Simple registration, metadata, validation, and a read-only property /// key. Calling this version restricts the property such that it can /// only be set via the corresponding overload of DependencyObject.SetValue. /// </summary> public static DependencyPropertyKey RegisterReadOnly( string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback ) { RegisterParameterValidation(name, propertyType, ownerType); PropertyMetadata defaultMetadata = null; if (typeMetadata != null && typeMetadata.DefaultValueWasSet()) { defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue); } else { defaultMetadata = AutoGeneratePropertyMetadata(propertyType,validateValueCallback,name,ownerType); } // We create a DependencyPropertyKey at this point with a null property // and set that in the _readOnlyKey field. This is so the property is // marked as requiring a key immediately. If something fails in the // initialization path, the property is still marked as needing a key. // This is better than the alternative of creating and setting the key // later, because if that code fails the read-only property would not // be marked read-only. The intent of this mildly convoluted code // is so we fail securely. DependencyPropertyKey authorizationKey = new DependencyPropertyKey(null); // No property yet, use null as placeholder. DependencyProperty property = RegisterCommon(name, propertyType, ownerType, defaultMetadata, validateValueCallback); property._readOnlyKey = authorizationKey; authorizationKey.SetDependencyProperty(property); if (typeMetadata == null ) { // No metadata specified, generate one so we can specify the authorized key. typeMetadata = AutoGeneratePropertyMetadata(propertyType,validateValueCallback,name,ownerType); } // Authorize registering type for read-only access, create key. #pragma warning suppress 6506 // typeMetadata is never null, since we generate default metadata if none is provided. // Apply type-specific metadata to owner type only property.OverrideMetadata(ownerType, typeMetadata, authorizationKey); return authorizationKey; }
/// <summary> /// Register an attached Dependency Property /// </summary> /// <param name="name">Name of property</param> /// <param name="propertyType">Type of the property</param> /// <param name="ownerType">Type that is registering the property</param> /// <param name="defaultMetadata">Metadata to use if current type doesn't specify type-specific metadata</param> /// <param name="validateValueCallback">Provides additional value validation outside automatic type validation</param> /// <returns>Dependency Property</returns> public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback) { RegisterParameterValidation(name, propertyType, ownerType); return RegisterCommon( name, propertyType, ownerType, defaultMetadata, validateValueCallback ); }
private static PropertyMetadata AutoGeneratePropertyMetadata( Type propertyType, ValidateValueCallback validateValueCallback, string name, Type ownerType) { // Default per-type metadata not provided, create object defaultValue = AutoGenerateDefaultValue(propertyType); // If a validator is passed in, see if the default value makes sense. if ( validateValueCallback != null && !validateValueCallback(defaultValue)) { // Didn't work - require the caller to specify one. throw new ArgumentException(SR.Get(SRID.DefaultValueAutoAssignFailed, name, ownerType.Name)); } return new PropertyMetadata(defaultValue); }