public void CanConvertTo ()
{
EnumConverter converter = new EnumConverter (typeof (E));
Assert.IsTrue (converter.CanConvertTo (typeof (string)), "#A1");
Assert.IsFalse (converter.CanConvertTo (typeof (Enum)), "#A2");
Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#A3");
Assert.IsFalse (converter.CanConvertTo (typeof (int)), "#A4");
Assert.IsTrue (converter.CanConvertTo (typeof (InstanceDescriptor)), "#A5");
Assert.IsFalse (converter.CanConvertTo (typeof (string [])), "#A6");
#if NET_2_0
Assert.IsTrue (converter.CanConvertTo (typeof (Enum [])), "#A7");
#else
Assert.IsFalse (converter.CanConvertTo (typeof (Enum [])), "#A7");
#endif
converter = new EnumConverter (typeof (E2));
Assert.IsTrue (converter.CanConvertTo (typeof (string)), "#B1");
Assert.IsFalse (converter.CanConvertTo (typeof (Enum)), "#B2");
Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#B3");
Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#B4");
Assert.IsTrue (converter.CanConvertTo (typeof (InstanceDescriptor)), "#B5");
Assert.IsFalse (converter.CanConvertTo (typeof (string [])), "#B6");
#if NET_2_0
Assert.IsTrue (converter.CanConvertTo (typeof (Enum [])), "#B7");
#else
Assert.IsFalse (converter.CanConvertTo (typeof (Enum [])), "#B7");
#endif
}
internal static SettingsSerializeAs GetSerializeAs(string serializeAs)
{
var converter = new EnumConverter(typeof(SettingsSerializeAs));
if (!String.IsNullOrEmpty(serializeAs))
return (SettingsSerializeAs)converter.ConvertFromInvariantString(serializeAs);
return default(SettingsSerializeAs);
}
private static TypeConverter GetTypeConverter(Type from, Type converter)
{
TypeConverter typeConverter;
if (converter == typeof(EnumConverter))
typeConverter = new EnumConverter(from);
else
typeConverter = (TypeConverter)Activator.CreateInstance(converter);
return typeConverter;
}
public SettingsMapping (XPathNavigator nav)
{
_sectionTypeName = nav.GetAttribute ("sectionType", String.Empty);
_mapperTypeName = nav.GetAttribute ("mapperType", String.Empty);
EnumConverter cvt = new EnumConverter (typeof (SettingsMappingPlatform));
_platform = (SettingsMappingPlatform) cvt.ConvertFromInvariantString (nav.GetAttribute ("platform", String.Empty));
LoadContents (nav);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var valueType = value.GetType();
var originalValue = (Enum) value;
var converter = new EnumConverter(valueType);
var flag = (Enum) converter.ConvertFrom(parameter);
Debug.Assert(flag != null, "flag != null");
return originalValue.HasFlag(flag);
}
private JsonFxAOT()
{
System.ComponentModel.TypeConverter c;
c = new ArrayConverter();
m_fakeFlag = c.Equals(c);
//c = new BaseNumberConverter();
//m_fakeFlag = c.Equals(c);
c = new BooleanConverter();
m_fakeFlag = c.Equals(c);
c = new ByteConverter();
m_fakeFlag = c.Equals(c);
c = new CollectionConverter();
m_fakeFlag = c.Equals(c);
c = new ComponentConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new CultureInfoConverter();
m_fakeFlag = c.Equals(c);
c = new DateTimeConverter();
m_fakeFlag = c.Equals(c);
c = new DecimalConverter();
m_fakeFlag = c.Equals(c);
c = new DoubleConverter();
m_fakeFlag = c.Equals(c);
c = new EnumConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new ExpandableObjectConverter();
m_fakeFlag = c.Equals(c);
c = new Int16Converter();
m_fakeFlag = c.Equals(c);
c = new Int32Converter();
m_fakeFlag = c.Equals(c);
c = new Int64Converter();
m_fakeFlag = c.Equals(c);
c = new NullableConverter(typeof(object));
m_fakeFlag = c.Equals(c);
c = new SByteConverter();
m_fakeFlag = c.Equals(c);
c = new SingleConverter();
m_fakeFlag = c.Equals(c);
c = new StringConverter();
m_fakeFlag = c.Equals(c);
c = new TimeSpanConverter();
m_fakeFlag = c.Equals(c);
c = new UInt16Converter();
m_fakeFlag = c.Equals(c);
c = new UInt32Converter();
m_fakeFlag = c.Equals(c);
c = new UInt64Converter();
m_fakeFlag = c.Equals(c);
}
public EnumeratedTypeChooser(Type enumType)
{
if (enumType.IsEnumType() == false)
throw new ArgumentException("The parameter enumType must be an Enum type. Nullable Enum types are also accepted. Other types are not allowed.");
ec = new EnumConverter(enumType);
InitializeComponent();
foreach (var val in Enum.GetValues(enumType))
{
cmbValue.Items.Add(val);
}
}
public void ConvertFrom_Null ()
{
EnumConverter converter = new EnumConverter (typeof (E));
try {
converter.ConvertFrom (null, CultureInfo.InvariantCulture, null);
Assert.Fail ("#1");
} catch (NotSupportedException ex) {
// EnumConverter cannot convert from (null)
Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsTrue (ex.Message.IndexOf (typeof (EnumConverter).Name) != -1, "#5");
Assert.IsTrue (ex.Message.IndexOf ("(null)") != -1, "#6");
}
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression left = null;
using (CodeDomSerializerBase.TraceScope("EnumCodeDomSerializer::Serialize"))
{
Enum[] enumArray;
if (!(value is Enum))
{
return left;
}
bool flag = false;
TypeConverter converter = TypeDescriptor.GetConverter(value);
if ((converter != null) && converter.CanConvertTo(typeof(Enum[])))
{
enumArray = (Enum[]) converter.ConvertTo(value, typeof(Enum[]));
flag = enumArray.Length > 1;
}
else
{
enumArray = new Enum[] { (Enum) value };
flag = true;
}
CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(value.GetType());
TypeConverter converter2 = new EnumConverter(value.GetType());
foreach (Enum enum2 in enumArray)
{
string str = (converter2 != null) ? converter2.ConvertToString(enum2) : null;
CodeExpression right = !string.IsNullOrEmpty(str) ? new CodeFieldReferenceExpression(targetObject, str) : null;
if (right != null)
{
if (left == null)
{
left = right;
}
else
{
left = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BitwiseOr, right);
}
}
}
if ((left != null) && flag)
{
left = new CodeCastExpression(value.GetType(), left);
}
}
return left;
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
char[] separator = new char[] { '\n' };
string[] strArray = ((string) value).Split(separator);
Keyframe[] keys = new Keyframe[strArray.Length - 2];
for (int i = 0; i < keys.Length; i++)
{
char[] chArray2 = new char[] { ',' };
string[] keyvals = strArray[i + 2].Split(chArray2);
keys[i] = new Keyframe(ParseKeyVal(keyvals, Val.Time), ParseKeyVal(keyvals, Val.Value), ParseKeyVal(keyvals, Val.InTangent), ParseKeyVal(keyvals, Val.OutTangent));
}
AnimationCurve curve = new AnimationCurve(keys);
EnumConverter converter = new EnumConverter(typeof(WrapMode));
curve.postWrapMode = (WrapMode) converter.ConvertFromString(strArray[0]);
curve.preWrapMode = (WrapMode) converter.ConvertFromString(strArray[1]);
return curve;
}
private static string AnimationCurveToString(object value)
{
if (value == null)
{
return string.Empty;
}
AnimationCurve curve = (AnimationCurve) value;
StringBuilder builder = new StringBuilder();
EnumConverter converter = new EnumConverter(typeof(WrapMode));
builder.AppendFormat("{0}\n{1}", converter.ConvertToString(curve.postWrapMode), converter.ConvertToString(curve.preWrapMode));
foreach (Keyframe keyframe in curve.keys)
{
object[] args = new object[] { InvStr(keyframe.inTangent), InvStr(keyframe.outTangent), InvStr(keyframe.time), InvStr(keyframe.value) };
builder.AppendFormat("\n{0}, {1}, {2}, {3}", args);
}
return builder.ToString();
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
var booleanValue = (bool) value;
var converter = new EnumConverter(targetType);
var flag = (Enum)converter.ConvertFrom(parameter);
if (booleanValue) {
dynamic result = OriginalValue;
result |= flag;
return result;
}
else {
dynamic result = OriginalValue;
dynamic dynFlag = flag;
result &= ~dynFlag;
return result;
}
}
/// <summary>
/// Returns <see cref="TypeConverter"/> for the specified type.
/// </summary>
/// <param name="type">Type to get the converter for.</param>
/// <returns>a type converter for the specified type.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="type"/> is <c>null</c>.</exception>
public static TypeConverter GetConverter(Type type)
{
AssertUtils.ArgumentNotNull(type, "type");
TypeConverter converter;
if (!_converters.TryGetValue(type, out converter))
{
if (type.IsEnum)
{
converter = new EnumConverter(type);
}
else
{
converter = TypeDescriptor.GetConverter(type);
}
}
return converter;
}
static void Main(string[] args)
{
Console.WriteLine("使用 EnumConverter ");
{
EnumConverter converter = new EnumConverter(typeof(ProgrammingLanguage));
// 将字符串转换为枚举.
string langStr = "CS, Cpp, XAML";
Console.WriteLine("将字符串 \"{0}\" 转换为枚举...", langStr);
ProgrammingLanguage lang = (ProgrammingLanguage)converter.ConvertFromString(langStr);
Console.WriteLine("完成!");
// 将枚举转换为字符串.
Console.WriteLine("将枚举结果转换为字符串...");
langStr = converter.ConvertToString(lang);
Console.WriteLine("完成! \"{0}\"", langStr);
}
Console.WriteLine("\n使用 EnumDescriptionConverter ");
{
EnumDescriptionConverter converter = new EnumDescriptionConverter(
typeof(ProgrammingLanguage));
// 将枚举转换为字符串.
string langStr = "Visual C#, Visual C++, XAML";
Console.WriteLine("将字符串 \"{0}\" 转换为枚举...", langStr);
ProgrammingLanguage lang = (ProgrammingLanguage)converter.ConvertFromString(langStr);
Console.WriteLine("完成!");
// 将枚举转换为字符串.
Console.WriteLine("将枚举结果转换为字符串...");
langStr = converter.ConvertToString(lang);
Console.WriteLine("完成! \"{0}\"", langStr);
}
Console.ReadLine();
}
private static DockWindowStruct[] LoadDockWindows(XmlTextReader xmlIn, DockPanel dockPanel)
{
EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
int countOfDockWindows = dockPanel.DockWindows.Count;
DockWindowStruct[] dockWindows = new DockWindowStruct[countOfDockWindows];
MoveToNextElement(xmlIn);
for (int i = 0; i < countOfDockWindows; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "DockWindow" || id != i)
throw new ArgumentException(DockPanelSuite.Properties.Resources.DockPanel_LoadFromXml_InvalidXmlFormat);
dockWindows[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
dockWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
throw new ArgumentException(DockPanelSuite.Properties.Resources.DockPanel_LoadFromXml_InvalidXmlFormat);
int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
dockWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
MoveToNextElement(xmlIn);
for (int j = 0; j < countOfNestedPanes; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Pane" || id2 != j)
throw new ArgumentException(DockPanelSuite.Properties.Resources.DockPanel_LoadFromXml_InvalidXmlFormat);
dockWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
dockWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
dockWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
dockWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
return dockWindows;
}
// Return an instance of a TypeConverter object, given the type id of the object.
// This may be a known element, or one that is stored in a type record
internal TypeConverter GetConverterFromId (
short typeId,
Type propType,
ParserContext pc)
{
TypeConverter tc = null;
if (typeId < 0)
{
// The EnumConverter and NullableConverter need to be created specially, since
// they need the type of the Enum or Nullable in their constructor.
switch((KnownElements)(-typeId))
{
case KnownElements.EnumConverter:
Debug.Assert(propType.IsEnum);
tc = GetConverterFromCache(propType);
if (tc == null)
{
tc = new System.ComponentModel.EnumConverter(propType);
ConverterCache.Add(propType, tc);
}
break;
case KnownElements.NullableConverter:
Debug.Assert(ReflectionHelper.IsNullableType(propType));
tc = GetConverterFromCache(propType);
if (tc == null)
{
tc = new System.ComponentModel.NullableConverter(propType);
ConverterCache.Add(propType, tc);
}
break;
default:
tc = GetConverterFromCache(typeId);
if (tc == null)
{
tc = CreateKnownTypeFromId(typeId) as TypeConverter;
ConverterCache.Add(typeId, tc);
}
break;
}
}
else
{
Type t = GetTypeFromId(typeId);
tc = GetConverterFromCache(t);
if (tc == null)
{
if (ReflectionHelper.IsPublicType(t))
{
tc = Activator.CreateInstance(t) as TypeConverter;
}
else
{
tc = XamlTypeMapper.CreateInternalInstance(pc, t) as TypeConverter;
}
if (tc == null)
{
ThrowException(SRID.ParserNoTypeConv, propType.Name);
}
else
{
ConverterCache.Add(t, tc);
}
}
}
return tc;
}
// Returns the known TypeConverter for a given object type. If there is no known
// converter, return null. This is a static version of the previous
// method for use when there is no parser context available.
internal static TypeConverter GetKnownConverterFromType_NoCache(Type type)
{
KnownElements typeId = GetKnownTypeConverterIdFromType(type);
TypeConverter tc;
// The EnumConverter and NullableConverter need to be created specially, since
// they need the type of the Enum or Nullable in their constructor.
switch (typeId)
{
case KnownElements.EnumConverter:
Debug.Assert(type.IsEnum);
tc = new System.ComponentModel.EnumConverter(type);
break;
case KnownElements.NullableConverter:
Debug.Assert(ReflectionHelper.IsNullableType(type));
tc = new System.ComponentModel.NullableConverter(type);
break;
case KnownElements.UnknownElement:
tc = null;
break;
default:
tc = KnownTypes.CreateKnownElement(typeId) as TypeConverter;
break;
}
return tc;
}
internal void Save(XmlWriter writer)
{
writer.WriteStartElement("thumbnail");
SizeConverter sizeConv = new SizeConverter();
writer.WriteStartElement("size");
writer.WriteAttributeString("value", sizeConv.ConvertToString(size));
writer.WriteEndElement();
EnumConverter ipConv = new EnumConverter(typeof(InterpolationMode));
writer.WriteStartElement("interpolationMode");
writer.WriteAttributeString("value", ipConv.ConvertToString(interpolationMode));
writer.WriteEndElement();
ColorConverter colorConv = new ColorConverter();
writer.WriteStartElement("backColor");
writer.WriteAttributeString("value", colorConv.ConvertToString(backColor));
writer.WriteEndElement();
EnumConverter priorityConv = new EnumConverter(typeof(ThreadPriority));
writer.WriteStartElement("threadPriority");
writer.WriteAttributeString("value", priorityConv.ConvertToString(threadPriority));
writer.WriteEndElement();
writer.WriteEndElement();
}
public static ThumbnailSettings Load(XmlDocument document)
{
Size size;
InterpolationMode interpolationMode;
Color backColor;
ThreadPriority threadPriority;
SizeConverter sizeConv = new SizeConverter();
XmlElement sizeElem = document.SelectSingleNode("settings/thumbnail/size") as XmlElement;
if (sizeElem != null) {
try {
size = (Size)sizeConv.ConvertFromString(sizeElem.GetAttribute("value"));
}
catch {
size = DefaultSize;
}
}
else {
size = DefaultSize;
}
EnumConverter ipConv = new EnumConverter(typeof(InterpolationMode));
XmlElement ipmodeElem = document.SelectSingleNode("settings/thumbnail/interpolationMode") as XmlElement;
if (ipmodeElem != null) {
try {
interpolationMode = (InterpolationMode)ipConv.ConvertFromString(ipmodeElem.GetAttribute("value"));
}
catch {
interpolationMode = DefaultInterpolationMode;
}
}
else {
interpolationMode = DefaultInterpolationMode;
}
ColorConverter colorConv = new ColorConverter();
XmlElement bcolorElem = document.SelectSingleNode("settings/thumbnail/backColor") as XmlElement;
if (bcolorElem != null) {
try {
backColor = (Color)colorConv.ConvertFromString(bcolorElem.GetAttribute("value"));
}
catch {
backColor = DefaultBackColor;
}
}
else {
backColor = DefaultBackColor;
}
EnumConverter priorityConv = new EnumConverter(typeof(ThreadPriority));
XmlElement priorityElem = document.SelectSingleNode("settings/thumbnail/threadPriority") as XmlElement;
if (priorityElem != null) {
try {
threadPriority = (ThreadPriority)priorityConv.ConvertFromString(priorityElem.GetAttribute("value"));
}
catch {
threadPriority = DefaultThumbnailThreadPriority;
}
}
else {
threadPriority = DefaultThumbnailThreadPriority;
}
return new ThumbnailSettings(size, interpolationMode, backColor, threadPriority);
}
internal static TypeConverter GetCoreConverterFromCustomType(Type type)
{
TypeConverter typeConverter = null;
if (type.IsEnum)
{
// Need to handle Enums types specially as they require a ctor that
// takes the underlying type.
typeConverter = new System.ComponentModel.EnumConverter(type);
}
else if (typeof(Int32).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.Int32Converter();
}
else if (typeof(Int16).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.Int16Converter();
}
else if (typeof(Int64).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.Int64Converter();
}
else if (typeof(UInt32).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.UInt32Converter();
}
else if (typeof(UInt16).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.UInt16Converter();
}
else if (typeof(UInt64).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.UInt64Converter();
}
else if (typeof(Boolean).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.BooleanConverter();
}
else if (typeof(Double).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.DoubleConverter();
}
else if (typeof(Single).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.SingleConverter();
}
else if (typeof(Byte).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.ByteConverter();
}
else if (typeof(SByte).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.SByteConverter();
}
else if (typeof(Char).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.CharConverter();
}
else if (typeof(Decimal).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.DecimalConverter();
}
else if (typeof(TimeSpan).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.TimeSpanConverter();
}
else if (typeof(Guid).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.GuidConverter();
}
else if (typeof(String).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.StringConverter();
}
else if (typeof(CultureInfo).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.CultureInfoConverter();
}
#if !SYSTEM_XAML
else if (typeof(Type).IsAssignableFrom(type))
{
typeConverter = new System.Windows.Markup.TypeTypeConverter();
}
#else
else if (type == typeof(Type))
{
typeConverter = new System.Xaml.Replacements.TypeTypeConverter();
}
#endif
else if (typeof(DateTime).IsAssignableFrom(type))
{
typeConverter = new DateTimeConverter2();
}
return typeConverter;
}
public void ConvertFrom_String ()
{
EnumConverter converter = new EnumConverter (typeof (E));
Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Bb"), "#A1");
Assert.AreEqual (E.Cc, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "2"), "#A2");
Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " Bb "), "#A3");
Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " 3 "), "#A4");
Assert.AreEqual ((E) 666, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "666"), "#A5");
Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Bb,Dd"), "#A6");
Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Dd,Bb"), "#A7");
Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Aa,Bb"), "#A8");
try {
converter.ConvertFrom (null, CultureInfo.InvariantCulture, string.Empty);
Assert.Fail ("#B1");
#if NET_2_0
} catch (FormatException ex) {
// is not a valid value for E
Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
Assert.IsNotNull (ex.InnerException, "#B3");
Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#B4");
Assert.IsNotNull (ex.Message, "#B5");
Assert.IsTrue (ex.Message.IndexOf ("E") != -1, "#B6");
// Must specify valid information for parsing in the string
ArgumentException inner = (ArgumentException) ex.InnerException;
Assert.IsNull (inner.InnerException, "#B7");
Assert.IsNotNull (inner.Message, "#B8");
}
#else
} catch (ArgumentException ex) {
/// <summary>
/// Parse WindowState.
/// </summary>
/// <param name="xmlIn"></param>
/// <returns></returns>
private static WindowStateStruct LoadWindowState(XmlTextReader xmlIn)
{
while (!xmlIn.Name.Equals("Form"))
{
if (!MoveToNextElement(xmlIn))
throw new ArgumentException();
}
EnumConverter windowStateConverter = new EnumConverter(typeof(FormWindowState));
WindowStateStruct windowState = new WindowStateStruct();
windowState.WindowState = (FormWindowState)windowStateConverter.ConvertFrom(xmlIn.GetAttribute("WindowState"));
windowState.Left = Convert.ToInt32(xmlIn.GetAttribute("Left"), CultureInfo.InvariantCulture);
windowState.Top = Convert.ToInt32(xmlIn.GetAttribute("Top"), CultureInfo.InvariantCulture);
windowState.Height = Convert.ToInt32(xmlIn.GetAttribute("Height"), CultureInfo.InvariantCulture);
windowState.Width = Convert.ToInt32(xmlIn.GetAttribute("Width"), CultureInfo.InvariantCulture);
windowState.Screen = Convert.ToInt32(xmlIn.GetAttribute("Screen"), CultureInfo.InvariantCulture);
return windowState;
}
private static PaneStruct[] LoadPanes(XmlTextReader xmlIn)
{
EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
int countOfPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
PaneStruct[] panes = new PaneStruct[countOfPanes];
MoveToNextElement(xmlIn);
for (int i = 0; i < countOfPanes; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Pane" || id != i)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
panes[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
panes[i].IndexActiveContent = Convert.ToInt32(xmlIn.GetAttribute("ActiveContent"), CultureInfo.InvariantCulture);
panes[i].ZOrderIndex = -1;
MoveToNextElement(xmlIn);
if (xmlIn.Name != "Contents")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
int countOfPaneContents = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
panes[i].IndexContents = new int[countOfPaneContents];
MoveToNextElement(xmlIn);
for (int j = 0; j < countOfPaneContents; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Content" || id2 != j)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
panes[i].IndexContents[j] = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
return panes;
}
public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent)
{
if (dockPanel.Contents.Count != 0)
throw new InvalidOperationException(ResourceHelper.GetString("DockPanel.LoadFromXml.AlreadyInitialized"));
EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
RectangleConverter rectConverter = new RectangleConverter();
XmlTextReader xmlIn = new XmlTextReader(stream);
xmlIn.WhitespaceHandling = WhitespaceHandling.None;
xmlIn.MoveToContent();
if (xmlIn.Name != "DockPanel")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
string formatVersion = xmlIn.GetAttribute("FormatVersion");
if (formatVersion != ConfigFileVersion)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidFormatVersion"));
DockPanelStruct dockPanelStruct = new DockPanelStruct();
dockPanelStruct.DockLeftPortion = Convert.ToDouble(xmlIn.GetAttribute("DockLeftPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.DockRightPortion = Convert.ToDouble(xmlIn.GetAttribute("DockRightPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.DockTopPortion = Convert.ToDouble(xmlIn.GetAttribute("DockTopPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.DockBottomPortion = Convert.ToDouble(xmlIn.GetAttribute("DockBottomPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.IndexActiveDocumentPane = Convert.ToInt32(xmlIn.GetAttribute("ActiveDocumentPane"));
dockPanelStruct.IndexActivePane = Convert.ToInt32(xmlIn.GetAttribute("ActivePane"));
// Load Contents
MoveToNextElement(xmlIn);
if (xmlIn.Name != "Contents")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
int countOfContents = Convert.ToInt32(xmlIn.GetAttribute("Count"));
ContentStruct[] contents = new ContentStruct[countOfContents];
MoveToNextElement(xmlIn);
for (int i=0; i<countOfContents; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
if (xmlIn.Name != "Content" || id != i)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
contents[i].PersistString = xmlIn.GetAttribute("PersistString");
contents[i].AutoHidePortion = Convert.ToDouble(xmlIn.GetAttribute("AutoHidePortion"), CultureInfo.InvariantCulture);
contents[i].IsHidden = Convert.ToBoolean(xmlIn.GetAttribute("IsHidden"));
contents[i].IsFloat = Convert.ToBoolean(xmlIn.GetAttribute("IsFloat"));
MoveToNextElement(xmlIn);
}
// Load Panes
if (xmlIn.Name != "Panes")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
int countOfPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"));
PaneStruct[] panes = new PaneStruct[countOfPanes];
MoveToNextElement(xmlIn);
for (int i=0; i<countOfPanes; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
if (xmlIn.Name != "Pane" || id != i)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
panes[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
panes[i].IndexActiveContent = Convert.ToInt32(xmlIn.GetAttribute("ActiveContent"));
panes[i].ZOrderIndex = -1;
MoveToNextElement(xmlIn);
if (xmlIn.Name != "Contents")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
int countOfPaneContents = Convert.ToInt32(xmlIn.GetAttribute("Count"));
panes[i].IndexContents = new int[countOfPaneContents];
MoveToNextElement(xmlIn);
for (int j=0; j<countOfPaneContents; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"));
if (xmlIn.Name != "Content" || id2 != j)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
panes[i].IndexContents[j] = Convert.ToInt32(xmlIn.GetAttribute("RefID"));
MoveToNextElement(xmlIn);
}
}
// Load DockWindows
if (xmlIn.Name != "DockWindows")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
int countOfDockWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"));
DockWindowStruct[] dockWindows = new DockWindowStruct[countOfDockWindows];
MoveToNextElement(xmlIn);
for (int i=0; i<countOfDockWindows; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
if (xmlIn.Name != "DockWindow" || id != i)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
dockWindows[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
dockWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"));
MoveToNextElement(xmlIn);
if (xmlIn.Name != "DockList")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
int countOfDockList = Convert.ToInt32(xmlIn.GetAttribute("Count"));
dockWindows[i].DockList = new DockListItem[countOfDockList];
MoveToNextElement(xmlIn);
for (int j=0; j<countOfDockList; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"));
if (xmlIn.Name != "Pane" || id2 != j)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
dockWindows[i].DockList[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"));
dockWindows[i].DockList[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"));
dockWindows[i].DockList[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
dockWindows[i].DockList[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
// Load FloatWindows
if (xmlIn.Name != "FloatWindows")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
int countOfFloatWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"));
FloatWindowStruct[] floatWindows = new FloatWindowStruct[countOfFloatWindows];
MoveToNextElement(xmlIn);
for (int i=0; i<countOfFloatWindows; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"));
if (xmlIn.Name != "FloatWindow" || id != i)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
floatWindows[i].Bounds = (Rectangle)rectConverter.ConvertFromInvariantString(xmlIn.GetAttribute("Bounds"));
floatWindows[i].AllowRedocking = Convert.ToBoolean(xmlIn.GetAttribute("AllowRedocking"));
floatWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"));
MoveToNextElement(xmlIn);
if (xmlIn.Name != "DockList")
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
int countOfDockList = Convert.ToInt32(xmlIn.GetAttribute("Count"));
floatWindows[i].DockList = new DockListItem[countOfDockList];
MoveToNextElement(xmlIn);
for (int j=0; j<countOfDockList; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"));
if (xmlIn.Name != "Pane" || id2 != j)
throw new ArgumentException(ResourceHelper.GetString("DockPanel.LoadFromXml.InvalidXmlFormat"));
floatWindows[i].DockList[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"));
floatWindows[i].DockList[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"));
floatWindows[i].DockList[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
floatWindows[i].DockList[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
xmlIn.Close();
dockPanel.DockLeftPortion = dockPanelStruct.DockLeftPortion;
dockPanel.DockRightPortion = dockPanelStruct.DockRightPortion;
dockPanel.DockTopPortion = dockPanelStruct.DockTopPortion;
dockPanel.DockBottomPortion = dockPanelStruct.DockBottomPortion;
// Create Contents
for (int i=0; i<contents.Length; i++)
{
DockContent content = deserializeContent(contents[i].PersistString);
if (content == null)
content = new DummyContent();
content.DockPanel = dockPanel;
content.AutoHidePortion = contents[i].AutoHidePortion;
content.IsHidden = true;
content.IsFloat = contents[i].IsFloat;
}
// Create panes
for (int i=0; i<panes.Length; i++)
{
DockPane pane = null;
for (int j=0; j<panes[i].IndexContents.Length; j++)
{
DockContent content = dockPanel.Contents[panes[i].IndexContents[j]];
if (j==0)
pane = dockPanel.DockPaneFactory.CreateDockPane(content, panes[i].DockState, false);
else if (panes[i].DockState == DockState.Float)
content.FloatPane = pane;
else
content.PanelPane = pane;
}
}
// Assign Panes to DockWindows
for (int i=0; i<dockWindows.Length; i++)
{
for (int j=0; j<dockWindows[i].DockList.Length; j++)
{
DockWindow dw = dockPanel.DockWindows[dockWindows[i].DockState];
int indexPane = dockWindows[i].DockList[j].IndexPane;
DockPane pane = dockPanel.Panes[indexPane];
int indexPrevPane = dockWindows[i].DockList[j].IndexPrevPane;
DockPane prevPane = (indexPrevPane == -1) ? dw.DockList.GetDefaultPrevPane(pane) : dockPanel.Panes[indexPrevPane];
DockAlignment alignment = dockWindows[i].DockList[j].Alignment;
double proportion = dockWindows[i].DockList[j].Proportion;
pane.AddToDockList(dw, prevPane, alignment, proportion);
if (panes[indexPane].DockState == dw.DockState)
panes[indexPane].ZOrderIndex = dockWindows[i].ZOrderIndex;
}
}
// Create float windows
for (int i=0; i<floatWindows.Length; i++)
{
FloatWindow fw = null;
for (int j=0; j<floatWindows[i].DockList.Length; j++)
{
int indexPane = floatWindows[i].DockList[j].IndexPane;
DockPane pane = dockPanel.Panes[indexPane];
if (j == 0)
fw = dockPanel.FloatWindowFactory.CreateFloatWindow(dockPanel, pane, floatWindows[i].Bounds);
else
{
int indexPrevPane = floatWindows[i].DockList[j].IndexPrevPane;
DockPane prevPane = indexPrevPane == -1 ? null : dockPanel.Panes[indexPrevPane];
DockAlignment alignment = floatWindows[i].DockList[j].Alignment;
double proportion = floatWindows[i].DockList[j].Proportion;
pane.AddToDockList(fw, prevPane, alignment, proportion);
if (panes[indexPane].DockState == fw.DockState)
panes[indexPane].ZOrderIndex = floatWindows[i].ZOrderIndex;
}
}
}
// sort DockContent by its Pane's ZOrder
int[] sortedContents = null;
if (contents.Length > 0)
{
sortedContents = new int[contents.Length];
for (int i=0; i<contents.Length; i++)
sortedContents[i] = i;
int lastDocument = contents.Length;
for (int i=0; i<contents.Length - 1; i++)
{
for (int j=i+1; j<contents.Length; j++)
{
DockPane pane1 = dockPanel.Contents[sortedContents[i]].Pane;
int ZOrderIndex1 = pane1 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane1)].ZOrderIndex;
DockPane pane2 = dockPanel.Contents[sortedContents[j]].Pane;
int ZOrderIndex2 = pane2 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane2)].ZOrderIndex;
if (ZOrderIndex1 > ZOrderIndex2)
{
int temp = sortedContents[i];
sortedContents[i] = sortedContents[j];
sortedContents[j] = temp;
}
}
}
}
// show non-document DockContent first to avoid screen flickers
for (int i=0; i<contents.Length; i++)
{
DockContent content = dockPanel.Contents[sortedContents[i]];
if (content.Pane != null && content.Pane.DockState != DockState.Document)
content.IsHidden = contents[sortedContents[i]].IsHidden;
}
// after all non-document DockContent, show document DockContent
for (int i=0; i<contents.Length; i++)
{
DockContent content = dockPanel.Contents[sortedContents[i]];
if (content.Pane != null && content.Pane.DockState == DockState.Document)
content.IsHidden = contents[sortedContents[i]].IsHidden;
}
for (int i=0; i<panes.Length; i++)
dockPanel.Panes[i].ActiveContent = panes[i].IndexActiveContent == -1 ? null : dockPanel.Contents[panes[i].IndexActiveContent];
if (dockPanelStruct.IndexActiveDocumentPane != -1)
dockPanel.Panes[dockPanelStruct.IndexActiveDocumentPane].Activate();
if (dockPanelStruct.IndexActivePane != -1)
dockPanel.Panes[dockPanelStruct.IndexActivePane].Activate();
for (int i=dockPanel.Contents.Count-1; i>=0; i--)
if (dockPanel.Contents[i] is DummyContent)
dockPanel.Contents[i].Close();
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
int progress = 0;
optrez.Clear();
finalRez.Clear();
alg = new PGA();
OptimizationModel optModel = new OptimizationModel(func);
EnumConverter InitialLoadTypeCollection = new EnumConverter(typeof(InitialLoadType));
EnumConverter EndConditionTypeCollecton = new EnumConverter(typeof(EndCondition));
EnumConverter MutationTypeCollecton = new EnumConverter(typeof(MutationType));
EnumConverter SelectionTypeCollection = new EnumConverter(typeof(SelectionType));
foreach (InitialLoadType il in InitialLoadTypeCollection.GetStandardValues())
{
foreach (EndCondition ec in EndConditionTypeCollecton.GetStandardValues())
{
foreach (MutationType mt in MutationTypeCollecton.GetStandardValues())
{
foreach (SelectionType st in SelectionTypeCollection.GetStandardValues())
{
double[] f1m = new double[(int)numericUpDown8.Value];
double[] f2m = new double[(int)numericUpDown8.Value];
double[] fm = new double[(int)numericUpDown8.Value];
double[] x1m = new double[(int)numericUpDown8.Value];
double[] x2m = new double[(int)numericUpDown8.Value];
for (int i = 0; i < (int)numericUpDown8.Value; i++)
{
AlgorithmSettings settings = new AlgorithmSettings()
{
InitialLoadType = il,
OptModel = optModel,
InitialPointCount = (int)numericUpDown1.Value,
SelectionType = st,
EndCondition = ec,
MaxGenerationCount = (int)numericUpDown2.Value,
SurvivedCount = (int)numericUpDown3.Value,
MutationChance = (double)numericUpDown4.Value,
CrossingGenNumber = (int)numericUpDown5.Value,
Tolerance = (double)numericUpDown6.Value,
MutationChanceAfterCrossing = (double)numericUpDown7.Value,
MutationType = mt
};
alg.Run(settings);
double x1 = alg.Best.X1;
double x2 = alg.Best.X2;
double f1 = alg.Best.F;
double f2 = alg.CallCount;
double f = GetCriterion(f1, f2);
f1m[i] = f1;
f2m[i] = f2;
fm[i] = f;
x1m[i] = x1;
x2m[i] = x2;
optrez.Add(new OptRezult()
{
I = il,
E = ec,
S = st,
M = mt,
F1 = f1,
F2 = f2,
X1 = x1,
X2 = x2,
F = f
});
}
progress++;
backgroundWorker1.ReportProgress(progress * 100 / 24);
finalRez.Add(new OptRezult()
{
I = il,
E = ec,
S = st,
M = mt,
X1 = x1m.Average(),
X2 = x2m.Average(),
F1 = f1m.Average(),
F2 = f2m.Average(),
F = fm.Average()
});
}
}
}
}
}
public static TypeConverter GetConverter(Type type)
{
TypeConverter converter = null;
/*
* Explicitly construct common type converters.
*
* TypeDescriptor.ConvertFrom() uses reflection Invoke() to construct the converter
* and of course this means that some type converters may be optimized away by the linker
* if used by the build.
*
* Another workaround is to specify '--linkskip=system' on the command-line.
*/
if (type.IsEnum)
{
converter = new System.ComponentModel.EnumConverter(type);
}
else if (typeof(System.Boolean) == type)
{
converter = new System.ComponentModel.BooleanConverter();
}
else if (typeof(System.Char) == type)
{
converter = new System.ComponentModel.CharConverter();
}
else if (typeof(System.DateTime) == type)
{
converter = new System.ComponentModel.DateTimeConverter();
}
else if (typeof(System.Double) == type)
{
converter = new System.ComponentModel.DoubleConverter();
}
else if (typeof(System.Int32) == type)
{
converter = new System.ComponentModel.Int32Converter();
}
else if (typeof(System.Single) == type)
{
converter = new System.ComponentModel.SingleConverter();
}
else if (typeof(System.UInt32) == type)
{
converter = new System.ComponentModel.UInt32Converter();
}
else if (typeof(System.Uri) == type)
{
converter = new System.UriTypeConverter();
}
else /* last chance */
{
converter = TypeDescriptor.GetConverter(type);
}
return(converter);
}
private CodeExpression GetPropertyValueExpression(ITypeDescriptorContext ctx, Type typeToConvertTo, Object value, string attributeValue)
{
CodeExpression ce = null;
InstanceDescriptor desc = null;
TypeConverter converter = null;
if (value != null && (typeToConvertTo == typeof(String) || typeToConvertTo.IsPrimitive))
{
ce = new CodePrimitiveExpression(value);
}
else if (typeToConvertTo == typeof(Uri))
{
converter = new UriTypeConverter();
if (!UriParser.IsKnownScheme(URISCHEME_PACK))
{
UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), URISCHEME_PACK, -1);
}
}
else if (typeToConvertTo.IsEnum)
{
converter = new EnumConverter(typeToConvertTo);
}
if (converter != null)
{
if (value == null)
{
if (attributeValue != null)
{
value = converter.ConvertFromString(ctx, TypeConverterHelper.InvariantEnglishUS, attributeValue);
if (value == null)
{
return null;
}
}
else
{
ce = new CodePrimitiveExpression(null);
return ce;
}
}
if (converter.CanConvertTo(ctx, typeof(InstanceDescriptor)))
{
desc = (InstanceDescriptor)converter.ConvertTo(ctx, TypeConverterHelper.InvariantEnglishUS, value, typeof(InstanceDescriptor));
Debug.Assert(desc != null);
// static field ref...
if (desc.MemberInfo is FieldInfo || desc.MemberInfo is PropertyInfo)
{
CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
ce = cfre;
}
else // static method invoke
{
object[] args = new object[desc.Arguments.Count];
desc.Arguments.CopyTo(args, 0);
CodeExpression[] expressions = new CodeExpression[args.Length];
if (desc.MemberInfo is MethodInfo)
{
MethodInfo mi = (MethodInfo)desc.MemberInfo;
ParameterInfo[] parameters = mi.GetParameters();
for (int i = 0; i < args.Length; i++)
{
expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null);
}
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
foreach (CodeExpression e in expressions)
{
cmie.Parameters.Add(e);
}
ce = cmie;
}
else if (desc.MemberInfo is ConstructorInfo) // instance ctor invoke
{
ConstructorInfo ci = (ConstructorInfo)desc.MemberInfo;
ParameterInfo[] parameters = ci.GetParameters();
for (int i = 0; i < args.Length; i++)
{
expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null);
}
CodeObjectCreateExpression coce = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName);
foreach (CodeExpression e in expressions)
{
coce.Parameters.Add(e);
}
ce = coce;
}
}
}
}
return ce;
}
private void DeserializeBoxSettings(AnnotationBox boxSettings, XmlElement boxSettingsNode)
{
string font = boxSettingsNode.GetAttribute("font");
string color = boxSettingsNode.GetAttribute("color");
string italics = boxSettingsNode.GetAttribute("italics");
string bold = boxSettingsNode.GetAttribute("bold");
string numberOfLines = boxSettingsNode.GetAttribute("number-of-lines");
string truncation = boxSettingsNode.GetAttribute("truncation");
string justification = boxSettingsNode.GetAttribute("justification");
string verticalAlignment = boxSettingsNode.GetAttribute("vertical-alignment");
string fitWidth = boxSettingsNode.GetAttribute("fit-width");
string alwaysVisible = boxSettingsNode.GetAttribute("always-visible");
if (!String.IsNullOrEmpty(font))
boxSettings.Font = font;
if (!String.IsNullOrEmpty(color))
boxSettings.Color = color;
if (!String.IsNullOrEmpty(italics))
boxSettings.Italics = (String.Compare("true", italics, true) == 0);
if (!String.IsNullOrEmpty(bold))
boxSettings.Bold = (String.Compare("true", bold, true) == 0);
if (!String.IsNullOrEmpty(numberOfLines))
{
byte result;
if (!byte.TryParse(numberOfLines, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out result))
result = 1;
boxSettings.NumberOfLines = result;
}
if (!String.IsNullOrEmpty(fitWidth))
boxSettings.FitWidth = (String.Compare("true", fitWidth) == 0);
if (!String.IsNullOrEmpty(alwaysVisible))
boxSettings.AlwaysVisible = (String.Compare("true", alwaysVisible, true) == 0);
if (!String.IsNullOrEmpty(truncation))
{
AnnotationBox.TruncationBehaviour fromString = boxSettings.Truncation;
EnumConverter converter = new EnumConverter(typeof(AnnotationBox.TruncationBehaviour));
if (converter.IsValid(truncation))
boxSettings.Truncation = (AnnotationBox.TruncationBehaviour)converter.ConvertFromString(truncation);
}
if (!String.IsNullOrEmpty(justification))
{
AnnotationBox.JustificationBehaviour fromString = boxSettings.Justification;
EnumConverter converter = new EnumConverter(typeof(AnnotationBox.JustificationBehaviour));
if (converter.IsValid(justification))
boxSettings.Justification = (AnnotationBox.JustificationBehaviour)converter.ConvertFromString(justification);
}
if (!String.IsNullOrEmpty(verticalAlignment))
{
AnnotationBox.VerticalAlignmentBehaviour fromString = boxSettings.VerticalAlignment;
EnumConverter converter = new EnumConverter(typeof(AnnotationBox.VerticalAlignmentBehaviour));
if (converter.IsValid(verticalAlignment))
boxSettings.VerticalAlignment = (AnnotationBox.VerticalAlignmentBehaviour)converter.ConvertFromString(verticalAlignment);
}
XmlElement configurationSettings = (XmlElement)boxSettingsNode.SelectSingleNode("configuration-settings");
if (configurationSettings != null)
{
string showLabel = configurationSettings.GetAttribute("show-label");
string showLabelIfEmpty = configurationSettings.GetAttribute("show-label-if-empty");
if (!String.IsNullOrEmpty(showLabel))
boxSettings.ConfigurationOptions.ShowLabel = (String.Compare("true", showLabel, true) == 0);
if (!String.IsNullOrEmpty(showLabelIfEmpty))
boxSettings.ConfigurationOptions.ShowLabelIfValueEmpty = (String.Compare("true", showLabelIfEmpty, true) == 0);
}
}
internal static TypeConverter GetCoreConverterFromCustomType(Type type)
{
TypeConverter typeConverter = null;
if (type.IsEnum)
{
// Need to handle Enums types specially as they require a ctor that
// takes the underlying type.
typeConverter = new System.ComponentModel.EnumConverter(type);
}
else if (typeof(Int32).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.Int32Converter();
}
else if (typeof(Int16).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.Int16Converter();
}
else if (typeof(Int64).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.Int64Converter();
}
else if (typeof(UInt32).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.UInt32Converter();
}
else if (typeof(UInt16).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.UInt16Converter();
}
else if (typeof(UInt64).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.UInt64Converter();
}
else if (typeof(Boolean).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.BooleanConverter();
}
else if (typeof(Double).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.DoubleConverter();
}
else if (typeof(Single).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.SingleConverter();
}
else if (typeof(Byte).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.ByteConverter();
}
else if (typeof(SByte).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.SByteConverter();
}
else if (typeof(Char).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.CharConverter();
}
else if (typeof(Decimal).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.DecimalConverter();
}
else if (typeof(TimeSpan).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.TimeSpanConverter();
}
else if (typeof(Guid).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.GuidConverter();
}
else if (typeof(String).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.StringConverter();
}
else if (typeof(CultureInfo).IsAssignableFrom(type))
{
typeConverter = new System.ComponentModel.CultureInfoConverter();
}
#if !SYSTEM_XAML
else if (typeof(Type).IsAssignableFrom(type))
{
typeConverter = new System.Windows.Markup.TypeTypeConverter();
}
#else
else if (type == typeof(Type))
{
typeConverter = new System.Xaml.Replacements.TypeTypeConverter();
}
#endif
else if (typeof(DateTime).IsAssignableFrom(type))
{
typeConverter = new DateTimeConverter2();
}
else if (typeof(Uri).IsAssignableFrom(type))
{
typeConverter = new System.Xaml.Replacements.TypeUriConverter();
}
return(typeConverter);
}
/// <summary>
/// Returns <see cref="TypeConverter"/> for the specified type.
/// </summary>
/// <param name="type">Type to get the converter for.</param>
/// <returns>a type converter for the specified type.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="type"/> is <c>null</c>.</exception>
public static TypeConverter GetConverter(Type type)
{
AssertUtils.ArgumentNotNull(type, "type");
TypeConverter converter = (TypeConverter) converters[type];
if (converter == null)
{
if (type.IsEnum)
{
converter = new EnumConverter(type);
}
else
{
converter = TypeDescriptor.GetConverter(type);
}
}
return converter;
}
private static FloatWindowStruct[] LoadFloatWindows(XmlTextReader xmlIn)
{
EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
RectangleConverter rectConverter = new RectangleConverter();
int countOfFloatWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
FloatWindowStruct[] floatWindows = new FloatWindowStruct[countOfFloatWindows];
MoveToNextElement(xmlIn);
for (int i = 0; i < countOfFloatWindows; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "FloatWindow" || id != i)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
floatWindows[i].Bounds = (Rectangle)rectConverter.ConvertFromInvariantString(xmlIn.GetAttribute("Bounds"));
floatWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
floatWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
MoveToNextElement(xmlIn);
for (int j = 0; j < countOfNestedPanes; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Pane" || id2 != j)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
floatWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
floatWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
floatWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
floatWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
return floatWindows;
}
public void ConvertFrom_EnumArray ()
{
EnumConverter converter = new EnumConverter (typeof (E));
Assert.AreEqual (E.Aa, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [] { E.Aa }), "#A1");
Assert.AreEqual ((E) 8, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [] { E.Aa, E2.Dd }), "#A2");
Assert.AreEqual ((E) 958, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [] { (E2) 444, (E) 666 }), "#A3");
Assert.AreEqual ((E) 0, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [0]), "#A4");
converter = new EnumConverter (typeof (E2));
Assert.AreEqual ((E2) 0, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [] { E.Aa }), "#B1");
Assert.AreEqual (E2.Dd, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [] { E.Aa, E2.Dd }), "#B2");
Assert.AreEqual ((E2) 958, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [] { (E2) 444, (E) 666 }), "#B3");
Assert.AreEqual ((E2) 0, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [0]), "#B4");
Assert.AreEqual (E2.Bb | E2.Dd, converter.ConvertFrom (null,
CultureInfo.InvariantCulture,
(Enum []) new Enum [] { E2.Bb, E2.Dd }), "#B5");
}
