private string HandleEnumType()
{
FlagsAttribute flags = t.GetCustomAttribute <FlagsAttribute>();
if (flags != null)
{
CrIndentPush(sb);
sb.Append("[FLAGS]: <");
int numFlags = 0;
foreach (Enum value in Enum.GetValues(t))
{
if (((Enum)obj).HasFlag(value))
{
sb.AppendFormat($"{value.ToString()},");
numFlags++;
}
}
if (numFlags > 0)
{
sb.Length--;
}
sb.Append(">");
}
else
{
sb.Append(Enum.GetName(t, obj));
}
return(sb.ToString());
}
public bool PosTest1()
{
bool retVal = true;
// Add your scenario description here
TestLibrary.TestFramework.BeginScenario("PosTest1: Verify Ctor.");
try
{
FlagsAttribute fa = new FlagsAttribute();
if (fa == null)
{
TestLibrary.TestFramework.LogError("001.1", "Ctor Err !");
retVal = false;
return retVal;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
public void ReadMeReflectedInformation()
{
// Shortcut for typeof(T).GetFields(BindingFlags.Public | BindingFlags.Static)
FieldInfo[] fields = EnumUtil.GetEnumFields <YourEnum>();
// On the Enumeration itself
FlagsAttribute attr = EnumUtil.GetAttribute <FlagsAttribute, YourEnum>();
IEnumerable <DescriptionAttribute> attrs = EnumUtil.GetAttributes <DescriptionAttribute, YourEnum>();
bool hasFlagsAttr = EnumUtil.HasAttribute <FlagsAttribute, YourEnum>();
bool hasFlagsShortcut = EnumUtil.HasFlagsAttribute <YourEnum>();
// On a field in the enumeration
DescriptionAttribute attr2 = EnumUtil.GetAttribute <DescriptionAttribute, YourEnum>(YourEnum.Bar);
IEnumerable <DescriptionAttribute> attrs3 = EnumUtil.GetAttributes <DescriptionAttribute, YourEnum>(YourEnum.Bar);
// Various Read Only Dictionaries
// with data about the members of an enumeration
var valueDescription = EnumUtil.GetValueDescription <YourEnum>();
var valueNameDescription = EnumUtil.GetValueNameDescription <YourEnum>();
var valueNameAttributes = EnumUtil.GetValueNameAttributes <YourEnum>();
var nameValueAttribute = EnumUtil.GetNameValueAttribute <YourEnum, DescriptionAttribute>();
var valueNameAttribute = EnumUtil.GetValueNameAttribute <YourEnum, DescriptionAttribute>();
var valueAttribute = EnumUtil.GetValueAttribute <YourEnum, DescriptionAttribute>();
var nameValue = EnumUtil.GetNameValue <YourEnum>();
var valueName = EnumUtil.GetValueName <YourEnum>();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testBoth() throws Exception
public virtual void testBoth()
{
ISet <string> untoks = new HashSet <string>();
untoks.Add(WikipediaTokenizer.CATEGORY);
untoks.Add(WikipediaTokenizer.ITALICS);
string test = "[[Category:a b c d]] [[Category:e f g]] [[link here]] [[link there]] ''italics here'' something ''more italics'' [[Category:h i j]]";
//should output all the indivual tokens plus the untokenized tokens as well. Untokenized tokens
WikipediaTokenizer tf = new WikipediaTokenizer(new StringReader(test), WikipediaTokenizer.BOTH, untoks);
assertTokenStreamContents(tf, new string[] { "a b c d", "a", "b", "c", "d", "e f g", "e", "f", "g", "link", "here", "link", "there", "italics here", "italics", "here", "something", "more italics", "more", "italics", "h i j", "h", "i", "j" }, new int[] { 11, 11, 13, 15, 17, 32, 32, 34, 36, 42, 47, 56, 61, 71, 71, 79, 86, 98, 98, 103, 124, 124, 128, 132 }, new int[] { 18, 12, 14, 16, 18, 37, 33, 35, 37, 46, 51, 60, 66, 83, 78, 83, 95, 110, 102, 110, 133, 125, 129, 133 }, new int[] { 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1 });
// now check the flags, TODO: add way to check flags from BaseTokenStreamTestCase?
tf = new WikipediaTokenizer(new StringReader(test), WikipediaTokenizer.BOTH, untoks);
int[] expectedFlags = new int[] { UNTOKENIZED_TOKEN_FLAG, 0, 0, 0, 0, UNTOKENIZED_TOKEN_FLAG, 0, 0, 0, 0, 0, 0, 0, UNTOKENIZED_TOKEN_FLAG, 0, 0, 0, UNTOKENIZED_TOKEN_FLAG, 0, 0, UNTOKENIZED_TOKEN_FLAG, 0, 0, 0 };
FlagsAttribute flagsAtt = tf.addAttribute(typeof(FlagsAttribute));
tf.reset();
for (int i = 0; i < expectedFlags.Length; i++)
{
assertTrue(tf.incrementToken());
assertEquals("flags " + i, expectedFlags[i], flagsAtt.Flags);
}
assertFalse(tf.incrementToken());
tf.close();
}
protected void GetParamValueControlEnum()
{
_values.AddRange(Enum.GetValues(_type));
FlagsAttribute flags = (FlagsAttribute)
Attribute.GetCustomAttribute(_type,
typeof(FlagsAttribute));
if (flags != null)
{
// A bit field
CheckedListBox cb = new CheckedListBox();
cb.CheckOnClick = true;
cb.Items.AddRange(Enum.GetNames(_type));
_valueControl = cb;
_valueType = VALUE_ENUM_MULTI;
}
else
{
// Not a bit field, use a normal combo box
ComboBox cb = new ComboBox();
cb.DropDownStyle = ComboBoxStyle.DropDownList;
cb.Items.AddRange(Enum.GetNames(_type));
cb.SelectedIndex = 0;
_valueControl = cb;
_valueType = VALUE_ENUM;
}
SetEnumValue();
}
public bool PosTest1()
{
bool retVal = true;
// Add your scenario description here
TestLibrary.TestFramework.BeginScenario("PosTest1: Verify Ctor.");
try
{
FlagsAttribute fa = new FlagsAttribute();
if (fa == null)
{
TestLibrary.TestFramework.LogError("001.1", "Ctor Err !");
retVal = false;
return(retVal);
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return(retVal);
}
private static bool HasFlagsInternal(Type type)
{
Contract.Assert(type != null);
FlagsAttribute attribute = type.GetCustomAttribute <FlagsAttribute>(inherit: false);
return(attribute != null);
}
public static bool IsCompositeValue(Type valType)
{
FlagsAttribute flagsAttribute = valType.GetCustomAttributes(false).OfType <FlagsAttribute>().SingleOrDefault();
if (flagsAttribute != null)
{
return(true);
}
return(false);
}
public void AttributesTest()
{
SerializableAttribute serializable_attr = new SerializableAttribute();
FlagsAttribute flags_attr = new FlagsAttribute();
CustomAttributeCollection attr_coll = new CustomAttributeCollection(serializable_attr, flags_attr);
Attribute [] attributes = attr_coll.GetAttributes();
Assert.AreEqual(true, attributes != null, "#A0");
Assert.AreEqual(2, attributes.Length, "#A1");
// The property is supposed to be giving us the same instance in all the invocations
Assert.AreSame(attributes, attr_coll.GetAttributes(), "#A2");
}
public void Execute_4_Dependencies()
{
_resolverMock.Resolve <string>().Returns("str-dep-1");
_resolverMock.Resolve <long>().Returns(42);
_resolverMock.Resolve <int>().Returns(12);
var dep4 = new FlagsAttribute();
_resolverMock.Resolve <FlagsAttribute>().Returns(dep4);
var queryMock = Substitute.For <IQuery <int, string, long, int, FlagsAttribute> >();
_queryExecutor.Execute(queryMock);
queryMock.Received().Execute("str-dep-1", 42, 12, dep4);
}
public virtual void TestFlagsAttribute()
{
FlagsAttribute att = new FlagsAttribute();
Assert.AreEqual(0, att.Flags);
att.Flags = 1234;
Assert.AreEqual("flags=1234", att.ToString());
FlagsAttribute att2 = (FlagsAttribute) AssertCloneIsEqual(att);
Assert.AreEqual(1234, att2.Flags);
att2 = (FlagsAttribute) AssertCopyIsEqual(att);
Assert.AreEqual(1234, att2.Flags);
att.Clear();
Assert.AreEqual(0, att.Flags);
}
/// <summary>
/// 解析枚举
/// </summary>
/// <param name="_enumType">枚举类别</param>
/// <returns>HashCode</returns>
int OnResolveEnum(Type _enumType)
{
int hashCode = _enumType.GetHashCode();
if (!mEnumPopupValueMaping.ContainsKey(hashCode))
{
Dictionary <int, string> vtn = _enumType.ValueToName();
Dictionary <int, string> vta = _enumType.ValueToAttributeSpecifyValue <AliasTooltipAttribute, string>((a) => { if (a != null)
{
return(a.alias);
}
else
{
return(string.Empty);
} });
List <int> values = new List <int>(vtn.Keys);
List <GUIContent> aliass = new List <GUIContent>();
List <string> masks = new List <string>();
FlagsAttribute flags = _enumType.GetFirstAttribute <FlagsAttribute>();
foreach (int v in values)
{
if (string.IsNullOrEmpty(vta[v]))
{
aliass.Add(new GUIContent(vtn[v]));
}
else
{
aliass.Add(new GUIContent(vta[v]));
}
if (string.IsNullOrEmpty(vta[v]))
{
masks.Add(vtn[v]);
}
else
{
masks.Add(vta[v]);
}
}
mEnumPopupValueMaping.Add(hashCode, values.ToArray());
mEnumPopupAliasMaping.Add(hashCode, aliass.ToArray());
mEnumPopupMaskAliasMaping.Add(hashCode, masks.ToArray());
mEnumIsFlagsMaping.Add(hashCode, flags != null);
}
return(hashCode);
}
/// <summary>
/// Gets a value indicating whether the given <paramref name="type"/> or an expression of this
/// <see cref="Type"/> is suitable for use in <see cref="GetSelectList(Type)"/> and <see
/// cref="SelectExtensions.EnumDropDownListFor{TModel,TEnum}(HtmlHelper{TModel}, Expression{Func{TModel, TEnum}})"/>
/// calls.
/// </summary>
/// <param name="type">The <see cref="Type"/> to check.</param>
/// <returns>
/// <see langword="true"/> if <see cref="GetSelectList(Type)"/> will not throw when passed given
/// <see cref="Type"/> and <see
/// cref="SelectExtensions.EnumDropDownListFor{TModel,TEnum}(HtmlHelper{TModel}, Expression{Func{TModel, TEnum}})"/>
/// will not throw when passed an expression of this <see cref="Type"/>; <see langword="false"/> otherwise.
/// </returns>
/// <remarks>
/// Currently returns <see langref="true"/> if the <paramref name="type"/> parameter is
/// non-<see langref="null"/>, is an <see langref="enum"/> type, and does not have a
/// <see cref="FlagsAttribute"/> attribute.
/// </remarks>
public static bool IsValidForEnumHelper(Type type)
{
bool isValid = false;
if (type != null)
{
// Type.IsEnum is false for Nullable<T> even if T is an enum. Check underlying type (if any).
// Do not support Enum type itself -- IsEnum property is false for that class.
Type checkedType = Nullable.GetUnderlyingType(type) ?? type;
if (checkedType.IsEnum)
{
FlagsAttribute attribute = checkedType.GetCustomAttribute <FlagsAttribute>(inherit: false);
isValid = attribute == null;
}
}
return(isValid);
}
public override string SerializeToJson(object inputObject)
{
var attrList = inputObject.GetType().GetCustomAttributes(false);
var listAttr = attrList.ToList();
FlagsAttribute flagAttr = attrList.Count() != 0 ? (FlagsAttribute)listAttr.Find(item => item.GetType() == typeof(FlagsAttribute)) : null;
bool flag = (flagAttr != null) ? true : false;
if (flag)
{
int value = (int)inputObject;
return(value.ToString());
}
else
{
IDictionary <string, object> enumDictionary = BuildJsonDictionary(inputObject);
object enumValue = enumDictionary.First().Value;
string enumstring = "\"" + enumValue.ToString() + "\"";
return(enumstring);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testFilterTokens() throws Exception
public virtual void testFilterTokens()
{
SnowballFilter filter = new SnowballFilter(new TestTokenStream(this), "English");
CharTermAttribute termAtt = filter.getAttribute(typeof(CharTermAttribute));
OffsetAttribute offsetAtt = filter.getAttribute(typeof(OffsetAttribute));
TypeAttribute typeAtt = filter.getAttribute(typeof(TypeAttribute));
PayloadAttribute payloadAtt = filter.getAttribute(typeof(PayloadAttribute));
PositionIncrementAttribute posIncAtt = filter.getAttribute(typeof(PositionIncrementAttribute));
FlagsAttribute flagsAtt = filter.getAttribute(typeof(FlagsAttribute));
filter.incrementToken();
assertEquals("accent", termAtt.ToString());
assertEquals(2, offsetAtt.startOffset());
assertEquals(7, offsetAtt.endOffset());
assertEquals("wrd", typeAtt.type());
assertEquals(3, posIncAtt.PositionIncrement);
assertEquals(77, flagsAtt.Flags);
assertEquals(new BytesRef(new sbyte[] { 0, 1, 2, 3 }), payloadAtt.Payload);
}
public ReflectionEnumPropertyInfo(PropertyInfo propertyInfo)
: base(propertyInfo)
{
string[] names = Enum.GetNames(propertyInfo.PropertyType);
Array values = Enum.GetValues(propertyInfo.PropertyType);
var predefinedValues = new Dictionary <string, T> (names.Length);
for (int i = 0; i < names.Length; i++)
{
predefinedValues.Add(names[i], (T)values.GetValue(i));
}
PredefinedValues = predefinedValues;
FlagsAttribute flags = PropertyInfo.PropertyType.GetCustomAttribute <FlagsAttribute> ();
if (IsValueCombinable = flags != null)
{
DynamicBuilder.RequestOrOperator <T> ();
DynamicBuilder.RequestHasFlagMethod <T> ();
DynamicBuilder.RequestCaster <IReadOnlyList <T> > ();
}
}
private static void ShowAttributes(MemberInfo attributeTarget)
{
Attribute[] attributes = Attribute.GetCustomAttributes(attributeTarget);
Console.WriteLine("Attributes applied to {0}: {1}",
attributeTarget.Name, (attributes.Length == 0 ? "None" : String.Empty));
foreach (Attribute attribute in attributes)
{
// Display the type of each applied attribute
Console.WriteLine(" {0}", attribute.GetType().ToString());
DebuggerDisplayAttribute dda = attribute as DebuggerDisplayAttribute;
if (dda != null)
{
Console.WriteLine(" Value={0}, Name={1}, Target={2}",
dda.Value, dda.Name, dda.Target);
}
FlagsAttribute flags = attribute as FlagsAttribute;
if (flags != null)
{
Console.WriteLine(flags.ToString());
Console.WriteLine(flags.GetType().Name);
}
}
}
public void Execute_6_Dependencies()
{
_resolverMock.Resolve <string>().Returns("str-dep-1");
_resolverMock.Resolve <long>().Returns(42);
_resolverMock.Resolve <int>().Returns(12);
var dep4 = new FlagsAttribute();
_resolverMock.Resolve <FlagsAttribute>().Returns(dep4);
var dep5 = new SystemException();
_resolverMock.Resolve <SystemException>().Returns(dep5);
var dep6 = new TimeSpan();
_resolverMock.Resolve <TimeSpan>().Returns(dep6);
var queryMock = Substitute.For <IQuery <int, string, long, int, FlagsAttribute, SystemException, TimeSpan> >();
_queryExecutor.Execute(queryMock);
queryMock.Received().Execute("str-dep-1", 42, 12, dep4, dep5, dep6);
}
public static void Ctor()
{
var attribute = new FlagsAttribute();
}
public static object DrawObject(GUIContent title, object obj, Type type, object[] attrs = null)
{
using (var lay = new EditorGUILayout.VerticalScope())
{
if (null == obj)
{//初始化
obj = TypeUtility.CreateInstance(type);
}
float oldLabelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = CalcLabelWidth(title);
obj = DrawObjectCustom(out bool isDraw, title, obj, type, attrs);
if (!isDraw)
{
switch (obj)
{
case float v:
{
RangeAttribute attr = GetTargetAttr <RangeAttribute>();
obj = null == attr?EditorGUILayout.FloatField(title, v) : EditorGUILayout.Slider(title, v, attr.min, attr.max);
}
break;
case double v:
obj = EditorGUILayout.DoubleField(title, v);
break;
case int v:
{
RangeAttribute attr = GetTargetAttr <RangeAttribute>();
obj = null == attr?EditorGUILayout.IntField(title, v) : EditorGUILayout.IntSlider(title, v, (int)attr.min, (int)attr.max);
}
break;
case string v:
obj = EditorGUILayout.TextField(title, v);
break;
case bool v:
obj = EditorGUILayout.Toggle(title, v);
break;
case Vector2 v:
{
v = EditorGUILayout.Vector2Field(title, v);
RangeAttribute attr = GetTargetAttr <RangeAttribute>();
if (attr != null)
{
v.x = Mathf.Clamp(v.x, attr.min, attr.max);
v.y = Mathf.Clamp(v.y, attr.min, attr.max);
if (v.x > v.y)
{
v.x = v.y;
}
using (var lay2 = new EditorGUILayout.HorizontalScope())
{
GUILayout.Space(EditorGUIUtility.labelWidth);
EditorGUILayout.MinMaxSlider(ref v.x, ref v.y, attr.min, attr.max);
}
}
obj = v;
}
break;
case Vector3 v:
obj = EditorGUILayout.Vector3Field(title, v);
break;
case Vector2Int v:
{
v = EditorGUILayout.Vector2IntField(title, v);
RangeAttribute attr = GetTargetAttr <RangeAttribute>();
if (attr != null)
{
Vector2 vf = v;
v.x = Mathf.Clamp(Mathf.RoundToInt(vf.x), (int)attr.min, (int)attr.max);
v.y = Mathf.Clamp(Mathf.RoundToInt(vf.y), (int)attr.min, (int)attr.max);
if (v.x > v.y)
{
v.x = v.y;
}
using (var lay2 = new EditorGUILayout.HorizontalScope())
{
GUILayout.Space(EditorGUIUtility.labelWidth);
EditorGUILayout.MinMaxSlider(ref vf.x, ref vf.y, attr.min, attr.max);
}
v = new Vector2Int((int)vf.x, (int)vf.y);
}
obj = v;
}
break;
case Vector3Int v:
obj = EditorGUILayout.Vector3IntField(title, v);
break;
case Enum v:
{
FlagsAttribute attr = GetTargetAttr <FlagsAttribute>();
obj = null == attr?EditorGUILayout.EnumPopup(title, v) : EditorGUILayout.EnumFlagsField(title, v);
}
break;
case LayerMask v:
{
int mask = InternalEditorUtility.LayerMaskToConcatenatedLayersMask(v);
mask = EditorGUILayout.MaskField(title, mask, InternalEditorUtility.layers);
obj = InternalEditorUtility.ConcatenatedLayersMaskToLayerMask(mask);
}
break;
case IList v:
{
if (type.IsGenericType && type.GenericTypeArguments.Length == 1)
{
Type subType = type.GenericTypeArguments[0];
using (var lay2 = new EditorGUILayout.VerticalScope("FrameBox"))
{
if (subType.IsClass || subType.IsValueType)
{
EditorGUIUtility.labelWidth = CalcLabelWidth(title);
EditorGUILayout.BeginHorizontal();
int cnt = EditorGUILayout.IntField(title, v.Count);
if (GUILayout.Button("+", GUILayout.Width(40)))
{
cnt++;
GUI.FocusControl(null);
}
EditorGUILayout.EndHorizontal();
EditorGUIUtility.labelWidth = oldLabelWidth;
int diff = cnt - v.Count;
while (diff < 0)
{
v.RemoveAt(v.Count - 1);
diff++;
}
while (diff > 0)
{
object subObj = TypeUtility.CreateInstance(subType);
v.Add(subObj);
diff--;
}
EditorGUI.indentLevel += 1;
for (int i = 0; i < cnt; i++)
{
using (var lay3 = new EditorGUILayout.VerticalScope("FrameBox"))
{
v[i] = DrawObject(new GUIContent($"{i}"), v[i], subType, attrs);
using (var lay4 = new EditorGUILayout.HorizontalScope())
{
if (GUILayout.Button("↑") && i > 0)
{
object swap = v[i - 1];
v[i - 1] = v[i];
v[i] = swap;
}
if (GUILayout.Button("↓") && i < cnt - 1)
{
object swap = v[i + 1];
v[i + 1] = v[i];
v[i] = swap;
}
if (GUILayout.Button("x"))
{
v.RemoveAt(i);
i--;
cnt--;
}
}
}
}
EditorGUI.indentLevel -= 1;
}
}
}
else
{
EditorGUILayout.LabelField($"不支持 {type} 类型");
}
obj = v;
}
break;
default:
{
if (!type.IsPrimitive && (type.IsClass || type.IsValueType))
{
FieldInfo[] fields = type.GetFields();
//=============================================================
//查找成员显示控制
Dictionary <string, bool> enableDict = EnableToggleAttribute.GetEnableDict(obj);
//=============================================================
int depth = 0;
if (title != GUIContent.none)
{
EditorGUILayout.LabelField($"{title.text}");
depth = 1;
}
EditorGUI.indentLevel += depth;
foreach (var field in fields)
{
//=============================================================
if (!EnableToggleItemAttribute.EnableChecker(field, enableDict))
{ //不显示
continue;
}
//===========================================================
DrawField(obj, field);
}
EditorGUI.indentLevel -= depth;
}
else
{
EditorGUILayout.LabelField($"不支持 {type} 类型");
}
}
break;
}
}
EditorGUIUtility.labelWidth = oldLabelWidth;
return(obj);
T GetTargetAttr <T>() where T : Attribute
{
T result = null;
if (attrs != null)
{
result = (T)Array.Find(attrs, t => t is T);
}
if (result == null)
{
result = type.GetCustomAttribute <T>();
}
return(result);
}
}
}
public override void CopyTo(AttributeImpl target)
{
FlagsAttribute t = (FlagsAttribute)target;
t.SetFlags(flags);
}
override public System.Object Clone()
{
FlagsAttribute impl = new FlagsAttribute();
impl.flags = this.flags;
return impl;
}
public static bool HasFlagsInternal(Type type)
{
FlagsAttribute attribute = type.GetCustomAttribute <FlagsAttribute>(inherit: false);
return(attribute != null);
}
// [Note by Max 20140906] TODO this should create a new appdomain to import an assembly and then unloading it.
// If you load an assembly of the current solution you are not able to build anymore
// since msbuild is unable to delete the assembly because is currently in use.
private void ImportExternalEnum()
{
OpenFileDialog ofd = new OpenFileDialog()
{
DefaultExt = "dll",
Filter = "Assemblies (*.dll)|*.dll|All Files (*.*)|*.*"
};
if (ofd.ShowDialog() == DialogResult.OK)
{
string file = ofd.FileName;
Assembly assembly = Assembly.LoadFrom(file);
List <Type> enumTypes = new List <Type>();
foreach (Type type in assembly.GetExportedTypes())
{
if (type.IsEnum)
{
enumTypes.Add(type);
}
}
if (enumTypes.Count == 0)
{
MessageBox.Show("The chosen assembly has no public Enums.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
ConfigurationSectionDesignerDiagram diagram = this.SingleDocumentSelection as ConfigurationSectionDesignerDiagram;
using (Transaction transaction = diagram.Store.TransactionManager.BeginTransaction("Import External Enum"))
{
using (ImportEnumForm importEnumForm = new ImportEnumForm(enumTypes))
{
if (importEnumForm.ShowDialog() == DialogResult.OK)
{
ConfigurationSectionModel model = diagram.ModelElement as ConfigurationSectionModel;
Type enumType = importEnumForm.SelectedEnum;
FlagsAttribute fa = enumType.GetCustomAttributes(false)
.Where(a => a is FlagsAttribute)
.SingleOrDefault() as FlagsAttribute;
EnumeratedType enumeratedType = new EnumeratedType(diagram.Store);
enumeratedType.CodeGenOptions = TypeDefinitionCodeGenOptions.None;
enumeratedType.Name = enumType.Name;
enumeratedType.Namespace = enumType.Namespace;
enumeratedType.IsFlags = fa != null;
FieldInfo[] fields = enumType.GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo field in fields)
{
EnumerationLiteral enumeratedLiteral = new EnumerationLiteral(diagram.Store);
enumeratedLiteral.Name = field.Name;
enumeratedType.Literals.Add(enumeratedLiteral);
}
model.TypeDefinitions.Add(enumeratedType);
transaction.Commit();
}
else
{
transaction.Rollback();
}
}
}
}
}
private static object ConvertData(Type targetType, object value)
{
if (value is Array)
{
int length = ((Array)value).Length;
if (length < 1)
{
value = null;
}
else if (length == 1)
{
value = ((Array)value).GetValue(0);
}
}
if (value is String)
{
value = ((String)value).TrimEnd('\0').Trim();
}
if (targetType == null || value == null)
{
return(value);
}
if (targetType == typeof(DateTime) && value is String)
{
DateTime dateTime;
if (DateTime.TryParseExact((string)value, ExifDecoder.ExifDateTimeFormats,
DateTimeFormatInfo.InvariantInfo,
DateTimeStyles.AllowWhiteSpaces, out dateTime))
{
return(dateTime);
}
}
if (targetType.IsEnum)
{
Type underlyingType = Enum.GetUnderlyingType(targetType);
if (value.GetType() != underlyingType)
{
value = Convert.ChangeType(value, underlyingType);
}
if (Enum.IsDefined(targetType, value) || FlagsAttribute.IsDefined(targetType, typeof(FlagsAttribute)))
{
try
{
return(Enum.ToObject(targetType, value));
}
catch { }
}
}
if (targetType == typeof(UnicodeEncoding) && value is byte[])
{
byte[] bytes = (byte[])value;
if (bytes.Length <= 1)
{
return(String.Empty);
}
return(Encoding.Unicode.GetString(bytes, 0, bytes.Length - 1));
}
if (targetType == typeof(Bitmap) && value is byte[])
{
byte[] bytes = (byte[])value;
if (bytes.Length < 1)
{
return(null);
}
using (MemoryStream stream = new MemoryStream(bytes))
{
return(Bitmap.FromStream(stream));
}
}
return(value);
}
private Node CreateLogicalNode(object data, bool writeType, bool useCache)
{
Type type = data.GetType();
Node result = new Node {
Name = type.Name, Type = type.FullName, WriteType = writeType
};
if (WriteCache.ContainsKey(data))
{
if (useCache)
{
return(WriteCache[data]);
}
if (WriteCache[data].RefID == 0)
{
Increment++;
WriteCache[data].RefID = Increment;
}
result.WriteType = false;
result.Reference = WriteCache[data].RefID;
return(result);
}
else
{
WriteCache.Add(data, result);
}
PropertyInfo[] properties = Reflector.GetProperties(type);// type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
if (properties.Length < 1)
{
result.Value = data.ToString();
}
foreach (PropertyInfo info in properties)
{
if (info.IsDefined(typeof(XmlIgnoreAttribute), true))
{
continue;
}
if (!info.CanRead)
{
continue;
}
if (!info.CanWrite)
{
continue;
}
if (info.GetSetMethod() == null)
{
continue;
}
object value = info.GetValue(data, null);
if (value == null)
{
continue;
}
// check vs. default value
object[] attributes = info.GetCustomAttributes(typeof(DefaultValueAttribute), true);
if (attributes.Length > 0)
{
DefaultValueAttribute def = attributes[0] as DefaultValueAttribute;
if (def.Value != null)
{
if (def.Value.Equals(value))
{
continue;
}
}
}
Type valueType = value.GetType();
if (info.PropertyType.IsPrimitive || info.PropertyType == typeof(string) || info.PropertyType.IsEnum)
{
FlagsAttribute flags = Reflector.GetAttribute <FlagsAttribute>(info.PropertyType);
if (flags != null)
{
Node sub = new Node {
Name = info.Name, Value = ((int)value).ToString()
};
result.Nodes.Add(sub);
}
else
{
Node sub = new Node {
Name = info.Name, Value = value.ToString()
};
result.Nodes.Add(sub);
}
}
else if (valueType.IsValueType)
{
TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(valueType);
if (converter != null)
{
try
{
string str = converter.ConvertToString(value);
Node sub = new Node {
Name = info.Name, Value = str
};
result.Nodes.Add(sub);
}
catch (Exception exc)
{
throw exc;
}
}
else
{
Node sub = CreateLogicalNode(value, !info.PropertyType.FullName.Equals(valueType.FullName), false);
sub.Name = info.Name;
result.Nodes.Add(sub);
}
}
else if (value is IList)
{
Node sub = new Node {
Name = info.Name, Type = valueType.FullName
};
result.Nodes.Add(sub);
string name = null;
string fullname = null;
if (valueType.IsGenericType || valueType.BaseType.IsGenericType)
{
Type t = valueType.IsGenericType ? valueType : valueType.BaseType;
Type[] gens = t.GetGenericArguments();
if (gens.Length > 0)
{
name = gens[0].Name;
fullname = gens[0].FullName;
}
}
else
{
fullname = ((IList)value)[0].GetType().FullName;
}
foreach (object item in ((IList)value))
{
if (item != null)
{
Type stype = item.GetType();
Node child = CreateLogicalNode(item, !fullname.Equals(item.GetType().FullName), false);
if (!string.IsNullOrEmpty(name))
{
child.Name = name;
}
sub.Nodes.Add(child);
}
else
{
Node child = new Node {
Name = name
};
sub.Nodes.Add(child);
}
}
}
else if (value is IDictionary)
{
Node sub = new Node {
Name = info.Name, Type = valueType.FullName
};
result.Nodes.Add(sub);
Type itemType = null;
if (valueType.IsGenericType)
{
Type[] gens = valueType.GetGenericArguments();
if (gens.Length > 0)
{
itemType = gens[1];
}
}
else if (valueType.BaseType.IsGenericType)
{
Type[] gens = valueType.BaseType.GetGenericArguments();
if (gens.Length > 0)
{
itemType = gens[1];
}
}
IDictionary dict = (IDictionary)value;
foreach (object key in dict.Keys)
{
Node element = CreateLogicalNode(dict[key], true, false);
//Node element = CreateLogicalNode(dict[key], !dict[key].GetType().FullName.Equals(itemType.FullName), false);
element.Key = key.ToString();
sub.Nodes.Add(element);
}
}
//else if (value is Entity)// && info.GetAttribute<NoRefAttribute>() == null)
//{
// // entity as a property - we want a reference here, not the actual entity
// Node sub = new Node { Name = info.Name, WriteType = false };
// if (WriteCache.ContainsKey(value))
// sub.Reference = WriteCache[value].RefID;
// else
// {
// Node cached = CreateNode(value, false, false);
// if (WriteCache[value].RefID == 0)
// {
// Increment++;
// WriteCache[value].RefID = Increment;
// }
// sub.Reference = cached.RefID;
// }
// result.Nodes.Add(sub);
//}
else
{
Node sub = CreateLogicalNode(value, !info.PropertyType.FullName.Equals(valueType.FullName), false);
sub.Name = info.Name;
result.Nodes.Add(sub);
}
}
if (data is Control)
{
// Entity entity = data as Entity;
// if (!entity.IsPrototype)
// {
// Node sub = new Node { Name = "Components", Type = typeof(Component).FullName };
// result.Nodes.Add(sub);
// foreach (Component c in entity.Components)
// {
// Node child = CreateNode(c, true, false, resources);
// child.Name = "Component";
// sub.Nodes.Add(child);
// }
ElementCollection elements = ((Control)data).GetElements();
if (elements.Count > 0)
{
Node sub = new Node {
Name = "Elements", Type = typeof(Control).FullName
};
result.Nodes.Add(sub);
foreach (Control e in elements)
{
sub.Nodes.Add(CreateLogicalNode(e, false, true));
}
}
// }
// else
// {
// Node sub = new Node { Name = "Components", Type = typeof(Component).FullName };
// result.Nodes.Add(sub);
// Node child = CreateNode(entity.Transform, true, false, resources);
// child.Name = "Component";
// sub.Nodes.Add(child);
// }
}
return(result);
}
