CnC_Remastered_Collection

BasicSection.cs (6859B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // The Command & Conquer Map Editor and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // The Command & Conquer Map Editor and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 using MobiusEditor.Utility;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Globalization;
 using System.Runtime.CompilerServices;
 
 namespace MobiusEditor.Model
 {
     public class BooleanTypeConverter : TypeConverter
     {
         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
         {
             return (context is MapContext) && (sourceType == typeof(string));
         }
 
         public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
         {
             return (context is MapContext) && (destinationType == typeof(string));
         }
 
         public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
         {
             if (!(value is bool boolean) || !CanConvertTo(context, destinationType))
             {
                 return null;
             }
 
             return boolean ? "1" : "0";
         }
 
         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
         {
             if (!(value is string str) || !CanConvertFrom(context, value?.GetType()))
             {
                 return null;
             }
 
             var first = (str.Length > 0) ? str.ToUpper()[0] : 0;
             return (first == 'T') || (first == 'Y') || (first == '1');
         }
     }
 
     public class PercentageTypeConverter : TypeConverter
     {
         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
         {
             return (context is MapContext) && (sourceType == typeof(string));
         }
 
         public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
         {
             return (context is MapContext) && (destinationType == typeof(string));
         }
 
         public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
         {
             if (!(value is int percent) || !CanConvertTo(context, destinationType))
             {
                 return null;
             }
 
             var mapContext = context as MapContext;
             return mapContext.FractionalPercentages ? (percent / 100M).ToString("D2") : percent.ToString();
         }
 
         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
         {
             if (!(value is string str) || !CanConvertFrom(context, value?.GetType()))
             {
                 return null;
             }
 
             var mapContext = context as MapContext;
             if (mapContext.FractionalPercentages && str.Contains("."))
             {
                 if (!decimal.TryParse(str, out decimal percent))
                 {
                     return null;
                 }
                 return (int)(percent * 100);
             }
             else
             {
                 if (!int.TryParse(str, out int percent))
                 {
                     return null;
                 }
                 return percent;
             }
         }
     }
 
     public class BasicSection : INotifyPropertyChanged
     {
         public event PropertyChangedEventHandler PropertyChanged;
 
         private string name;
         [DefaultValue(null)]
         public string Name { get => name; set => SetField(ref name, value); }
 
         private int carryOverCap;
         [TypeConverter(typeof(PercentageTypeConverter))]
         [DefaultValue(-1)]
         public int CarryOverCap { get => carryOverCap; set => SetField(ref carryOverCap, value); }
 
         private int carryOverMoney;
         [TypeConverter(typeof(PercentageTypeConverter))]
         [DefaultValue(100)]
         public int CarryOverMoney { get => carryOverMoney; set => SetField(ref carryOverMoney, value); }
 
         private string intro;
         [DefaultValue(null)]
         public string Intro { get => intro; set => SetField(ref intro, value); }
 
         private string theme;
         [DefaultValue("No Theme")]
         public string Theme { get => theme; set => SetField(ref theme, value); }
 
         private int percent;
         [TypeConverter(typeof(PercentageTypeConverter))]
         [DefaultValue(100)]
         public int Percent { get => percent; set => SetField(ref percent, value); }
 
         public string player;
         [DefaultValue(null)]
         public string Player { get => player; set => SetField(ref player, value); }
 
         private string action;
         [DefaultValue("x")]
         public string Action { get => action; set => SetField(ref action, value); }
 
         private string lose;
         [DefaultValue("x")]
         public string Lose { get => lose; set => SetField(ref lose, value); }
 
         private string win;
         [DefaultValue("x")]
         public string Win { get => win; set => SetField(ref win, value); }
 
         private string brief;
         [DefaultValue("x")]
         public string Brief { get => brief; set => SetField(ref brief, value); }
 
         private string author;
         [DefaultValue(null)]
         public string Author { get => author; set => SetField(ref author, value); }
 
         private string basePlayer;
         [NonSerializedINIKey]
         [DefaultValue(null)]
         public string BasePlayer { get => basePlayer; set => SetField(ref basePlayer, value); }
 
         private bool soloMission;
         [DefaultValue(false)]
         public bool SoloMission { get => soloMission; set => SetField(ref soloMission, value); }
 
         protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
         {
             if (EqualityComparer<T>.Default.Equals(field, value))
             {
                 return false;
             }
             field = value;
             OnPropertyChanged(propertyName);
             return true;
         }
 
         protected void OnPropertyChanged(string propertyName) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
 }