/// <summary>
        /// Convert displayed or input value into value stored in XML
        /// </summary>
        /// <param name="value">Displayed or input value</param>
        public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = value;
            int    tmp;

            if (string.IsNullOrWhiteSpace(result))
            {
                return(null);
            }

            if (Helper.IntTryParse(result, out tmp))
            {
                return(result);
            }
            result = result.Replace("[", "").Replace(" ", "");
            if (result.IndexOf("]") == -1)
            {
                return(null);
            }
            result = result.Substring(0, result.IndexOf("]"));
            if (Helper.IntTryParse(result, out tmp))
            {
                return(result);
            }

            return(null);
        }
        /// <summary>
        /// Convert displayed or input value into value stored in XML
        /// </summary>
        /// <param name="value">Displayed or input value</param>
        public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = base.ValueToXml(value, type, min, max);

            if (result != value)
            {
                return(result);
            }
            return(value);
        }
 /// <summary>
 /// Convert inner value into displayed value
 /// </summary>
 /// <param name="value">Inner value</param>
 public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
 {
     if (string.IsNullOrWhiteSpace(value))
     {
         return(value);
     }
     if (!VesselData.Current.VesselList.ContainsKey(value))
     {
         return("[" + value + "] Vessel does not exist");
     }
     return(VesselData.Current.VesselToString(value));
 }
        /// <summary>
        /// Convert XML value to display value
        /// </summary>
        /// <param name="value">Value from XML</param>
        /// <param name="type">Value type</param>
        /// <param name="min">Min limit</param>
        /// <param name="max">Max limit</param>
        public virtual string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            switch (type)
            {
            case ExpressionMemberValueType.VarBool:
                int tmpBool;
                if (value == null)
                {
                    break;
                }
                if (!Helper.IntTryParse(value, out tmpBool))
                {
                    tmpBool = 0;
                }
                if (min != null && max != null)
                {
                    value = tmpBool != 0 ? max.ToString() : min.ToString();
                }
                else
                {
                    value = tmpBool != 0 ? "true" : "false";
                }
                break;

            case ExpressionMemberValueType.VarInteger:
                break;

            case ExpressionMemberValueType.VarDouble:
                break;

            case ExpressionMemberValueType.VarString:
                break;

            case ExpressionMemberValueType.Body:
                break;

            default:
                break;
            }

            if (value == null)
            {
                return(value);
            }
            if (XmlValueToDisplay.ContainsKey(value))
            {
                return(XmlValueToDisplay[value]);
            }
            else
            {
                return(value);
            }
        }
        /// <summary>
        /// Convert display or input value to XML value
        /// </summary>
        /// <param name="value">Value from XML</param>
        /// <param name="type">Value type</param>
        /// <param name="min">Min limit</param>
        /// <param name="max">Max limit</param>
        public virtual string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
        {
            switch (type)
            {
            case ExpressionMemberValueType.VarBool:
                if (value == "Default")
                {
                    value = null;
                }
                if ((min != null && value == min.ToString()) || (min == null && value == "false"))
                {
                    value = "0";
                }
                if ((max != null && value == max.ToString()) || (max == null && value == "true"))
                {
                    value = "1";
                }
                break;

            case ExpressionMemberValueType.VarInteger:
                break;

            case ExpressionMemberValueType.VarDouble:
                break;

            case ExpressionMemberValueType.VarString:
                break;

            case ExpressionMemberValueType.Body:
                break;

            default:
                break;
            }

            if (value == null)
            {
                return(value);
            }
            if (MenuValueToXml.ContainsKey(value))
            {
                return(MenuValueToXml[value]);
            }
            if (DisplayValueToXml.ContainsKey(value))
            {
                return(DisplayValueToXml[value]);
            }
            else
            {
                return(value);
            }
        }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = "";

            if (value == null)
            {
                return("None");
            }

            value = value.ToLower();

            if (value.Contains('m'))
            {
                result += "Msc ";
            }
            if (value.Contains('h'))
            {
                result += "Hlm ";
            }
            if (value.Contains('w'))
            {
                result += "Wep ";
            }
            if (value.Contains('e'))
            {
                result += "Eng ";
            }
            if (value.Contains('s'))
            {
                result += "Sci ";
            }
            if (value.Contains('c'))
            {
                result += "Com ";
            }
            if (value.Contains('o'))
            {
                result += "Obs ";
            }

            if (result.Length > 0)
            {
                return(result.Substring(0, result.Length - 1));
            }
            else
            {
                return("None");
            }
        }
 public ExpressionMemberValueDescription(ExpressionMemberValueType type,
                                         ExpressionMemberValueBehaviorInXml behavior, ExpressionMemberValueEditor editor,
                                         object min           = null, object max      = null,
                                         string quoteLeft     = "", string quoteRight = " ",
                                         string defaultIfNull = null)
 {
     Type          = type;
     BehaviorInXml = behavior;
     Editor        = editor;
     Min           = min;
     Max           = max;
     QuoteLeft     = quoteLeft;
     QuoteRight    = quoteRight;
     DefaultIfNull = defaultIfNull;
 }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = base.ValueToDisplay(value, type, min, max);

            if (result != value)
            {
                return(result);
            }
            double tmp;

            Helper.DoubleTryParse(value, out tmp);
            value = Helper.DoubleToPercent(tmp);

            return(value);
        }
        /// <summary>
        /// Convert displayed or input value into value stored in XML
        /// </summary>
        /// <param name="value">Displayed or input value</param>
        public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = base.ValueToXml(value, type, min, max);

            if (result != value)
            {
                return(result);
            }
            if (string.IsNullOrWhiteSpace(value))
            {
                return(null);
            }
            value = value.ToLower();
            value = value.Replace(' ', '_');
            return(value);
        }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = base.ValueToDisplay(value, type, min, max);

            if (result != value)
            {
                return(result);
            }
            //Prevent empty entry from appearing in the menu or in text representation of the node
            if (string.IsNullOrWhiteSpace(value))
            {
                return(null);
            }
            value = value.Replace('_', ' ');
            value = value.Substring(0, 1).ToUpper() + value.Substring(1, value.Length - 1);

            return(value);
        }
 /// <summary>
 /// Convert displayed or input value into value stored in Xml
 /// </summary>
 /// <param name="value">Displayed or input value</param>
 public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
 {
     string result = base.ValueToXml(value, type, min, max);
     if (result != value)
         return result;
     if (string.IsNullOrWhiteSpace(value))
         return null;
     value = value.ToLower();
     value = value.Replace(' ', '_');
     return value;
 }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = base.ValueToDisplay(value, type, min, max);
            if (result != value)
                return result;
            //Prevent empty entry from appearing in the menu or in text representation of the node
            if (string.IsNullOrWhiteSpace(value))
                return null;
            value = value.Replace('_', ' ');
            value = value.Substring(0, 1).ToUpper() + value.Substring(1, value.Length - 1);

            return value;
        }
 /// <summary>
 /// Convert displayed or input value into value stored in Xml
 /// </summary>
 /// <param name="value">Displayed or input value</param>
 public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
 {
     string result = base.ValueToXml(value, type, min, max);
     if (result != value)
         return result;
     return value;
 }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = base.ValueToDisplay(value, type, min, max);
            if (result != value)
                return result;
            double tmp;
            Helper.DoubleTryParse(value, out tmp);
            value = Helper.DoubleToPercent(tmp);

            return value;
        }
        /// <summary>
        /// Convert displayed or input value into value stored in Xml
        /// </summary>
        /// <param name="value">Displayed or input value</param>
        public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = value;
            int tmp;

            if (string.IsNullOrWhiteSpace(result))
                return null;

            if (Helper.IntTryParse(result, out tmp))
                return result;
            result = result.Replace("[", "").Replace(" ", "");
            if (result.IndexOf("]") == -1)
                return null;
            result = result.Substring(0, result.IndexOf("]"));
            if (Helper.IntTryParse(result, out tmp))
                return result;

            return null;
        }
 /// <summary>
 /// Convert inner value into displayed value
 /// </summary>
 /// <param name="value">Inner value</param>
 public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
 {
     if (string.IsNullOrWhiteSpace(value))
         return value;
     if (!VesselData.Current.VesselList.ContainsKey(value))
         return "[" + value + "] Vessel does not exist";
     return VesselData.Current.VesselToString(value);
 }
 /// <summary>
 /// Convert displayed or input value into value stored in Xml
 /// </summary>
 /// <param name="value">Displayed or input value</param>
 public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
 {
     return value;
 }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = "";

            if (value == null)
                return "None";

            value = value.ToLower();

            if (value.Contains('m'))
                result += "Msc ";
            if (value.Contains('h'))
                result += "Hlm ";
            if (value.Contains('w'))
                result += "Wep ";
            if (value.Contains('e'))
                result += "Eng ";
            if (value.Contains('s'))
                result += "Sci ";
            if (value.Contains('c'))
                result += "Com ";
            if (value.Contains('o'))
                result += "Obs ";

            if (result.Length > 0)
                return result.Substring(0, result.Length - 1);
            else
                return "None";
        }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = "";

            if (value == null || !Helper.IntTryParse(value))
                return "[NO]";

            int bits = Helper.StringToInt(value);

            if ((bits & 1) == 1) result += "[INV-MS] ";
            if ((bits & 2) == 2) result += "[INV-LRS/TAC] ";
            if ((bits & 4) == 4) result += "[CLOAK] ";
            if ((bits & 8) == 8) result += "[HET] ";
            if ((bits & 16) == 16) result += "[WARP] ";
            if ((bits & 32) == 32) result += "[TELEPORT] ";
            if ((bits & 64) == 64) result += "[TRACTOR] ";
            if ((bits & 128) == 128) result += "[DRONE] ";
            if ((bits & 256) == 256) result += "[ANTI-MINE] ";
            if ((bits & 512) == 512) result += "[ANTI-TORP] ";
            if ((bits & 1024) == 1024) result += "[ANTI-SHLD] ";

            if (result.Length > 0)
                return result.Substring(0, result.Length - 1);
            else
                return "[NO]";
        }
        /// <summary>
        /// Convert display or input value to Xml value
        /// </summary>
        /// <param name="value">Value from Xml</param>
        /// <param name="type">Value type</param>
        /// <param name="min">Min limit</param>
        /// <param name="max">Max limit</param>
        public virtual string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
        {
            switch (type)
            {
                case ExpressionMemberValueType.VarBool:
                    if ((min != null && value == min.ToString()) || (min == null && value == "false"))
                        value = "0";
                    if ((max != null && value == max.ToString()) || (max == null && value == "true"))
                        value = "1";
                    break;
                case ExpressionMemberValueType.VarInteger:
                    break;
                case ExpressionMemberValueType.VarDouble:
                    break;
                case ExpressionMemberValueType.VarString:
                    break;
                case ExpressionMemberValueType.Body:
                    break;
                default:
                    break;
            }

            if (value == null)
                return value;
            if (MenuValueToXml.ContainsKey(value))
                return MenuValueToXml[value];
            if (DisplayValueToXml.ContainsKey(value))
                return DisplayValueToXml[value];
            else
                return value;
        }
        /// <summary>
        /// Convert inner value into displayed value
        /// </summary>
        /// <param name="value">Inner value</param>
        public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            string result = "";

            if (value == null || !Helper.IntTryParse(value))
            {
                return("[NO]");
            }

            int bits = Helper.StringToInt(value);

            if ((bits & 1) == 1)
            {
                result += "[INV-MS] ";
            }
            if ((bits & 2) == 2)
            {
                result += "[INV-LRS/TAC] ";
            }
            if ((bits & 4) == 4)
            {
                result += "[CLOAK] ";
            }
            if ((bits & 8) == 8)
            {
                result += "[HET] ";
            }
            if ((bits & 16) == 16)
            {
                result += "[WARP] ";
            }
            if ((bits & 32) == 32)
            {
                result += "[TELEPORT] ";
            }
            if ((bits & 64) == 64)
            {
                result += "[TRACTOR] ";
            }
            if ((bits & 128) == 128)
            {
                result += "[DRONE] ";
            }
            if ((bits & 256) == 256)
            {
                result += "[ANTI-MINE] ";
            }
            if ((bits & 512) == 512)
            {
                result += "[ANTI-TORP] ";
            }
            if ((bits & 1024) == 1024)
            {
                result += "[ANTI-SHLD] ";
            }

            if (result.Length > 0)
            {
                return(result.Substring(0, result.Length - 1));
            }
            else
            {
                return("[NO]");
            }
        }
 /// <summary>
 /// Convert inner value into displayed value
 /// </summary>
 /// <param name="value">Inner value</param>
 public override string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
 {
     return(value ?? "None");
 }
 /// <summary>
 /// Convert displayed or input value into value stored in XML
 /// </summary>
 /// <param name="value">Displayed or input value</param>
 public override string ValueToXml(string value, ExpressionMemberValueType type, object min, object max)
 {
     return(value);
 }
 public ExpressionMemberValueDescription(ExpressionMemberValueType type, 
     ExpressionMemberValueBehaviorInXml behavior, ExpressionMemberValueEditor editor, 
     object min = null, object max = null, 
     string quoteLeft = "", string quoteRight = " ", 
     string defaultIfNull = null)
 {
     Type			= type;
     BehaviorInXml	= behavior;
     Editor			= editor;
     Min				= min;
     Max				= max;
     QuoteLeft		= quoteLeft;
     QuoteRight		= quoteRight;
     DefaultIfNull	= defaultIfNull;
 }
        /// <summary>
        /// Convert Xml value to display value
        /// </summary>
        /// <param name="value">Value from Xml</param>
        /// <param name="type">Value type</param>
        /// <param name="min">Min limit</param>
        /// <param name="max">Max limit</param>
        public virtual string ValueToDisplay(string value, ExpressionMemberValueType type, object min, object max)
        {
            switch (type)
            {
                case ExpressionMemberValueType.VarBool:
                    int tmpBool;
                    if (!Helper.IntTryParse(value, out tmpBool))
                        tmpBool = 0;
                    if (min != null && max != null)
                        value = tmpBool != 0 ? max.ToString() : min.ToString();
                    else
                        value = tmpBool != 0 ? "true" : "false";
                    break;
                case ExpressionMemberValueType.VarInteger:
                    break;
                case ExpressionMemberValueType.VarDouble:
                    break;
                case ExpressionMemberValueType.VarString:
                    break;
                case ExpressionMemberValueType.Body:
                    break;
                default:
                    break;
            }

            if (value == null)
                return value;
            if (XmlValueToDisplay.ContainsKey(value))
                return XmlValueToDisplay[value];
            else
                return value;
        }