|
public ConvertFrom ( ITypeDescriptorContext context, |
||
| context | ITypeDescriptorContext | |
| culture | ||
| value | object | |
| return | object | |
/// <inheritdoc />
public override bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args)
{
System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertFrom(value.GetType()))
{
try {
result = converter.ConvertFrom(null, args.Culture, value);
return(true);
}
catch {
}
}
converter = TypeDescriptor.GetConverter(value.GetType());
if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertTo(destinationType))
{
try {
result = converter.ConvertTo(null, args.Culture, value, destinationType);
return(true);
}
catch {
}
}
result = null;
return(false);
}
private static bool InnerConvertObjectToType(object obj, Type type, bool throwOnError,
out object convertedObject)
{
Type originalType = obj.GetType();
OriginalTypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter.CanConvertFrom(originalType))
{
try
{
convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, obj);
return(true);
}
catch
{
if (throwOnError)
{
throw;
}
convertedObject = null;
return(false);
}
}
if (converter.CanConvertFrom(typeof(string)) && !(obj is DateTime))
{
try
{
string text = TypeDescriptor.GetConverter(originalType).ConvertToInvariantString(obj);
convertedObject = converter.ConvertFromInvariantString(text);
return(true);
}
catch
{
if (throwOnError)
{
throw;
}
convertedObject = null;
return(false);
}
}
if (type.IsInstanceOfType(obj))
{
convertedObject = obj;
return(true);
}
if (throwOnError)
{
throw new InvalidOperationException();
}
convertedObject = null;
return(false);
}
/// <summary>
/// 转换简单类型
/// </summary>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns></returns>
private static object ConvertObj(object value, Type type)
{
object returnValue;
if ((value == null) || type.IsInstanceOfType(value))
{
return(value);
}
string str = value as string;
if ((str != null) && (str.Length == 0))
{
return(null);
}
System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
bool flag = converter.CanConvertFrom(value.GetType());
if (!flag)
{
converter = TypeDescriptor.GetConverter(value.GetType());
}
if (!flag && !converter.CanConvertTo(type))
{
throw new InvalidOperationException("无法转换成类型：" + value.ToString() + "==>" + type);
}
try
{
returnValue = flag ? converter.ConvertFrom(null, null, value) : converter.ConvertTo(null, null, value, type);
}
catch (Exception e)
{
throw new InvalidOperationException("类型转换出错：" + value.ToString() + "==>" + type, e);
}
return(returnValue);
}
private object GetValue(DateTime dateTime, Type type, TypeConverter converter)
{
if (type.IsAssignableFrom(typeof(DateTime)))
return dateTime;
else
return converter.ConvertFrom(dateTime);
}
void TypeConverters()
{
System.ComponentModel.TypeConverter testConverter
= System.ComponentModel.TypeDescriptor.GetConverter(typeof(System.Drawing.Color));
System.Drawing.Color result = (System.Drawing.Color)testConverter.ConvertFrom("cyan");
var alt = System.Drawing.Color.FromName("cyan");
Console.WriteLine(result);
Console.WriteLine(alt == result);
}
private static SqlDbType GetDBType(Type theType)
{
SqlParameter p1 = new SqlParameter();
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(p1.DbType);
if (tc.CanConvertFrom(theType))
{
p1.DbType = (DbType)tc.ConvertFrom(theType.Name);
}
else
{
//Try brute force
try
{
p1.DbType = (DbType)tc.ConvertFrom(theType.Name);
}
catch { } //Do Nothing
}
return(p1.SqlDbType);
}
private void SetValueFromConverter(string newValue, Type targetType, TypeConverter converter)
{
if (!converter.CanConvertFrom(targetType) && string.IsNullOrEmpty(newValue))
{
this.Value = null;
}
else
{
this.Value = converter.ConvertFrom(newValue);
}
}
public static T ConvertType <T>(string value)
{
if (typeof(T).IsEnum)
{
return((T)Enum.Parse(typeof(T), value));
}
System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(typeof(T));
if (converter != null && converter.CanConvertFrom(value.GetType()))
{
return((T)converter.ConvertFrom(value));
}
else
{
return((T)Convert.ChangeType(value, typeof(T)));
}
}
//-------------------------------------------------------------------------------------------------
public static object ConvertType(string value, Type type)
{
if (type.IsEnum)
{
return(Enum.Parse(type, value));
}
System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter != null && converter.CanConvertFrom(value.GetType()))
{
return(converter.ConvertFrom(value));
}
else
{
return(Convert.ChangeType(value, type));
}
}
private static object ConvertSimpleType(CultureInfo culture, object value, Type destinationType)
{
if (value == null || destinationType.IsInstanceOfType(value))
{
return(value);
}
// if this is a user-input value but the user didn't type anything, return no value
string valueAsString = value as string;
if (valueAsString != null && valueAsString.Trim().Length == 0)
{
return(null);
}
//modified by Yang Li
//TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
bool canConvertFrom = converter.CanConvertFrom(value.GetType());
if (!canConvertFrom)
{
converter = TypeDescriptor.GetConverter(value.GetType());
}
if (!(canConvertFrom || converter.CanConvertTo(destinationType)))
{
string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_NoConverterExists,
value.GetType().FullName, destinationType.FullName);
throw new InvalidOperationException(message);
}
try
{
object convertedValue = (canConvertFrom) ?
converter.ConvertFrom(null /* context */, culture, value) :
converter.ConvertTo(null /* context */, culture, value, destinationType);
return(convertedValue);
}
catch (Exception ex)
{
string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_ConversionThrew,
value.GetType().FullName, destinationType.FullName);
throw new InvalidOperationException(message, ex);
}
}
/// <summary>
/// Converts the given object to the type of this converter, using the specified context and culture information.
/// </summary>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that provides a format context.</param>
/// <param name="culture">The <see cref="T:System.Globalization.CultureInfo"></see> to use as the current culture.</param>
/// <param name="value">The <see cref="T:System.Object"></see> to convert.</param>
/// <returns>
/// An <see cref="T:System.Object"></see> that represents the converted value.
/// </returns>
/// <exception cref="T:System.NotSupportedException">The conversion can not be performed. </exception>
public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value != null && value.GetType() == typeof(string))
{
if (parseFormats != null)
{
return(DateTime.ParseExact((string)value, parseFormats, GetCulture(culture).DateTimeFormat, dateTimeStyles));
}
else
{
return(DateTime.Parse((string)value, GetCulture(culture).DateTimeFormat, dateTimeStyles));
}
}
else
{
return(baseTypeConverter.ConvertFrom(context, culture, value));
}
}
protected override Resources.PDFImageXObject InitImageXObject(PDFContextBase context, Style style)
{
Document doc = this.Document;
if (null == doc)
{
throw new NullReferenceException(Errors.ParentDocumentCannotBeNull);
}
if (null != this.Data)
{
_xobj = null;
if (!string.IsNullOrEmpty(this.ImageKey))
{
_xobj = this.Document.GetImageResource(this.ImageKey, this, false);
}
if (null == _xobj)
{
string name;
if (string.IsNullOrEmpty(this.ImageKey))
{
name = "DataImage_" + this.Document.GetIncrementID(PDFObjectTypes.ImageXObject);
}
else
{
name = this.ImageKey;
}
System.ComponentModel.TypeConverter BitmapConverter = TypeDescriptor.GetConverter(typeof(Bitmap));
Bitmap img = (Bitmap)BitmapConverter.ConvertFrom(this.Data.Raw);
PDFImageData data = PDFImageData.LoadImageFromBitmap(name, img, this.Compress);
_xobj = PDFImageXObject.Load(data, name);
this.Document.SharedResources.Add(_xobj);
}
}
return(_xobj);
}
public static object ConvertToType(string value, Type type)
{
if (type == null)
{
return(null);
}
System.ComponentModel.TypeConverter conv = System.ComponentModel.TypeDescriptor.GetConverter(type);
if (conv.CanConvertFrom(typeof(string)))
{
try
{
return(conv.ConvertFrom(value));
}
catch
{
return(null);
}
}
return(null);
}
public bool LoadDir(string DirPath, List <string> crFiles, Color Transparency)
{
List <string> filenames = new List <string>();
foreach (var path in this.EditorData.GraphicsPaths)
{
var fullPath = DirPath + Path.DirectorySeparatorChar + path;
if (Directory.Exists(fullPath))
{
filenames.AddRange(Directory.GetFiles(fullPath));
}
}
foreach (var crFile in crFiles)
{
foreach (var filename in filenames)
{
string ext = Path.GetExtension(filename).ToLower();
if (!(ext == ".frm" || ext == ".png"))
{
continue;
}
byte[] bytes = File.ReadAllBytes(filename);
if (ext == ".frm")
{
var frm = FalloutFRMLoader.LoadFRM(bytes, Transparency);
Frms[filename] = frm;
}
else
{
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Bitmap));
Bitmap bitmap = (Bitmap)tc.ConvertFrom(bytes);
Frms[filename] = new FalloutFRM();
Frms[filename].Frames = new List <Bitmap>();
Frms[filename].Frames.Add(bitmap);
Frms[filename].FileName = filename.Remove(filename.IndexOf(DirPath), DirPath.Length);
}
}
}
return(true);
}
object ConvertData (TypeConverter c)
{
if (mime_type == ResXResourceWriter.ByteArraySerializedObjectMimeType) {
if (c.CanConvertFrom (typeof (byte [])))
return c.ConvertFrom (Convert.FromBase64String (dataString));
} else if (String.IsNullOrEmpty (mime_type)) {
if (c.CanConvertFrom (typeof (string)))
return c.ConvertFromInvariantString (dataString);
}
else
throw new Exception ("shouldnt get here, invalid mime type");
throw new TypeLoadException ("No converter for this type found");
}
private static object FormatObjectInternal(object value, System.Type targetType, TypeConverter sourceConverter, TypeConverter targetConverter, string formatString, IFormatProvider formatInfo, object formattedNullValue)
{
if ((value == DBNull.Value) || (value == null))
{
if (formattedNullValue != null)
{
return formattedNullValue;
}
if (targetType == stringType)
{
return string.Empty;
}
if (targetType == checkStateType)
{
return CheckState.Indeterminate;
}
return null;
}
if (((targetType == stringType) && (value is IFormattable)) && !string.IsNullOrEmpty(formatString))
{
return (value as IFormattable).ToString(formatString, formatInfo);
}
System.Type type = value.GetType();
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (((sourceConverter != null) && (sourceConverter != converter)) && sourceConverter.CanConvertTo(targetType))
{
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
TypeConverter converter2 = TypeDescriptor.GetConverter(targetType);
if (((targetConverter != null) && (targetConverter != converter2)) && targetConverter.CanConvertFrom(type))
{
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
if (targetType == checkStateType)
{
if (type == booleanType)
{
return (((bool) value) ? CheckState.Checked : CheckState.Unchecked);
}
if (sourceConverter == null)
{
sourceConverter = converter;
}
if ((sourceConverter != null) && sourceConverter.CanConvertTo(booleanType))
{
return (((bool) sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, booleanType)) ? CheckState.Checked : CheckState.Unchecked);
}
}
if (targetType.IsAssignableFrom(type))
{
return value;
}
if (sourceConverter == null)
{
sourceConverter = converter;
}
if (targetConverter == null)
{
targetConverter = converter2;
}
if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType))
{
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
if ((targetConverter != null) && targetConverter.CanConvertFrom(type))
{
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
if (!(value is IConvertible))
{
throw new FormatException(GetCantConvertMessage(value, targetType));
}
return ChangeType(value, targetType, formatInfo);
}
private static object ParseObjectInternal(object value, System.Type targetType, System.Type sourceType, TypeConverter targetConverter, TypeConverter sourceConverter, IFormatProvider formatInfo, object formattedNullValue)
{
if (EqualsFormattedNullValue(value, formattedNullValue, formatInfo) || (value == DBNull.Value))
{
return DBNull.Value;
}
TypeConverter converter = TypeDescriptor.GetConverter(targetType);
if (((targetConverter != null) && (converter != targetConverter)) && targetConverter.CanConvertFrom(sourceType))
{
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
TypeConverter converter2 = TypeDescriptor.GetConverter(sourceType);
if (((sourceConverter != null) && (converter2 != sourceConverter)) && sourceConverter.CanConvertTo(targetType))
{
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
if (value is string)
{
object obj2 = InvokeStringParseMethod(value, targetType, formatInfo);
if (obj2 != parseMethodNotFound)
{
return obj2;
}
}
else if (value is CheckState)
{
CheckState state = (CheckState) value;
if (state == CheckState.Indeterminate)
{
return DBNull.Value;
}
if (targetType == booleanType)
{
return (state == CheckState.Checked);
}
if (targetConverter == null)
{
targetConverter = converter;
}
if ((targetConverter != null) && targetConverter.CanConvertFrom(booleanType))
{
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), state == CheckState.Checked);
}
}
else if ((value != null) && targetType.IsAssignableFrom(value.GetType()))
{
return value;
}
if (targetConverter == null)
{
targetConverter = converter;
}
if (sourceConverter == null)
{
sourceConverter = converter2;
}
if ((targetConverter != null) && targetConverter.CanConvertFrom(sourceType))
{
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType))
{
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
if (!(value is IConvertible))
{
throw new FormatException(GetCantConvertMessage(value, targetType));
}
return ChangeType(value, targetType, formatInfo);
}
/// <summary>
/// ��ȡ"Value"�ڵ�
/// �������ԣ��������ĵ��е�����ֵ�������͵�ת����ת��Ϊ��ǰ���Ե�ֵ����
/// </summary>
/// <param name="node">���ڵ�</param>
/// <param name="converter">���͵�ת����</param>
/// <param name="value">����</param>
/// <returns>��ֵ�Ƿ��ܹ���ת������Ҫ������</returns>
private bool ReadValue(XmlNode node, TypeConverter converter, ref object value)
{
try
{
foreach (XmlNode child in node.ChildNodes)
{
//XmlNodeTypeö��ָ���ڵ�����͡�.Text:�ڵ���ı����ݡ�Text �ڵ㲻�ܾ����κ��ӽڵ㡣
if (child.NodeType == XmlNodeType.Text)
{
value = converter.ConvertFromInvariantString(node.InnerText);
return true;
}
else if (child.NodeType == XmlNodeType.Element)
{//������Ϣ�ڵ����ô˲��ֶ�ȡ����ӿ���Ϣ20090616
List<string> tempIO = new List<string>();
for (int i = 0; i < node.ChildNodes.Count; i++)
{
tempIO.Add(node.ChildNodes[i].Attributes["name"].Value);
}
value = String.Join(",", tempIO.ToArray());
return true;
}
else if (child.Name.Equals("Binary"))
{
byte[] data = Convert.FromBase64String(child.InnerText);
if (GetConversionSupported(converter, typeof(byte[])))
{
value = converter.ConvertFrom(data);
return true;
}
else
{
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream(data);
value = formatter.Deserialize(stream);
return true;
}
}
else
{
value = null;
return false;
}
}
return true;
}
catch (Exception ex)
{
value = null;
return false;
}
}
protected virtual object GetFormattedValue (object value, int rowIndex, ref DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context)
{
if (DataGridView == null)
return null;
if (rowIndex < 0 || rowIndex >= DataGridView.RowCount)
throw new ArgumentOutOfRangeException ("rowIndex");
// Give the user a chance to custom format
if (!(this is DataGridViewRowHeaderCell)) {
DataGridViewCellFormattingEventArgs e = new DataGridViewCellFormattingEventArgs (ColumnIndex, rowIndex, value, FormattedValueType, cellStyle);
DataGridView.OnCellFormattingInternal (e);
if (e.FormattingApplied)
return e.Value;
cellStyle = e.CellStyle;
value = e.Value;
}
if (value == null || (cellStyle != null && value == cellStyle.DataSourceNullValue)) {
if (FormattedValueType == typeof (string))
return String.Empty;
}
if (FormattedValueType == typeof(string) && value is IFormattable && !String.IsNullOrEmpty (cellStyle.Format))
return ((IFormattable) value).ToString (cellStyle.Format, cellStyle.FormatProvider);
if (value != null && FormattedValueType.IsAssignableFrom (value.GetType()))
return value;
if (formattedValueTypeConverter == null)
formattedValueTypeConverter = FormattedValueTypeConverter;
if (valueTypeConverter == null)
valueTypeConverter = ValueTypeConverter;
if (valueTypeConverter != null && valueTypeConverter.CanConvertTo (FormattedValueType))
return valueTypeConverter.ConvertTo (value, FormattedValueType);
if (formattedValueTypeConverter != null && formattedValueTypeConverter.CanConvertFrom (ValueType))
return formattedValueTypeConverter.ConvertFrom (value);
return Convert.ChangeType (value, FormattedValueType);
}
protected virtual void SetHighlightValue(FrameworkElement ctrl, DependencyProperty dpProp, Highlight h, HighlightConverter converter, TypeConverter finalConverter)
{
if (converter == null) throw new ArgumentNullException("converter");
if (finalConverter == null) throw new ArgumentNullException("finalConverter");
var value = converter.Convert(h, null, null, null);
if (value == Binding.DoNothing)
ctrl.SetValue(dpProp, DependencyProperty.UnsetValue);
else if (value == null)
ctrl.SetValue(dpProp, null);
else if (dpProp.PropertyType.IsAssignableFrom(value.GetType()))
ctrl.SetValue(dpProp, value);
else
ctrl.SetValue(dpProp, finalConverter.ConvertFrom(value));
}
/// <devdoc>
///
/// Converts a value into a format suitable for display to the end user.
///
/// - Converts DBNull or null into a suitable formatted representation of 'null'
/// - Performs some special-case conversions (eg. Boolean to CheckState)
/// - Uses TypeConverters or IConvertible where appropriate
/// - Throws a FormatException is no suitable conversion can be found
///
/// </devdoc>
private static object FormatObjectInternal(object value,
Type targetType,
TypeConverter sourceConverter,
TypeConverter targetConverter,
string formatString,
IFormatProvider formatInfo,
object formattedNullValue) {
if (value == System.DBNull.Value || value == null) {
//
// Convert DBNull to the formatted representation of 'null' (if possible)
//
if (formattedNullValue != null)
{
return formattedNullValue;
}
//
// Convert DBNull or null to a specific 'known' representation of null (otherwise fail)
//
if (targetType == stringType)
{
return String.Empty;
}
if (targetType == checkStateType) {
return CheckState.Indeterminate;
}
// Just pass null through: if this is a value type, it's been unwrapped here, so we return null
// and the caller has to wrap if appropriate.
return null;
}
//
// Special case conversions
//
if (targetType == stringType) {
if (value is IFormattable && !String.IsNullOrEmpty(formatString)) {
return (value as IFormattable).ToString(formatString, formatInfo);
}
}
//The converters for properties should take precedence. Unfortunately, we don't know whether we have one. Check vs. the
//type's TypeConverter. We're punting the case where the property-provided converter is the same as the type's converter.
Type sourceType = value.GetType();
TypeConverter sourceTypeTypeConverter = TypeDescriptor.GetConverter(sourceType);
if (sourceConverter != null && sourceConverter != sourceTypeTypeConverter && sourceConverter.CanConvertTo(targetType)) {
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
TypeConverter targetTypeTypeConverter = TypeDescriptor.GetConverter(targetType);
if (targetConverter != null && targetConverter != targetTypeTypeConverter && targetConverter.CanConvertFrom(sourceType)) {
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
if (targetType == checkStateType) {
if (sourceType == booleanType) {
return ((bool)value) ? CheckState.Checked : CheckState.Unchecked;
}
else {
if (sourceConverter == null) {
sourceConverter = sourceTypeTypeConverter;
}
if (sourceConverter != null && sourceConverter.CanConvertTo(booleanType)) {
return (bool)sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, booleanType)
? CheckState.Checked : CheckState.Unchecked;
}
}
}
if (targetType.IsAssignableFrom(sourceType)) {
return value;
}
//
// If explicit type converters not provided, supply default ones instead
//
if (sourceConverter == null) {
sourceConverter = sourceTypeTypeConverter;
}
if (targetConverter == null) {
targetConverter = targetTypeTypeConverter;
}
//
// Standardized conversions
//
if (sourceConverter != null && sourceConverter.CanConvertTo(targetType)) {
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
else if (targetConverter != null && targetConverter.CanConvertFrom(sourceType)) {
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
else if (value is IConvertible) {
return ChangeType(value, targetType, formatInfo);
}
//
// Fail if no suitable conversion found
//
throw new FormatException(GetCantConvertMessage(value, targetType));
}
private object ConvertType(FieldMap fm, object val)
{
Check.VerifyNotNull(fm, Error.NullParameter, "fm");
// convert DBNull to system null
if (val != null && val.Equals(DBNull.Value))
{
val = null;
}
// perform null handling (NullValue translation)
if (val == null && !fm.IsNullAssignable)
{
Check.Verify(fm.NullValue != null, Error.NullWithNoNullValue, fm.ColumnName, fm.Type);
return(fm.NullValue);
}
else
{
if (val != null)
{
Type type = val.GetType();
// trim strings.. otherwise char columns are as wide as their size
if (fm.Type == typeof(string) || fm.Type == typeof(Guid))
{
if (fm.Type == typeof(Guid))
{
if (fm.Size == 16) // binary compressed version
{
val = Common.TypeConverter.ToGuid((string)val);
}
else
{
val = new Guid(val.ToString());
}
}
else
{
string strval = (string)val;
// size is 0 for variable width columns
// assume we should trim all fixed-width columns
val = fm.Size > 0 ? strval.TrimEnd() : strval;
}
}
else if (fm.Type == typeof(bool) && type != typeof(bool))
{
// if property is boolean but database uses integers we need to convert
// the type before updating it
val = Convert.ToBoolean(val);
}
else if (fm.Type.IsEnum && !type.IsEnum)
{
// check whether enum should be stored as string or numeric value
// TODO we should check if enum requires 64-bit conversion
// val = fm.HandleEnumAsString ? Enum.Parse( fm.Type, Convert.ToString( val ), true ) : Enum.ToObject( fm.Type, Convert.ToInt32( val ) );
val = Common.TypeConverter.Get(fm.Type, val);
}
else if (fm.Type == typeof(decimal) && type != typeof(decimal))
{
val = Convert.ToDecimal(val, NumberFormatInfo.InvariantInfo);
}
else if (fm.Type != type)
{
TypeConverter typeConv = TypeDescriptor.GetConverter(fm.Type);
if (typeConv != null && typeConv.CanConvertFrom(type))
{
val = typeConv.ConvertFrom(val);
}
else
{
// check for the existence of a TypeConverterAttribute for the field/property
object[] attrs = fm.MemberInfo.GetCustomAttributes(typeof(TypeConverterAttribute), false);
if (attrs.Length == 1)
{
TypeConverterAttribute tca = (TypeConverterAttribute)attrs[0];
TypeConverter typeConverter = (TypeConverter)
Activator.CreateInstance(Type.GetType(tca.ConverterTypeName));
if (typeConverter != null && typeConverter.CanConvertFrom(val.GetType()))
{
val = typeConverter.ConvertFrom(val);
}
else
{
val = Convert.ChangeType(val, fm.Type);
}
}
else
{
val = Convert.ChangeType(val, fm.Type);
}
}
}
}
else
{
// allow NullValue conversion for null strings
if (fm.Type == typeof(string) && fm.NullValue != null)
{
val = fm.NullValue;
}
}
return(val);
}
}
protected override object Read (byte token, BinaryReader r, ReaderContext ctx)
{
Type t = (Type) ObjectFormatter.ReadObject (r, ctx);
converter = TypeDescriptor.GetConverter (t);
token = r.ReadByte ();
string v = (string) base.Read (token, r, ctx);
return converter.ConvertFrom (null, Helpers.InvariantCulture, v);
}
public static object ChangeType(object value, Type destinationType, CultureInfo culture)
{
if (value == null || value.IsDbNull())
{
return((!destinationType.IsValueType()) ? null : Activator.CreateInstance(destinationType));
}
Type type = value.GetType();
if (destinationType == type || destinationType.IsAssignableFrom(type))
{
return(value);
}
if (destinationType.IsGenericType())
{
Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(Nullable <>))
{
Type destinationType2 = destinationType.GetGenericArguments()[0];
object obj = ChangeType(value, destinationType2, culture);
return(Activator.CreateInstance(destinationType, obj));
}
}
if (destinationType.IsEnum())
{
string text = value as string;
return((text == null) ? value : Enum.Parse(destinationType, text, true));
}
if (destinationType == typeof(bool))
{
if ("0".Equals(value))
{
return(false);
}
if ("1".Equals(value))
{
return(true);
}
}
System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter != null && converter.CanConvertTo(destinationType))
{
return(converter.ConvertTo(null, culture, value, destinationType));
}
System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
if (converter2 != null && converter2.CanConvertFrom(type))
{
return(converter2.ConvertFrom(null, culture, value));
}
Type[] array = new Type[2]
{
type,
destinationType
};
foreach (Type type2 in array)
{
foreach (MethodInfo publicStaticMethod2 in type2.GetPublicStaticMethods())
{
if (publicStaticMethod2.IsSpecialName && (publicStaticMethod2.Name == "op_Implicit" || publicStaticMethod2.Name == "op_Explicit") && destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
{
ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
{
try
{
return(publicStaticMethod2.Invoke(null, new object[1]
{
value
}));
}
catch (TargetInvocationException ex)
{
throw ex.Unwrap();
}
}
}
}
}
if (type == typeof(string))
{
try
{
MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider));
if (publicStaticMethod != null)
{
return(publicStaticMethod.Invoke(null, new object[2]
{
value,
culture
}));
}
publicStaticMethod = ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string));
if (publicStaticMethod != null)
{
return(publicStaticMethod.Invoke(null, new object[1]
{
value
}));
}
}
catch (TargetInvocationException ex2)
{
throw ex2.Unwrap();
}
}
if (destinationType == typeof(TimeSpan))
{
return(TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture)));
}
return(Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture));
}
private static bool TryConvertTo( object value, Type targetType, CultureInfo culture, TypeConverter converter, out object result )
{
if( converter != null )
{
try
{
result = converter.ConvertTo( null, culture, value, targetType );
return true;
}
catch
{
// We'll try to convert the value another way.
}
if( ( value != null ) && ( converter.CanConvertFrom( value.GetType() ) ) )
{
try
{
var newValue = converter.ConvertFrom( null, culture, value );
result = converter.ConvertTo( null, culture, newValue, targetType );
return true;
}
catch
{
}
}
}
result = null;
return false;
}
/// <summary>
/// Convert the object value using a specified TypeConveter, circumventing the Type's TypeConverter
/// </summary>
/// <param name="value">The original object to convert from</param>
/// <param name="tc">The type converter that will be used</param>
/// <returns></returns>
public static object ConvertValueToTargetType(object value, System.ComponentModel.TypeConverter tc)
{
//System.ComponentModel.TypeConverter tc = TypeDescriptor.GetConverter(t);
return(tc.ConvertFrom(value));
}
/// Generic function to read an object value. Returns true if the read
/// succeeded.
private bool ReadValue(XmlNode node, TypeConverter converter, ArrayList errors, out object value)
{
try
{
foreach (XmlNode child in node.ChildNodes)
{
if (child.NodeType == XmlNodeType.Text)
{
value = converter.ConvertFromInvariantString(node.InnerText);
return true;
}
else if (child.Name.Equals("Binary"))
{
byte[] data = Convert.FromBase64String(child.InnerText);
// Binary blob. Now, check to see if the type converter
// can convert it. If not, use serialization.
//
if (GetConversionSupported(converter, typeof(byte[])))
{
value = converter.ConvertFrom(null, CultureInfo.InvariantCulture, data);
return true;
}
else
{
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream(data);
value = formatter.Deserialize(stream);
return true;
}
}
else if (child.Name.Equals("InstanceDescriptor"))
{
value = ReadInstanceDescriptor(child, errors);
return (value != null);
}
else
{
errors.Add(string.Format("Unexpected element type {0}", child.Name));
value = null;
return false;
}
}
// If we get here, it is because there were no nodes. No nodes and no inner
// text is how we signify null.
//
value = null;
return true;
}
catch (Exception ex)
{
errors.Add(ex.Message);
value = null;
return false;
}
}
/// <summary>
/// Creates a new instance of the ConfigurationProperty class.
/// </summary>
/// <param name="name">The name of the xml entity.</param>
/// <param name="type">The type of the xml entity.</param>
/// <param name="defaultValue">The default value of the xml entity.</param>
/// <param name="converter">The type of the converter to apply.</param>
/// <param name="validation">The validator to use.</param>
/// <param name="flags">One of the APXmlPropertyOptions enumeration values.</param>
/// <param name="description">The description of the xml entity.</param>
public APXmlProperty(string name, Type type, object defaultValue,
TypeConverter converter, APValidatorBase validation, APXmlPropertyOptions flags, string description)
{
_name = name;
_converter = converter != null ? converter : TypeDescriptor.GetConverter(type);
if (defaultValue != null)
{
if (defaultValue == NoDefaultValue)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Object:
defaultValue = null;
break;
case TypeCode.String:
defaultValue = String.Empty;
break;
default:
defaultValue = Activator.CreateInstance(type);
break;
}
}
else
{
if (!type.IsAssignableFrom(defaultValue.GetType()))
{
if (!_converter.CanConvertFrom(defaultValue.GetType()))
throw new APXmlException(APResource.GetString(APResource.APXml_DefaultValueTypeError, name, type, defaultValue.GetType()));
defaultValue = _converter.ConvertFrom(defaultValue);
}
}
}
_defaultValue = defaultValue;
_flags = flags;
_type = type;
_validation = validation != null ? validation : new DefaultAPValidator();
_description = description;
}
/// <devdoc>
///
/// Converts a value entered by the end user (through UI) into the corresponding binary value.
///
/// - Converts formatted representations of 'null' into DBNull
/// - Performs some special-case conversions (eg. CheckState to Boolean)
/// - Uses TypeConverters or IConvertible where appropriate
/// - Throws a FormatException is no suitable conversion can be found
///
/// </devdoc>
private static object ParseObjectInternal(object value,
Type targetType,
Type sourceType,
TypeConverter targetConverter,
TypeConverter sourceConverter,
IFormatProvider formatInfo,
object formattedNullValue) {
//
// Convert the formatted representation of 'null' to DBNull (if possible)
//
if (EqualsFormattedNullValue(value, formattedNullValue, formatInfo) || value == System.DBNull.Value) {
return System.DBNull.Value;
}
//
// Special case conversions
//
TypeConverter targetTypeTypeConverter = TypeDescriptor.GetConverter(targetType);
if (targetConverter != null && targetTypeTypeConverter != targetConverter && targetConverter.CanConvertFrom(sourceType)) {
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
TypeConverter sourceTypeTypeConverter = TypeDescriptor.GetConverter(sourceType);
if (sourceConverter != null && sourceTypeTypeConverter != sourceConverter && sourceConverter.CanConvertTo(targetType)) {
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
if (value is string) {
// If target type has a suitable Parse method, use that to parse strings
object parseResult = InvokeStringParseMethod(value, targetType, formatInfo);
if (parseResult != parseMethodNotFound) {
return parseResult;
}
}
else if (value is CheckState) {
CheckState state = (CheckState)value;
if (state == CheckState.Indeterminate) {
return DBNull.Value;
}
// Explicit conversion from CheckState to Boolean
if (targetType == booleanType) {
return (state == CheckState.Checked);
}
if (targetConverter == null) {
targetConverter = targetTypeTypeConverter;
}
if (targetConverter != null && targetConverter.CanConvertFrom(booleanType)) {
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), state == CheckState.Checked);
}
}
else if (value != null && targetType.IsAssignableFrom(value.GetType())) {
// If value is already of a compatible type, just go ahead and use it
return value;
}
//
// If explicit type converters not provided, supply default ones instead
//
if (targetConverter == null) {
targetConverter = targetTypeTypeConverter;
}
if (sourceConverter == null) {
sourceConverter = sourceTypeTypeConverter;
}
//
// Standardized conversions
//
if (targetConverter != null && targetConverter.CanConvertFrom(sourceType)) {
return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value);
}
else if (sourceConverter != null && sourceConverter.CanConvertTo(targetType)) {
return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType);
}
else if (value is IConvertible) {
return ChangeType(value, targetType, formatInfo);
}
//
// Fail if no suitable conversion found
//
throw new FormatException(GetCantConvertMessage(value, targetType));
}
public static bool Convert(object val, Type targetType, out object result)
{
result = val;
// Trivial cases
if (val == null)
{
// Cannot convert null to value type
return(!targetType.IsValueType);
}
if (targetType.IsAssignableFrom(val.GetType()))
{
return(true);
}
// Custom type conversions
if (_customTypeConverter != null)
{
if (_customTypeConverter(val, targetType, out result))
{
return(true);
}
}
// TODO: typeof(Nullable<T>)
// Built-in type conversions
if (val.GetType() == typeof(string) && targetType == typeof(Type))
{ // string -> Type
result = Type.GetType(val.ToString());
return(result != null);
}
// Enumerations
if (val.GetType() == typeof(string) && targetType.IsEnum)
{ // string -> Enum
result = Enum.Parse(targetType, (string)val);
return(true);
}
// String target type must be done before enumerations are tried - else, the string will be treated as enumeration
if (targetType.IsAssignableFrom(typeof(string)))
{ // * -> string
result = val.ToString();
return(true);
}
// Collection types
Type enumerableType;
Type entryType;
ReflectionHelper.FindImplementedEnumerableType(targetType, out enumerableType, out entryType);
if (enumerableType != null) // Targets IList, ICollection, IList<>, ICollection<>
{
ICollection col;
if (!ToCollection(val, entryType, out col))
{
return(false);
}
List <object> resultList = col.Cast <object>().ToList();
result = resultList;
return(true);
}
ICollection sourceCol = val as ICollection;
if (sourceCol != null && sourceCol.Count == 1) // From collection to non-collection target
{
// Use the first (single) item of a collection or dictionary
IEnumerator enumerator = sourceCol.GetEnumerator();
enumerator.MoveNext();
object item = enumerator.Current;
if (Convert(item, targetType, out result)) // Single collection item
{
return(true);
}
KeyValuePair <object, object>?kvp = item as KeyValuePair <object, object>?;
if (kvp.HasValue && Convert(kvp.Value.Value, targetType, out result)) // Value of single dictionary entry - generic dictionary
{
IDisposable d = kvp.Value.Key as IDisposable;
if (d != null)
{
d.Dispose();
}
return(true);
}
DictionaryEntry?entry = item as DictionaryEntry?;
if (entry.HasValue && Convert(entry.Value.Value, targetType, out result)) // Value of single dictionary entry - legacy dictionary
{
IDisposable d = entry.Value.Key as IDisposable;
if (d != null)
{
d.Dispose();
}
return(true);
}
}
// Simple type conversions
System.ComponentModel.TypeConverter tc = TypeDescriptor.GetConverter(targetType);
if (tc != null && tc.CanConvertFrom(val.GetType()))
{
try
{
result = tc.ConvertFrom(null, CultureInfo.InvariantCulture, val);
return(true);
}
catch { }
}
tc = TypeDescriptor.GetConverter(val);
if (tc != null && tc.CanConvertTo(targetType))
{
result = tc.ConvertTo(val, targetType);
return(true);
}
return(false);
}
public override object ConvertFrom(cm.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
return(etoConverter.ConvertFrom(null, culture, value));
}
public bool LoadZip(string ZipPath, List <string> crFiles, Color Transparency)
{
if (!File.Exists(ZipPath))
{
MessageBox.Show("Unable to load " + ZipPath + ", doesn't exist.", "Mapper", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
var zip = ZipStorer.Open(ZipPath, FileAccess.Read);
if (zip == null)
{
MessageBox.Show("Unable to load " + ZipPath + ".", "Mapper", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
var patternToCheck = new List <string>();
foreach (var cr in crFiles)
{
patternToCheck.Add(cr);
}
foreach (var path in this.EditorData.GraphicsPaths)
{
patternToCheck.Add(path);
}
var filesToLoad = new List <ZipStorer.ZipFileEntry>();
var entries = zip.ReadCentralDir();
foreach (var entry in entries)
{
foreach (var path in patternToCheck)
{
if (!entry.FilenameInZip.Replace('/', '\\').Contains(path))
{
continue;
}
if (entry.CompressedSize == 0)
{
continue;
}
string filename = entry.FilenameInZip.ToLower().Replace('/', '\\');
string ext = Path.GetExtension(filename).ToLower();
if (!(ext == ".frm" || ext == ".png"))
{
continue;
}
filesToLoad.Add(entry);
}
}
this.BeginInvoke((MethodInvoker) delegate
{
frmLoading.SetNextFile(Path.GetFileName(ZipPath));
frmLoading.SetResourceNum(filesToLoad.Count);
});
foreach (var entry in filesToLoad)
{
string filename = entry.FilenameInZip.ToLower().Replace('/', '\\');
string ext = Path.GetExtension(filename).ToLower();
this.BeginInvoke((MethodInvoker) delegate
{
frmLoading.SetNextResource(filename);
});
byte[] bytes;
using (MemoryStream stream = new MemoryStream())
{
zip.ExtractFile(entry, stream);
bytes = stream.ToArray();
}
if (ext == ".frm")
{
var frm = FalloutFRMLoader.LoadFRM(bytes, Transparency);
Frms[filename] = frm;
}
else
{
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Bitmap));
Bitmap bitmap = (Bitmap)tc.ConvertFrom(bytes);
Frms[filename] = new FalloutFRM();
Frms[filename].Frames = new List <Bitmap>();
Frms[filename].Frames.Add(bitmap);
Frms[filename].FileName = entry.FilenameInZip;
}
}
return(true);
}
public void CheckConversion(object check, object expect, TypeConverter conv, Type type, bool test_from, bool test_to, CultureInfo culture) {
object obj;
object result;
obj = check;
if (debug > 0) {
Console.WriteLine("{0}: CheckConversion, checking {1}({2}) <-> {3}({4})", conv.ToString(), check.GetType().ToString(), check.ToString(), type.ToString(), expect != null ? expect.ToString() : "null");
}
if (test_to) {
obj = conv.ConvertTo(null, culture, check, type);
if (obj == null) {
if (expect != null) {
failed++;
Console.WriteLine("{0}: ConvertTo failed, type {1}, expected {2}, got null", conv.ToString(), type.ToString(), expect.ToString());
}
return;
}
// Intermediate verification
if (expect != null && !obj.Equals(expect)) {
failed++;
if (verbose > 0) {
Console.WriteLine("{0}: ConvertTo failed, type {1}, expected {2}, got {3}", conv.ToString(), type.ToString(), expect.ToString(), obj.ToString());
}
}
if (debug > 1) {
Console.WriteLine("{0}: CheckConversion, ConvertTo result: '{1}')", conv.ToString(), obj);
}
}
if (test_from) {
result = conv.ConvertFrom(null, culture, obj);
if (test_to) {
// Roundtrip check
if (!check.Equals(result)) {
failed++;
if (verbose > 0) {
Console.WriteLine("{0}: ConvertTo/ConvertFrom roundtrip failed, type {1}", conv.ToString(), type.ToString());
}
}
} else {
if (!expect.Equals(result)) {
failed++;
if (verbose > 0) {
Console.WriteLine("{0}: ConvertFrom failed, type {1}", conv.ToString(), type.ToString());
}
}
}
if (debug > 1) {
Console.WriteLine("{0}: CheckConversion, ConvertFrom result: '{1}')", conv.ToString(), result);
}
}
}
private static bool ConvertObjectToTypeInternal(object o, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject)
{
IDictionary<string, object> dictionary = o as IDictionary<string, object>;
if (dictionary != null)
{
return ConvertDictionaryToObject(dictionary, type, serializer, throwOnError, out convertedObject);
}
IList list = o as IList;
if (list != null)
{
IList list2;
if (ConvertListToObject(list, type, serializer, throwOnError, out list2))
{
convertedObject = list2;
return true;
}
convertedObject = null;
return false;
}
if ((type == null) || (o.GetType() == type))
{
convertedObject = o;
return true;
}
//TypeDescriptor.GetConverter(type) !!!
TypeConverter converter = new TypeConverter();
if (converter.CanConvertFrom(o.GetType()))
{
try
{
convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, o);
return true;
}
catch
{
if (throwOnError)
{
throw;
}
convertedObject = null;
return false;
}
}
if (converter.CanConvertFrom(typeof(string)))
{
try
{
string str;
if (o is DateTime)
{
DateTime time = (DateTime)o;
str = time.ToUniversalTime().ToString("u", CultureInfo.InvariantCulture);
}
else
{
//ConvertToInvariantString(o); !!!
str = converter.ConvertToString(o);
}
//ConvertFromInvariantString(str); !!!
convertedObject = converter.ConvertToString(str);
return true;
}
catch
{
if (throwOnError)
{
throw;
}
convertedObject = null;
return false;
}
}
if (type.IsAssignableFrom(o.GetType()))
{
convertedObject = o;
return true;
}
if (throwOnError)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CannotConvertObjectToType, new object[] { o.GetType(), type }));
}
convertedObject = null;
return false;
}
public virtual object ParseFormattedValue (object formattedValue, DataGridViewCellStyle cellStyle, TypeConverter formattedValueTypeConverter, TypeConverter valueTypeConverter)
{
if (cellStyle == null)
throw new ArgumentNullException ("cellStyle is null.");
if (FormattedValueType == null)
throw new FormatException ("The System.Windows.Forms.DataGridViewCell.FormattedValueType property value is null.");
if (formattedValue == null)
throw new ArgumentException ("formattedValue is null.");
if (ValueType == null)
throw new FormatException ("valuetype is null");
if (!FormattedValueType.IsAssignableFrom (formattedValue.GetType ()))
throw new ArgumentException ("formattedValue is not of formattedValueType.");
if (formattedValueTypeConverter == null)
formattedValueTypeConverter = FormattedValueTypeConverter;
if (valueTypeConverter == null)
valueTypeConverter = ValueTypeConverter;
if (valueTypeConverter != null && valueTypeConverter.CanConvertFrom (FormattedValueType))
return valueTypeConverter.ConvertFrom (formattedValue);
if (formattedValueTypeConverter != null && formattedValueTypeConverter.CanConvertTo (ValueType))
return formattedValueTypeConverter.ConvertTo (formattedValue, ValueType);
return Convert.ChangeType (formattedValue, ValueType);
}
/// <summary>
/// ��ȡ"Value"�ڵ�
/// �������ԣ��������ĵ��е�����ֵ�������͵�ת����ת��Ϊ��ǰ���Ե�ֵ����
/// </summary>
/// <param name="node">���ڵ�</param>
/// <param name="converter">���͵�ת����</param>
/// <param name="errors">�����ڼ������Ĵ�������еĻ����ļ���</param>
/// <param name="value">����</param>
/// <returns>��ֵ�Ƿ��ܹ���ת������Ҫ������</returns>
private bool ReadValue(XmlNode node, TypeConverter converter, ArrayList errors, ref object value)
{
try
{
foreach (XmlNode child in node.ChildNodes)
{
//XmlNodeTypeö��ָ���ڵ�����͡�.Text:�ڵ���ı����ݡ�Text �ڵ㲻�ܾ����κ��ӽڵ㡣
if (child.NodeType == XmlNodeType.Text)
{
value = converter.ConvertFromInvariantString(node.InnerText);
return true;
}
else if (child.Name.Equals("Binary"))
{
byte[] data = Convert.FromBase64String(child.InnerText);
if (GetConversionSupported(converter, typeof(byte[])))
{
value = converter.ConvertFrom(data);
return true;
}
else
{
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream(data);
value = formatter.Deserialize(stream);
return true;
}
}
else
{
errors.Add(string.Format("��������{0}", child.Name));
value = null;
return false;
}
}
return true;
}
catch (Exception ex)
{
errors.Add(ex.Message);
value = null;
return false;
}
}
public static object ChangeType(Type t, object value)
{
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(t);
return(tc.ConvertFrom(value));
}
public bool LoadDat(string DatPath, List <string> crFiles, Color Transparency)
{
DatReaderError status;
DAT loadedDat = DATReader.ReadDat(DatPath, out status);
if (status.Error != DatError.Success)
{
MessageBox.Show("Error loading " + DatPath + ": " + Environment.NewLine + status.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
List <DATFile> files = new List <DATFile>();
foreach (string path in this.EditorData.GraphicsPaths)
{
files.AddRange(loadedDat.GetFilesByPattern(path));
// Critters to load
foreach (var crType in critterData.crTypeGraphic.Values)
{
var file = loadedDat.GetFileByName("art\\critters\\" + crType.ToUpper() + "AA.FRM"); // Idle anim
if (file == null)
{
file = loadedDat.GetFileByName("art\\critters\\" + crType.ToLower() + "aa.frm");
}
if (file == null)
{
continue;
}
files.Add(file);
}
}
this.BeginInvoke((MethodInvoker) delegate {
frmLoading.SetNextFile(Path.GetFileName(DatPath));
frmLoading.SetResourceNum(files.Count);
});
foreach (DATFile file in files)
{
this.BeginInvoke((MethodInvoker) delegate { frmLoading.SetNextResource(file.FileName); });
string ext = Path.GetExtension(file.FileName).ToLower();
if (!(ext == ".frm" || ext == ".png"))
{
continue;
}
byte[] data = file.GetData();
if (data == null)
{
WriteLog("Error opening " + file.FileName + ": " + file.ErrorMsg);
continue;
}
if (ext == ".frm")
{
var frm = FalloutFRMLoader.LoadFRM(data, Transparency);
frm.FileName = file.Path.ToLower();
Frms[frm.FileName] = frm;
}
else
{
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Bitmap));
Bitmap bitmap = (Bitmap)tc.ConvertFrom(data);
}
}
loadedDat.Close();
return(true);
}
private bool ReadValue(XmlNode node, TypeConverter converter, ArrayList errors, out object value)
{
try
{
foreach (XmlNode child in node.ChildNodes)
{
if (child.NodeType == XmlNodeType.Text)
{
value = converter.ConvertFromInvariantString(node.InnerText);
return true;
}
if (child.Name.Equals("Binary"))
{
byte[] data = Convert.FromBase64String(child.InnerText);
if (this.GetConversionSupported(converter, typeof(byte[])))
{
value = converter.ConvertFrom(null, CultureInfo.InvariantCulture, data);
return true;
}
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream(data);
value = formatter.Deserialize(stream);
return true;
}
if (child.Name.Equals("InstanceDescriptor"))
{
value = this.ReadInstanceDescriptor(child, errors);
return (value != null);
}
errors.Add(string.Format("Unexpected element type {0}", child.Name));
value = null;
return false;
}
value = null;
return true;
}
catch (Exception ex)
{
errors.Add(ex.Message);
value = null;
return false;
}
}
/// <summary>
/// Converts the given object to the type of this converter, using the specified
/// context and culture information.
/// </summary>
/// <param name="context">An System.ComponentModel.ITypeDescriptorContext that provides a format context.</param>
/// <param name="culture">The System.Globalization.CultureInfo to use as the current culture.</param>
/// <param name="value">The System.Object to convert.</param>
/// <returns>An System.Object that represents the converted value.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(double));
return(converter.ConvertFrom(context, culture, value));
}
