void IBindingList <T> .ApplySort(
SCM.PropertyDescriptor property,
SCM.ListSortDirection direction
)
{
AsBindingList.ApplySort(property, direction);
}
protected override void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor)
{
switch (propertyDescriptor.Name)
{
case "AllowedModes":
var valueName = string.Concat(bindingContext.ModelName, ".", propertyDescriptor.Name);
var valueObject = bindingContext.ValueProvider.GetValue(valueName);
if (valueObject != null)
{
// One or more selected - default behaviour is fine
base.BindProperty(controllerContext, bindingContext, propertyDescriptor);
}
else
{
// None selected, blank it out
SetProperty(controllerContext, bindingContext, propertyDescriptor, new List<UrlPickerMode>());
}
break;
default:
base.BindProperty(controllerContext, bindingContext, propertyDescriptor);
break;
}
}
public LoginViewDesignerRegion(ControlDesigner owner, object obj, ITemplate template, System.ComponentModel.PropertyDescriptor descriptor, TemplateDefinition definition) : base(definition)
{
this._template = template;
this._object = obj;
this._prop = descriptor;
base.EnsureSize = true;
}
public SortExpression(string propertyName, ListSortDirection sortDirection)
{
this.PropertyName = propertyName;
this.SortDirection = sortDirection;
this.PropertyDescriptor = null;
this.a = new Hashtable();
}
private void SetPackageAsDirty(IDTSSequence container, string expression, object objectChanged)
{
try
{
if (!string.IsNullOrEmpty(expression))
{
shouldSkipExpressionHighlighting = true; //this flag is used by the expression highlighter to skip re-highlighting if all that's changed is the string of an existing expression... if one has been removed, then re-highlight
}
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(objectChanged);
System.ComponentModel.PropertyDescriptor expressionsProperty = properties.Find("Expressions", false);
// Mark package object as dirty
IComponentChangeService changeService = (IComponentChangeService)designer.GetService(typeof(IComponentChangeService));
if (objectChanged == null)
{
changeService.OnComponentChanging(container, null);
changeService.OnComponentChanged(container, null, null, null); //marks the package designer as dirty
}
else
{
changeService.OnComponentChanging(objectChanged, expressionsProperty);
changeService.OnComponentChanged(objectChanged, expressionsProperty, null, null); //marks the package designer as dirty
}
if (container is Package)
{
SSISHelpers.MarkPackageDirty((Package)container);
}
}
finally
{
shouldSkipExpressionHighlighting = false;
}
}
public SortExpression(string propertyName)
{
this.PropertyName = propertyName;
this.SortDirection = ListSortDirection.Ascending;
this.PropertyDescriptor = null;
this.a = new Hashtable();
}
internal bool IsSelectable()
{
Object runtimeComp = this.RuntimeComponent;
Debug.Assert(runtimeComp != null);
// the selected datasource must not be private
MemberAttributes modifiers = 0;
PropertyDescriptor modifiersProp = TypeDescriptor.GetProperties(runtimeComp)["Modifiers"];
if (modifiersProp != null)
{
modifiers = (MemberAttributes)modifiersProp.GetValue(runtimeComp);
}
if (modifiers == MemberAttributes.Private)
{
String message = String.Format(SR.GetString(SR.ListGeneralPage_PrivateMemberMessage), dataSourceName);
String caption = SR.GetString(SR.ListGeneralPage_PrivateMemberCaption);
MessageBox.Show(message, caption, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return(false);
}
// ok to select
return(true);
}
/// <summary>
/// </summary>
private void LoadDataSourceFields()
{
using (new LoadingModeResource(this))
{
_dataTextFieldCombo.SelectedIndex = -1;
_dataTextFieldCombo.Items.Clear();
_dataTextFieldCombo.EnsureNotSetItem();
_dataValueFieldCombo.SelectedIndex = -1;
_dataValueFieldCombo.Items.Clear();
_dataValueFieldCombo.EnsureNotSetItem();
if (_currentDataSource != null)
{
PropertyDescriptorCollection fields = _currentDataSource.Fields;
if (fields != null)
{
IEnumerator fieldEnum = fields.GetEnumerator();
while (fieldEnum.MoveNext())
{
PropertyDescriptor fieldDesc = (PropertyDescriptor)fieldEnum.Current;
if (BaseDataList.IsBindableType(fieldDesc.PropertyType))
{
_dataTextFieldCombo.AddItem(fieldDesc.Name);
_dataValueFieldCombo.AddItem(fieldDesc.Name);
}
}
}
}
}
}
/// <summary>
/// Returns the index of the row that has the given PropertyDescriptor.
/// </summary>
/// <param name="property">Returns the index of the row that has the given PropertyDescriptor.</param>
/// <param name="key">The value of the property parameter to search for. </param>
/// <returns>The index of the row that has the given PropertyDescriptor.</returns>
internal int Find(System.ComponentModel.PropertyDescriptor property, object key)
{
int idx = 0;
int result = -1;
for (idx = 0; idx <= this.Count - 1; idx++)
{
object value = property.GetValue(this[idx]);
switch (property.Name)
{
case "ValueToString":
if ((value == key))
{
result = idx;
}
break;
default:
if ((value == key))
{
result = idx;
}
break;
}
if ((result != -1))
{
return(result);
}
}
return(0);
}
public static List <PropertyInfo> GetBrowsableAttributes(Type type)
{
try
{
List <PropertyInfo> pInfos = new List <PropertyInfo>();
// Type type = obj.GetType();
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(type);
foreach (PropertyInfo pInfo in type.GetProperties())
{
System.ComponentModel.PropertyDescriptor myProperty = properties.Find(pInfo.Name, false);
if (!object.ReferenceEquals(null, myProperty) && myProperty.IsBrowsable)
{
pInfos.Add(pInfo);
}
}
return(pInfos);
}
catch
{
throw;
}
}
public ValueTypeChainItem(PropertyDescriptor propertyDescriptor,
object value, object target)
{
PropertyDescriptor = propertyDescriptor;
Value = value;
Target = target;
}
protected virtual ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, PropertyDescriptor propertyDescriptor)
{
IEnumerable<Attribute> attributes = FilterAttributes(containerType, propertyDescriptor, new AttributeList(propertyDescriptor.Attributes));
ModelMetadata result = CreateMetadata(attributes, containerType, modelAccessor, propertyDescriptor.PropertyType, propertyDescriptor.Name);
ApplyMetadataAwareAttributes(attributes, result);
return result;
}
protected override object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
{
var propertyType = propertyDescriptor.PropertyType;
// Check if the property type is an enum with the flag attribute
if (propertyType.IsEnum && propertyType.GetCustomAttributes(true).Any())
{
var providerValue = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
if (providerValue != null)
{
var value = providerValue.RawValue;
if (value != null)
{
// In case it is a checkbox list/dropdownlist/radio button list
if (value is string[])
{
// Create flag value from posted values
int flagValue = 0;
foreach (string val in ((string[])value))
{
flagValue = flagValue | (int)Enum.Parse(propertyType, val);
}
return Enum.ToObject(propertyType, flagValue);
}
// In case it is a single value
if (value.GetType().IsEnum)
{
return Enum.ToObject(propertyType, value);
}
}
}
}
return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);
}
public UpdateContentItemAction(IView view, IController con, ContentItem item, PropertyDescriptor property, object previousValue)
{
_view = view;
_con = con;
_state = ContentItemState.Get(item);
var name = property.Name;
var value = previousValue;
if (name == "Importer")
{
name = "ImporterName";
value = ((ImporterTypeDescription)value).TypeName;
}
if (name == "Processor")
{
name = "ProcessorName";
value = ((ProcessorTypeDescription)value).TypeName;
}
var field = _state.GetType().GetMember(name).SingleOrDefault() as FieldInfo;
if (field == null)
{
if (!_state.ProcessorParams.ContainsKey(name))
throw new Exception();
_state.ProcessorParams[name] = value;
}
else
{
field.SetValue(_state, value);
}
}
/// <include file='doc\DataGridGeneralPage.uex' path='docs/doc[@for="DataGridGeneralPage.LoadDataSourceFields"]/*' />
/// <devdoc>
/// </devdoc>
private void LoadDataSourceFields()
{
EnterLoadingMode();
dataKeyFieldCombo.SelectedIndex = -1;
dataKeyFieldCombo.Items.Clear();
dataKeyFieldCombo.EnsureNotSetItem();
if (currentDataSource != null)
{
PropertyDescriptorCollection fields = currentDataSource.Fields;
if (fields != null)
{
IEnumerator fieldEnum = fields.GetEnumerator();
while (fieldEnum.MoveNext())
{
PropertyDescriptor fieldDesc = (PropertyDescriptor)fieldEnum.Current;
if (BaseDataList.IsBindableType(fieldDesc.PropertyType))
{
dataKeyFieldCombo.AddItem(fieldDesc.Name);
}
}
}
}
ExitLoadingMode();
}
public void SetUp()
{
_archetype = ContentHelpers.Archetype;
var content = ContentHelpers.FakeContent(123, "Fake Node 1", properties: new Collection<IPublishedProperty>
{
new FakePublishedProperty("myArchetypeProperty", _archetype, true)
});
_content = new FakeModel(content);
_propertyDescriptor = TypeDescriptor.GetProperties(_content)["TextString"];
_context = new FakeDittoValueResolverContext(_content, _propertyDescriptor);
var mockedPropertyService = new Mock<PropertyValueService>();
mockedPropertyService.SetupSequence(
i =>
i.Set(It.IsAny<IPublishedContent>(), It.IsAny<CultureInfo>(), It.IsAny<PropertyInfo>(),
It.IsAny<object>(), It.IsAny<object>(), It.IsAny<DittoValueResolverContext>()))
.Returns(new HtmlString("<p>This is the <strong>summary</strong> text.</p>"))
.Returns("Ready to Enroll?")
.Returns("{}");
_sut = new ArchetypeBindingService(mockedPropertyService.Object, new DittoAliasLocator());
}
private static bool AllowPropertyUpdate(PropertyDescriptor property)
{
if (property.IsReadOnly && !CanUpdateReadonlyTypedReference(property.PropertyType))
return false;
return !property.Attributes.OfType<SkipBindingAttribute>().Any();
}
/// <include file='doc\HtmlControlDesigner.uex' path='docs/doc[@for="HtmlControlDesigner.PreFilterProperties"]/*' />
/// <devdoc>
/// <para>
/// Allows a designer to filter the set of member attributes
/// that the component it is designing will expose through the <see cref='System.ComponentModel.TypeDescriptor'/>
/// object.
/// </para>
/// </devdoc>
protected override void PreFilterProperties(IDictionary properties) {
base.PreFilterProperties(properties);
PropertyDescriptor prop = (PropertyDescriptor)properties["Name"];
if (prop != null) {
properties["Name"] = TypeDescriptor.CreateProperty(prop.ComponentType, prop, BrowsableAttribute.No);
}
prop = (PropertyDescriptor)properties["Modifiers"];
if (prop != null) {
properties["Modifiers"] = TypeDescriptor.CreateProperty(prop.ComponentType, prop, BrowsableAttribute.No);
}
properties["DataBindings"] =
TypeDescriptor.CreateProperty(this.GetType(), "DataBindings", typeof(DataBindingCollection),
new Attribute[] {
DesignerSerializationVisibilityAttribute.Hidden,
CategoryAttribute.Data,
new EditorAttribute(typeof(DataBindingCollectionEditor), typeof(UITypeEditor)),
new TypeConverterAttribute(typeof(DataBindingCollectionConverter)),
new ParenthesizePropertyNameAttribute(true),
MergablePropertyAttribute.No,
new DescriptionAttribute(SR.GetString(SR.Control_DataBindings))
});
}
/// <summary>
/// Resets the property on objects</summary>
/// <param name="owners">Objects whose property is reset</param>
/// <param name="descriptor">Property to reset</param>
public static void ResetProperty(IEnumerable <object> owners, PropertyDescriptor descriptor)
{
foreach (object owner in owners)
{
descriptor.ResetValue(owner);
}
}
public SortExpression(string propertyName, ListSortDirection sortDirection)
{
PropertyName = propertyName;
SortDirection = sortDirection;
PropertyDescriptor = null;
_propertyValueCache = new Hashtable();
}
public static CustomProperty CreateCustomProperty(IServiceProvider serviceProvider, string customPropertyName, PropertyDescriptor propertyDescriptor, object propertyOwner)
{
CustomProperty property = new CustomProperty(serviceProvider) {
Name = customPropertyName
};
if (TypeProvider.IsAssignable(typeof(ActivityBind), propertyDescriptor.PropertyType))
{
System.Type type = PropertyDescriptorUtils.GetBaseType(propertyDescriptor, propertyOwner, serviceProvider);
if (type == null)
{
throw new InvalidOperationException(SR.GetString("Error_CantDeterminePropertyBaseType", new object[] { propertyDescriptor.Name }));
}
property.Type = type.FullName;
}
else
{
property.Type = propertyDescriptor.PropertyType.FullName;
}
if (propertyDescriptor is ActivityBindPropertyDescriptor)
{
DependencyProperty property2 = DependencyProperty.FromName(propertyDescriptor.Name, propertyDescriptor.ComponentType);
property.IsEvent = (property2 != null) && property2.IsEvent;
}
property.Category = propertyDescriptor.Category;
return property;
}
public LocalizedPropertyDescriptor(PropertyDescriptor basePropertyDescriptor) : base(basePropertyDescriptor)
{
LocalizedPropertyAttribute localizedPropertyAttribute = null;
foreach (Attribute attr in basePropertyDescriptor.Attributes) {
localizedPropertyAttribute = attr as LocalizedPropertyAttribute;
if (localizedPropertyAttribute != null) {
break;
}
}
if (localizedPropertyAttribute != null) {
localizedName = localizedPropertyAttribute.Name;
localizedDescription = localizedPropertyAttribute.Description;
localizedCategory = localizedPropertyAttribute.Category;
} else {
localizedName = basePropertyDescriptor.Name;
localizedDescription = basePropertyDescriptor.Description;
localizedCategory = basePropertyDescriptor.Category;
}
this.basePropertyDescriptor = basePropertyDescriptor;
// "Booleans" get a localized type converter
if (basePropertyDescriptor.PropertyType == typeof(System.Boolean)) {
customTypeConverter = new BooleanTypeConverter();
}
}
public MetadataPropertyDescriptorWrapper(PropertyDescriptor descriptor, Attribute[] newAttributes)
: base(descriptor, newAttributes)
{
_descriptor = descriptor;
var readOnlyAttribute = newAttributes.OfType<ReadOnlyAttribute>().FirstOrDefault();
_isReadOnly = (readOnlyAttribute != null ? readOnlyAttribute.IsReadOnly : false);
}
/// <summary>
/// This takes care of the actual value-change of the property.
/// </summary>
/// <param name="itdc">Standard ITypeDescriptorContext object.</param>
/// <param name="isp">Standard IServiceProvider object.</param>
/// <param name="value">The value as an object.</param>
/// <returns>The new value as an object.</returns>
public override object EditValue(ITypeDescriptorContext itdc, IServiceProvider isp, object value)
{
if(itdc != null && itdc.Instance != null && isp != null)
{
iwfes = (IWindowsFormsEditorService)isp.GetService(typeof(IWindowsFormsEditorService));
if(iwfes != null)
{
HatchStyle hs = HatchStyle.Weave;
//if(itdc.PropertyDescriptor.GetValue(itdc.Instance) is HatchStyle)
if(value is HatchStyle)
{
hs = (HatchStyle)itdc.PropertyDescriptor.GetValue(itdc.Instance);
pd = itdc.PropertyDescriptor;
oInstance = itdc.Instance;
}
//EditorHatchStyleUI ehsui = new EditorHatchStyleUI(hs, Color.White, Color.Black); //FIX THIS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
EditorHatchStyleUI ehsui = new EditorHatchStyleUI(HatchStyle.Trellis, Color.White, Color.Black);
ehsui.IWFES = iwfes;
ehsui.ITDC = itdc;
ehsui.HatchStyle = (HatchStyle)value;
ehsui.HatchStyleChanged += new EditorHatchStyleUI.MWHatchStyleEventHandler(ValueChanged);
iwfes.DropDownControl(ehsui);
value = ehsui.HatchStyle;
}
}
return value;
}
protected override void SetProperty(
ControllerContext controllerContext,
ModelBindingContext bindingContext,
PropertyDescriptor propertyDescriptor,
object value)
{
base.SetProperty(controllerContext, bindingContext, propertyDescriptor, value);
switch (propertyDescriptor.Name)
{
case "ClientName":
if (string.IsNullOrWhiteSpace((string)value))
bindingContext.ModelState.AddModelError("ClientName", "Please enter your name [binder]");
break;
case "Date":
if (bindingContext.ModelState.IsValidField("Date") && DateTime.Now.Date > (DateTime)value)
bindingContext.ModelState.AddModelError("Date", "Please enter a date in the future [binder]");
break;
case "TermsAccepted":
if (!(bool)value)
bindingContext.ModelState.AddModelError("TermsAccepted", "You must accept the terms [binder]");
break;
}
}
protected override bool OnPropertyValidating(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, object value)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (propertyDescriptor == null)
{
throw new ArgumentNullException("propertyDescriptor");
}
if (value is string && controllerContext.HttpContext.Request.ContentType.StartsWith(WebConstants.APPLICATIONJSON, StringComparison.OrdinalIgnoreCase))
{
if (controllerContext.Controller.ValidateRequest && bindingContext.PropertyMetadata[propertyDescriptor.Name].RequestValidationEnabled)
{
int index;
if (IsDangerousString(value.ToString(), out index))
{
throw new HttpRequestValidationException("Dangerous Input Detected");
}
}
}
return base.OnPropertyValidating(controllerContext, bindingContext, propertyDescriptor, value);
}
public IEnumerable<ModelValidationResult> ValidateObject(object model, ControllerContext controllerContext, bool markProperties=true)
{
var results = new List<ModelValidationResult>();
var properties = GetTypeDescriptor(model.GetType()).GetProperties();
var props = new PropertyDescriptor[properties.Count];
properties.CopyTo(props, 0);
foreach (var prop in props)
{
var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null , model.GetType(), prop.Name);
metadata.Model = prop.GetValue(model);
metadata.IsRequired = false;
var validators = this.GetValidators(metadata, controllerContext);
foreach (var validator in validators)
{
var validationResult = validator.Validate(model).ToList();
if(markProperties)
foreach (var res in validationResult)
res.MemberName = prop.Name;
results.AddRange(validationResult);
}
}
return results;
}
public string GetDescription(PropertyDescriptor descriptor)
{
var description = GetResourceDescription(descriptor.ComponentType, descriptor.Name);
if (description != null)
return description;
return UsageDescriptionProvider.Default.GetDescription(descriptor);
}
public CustomPropertyDescriptor(
PropertyDescriptor propertyDescriptor,
PropertyCustomisation customisation) : base(propertyDescriptor)
{
_basePropertyDescriptor=propertyDescriptor;
_customisation = customisation ;
}
/// <summary>
/// Publish Dependant Component Changes
/// </summary>
/// <typeparam name="T">Type of property</typeparam>
/// <param name="propertyName">Property Name that has changed</param>
/// <param name="value">new value for Property</param>
private void PublishDependentComponentChanges <T>(string propertyName, T value)
{
System.ComponentModel.Design.IComponentChangeService changeService = null;
System.ComponentModel.PropertyDescriptor property = null;
T currentValue = default(T);
if (DesignMode && this.Site != null)
{
property = System.ComponentModel.TypeDescriptor.GetProperties(this)[propertyName];
changeService = (System.ComponentModel.Design.IComponentChangeService) this.Site.GetService(typeof(System.ComponentModel.Design.IComponentChangeService));
if (changeService != null)
{
currentValue = (T)property.GetValue(this);
if (currentValue == null)
{
currentValue = default(T);
}
// Trap any error and ignore it
changeService.OnComponentChanging(this, property);
// try to set new value
property.SetValue(this, value);
changeService.OnComponentChanged(this, property, currentValue, value);
}
}
}
/// <devdoc>
/// Creates a new ExtenderProvidedPropertyAttribute.
/// </devdoc>
internal static ExtenderProvidedPropertyAttribute Create(PropertyDescriptor extenderProperty, Type receiverType, IExtenderProvider provider) {
ExtenderProvidedPropertyAttribute e = new ExtenderProvidedPropertyAttribute();
e.extenderProperty = extenderProperty;
e.receiverType = receiverType;
e.provider = provider;
return e;
}
/// <summary>
/// Constructor
/// </summary>
public PropertyChangedCommand(object obj, PropertyDescriptor descriptor, object oldValue, object newValue)
{
mObject = obj;
mDescriptor = descriptor;
mOldValue = oldValue;
mNewValue = newValue;
}
/// <summary>
/// Initializes the command after the property was first changed.
/// </summary>
/// <param name="target">The object the property belongs to.</param>
/// <param name="property">The property that was changed.</param>
/// <param name="oldValue">The property's old value.</param>
/// <param name="newValue">The property's current value.</param>
public PropertyChangedCommand(object target, PropertyDescriptor property, object oldValue, object newValue)
{
_target = target;
_property = property;
_oldValue = oldValue;
_newValue = newValue;
}
protected override void OnSortingRangeRows(SortRangeRowsEventArgs e)
{
base.OnSortingRangeRows(e);
if (DataSource == null || DataSource.AllowSort == false)
{
return;
}
System.ComponentModel.PropertyDescriptor propertyCol = Columns[e.KeyColumn].PropertyColumn;
if (propertyCol != null)
{
ListSortDirection direction;
if (e.Ascending)
{
direction = ListSortDirection.Ascending;
}
else
{
direction = ListSortDirection.Descending;
}
ListSortDescription[] sortsArray = new ListSortDescription[1];
sortsArray[0] = new ListSortDescription(propertyCol, direction);
DataSource.ApplySort(new ListSortDescriptionCollection(sortsArray));
}
else
{
DataSource.ApplySort(null);
}
}
public Type GetElementType(PropertyDescriptor[] listAccessors)
{
PropertyDescriptor descriptor = listAccessors[0];
foreach (DSPropertyDescriptor descriptor2 in this._TableDesc)
{
if (descriptor2.Name == descriptor.Name)
{
if (listAccessors.Length == 1)
{
return descriptor2.ComponentType;
}
Type componentType = descriptor2.ComponentType;
for (int i = 1; i < listAccessors.Length; i++)
{
PropertyInfo property = componentType.GetProperty(listAccessors[1].Name);
if (property == null)
{
return null;
}
property = property.PropertyType.GetProperty("Item");
if (property == null)
{
return null;
}
componentType = property.PropertyType;
}
return componentType;
}
}
return null;
}
/// <summary>
/// Gets the rules the adapter provides.
/// </summary>
/// <param name="attribute">The <see cref="ValidationAttribute"/> that should be handled.</param>
/// <param name="descriptor">A <see cref="PropertyDescriptor"/> instance for the property that is being validated.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of <see cref="ModelValidationRule"/> instances.</returns>
public override IEnumerable<ModelValidationRule> GetRules(ValidationAttribute attribute, PropertyDescriptor descriptor)
{
yield return new StringLengthValidationRule(attribute.FormatErrorMessage,
new[] { descriptor.Name },
((StringLengthAttribute)attribute).MinimumLength,
((StringLengthAttribute)attribute).MaximumLength);
}
/// <summary>
/// Gets whether two property descriptors should be considered equal, for the purposes of ATF
/// property editing. The default .NET Equals() method doesn't take into account the Category.</summary>
/// <param name="a">First PropertyDescriptor to compare</param>
/// <param name="b">Second PropertyDescriptor to compare</param>
/// <returns>True iff PropertyDescriptors equal, i.e., the name, category and type are the same</returns>
public static bool PropertyDescriptorsEqual(PropertyDescriptor a, PropertyDescriptor b)
{
return
(a.Name == b.Name &&
GetCategoryName(a) == GetCategoryName(b) &&
a.PropertyType == b.PropertyType);
}
public static PropertyDescriptorCollection GetProperties(Type memberType)
{
if (memberType == null)
return PropertyDescriptorCollection.Empty;
PropertyDescriptorCollection pdc;
if ((pdc = (PropertyDescriptorCollection) collections[memberType]) != null)
return (pdc);
PropertyInfo[] allProps = memberType.GetProperties();
int l = allProps.Length;
for (int i = 0; i < allProps.Length; i++)
{
PropertyInfo pi = allProps[i];
if (!IsAllowedProperty(pi.Name))
{
allProps[i] = null;
l--;
}
}
PropertyDescriptor[] descriptors = new PropertyDescriptor[l];
int j = 0;
foreach(PropertyInfo pinfo in allProps)
{
if (pinfo != null)
{
descriptors[j++] = new ExtendedPropertyDescriptor(pinfo.Name, memberType, pinfo.PropertyType);
}
}
PropertyDescriptorCollection result = new PropertyDescriptorCollection(descriptors);
collections.Add(memberType, result);
return result;
}
/// <summary>
/// Method to get the attempted value for the property and to execute the callback method to retreive the 'real' value,
/// then set the property whilst executing the correct events.
/// The event order is based on how the DefaultModelBinder sets properties so figured I'd go with these 'best practices'.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="bindingContext"></param>
/// <param name="propertyDescriptor"></param>
/// <param name="getValue">callback method to get the 'real' value</param>
protected internal void SetPropertyValue(ControllerContext controllerContext,
ModelBindingContext bindingContext,
PropertyDescriptor propertyDescriptor,
Func<string, object> getValue)
{
var valueObject = bindingContext.ValueProvider.GetValue(propertyDescriptor.Name);
if (valueObject != null)
{
var val = valueObject.AttemptedValue;
//get the real value from the callback
var realVal = getValue.Invoke(val);
//add the bound value to model state if it's not already there, generally only simple props will be there
if (!bindingContext.ModelState.ContainsKey(propertyDescriptor.Name))
{
bindingContext.ModelState.Add(propertyDescriptor.Name, new ModelState());
bindingContext.ModelState.SetModelValue(propertyDescriptor.Name, new ValueProviderResult(realVal, val, null));
}
//set the value
if (OnPropertyValidating(controllerContext, bindingContext, propertyDescriptor, realVal))
{
SetProperty(controllerContext, bindingContext, propertyDescriptor, realVal);
OnPropertyValidated(controllerContext, bindingContext, propertyDescriptor, realVal);
return;
}
}
}
/// <summary>
/// Retourne la collection des propriétés à afficher pour l'objet
/// </summary>
/// <remarks>
/// Cette méthode ajoute le descripteur de la propriété "Name" uniquement pour les objets qui sont au moins <see cref="Control"/>.
/// </remarks>
/// <param name="component">objet dont les propriétés sont à afficher</param>
/// <param name="attributes">null ou tableau de filtrage selon les attributs</param>
/// <returns>la collection des descripteurs des propriétés à afficher</returns>
public override PropertyDescriptorCollection GetProperties( object component, System.Attribute[] attributes ) {
PropertyDescriptorCollection properties;
// récupérer le propriétés à partir du descripteur de type
if ( attributes == null ) attributes = DefaultFilter ;
properties = TypeDescriptor.GetProperties( component, attributes );
// l'objet dont les propriétés sont à afficher n'est pas Control --> rien d'autre à faire
if (! (component is Control) ) return properties;
// si la propriété Name figure déjà dans la collection --> rien d'autre à faire
PropertyDescriptor oldDescriptorOfName = properties.Find( "Name", false ) ;
if (oldDescriptorOfName != null) return properties ;
// rechercher le descripteur de la propriété Name dans la collection de tous les descripteurs de propriétés
PropertyDescriptorCollection allProperties = TypeDescriptor.GetProperties( component );
oldDescriptorOfName = allProperties.Find( "Name", false );
if ( oldDescriptorOfName == null ) return properties;
// composer le nouveau descripteur de la propriété Name
PropertyDescriptor newDescriptorOfName = TypeDescriptor.CreateProperty( oldDescriptorOfName.ComponentType, oldDescriptorOfName, new ParenthesizePropertyNameAttribute( true ), CategoryAttribute.Design );
//PropertyDescriptor newDescriptorOfName = TypeDescriptor.CreateProperty( oldDescriptorOfName.ComponentType, oldDescriptorOfName, BrowsableAttribute.Yes, new ParenthesizePropertyNameAttribute( true ), CategoryAttribute.Design );
// composer la collection des descripteurs de propriétés obtenu en ajoutant le descripteur de la propriété Name
PropertyDescriptor[] propertiesArray = new PropertyDescriptor[ properties.Count ];
properties.CopyTo( propertiesArray, 0 );
properties = new PropertyDescriptorCollection( propertiesArray );
properties.Add( newDescriptorOfName );
return properties;
}
/// <summary>
/// Initializes a new instance of the <see cref = "T:SiliconStudio.Core.TypeConverters.Half2Converter" /> class.
/// </summary>
public Half2Converter()
{
Type type = typeof (Half2);
PropertyDescriptor[] propArray = new PropertyDescriptor[]
{new FieldPropertyDescriptor(type.GetField("X")), new FieldPropertyDescriptor(type.GetField("Y"))};
properties = new PropertyDescriptorCollection(propArray);
}
/// <summary>
/// <para>Gets a collection of properties for the type of array specified by the value parameter.</para>
/// </summary>
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
if (value == null)
{
return null;
}
PropertyDescriptor[] props = null;
if (value.GetType().IsArray)
{
Array valueArray = (Array)value;
int length = valueArray.GetLength(0);
props = new PropertyDescriptor[length];
Type arrayType = value.GetType();
Type elementType = arrayType.GetElementType();
for (int i = 0; i < length; i++)
{
props[i] = new ArrayPropertyDescriptor(arrayType, elementType, i);
}
}
return new PropertyDescriptorCollection(props);
}
public SortExpression(string propertyName)
{
PropertyName = propertyName;
SortDirection = ListSortDirection.Ascending;
PropertyDescriptor = null;
_propertyValueCache = new Hashtable();
}
protected virtual IEnumerable<Attribute> FilterAttributes(Type containerType, PropertyDescriptor propertyDescriptor, IEnumerable<Attribute> attributes) {
if (typeof(ViewPage).IsAssignableFrom(containerType) || typeof(ViewUserControl).IsAssignableFrom(containerType)) {
return attributes.Where(a => !(a is ReadOnlyAttribute));
}
return attributes;
}
public BindablePropertyNode(System.ComponentModel.PropertyDescriptor propDesc, ExpressionBinding binding)
{
this._binding = binding;
this._propDesc = propDesc;
this._isValid = true;
base.Text = propDesc.Name;
base.ImageIndex = base.SelectedImageIndex = this.IsBound ? (this.IsGenerated ? 2 : 1) : 0;
}
public DataGridColumnStyle(System.ComponentModel.PropertyDescriptor prop) : this()
{
this.PropertyDescriptor = prop;
if (prop != null)
{
this.readOnly = prop.IsReadOnly;
}
}
// Helper method to safely set a component’s property
private void SetProperty(string propertyName, object value)
{
// Get property
System.ComponentModel.PropertyDescriptor property
= System.ComponentModel.TypeDescriptor.GetProperties(this.Panel)[propertyName];
// Set property value
property.SetValue(this.Panel, value);
}
/// <summary>
/// Obtains the default properties for an object</summary>
/// <param name="owner">Object whose properties are obtained</param>
/// <returns>Default properties for an object, as an array</returns>
public static PropertyDescriptor[] GetDefaultProperties2(object owner)
{
PropertyDescriptorCollection propertyCollection = GetDefaultProperties(owner);
PropertyDescriptor[] result = new PropertyDescriptor[propertyCollection.Count];
propertyCollection.CopyTo(result, 0);
return(result);
}
internal DataGridColumnStyle(System.ComponentModel.PropertyDescriptor prop, bool isDefault) : this(prop)
{
this.isDefault = isDefault;
if (isDefault)
{
this.headerName = prop.Name;
this.mappingName = prop.Name;
}
}
public void Sort(string PropertyName, ListSortDirection direction)
{
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T));
System.ComponentModel.PropertyDescriptor myProperty = properties.Find(PropertyName, false);
if (myProperty != null)
{
((IBindingList)this).ApplySort(myProperty, direction);
}
}
PropertyDescriptorCollection ITypedList.GetItemProperties(System.ComponentModel.PropertyDescriptor[] listAccessors)
{
System.Collections.ArrayList descriptors = new System.Collections.ArrayList();
descriptors.Add(new PropertyDescriptor("Name"));
descriptors.Add(new PropertyDescriptor("Address"));
descriptors.Add(new PropertyDescriptor("Address_City"));
System.ComponentModel.PropertyDescriptor[] propertyDescriptors = new System.ComponentModel.PropertyDescriptor[descriptors.Count];
descriptors.CopyTo(propertyDescriptors, 0);
return(new PropertyDescriptorCollection(propertyDescriptors));
}
public System.ComponentModel.EventDescriptor GetEvent(System.ComponentModel.PropertyDescriptor property)
{
EventPropertyDescriptor epd = property as EventPropertyDescriptor;
if (epd == null)
{
return(null);
}
return(epd.InternalEventDescriptor);
}
/// <summary>
/// Obtains a property's category name</summary>
/// <param name="descriptor">Property descriptor</param>
/// <returns>Property's category name; "Misc" if none is defined by the descriptor</returns>
public static string GetCategoryName(PropertyDescriptor descriptor)
{
string result = descriptor.Category;
if (result == null)
{
result = "Misc".Localize("Miscellaneous category");
}
return(result);
}
/// <summary>
/// Gets a hash code for a property descriptor that allows different PropertyDescriptor
/// objects to be considered equivalent if their name, category, and property type match</summary>
/// <param name="propertyDescriptor">Property descriptor to get hash code for</param>
/// <returns>Hash code for property descriptor</returns>
/// <remarks>Consider using GetPropertyDescriptorKey() instead, to avoid any chance of
/// collisions, since it's not really appropriate to compare hash codes alone when
/// determining equality.</remarks>
public static int GetPropertyDescriptorHash(this PropertyDescriptor propertyDescriptor)
{
// Different PropertyDescriptor objects need to have the same hash code if the Name
// and Category and PropertyType match. Note that 'Name' and 'Category' can be equal
// to each other, so we can't xor their hash codes together. Note that Category can be null.
// http://tracker.ship.scea.com/jira/browse/WWSATF-1051
return
(propertyDescriptor.Name.GetHashCode() ^
(GetCategoryName(propertyDescriptor).GetHashCode() << 8) ^
propertyDescriptor.PropertyType.GetHashCode());
}
public void ApplySort(System.ComponentModel.PropertyDescriptor pd, System.ComponentModel.ListSortDirection direction)
{
if (_list.SupportsSorting)
{
_list.ApplySort(pd, direction);
}
else
{
ApplySort(new ListSortDescriptionCollection(new ListSortDescription[] { new ListSortDescription(pd, direction) }));
}
}
/// <summary>
/// Determines whether the property is read-only.
/// </summary>
/// <param name="pd">The property descriptor.</param>
/// <returns><c>true</c> if the property is read-only; otherwise, <c>false</c>.</returns>
public static bool IsReadOnly(this System.ComponentModel.PropertyDescriptor pd)
{
var a = pd.GetFirstAttributeOrDefault <ReadOnlyAttribute>();
if (a != null)
{
return(a.IsReadOnly);
}
return(pd.IsReadOnly);
}
/// <summary>
/// Gets the category for the specified property.
/// </summary>
/// <param name="pd">The property descriptor.</param>
/// <returns>The category.</returns>
public static string GetCategory(this System.ComponentModel.PropertyDescriptor pd)
{
var a = pd.GetFirstAttributeOrDefault <CategoryAttribute>();
if (a != null)
{
return(a.Category);
}
return(pd.Category);
}
/// <summary>
/// Gets the display name for the specified property.
/// </summary>
/// <param name="pd">The property descriptor.</param>
/// <returns>The display name.</returns>
public static string GetDisplayName(this System.ComponentModel.PropertyDescriptor pd)
{
var a = pd.GetFirstAttributeOrDefault <DisplayNameAttribute>();
if (a != null)
{
return(a.DisplayName);
}
return(pd.DisplayName);
}
/// <summary>
/// Returns whether or not the property can be reset</summary>
/// <param name="owners">Objects whose property is tested</param>
/// <param name="descriptor">Property to reset</param>
/// <returns>True iff the property can be reset on the object</returns>
public static bool CanResetProperty(IEnumerable <object> owners, PropertyDescriptor descriptor)
{
foreach (object owner in owners)
{
if (!descriptor.CanResetValue(owner))
{
return(false);
}
}
return(true);
}
// Cannot use one PropertyDescriptor for all owners, because the
// propertydescriptors might have different Invokees. Check
// ReflectionPropertyDescriptor.GetInvokee and how it's used.
//
public GridEntry (PropertyGrid propertyGrid, PropertyDescriptor[] properties,
GridEntry parent) : this (propertyGrid, parent)
{
if (properties == null || properties.Length == 0)
throw new ArgumentNullException ("prop_desc");
property_descriptors = properties;
}
