protected override void PreFilterProperties(IDictionary properties)
{
PropertyDescriptor integralHeightProp = (PropertyDescriptor)properties["IntegralHeight"];
if (integralHeightProp != null)
{
properties["IntegralHeight"] = TypeDescriptor.CreateProperty(typeof(ListBoxDesigner), integralHeightProp, Array.Empty <Attribute>());
}
PropertyDescriptor dockProp = (PropertyDescriptor)properties["Dock"];
if (dockProp != null)
{
properties["Dock"] = TypeDescriptor.CreateProperty(typeof(ListBoxDesigner), dockProp, Array.Empty <Attribute>());
}
base.PreFilterProperties(properties);
}
protected override void PreFilterProperties(IDictionary properties)
{
PropertyDescriptor ownerDrawProp = (PropertyDescriptor)properties["OwnerDraw"];
if (ownerDrawProp != null)
{
properties["OwnerDraw"] = TypeDescriptor.CreateProperty(typeof(ListViewDesigner), ownerDrawProp, Array.Empty <Attribute>());
}
PropertyDescriptor viewProp = (PropertyDescriptor)properties["View"];
if (viewProp != null)
{
properties["View"] = TypeDescriptor.CreateProperty(typeof(ListViewDesigner), viewProp, Array.Empty <Attribute>());
}
base.PreFilterProperties(properties);
}
/// <summary>
/// Adjusts the set of properties the component exposes through a TypeDescriptor.
/// </summary>
/// <param name="properties">An IDictionary containing the properties for the class of the component.</param>
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
// Setup the array of properties we override
Attribute[] attributes = new Attribute[0];
string[] strArray = new string[] { "Visible", "Enabled" };
// Adjust our list of properties
for (int i = 0; i < strArray.Length; i++)
{
PropertyDescriptor descrip = (PropertyDescriptor)properties[strArray[i]];
if (descrip != null)
{
properties[strArray[i]] = TypeDescriptor.CreateProperty(typeof(KryptonRibbonGroupMaskedTextBoxDesigner), descrip, attributes);
}
}
}
public override PropertyDescriptorCollection GetProperties()
{
var properties = new List <PropertyDescriptor>();
var KeyDescriptor = new KeyValueDescriptor(TypeDescriptor.CreateProperty(GetType(), "Key", typeof(TKey)),
EditorAttribute.KeyConverterType, EditorAttribute.KeyEditorType, EditorAttribute.KeyAttributeProviderType,
EditorAttribute.KeyDisplayName);
properties.Add(KeyDescriptor);
var ValueDescriptor = new KeyValueDescriptor(TypeDescriptor.CreateProperty(GetType(), "Value", typeof(TValue)),
EditorAttribute.ValueConverterType, EditorAttribute.ValueEditorType, EditorAttribute.ValueAttributeProviderType,
EditorAttribute.ValueDisplayName);
properties.Add(ValueDescriptor);
return(new PropertyDescriptorCollection(properties.ToArray()));
}
protected override void PostFilterProperties(IDictionary properties)
{
PropertyDescriptor pd =
properties["Enabled"] as PropertyDescriptor;
pd = TypeDescriptor.CreateProperty(
pd.ComponentType,
pd, new Attribute[2] {
new BrowsableAttribute(false),
new EditorBrowsableAttribute(EditorBrowsableState.Never)
});
properties[pd.Name] = pd;
// Always call the base PostFilterProperties implementation
// after you modify the properties collection.
base.PostFilterProperties(properties);
}
/// <summary>
/// Allows a designer to change or remove items from the set of properties that it
/// exposes through a TypeDescriptor
/// </summary>
/// <param name="properties">The properties for the class of the component.</param>
protected override void PostFilterProperties(IDictionary properties)
{
// Set new default value for BackColor
PropertyDescriptor property = (PropertyDescriptor)properties["BackColor"];
properties["BackColor"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, new DefaultValueAttribute(System.Drawing.SystemColors.ControlDark));
// Set default value for Dock to left
property = (PropertyDescriptor)properties["Dock"];
properties["Dock"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, new DefaultValueAttribute(DockStyle.Left));
// Remove some properties
properties.Remove("BackgroundImage");
base.PostFilterProperties(properties);
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
{
PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(this.Target);
if (this.propsToHide != null && this.propsToHide.Length > 0)
{
List <PropertyDescriptor> list = new List <PropertyDescriptor>();
for (int i = 0; i < propertyDescriptorCollection.Count; i++)
{
PropertyDescriptor prop = propertyDescriptorCollection[i];
ExtenderControlPropertyAttribute extenderControlPropertyAttribute = (ExtenderControlPropertyAttribute)prop.Attributes[typeof(ExtenderControlPropertyAttribute)];
if (extenderControlPropertyAttribute != null)
{
ExtenderVisiblePropertyAttribute extenderVisiblePropertyAttribute = (ExtenderVisiblePropertyAttribute)prop.Attributes[typeof(ExtenderVisiblePropertyAttribute)];
if (extenderVisiblePropertyAttribute != null && extenderVisiblePropertyAttribute.Value)
{
int num = Array.FindIndex <string>(this.propsToHide, (string s) => s == prop.Name);
if (num == -1)
{
IDReferencePropertyAttribute idreferencePropertyAttribute = (IDReferencePropertyAttribute)prop.Attributes[typeof(IDReferencePropertyAttribute)];
Attribute attribute = prop.Attributes[typeof(TypeConverterAttribute)];
if (idreferencePropertyAttribute != null && !idreferencePropertyAttribute.IsDefaultAttribute())
{
Type type = typeof(TypedControlIDConverter <Control>).GetGenericTypeDefinition();
type = type.MakeGenericType(new Type[]
{
idreferencePropertyAttribute.ReferencedControlType
});
attribute = new TypeConverterAttribute(type);
}
prop = TypeDescriptor.CreateProperty(prop.ComponentType, prop, new Attribute[]
{
BrowsableAttribute.Yes,
attribute
});
list.Add(prop);
}
}
}
}
propertyDescriptorCollection = new PropertyDescriptorCollection(list.ToArray());
}
return(propertyDescriptorCollection);
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object component, Attribute[] attributes)
{
IEventBindingService eventPropertyService = this.GetEventPropertyService(component, context);
if (eventPropertyService == null)
{
return(new PropertyDescriptorCollection(null));
}
EventDescriptorCollection events = TypeDescriptor.GetEvents(component, attributes);
PropertyDescriptorCollection eventProperties = eventPropertyService.GetEventProperties(events);
Attribute[] destinationArray = new Attribute[attributes.Length + 1];
Array.Copy(attributes, 0, destinationArray, 0, attributes.Length);
destinationArray[attributes.Length] = DesignerSerializationVisibilityAttribute.Content;
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(component, destinationArray);
if (properties.Count > 0)
{
ArrayList list = null;
for (int i = 0; i < properties.Count; i++)
{
PropertyDescriptor oldPropertyDescriptor = properties[i];
if (oldPropertyDescriptor.Converter.GetPropertiesSupported() && (TypeDescriptor.GetEvents(oldPropertyDescriptor.GetValue(component), attributes).Count > 0))
{
if (list == null)
{
list = new ArrayList();
}
oldPropertyDescriptor = TypeDescriptor.CreateProperty(oldPropertyDescriptor.ComponentType, oldPropertyDescriptor, new Attribute[] { MergablePropertyAttribute.No });
list.Add(oldPropertyDescriptor);
}
}
if (list != null)
{
PropertyDescriptor[] array = new PropertyDescriptor[list.Count];
list.CopyTo(array, 0);
PropertyDescriptor[] descriptorArray2 = new PropertyDescriptor[eventProperties.Count + array.Length];
eventProperties.CopyTo(descriptorArray2, 0);
Array.Copy(array, 0, descriptorArray2, eventProperties.Count, array.Length);
eventProperties = new PropertyDescriptorCollection(descriptorArray2);
}
}
return(eventProperties);
}
public static PropertyDescriptorCollection GetProperties(ISerializableControl component, Attribute[] attributes)
{
PropertyDescriptorCollection propertyDescriptorCollection = new PropertyDescriptorCollection(null);
// add only direct properties of LayoutFrame - inherited properties are not added
PropertyDescriptorCollection originalProperties = TypeDescriptor.GetProperties(component, attributes, true);
foreach (PropertyDescriptor propertyDescriptor in originalProperties)
{
if (typeof(ISerializableControl).IsAssignableFrom(propertyDescriptor.ComponentType))
{
Attribute[] attributeArray = GetAttributes(component.SerializationObject, propertyDescriptor.Name);
var pd = TypeDescriptor.CreateProperty(component.GetType(), propertyDescriptor, attributeArray);
propertyDescriptorCollection.Add(new NotifierTypeDescriptor(component, pd));
}
}
// add properties of the serialization object
if (component.SerializationObject != null)
{
PropertyDescriptorCollection serializationProperties = TypeDescriptor.GetProperties(component.SerializationObject, attributes, true);
foreach (PropertyDescriptor propertyDescriptor in serializationProperties)
{
Attribute[] attributeArray = GetAttributes(component.SerializationObject, propertyDescriptor.Name);
var pd = TypeDescriptor.CreateProperty(component.SerializationObject.GetType(), propertyDescriptor, attributeArray);
propertyDescriptorCollection.Add(new NotifierTypeDescriptor(component, pd));
}
}
// adding events
IFrameControl frameControl = component as IFrameControl;
if (frameControl != null)
{
PropertyDescriptor[] eventDescriptors = frameControl.GetEventDescriptors();
foreach (PropertyDescriptor eventDescriptor in eventDescriptors)
{
propertyDescriptorCollection.Add(new NotifierTypeDescriptor(component, eventDescriptor));
}
}
return(propertyDescriptorCollection);
}
internal static PropertyDescriptorCollection Fix(Type type, PropertyDescriptorCollection pdc)
{
if (pdc == null || pdc.Count < 1)
{
return(pdc);
}
var factory = EntityFactory.CreateOperate(type);
// 准备字段集合
var dic = new Dictionary <String, FieldItem>(StringComparer.OrdinalIgnoreCase);
foreach (var item in factory.Fields)
{
dic.Add(item.Name, item);
}
Boolean hasChanged = false;
var list = new List <PropertyDescriptor>();
foreach (PropertyDescriptor item in pdc)
{
// 显示名与属性名相同，并且没有DisplayName特性
if (item.Name == item.DisplayName && !ContainAttribute(item.Attributes, typeof(DisplayNameAttribute)))
{
// 添加一个特性
FieldItem fi = null;
if (dic.TryGetValue(item.Name, out fi) && !String.IsNullOrEmpty(fi.Description))
{
var dis = new DisplayNameAttribute(fi.Description);
list.Add(TypeDescriptor.CreateProperty(type, item, dis));
hasChanged = true;
continue;
}
}
list.Add(item);
}
if (hasChanged)
{
pdc = new PropertyDescriptorCollection(list.ToArray());
}
return(pdc);
}
protected override void PostFilterProperties(IDictionary properties)
{
base.PostFilterProperties(properties);
PropertyDescriptor oldPropertyDescriptor = (PropertyDescriptor)properties["ID"];
PropertyDescriptor descriptor2 = (PropertyDescriptor)properties["ContentPlaceHolderID"];
properties.Clear();
ContentDesignerState showDefaultContent = ContentDesignerState.ShowDefaultContent;
ContentDefinition contentDefinition = this.GetContentDefinition();
if ((this.ContentResolutionService != null) && (contentDefinition != null))
{
showDefaultContent = this.ContentResolutionService.GetContentDesignerState(contentDefinition.ContentPlaceHolderID);
}
oldPropertyDescriptor = TypeDescriptor.CreateProperty(oldPropertyDescriptor.ComponentType, oldPropertyDescriptor, new Attribute[] { (showDefaultContent == ContentDesignerState.ShowDefaultContent) ? ReadOnlyAttribute.Yes : ReadOnlyAttribute.No });
properties.Add("ID", oldPropertyDescriptor);
descriptor2 = TypeDescriptor.CreateProperty(descriptor2.ComponentType, descriptor2, new Attribute[] { ReadOnlyAttribute.Yes });
properties.Add("ContentPlaceHolderID", descriptor2);
}
// </snippet440>
// <snippet450>
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
if (properties.Contains("Padding"))
{
properties.Remove("Padding");
}
properties["Visible"] = TypeDescriptor.CreateProperty(
typeof(MarqueeBorderDesigner),
(PropertyDescriptor)properties["Visible"],
new Attribute[0]);
properties["Enabled"] = TypeDescriptor.CreateProperty(
typeof(MarqueeBorderDesigner),
(PropertyDescriptor)properties["Enabled"],
new Attribute[0]);
}
/// <include file='doc\ListControlDesigner.uex' path='docs/doc[@for="ListControlDesigner.PreFilterProperties"]/*' />
/// <devdoc>
/// <para>
/// Filters the properties to replace the runtime DataSource property
/// descriptor with the designer's.
/// </para>
/// </devdoc>
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
PropertyDescriptor prop;
prop = (PropertyDescriptor)properties["DataSource"];
Debug.Assert(prop != null);
// we can't create the designer DataSource property based on the runtime property since theie
// types do not match. Therefore, we have to copy over all the attributes from the runtime
// and use them that way.
AttributeCollection runtimeAttributes = prop.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataSourceConverter));
prop = TypeDescriptor.CreateProperty(this.GetType(), "DataSource", typeof(string),
attrs);
properties["DataSource"] = prop;
prop = (PropertyDescriptor)properties["DataMember"];
Debug.Assert(prop != null);
prop = TypeDescriptor.CreateProperty(this.GetType(), prop,
new Attribute[] {
new TypeConverterAttribute(typeof(DataMemberConverter))
});
properties["DataMember"] = prop;
Attribute[] fieldPropAttrs = new Attribute[] {
new TypeConverterAttribute(typeof(DataFieldConverter))
};
prop = (PropertyDescriptor)properties["DataTextField"];
Debug.Assert(prop != null);
prop = TypeDescriptor.CreateProperty(this.GetType(), prop, fieldPropAttrs);
properties["DataTextField"] = prop;
prop = (PropertyDescriptor)properties["DataValueField"];
Debug.Assert(prop != null);
prop = TypeDescriptor.CreateProperty(this.GetType(), prop, fieldPropAttrs);
properties["DataValueField"] = prop;
}
protected override void PreFilterProperties(System.Collections.IDictionary properties)
{
base.PreFilterProperties(properties);
// Properties that are overridden in the designer because they have custom editors or converters
Type designerType = GetType();
properties["ConnectionString"] = TypeDescriptor.CreateProperty(designerType, "ConnectionString", typeof(string));
properties["DefaultContainerName"] = TypeDescriptor.CreateProperty(designerType, "DefaultContainerName", typeof(string));
properties["EntitySetName"] = TypeDescriptor.CreateProperty(designerType, "EntitySetName", typeof(string));
properties["EntityTypeFilter"] = TypeDescriptor.CreateProperty(designerType, "EntityTypeFilter", typeof(string));
properties["CommandText"] = TypeDescriptor.CreateProperty(designerType, "CommandText", typeof(string));
properties["OrderBy"] = TypeDescriptor.CreateProperty(designerType, "OrderBy", typeof(string));
properties["Select"] = TypeDescriptor.CreateProperty(designerType, "Select", typeof(string));
properties["Where"] = TypeDescriptor.CreateProperty(designerType, "Where", typeof(string));
// Properties that should be browsable in intellisense, but not visible in the designer property grid
properties.Remove("ContextType");
}
protected override void PreFilterProperties(IDictionary properties)
{
// Invoke the base method. This will hide those properties
// specified in ConnectionsZoneDesigner.
base.PreFilterProperties(properties);
// Set attributes to remove it from the property grid and any editors.
Attribute[] newAttributes = new Attribute[]
{ new BrowsableAttribute(false),
new EditorBrowsableAttribute(EditorBrowsableState.Never) };
PropertyDescriptor property = (PropertyDescriptor)properties[propertyToHide];
if (property != null)
{
// Re-create the property with the attributes specified above.
properties[propertyToHide] = TypeDescriptor.CreateProperty(property.ComponentType, property, newAttributes);
}
}
public TriggerDescriptionProvider()
{
_properties = new PropertyDescriptorCollection(
TypeDescriptor.GetProperties(typeof(Trigger))
.Cast <PropertyDescriptor>()
.Select(prop =>
{
if (prop.PropertyType == typeof(DateTime?))
{
return(TypeDescriptor.CreateProperty(typeof(Trigger), prop, new EditorAttribute("System.ComponentModel.Design.DateTimeEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))));
}
if (prop.Name == "Parameters")
{
return(TypeDescriptor.CreateProperty(typeof(Trigger), prop, new TypeConverterAttribute(typeof(TriggerParametersTypeConverter))));
}
return(prop);
})
.ToArray());
}
/// <summary>
/// Allows a designer to change or remove items from the set of properties that it
/// exposes through a TypeDescriptor
/// </summary>
/// <param name="properties">The properties for the class of the component.</param>
protected override void PostFilterProperties(IDictionary properties)
{
StringCollection toRemove = new StringCollection();
foreach (string key in properties.Keys)
{
// Remove everything except Text and ImageIndex
if (key != "Text" && key != "ImageIndex" && !key.StartsWith("Name") &&
!key.StartsWith("ImageList") && !key.StartsWith("Height") &&
!key.StartsWith("HelpText"))
{
toRemove.Add(key);
}
}
foreach (string str in toRemove)
{
properties.Remove(str);
}
PropertyDescriptor property = (PropertyDescriptor)properties["ImageList"];
// set ImageList property to not browsable
properties["ImageList"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, BrowsableAttribute.No, DesignerSerializationVisibilityAttribute.Hidden);
property = (PropertyDescriptor)properties["ImageListLarge"];
properties["ImageListLarge"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, BrowsableAttribute.No);
property = (PropertyDescriptor)properties["ImageListSmall"];
properties["ImageListSmall"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, BrowsableAttribute.No);
property = (PropertyDescriptor)properties["Height"];
properties["Height"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, BrowsableAttribute.No, DesignerSerializationVisibilityAttribute.Hidden);
property = (PropertyDescriptor)properties["HeightLarge"];
properties["HeightLarge"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, BrowsableAttribute.No);
property = (PropertyDescriptor)properties["HeightSmall"];
properties["HeightSmall"] = TypeDescriptor.CreateProperty(property.ComponentType,
property, BrowsableAttribute.No);
base.PostFilterProperties(properties);
}
protected override void PostFilterProperties(IDictionary properties)
{
base.PostFilterProperties(properties);
var propertiesToRemove = new string[] {
"Dock", "Anchor", "Size", "Location", "Width", "Height",
"MinimumSize", "MaximumSize", "AutoSize", "AutoSizeMode",
"Visible", "Enabled",
};
foreach (var item in propertiesToRemove)
{
if (properties.Contains(item))
{
properties[item] = TypeDescriptor.CreateProperty(this.Component.GetType(),
(PropertyDescriptor)properties[item],
new BrowsableAttribute(false));
}
}
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
if (context != null && ((MapLocation)value).Docked)
{
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(value, new Attribute[1]
{
new BrowsableAttribute(browsable: true)
});
PropertyDescriptorCollection propertyDescriptorCollection = new PropertyDescriptorCollection(null);
{
foreach (PropertyDescriptor item in properties)
{
propertyDescriptorCollection.Add(TypeDescriptor.CreateProperty(value.GetType(), item, new ReadOnlyAttribute(isReadOnly: true)));
}
return(propertyDescriptorCollection);
}
}
return(base.GetProperties(context, value, attributes));
}
protected override void PostFilterProperties(IDictionary properties)
{
// To support the Reset option in the property grid a property must
// have a setter (amongst other things). Most of ours do not because
// the public API does not require it. To offer a Reset option we
// instead tell the designer to use the following properties in THIS
// class as if they were on the control class, thereby allowing us
// to provide a (hidden) setter and get Reset functionality.
// All your property are belong to us ;)
properties["Scrolling"] = TypeDescriptor.CreateProperty(
GetType(),
"Scrolling",
typeof(Scrolling),
GetCustomAttributes("Scrolling"));
base.PostFilterProperties(properties);
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
var baseProperties = base.GetProperties(context, value, attributes);
var properties = new PropertyDescriptorCollection(null);
foreach (PropertyDescriptor baseProperty in baseProperties)
{
if (baseProperty.Name == "Name")
{
continue;
}
var property = TypeDescriptor.CreateProperty(
baseProperty.ComponentType,
baseProperty,
RefreshPropertiesAttribute.Repaint);
properties.Add(property);
}
return(properties);
}
/// <summary>
/// Allows a designer to filter the set of properties the component it is designing will expose through the TypeDescriptor object.
/// </summary>
protected virtual void PostFilterProperties(IDictionary properties)
{
if (_inheritedProps is null)
{
return;
}
bool readOnlyInherit = InheritanceAttribute.Equals(InheritanceAttribute.InheritedReadOnly);
if (readOnlyInherit)
{
// Now loop through all the properties. For each one, try to match a pre-created property.
// If that fails, then create a new property.
PropertyDescriptor[] values = new PropertyDescriptor[properties.Values.Count];
properties.Values.CopyTo(values, 0);
for (int i = 0; i < values.Length; i++)
{
PropertyDescriptor prop = values[i];
// This is a private component. Therefore, the user should not be allowed to modify any properties.
// We replace all properties with read-only versions.
properties[prop.Name] = TypeDescriptor.CreateProperty(prop.ComponentType, prop, ReadOnlyAttribute.Yes);
}
return;
}
// otherwise apply our inherited properties to the actual property list.
foreach (DictionaryEntry de in _inheritedProps)
{
if (de.Value is InheritedPropertyDescriptor inheritedPropDesc)
{
// replace the property descriptor it was created with with the new one in case we're shadowing
PropertyDescriptor newInnerProp = (PropertyDescriptor)properties[de.Key];
if (newInnerProp != null)
{
inheritedPropDesc.PropertyDescriptor = newInnerProp;
properties[de.Key] = inheritedPropDesc;
}
}
}
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
PropertyDescriptor[] properties = new PropertyDescriptor[3];
properties[0] = new ShadowProperty(
"DayHeadersBackColor",
TypeDescriptor.CreateProperty(
typeof(DayHeadersStyle),
DayHeadersBackColorName,
typeof(ExpressionInfo),
new TypeConverterAttribute(typeof(ColorExpressionInfoConverter)),
new DefaultValueAttribute((object)ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertColorToString(CalendarData.DefaultDayHeadersBackcolor)))));
properties[1] = new ShadowProperty(
"DayHeadersBorderStyle",
TypeDescriptor.CreateProperty(
typeof(DayHeadersStyle),
DayHeadersBorderName,
typeof(DesignLineStyle),
new TypeConverterAttribute(typeof(DesignLineStyle.Converter)),
new DefaultValueAttribute(typeof(DesignLineStyle), string.Format("{0}, {1}, {2}",
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertColorToString(CalendarData.DefaultDayHeadersBorderColor)),
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertLengthToString(CalendarData.DefaultDayHeadersBorderWidth)),
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertToString(CalendarData.DefaultDayHeadersBorderStyle))))));
properties[2] = new ShadowProperty(
"DayHeadersFontStyle",
TypeDescriptor.CreateProperty(
typeof(DayHeadersStyle),
DayHeadersFontStyleName,
typeof(DesignTextStyle),
new TypeConverterAttribute(typeof(DesignTextStyle.Converter)),
new DefaultValueAttribute(typeof(DesignTextStyle), string.Format("{0}, {1}, {2}, {3}, {4}, {5}",
ExpressionInfo.FromString(CalendarData.DefaultDayHeadersFontFamily),
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertLengthToString(CalendarData.DefaultDayHeadersFontSize)),
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertToString(CalendarData.DefaultDayHeadersFontStyle)),
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertToString(CalendarData.DefaultDayHeadersFontWeight)),
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertToString(CalendarData.DefaultDayHeadersFontDecoration)),
ExpressionInfo.FromString(ToolsNamespace.Utils.ConvertColorToString(CalendarData.DefaultDayHeadersFontColor))))));
PropertyDescriptorCollection pdc = new PropertyDescriptorCollection(properties);
return(pdc.Sort(PropertySortOrder));
}
// MSDN says that this adds the "BackColor" and "Location" browsable design-time propeties.
//
// The reason for overwriting the Location property created by the ControDesigner is that
// the root component is not draggable (e.g a form has a static location in the DesignerViewFrame)
//
protected override void PreFilterProperties (IDictionary properties)
{
base.PreFilterProperties (properties);
PropertyDescriptor propertyDescriptor = properties["BackColor"] as PropertyDescriptor;
if (propertyDescriptor != null)
{
properties["BackColor"] = TypeDescriptor.CreateProperty (typeof (DocumentDesigner),
propertyDescriptor,
new Attribute[] { new DefaultValueAttribute (System.Drawing.SystemColors.Control) });
}
propertyDescriptor = properties["Location"] as PropertyDescriptor;
if (propertyDescriptor != null)
{
properties["Location"] = TypeDescriptor.CreateProperty (typeof (DocumentDesigner),
propertyDescriptor,
new Attribute[] { new DefaultValueAttribute (typeof (Point), "0, 0") });
}
}
internal static void AddAttributesToProperty(
Type designerType,
IDictionary properties,
String propertyName,
Attribute[] attributeArray)
{
Debug.Assert(propertyName != null &&
propertyName.Length != 0);
PropertyDescriptor prop = (PropertyDescriptor)properties[propertyName];
Debug.Assert(prop != null);
prop = TypeDescriptor.CreateProperty(
designerType,
prop,
attributeArray);
properties[propertyName] = prop;
}
private static void HideProperty(String propertyName, FilterComponentPropertiesEventArgs e)
{
var oldPropertyDescriptor = e.Properties[propertyName] as PropertyDescriptor;
if (oldPropertyDescriptor != null)
{
// Substitute the current property descriptor
// with a custom one with the BrowsableAttribute.No attribute.
e.Properties[propertyName] = TypeDescriptor.CreateProperty(
oldPropertyDescriptor.ComponentType,
oldPropertyDescriptor,
BrowsableAttribute.No);
}
else
{
// If the property descriptor can not be substituted,
// remove it from the Properties collection.
e.Properties.Remove(propertyName);
}
}
static IEnumerable <GraphEdge> GetLayeredSuccessors(Node <ExpressionBuilder, ExpressionBuilderArgument> node, int layer, Dictionary <Node <ExpressionBuilder, ExpressionBuilderArgument>, GraphNode> layerMap)
{
foreach (var successor in node.Successors)
{
var layeredSuccessor = layerMap[successor.Target];
var currentSuccessor = layeredSuccessor;
var property = TypeDescriptor.CreateProperty(typeof(Edge <ExpressionBuilder, ExpressionBuilderArgument>), "Label", typeof(ExpressionBuilderArgument));
var context = new TypeDescriptorContext(successor, property);
for (int i = layeredSuccessor.Layer + 1; i < layer; i++)
{
var edge = new GraphEdge(context, successor.Label, currentSuccessor);
var dummyNode = new GraphNode(null, i, Enumerable.Repeat(edge, 1));
dummyNode.Tag = edge;
currentSuccessor = dummyNode;
}
yield return(new GraphEdge(context, successor.Label, currentSuccessor));
}
}
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
string[] propertiesToHide = { "Text" };
foreach (string propname in propertiesToHide)
{
var prop = (PropertyDescriptor)properties[propname];
if (prop != null)
{
// Add Browsable(false) to attributes
Attribute[] attributes = new Attribute[prop.Attributes.Count + 1];
prop.Attributes.CopyTo(attributes, 0);
attributes[attributes.Length - 1] = new BrowsableAttribute(false);
prop = TypeDescriptor.CreateProperty(this.GetType(), propname, prop.PropertyType, attributes);
properties[propname] = prop;
}
}
}
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
properties[_appliedDeviceFiltersPropName] =
TypeDescriptor.CreateProperty(this.GetType(), _appliedDeviceFiltersPropName, typeof(String));
properties[_propertyOverridesPropName] =
TypeDescriptor.CreateProperty(this.GetType(), _propertyOverridesPropName, typeof(String));
foreach (string propertyName in _nonBrowsableProperties)
{
PropertyDescriptor property = (PropertyDescriptor)properties[propertyName];
Debug.Assert(property != null, "Property is null: " + propertyName);
if (property != null)
{
properties[propertyName] = TypeDescriptor.CreateProperty(this.GetType(), property, BrowsableAttribute.No);
}
}
}
private static void ReplaceDefaultValue(IDictionary properties, String name, DefaultValueAttribute newDefault)
{
PropertyDescriptor propertyToChange = (PropertyDescriptor)properties[name];
Attribute[] newAttributes = new Attribute[propertyToChange.Attributes.Count];
for (int i = 0; i < propertyToChange.Attributes.Count; i++)
{
Attribute attr = propertyToChange.Attributes[i];
if (attr is DefaultValueAttribute)
{
newAttributes[i] = newDefault;
}
else
{
newAttributes[i] = propertyToChange.Attributes[i];
}
}
propertyToChange = TypeDescriptor.CreateProperty(typeof(CheckedListBox), propertyToChange, newAttributes);
properties[name] = propertyToChange;
}
