/// <summary>
/// Initializes a new instance of the <see cref='System.ComponentModel.Design.ComponentDesigner' /> class using the specified component.
/// </summary>
public virtual void Initialize(IComponent component)
{
Debug.Assert(component != null, "Can't create designer with no component!");
_component = component;
// For inherited components, save off the current values so we can compute a delta. We also do this for the root component, but,
// as it is ALWAYS inherited, the computation of default values favors the presence of a default value attribute over the current code value.
bool isRoot = false;
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
if (host != null && component == host.RootComponent)
{
isRoot = true;
}
if (component.Site is IServiceContainer sc && GetService(typeof(DesignerCommandSet)) == null)
{
sc.AddService(typeof(DesignerCommandSet), new CDDesignerCommandSet(this));
}
IComponentChangeService cs = (IComponentChangeService)GetService(typeof(IComponentChangeService));
if (cs != null)
{
cs.ComponentRename += new ComponentRenameEventHandler(OnComponentRename);
}
if (isRoot || !InheritanceAttribute.Equals(InheritanceAttribute.NotInherited))
{
InitializeInheritedProperties(isRoot);
}
}
/// <include file='doc\ComponentDesigner.uex' path='docs/doc[@for="ComponentDesigner.Initialize"]/*' />
/// <devdoc>
/// <para>
/// Initializes a new instance of the <see cref='System.ComponentModel.Design.ComponentDesigner'/>
/// class using the specified component.
/// </para>
/// </devdoc>
public virtual void Initialize(IComponent component)
{
Debug.Assert(component != null, "Can't create designer with no component!");
this.component = component;
// For inherited components, save off the current values so we can
// compute a delta. We also do this for the root component, but,
// as it is ALWAYS inherited, the computation of default values
// favors the presence of a default value attribute over
// the current code value.
//
bool isRoot = false;
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
if (host != null && component == host.RootComponent)
{
isRoot = true;
}
if (isRoot || !InheritanceAttribute.Equals(InheritanceAttribute.NotInherited))
{
InitializeInheritedProperties(isRoot);
}
}
/// <summary>
/// We don't actually want to serialize any code here, so we just delegate that to the base type's
/// serializer. All we want to do is if we are in a localizable form, we want to push a
/// 'LayoutSettings' entry into the resx.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// First call the base serializer to serialize the object.
object codeObject = GetBaseSerializer(manager).Serialize(manager, value);
// Now push our layout settings stuff into the resx if we are not inherited read only and
// are in a localizable Form.
TableLayoutPanel tlp = value as TableLayoutPanel;
Debug.Assert(tlp != null, "Huh? We were expecting to be serializing a TableLayoutPanel here.");
if (tlp != null)
{
InheritanceAttribute ia = (InheritanceAttribute)TypeDescriptor.GetAttributes(tlp)[typeof(InheritanceAttribute)];
if (ia is null || ia.InheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (IsLocalizable(host))
{
PropertyDescriptor lsProp = TypeDescriptor.GetProperties(tlp)[LayoutSettingsPropName];
object val = (lsProp != null) ? lsProp.GetValue(tlp) : null;
if (val != null)
{
string key = manager.GetName(tlp) + "." + LayoutSettingsPropName;
SerializeResourceInvariant(manager, key, val);
}
}
}
}
return(codeObject);
}
/// <summary>
/// Allows a designer to filter the set of events the component it is designing will expose through the TypeDescriptor object.
/// </summary>
protected virtual void PostFilterEvents(IDictionary events)
{
// If this component is being privately inherited, we need to filter the events to make them read-only.
if (events is null)
{
return;
}
InheritanceAttribute inheritanceAttribute = InheritanceAttribute;
if (inheritanceAttribute is null || !inheritanceAttribute.Equals(InheritanceAttribute.InheritedReadOnly))
{
return;
}
EventDescriptor[] values = new EventDescriptor[events.Values.Count];
events.Values.CopyTo(values, 0);
for (int i = 0; i < values.Length; i++)
{
EventDescriptor evt = values[i];
if (evt != null)
{
events[evt.Name] = TypeDescriptor.CreateEvent(evt.ComponentType, evt, ReadOnlyAttribute.Yes);
}
}
}
public void Ctor_Default()
{
var attribute = new InheritanceAttribute();
Assert.Equal(InheritanceLevel.NotInherited, attribute.InheritanceLevel);
Assert.True(attribute.IsDefaultAttribute());
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
object obj2 = this.GetBaseSerializer(manager).Serialize(manager, value);
TableLayoutPanel component = value as TableLayoutPanel;
if (component != null)
{
InheritanceAttribute attribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(component)[typeof(InheritanceAttribute)];
if ((attribute == null) || (attribute.InheritanceLevel != InheritanceLevel.InheritedReadOnly))
{
IDesignerHost service = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (this.IsLocalizable(service))
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(component)[LayoutSettingsPropName];
object obj3 = (descriptor != null) ? descriptor.GetValue(component) : null;
if (obj3 != null)
{
string resourceName = manager.GetName(component) + "." + LayoutSettingsPropName;
base.SerializeResourceInvariant(manager, resourceName, obj3);
}
}
}
}
return(obj2);
}
public void Ctor_InheritanceLevel(InheritanceLevel inheritanceLevel)
{
var attribute = new InheritanceAttribute(inheritanceLevel);
Assert.Equal(inheritanceLevel, attribute.InheritanceLevel);
Assert.Equal(inheritanceLevel == InheritanceLevel.NotInherited, attribute.IsDefaultAttribute());
}
private static bool HasMixedInheritedChildren(Control parent)
{
bool inheritedChildren = false;
bool nonInheritedChildren = false;
foreach (Control c in parent.Controls)
{
InheritanceAttribute ia = (InheritanceAttribute)TypeDescriptor.GetAttributes(c)[typeof(InheritanceAttribute)];
if (ia != null && ia.InheritanceLevel != InheritanceLevel.NotInherited)
{
inheritedChildren = true;
}
else
{
nonInheritedChildren = true;
}
if (inheritedChildren && nonInheritedChildren)
{
return(true);
}
}
return(false);
}
protected override bool HasSitedNonReadonlyChildren(Control parent)
{
ToolStrip toolStrip = parent as ToolStrip;
if (toolStrip is null)
{
Debug.Fail("why were we passed a non winbar?");
return(false);
}
if (toolStrip.Items.Count == 0)
{
return(false);
}
foreach (ToolStripItem item in toolStrip.Items)
{
if (item.Site != null && toolStrip.Site != null && item.Site.Container == toolStrip.Site.Container)
{
// We only emit Size/Location information for controls that are sited and not inherrited readonly.
InheritanceAttribute ia = (InheritanceAttribute)TypeDescriptor.GetAttributes(item)[typeof(InheritanceAttribute)];
if (ia != null && ia.InheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
return(true);
}
}
}
return(false);
}
private void SerializeZOrder(IDesignerSerializationManager manager, CodeStatementCollection statements, Control control)
{
using (CodeDomSerializerBase.TraceScope("ControlCodeDomSerializer::SerializeZOrder()"))
{
for (int i = control.Controls.Count - 1; i >= 0; i--)
{
Control component = control.Controls[i];
if ((component.Site != null) && (component.Site.Container == control.Site.Container))
{
InheritanceAttribute attribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(component)[typeof(InheritanceAttribute)];
if (attribute.InheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
CodeExpression targetObject = new CodePropertyReferenceExpression(base.SerializeToExpression(manager, control), "Controls");
CodeMethodReferenceExpression expression2 = new CodeMethodReferenceExpression(targetObject, "SetChildIndex");
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
Method = expression2
};
CodeExpression expression4 = base.SerializeToExpression(manager, component);
expression.Parameters.Add(expression4);
expression.Parameters.Add(base.SerializeToExpression(manager, 0));
CodeExpressionStatement statement = new CodeExpressionStatement(expression);
statements.Add(statement);
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ComponentDesigner"/> class using the specified component.
/// </summary>
public virtual void Initialize(IComponent component)
{
Component = component;
// For inherited components, save off the current values so we can compute a delta. We also do this for
// the root component, but, as it is ALWAYS inherited, the computation of default values favors the
// presence of a default value attribute over the current code value.
bool isRoot = TryGetService(out IDesignerHost host) && component == host.RootComponent;
if (component?.Site is IServiceContainer sc && GetService(typeof(DesignerCommandSet)) is null)
{
sc.AddService(typeof(DesignerCommandSet), new CDDesignerCommandSet(this));
}
if (TryGetService(out IComponentChangeService cs))
{
cs.ComponentRename += new ComponentRenameEventHandler(OnComponentRename);
}
InheritanceAttribute inheritanceAttribute = InheritanceAttribute;
if (isRoot || InheritanceAttribute is null || !inheritanceAttribute.Equals(InheritanceAttribute.NotInherited))
{
InitializeInheritedProperties();
}
}
public void Equals_Object_ReturnsExpected(InheritanceAttribute attribute, object other, bool expected)
{
Assert.Equal(expected, attribute.Equals(other));
if (other is InheritanceAttribute)
{
Assert.Equal(expected, attribute.GetHashCode().Equals(other.GetHashCode()));
}
}
public void NotInherited_Get_ReturnsExpected()
{
InheritanceAttribute attribute = InheritanceAttribute.NotInherited;
Assert.Same(attribute, InheritanceAttribute.NotInherited);
Assert.Equal(InheritanceLevel.NotInherited, attribute.InheritanceLevel);
Assert.True(attribute.IsDefaultAttribute());
}
public void InheritedReadOnly_Get_ReturnsExpected()
{
InheritanceAttribute attribute = InheritanceAttribute.InheritedReadOnly;
Assert.Same(attribute, InheritanceAttribute.InheritedReadOnly);
Assert.Equal(InheritanceLevel.InheritedReadOnly, attribute.InheritanceLevel);
Assert.False(attribute.IsDefaultAttribute());
}
/// <include file='doc\ComponentDesigner.uex' path='docs/doc[@for="ComponentDesigner.PostFilterAttributes"]/*' />
/// <devdoc>
/// <para>
/// Allows a
/// designer to filter the set of member attributes the
/// component it is designing will expose through the
/// TypeDescriptor object.
/// </para>
/// </devdoc>
protected virtual void PostFilterAttributes(IDictionary attributes)
{
// If this component is being inherited, mark it as such in the class attributes.
//
if (!InheritanceAttribute.Equals(InheritanceAttribute.NotInherited))
{
attributes[typeof(InheritanceAttribute)] = InheritanceAttribute;
}
}
/// <summary>
/// Gets the inheritance attribute of the specified component.
/// </summary>
public InheritanceAttribute GetInheritanceAttribute(IComponent component)
{
InheritanceAttribute attr = (InheritanceAttribute)_inheritedComponents[component];
if (attr == null)
{
attr = InheritanceAttribute.Default;
}
return(attr);
}
static bool IsInherited(object component)
{
InheritanceAttribute attribute = GetInheritanceAttribute(component);
if (attribute != null)
{
return(attribute.InheritanceLevel != InheritanceLevel.NotInherited);
}
return(false);
}
internal DesignerActionGlyph GetDesignerActionGlyph(IComponent comp, DesignerActionListCollection dalColl)
{
InheritanceAttribute attribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(comp)[typeof(InheritanceAttribute)];
if (attribute != InheritanceAttribute.InheritedReadOnly)
{
if (dalColl == null)
{
dalColl = this.designerActionService.GetComponentActions(comp);
}
if ((dalColl != null) && (dalColl.Count > 0))
{
DesignerActionGlyph glyph = null;
if (this.componentToGlyph[comp] == null)
{
DesignerActionBehavior behavior = new DesignerActionBehavior(this.serviceProvider, comp, dalColl, this);
if (!(comp is Control) || (comp is ToolStripDropDown))
{
ComponentTray service = this.serviceProvider.GetService(typeof(ComponentTray)) as ComponentTray;
if (service != null)
{
ComponentTray.TrayControl trayControlFromComponent = service.GetTrayControlFromComponent(comp);
if (trayControlFromComponent != null)
{
Rectangle bounds = trayControlFromComponent.Bounds;
glyph = new DesignerActionGlyph(behavior, bounds, service);
}
}
}
if (glyph == null)
{
glyph = new DesignerActionGlyph(behavior, this.designerActionAdorner);
}
if (glyph != null)
{
this.componentToGlyph.Add(comp, glyph);
}
return(glyph);
}
glyph = this.componentToGlyph[comp] as DesignerActionGlyph;
if (glyph != null)
{
DesignerActionBehavior behavior2 = glyph.Behavior as DesignerActionBehavior;
if (behavior2 != null)
{
behavior2.ActionLists = dalColl;
}
glyph.Invalidate();
}
return(glyph);
}
this.RemoveActionGlyph(comp);
}
return(null);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager == null || value == null)
{
throw new ArgumentNullException((manager == null) ? "manager" : "value");
}
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (codeDomSerializer == null)
{
return(null);
}
object obj = codeDomSerializer.Serialize(manager, value);
InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
InheritanceLevel inheritanceLevel = InheritanceLevel.NotInherited;
if (inheritanceAttribute != null)
{
inheritanceLevel = inheritanceAttribute.InheritanceLevel;
}
if (inheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
IDesignerHost designerHost = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (designerHost != null)
{
PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(designerHost.RootComponent)["Localizable"];
if (propertyDescriptor != null && propertyDescriptor.PropertyType == typeof(bool) && (bool)propertyDescriptor.GetValue(designerHost.RootComponent))
{
this.SerializeControlHierarchy(manager, designerHost, value);
}
}
CodeStatementCollection codeStatementCollection = obj as CodeStatementCollection;
if (codeStatementCollection != null)
{
Control control = (Control)value;
if ((designerHost != null && control == designerHost.RootComponent) || this.HasSitedNonReadonlyChildren(control))
{
this.SerializeSuspendLayout(manager, codeStatementCollection, value);
this.SerializeResumeLayout(manager, codeStatementCollection, value);
ControlDesigner controlDesigner = designerHost.GetDesigner(control) as ControlDesigner;
var serializePerformLayoutProp = typeof(ControlDesigner).GetProperty("SerializePerformLayout", BindingFlags.NonPublic | BindingFlags.Instance);
if (this.HasAutoSizedChildren(control) || (controlDesigner != null && (bool)serializePerformLayoutProp.GetValue(controlDesigner)))
{
this.SerializePerformLayout(manager, codeStatementCollection, value);
}
}
if (this.HasMixedInheritedChildren(control))
{
this.SerializeZOrder(manager, codeStatementCollection, control);
}
}
}
return(obj);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if ((manager == null) || (value == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "value");
}
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer == null)
{
return(null);
}
object obj2 = serializer.Serialize(manager, value);
InheritanceAttribute attribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
InheritanceLevel notInherited = InheritanceLevel.NotInherited;
if (attribute != null)
{
notInherited = attribute.InheritanceLevel;
}
if (notInherited != InheritanceLevel.InheritedReadOnly)
{
IDesignerHost service = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (service != null)
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(service.RootComponent)["Localizable"];
if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && ((bool)descriptor.GetValue(service.RootComponent)))
{
this.SerializeControlHierarchy(manager, service, value);
}
}
CodeStatementCollection statements = obj2 as CodeStatementCollection;
if (statements == null)
{
return(obj2);
}
Control parent = (Control)value;
if (((service != null) && (parent == service.RootComponent)) || this.HasSitedNonReadonlyChildren(parent))
{
this.SerializeSuspendLayout(manager, statements, value);
this.SerializeResumeLayout(manager, statements, value);
ControlDesigner designer = service.GetDesigner(parent) as ControlDesigner;
if (this.HasAutoSizedChildren(parent) || ((designer != null) && designer.SerializePerformLayout))
{
this.SerializePerformLayout(manager, statements, value);
}
}
if (this.HasMixedInheritedChildren(parent))
{
this.SerializeZOrder(manager, statements, parent);
}
}
return(obj2);
}
/// <summary>
/// This method returns true if the given member descriptor should be serialized,
/// or false if there is no need to serialize the member.
/// </summary>
public override bool ShouldSerialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor)
{
bool shouldSerialize = _serializer.ShouldSerialize(manager, value, descriptor);
if (!shouldSerialize && !descriptor.Attributes.Contains(DesignOnlyAttribute.Yes))
{
switch (_model)
{
case CodeDomLocalizationModel.PropertyReflection:
if (!shouldSerialize)
{
// hook up the event the first time to clear out our cache at the end of the serialization
if (localizationLanguage is null)
{
manager.SerializationComplete += new EventHandler(OnSerializationComplete);
}
if (GetLocalizationLanguage(manager) != CultureInfo.InvariantCulture)
{
shouldSerialize = true;
}
}
break;
case CodeDomLocalizationModel.PropertyAssignment:
// If this property contains its default value, we still want to serialize it if we are in
// localization mode if we are writing to the default culture, but only if the object
// is not inherited.
InheritanceAttribute inheritance = (InheritanceAttribute)manager.Context[typeof(InheritanceAttribute)];
if (inheritance is null)
{
inheritance = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
if (inheritance is null)
{
inheritance = InheritanceAttribute.NotInherited;
}
}
if (inheritance.InheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
shouldSerialize = true;
}
break;
default:
break;
}
}
return(shouldSerialize);
}
void IDesignerFilter.PostFilterAttributes(IDictionary attributes)
{
// If this component is being inherited, mark it as such in the class attributes.
if (attributes.Contains(typeof(InheritanceAttribute)))
{
_inheritanceAttribute = attributes[typeof(InheritanceAttribute)] as InheritanceAttribute;
}
else if (!InheritanceAttribute.Equals(InheritanceAttribute.NotInherited))
{
attributes[typeof(InheritanceAttribute)] = InheritanceAttribute;
}
}
/// <summary>
/// Allows a designer to filter the set of member attributes the component it is designing will expose through the TypeDescriptor object.
/// </summary>
protected virtual void PostFilterAttributes(IDictionary attributes)
{
// If this component is being inherited, mark it as such in the class attributes.
// Also, set our member variable to ensure that what you get by querying through the TypeDescriptor and through InheritanceAttribute directly is the same.
if (attributes.Contains(typeof(InheritanceAttribute)))
{
_inheritanceAttribute = attributes[typeof(InheritanceAttribute)] as InheritanceAttribute;
}
else if (!InheritanceAttribute.Equals(InheritanceAttribute.NotInherited))
{
attributes[typeof(InheritanceAttribute)] = InheritanceAttribute;
}
}
// Determine if two objects are equal.
public override bool Equals(Object value)
{
InheritanceAttribute other = (value as InheritanceAttribute);
if (other != null)
{
return(level == other.level);
}
else
{
return(false);
}
}
/// <include file='doc\ComponentDesigner.uex' path='docs/doc[@for="ComponentDesigner.PostFilterProperties"]/*' />
/// <devdoc>
/// <para>
/// Allows
/// a designer to filter the set of properties the
/// component it is designing will expose through the
/// TypeDescriptor object.
/// </para>
/// </devdoc>
protected virtual void PostFilterProperties(IDictionary properties)
{
// Check for inheritance
//
if (inheritedProps != null)
{
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);
}
}
else
{
// otherwise apply our inherited properties to the actual property list.
//
foreach (DictionaryEntry de in inheritedProps)
{
InheritedPropertyDescriptor inheritedPropDesc = de.Value as InheritedPropertyDescriptor;
if (inheritedPropDesc != null)
{
// 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;
}
}
}
}
}
}
void IDesignerFilter.PostFilterAttributes(IDictionary attributes)
{
// If this component is being inherited, mark it as such in the class attributes.
// VSWhidbey #424845 - if the InheritanceAttribute is set in attributes, then don't override it
// Also, set our member variable to ensure that what you get by querying through the TypeDescriptor and through InheritanceAttribute directly is the same.
if (attributes.Contains(typeof(InheritanceAttribute)))
{
_inheritanceAttribute = attributes[typeof(InheritanceAttribute)] as InheritanceAttribute;
}
else if (!InheritanceAttribute.Equals(InheritanceAttribute.NotInherited))
{
attributes[typeof(InheritanceAttribute)] = InheritanceAttribute;
}
}
public static IEnumerable <object[]> Equals_TestData()
{
var attribute = new InheritanceAttribute(InheritanceLevel.Inherited);
yield return(new object[] { attribute, attribute, true });
yield return(new object[] { attribute, new InheritanceAttribute(InheritanceLevel.Inherited), true });
yield return(new object[] { attribute, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly), false });
yield return(new object[] { attribute, new object(), false });
yield return(new object[] { attribute, null, false });
}
void IDesignerFilter.PostFilterEvents(IDictionary events)
{
// If this component is being privately inherited, we need to filter the events to make them read-only.
if (InheritanceAttribute.Equals(InheritanceAttribute.InheritedReadOnly))
{
EventDescriptor[] values = new EventDescriptor[events.Values.Count];
events.Values.CopyTo(values, 0);
for (int i = 0; i < values.Length; i++)
{
EventDescriptor evt = values[i];
events[evt.Name] = TypeDescriptor.CreateEvent(evt.ComponentType, evt, ReadOnlyAttribute.Yes);
}
}
}
private void InitializeInheritedProperties(bool rootComponent)
{
Hashtable props = new Hashtable();
bool readOnlyInherit = (InheritanceAttribute.Equals(InheritanceAttribute.InheritedReadOnly));
if (!readOnlyInherit)
{
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(Component);
// 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.Count];
properties.CopyTo(values, 0);
for (int i = 0; i < values.Length; i++)
{
PropertyDescriptor prop = values[i];
// Skip some properties
//
if (object.Equals(prop.Attributes[typeof(DesignOnlyAttribute)], DesignOnlyAttribute.Yes))
{
continue;
}
if (prop.SerializationVisibility == DesignerSerializationVisibility.Hidden && !prop.IsBrowsable)
{
continue;
}
PropertyDescriptor inheritedProp = (PropertyDescriptor)props[prop.Name];
if (inheritedProp == null)
{
// This ia a publicly inherited component. We replace all component properties with
// inherited versions that reset the default property values to those that are
// currently on the component.
//
props[prop.Name] = new InheritedPropertyDescriptor(prop, component, rootComponent);
}
}
}
inheritedProps = props;
}
private void ExtractInheritanceType()
{
System.Type element = Clazz;
InheritanceAttribute inhAnn = AttributeHelper.GetFirst <InheritanceAttribute>(element);
MappedSuperclassAttribute mappedSuperClass = AttributeHelper.GetFirst <MappedSuperclassAttribute>(element);
if (mappedSuperClass != null)
{
IsEmbeddableSuperclass = true;
type = inhAnn == null ? null : inhAnn.Strategy;
}
else
{
type = inhAnn == null ? InheritanceType.SingleTable : inhAnn.Strategy;
}
}
