1059 lines
25 KiB
C#
1059 lines
25 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Security;
|
|
using System.Text.RegularExpressions;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.Charts.Style;
|
|
|
|
namespace DevComponents.DotNetBar.Charts
|
|
{
|
|
#region XmlSerializableFont
|
|
|
|
static public class XmlSerializableFont
|
|
{
|
|
static public string ConvertToString(Font font)
|
|
{
|
|
if (font != null)
|
|
{
|
|
TypeConverter converter =
|
|
TypeDescriptor.GetConverter(typeof(Font));
|
|
|
|
return (converter.ConvertToString(font));
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
static public Font ConvertFromString(string fontString)
|
|
{
|
|
TypeConverter converter =
|
|
TypeDescriptor.GetConverter(typeof(Font));
|
|
|
|
Font font = (Font)converter.ConvertFromString(fontString);
|
|
|
|
return (font);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region XmlSerializableImageList
|
|
|
|
static public class XmlSerializableImageList
|
|
{
|
|
static public string ConvertToString(ImageList list)
|
|
{
|
|
TypeConverter converter =
|
|
TypeDescriptor.GetConverter(typeof(ImageList));
|
|
|
|
return (converter.ConvertToString(list));
|
|
}
|
|
|
|
static public ImageList ConvertFromString(string listString)
|
|
{
|
|
TypeConverter converter =
|
|
TypeDescriptor.GetConverter(typeof(ImageList));
|
|
|
|
ImageList list = (ImageList)converter.ConvertFromString(listString);
|
|
|
|
return (list);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SerialElementCollection
|
|
|
|
public delegate void Pv(SerialElement se);
|
|
public delegate void Pc(SerialElement se);
|
|
|
|
public class SerialElementCollection : CustomCollection<SerialElement>
|
|
{
|
|
#region Private variables
|
|
|
|
private int _ReadIndex = -1;
|
|
|
|
private SerialElement _ReadSe;
|
|
private string _Name;
|
|
|
|
private int _ValueIndex;
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region Eof
|
|
|
|
internal bool Eof
|
|
{
|
|
get { return (_ReadIndex >= Count); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Name
|
|
|
|
internal string Name
|
|
{
|
|
get { return (_Name); }
|
|
set { _Name = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ReadIndex
|
|
|
|
internal int ReadIndex
|
|
{
|
|
get { return (_ReadIndex); }
|
|
set { _ReadIndex = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ReadSe
|
|
|
|
internal SerialElement ReadSe
|
|
{
|
|
get { return (_ReadSe); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region AddStartElement
|
|
|
|
/// <summary>
|
|
/// Adds a 'Start' element to the collection.
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
public SerialElement AddStartElement(string name)
|
|
{
|
|
SerialElement se = new SerialElement(SerElementType.Start, name);
|
|
|
|
Items.Add(se);
|
|
|
|
return (se);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AddEndElement
|
|
|
|
/// <summary>
|
|
/// Adds an 'End' element to the collection.
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
public SerialElement AddEndElement(string name)
|
|
{
|
|
SerialElement se = new SerialElement(SerElementType.End, name);
|
|
|
|
Items.Add(se);
|
|
|
|
return (se);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AddValue
|
|
|
|
/// <summary>
|
|
/// Adds the given object element to the collection.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public SerialElement AddValue(object value)
|
|
{
|
|
SerialElement se = new SerialElement(null, value);
|
|
|
|
Items.Add(se);
|
|
|
|
return (se);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the given value to the collection (surrounded
|
|
/// by a 'Start' and 'End' element pair).
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
public void AddValue(string name, object value)
|
|
{
|
|
Items.Add(new SerialElement(SerElementType.ValueStart, name));
|
|
Items.Add(new SerialElement(name, value));
|
|
Items.Add(new SerialElement(SerElementType.ValueEnd, name));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the given value to the collection (surrounded
|
|
/// by a 'Start' and 'End' element pair) - but only if the
|
|
/// value is not equal to the given defaultValue.
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="defaultValue"></param>
|
|
public void AddValue(string name, object value, object defaultValue)
|
|
{
|
|
if ((defaultValue == null && value != null) ||
|
|
(defaultValue != null && defaultValue.Equals(value) == false))
|
|
{
|
|
AddValue(name, value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the given value Image to the collection (surrounded
|
|
/// by a 'Start' and 'End' element pair).
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="image"></param>
|
|
public void AddValue(string name, Image image)
|
|
{
|
|
if (image != null)
|
|
AddValue(name, ImageToString(image));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageToString
|
|
|
|
private String ImageToString(Image image)
|
|
{
|
|
BinaryFormatter bf = new BinaryFormatter();
|
|
MemoryStream ms = new MemoryStream();
|
|
|
|
bf.Serialize(ms, image);
|
|
|
|
return (Convert.ToBase64String(ms.ToArray()));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AddDataValue
|
|
|
|
/// <summary>
|
|
/// Adds the given 'Data' value to the collection (surrounded
|
|
/// by a 'Start' and 'End' element pair).
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
public void AddDataValue(string name, object value)
|
|
{
|
|
Items.Add(new SerialElement(SerElementType.ValueStart, name));
|
|
Items.Add(new SerialElement(SerElementType.DataValue, name, value));
|
|
Items.Add(new SerialElement(SerElementType.ValueEnd, name));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the given 'Data' value to the collection (surrounded
|
|
/// by a 'Start' and 'End' element pair) - but only if the
|
|
/// value is not equal to the given defaultValue.
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="defaultValue"></param>
|
|
public void AddDataValue(string name, object value, object defaultValue)
|
|
{
|
|
if ((defaultValue == null && value != null) ||
|
|
(defaultValue != null && defaultValue.Equals(value) == false))
|
|
{
|
|
AddDataValue(name, value);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AddElement
|
|
|
|
/// <summary>
|
|
/// Adds the given SerialElementCollection to the
|
|
/// collection, if the given collection is non-empty.
|
|
/// </summary>
|
|
/// <param name="sec"></param>
|
|
/// <returns></returns>
|
|
public SerialElement AddElement(SerialElementCollection sec)
|
|
{
|
|
if (sec != null && sec.Count > 0)
|
|
{
|
|
int count = sec.Count;
|
|
|
|
if (sec[count - 1].SerType == SerElementType.End)
|
|
count--;
|
|
|
|
if (sec[0].SerType == SerElementType.Start)
|
|
count--;
|
|
|
|
if (count > 0)
|
|
{
|
|
SerialElement se = new SerialElement(sec);
|
|
|
|
Items.Add(se);
|
|
|
|
return (se);
|
|
}
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the given style to the collection, if
|
|
/// it is not Empty.
|
|
/// </summary>
|
|
/// <param name="style"></param>
|
|
/// <returns></returns>
|
|
public SerialElement AddElement(BaseVisualStyle style)
|
|
{
|
|
if (style != null && style.IsEmpty == false)
|
|
return (AddElement(style.GetSerialData("")));
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PutSerialData
|
|
|
|
internal void PutSerialData(IProcessSerialElement ipse)
|
|
{
|
|
while (Read())
|
|
{
|
|
SerialElement se = ReadSe;
|
|
|
|
switch (se.SerType)
|
|
{
|
|
case SerElementType.Start:
|
|
case SerElementType.ValueStart:
|
|
string name = se.Name;
|
|
|
|
PutSerialData(ipse);
|
|
|
|
if (se.Name.Equals(name) == false)
|
|
throw new Exception("Expecting " + name + " End");
|
|
|
|
break;
|
|
|
|
case SerElementType.Value:
|
|
se.ValueIndex = _ValueIndex++;
|
|
|
|
ipse.ProcessValue(se);
|
|
break;
|
|
|
|
case SerElementType.Collection:
|
|
int valueIndex = _ValueIndex;
|
|
_ValueIndex = 0;
|
|
|
|
ipse.ProcessCollection(se);
|
|
|
|
_ValueIndex = valueIndex;
|
|
break;
|
|
|
|
case SerElementType.End:
|
|
case SerElementType.ValueEnd:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
#region SkipSerialData
|
|
|
|
private void SkipSerialData()
|
|
{
|
|
while (Read())
|
|
{
|
|
SerialElement se = ReadSe;
|
|
|
|
switch (se.SerType)
|
|
{
|
|
case SerElementType.Start:
|
|
case SerElementType.ValueStart:
|
|
string name = se.Name;
|
|
|
|
SkipSerialData();
|
|
|
|
if (se.Name.Equals(name) == false)
|
|
throw new Exception("Expecting " + name + " End");
|
|
|
|
break;
|
|
|
|
case SerElementType.End:
|
|
case SerElementType.ValueEnd:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Read
|
|
|
|
internal bool Read()
|
|
{
|
|
_ReadIndex++;
|
|
|
|
_ReadSe = (_ReadIndex < Count) ? Items[_ReadIndex] : null;
|
|
|
|
return (_ReadSe != null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Rewind
|
|
|
|
internal void Rewind()
|
|
{
|
|
_ReadIndex = -1;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetItemValue
|
|
|
|
internal string GetItemValue(string text)
|
|
{
|
|
foreach (SerialElement se in this)
|
|
{
|
|
if (se.SerType == SerElementType.Value)
|
|
{
|
|
if (se.Name.Equals(text))
|
|
return (se.StringValue);
|
|
}
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SerialElement
|
|
|
|
public class SerialElement
|
|
{
|
|
#region Private variables
|
|
|
|
private SerElementType _SerType;
|
|
|
|
private string _Name;
|
|
private object _Value;
|
|
|
|
private SerialElementCollection _Sec;
|
|
|
|
private int _ArrayCount;
|
|
private int _ValueIndex;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public SerialElement(SerElementType type, string name)
|
|
{
|
|
_SerType = type;
|
|
_Name = name;
|
|
}
|
|
|
|
public SerialElement(string name, object value)
|
|
{
|
|
_SerType = SerElementType.Value;
|
|
|
|
_Name = name;
|
|
_Value = value;
|
|
}
|
|
|
|
public SerialElement(SerElementType type, string name, object value)
|
|
{
|
|
_SerType = type;
|
|
|
|
_Name = name;
|
|
_Value = value;
|
|
}
|
|
|
|
public SerialElement(SerialElementCollection sec)
|
|
{
|
|
_SerType = SerElementType.Collection;
|
|
|
|
_Sec = sec;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
/// <summary>
|
|
/// Element name
|
|
/// </summary>
|
|
public string Name
|
|
{
|
|
get { return (_Name); }
|
|
set { _Name = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Element type.
|
|
/// </summary>
|
|
public SerElementType SerType
|
|
{
|
|
get { return (_SerType); }
|
|
set { _SerType = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Element value
|
|
/// </summary>
|
|
public object Value
|
|
{
|
|
get { return (_Value); }
|
|
set { _Value = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Element sub-collection.
|
|
/// </summary>
|
|
public SerialElementCollection Sec
|
|
{
|
|
get { return (_Sec); }
|
|
set { _Sec = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region ArrayCount
|
|
|
|
internal int ArrayCount
|
|
{
|
|
get { return (_ArrayCount); }
|
|
set { _ArrayCount = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ColorValue
|
|
|
|
internal Color ColorValue
|
|
{
|
|
get { return (GetValueColor()); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DataValue
|
|
|
|
internal object DataValue
|
|
{
|
|
get
|
|
{
|
|
if (Value is string)
|
|
{
|
|
string s = (string)Value;
|
|
|
|
if (s.StartsWith("\"") && s.EndsWith("\""))
|
|
return (s.Substring(1, s.Length - 2));
|
|
|
|
if (s.StartsWith("#") && s.EndsWith("#"))
|
|
return (DateTime.Parse(s.Substring(1, s.Length - 2)));
|
|
|
|
if (s.StartsWith("{") && s.EndsWith("}"))
|
|
return (ColorTranslator.FromHtml(s.Substring(1, s.Length - 2)));
|
|
|
|
if (s.StartsWith("[") && s.EndsWith("]"))
|
|
{
|
|
s = s.Substring(1, s.Length - 2);
|
|
|
|
string[] t = s.Split(',');
|
|
|
|
TypeCode tc = TypeCode.Double;
|
|
|
|
if (t.Length > 1)
|
|
tc = (TypeCode)int.Parse(t[1]);
|
|
|
|
return (GetNumericValue(t[0], tc));
|
|
}
|
|
|
|
if (s.Equals("xsi:nil=\"true\""))
|
|
return (null);
|
|
|
|
return (s);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StringValue
|
|
|
|
internal string StringValue
|
|
{
|
|
get
|
|
{
|
|
if (Value is string)
|
|
{
|
|
string s = (string)Value;
|
|
|
|
if (s.StartsWith("\"") && s.EndsWith("\""))
|
|
return (s.Substring(1, s.Length - 2));
|
|
|
|
return (s);
|
|
}
|
|
|
|
return ("");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValueIndex
|
|
|
|
internal int ValueIndex
|
|
{
|
|
get { return (_ValueIndex); }
|
|
set { _ValueIndex = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetValueColor
|
|
|
|
internal Color GetValueColor()
|
|
{
|
|
string s = StringValue;
|
|
|
|
if (string.IsNullOrEmpty(s) == false)
|
|
{
|
|
if (s.IndexOf('=') >= 0)
|
|
{
|
|
string pattern = @"A=(?<A>\d+)\s*,\s*R=(?<R>\d+)\s*,\s*G=(?<G>\d+)\s*,\s*B=(?<B>\d+)";
|
|
|
|
Match match = Regex.Match(s, pattern);
|
|
|
|
if (match.Success == true)
|
|
{
|
|
Color color = Color.FromArgb(
|
|
int.Parse(match.Groups["A"].Value),
|
|
int.Parse(match.Groups["R"].Value),
|
|
int.Parse(match.Groups["G"].Value),
|
|
int.Parse(match.Groups["B"].Value));
|
|
|
|
return (color);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return (Color)Color.FromName(s);
|
|
}
|
|
}
|
|
|
|
return (Color.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetValueString
|
|
|
|
internal string GetValueString()
|
|
{
|
|
string s = GetValueStringEx();
|
|
|
|
string encodedXml = SecurityElement.Escape(s);
|
|
|
|
return (encodedXml);
|
|
}
|
|
|
|
internal string GetValueStringEx()
|
|
{
|
|
object value = Value;
|
|
|
|
if (value == null)
|
|
return ("xsi:nil=\"true\"");
|
|
|
|
if (value is string)
|
|
return ((string)value);
|
|
|
|
if (value is DateTime)
|
|
return (((DateTime)value).ToString("o"));
|
|
|
|
if (value is Color)
|
|
{
|
|
Color color = (Color)value;
|
|
|
|
string s = color.ToString();
|
|
|
|
int start = s.IndexOf('[') + 1;
|
|
int end = s.IndexOf(']');
|
|
|
|
s = s.Substring(start, end - start);
|
|
|
|
return (s);
|
|
}
|
|
|
|
return (value.ToString());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetDataValueString
|
|
|
|
internal string GetDataValueString()
|
|
{
|
|
object value = Value;
|
|
|
|
if (value == null)
|
|
return ("xsi:nil=\"true\"");
|
|
|
|
if (value is string)
|
|
return ("\"" + value + "\"");
|
|
|
|
if (value is DateTime)
|
|
return ("#" + ((DateTime)value).ToString("o") + "#");
|
|
|
|
if (value is Color)
|
|
return ("{" + ColorTranslator.ToHtml((Color)value) + "}");
|
|
|
|
if (Value is Enum == false)
|
|
{
|
|
TypeCode typeCode;
|
|
|
|
if (IsNumericValue(out typeCode))
|
|
{
|
|
string s = value.ToString();
|
|
|
|
return ("[" + s + "," + (int)typeCode + "]");
|
|
}
|
|
}
|
|
|
|
return (value.ToString());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetValueEnum
|
|
|
|
internal object GetValueEnum(Type type)
|
|
{
|
|
return (Enum.Parse(type, StringValue));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetValuePoint
|
|
|
|
internal Point GetValuePoint()
|
|
{
|
|
string svalue = StringValue;
|
|
|
|
if (string.IsNullOrEmpty(svalue) == false)
|
|
{
|
|
string pattern = @"(?<x>X=\d+)\s,\s(?<y>Y=\d+)";
|
|
|
|
Match match = Regex.Match(svalue, pattern);
|
|
|
|
if (match.Success == true)
|
|
{
|
|
Point pt = new Point(
|
|
int.Parse(match.Groups["x"].Value),
|
|
int.Parse(match.Groups["y"].Value));
|
|
|
|
return (pt);
|
|
}
|
|
}
|
|
|
|
return (Point.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetValuePointF
|
|
|
|
internal PointF GetValuePointF()
|
|
{
|
|
string svalue = StringValue;
|
|
|
|
if (string.IsNullOrEmpty(svalue) == false)
|
|
{
|
|
string pattern = @"(?<x>X=\d+)\s,\s(?<y>Y=\d+)";
|
|
|
|
Match match = Regex.Match(svalue, pattern);
|
|
|
|
if (match.Success == true)
|
|
{
|
|
PointF ptf = new PointF(
|
|
float.Parse(match.Groups["x"].Value),
|
|
float.Parse(match.Groups["y"].Value));
|
|
|
|
return (ptf);
|
|
}
|
|
}
|
|
|
|
return (PointF.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetValueSize
|
|
|
|
internal Size GetValueSize()
|
|
{
|
|
string svalue = StringValue;
|
|
|
|
if (string.IsNullOrEmpty(svalue) == false)
|
|
{
|
|
string pattern = @"Width=(?<width>\d+)\s*,\s*Height=(?<height>\d+)";
|
|
|
|
Match match = Regex.Match(svalue, pattern);
|
|
|
|
if (match.Success == true)
|
|
{
|
|
Size size = new Size(
|
|
int.Parse(match.Groups["width"].Value),
|
|
int.Parse(match.Groups["height"].Value));
|
|
|
|
return (size);
|
|
}
|
|
}
|
|
|
|
return (Size.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetValueRect
|
|
|
|
internal Rectangle GetValueRect()
|
|
{
|
|
string svalue = StringValue;
|
|
|
|
if (string.IsNullOrEmpty(svalue) == false)
|
|
{
|
|
string pattern = @"(?<x>X=\d+)\s,\s(?<x>Y=\d+)\s,\s(?<width>Width=\d+)\s,\s(?<height>Height=\d+)";
|
|
|
|
Match match = Regex.Match(svalue, pattern);
|
|
|
|
if (match.Success == true)
|
|
{
|
|
Rectangle rect = new Rectangle(
|
|
int.Parse(match.Groups["x"].Value),
|
|
int.Parse(match.Groups["y"].Value),
|
|
int.Parse(match.Groups["width"].Value),
|
|
int.Parse(match.Groups["height"].Value));
|
|
|
|
return (rect);
|
|
}
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetValueImage
|
|
|
|
internal Image GetValueImage()
|
|
{
|
|
string svalue = StringValue;
|
|
|
|
if (string.IsNullOrEmpty(svalue) == false)
|
|
return (StringToImage(svalue));
|
|
|
|
return (null);
|
|
}
|
|
|
|
#region StringToImage
|
|
|
|
private Image StringToImage(String data)
|
|
{
|
|
MemoryStream ms = new MemoryStream(Convert.FromBase64String(data));
|
|
BinaryFormatter bf = new BinaryFormatter();
|
|
|
|
Image image = (Image)bf.Deserialize(ms);
|
|
|
|
return (image);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region IsNumericValue
|
|
|
|
private bool IsNumericValue(out TypeCode typeCode)
|
|
{
|
|
typeCode = Type.GetTypeCode(Value.GetType());
|
|
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Byte:
|
|
case TypeCode.Decimal:
|
|
case TypeCode.Double:
|
|
case TypeCode.Int16:
|
|
case TypeCode.Int32:
|
|
case TypeCode.Int64:
|
|
case TypeCode.SByte:
|
|
case TypeCode.Single:
|
|
case TypeCode.UInt16:
|
|
case TypeCode.UInt32:
|
|
case TypeCode.UInt64:
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetNumericValue
|
|
|
|
private object GetNumericValue(string s, TypeCode typeCode)
|
|
{
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Byte:
|
|
return (Byte.Parse(s));
|
|
|
|
case TypeCode.Decimal:
|
|
return (Decimal.Parse(s));
|
|
|
|
case TypeCode.Double:
|
|
return (Double.Parse(s));
|
|
|
|
case TypeCode.Int16:
|
|
return (Int16.Parse(s));
|
|
|
|
case TypeCode.Int32:
|
|
return (Int32.Parse(s));
|
|
|
|
case TypeCode.Int64:
|
|
return (Int64.Parse(s));
|
|
|
|
case TypeCode.SByte:
|
|
return (SByte.Parse(s));
|
|
|
|
case TypeCode.Single:
|
|
return (Single.Parse(s));
|
|
|
|
case TypeCode.UInt16:
|
|
return (UInt16.Parse(s));
|
|
|
|
case TypeCode.UInt32:
|
|
return (UInt32.Parse(s));
|
|
|
|
case TypeCode.UInt64:
|
|
return (UInt64.Parse(s));
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Interfaces
|
|
|
|
internal interface IProcessSerialElement
|
|
{
|
|
void ProcessValue(SerialElement se);
|
|
void ProcessCollection(SerialElement se);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SerElementType enum
|
|
|
|
public enum SerElementType
|
|
{
|
|
Start,
|
|
End,
|
|
|
|
ValueStart,
|
|
ValueEnd,
|
|
|
|
Value,
|
|
DataValue,
|
|
|
|
Collection,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StreamWriterNC
|
|
|
|
public class StreamWriterNC : IDisposable
|
|
{
|
|
#region Private variables
|
|
|
|
private Stream _Stream;
|
|
|
|
#endregion
|
|
|
|
public StreamWriterNC(Stream stream)
|
|
{
|
|
_Stream = stream;
|
|
|
|
stream.Position = 0;
|
|
}
|
|
|
|
#region Public properties
|
|
|
|
public Stream Stream
|
|
{
|
|
get { return (_Stream); }
|
|
internal set { _Stream = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Write
|
|
|
|
public void Write(string s)
|
|
{
|
|
byte[] bytes = new byte[s.Length * sizeof(char)];
|
|
|
|
Buffer.BlockCopy(s.ToCharArray(), 0, bytes, 0, bytes.Length);
|
|
|
|
_Stream.Write(bytes, 0, bytes.Length);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region WriteLine
|
|
|
|
public void WriteLine(string s)
|
|
{
|
|
Write(s + "\n");
|
|
}
|
|
|
|
public void WriteLine()
|
|
{
|
|
Write("\n");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Dispose
|
|
|
|
public void Dispose()
|
|
{
|
|
_Stream.Flush();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
} |