protected virtual void Describe(PropertyGridProperty property, PropertyDescriptor descriptor)
{
if (property == null)
{
throw new ArgumentNullException("property");
}
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
property.Descriptor = descriptor;
property.Name = descriptor.Name;
property.PropertyType = descriptor.PropertyType;
// unset by default. conversion service does the default job
//property.Converter = descriptor.Converter;
property.Category = string.IsNullOrWhiteSpace(descriptor.Category) || descriptor.Category.EqualsIgnoreCase(CategoryAttribute.Default.Category) ? Grid.DefaultCategoryName : descriptor.Category;
property.IsReadOnly = descriptor.IsReadOnly;
property.Description = descriptor.Description;
property.DisplayName = descriptor.DisplayName;
if (property.DisplayName == descriptor.Name)
{
property.DisplayName = DecamelizationService.Decamelize(property.DisplayName);
}
property.IsEnum = descriptor.PropertyType.IsEnum;
property.IsFlagsEnum = descriptor.PropertyType.IsEnum && Extensions.IsFlagsEnum(descriptor.PropertyType);
DefaultValueAttribute att = descriptor.GetAttribute <DefaultValueAttribute>();
property.HasDefaultValue = att != null;
property.DefaultValue = att != null ? att.Value : null;
PropertyGridOptionsAttribute options = descriptor.GetAttribute <PropertyGridOptionsAttribute>();
if (options != null)
{
if (options.SortOrder != 0)
{
property.SortOrder = options.SortOrder;
}
property.IsEnum = options.IsEnum;
property.IsFlagsEnum = options.IsFlagsEnum;
}
AddDynamicProperties(descriptor.Attributes.OfType <PropertyGridAttribute>(), property.Attributes);
AddDynamicProperties(descriptor.PropertyType.GetAttributes <PropertyGridAttribute>(), property.TypeAttributes);
}
private CmdLineProperty GetCmdLineProperty(PropertyDescriptor propDesc, T obj)
{
var prop = new CmdLineProperty(propDesc, obj);
var claAtt = propDesc.GetAttribute <CmdLineArgAttribute>();
var showUsage = (bool?)null;
if (claAtt != null)
{
prop.Aliases = claAtt.Aliases;
showUsage = claAtt.mShowInUsage; // Use internal field instead of property so we can get null value.
prop.ShowInHelp = claAtt.ShowInHelp;
prop.ShowDefaultValue = claAtt.ShowDefaultValue;
}
prop.Required = propDesc.GetAttribute <RequiredAttribute>() != null;
// Determine if we should show this in the usage or not.
if (showUsage ?? false)
{
prop.ShowInUsage = true;
}
else if (showUsage ?? prop.Required)
{
prop.ShowInUsage = true;
}
else
{
prop.ShowInUsage = false;
}
prop.DefaultValue = prop.Value;
// Make sure aliases has a valid value so we don't have to check for nulls everywhere.
if (prop.Aliases == null)
{
prop.Aliases = new string[] { }
}
;
return(prop);
}
public virtual PropertyGridProperty CreateProperty(PropertyDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
bool forceReadWrite = false;
PropertyGridProperty property = null;
PropertyGridOptionsAttribute options = descriptor.GetAttribute <PropertyGridOptionsAttribute>();
if (options != null)
{
forceReadWrite = options.ForceReadWrite;
if (options.PropertyType != null)
{
property = (PropertyGridProperty)Activator.CreateInstance(options.PropertyType, this);
}
}
if (property == null)
{
options = descriptor.PropertyType.GetAttribute <PropertyGridOptionsAttribute>();
if (options != null)
{
if (!forceReadWrite)
{
forceReadWrite = options.ForceReadWrite;
}
if (options.PropertyType != null)
{
property = (PropertyGridProperty)Activator.CreateInstance(options.PropertyType, this);
}
}
}
if (property == null)
{
property = CreateProperty();
}
Describe(property, descriptor);
if (forceReadWrite)
{
property.IsReadOnly = false;
}
property.OnDescribed();
property.RefreshValueFromDescriptor();
return(property);
}
private NewVariableAttribute GetNewVariableDefaults(PropertyDescriptor property, object target)
{
var defaultAttr = property.GetAttribute <NewVariableAttribute>();
if (defaultAttr != null)
{
return(defaultAttr);
}
//Look for the interface
var ifc = target as INewVariableProvider;
if (ifc != null)
{
return(ifc.GetNewVariable(property.Name));
}
return(new NewVariableAttribute(property.Name, typeof(int)));
}
private void WriteProperty(XContainer parentElement, object obj, string name, PropertyDescriptor prop)
{
SerializerOptionsAttribute att = prop != null?prop.GetAttribute <SerializerOptionsAttribute>() ?? new SerializerOptionsAttribute() : new SerializerOptionsAttribute();
if (!string.IsNullOrEmpty(att.Redirect))
{
string newName = name;
var namable = obj as INamable;
if (namable != null)
{
newName = namable.Name;
}
parentElement.Add(new XElement(name, att.Redirect + "/" + newName));
this.WriteRedirect(att.Redirect, obj, newName);
}
else
{
this.AddObjectToXmlDoc(parentElement, obj, name);
}
}
/// <summary>
/// Does the wrapped <see cref="PropertyInfo"/> have an attribute of type <typeparamref name="T"/>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static bool HasAttribute <T>(this PropertyDescriptor prop) where T : Attribute
{
T attribute = prop.GetAttribute <T>();
return(attribute != null);
}
private static IList <PropertyDescriptor[]> GetCommonProperties(
object[] objects,
bool presort,
PropertyTab tab,
GridEntry parentEntry)
{
var objectProperties = new PropertyDescriptorCollection[objects.Length];
var attributes = new Attribute[parentEntry.BrowsableAttributes.Count];
parentEntry.BrowsableAttributes.CopyTo(attributes, 0);
for (int i = 0; i < objects.Length; i++)
{
var properties = tab.GetProperties(parentEntry, objects[i], attributes);
if (presort)
{
properties = properties.Sort(s_propertyComparer);
}
objectProperties[i] = properties;
}
List <PropertyDescriptor[]> mergedList = new();
var matchArray = new PropertyDescriptor[objects.Length];
//
// Merge the property descriptors
//
int[] positions = new int[objectProperties.Length];
// Iterate through the first object's properties to see if it has matches in the other objects.
for (int i = 0; i < objectProperties[0].Count; i++)
{
PropertyDescriptor pivotProperty = objectProperties[0][i];
bool match = pivotProperty.GetAttribute <MergablePropertyAttribute>().IsDefaultAttribute();
for (int j = 1; match && j < objectProperties.Length; j++)
{
if (positions[j] >= objectProperties[j].Count)
{
match = false;
break;
}
// Check to see if we're on a match.
PropertyDescriptor property = objectProperties[j][positions[j]];
if (pivotProperty.Equals(property))
{
positions[j] += 1;
if (!property.GetAttribute <MergablePropertyAttribute>().IsDefaultAttribute())
{
match = false;
break;
}
matchArray[j] = property;
continue;
}
int position = positions[j];
property = objectProperties[j][position];
match = false;
// If we aren't on a match, check all the items until we're past where the matching item would be.
while (s_propertyComparer.Compare(property, pivotProperty) <= 0)
{
// Got a match!
if (pivotProperty.Equals(property))
{
if (!property.GetAttribute <MergablePropertyAttribute>().IsDefaultAttribute())
{
match = false;
position++;
}
else
{
match = true;
matchArray[j] = property;
positions[j] = position + 1;
}
break;
}
// Try again.
position++;
if (position < objectProperties[j].Count)
{
property = objectProperties[j][position];
}
else
{
break;
}
}
// If we got here, there is no match, quit for this one.
if (!match)
{
positions[j] = position;
break;
}
}
// Do we have a match?
if (match)
{
matchArray[0] = pivotProperty;
mergedList.Add((PropertyDescriptor[])matchArray.Clone());
}
}
return(mergedList);
}
