public static SqlDbType ConvertToSqlDbType(this Type obj_type)
{
SqlParameter parm = new SqlParameter();
System.ComponentModel.TypeConverter tcon = System.ComponentModel.TypeDescriptor.GetConverter(parm.DbType);
if (tcon.CanConvertFrom(obj_type))
{
parm.DbType = ((DbType)tcon.ConvertFrom(obj_type.Name));
return(parm.SqlDbType);
}
switch (obj_type.Name)
{
case "Char":
return(SqlDbType.Char);
case "SByte":
case "UInt16":
return(SqlDbType.SmallInt);
case "UInt32":
return(SqlDbType.Int);
case "UInt64":
return(SqlDbType.Decimal);
case "Byte[]":
return(SqlDbType.Binary);
}
return(SqlDbType.VarChar); //all else fails return varchar
}
/// <summary>
/// Turns a string into a typed value. Useful for auto-conversion routines
/// like form variable or XML parsers.
/// <seealso>Class wwUtils</seealso>
/// </summary>
/// <param name="SourceString">
/// The string to convert from
/// </param>
/// <param name="TargetType">
/// The type to convert to
/// </param>
/// <param name="Culture">
/// Culture used for numeric and datetime values.
/// </param>
/// <returns>object. Throws exception if it cannot be converted.</returns>
public static object StringToTypedValue(string SourceString, Type TargetType, CultureInfo Culture)
{
object Result = null;
if (TargetType == typeof(string))
{
Result = SourceString;
}
else if (TargetType == typeof(int))
{
Result = int.Parse(SourceString, NumberStyles.Integer, Culture.NumberFormat);
}
else if (TargetType == typeof(byte))
{
Result = Convert.ToByte(SourceString);
}
else if (TargetType == typeof(decimal))
{
Result = Decimal.Parse(SourceString, NumberStyles.Any, Culture.NumberFormat);
}
else if (TargetType == typeof(double))
{
Result = Double.Parse(SourceString, NumberStyles.Any, Culture.NumberFormat);
}
else if (TargetType == typeof(bool))
{
if (SourceString.ToLower() == "true" || SourceString.ToLower() == "on" || SourceString == "1")
{
Result = true;
}
else
{
Result = false;
}
}
else if (TargetType == typeof(DateTime))
{
Result = Convert.ToDateTime(SourceString, Culture.DateTimeFormat);
}
else if (TargetType.IsEnum)
{
Result = Enum.Parse(TargetType, SourceString, true);
}
else
{
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(TargetType);
if (converter != null && converter.CanConvertFrom(typeof(string)))
{
Result = converter.ConvertFromString(null, Culture, SourceString);
}
else
{
System.Diagnostics.Debug.Assert(false, "Type Conversion not handled in StringToTypedValue for " +
TargetType.Name + " " + SourceString);
throw (new Exception("Type Conversion not handled in StringToTypedValue"));
}
}
return(Result);
}
public void setValue(iModel model, object val)
{
// parse Enum values ...
if (Type.IsEnum)
{
if (DbType == System.Data.DbType.String)
{
_fieldInfo.SetValue(model, Enum.Parse(Type, val.ToString()));
}
else
{
_fieldInfo.SetValue(model, Enum.ToObject(Type, val));
}
}
else if (Type == typeof(bool) && DbType == System.Data.DbType.String)
{
_fieldInfo.SetValue(model, bool.Parse(val.ToString()));
}
else if (val != null && val.Equals(DBNull.Value) && Type.IsValueType)
{
_fieldInfo.SetValue(model, Activator.CreateInstance(Type));
}
else if (val != null && !Type.Equals(val.GetType()))
{
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(val.GetType());
_fieldInfo.SetValue(model, converter.ConvertTo(val, Type));
}
else
{
_fieldInfo.SetValue(model, val);
}
}
protected T ReadSetting <T>(string settingName, T defaultValue)
{
Hashtable settings = controller.GetTabModuleSettings(this.tabModuleId);
T ret = default(T);
if (settings.ContainsKey(settingName))
{
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
try
{
ret = (T)tc.ConvertFrom(settings[settingName]);
}
catch
{
ret = defaultValue;
}
}
else
{
ret = defaultValue;
}
return(ret);
}
/// <summary>
/// 根据数据库执行输入的sql获取对应的 TableSchema，其中无法获取数据库中制定字段的长度
/// </summary>
/// <param name="database"></param>
/// <param name="sql"></param>
/// <returns></returns>
public static TableSchema GetTableSchemaByScript(this DatabaseSchema database, string sql)
{
DataTable dt = new DataTable();
DbProviderFactory dbFactory = SqlClientFactory.Instance;
DbConnection dbConnection = dbFactory.CreateConnection();
dbConnection.ConnectionString = database.ConnectionString;
using (DbCommand dbcommand = dbConnection.CreateCommand())
{
dbcommand.CommandType = CommandType.Text;
dbcommand.CommandText = " SET ROWCOUNT 1; " + sql;
dbcommand.CommandTimeout = 180;
using (DbDataAdapter dataAdapter = dbFactory.CreateDataAdapter())
{
dataAdapter.SelectCommand = dbcommand;
dataAdapter.Fill(dt);
}
}
if (dt != null)
{
dt.TableName = "QueryList_" + sql.Length;
var tc = new System.ComponentModel.TypeConverter();
TableSchema tbs = new TableSchema(database, dt.TableName, "dbo", DateTime.Now);
foreach (DataColumn column in dt.Columns)
{
tbs.Columns.Add(new ColumnSchema(tbs, column.ColumnName, column.DataType.GetDbType(), column.DataType.ToString(), 0, 0, 0, true));
}
return(tbs);
}
return(null);
}
public ActionResult Calculate(string s)
{
Color myColor = Color.PaleVioletRed;
// Create the ColorConverter.
System.ComponentModel.TypeConverter converter =
System.ComponentModel.TypeDescriptor.GetConverter(myColor);
var colorBands = JsonConvert.DeserializeObject <ColorBands>(s);
Color a = ColorTranslator.FromHtml(colorBands.BandAColor.Replace("#", "#FF"));
Color b = ColorTranslator.FromHtml(colorBands.BandBColor.Replace("#", "#FF"));
Color c = ColorTranslator.FromHtml(colorBands.BandCColor.Replace("#", "#FF"));
Color d = ColorTranslator.FromHtml(colorBands.BandDColor.Replace("#", "#FF"));
var colormsg = a.Name + b.Name + c.Name + d.Name;
OhmValueCalculator ohmValueCalculator = new OhmValueCalculator();
try
{
double ohmValue = ohmValueCalculator.CalculateOhmValue(a.Name, b.Name, c.Name, d.Name);
string meaningfulTolerance = "";
double[] tolerancePercent = ohmValueCalculator.FindTolerance(d.Name);
int tolerance = 0;
if (tolerancePercent[0] > 0)
{
tolerance = (int)((tolerancePercent[0] / 100) * ohmValue);
}
meaningfulTolerance = tolerance == 0 ? "" : "±" + tolerance;
return(Json(new
{
msg = "Successfully added ",
ohm = ohmValue,
colors = colormsg,
tolerance = meaningfulTolerance
}));
}
catch (ArgumentException argException)
{
return(Json(new
{
msg = "Resistor with bands selected does not exist.",
ohm = -1,
colors = colormsg
}));
}
catch (Exception exc)
{
return(Json(new
{
msg = "Error",
ohm = -1,
colors = colormsg
}));
}
}
private bool IsMethodValid(MethodInfo info)
{
ParameterInfo[] param = info.GetParameters();
if (param.Length > 0)
{
return(false);
}
if (info.ReturnType == null || info.ReturnType == typeof(void))
{
return(false);
}
#if !NETFX_CORE
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(info.ReturnType);
if (!Type.IsAssignableFrom(info.ReturnType) && !converter.CanConvertTo(Type))
{
return(false);
}
#else
if (!Type.GetTypeInfo().IsAssignableFrom(info.ReturnType.GetTypeInfo()))
{
return(false);
}
#endif
return(true);
}
public override void Register(RegistrationContext context)
{
using (Key key = context.CreateKey(EditorRegKey))
{
key.SetValue(string.Empty, FactoryType.Name);
key.SetValue("DisplayName", string.Format(CultureInfo.InvariantCulture, "#{0}", NameResourceID));
key.SetValue("Package", context.ComponentType.GUID.ToString("B"));
key.SetValue("CommonPhysicalViewAttributes", (int)_commonPhysicalViewAttributes);
key.SetValue("EditorTrustLevel", (int)_trustLevel);
using (Key key2 = key.CreateSubkey("LogicalViews"))
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(LogicalView));
object[] customAttributes = FactoryType.GetCustomAttributes(typeof(ProvideViewAttribute), true);
foreach (ProvideViewAttribute attribute in customAttributes)
{
if (attribute.LogicalView != LogicalView.Primary)
{
Guid guid = (Guid)converter.ConvertTo(attribute.LogicalView, typeof(Guid));
string physicalView = attribute.PhysicalView ?? string.Empty;
key2.SetValue(guid.ToString("B"), physicalView);
}
}
}
}
}
private SqlDataAdapter CreateDataAdapter(CommandType commandType, string commandText, Dictionary <string, object> argsDic, int overrideTimeout = 0)
{
SqlDataAdapter myDataAdapter = new SqlDataAdapter
{
MissingSchemaAction = MissingSchemaAction.AddWithKey
};
SqlCommand cmd = CreateSqlCommand(commandType, commandText, overrideTimeout);
if (argsDic.Count > 0)
{
foreach (KeyValuePair <string, object> currParamKeyValue in argsDic)
{
SqlParameter currParam = new SqlParameter
{
ParameterName = currParamKeyValue.Key
};
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(currParam.DbType);
currParam.Value = currParamKeyValue.Value;
if (currParamKeyValue.Value != null)
{
currParam.DbType = (DbType)tc.ConvertFrom(currParamKeyValue.Value.GetType().Name);
}
cmd.Parameters.Add(currParam);
}
}
myDataAdapter.SelectCommand = cmd;
myDataAdapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
return(myDataAdapter);
}
public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
string str = value as string;
if (str == null)
{
return(base.ConvertFrom(context, culture, value));
}
str = str.Trim();
if (str.Length == 0)
{
return(null);
}
if (culture == null)
{
culture = System.Globalization.CultureInfo.CurrentCulture;
}
char ch = culture.TextInfo.ListSeparator[0];
string[] strArray = str.Split(new char[] { ch });
int[] numArray = new int[strArray.Length];
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(int));
for (int i = 0; i < numArray.Length; i++)
{
numArray[i] = (int)converter.ConvertFromString(context, culture, strArray[i]);
}
if (numArray.Length != 4)
{
throw new System.ArgumentException(string.Format("{0}长度必须为4位，当前为{1}，参考格式：{2}。", new object[] { "value", str, "left, top, right, bottom" }));
}
return(new Padding(numArray[0], numArray[1], numArray[2], numArray[3]));
}
/// <summary>
/// Construct a DataModel for the specified type.
/// </summary>
/// <param name="p_Type">Cell Type</param>
/// <returns>
/// If the Type support an <c>UITypeEditor</c> returns an <see cref="EditorUITypeEditor"/> else if the type has a StandardValues list return an <c>EditorComboBox</c>
/// else if the type support string conversion returns an <see cref="EditorTextBox"/> otherwise returns <c>null</c>.
/// </returns>
public static DataModels.IDataModel CreateDataModel(Type p_Type)
{
System.ComponentModel.TypeConverter l_TypeConverter = System.ComponentModel.TypeDescriptor.GetConverter(p_Type);
ICollection l_StandardValues = null;
bool l_StandardValuesExclusive = false;
if (l_TypeConverter != null)
{
l_StandardValues = l_TypeConverter.GetStandardValues();
l_StandardValuesExclusive = l_TypeConverter.GetStandardValuesExclusive();
}
object l_objUITypeEditor = System.ComponentModel.TypeDescriptor.GetEditor(p_Type, typeof(System.Drawing.Design.UITypeEditor));
if (l_objUITypeEditor != null) // UITypeEditor founded
{
return(new DataModels.EditorUITypeEditor(p_Type, (System.Drawing.Design.UITypeEditor)l_objUITypeEditor));
}
else
{
if (l_StandardValues != null) // combo box
{
return(new DataModels.EditorComboBox(p_Type, l_StandardValues, l_StandardValuesExclusive));
}
else if (l_TypeConverter != null && l_TypeConverter.CanConvertFrom(typeof(string)))//txtbox
{
return(new DataModels.EditorTextBox(p_Type));
}
else // no editor found
{
return(null);
}
}
}
static private TData parseData <TData>(System.Reflection.FieldInfo[] fieldInfoList, ConfigTable table, ConfigRow configRow) where TData : new()
{
TData data = new TData();
foreach (System.Reflection.FieldInfo fieldInfo in fieldInfoList)
{
string configValue = getConfigValue(fieldInfo, table, configRow);
if (!string.IsNullOrEmpty(configValue))
{
try
{
System.ComponentModel.TypeConverter typeConverter = getTypeConverter(fieldInfo);
object fieldValue = typeConverter.ConvertFromString(configValue);
fieldInfo.SetValue(data, fieldValue);
}
catch (Exception)
{
act.debug.PrintSystem.LogError("[CONFIG] error in field : " + fieldInfo.Name);
throw;
}
}
}
return(data);
}
/// <summary>
/// Interprets the input string as a hex number in the form 0x..... and converts that to an int, and then to color
/// </summary>
public static TCODColor HexToColor(string hexColor)
{
System.ComponentModel.TypeConverter typeConverter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Int32));
Int32 color = (Int32)typeConverter.ConvertFromString(hexColor);
return(IntToColor(color));
}
public static void SetFont(string fontString1)
{
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Font));
Font myFont1 = (Font)converter.ConvertFromString(fontString1);
KatanaForm.form3.programOutputText.Font = myFont1;
}
private static string GetPrintableText(TSgrdDataGrid AGrid, int AGridColumnId, object ADataColumn)
{
string ReturnValue;
EditorBase editor = AGrid.Columns[AGridColumnId].DataCell.Editor;
if (editor != null)
{
System.ComponentModel.TypeConverter tc = editor.TypeConverter;
if (tc is TSgrdDataGrid.PartnerKeyConverter ||
tc is TypeConverter.TDecimalConverter ||
tc is TypeConverter.TCurrencyConverter ||
tc is TypeConverter.TDateConverter ||
tc is TypeConverter.TShortTimeConverter ||
tc is TypeConverter.TLongTimeConverter)
{
ReturnValue = (string)tc.ConvertTo(ADataColumn, typeof(System.String));
}
else
{
// Including Boolean - in a grid that is a checkbox but we want simple text
ReturnValue = ADataColumn.ToString();
}
}
else
{
// Simple cell with no special editor
ReturnValue = ADataColumn.ToString();
}
return(ReturnValue);
}
public static T[] ConvertTo <T>(this Array ar)
{
T[] ret = new T[ar.Length];
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
if (tc.CanConvertFrom(ar.GetValue(0).GetType()))
{
for (int i = 0; i < ar.Length; i++)
{
ret[i] = (T)tc.ConvertFrom(ar.GetValue(i));
}
}
else
{
tc = System.ComponentModel.TypeDescriptor.GetConverter(ar.GetValue(0).GetType());
if (tc.CanConvertTo(typeof(T)))
{
for (int i = 0; i < ar.Length; i++)
{
ret[i] = (T)tc.ConvertTo(ar.GetValue(i), typeof(T));
}
}
else
{
throw new NotSupportedException();
}
}
return(ret);
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Returns non-null string if this value can be converted to a string,
// null otherwise.
internal static string GetStringValue(DependencyProperty property, object propertyValue)
{
string stringValue = null;
// Special cases working around incorrectly implemented type converters
if (property == UIElement.BitmapEffectProperty)
{
return(null); // Always treat BitmapEffects as complex value
}
if (property == Inline.TextDecorationsProperty)
{
stringValue = TextDecorationsFixup((TextDecorationCollection)propertyValue);
}
else if (typeof(CultureInfo).IsAssignableFrom(property.PropertyType)) //NumberSubstitution.CultureOverrideProperty
{
stringValue = CultureInfoFixup(property, (CultureInfo)propertyValue);
}
if (stringValue == null)
{
DPTypeDescriptorContext context = new DPTypeDescriptorContext(property, propertyValue);
System.ComponentModel.TypeConverter typeConverter = System.ComponentModel.TypeDescriptor.GetConverter(property.PropertyType);
Invariant.Assert(typeConverter != null);
if (typeConverter.CanConvertTo(context, typeof(string)))
{
stringValue = (string)typeConverter.ConvertTo(
context, System.Globalization.CultureInfo.InvariantCulture, propertyValue, typeof(string));
}
}
return(stringValue);
}
/**********************************************************************/
public SqlDbType GetSqlTypeFromModel(System.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 if (theType.Name.Equals("Byte[]")) //byte array (sql varbinary) needs special handling
{
return(SqlDbType.VarBinary);
}
else if (theType.FullName.Contains("DateTime")) //needed for nullable DateTime field
{
return(SqlDbType.DateTime);
}
else
{
try
{
//allow to work with nullable types
string effectiveTypeName = theType.Name.StartsWith("Nullable") ? Nullable.GetUnderlyingType(theType).Name : theType.Name;
p1.DbType = (DbType)tc.ConvertFrom(effectiveTypeName);
}
catch (Exception e)
{
Logger.Instance.WriteToLog(e.ToString());
}
}
return(p1.SqlDbType);
}
/// <summary>
/// </summary>
public T ReadSetting <T>(string settingName, T defaultValue)
{
Hashtable settings = _controller.GetModule(_moduleId, DotNetNuke.Common.Utilities.Null.NullInteger, true).ModuleSettings;
T ret = default(T);
if (settings.ContainsKey(settingName))
{
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
try
{
ret = (T)tc.ConvertFrom(settings[settingName]);
}
catch
{
ret = defaultValue;
}
}
else
{
ret = defaultValue;
}
return(ret);
}
public override void DoDrop(object srcInst, object destInst, object srcHolder, object destHolder)
{
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(destInst);
if (converter != null)
{
object newObject = converter.ConvertFrom(srcInst);
}
}
public static Color GetColor(string strColorString)
{
// Create the ColorConverter.
System.ComponentModel.TypeConverter converter =
System.ComponentModel.TypeDescriptor.GetConverter(typeof(Color));
return((Color)converter.ConvertFromString(strColorString));
}
protected override object GetFormattedValue(object value, int rowIndex,
ref DataGridViewCellStyle cellStyle,
System.ComponentModel.TypeConverter valueTypeConverter,
System.ComponentModel.TypeConverter formattedValueTypeConverter,
DataGridViewDataErrorContexts context)
{
return(null);
}
public static string GetColorString(Color color)
{
// Create the ColorConverter.
System.ComponentModel.TypeConverter converter =
System.ComponentModel.TypeDescriptor.GetConverter(typeof(Color));
return(converter.ConvertToString(color));
}
public override bool CanDoDrop(object srcInst, object destInst)
{
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(destInst);
if (converter != null)
{
return(converter.CanConvertFrom(srcInst.GetType()));
}
return(false);
}
private static Dictionary <string, Color[]> LoadNoteColours(string defs)
{
System.ComponentModel.TypeConverter colorConverter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Color));
// (Color)colorConverter.ConvertFromString("#00000000")
Dictionary <string, Color[]> noteColours_Default = new Dictionary <string, Color[]>
{
{ NoteTypes.NoteTypeDefs.None.TypeName, new Color[] { Color.Transparent, Color.Transparent } },
{ NoteTypes.NoteTypeDefs.Tap.TypeName, new Color[] { Color.Blue, Color.Transparent } },
{ NoteTypes.NoteTypeDefs.Hold.TypeName, new Color[] { Color.LimeGreen, Color.Transparent } },
{ NoteTypes.NoteTypeDefs.SimulTap.TypeName, new Color[] { Color.DeepPink, Color.Transparent } },
{ NoteTypes.NoteTypeDefs.SimulHoldStart.TypeName, new Color[] { Color.DeepPink, Color.Transparent } },
{ NoteTypes.NoteTypeDefs.SimulHoldRelease.TypeName, new Color[] { Color.DeepPink, Color.Transparent } },
{ NoteTypes.NoteTypeDefs.FlickLeft.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.FromArgb(0x70, 0, 0x78) } },
{ NoteTypes.NoteTypeDefs.HoldEndFlickLeft.TypeName, new Color[] { Color.LightGray, Color.FromArgb(0x70, 0, 0x78) } },
{ NoteTypes.NoteTypeDefs.SwipeLeftStartEnd.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.DarkViolet } },
{ NoteTypes.NoteTypeDefs.SwipeLeftMid.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.Violet } },
{ NoteTypes.NoteTypeDefs.SwipeChangeDirR2L.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.Violet } },
{ NoteTypes.NoteTypeDefs.FlickRight.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.FromArgb(0xcc, 0x88, 0) } },
{ NoteTypes.NoteTypeDefs.HoldEndFlickRight.TypeName, new Color[] { Color.LightGray, Color.FromArgb(0xcc, 0x88, 0) } },
{ NoteTypes.NoteTypeDefs.SwipeRightStartEnd.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.DarkOrange } },
{ NoteTypes.NoteTypeDefs.SwipeRightMid.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.Gold } },
{ NoteTypes.NoteTypeDefs.SwipeChangeDirL2R.TypeName, new Color[] { Color.FromArgb(0xc0, 0xc0, 0xc0), Color.Gold } },
{ NoteTypes.NoteTypeDefs.ExtendHoldMid.TypeName, new Color[] { Color.LightGray, Color.Transparent } },
{ NoteTypes.NoteTypeDefs.GbsFlick.TypeName, new Color[] { Color.Gold, Color.LightYellow } },
{ NoteTypes.NoteTypeDefs.GbsHoldEndFlick.TypeName, new Color[] { Color.LightGray, Color.Gold } },
{ NoteTypes.NoteTypeDefs.GbsSimulFlick.TypeName, new Color[] { Color.Goldenrod, Color.LightYellow } },
{ NoteTypes.NoteTypeDefs.GbsClock.TypeName, new Color[] { Color.Blue, Color.Gold } },
{ NoteTypes.NoteTypeDefs.GbsSimulClock.TypeName, new Color[] { Color.DeepPink, Color.Gold } }
};
Dictionary <string, Color[]> noteColours = noteColours_Default;
string[] defslines = defs.Split("\n".ToCharArray());
for (int i = 0; i < defslines.Length; i++)
{
if (defslines[i].StartsWith("#") || defslines[i].Trim().Length == 0)
{
continue;
}
string cleanDef = defslines[i].Replace(" ", "");
if (!cleanDef.Contains(":"))
{
continue;
}
string type = cleanDef.Split(":".ToCharArray())[0];
string[] vals = cleanDef.Split(":".ToCharArray())[1].Split(",".ToCharArray());
noteColours[type] = new Color[] { (Color)colorConverter.ConvertFromString(vals[0]), (Color)colorConverter.ConvertFromString(vals[1]) };
}
return(noteColours);
}
private object cc2(object tipo)
{
if (tipo == null)
{
return(null);
}
if (tipo is seriable3)
{
seriable3 trans = (seriable3)tipo;
return(new System.Web.UI.Triplet(cc2(trans.First), cc2(trans.Second), cc2(trans.Third)));
}
else if (tipo is seriable2)
{
seriable2 trans = (seriable2)tipo;
return(new System.Web.UI.Pair(cc2(trans.First), cc2(trans.Second)));
}
else if (tipo is ArrayList)
{
ArrayList salida = (ArrayList)tipo;
for (int x = 0; x < salida.Count; x++)
{
salida[x] = cc2(salida[x]);
}
return(salida);
}
else if (tipo is Array)
{
Array salida = (Array)tipo;
for (int x = 0; x < salida.Length; x++)
{
salida.SetValue(cc2(salida.GetValue(x)), x);
}
return(salida);
}
else if (tipo is Hashtable)
{
IDictionaryEnumerator enumerator = ((Hashtable)tipo).GetEnumerator();
Hashtable salida = new Hashtable();
while (enumerator.MoveNext())
{
salida.Add(cc2(enumerator.Key), cc2(enumerator.Value));
}
return(salida);
}
else if (tipo is generalCnv)
{
generalCnv datos = (generalCnv)tipo;
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(datos.bTipo);
return(converter.ConvertFromInvariantString(datos.bString));
}
else
{
return(tipo);
//Salida General
}
}
private SqlDbType TypeToSqlDbType(Type type)
{
System.Data.SqlClient.SqlParameter p1 = new System.Data.SqlClient.SqlParameter();
System.ComponentModel.TypeConverter tc = null;
tc = System.ComponentModel.TypeDescriptor.GetConverter(p1.DbType);
p1.DbType = (DbType)tc.ConvertFrom(type.Name);
return(p1.SqlDbType);
}
private static object _ChangeType(object obj, System.Type type)
{
System.ComponentModel.TypeConverter typeConverter = System.ComponentModel.TypeDescriptor.GetConverter(obj);
if (((null == typeConverter) ||
(false == typeConverter.CanConvertTo(type))))
{
return(System.Convert.ChangeType(obj, type));
}
return(typeConverter.ConvertTo(obj, type));
}
/// <summary>
/// Gets the correct SqlDBType for a given .NET type. Useful for working with SQL CE.
/// </summary>
/// <param name="type">The .Net Type used to find the SqlDBType.</param>
/// <returns>The correct SqlDbType for the .Net type passed in.</returns>
public static SqlDbType GetSqlDBTypeFromType(Type type)
{
System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(DbType));
DbType dbType = (DbType)tc.ConvertFrom(type.Name);
// A cheat, but the parameter class knows how to map between DbType and SqlDBType.
SqlParameter param = new SqlParameter();
param.DbType = dbType;
return(param.SqlDbType); // The parameter class did the conversion for us!!
}
private void btnSaveChanges_Click(object sender, RoutedEventArgs e)
{
System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(ddColor.Color);
var dueDateColorData = converter.ConvertToString(ddColor.Color);
System.ComponentModel.TypeConverter converter2 = System.ComponentModel.TypeDescriptor.GetConverter(ccMessage.Color);
var messageTextColor = converter2.ConvertToString(ccMessage.Color);
System.ComponentModel.TypeConverter converter3 = System.ComponentModel.TypeDescriptor.GetConverter(backgroundDueDate.Color);
var BackgroundDueDateColor = converter3.ConvertToString(backgroundDueDate.Color);
System.ComponentModel.TypeConverter converter4 = System.ComponentModel.TypeDescriptor.GetConverter(backgroundMessageColor.Color);
var BackgroundMessageColor = converter4.ConvertToString(backgroundMessageColor.Color);
string dueDate = "";
string companyLogo = "";
if (dpDueDate.SelectedDate != null)
{
dueDate = dpDueDate.SelectedDate.Value.ToString();
}
if (!String.IsNullOrWhiteSpace(screenSettings.CompanyLogo))
{
companyLogo = screenSettings.CompanyLogo;
}
screenSettings = new ScreenSaverSettings()
{
Message = txtMessage.Text,
DueDateMessage = txtDueDateMessage.Text,
DueDate = dueDate,
CompanyLogo = companyLogo,
DueDateTextColor = dueDateColorData,
MessageTextColor = messageTextColor,
BackgroundDueDateColor = BackgroundDueDateColor,
BackgroundMessageColor = BackgroundMessageColor
};
var json = Newtonsoft.Json.JsonConvert.SerializeObject(screenSettings);
try
{
var sw = new StreamWriter(@"c:\screen\data.enigma");
sw.Write(json);
sw.Close();
}
catch (Exception exp)
{
MessageBox.Show(exp.Message, "Unable to write to directory");
}
this.Close();
}
public static bool _ConvertTo_System_ComponentModel_TypeConverter_System_ComponentModel_ITypeDescriptorContext_System_Globalization_CultureInfo_System_Object_System_Type( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
System.ComponentModel.ITypeDescriptorContext context = null;
System.Globalization.CultureInfo culture = null;
System.Object _value = null;
System.Type destinationType = null;
//ReturnType/Value
System.Object returnVal_Real = null;
System.Object returnVal_Intercepted = null;
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
returnVal_Real = _System_ComponentModel_TypeConverter.ConvertTo(context,culture,_value,destinationType);
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
returnVal_Intercepted = _System_ComponentModel_TypeConverter.ConvertTo(context,culture,_value,destinationType);
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Messsage == exception_Intercepted.Message ) && ( returnValue_Real == returnValue_Intercepted ) );
}
public static bool _IsValid_System_ComponentModel_TypeConverter_System_ComponentModel_ITypeDescriptorContext_System_Object( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
System.ComponentModel.ITypeDescriptorContext context = null;
System.Object _value = null;
//ReturnType/Value
System.Boolean returnVal_Real = false;
System.Boolean returnVal_Intercepted = false;
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
returnVal_Real = _System_ComponentModel_TypeConverter.IsValid(context,_value);
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
returnVal_Intercepted = _System_ComponentModel_TypeConverter.IsValid(context,_value);
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Messsage == exception_Intercepted.Message ) && ( returnValue_Real == returnValue_Intercepted ) );
}
public static bool _CreateInstance_System_ComponentModel_TypeConverter_System_ComponentModel_ITypeDescriptorContext_System_Collections_IDictionary( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
System.ComponentModel.ITypeDescriptorContext context = null;
System.Collections.IDictionary propertyValues = null;
//ReturnType/Value
System.Object returnVal_Real = null;
System.Object returnVal_Intercepted = null;
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
returnVal_Real = _System_ComponentModel_TypeConverter.CreateInstance(context,propertyValues);
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
returnVal_Intercepted = _System_ComponentModel_TypeConverter.CreateInstance(context,propertyValues);
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Messsage == exception_Intercepted.Message ) && ( returnValue_Real == returnValue_Intercepted ) );
}
public static bool _ConvertFromString_System_ComponentModel_TypeConverter_System_ComponentModel_ITypeDescriptorContext_System_String( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
System.ComponentModel.ITypeDescriptorContext context = null;
System.String text = null;
//ReturnType/Value
System.Object returnVal_Real = null;
System.Object returnVal_Intercepted = null;
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
returnVal_Real = _System_ComponentModel_TypeConverter.ConvertFromString(context,text);
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
returnVal_Intercepted = _System_ComponentModel_TypeConverter.ConvertFromString(context,text);
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Messsage == exception_Intercepted.Message ) && ( returnValue_Real == returnValue_Intercepted ) );
}
public static bool _CanConvertTo_System_ComponentModel_TypeConverter_System_Type( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
System.Type destinationType = null;
//ReturnType/Value
System.Boolean returnVal_Real = false;
System.Boolean returnVal_Intercepted = false;
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
returnVal_Real = _System_ComponentModel_TypeConverter.CanConvertTo(destinationType);
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
returnVal_Intercepted = _System_ComponentModel_TypeConverter.CanConvertTo(destinationType);
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Messsage == exception_Intercepted.Message ) && ( returnValue_Real == returnValue_Intercepted ) );
}
public static bool _GetProperties_System_ComponentModel_TypeConverter_System_Object( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
System.Object _value = null;
//ReturnType/Value
System.ComponentModel.PropertyDescriptorCollection returnVal_Real = null;
System.ComponentModel.PropertyDescriptorCollection returnVal_Intercepted = null;
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
returnVal_Real = _System_ComponentModel_TypeConverter.GetProperties(_value);
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
returnVal_Intercepted = _System_ComponentModel_TypeConverter.GetProperties(_value);
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Messsage == exception_Intercepted.Message ) && ( returnValue_Real == returnValue_Intercepted ) );
}
public static bool _ConvertToInvariantString_System_ComponentModel_TypeConverter_System_Object( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
System.Object _value = null;
//ReturnType/Value
System.String returnVal_Real = null;
System.String returnVal_Intercepted = null;
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
returnVal_Real = _System_ComponentModel_TypeConverter.ConvertToInvariantString(_value);
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
returnVal_Intercepted = _System_ComponentModel_TypeConverter.ConvertToInvariantString(_value);
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Messsage == exception_Intercepted.Message ) && ( returnValue_Real == returnValue_Intercepted ) );
}
public static bool _ctor_System_ComponentModel_TypeConverter( )
{
//class object
System.ComponentModel.TypeConverter _System_ComponentModel_TypeConverter = new System.ComponentModel.TypeConverter();
//Parameters
//Exception
System.Exception exception_Real = null;
System.Exception exception_Intercepted = null;
InterceptionMaintenance.disableInterception( );
try
{
_System_ComponentModel_TypeConverter.ctor();
}
catch( System.Exception e )
{
exception_Real = e;
}
InterceptionMaintenance.enableInterception( );
try
{
_System_ComponentModel_TypeConverter.ctor();
}
catch( System.Exception e )
{
exception_Intercepted = e;
}
return( ( exception_Real.Message == exception_Intercepted.Message ));
}
private string BuildProps(List<Column> cols)
{
System.ComponentModel.TypeConverter tc = new System.ComponentModel.TypeConverter();
string result = "#region Props\r\n";
foreach (Column c in cols)
{
//public int Property {get{return _field;} set{_field=value;}}
result += string.Format("\tpublic {0} {2} {{get{{return {1};}} set{{{1}=value;}}}}\r\n",
c.GetASPNetDataType(), GetFieldName(c), GetPropName(c));
}
result += "#endregion //Props\r\n";
return result;
}
public WMIValueTypeConverter(System.Type baseType)
{
baseConverter = System.ComponentModel.TypeDescriptor.GetConverter(baseType);
}
private string BuildFields(List<Column> cols)
{
System.ComponentModel.TypeConverter tc = new System.ComponentModel.TypeConverter();
string result="#region Fields\r\n";
foreach (Column c in cols) {
//private int _field;
result += string.Format( "\t private {0} {1};\r\n",
c.GetASPNetDataType(),GetFieldName(c));
}
result += "#endregion //Fields\r\n";
return result;
}
private string BuildConstructor(List<Column> cols, string className)
{
System.ComponentModel.TypeConverter tc = new System.ComponentModel.TypeConverter();
string result = "#region CTOR\r\n";
string CTORdflt=string.Format("\tpublic {0}(){{\r\n", className);
string CTOR = string.Format("\tpublic {0} ({1}){{\r\n", className, GetFieldsAsInputParams(cols));
foreach (Column c in cols)
{
//_field=value;
CTORdflt += string.Format("\t\t{0} = {1};\r\n",
GetFieldName(c), GetInitialValueByType(c));
//_field=inputParam;
CTOR += string.Format ("\t\t{0}={1};\r\n",
GetFieldName(c), GetInputParamName(c));
}
CTORdflt += "\t}\r\n";
CTOR += "\t}\r\n";
result += CTORdflt + CTOR;
result += "#endregion //CTOR\r\n";
return result;
}
