/// <summary> /// Method that <see cref="IPropertyBuildContext{TSubject}.AddEntry(string,IValueGetter,Demo.yFiles.Option.DataBinding.IValueSetter)">adds entries</see> /// for the <see cref="INode.Layout"/> of a node. /// </summary> /// <remarks> /// This implementation create a <see cref="IPropertyBuildContext{TSubject}.CreateChildContext{TChild}">child context</see> /// and adds properties for x,y,width, and height. /// </remarks> /// <param name="context">The context to use.</param> protected virtual void BuildLayoutProperties(IPropertyBuildContext <INode> context) { IPropertyBuildContext <IMutableRectangle> childContext = context.CreateChildContext <IMutableRectangle>(LayoutPropertyName, delegate { return((IMutableRectangle)context.CurrentInstance.Lookup(typeof(IMutableRectangle))); }, delegate { //we work directly on the mutable rectangle }, AssignmentPolicy.ModifyInstance); childContext.AddEntry <double>(LayoutXName, delegate { return(childContext.CurrentInstance.X); }, delegate(double value) { childContext.CurrentInstance.X = value; }); childContext.AddEntry <double>(LayoutYName, delegate { return(childContext.CurrentInstance.Y); }, delegate(double value) { childContext.CurrentInstance.Y = value; }); childContext.AddEntry <double>(LayoutWidthName, delegate { return(childContext.CurrentInstance.Width); }, delegate(double value) { childContext.CurrentInstance.Width = value; }); childContext.AddEntry <double>(LayoutHeightName, delegate { return(childContext.CurrentInstance.Height); }, delegate(double value) { childContext.CurrentInstance.Height = value; }); }
/// <summary> /// Builds the properties for the labels's <see cref="ILabelModel"/> type. /// </summary> protected virtual void BuildModelProperties(IPropertyBuildContext <ILabel> context) { ValueGetterDelegate <Type> labelModelGetter = new ValueGetterDelegate <Type>( delegate { var type = context.CurrentInstance.LayoutParameter.Model.GetType(); while (!type.IsPublic) { type = type.BaseType; } return(type); }); ValueSetterDelegate <Type> labelModelSetter = new ValueSetterDelegate <Type>( delegate(Type value) { IGraph graph = context.Lookup(typeof(IGraph)) as IGraph; if (graph != null) { ILabelModel model = Activator.CreateInstance(value) as ILabelModel; if (model != null) { ILabelModelParameterFinder finder = model.Lookup(typeof(ILabelModelParameterFinder)) as ILabelModelParameterFinder; ILabelModelParameter parameter; ILabel subject = context.CurrentInstance; if (finder != null) { parameter = finder.FindBestParameter(subject, model, subject.GetLayout()); } else { parameter = model.CreateDefaultParameter(); } graph.SetLabelLayoutParameter(subject, parameter); } } }); ILabel currentLabel; currentLabel = context.CurrentInstance; if (currentLabel == null) { return; } if (currentLabel.Owner is IEdge) { context.AddEntry(EdgeLabelModelProperty, labelModelGetter, labelModelSetter, null); } if (currentLabel.Owner is INode) { context.AddEntry(NodeLabelModelProperty, labelModelGetter, labelModelSetter, null); } if (currentLabel.Owner is IPort) { context.AddEntry(PortLabelModelProperty, labelModelGetter, labelModelSetter, null); } }
protected override void BuildPropertyMapImpl(IPropertyBuildContext <StringFormat> context) { context.AddEntry(DirectionProperty, new DelegateGetter <object>(delegate { StringFormat format = context.CurrentInstance; if ((format.FormatFlags & StringFormatFlags.DirectionRightToLeft) == StringFormatFlags.DirectionRightToLeft) { return(StringFormatFlags.DirectionRightToLeft); } if ((format.FormatFlags & StringFormatFlags.DirectionVertical) == StringFormatFlags.DirectionVertical) { return(StringFormatFlags.DirectionVertical); } return(null); }), new DelegateSetter <object>( delegate(object value) { if (value == null) { context.CurrentInstance.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft; context.CurrentInstance.FormatFlags &= ~StringFormatFlags.DirectionVertical; } else if (value is StringFormatFlags) { if ((StringFormatFlags)value == StringFormatFlags.DirectionRightToLeft) { context.CurrentInstance.FormatFlags &= ~StringFormatFlags.DirectionVertical; context.CurrentInstance.FormatFlags |= StringFormatFlags.DirectionRightToLeft; } else if ((StringFormatFlags)value == StringFormatFlags.DirectionVertical) { context.CurrentInstance.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft; context.CurrentInstance.FormatFlags |= StringFormatFlags.DirectionVertical; } } })); context.AddEntry <StringAlignment>(AlignmentProperty, delegate { return(context.CurrentInstance.Alignment); }, delegate(StringAlignment value) { context.CurrentInstance.Alignment = value; }); context.AddEntry <StringAlignment>(LineAlignmentProperty, delegate { return(context.CurrentInstance.LineAlignment); }, delegate(StringAlignment value) { context.CurrentInstance.LineAlignment = value; }); context.AddEntry <StringTrimming>(TrimmingProperty, delegate { return(context.CurrentInstance.Trimming); }, delegate(StringTrimming value) { context.CurrentInstance.Trimming = value; }); }
/// <summary> /// Builds the property for the labels's <see cref="ILabel.Text"/>. /// </summary> protected virtual void BuildLabelTextProperty(IPropertyBuildContext <ILabel> context) { context.AddEntry(TextProperty , new ValueGetterDelegate <string>(delegate { return(context.CurrentInstance.Text); }) , new ValueSetterDelegate <string>(delegate(string value) { IGraph graph = context.Lookup(typeof(IGraph)) as IGraph; if (graph != null) { graph.SetLabelText(context.CurrentInstance, value); } }), null); }
/// <summary> /// Builds the properties for the labels's <see cref="ILabel.PreferredSize"/>. /// </summary> protected virtual void BuildPreferredSizeProperties(IPropertyBuildContext <ILabel> context) { context.AddEntry(PreferredSizeProperty, new ValueGetterDelegate <SizeD>(delegate() { return(context.CurrentInstance.PreferredSize); }), new ValueSetterDelegate <SizeD>(delegate(SizeD value) { IGraph graph = context.Lookup(typeof(IGraph)) as IGraph; if (graph != null) { graph.SetLabelPreferredSize(context.CurrentInstance, value); } }), null); }
/// <summary> /// Builds the property for the port's <see cref="IPort.Style"/>. /// </summary> protected virtual void BuildPortStylesProperty(IPropertyBuildContext <IPort> context) { context.AddEntry(PortStyleProperty, new ValueGetterDelegate <Type>(delegate { var type = context.CurrentInstance.Style.GetType(); while (!type.IsPublic) { type = type.BaseType; } return(type); }) , new ValueSetterDelegate <Type>(delegate(Type value) { IGraph graph = context.Lookup(typeof(IGraph)) as IGraph; IPortStyle style = Activator.CreateInstance(value) as IPortStyle; if (graph != null && style != null) { graph.SetStyle(context.CurrentInstance, style); } }), null); }
public IPropertyItem AddEntry(string virtualPropertyName, IValueGetter getter, IValueSetter setter, IEqualityComparer comparer) { return(childContext.AddEntry(virtualPropertyName, getter, wrapper.decorate(setter), comparer)); }
private void AddProperty(IPropertyBuildContext <TSubject> context, MethodInfo buildChildContextMethod, PropertyInfo d) { PropertyInfo descriptor = d; Type propertyType = descriptor.PropertyType; AssignmentPolicyAttribute assignmentPolicyAttribute = descriptor.GetAttribute <AssignmentPolicyAttribute>(); NullableAttribute nullableAttribute = descriptor.GetAttribute <NullableAttribute>(); bool nullable = nullableAttribute == null || nullableAttribute.IsNullable; AssignmentPolicy policy; if (assignmentPolicyAttribute != null && context.Policy == AssignmentPolicy.Default) { policy = assignmentPolicyAttribute.Policy; } else { policy = context.Policy == AssignmentPolicy.Default ? AssignmentPolicy.CreateNewInstance : context.Policy; } object childbuilder; object currentPropertyValue = descriptor.GetValue(context.CurrentInstance, null); if (currentPropertyValue == null && nullable) { //todo: make this dependent on yet-to-implement nullable attribute childbuilder = context.GetPropertyMapBuilder(propertyType, currentPropertyValue); } else { childbuilder = context.GetPropertyMapBuilder(currentPropertyValue); } string name = descriptor.GetDisplayName(); if (childbuilder != null) { // Create the SetInstanceDelegate that uses the builders' CurrentInstance for the set operation Delegate setMemberInstanceDelegate; { Type helperSetInstanceDelegateType = typeof(HelperSetInstanceDelegate <,>) .MakeGenericType(propertyType, typeof(TSubject)); ConstructorInfo setterConstructorInfo = helperSetInstanceDelegateType .GetConstructor(new[] { typeof(PropertyInfo), typeof(IPropertyBuildContext <TSubject>) }); object helperSetInstanceDelegateInstance = setterConstructorInfo .Invoke(new object[] { descriptor, context }); MethodInfo method = helperSetInstanceDelegateType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)[0]; setMemberInstanceDelegate = Delegate.CreateDelegate(typeof(SetInstanceDelegate <>).MakeGenericType(propertyType), helperSetInstanceDelegateInstance, method); } // Create the SetInstanceDelegate that uses the builders' CurrentInstance for the set operation Delegate getMemberInstanceDelegate; { Type helperInstanceDelegateType = typeof(HelperGetInstanceDelegate <,>) .MakeGenericType(propertyType, typeof(TSubject)); ConstructorInfo getterConstructorInfo = helperInstanceDelegateType .GetConstructor(new[] { typeof(PropertyInfo), typeof(IPropertyBuildContext <TSubject>) }); object helperGetInstanceDelegateInstance = getterConstructorInfo .Invoke(new object[] { descriptor, context }); MethodInfo method = helperInstanceDelegateType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)[0]; getMemberInstanceDelegate = Delegate.CreateDelegate(typeof(GetInstanceDelegate <>).MakeGenericType(propertyType), helperGetInstanceDelegateInstance, method); } object childContext = buildChildContextMethod.MakeGenericMethod(propertyType).Invoke(context, new object[] { name, getMemberInstanceDelegate , setMemberInstanceDelegate , policy }); MethodInfo buildPropertyMapMethod = typeof(IPropertyMapBuilder).GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)[0]; buildPropertyMapMethod.MakeGenericMethod(propertyType).Invoke(childbuilder, new[] { childContext }); } else { context.AddEntry(name, new ReflectionGetter <TSubject>(descriptor, context), new ReflectionSetter <TSubject>(descriptor, context)); } }
/// <summary> /// Method that populates the <see cref="IPropertyMap"/> for edge styles in a given context. /// </summary> /// <remarks> /// This implementation uses <see cref="GetStylePropertyMapBuilder"/> to retrieve the builder for the style. /// </remarks> /// <param name="context">The context to use for queries.</param> protected virtual void BuildStyleProperties(IPropertyBuildContext <INode> context) { INode node = context.CurrentInstance; if (node != null) { INodeStyle style = node.Style; if (style != null) { GetInstanceDelegate <INodeStyle> styleGetter = delegate { return(context.CurrentInstance.Style); }; SetInstanceDelegate <INodeStyle> styleSetter = delegate(INodeStyle newValue) { IGraph graph = context.Lookup(typeof(IGraph)) as IGraph; INode currentNode = context.CurrentInstance; if (graph != null) { graph.SetStyle(currentNode, newValue); var foldingView = graph.Lookup(typeof(IFoldingView)) as IFoldingView; if (foldingView != null) { var masterNode = foldingView.GetMasterItem(currentNode); if (foldingView.IsInFoldingState(currentNode)) { // update non-dummy node foldingView.Manager.MasterGraph.SetStyle(masterNode, newValue); } else if (foldingView.IsExpanded(currentNode)) { // update dummy node if (foldingView.Manager.HasFolderNodeState(masterNode)) { foldingView.Manager.GetFolderNodeState(masterNode).Style = newValue; } } } } }; IPropertyBuildContext <INodeStyle> styleContext = context.CreateChildContext(StylePropertyName, styleGetter, styleSetter, styleAssignmentPolicy); styleContext.AddEntry("Shadow", new DelegateGetter <bool>( delegate { return(context.CurrentInstance.Style is ShadowNodeStyleDecorator); }, delegate { //show item only for !PanelNodeStyle... return(!(context.CurrentInstance.Style is PanelNodeStyle)); }), new DelegateSetter <bool>(delegate(bool isShadow) { INodeStyle currentStyle = context.CurrentInstance.Style; if (isShadow && !(currentStyle is ShadowNodeStyleDecorator)) { //don't decorate if already decorated... INodeStyle newStyle = new ShadowNodeStyleDecorator(currentStyle); styleContext.SetNewInstance(newStyle); } else { if (!isShadow && currentStyle is ShadowNodeStyleDecorator) { //remove decoration styleContext.SetNewInstance( ((ShadowNodeStyleDecorator)currentStyle).Wrapped); } } }, delegate { return(!(context.CurrentInstance.Style is PanelNodeStyle)); } )); IPropertyMapBuilder propertyBuilder = GetStylePropertyMapBuilder(context, style); if (propertyBuilder != null) { GetInstanceDelegate <INodeStyle> innerStyleGetter = delegate { return(styleContext.CurrentInstance); }; SetInstanceDelegate <INodeStyle> innerStyleSetter = delegate(INodeStyle newValue) { styleContext.SetNewInstance(newValue); }; propertyBuilder.BuildPropertyMap(styleContext.CreateChildContext(string.Empty, innerStyleGetter, innerStyleSetter, styleAssignmentPolicy)); } } } }
protected override void BuildPropertyMapImpl(IPropertyBuildContext <Brush> context) { IValueGetter fillTypeGetter = new DelegateGetter <object>( delegate() { Brush brush = context.CurrentInstance; if (brush == null) { return(null); } if (brush is SolidBrush) { return(BrushTypes.SolidBrush); } if (brush is HatchBrush) { return(BrushTypes.HatchBrush); } if (brush is LinearGradientBrush) { return(BrushTypes.LinearGradientBrush); } if (brush is TextureBrush) { return(BrushTypes.TextureBrush); } return(BrushTypes.Custom); }); IValueSetter fillTypeSetter = new DelegateSetter <object>( delegate(object value) { if (value != null) { if (!(value is BrushTypes)) { return; } BrushTypes type = (BrushTypes)value; Brush brush = context.CurrentInstance; if (type == BrushTypes.Custom) { context.SetNewInstance(brush); return; } //todo: this code should be replaced by a composite brush editor some day Color fg = Color.Black; Color bg = Color.Empty; if (brush != null) { if (brush is SolidBrush) { fg = ((SolidBrush)brush).Color; } if (brush is HatchBrush) { HatchBrush hb = (HatchBrush)brush; fg = hb.ForegroundColor; bg = hb.BackgroundColor; } if (brush is LinearGradientBrush) { LinearGradientBrush lb = (LinearGradientBrush)brush; Color[] colors = lb.LinearColors; if (colors != null) { fg = colors[0]; bg = colors[1]; } } } switch (type) { case BrushTypes.SolidBrush: if (!(brush is SolidBrush)) { context.SetNewInstance(new SolidBrush(fg)); return; } break; case BrushTypes.HatchBrush: if (!(brush is HatchBrush)) { context.SetNewInstance(new HatchBrush(System.Drawing.Drawing2D.HatchStyle.ForwardDiagonal, fg, bg)); return; } break; case BrushTypes.TextureBrush: if (!(brush is TextureBrush)) { Image img = new Bitmap(1, 1); context.SetNewInstance(new TextureBrush(img)); return; } break; case BrushTypes.LinearGradientBrush: if (!(brush is LinearGradientBrush)) { //Accomodate for rounding errors LinearGradientBrush lgb = new LinearGradientBrush(new PointF(), new PointF(1.01f, 0), fg, bg); context.SetNewInstance(lgb); return; } break; } } else { context.SetNewInstance(null); } }); context.AddEntry(FillType, fillTypeGetter, fillTypeSetter, null); DelegateGetter <Color> foregroundColorGetter = new DelegateGetter <Color>( delegate() { Brush brush = context.CurrentInstance; if (brush == null) { return(Color.Empty); } if (brush is SolidBrush) { return(((SolidBrush)brush).Color); } if (brush is HatchBrush) { return (((HatchBrush)brush).ForegroundColor); } if (brush is LinearGradientBrush) { Color[] colors = ((LinearGradientBrush)brush). LinearColors; return (colors == null ? Color.Empty : colors[0]); } return(Color.Empty); }); DelegateSetter <Color> foregroundColorSetter = new DelegateSetter <Color>( delegate(Color value) { Brush brush = context.CurrentInstance; if (brush is SolidBrush) { SolidBrush newBrush = new SolidBrush(value); context.SetNewInstance(newBrush); return; } if (brush is HatchBrush) { HatchBrush hb = (HatchBrush)brush; HatchBrush newBrush = new HatchBrush(hb.HatchStyle, value, hb.BackgroundColor); context.SetNewInstance(newBrush); return; } if (brush is LinearGradientBrush) { LinearGradientBrush lb = (LinearGradientBrush)brush; Color[] colors = lb.LinearColors; LinearGradientBrush newBrush = new LinearGradientBrush(lb.Rectangle, value, colors[1], 0f); newBrush.WrapMode = lb.WrapMode; newBrush.Transform = lb.Transform; //(LinearGradientBrush)lb.Clone(); // newBrush.LinearColors = new Color[] { colors[0], value }; context.SetNewInstance(newBrush); return; } // if (brush is LinearGradientBrush) { // LinearGradientBrush lb = (LinearGradientBrush)brush; // Color[] colors = lb.LinearColors; // LinearGradientBrush newBrush = (LinearGradientBrush)lb.Clone(); // newBrush.LinearColors = new Color[] { value, colors[1] }; // // context.SetNewInstance(newBrush); // return; // } }, delegate() { Brush brush = context.CurrentInstance; if (brush is SolidBrush || brush is HatchBrush) { return(true); } if (brush is LinearGradientBrush) { LinearGradientBrush lb = (LinearGradientBrush)brush; Color[] colors = lb.LinearColors; return(colors != null); } return(false); }); context.AddEntry(ForegroundColor, foregroundColorGetter, foregroundColorSetter, new ArgbEqualityComparer()); DelegateGetter <Color> backgroundColorGetter = new DelegateGetter <Color>( delegate() { Brush brush = context.CurrentInstance; if (brush == null) { return(Color.Empty); } if (brush is HatchBrush) { return (((HatchBrush)brush).BackgroundColor); } if (brush is LinearGradientBrush) { Color[] colors = ((LinearGradientBrush)brush). LinearColors; return (colors == null ? Color.Empty : colors[1]); } return(Color.Empty); }); DelegateSetter <Color> backgroundColorSetter = new DelegateSetter <Color>( delegate(Color value) { Brush brush = context.CurrentInstance; if (brush is HatchBrush) { HatchBrush hb = (HatchBrush)brush; HatchBrush newBrush = new HatchBrush(hb.HatchStyle, hb.ForegroundColor, value); context.SetNewInstance(newBrush); return; } if (brush is LinearGradientBrush) { LinearGradientBrush lb = (LinearGradientBrush)brush; Color[] colors = lb.LinearColors; LinearGradientBrush newBrush = new LinearGradientBrush(lb.Rectangle, colors[0], value, 0f); newBrush.Transform = lb.Transform; newBrush.WrapMode = lb.WrapMode; //(LinearGradientBrush)lb.Clone(); // newBrush.LinearColors = new Color[] { colors[0], value }; context.SetNewInstance(newBrush); return; } }, delegate() { Brush brush = context.CurrentInstance; if (brush is SolidBrush || brush is HatchBrush) { return(true); } if (brush is LinearGradientBrush) { LinearGradientBrush lb = (LinearGradientBrush)brush; Color[] colors = lb.LinearColors; return(colors != null); } return(false); }); context.AddEntry(BackgroundColor, backgroundColorGetter, backgroundColorSetter, new ArgbEqualityComparer()); context.AddEntry(HatchStyle, new DelegateGetter <object>(delegate() { Brush brush = context.CurrentInstance; HatchBrush hb = brush as HatchBrush; if (hb != null) { return(hb.HatchStyle); } else { return(OptionItem.VALUE_UNDEFINED); } }), new DelegateSetter <HatchStyle>( delegate(HatchStyle value) { HatchBrush hb = context.CurrentInstance as HatchBrush; if (hb != null) { HatchBrush newBrush = new HatchBrush(value, hb.ForegroundColor, hb.BackgroundColor); context.SetNewInstance(newBrush); } })); context.AddEntry(Rotation, new DelegateGetter <float>(delegate() { LinearGradientBrush lb = context.CurrentInstance as LinearGradientBrush; if (lb != null) { return((float)CalculateAngle(lb.Transform)); } else { return(0); } }), new DelegateSetter <float>( delegate(float value) { LinearGradientBrush lb = context.CurrentInstance as LinearGradientBrush; if (lb != null) { context.SetNewInstance(RotateBrush(lb, value)); } })); context.AddEntry(Image, new DelegateGetter <Image>(delegate() { TextureBrush textureBrush = context.CurrentInstance as TextureBrush; if (textureBrush != null) { return(textureBrush.Image); } else { return(null); } }), new DelegateSetter <Image>( delegate(Image value) { TextureBrush newBrush = new TextureBrush(value); context.SetNewInstance(newBrush); })); #endregion }
protected override void BuildPropertyMapImpl(IPropertyBuildContext <TSubject> builder) { MethodInfo[] infos = typeof(IPropertyBuildContext <>).MakeGenericType(typeof(TSubject)).GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public); MethodInfo buildChildContextMethod = null; foreach (MethodInfo info in infos) { if (info.IsGenericMethod && info.ReturnType.IsGenericType) { buildChildContextMethod = info; break; } } if (buildChildContextMethod == null) { throw new InvalidDataException("Method not found!"); } TSubject instance = builder.CurrentInstance; PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(instance); foreach (PropertyDescriptor d in properties) { PropertyDescriptor descriptor = d; AttributeBuilderAttribute mapAttribute = (AttributeBuilderAttribute)descriptor.Attributes[typeof(AttributeBuilderAttribute)]; if (mapAttribute != null && mapAttribute.Invisible) { continue; } DisplayNameAttribute displayNameAttribute = (DisplayNameAttribute)descriptor.Attributes[typeof(DisplayNameAttribute)]; string propertyName; if (displayNameAttribute == null || displayNameAttribute.DisplayName.Length < 1) { propertyName = descriptor.Name; } else { propertyName = displayNameAttribute.DisplayName; } AssignmentPolicyAttribute assignmentPolicyAttribute = (AssignmentPolicyAttribute)descriptor.Attributes[typeof(AssignmentPolicyAttribute)]; Type propertyType = descriptor.PropertyType; NullableAttribute nullableAttribute = (NullableAttribute)descriptor.Attributes[typeof(NullableAttribute)]; bool nullable = nullableAttribute == null || nullableAttribute.IsNullable; AssignmentPolicy policy; if (assignmentPolicyAttribute != null && builder.Policy == AssignmentPolicy.Default) { policy = assignmentPolicyAttribute.Policy; } else { policy = builder.Policy == AssignmentPolicy.Default ? AssignmentPolicy.ModifyInstance : builder.Policy; } object childbuilder; object currentPropertyValue = descriptor.GetValue(builder.CurrentInstance); if (currentPropertyValue == null && nullable) { //todo: make this dependent on yet-to-implement nullable attribute childbuilder = builder.GetPropertyMapBuilder(propertyType, currentPropertyValue); } else { childbuilder = builder.GetPropertyMapBuilder(currentPropertyValue); } if (childbuilder != null) { // Create the SetInstanceDelegate that uses the builders' CurrentInstance for the set operation Delegate setMemberInstanceDelegate; { Type helperSetInstanceDelegateType = typeof(HelperSetInstanceDelegate <,>) .MakeGenericType(propertyType, typeof(TSubject)); ConstructorInfo setterConstructorInfo = helperSetInstanceDelegateType .GetConstructor(new Type[] { typeof(PropertyDescriptor), typeof(IPropertyBuildContext <TSubject>) }); object helperSetInstanceDelegateInstance = setterConstructorInfo .Invoke(new object[] { descriptor, builder }); MethodInfo method = helperSetInstanceDelegateType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)[0]; setMemberInstanceDelegate = Delegate.CreateDelegate(typeof(SetInstanceDelegate <>).MakeGenericType(propertyType), helperSetInstanceDelegateInstance, method); } // Create the SetInstanceDelegate that uses the builders' CurrentInstance for the set operation Delegate getMemberInstanceDelegate; { Type helperInstanceDelegateType = typeof(HelperGetInstanceDelegate <,>) .MakeGenericType(propertyType, typeof(TSubject)); ConstructorInfo getterConstructorInfo = helperInstanceDelegateType .GetConstructor(new Type[] { typeof(PropertyDescriptor), typeof(IPropertyBuildContext <TSubject>) }); object helperGetInstanceDelegateInstance = getterConstructorInfo .Invoke(new object[] { descriptor, builder }); MethodInfo method = helperInstanceDelegateType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)[0]; getMemberInstanceDelegate = Delegate.CreateDelegate(typeof(GetInstanceDelegate <>).MakeGenericType(propertyType), helperGetInstanceDelegateInstance, method); } object childContext = buildChildContextMethod.MakeGenericMethod(propertyType).Invoke(builder, new object[] { propertyName, getMemberInstanceDelegate, setMemberInstanceDelegate, policy }); MethodInfo buildPropertyMapMethod = typeof(IPropertyMapBuilder).GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)[0]; buildPropertyMapMethod.MakeGenericMethod(propertyType).Invoke(childbuilder, new object[] { childContext }); } else { builder.AddEntry(propertyName, new ReflectionGetter <TSubject>(descriptor, builder), new ReflectionSetter <TSubject>(descriptor, builder)); } } }
protected override void BuildPropertyMapImpl(IPropertyBuildContext <Pen> context) { Brush b = context.CurrentInstance == null ? null : context.CurrentInstance.Brush; IPropertyMapBuilder brushBuilder; if (b == null) { brushBuilder = context.GetPropertyMapBuilder(typeof(Brush), b); } else { brushBuilder = context.GetPropertyMapBuilder(b); } if (brushBuilder != null) { brushBuilder.BuildPropertyMap(context.CreateChildContext <Brush>("", delegate() { Pen p = context.CurrentInstance; return(p == null ? null:context.CurrentInstance.Brush); }, delegate(Brush newInstance) { Pen p = context.CurrentInstance; if (newInstance == null) { context.SetNewInstance(null); return; } if (p == null) { context.SetNewInstance(new Pen(newInstance)); } else { Pen clone = (Pen)p.Clone(); clone.Brush = newInstance; context.SetNewInstance(clone); } }, AssignmentPolicy.CreateNewInstance)); } context.AddEntry <float>(Width, delegate { Pen pen = context.CurrentInstance; return(pen == null ? 0 : pen.Width); }, delegate(float value) { Pen pen = context.CurrentInstance; Pen clone = pen.Clone() as Pen; if (clone != null) { clone.Width = value; context.SetNewInstance(clone); } }); context.AddEntry(DashStyle, new DelegateGetter <object>( delegate() { Pen pen = context.CurrentInstance; return(pen == null ? OptionItem.VALUE_UNDEFINED : pen.DashStyle); }), new DelegateSetter <DashStyle>(delegate(DashStyle value) { Pen pen = context.CurrentInstance; Pen clone = pen.Clone() as Pen; if (clone != null) { clone.DashStyle = value; context.SetNewInstance(clone); } })); }