468 lines
16 KiB
C#
468 lines
16 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Text.RegularExpressions;
|
|
using System.Windows.Forms;
|
|
|
|
using System.IO;
|
|
|
|
|
|
namespace PluginCommon
|
|
{
|
|
// Useful types for log functions
|
|
public delegate void LogStringDelegate(string _msg);
|
|
public delegate void LogErrorAndMessageDelegate(bool _error, string _msg);
|
|
|
|
public class CommandLineArgs
|
|
{
|
|
protected Dictionary<string, string> mapArgs = null;
|
|
|
|
public bool find(string key)
|
|
{
|
|
return mapArgs != null && mapArgs.ContainsKey(key.ToLower());
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string fullArgs = "";
|
|
if (mapArgs != null)
|
|
{
|
|
foreach (var arg in mapArgs)
|
|
{
|
|
fullArgs += arg.Key;
|
|
fullArgs += "=";
|
|
fullArgs += arg.Value;
|
|
fullArgs += ";";
|
|
}
|
|
}
|
|
|
|
return fullArgs;
|
|
}
|
|
|
|
|
|
public bool getBoolValue(string key,bool _default)
|
|
{
|
|
string lowerKey = key.ToLower();
|
|
if (mapArgs != null && mapArgs.ContainsKey(lowerKey))
|
|
return (mapArgs[lowerKey].ToLower() == "true");
|
|
|
|
return _default;
|
|
}
|
|
|
|
public string getStringValue(string key, string _default = null)
|
|
{
|
|
string lowerKey = key.ToLower();
|
|
if (mapArgs != null && mapArgs.ContainsKey(lowerKey))
|
|
return mapArgs[lowerKey];
|
|
|
|
return _default;
|
|
}
|
|
|
|
public int getIntValue(string key, int _default)
|
|
{
|
|
string lowerKey = key.ToLower();
|
|
if (mapArgs != null && mapArgs.ContainsKey(lowerKey))
|
|
return int.Parse(mapArgs[lowerKey]);
|
|
|
|
return _default;
|
|
}
|
|
|
|
public uint getUIntValue(string key, uint _default)
|
|
{
|
|
string lowerKey = key.ToLower();
|
|
if (mapArgs != null && mapArgs.ContainsKey(lowerKey))
|
|
return uint.Parse(mapArgs[lowerKey]);
|
|
|
|
return _default;
|
|
}
|
|
|
|
public double getDoubleValue(string key, double _default)
|
|
{
|
|
string lowerKey = key.ToLower();
|
|
if (mapArgs != null && mapArgs.ContainsKey(lowerKey))
|
|
return double.Parse(mapArgs[lowerKey], System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
|
|
|
|
return _default;
|
|
}
|
|
|
|
public void append(string args)
|
|
{
|
|
string[] arglist = args.Split(';');
|
|
generateFromArgList(ref arglist);
|
|
}
|
|
|
|
public void append(string[] args)
|
|
{
|
|
//assume this list is not splitted
|
|
if (args.Length > 0)
|
|
{
|
|
string[] arglist = args[0].Split(';');
|
|
generateFromArgList(ref arglist);
|
|
}
|
|
}
|
|
|
|
public CommandLineArgs(string[] args)
|
|
{
|
|
if (args.Length > 0)
|
|
{
|
|
mapArgs = new Dictionary<string, string>();
|
|
string[] arglist = args[0].Split(';');
|
|
generateFromArgList(ref arglist);
|
|
}
|
|
}
|
|
|
|
public CommandLineArgs()
|
|
{
|
|
mapArgs = new Dictionary<string, string>();
|
|
}
|
|
|
|
|
|
protected void generateFromArgList(ref string[] _arglist)
|
|
{
|
|
foreach (string arg in _arglist)
|
|
{
|
|
if (arg != "")
|
|
{
|
|
int index = arg.LastIndexOf('=');
|
|
if (index != -1)
|
|
{
|
|
int startPos = index + 1;
|
|
string key = arg.Substring(0, index);
|
|
string value = arg.Substring(startPos);
|
|
|
|
mapArgs[key.ToLower()] = value;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class EngineSettings
|
|
{
|
|
public EngineSettings()
|
|
{
|
|
Port = 1001;
|
|
ClientRectangle = new Rectangle(0, 0, 0, 0);
|
|
}
|
|
|
|
public EngineSettings(CommandLineArgs args)
|
|
{
|
|
Port = args.getIntValue("port", 1001);
|
|
|
|
Rectangle rect = new Rectangle();
|
|
rect.X = args.getIntValue("x", 0);
|
|
rect.Y = args.getIntValue("y", 0);
|
|
rect.Width = args.getIntValue("width", 0);
|
|
rect.Height = args.getIntValue("height", 0);
|
|
ClientRectangle = rect;
|
|
|
|
WorkingDirectory = args.getStringValue("workingdirectory");
|
|
}
|
|
|
|
public void applyToForm(Form _form)
|
|
{
|
|
_form.StartPosition = FormStartPosition.Manual;
|
|
_form.ClientSize = new Size(ClientRectangle.Width, ClientRectangle.Height);
|
|
_form.Location = new Point(ClientRectangle.X, ClientRectangle.Y);
|
|
|
|
}
|
|
|
|
public void applyCurrentDirectory()
|
|
{
|
|
if (WorkingDirectory != "")
|
|
{
|
|
String dir;
|
|
if (WorkingDirectory == "@self")
|
|
{
|
|
dir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase);
|
|
dir = dir.Replace("file:\\","");
|
|
}
|
|
else
|
|
{
|
|
dir = WorkingDirectory;
|
|
}
|
|
|
|
if (dir != null)
|
|
Directory.SetCurrentDirectory(dir);
|
|
}
|
|
|
|
}
|
|
|
|
public bool isClientRectValid()
|
|
{
|
|
return !(ClientRectangle.X == 0 && ClientRectangle.Y == 0 && ClientRectangle.Width == 0 && ClientRectangle.Height == 0);
|
|
}
|
|
|
|
public int Port { get; protected set; }
|
|
public Rectangle ClientRectangle { get; protected set; }
|
|
public string WorkingDirectory { get; protected set; }
|
|
}
|
|
|
|
public class Keyboard
|
|
{
|
|
#region Key_to_KeyITF
|
|
public static int Key_To_KeyITF(Keys _key)
|
|
{
|
|
if ((int)_key < 27) return (int)_key;
|
|
|
|
switch (_key)
|
|
{
|
|
case Keys.Clear: return (int)KeyCodeITF.KEY_DEL; /*break;*/
|
|
case Keys.Return: return (int)KeyCodeITF.KEY_ENTER; /*break;*/
|
|
case Keys.Shift: return (int)KeyCodeITF.KEY_SPECIAL; /*break;*/
|
|
case Keys.Control: return (int)KeyCodeITF.KEY_SPECIAL; /*break;*/
|
|
|
|
case Keys.LShiftKey: return (int)KeyCodeITF.KEY_LSHIFT; /*break;*/
|
|
case Keys.RShiftKey: return (int)KeyCodeITF.KEY_RSHIFT; /*break;*/
|
|
case Keys.LControlKey: return (int)KeyCodeITF.KEY_LCTRL; /*break;*/
|
|
case Keys.RControlKey: return (int)KeyCodeITF.KEY_RCTRL; /*break;*/
|
|
case Keys.LMenu: return (int)KeyCodeITF.KEY_LALT; /*break;*/
|
|
case Keys.RMenu: return (int)KeyCodeITF.KEY_RALT; /*break;*/
|
|
|
|
case Keys.Escape: return (int)KeyCodeITF.KEY_ESC; /*break;*/
|
|
|
|
case Keys.Space: return (int)KeyCodeITF.KEY_SPACE; /*break;*/
|
|
case Keys.Prior: return (int)KeyCodeITF.KEY_PAGEDOWN; /*break;*/
|
|
case Keys.Next: return (int)KeyCodeITF.KEY_PAGEUP; /*break;*/
|
|
case Keys.End: return (int)KeyCodeITF.KEY_END; /*break;*/
|
|
case Keys.Home: return (int)KeyCodeITF.KEY_HOME; /*break;*/
|
|
case Keys.Left: return (int)KeyCodeITF.KEY_LEFT; /*break;*/
|
|
case Keys.Up: return (int)KeyCodeITF.KEY_UP; /*break;*/
|
|
case Keys.Right: return (int)KeyCodeITF.KEY_RIGHT; /*break;*/
|
|
case Keys.Down: return (int)KeyCodeITF.KEY_DOWN; /*break;*/
|
|
|
|
case Keys.NumPad0: return (int)KeyCodeITF.KEY_KP_0; /*break;*/
|
|
case Keys.NumPad1: return (int)KeyCodeITF.KEY_KP_1; /*break;*/
|
|
case Keys.NumPad2: return (int)KeyCodeITF.KEY_KP_2; /*break;*/
|
|
case Keys.NumPad3: return (int)KeyCodeITF.KEY_KP_3; /*break;*/
|
|
case Keys.NumPad4: return (int)KeyCodeITF.KEY_KP_4; /*break;*/
|
|
case Keys.NumPad5: return (int)KeyCodeITF.KEY_KP_5; /*break;*/
|
|
case Keys.NumPad6: return (int)KeyCodeITF.KEY_KP_6; /*break;*/
|
|
case Keys.NumPad7: return (int)KeyCodeITF.KEY_KP_7; /*break;*/
|
|
case Keys.NumPad8: return (int)KeyCodeITF.KEY_KP_8; /*break;*/
|
|
case Keys.NumPad9: return (int)KeyCodeITF.KEY_KP_9; /*break;*/
|
|
case Keys.Multiply: return (int)KeyCodeITF.KEY_KP_MULTIPLY; /*break;*/
|
|
case Keys.Add: return (int)KeyCodeITF.KEY_KP_ADD; /*break;*/
|
|
|
|
case Keys.Separator: return (int)KeyCodeITF.KEY_KP_EQUAL; /*break;*/
|
|
|
|
case Keys.Subtract: return (int)KeyCodeITF.KEY_KP_SUBTRACT; /*break;*/
|
|
case Keys.Decimal: return (int)KeyCodeITF.KEY_KP_DECIMAL; /*break;*/
|
|
case Keys.Divide: return (int)KeyCodeITF.KEY_KP_DIVIDE; /*break;*/
|
|
|
|
case Keys.F1: return (int)KeyCodeITF.KEY_F1; /*break;*/
|
|
case Keys.F2: return (int)KeyCodeITF.KEY_F2; /*break;*/
|
|
case Keys.F3: return (int)KeyCodeITF.KEY_F3; /*break;*/
|
|
case Keys.F4: return (int)KeyCodeITF.KEY_F4; /*break;*/
|
|
case Keys.F5: return (int)KeyCodeITF.KEY_F5; /*break;*/
|
|
case Keys.F6: return (int)KeyCodeITF.KEY_F6; /*break;*/
|
|
case Keys.F7: return (int)KeyCodeITF.KEY_F7; /*break;*/
|
|
case Keys.F8: return (int)KeyCodeITF.KEY_F8; /*break;*/
|
|
case Keys.F9: return (int)KeyCodeITF.KEY_F9; /*break;*/
|
|
case Keys.F10: return (int)KeyCodeITF.KEY_F10; /*break;*/
|
|
case Keys.F11: return (int)KeyCodeITF.KEY_F11; /*break;*/
|
|
case Keys.F12: return (int)KeyCodeITF.KEY_F12; /*break;*/
|
|
case Keys.F13: return (int)KeyCodeITF.KEY_F13; /*break;*/
|
|
case Keys.F14: return (int)KeyCodeITF.KEY_F14; /*break;*/
|
|
case Keys.F15: return (int)KeyCodeITF.KEY_F15; /*break;*/
|
|
case Keys.F16: return (int)KeyCodeITF.KEY_F16; /*break;*/
|
|
case Keys.F17: return (int)KeyCodeITF.KEY_F17; /*break;*/
|
|
case Keys.F18: return (int)KeyCodeITF.KEY_F18; /*break;*/
|
|
case Keys.F19: return (int)KeyCodeITF.KEY_F19; /*break;*/
|
|
case Keys.F20: return (int)KeyCodeITF.KEY_F20; /*break;*/
|
|
case Keys.F21: return (int)KeyCodeITF.KEY_F21; /*break;*/
|
|
case Keys.F22: return (int)KeyCodeITF.KEY_F22; /*break;*/
|
|
case Keys.F23: return (int)KeyCodeITF.KEY_F23; /*break;*/
|
|
case Keys.F24: return (int)KeyCodeITF.KEY_F24; /*break;*/
|
|
}
|
|
|
|
return (int)_key;
|
|
}
|
|
|
|
|
|
public enum KeyCodeITF
|
|
{
|
|
KEY_SPACE = 32,
|
|
KEY_SPECIAL = 256,
|
|
KEY_ESC,
|
|
KEY_F1,
|
|
KEY_F2,
|
|
KEY_F3,
|
|
KEY_F4,
|
|
KEY_F5,
|
|
KEY_F6,
|
|
KEY_F7,
|
|
KEY_F8,
|
|
KEY_F9,
|
|
KEY_F10,
|
|
KEY_F11,
|
|
KEY_F12,
|
|
KEY_F13,
|
|
KEY_F14,
|
|
KEY_F15,
|
|
KEY_F16,
|
|
KEY_F17,
|
|
KEY_F18,
|
|
KEY_F19,
|
|
KEY_F20,
|
|
KEY_F21,
|
|
KEY_F22,
|
|
KEY_F23,
|
|
KEY_F24,
|
|
KEY_F25,
|
|
KEY_UP,
|
|
KEY_DOWN,
|
|
KEY_LEFT,
|
|
KEY_RIGHT,
|
|
KEY_LSHIFT,
|
|
KEY_RSHIFT,
|
|
KEY_LCTRL,
|
|
KEY_RCTRL,
|
|
KEY_LALT,
|
|
KEY_RALT,
|
|
KEY_TAB,
|
|
KEY_ENTER,
|
|
KEY_BACKSPACE,
|
|
KEY_INSERT,
|
|
KEY_DEL,
|
|
KEY_PAGEUP,
|
|
KEY_PAGEDOWN,
|
|
KEY_HOME,
|
|
KEY_END,
|
|
KEY_KP_0,
|
|
KEY_KP_1,
|
|
KEY_KP_2,
|
|
KEY_KP_3,
|
|
KEY_KP_4,
|
|
KEY_KP_5,
|
|
KEY_KP_6,
|
|
KEY_KP_7,
|
|
KEY_KP_8,
|
|
KEY_KP_9,
|
|
KEY_KP_DIVIDE,
|
|
KEY_KP_MULTIPLY,
|
|
KEY_KP_SUBTRACT,
|
|
KEY_KP_ADD,
|
|
KEY_KP_DECIMAL,
|
|
KEY_KP_EQUAL,
|
|
KEY_KP_ENTER,
|
|
KEY_PRINT,
|
|
|
|
KEY_COUNT
|
|
};
|
|
#endregion
|
|
}
|
|
|
|
public class FileExtensionsString
|
|
{
|
|
|
|
public static string Delimiter
|
|
{
|
|
get { return ";"; }
|
|
}
|
|
|
|
public static string[] StringToArray(string extensionsString, string delimiter)
|
|
{
|
|
return extensionsString.
|
|
Split(delimiter.ToCharArray(), StringSplitOptions.RemoveEmptyEntries).
|
|
Select((ext) => ext.StartsWith(".") ? ext : "." + ext).ToArray();
|
|
}
|
|
|
|
public static string[] StringToArray(string extensionsString)
|
|
{
|
|
return StringToArray(extensionsString, Delimiter);
|
|
}
|
|
|
|
public static string ArrayToString(string[] extensions, string delimiter)
|
|
{
|
|
return string.Join(delimiter, extensions.Select((extension) => extension.TrimStart(Delimiter.ToCharArray())));
|
|
}
|
|
|
|
public static string ArrayToString(string[] extensions)
|
|
{
|
|
return ArrayToString(extensions, Delimiter);
|
|
}
|
|
|
|
public static string StringToFilter(string extensionsString, string delimiter)
|
|
{
|
|
string pattern = delimiter + "*";
|
|
return "*" + string.Join(pattern, StringToArray(extensionsString));
|
|
}
|
|
|
|
public static string StringToFilter(string extensionsString)
|
|
{
|
|
return StringToFilter(extensionsString, Delimiter);
|
|
}
|
|
|
|
public static string[] StringToFilterArray(string extensionsString)
|
|
{
|
|
return StringToArray(extensionsString);
|
|
}
|
|
}
|
|
|
|
public class PathUtil
|
|
{
|
|
public static string MakeRelativePath(string fromPath, string toPath)
|
|
{
|
|
if (string.IsNullOrEmpty(fromPath)) throw new ArgumentNullException("fromPath");
|
|
if (string.IsNullOrEmpty(toPath)) throw new ArgumentNullException("toPath");
|
|
|
|
const string slash = @"/";
|
|
string backSlash = Path.DirectorySeparatorChar.ToString();
|
|
char[] backSlashArray = backSlash.ToCharArray();
|
|
|
|
fromPath = fromPath.Replace(slash, backSlash);
|
|
toPath = toPath.Replace(slash, backSlash);
|
|
if (!fromPath.EndsWith(backSlash))
|
|
{
|
|
fromPath += backSlash;
|
|
}
|
|
|
|
string relativePath = toPath;
|
|
Uri fromUri = new Uri(fromPath);
|
|
Uri toUri = new Uri(toPath);
|
|
|
|
Uri relativeUri = fromUri.MakeRelativeUri(toUri);
|
|
relativePath = Uri.UnescapeDataString(relativeUri.ToString().Replace(slash, backSlash));
|
|
|
|
return relativePath;
|
|
}
|
|
|
|
public static string MakeRelative(string _fullpath, string _folder)
|
|
{
|
|
Uri fullPathUri = new Uri(Path.GetFullPath(_fullpath));
|
|
Uri folderUri = new Uri(Path.GetFullPath(_folder) + Path.DirectorySeparatorChar);
|
|
|
|
return Uri.UnescapeDataString(folderUri.MakeRelativeUri(fullPathUri).ToString());
|
|
}
|
|
|
|
}
|
|
|
|
public static class MessageUtils
|
|
{
|
|
/// <summary>
|
|
/// Indicates if the app is running silently.
|
|
/// </summary>
|
|
public static bool IsApplicationSilent { get; set; }
|
|
|
|
public static void ShowMessage(string message, string caption = "")
|
|
{
|
|
ShowMessage(null, message, caption);
|
|
}
|
|
|
|
public static void ShowMessage(IWin32Window owner, string message, string caption = "")
|
|
{
|
|
if (!IsApplicationSilent)
|
|
{
|
|
MessageBox.Show(owner, message, caption);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(message);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|