1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using Tango.Core;
using Tango.Core.CustomAttributes;
/// <summary>
/// Contains extension methods for <see cref="IParameterized"/>.
/// </summary>
public static class IParameterizedExtensions
{
/// <summary>
/// Creates an observable collection of the parameterized object.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="mode">The parameters update mode.</param>
/// <returns></returns>
public static ObservableCollection<ParameterItem> CreateParametersCollection(this IParameterized instance, ParameterItemMode mode)
{
var ps = new ObservableCollection<ParameterItem>();
int index = 0;
List<Type> types = new List<Type>();
Type currentType = instance.GetType();
while (true)
{
if (typeof(IParameterized).IsAssignableFrom(currentType) && currentType != typeof(IParameterized))
{
types.Add(currentType);
currentType = currentType.BaseType;
}
else
{
break;
}
}
List<PropertyInfo> properties = new List<PropertyInfo>();
foreach (var type in types)
{
foreach (var prop in type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Where(x => x.SetMethod != null))
{
if (prop.PropertyType.IsPrimitive || prop.PropertyType == typeof(String) || prop.PropertyType == typeof(DateTime))
{
var paramAtt = prop.GetCustomAttributes(typeof(ParameterItemAttribute), false).Cast<ParameterItemAttribute>().FirstOrDefault();
var ignore = prop.GetCustomAttributes(typeof(ParameterIgnoreAttribute), false).Cast<ParameterIgnoreAttribute>().FirstOrDefault();
var indexAttr = prop.GetCustomAttributes(typeof(PropertyIndexAttribute), false).Cast<PropertyIndexAttribute>().FirstOrDefault();
if (ignore == null && !properties.Exists(x => x.Name == prop.Name))
{
var item = instance.CreateParameterItem(prop, paramAtt,indexAttr != null ? indexAttr.Index : index++, mode);
ps.Add(item);
properties.Add(prop);
}
}
}
}
return ps.OrderBy(x => x.Index).ToObservableCollection();
}
/// <summary>
/// Creates the parameter item.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="propertyInfo">The property information.</param>
/// <param name="attribute">The attribute.</param>
/// <param name="index">The index.</param>
/// <param name="mode">The mode.</param>
/// <returns></returns>
public static ParameterItem CreateParameterItem(this IParameterized instance, PropertyInfo propertyInfo, ParameterItemAttribute attribute, int index, ParameterItemMode mode)
{
ParameterItem item = new ParameterItem();
item.Name = propertyInfo.Name.ToTitle();
item.Index = index;
item.Type = propertyInfo.PropertyType;
item.ParameterizedObject = instance;
if (attribute != null)
{
item.Value = attribute.Default;
item.Minimum = attribute.Minimum;
item.Maximum = attribute.Maximum;
item.CustomEditorTypeName = attribute.CustomEditorTypeName;
item.ExtraObject = attribute.ExtraObject;
if (attribute.Name != null)
{
item.Name = attribute.Name;
}
}
else
{
//Try get description and range attributes
DescriptionAttribute desAtt = propertyInfo.GetCustomAttribute<DescriptionAttribute>();
if (desAtt != null)
{
item.Description = desAtt.Description;
}
RangeAttribute rangeAtt = propertyInfo.GetCustomAttribute<RangeAttribute>();
if (rangeAtt != null)
{
item.Minimum = rangeAtt.Minimum;
item.Maximum = rangeAtt.Maximum;
}
StringFormatAttribute formatAtt = propertyInfo.GetCustomAttribute<StringFormatAttribute>();
if (formatAtt != null)
{
item.StringFormat = formatAtt.Format;
}
PropertyIndexAttribute indexAtt = propertyInfo.GetCustomAttribute<PropertyIndexAttribute>();
if (indexAtt != null)
{
item.Index = indexAtt.Index;
}
}
if (mode == ParameterItemMode.Event)
{
item.ParameterValueChanged += (sender, e) =>
{
propertyInfo.SetValue(instance, e.Value);
};
}
else if (mode == ParameterItemMode.Binding)
{
item.Bind(ParameterItem.ValueProperty, instance, propertyInfo.Name, System.Windows.Data.BindingMode.TwoWay);
}
return item;
}
/// <summary>
/// Creates the parameter item.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="attribute">The attribute.</param>
/// <param name="index">The index.</param>
/// <param name="mode">The mode.</param>
/// <returns></returns>
public static ParameterItem CreateParameterItem(this IParameterized instance, String propertyName, ParameterItemAttribute attribute, int index, ParameterItemMode mode)
{
return instance.CreateParameterItem(instance.GetType().GetProperty(propertyName), attribute, index, mode);
}
}
|
