private static InnerParametrizedObject GetInnerParametrizedObject( IParametrizedObject @this, MemberInfo fieldOrProperty) { FieldInfo fi = fieldOrProperty as FieldInfo; InnerParametrizedObject result = new InnerParametrizedObject() { ParentFieldName = fieldOrProperty.Name }; if (fi != null) { result.ParametrizedObject = fi.GetValue(@this) as IParametrizedObject; return(result); } PropertyInfo pi = fieldOrProperty as PropertyInfo; if (pi != null) { result.ParametrizedObject = pi.GetValue(@this, null) as IParametrizedObject; return(result); } return(null); }
private static Parameter CreateParameter(IParametrizedObject @this, MemberInfo fieldOrProperty, object attribute) { Parameter result = null; ParameterAttribute parameterAttribute = attribute as ParameterAttribute; Type fieldType = fieldOrProperty.GetFieldOrPropertyType(); string typeDescription = GetFieldOrPropertyTypeDescription(@this, fieldType, fieldOrProperty); result = new Parameter( @this, fieldOrProperty, fieldType, parameterAttribute.MinimumValue, parameterAttribute.MaximumValue, parameterAttribute.StringType, parameterAttribute.Description, typeDescription); if (!result.IsString && result.StringType != StringParameterType.Unspecified) { throw new InvalidOperationException("'StringType' argument can be used only with string fields. Class: " + @this.GetType().FullName + ", field name: " + fieldOrProperty.Name); } if (!result.IsNumeric && (result.MinimumValue != null || result.MaximumValue != null)) { throw new InvalidOperationException("'MinimumValue' and 'MaximumValue' arguments can be used only with numeric fields. Class: " + @this.GetType().FullName + ", field name: " + fieldOrProperty.Name); } return(result); }
private void ConfigureObjectWithInnerObjects(IParametrizedObject parametrizedObject) { if (this.inhibitParameterWindow) { return; } ParameterWindow.ConfigureParametrizedObjectAndInnerObjects(parametrizedObject); }
private void ConfigureObject(IParametrizedObject parametrizedObject) { if (this.inhibitParameterWindow) { return; } ParameterWindow.ConfigureParametrizedObject(parametrizedObject); }
public static void CopyParametersFrom(this IParametrizedObject @this, IParametrizedObject other) { Contract.Requires(@this.GetType().Equals(other.GetType())); foreach (var parameterPair in Enumerable.Zip(@this.GetParameters(), other.GetParameters(), (p1, p2) => new { P1 = p1, P2 = p2 })) { parameterPair.P1.SetValue(parameterPair.P2.GetValue()); } }
public static ParametersSnapshot GetParameterSnapshotWithInnerObjects(this IParametrizedObject @this, string parentFieldName) { ParametersSnapshot result = @this.GetParametersSnapshot(parentFieldName); result.InnerSnapshots = @this .GetInnerParametrizedObjects() .Select(io => GetParameterSnapshotWithInnerObjects(io.ParametrizedObject, io.ParentFieldName)) .ToArray(); return(result); }
public static IEnumerable <Parameter> GetParameters(this IParametrizedObject @this) { return(@this .GetType() .GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static) .Concat <MemberInfo>(@this.GetType().GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) .Select(fop => new { FieldOrProperty = fop, Attribute = ProcessAttributes(fop) }) .Where(d => d.Attribute != null) .Select(d => CreateParameter(@this, d.FieldOrProperty, d.Attribute)) .ToArray()); }
private void ConfigureItemClick(object sender, EventArgs e) { IParametrizedObject parametrizedObject = this.gridViewMenuStrip.Tag as IParametrizedObject; if (!parametrizedObject.GetParameters().Any()) { MessageBox.Show("This item has no configuration parameters", "Nothing to configure", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } ConfigureObjectWithInnerObjects(parametrizedObject); }
public static IEnumerable <InnerParametrizedObject> GetInnerParametrizedObjects( this IParametrizedObject @this) { return(@this .GetType() .GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static) .Concat <MemberInfo>(@this.GetType().GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) .Where(fop => !fop.GetCustomAttributes(typeof(CompilerGeneratedAttribute), true).Any()) .Where(fop => typeof(IParametrizedObject).IsAssignableFrom(fop.GetFieldOrPropertyType())) .Select(fop => GetInnerParametrizedObject(@this, fop)) .Where(po => po != null) .ToArray()); }
private static string GetFieldOrPropertyTypeDescription(IParametrizedObject @this, Type type, MemberInfo fieldOrProperty) { if (fieldTypeToDescription.ContainsKey(type)) { return(fieldTypeToDescription[type]); } if (type.BaseType != null && fieldTypeToDescription.ContainsKey(type.BaseType)) { return(fieldTypeToDescription[type.BaseType]); } throw new InvalidOperationException("Unsupported field type: '" + type.FullName + "' used in class: '" + @this.GetType().FullName + "', field name: '" + fieldOrProperty.Name + "'"); }
public static void CopyParametersFromWithInnerObjects(this IParametrizedObject @this, IParametrizedObject other) { Contract.Requires(@this.GetType().Equals(other.GetType())); @this.CopyParametersFrom(other); foreach (var objectPair in Enumerable.Zip(@this.GetInnerParametrizedObjects(), other.GetInnerParametrizedObjects(), (o1, o2) => new { O1 = o1, O2 = o2 })) { objectPair.O1.ParametrizedObject.CopyParametersFromWithInnerObjects(objectPair.O2.ParametrizedObject); } @this.ParametersChanged(); }
public static void SetParametersFromSnapshotWithInnerObjects(this IParametrizedObject @this, ParametersSnapshot snapshot) { @this.SetParametersFromSnapshot(snapshot); Dictionary <string, ParametersSnapshot> snapshots = snapshot.InnerSnapshots.ToDictionary(s => s.ParentFieldName, s => s); foreach (InnerParametrizedObject io in @this.GetInnerParametrizedObjects()) { if (snapshots.ContainsKey(io.ParentFieldName)) { io.ParametrizedObject.SetParametersFromSnapshotWithInnerObjects(snapshots[io.ParentFieldName]); } } @this.ParametersChanged(); }
private static ParametersSnapshot GetParametersSnapshot(this IParametrizedObject @this, string parentFieldName) { ParametersSnapshot result = new ParametersSnapshot() { ParentFieldName = parentFieldName }; result.ParameterValues = @this .GetParameters() .Select(p => new ParameterValuePair() { Name = p.Field.Name, Value = (string)Convert.ChangeType(p.GetValue(), typeof(string), CultureInfo.InvariantCulture) }) .ToArray(); return(result); }
public static void SetParametersFromSnapshot(this IParametrizedObject @this, ParametersSnapshot snapshot) { Dictionary <string, string> parameterValues = snapshot.ParameterValues.ToDictionary(pvp => pvp.Name, pvp => pvp.Value); foreach (Parameter parameter in @this.GetParameters()) { if (parameterValues.ContainsKey(parameter.Field.Name)) { if (parameter.IsEnum) { parameter.SetValue(Enum.Parse(parameter.FieldType, parameterValues[parameter.Field.Name])); } else { parameter.SetValue(Convert.ChangeType(parameterValues[parameter.Field.Name], parameter.FieldType, CultureInfo.InvariantCulture)); } } } @this.ParametersChanged(); }
public static DialogResult ConfigureParametrizedObject(IParametrizedObject parametrizedObject) { return((new ParameterWindow(parametrizedObject, false)).ShowDialog()); }
public static DialogResult ConfigureParametrizedObjectAndInnerObjects(IParametrizedObject parametrizedObject) { return((new ParameterWindow(parametrizedObject, true)).ShowDialog()); }
public void Initialize(IParametrizedObject parametrizedObject, bool includeInnerObjectParameters) { this.panel.Controls.Clear(); this.innerParameterControls.Clear(); this.parametrizedObject = parametrizedObject; this.panel.SuspendLayout(); this.SuspendLayout(); AddTitleLabel(); IEnumerable <Parameter> parameters = this.parametrizedObject.GetParameters(); IEnumerable <InnerParametrizedObject> innerParametrizedObjects = this.parametrizedObject.GetInnerParametrizedObjects(); if (parameters.Any()) { foreach (var parameter in parameters) { FlowLayoutPanel panel = new FlowLayoutPanel(); panel.CausesValidation = true; panel.FlowDirection = FlowDirection.LeftToRight; panel.WrapContents = false; panel.AutoSize = true; panel.AutoScroll = false; panel.AutoSize = true; AddParameterNameLabel(parameter, panel); AddParameterControl(parameter, panel); AddParameterDescriptionLabel(parameter, panel); this.panel.Controls.Add(panel); } } else { Label noParameterInfoLabel = new Label(); noParameterInfoLabel.AutoSize = true; noParameterInfoLabel.Text = "This object has no parameters"; noParameterInfoLabel.Enabled = false; noParameterInfoLabel.Font = new Font(noParameterInfoLabel.Font, FontStyle.Italic); noParameterInfoLabel.TextAlign = ContentAlignment.MiddleCenter; noParameterInfoLabel.Margin = new Padding(5); this.panel.Controls.Add(noParameterInfoLabel); } if (includeInnerObjectParameters) { foreach (InnerParametrizedObject innerParametrizedObject in innerParametrizedObjects) { ParameterControl pc = new ParameterControl(); pc.ParameterValueEdited = this.ParameterValueEdited; pc.AutoSize = true; pc.OwnerComponentName = this.parametrizedObject.GetType().GetDisplayName(); pc.OwnerComponentFieldName = innerParametrizedObject.ParentFieldName; pc.Initialize(innerParametrizedObject.ParametrizedObject, true); this.panel.Controls.Add(pc); this.innerParameterControls.Add(pc); } } this.ResumeLayout(); this.panel.ResumeLayout(); this.panel.PerformLayout(); }
public static ParametersSnapshot GetParameterSnapshotWithInnerObjects(this IParametrizedObject @this) { return(@this.GetParameterSnapshotWithInnerObjects(string.Empty)); }
public ParameterWindow(IParametrizedObject parametrizedObject, bool withInnerObjects) { InitializeComponent(); this.parameterControl.Initialize(parametrizedObject, withInnerObjects); }