534 lines
14 KiB
C#
534 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Xml.Serialization;
|
|
using CPF.Drawing;
|
|
using CPF.ReoGrid.Drawing.Text;
|
|
|
|
namespace CPF.ReoGrid.Common
|
|
{
|
|
internal class TextFormatHelper
|
|
{
|
|
public static string EncodeRect(Rect rect)
|
|
{
|
|
return string.Format("({0},{1},{2},{3})", new object[]
|
|
{
|
|
rect.Left,
|
|
rect.Top,
|
|
rect.Width,
|
|
rect.Height
|
|
});
|
|
}
|
|
|
|
public static string EncodePadding(PaddingValue pad)
|
|
{
|
|
return string.Format("({0},{1},{2},{3})", new object[]
|
|
{
|
|
pad.Left,
|
|
pad.Top,
|
|
pad.Right,
|
|
pad.Bottom
|
|
});
|
|
}
|
|
|
|
public static string EncodeSize(Size size)
|
|
{
|
|
return string.Format("({0},{1})", size.Width, size.Height);
|
|
}
|
|
|
|
public static string EncodeColor(Color c)
|
|
{
|
|
return (c.A == byte.MaxValue) ? string.Format("#{0:x2}{1:x2}{2:x2}", c.R, c.G, c.B) : string.Format("#{0:x2}{1:x2}{2:x2}{3:x2}", new object[]
|
|
{
|
|
c.A,
|
|
c.R,
|
|
c.G,
|
|
c.B
|
|
});
|
|
}
|
|
|
|
public static string EncodeColorNoAlpha(Color c)
|
|
{
|
|
return string.Format("FF{0:x2}{1:x2}{2:x2}", c.R, c.G, c.B).ToUpper();
|
|
}
|
|
|
|
public static string EncodePoint(Point p)
|
|
{
|
|
return string.Format("({0},{1})", p.X, p.Y);
|
|
}
|
|
|
|
public static string EncodePoints(IEnumerable<Point> points)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (Point point in points)
|
|
{
|
|
bool flag = stringBuilder.Length > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append(",");
|
|
}
|
|
stringBuilder.AppendFormat("{0} {1}", point.X, point.Y);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string EncodePointsHex(IEnumerable<Point> points)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (Point point in points)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes(point.X);
|
|
byte[] bytes2 = BitConverter.GetBytes(point.Y);
|
|
stringBuilder.AppendFormat("{0:x1}{1:x1}{2:x1}{3:x1}{4:x1}{5:x1}{6:x1}{7:x1}", new object[]
|
|
{
|
|
bytes[0],
|
|
bytes[1],
|
|
bytes[2],
|
|
bytes[3],
|
|
bytes2[0],
|
|
bytes2[1],
|
|
bytes2[2],
|
|
bytes2[3]
|
|
});
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string EncodeFontStyle(CPF.ReoGrid.Drawing.Text.FontStyles fs)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
bool flag = (fs & CPF.ReoGrid.Drawing.Text.FontStyles.Bold) > CPF.ReoGrid.Drawing.Text.FontStyles.Regular;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append("blob");
|
|
}
|
|
bool flag2 = (fs & CPF.ReoGrid.Drawing.Text.FontStyles.Italic) > CPF.ReoGrid.Drawing.Text.FontStyles.Regular;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = stringBuilder.Length > 0;
|
|
if (flag3)
|
|
{
|
|
stringBuilder.Append(" ");
|
|
}
|
|
stringBuilder.Append("italic");
|
|
}
|
|
bool flag4 = (fs & CPF.ReoGrid.Drawing.Text.FontStyles.Strikethrough) > CPF.ReoGrid.Drawing.Text.FontStyles.Regular;
|
|
if (flag4)
|
|
{
|
|
bool flag5 = stringBuilder.Length > 0;
|
|
if (flag5)
|
|
{
|
|
stringBuilder.Append(" ");
|
|
}
|
|
stringBuilder.Append("strikeout");
|
|
}
|
|
bool flag6 = (fs & CPF.ReoGrid.Drawing.Text.FontStyles.Underline) > CPF.ReoGrid.Drawing.Text.FontStyles.Regular;
|
|
if (flag6)
|
|
{
|
|
bool flag7 = stringBuilder.Length > 0;
|
|
if (flag7)
|
|
{
|
|
stringBuilder.Append(" ");
|
|
}
|
|
stringBuilder.Append("underline");
|
|
}
|
|
return (stringBuilder.Length == 0) ? "normal" : stringBuilder.ToString();
|
|
}
|
|
|
|
public static string EncodeBool(bool p)
|
|
{
|
|
return p ? "true" : "false";
|
|
}
|
|
|
|
public static string EncodeBool(bool p, bool def)
|
|
{
|
|
return (p == def) ? null : TextFormatHelper.EncodeBool(p);
|
|
}
|
|
|
|
public static string EncodeFloatArray(params float[] values)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (float value in values)
|
|
{
|
|
bool flag = stringBuilder.Length > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append(",");
|
|
}
|
|
stringBuilder.Append(value);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string EncodeIntArray(IEnumerable<int> values)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (int num in values)
|
|
{
|
|
float value = (float)num;
|
|
bool flag = stringBuilder.Length > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append(",");
|
|
}
|
|
stringBuilder.Append(value);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static Guid DecodeGuid(string data)
|
|
{
|
|
Guid result;
|
|
try
|
|
{
|
|
result = new Guid(data);
|
|
}
|
|
catch
|
|
{
|
|
result = Guid.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static Rect DecodeRect(string data)
|
|
{
|
|
Match match = TextFormatHelper.RectRegex.Match(data);
|
|
bool success = match.Success;
|
|
Rect result;
|
|
if (success)
|
|
{
|
|
float num = (float)TextFormatHelper.GetPixelValue(match.Groups[1].Value);
|
|
float num2 = (float)TextFormatHelper.GetPixelValue(match.Groups[2].Value);
|
|
float num3 = (float)TextFormatHelper.GetPixelValue(match.Groups[3].Value);
|
|
float num4 = (float)TextFormatHelper.GetPixelValue(match.Groups[4].Value);
|
|
result = new Rect(ref num, ref num2, ref num3, ref num4);
|
|
}
|
|
else
|
|
{
|
|
result = default(Rect);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static PaddingValue DecodePadding(string data)
|
|
{
|
|
Rect rect = TextFormatHelper.DecodeRect(data);
|
|
return new PaddingValue((float)((int)rect.Left), (float)((int)rect.Top), (float)((int)rect.Width), (float)((int)rect.Height));
|
|
}
|
|
|
|
public static Size DecodeSize(string data)
|
|
{
|
|
Point point = TextFormatHelper.DecodePoint(data);
|
|
float x = point.X;
|
|
float y = point.Y;
|
|
return new Size(ref x, ref y);
|
|
}
|
|
|
|
public static bool IsWebColorFormat(string data)
|
|
{
|
|
return TextFormatHelper.WebColorRegex.IsMatch(data);
|
|
}
|
|
|
|
public static bool DecodeColor(string data, out Color color)
|
|
{
|
|
bool flag = !string.IsNullOrEmpty(data) && !data.Equals("none", StringComparison.InvariantCultureIgnoreCase);
|
|
if (flag)
|
|
{
|
|
Match match = TextFormatHelper.WebColorRegex.Match(data);
|
|
bool success = match.Success;
|
|
if (success)
|
|
{
|
|
color = Color.FromArgb((match.Groups[1].Value.Length > 0) ? Convert.ToByte(match.Groups[1].Value, 16) : byte.MaxValue, Convert.ToByte(match.Groups[2].Value, 16), Convert.ToByte(match.Groups[3].Value, 16), Convert.ToByte(match.Groups[4].Value, 16));
|
|
return true;
|
|
}
|
|
try
|
|
{
|
|
color = (Color)ColorConverter.ConvertFromString(data);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
color = default(Color);
|
|
return false;
|
|
}
|
|
|
|
public static bool IsRectFormat(string data)
|
|
{
|
|
return TextFormatHelper.RectRegex.IsMatch(data);
|
|
}
|
|
|
|
public static Point DecodePoint(string data)
|
|
{
|
|
Match match = TextFormatHelper.PointRegex.Match(data);
|
|
bool success = match.Success;
|
|
Point result;
|
|
if (success)
|
|
{
|
|
float num = (float)TextFormatHelper.GetPixelValue(match.Groups[1].Value);
|
|
float num2 = (float)TextFormatHelper.GetPixelValue(match.Groups[2].Value);
|
|
result = new Point(ref num, ref num2);
|
|
}
|
|
else
|
|
{
|
|
float num = 0f;
|
|
float num2 = 0f;
|
|
result = new Point(ref num, ref num2);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static List<Point> DecodePoints(string data)
|
|
{
|
|
List<Point> list = new List<Point>(5);
|
|
foreach (object obj in TextFormatHelper.pointArrayRegex.Matches(data))
|
|
{
|
|
Match match = (Match)obj;
|
|
List<Point> list2 = list;
|
|
float floatPixelValue = TextFormatHelper.GetFloatPixelValue(match.Groups[1].Value, 0f);
|
|
float floatPixelValue2 = TextFormatHelper.GetFloatPixelValue(match.Groups[2].Value, 0f);
|
|
list2.Add(new Point(ref floatPixelValue, ref floatPixelValue2));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static float[] DecodeFloatArray(string str)
|
|
{
|
|
string[] array = str.Split(new char[]
|
|
{
|
|
','
|
|
});
|
|
float[] array2 = new float[array.Length];
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
try
|
|
{
|
|
float num;
|
|
float.TryParse(array[i], out num);
|
|
array2[i] = num;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
return array2;
|
|
}
|
|
|
|
public static int[] DecodeIntArray(string str)
|
|
{
|
|
string[] array = str.Split(new char[]
|
|
{
|
|
','
|
|
});
|
|
int[] array2 = new int[array.Length];
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
try
|
|
{
|
|
int num;
|
|
int.TryParse(array[i], out num);
|
|
array2[i] = num;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
return array2;
|
|
}
|
|
|
|
public static float GetFloatValue(string str, float def)
|
|
{
|
|
float.TryParse(str, out def);
|
|
return def;
|
|
}
|
|
|
|
public static float GetFloatValue(string str, float def, CultureInfo culture)
|
|
{
|
|
float.TryParse(str, NumberStyles.Any, culture, out def);
|
|
return def;
|
|
}
|
|
|
|
public static float GetFloatPixelValue(string str, float def)
|
|
{
|
|
return TextFormatHelper.GetFloatPixelValue(str, def, CultureInfo.CurrentCulture);
|
|
}
|
|
|
|
public static float GetFloatPixelValue(string str, float def, CultureInfo culture)
|
|
{
|
|
bool flag = str == null;
|
|
float result;
|
|
if (flag)
|
|
{
|
|
result = def;
|
|
}
|
|
else
|
|
{
|
|
str = str.Trim();
|
|
bool flag2 = str.EndsWith("px");
|
|
if (flag2)
|
|
{
|
|
str = str.Substring(0, str.Length - 2).Trim();
|
|
}
|
|
float num;
|
|
float.TryParse(str, NumberStyles.Any, culture, out num);
|
|
result = num;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static int GetPixelValue(string str)
|
|
{
|
|
return TextFormatHelper.GetPixelValue(str, 0);
|
|
}
|
|
|
|
public static int GetPixelValue(string str, CultureInfo culture)
|
|
{
|
|
return TextFormatHelper.GetPixelValue(str, 0, culture);
|
|
}
|
|
|
|
public static int GetPixelValue(string str, int def)
|
|
{
|
|
return (int)TextFormatHelper.GetFloatPixelValue(str, (float)def, CultureInfo.CurrentCulture);
|
|
}
|
|
|
|
public static int GetPixelValue(string str, int def, CultureInfo culture)
|
|
{
|
|
return (int)TextFormatHelper.GetFloatPixelValue(str, (float)def, culture);
|
|
}
|
|
|
|
public static float GetPercentValue(string str, float def)
|
|
{
|
|
bool flag = string.IsNullOrEmpty(str);
|
|
float result;
|
|
if (flag)
|
|
{
|
|
result = def;
|
|
}
|
|
else
|
|
{
|
|
string str2 = str.Substring(0, str.Length - 1).Trim();
|
|
result = TextFormatHelper.GetFloatValue(str2, def) / 100f;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static void ParseDataAttribute(string attr, Action<string, string> a)
|
|
{
|
|
bool flag = attr != null;
|
|
if (flag)
|
|
{
|
|
foreach (object obj in TextFormatHelper.AttrRegex.Matches(attr))
|
|
{
|
|
Match match = (Match)obj;
|
|
string value = match.Groups[1].Value;
|
|
string arg = (match.Groups[5].Value != null && match.Groups[5].Length > 0) ? match.Groups[5].Value : match.Groups[4].Value;
|
|
a(value, arg);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static T CreateElementFromAttribute<T>(T obj, string attr) where T : new()
|
|
{
|
|
T t = (obj == null) ? Activator.CreateInstance<T>() : obj;
|
|
TextFormatHelper.ParseDataAttribute(attr, delegate(string key, string value)
|
|
{
|
|
bool flag = key.Length > 0 && value != null;
|
|
if (flag)
|
|
{
|
|
FieldInfo field = t.GetType().GetField(key);
|
|
bool flag2 = field != null;
|
|
if (flag2)
|
|
{
|
|
field.SetValue(t, value);
|
|
}
|
|
else
|
|
{
|
|
key = key.Substring(0, 1).ToUpper() + key.Substring(1);
|
|
PropertyInfo propertyInfo = t.GetType().GetProperty(key);
|
|
bool flag3 = propertyInfo == null;
|
|
if (flag3)
|
|
{
|
|
propertyInfo = t.GetType().GetProperties().FirstOrDefault(delegate(PropertyInfo p)
|
|
{
|
|
XmlAttributeAttribute[] array = p.GetCustomAttributes(typeof(XmlAttributeAttribute), true) as XmlAttributeAttribute[];
|
|
return array != null && array.Length != 0 && array[0] != null && array[0].AttributeName.ToLower().Equals(key.ToLower());
|
|
});
|
|
}
|
|
bool flag4 = propertyInfo != null;
|
|
if (flag4)
|
|
{
|
|
propertyInfo.SetValue(t, value, null);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return t;
|
|
}
|
|
|
|
public static string GenerateDataAttributeString(Dictionary<string, string> data)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (string text in data.Keys)
|
|
{
|
|
bool flag = stringBuilder.Length > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append("; ");
|
|
}
|
|
stringBuilder.Append(string.Format("{0}: {1}", text, data[text]));
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string GenerateDataAttributeString(params string[] data)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < data.Length; i += 2)
|
|
{
|
|
bool flag = stringBuilder.Length > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append(" ");
|
|
}
|
|
stringBuilder.Append(string.Format("{0}: {1};", data[i], data[i + 1]));
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static bool IsSwitchOn(string value)
|
|
{
|
|
return !string.IsNullOrEmpty(value) && (string.Equals(value, "1", StringComparison.CurrentCultureIgnoreCase) || string.Equals(value, "true", StringComparison.CurrentCultureIgnoreCase) || string.Equals(value, "yes", StringComparison.CurrentCultureIgnoreCase) || string.Equals(value, "on", StringComparison.CurrentCultureIgnoreCase));
|
|
}
|
|
|
|
public static T LoadXml<T>(string filepath)
|
|
{
|
|
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
|
|
T result;
|
|
using (FileStream fileStream = new FileStream(filepath, FileMode.Open))
|
|
{
|
|
T t = (T)((object)xmlSerializer.Deserialize(fileStream));
|
|
result = t;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static readonly Regex RectRegex = new Regex("\\(\\s*([-\\w.]+)\\s*,\\s*([-\\w.]+)\\s*,\\s*([-\\w.]+)\\s*,\\s*([-\\w.]+)\\)\\s*");
|
|
|
|
public static readonly Regex WebColorRegex = new Regex("\\#?([0-9a-fA-F]{2})?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})");
|
|
|
|
public static readonly Regex PointRegex = new Regex("\\(\\s*([-\\w.]+)\\s*,\\s*([-\\w.]+)\\)\\s*");
|
|
|
|
public static readonly Regex pointArrayRegex = new Regex("(\\d*\\.?\\d+)\\s(\\d*\\.?\\d+)");
|
|
|
|
public static readonly Regex PathDataRegex = new Regex("(\\w?)\\(([-?\\d+,?]+)\\),?");
|
|
|
|
public static readonly Regex AttrRegex = new Regex("\\s*([-_\\w.]+)\\s*:\\s*((\\'([^\\']*)\\')|([^;]*))\\s*;?");
|
|
}
|
|
}
|