Make AutoCommands suck less.

Throw away xaml UI and just use a property grid.

Essentials/AutoCommand.cs

@@ -9,6 +9,7 @@
 using Torch.Commands;
 using Torch.API.Managers;
 using Torch.Server;
+using Torch.Views;
 
 namespace Essentials
 {
@@ -20,27 +21,40 @@ public class AutoCommand : ViewModel, IDisposable
         public bool Enabled { get => _enabled; set { _enabled = value; OnTimerChanged(); OnPropertyChanged(); } }
         private string _command;
         public string Command { get => _command; set { _command = value; OnTimerChanged(); OnPropertyChanged(); } }
-        private int _dueTime;
-        public int DueTime { get => _dueTime / 1000; set { _dueTime = value * 1000; OnTimerChanged(); OnPropertyChanged(); } }
-        private int _period;
-        public int Period { get => _period / 1000; set { _period = value * 1000; OnTimerChanged(); OnPropertyChanged(); } }
+        private TimeSpan _initialDelay;
+
+        [Display(Name = "Initial Delay", Description = "Sets the initial delay after server start before this command is run.")]
+        public string InitialDelay
+        {
+            get => _initialDelay.ToString();
+            set => _initialDelay = TimeSpan.Parse(value);
+        }
+
+        private TimeSpan _repeatInterval;
+
+        [Display(Name = "Repeat Interval", Description = "Sets the interval on which this command will be repeated after the first run.")]
+        public string RepeatInterval
+        {
+            get => _repeatInterval.ToString();
+            set => _repeatInterval = TimeSpan.Parse(value);
+        }
 
         private void OnTimerChanged()
         {
             _timer?.Dispose();
-            if (Enabled && Period > 0)
-                _timer = new Timer(RunCommand, this, _dueTime, _period);
+            if (Enabled && _repeatInterval.TotalMilliseconds > 0)
+                _timer = new Timer(RunCommand, this, _initialDelay, _repeatInterval);
         }
 
         private void RunCommand(object state)
         {
-            if (((TorchServer)TorchBase.Instance).State != ServerState.Running)
+            if (((TorchServer)EssentialsPlugin.Instance.Torch).State != ServerState.Running)
                 return;
 
             var autoCommand = (AutoCommand)state;
-            TorchBase.Instance.Invoke(() =>
+            EssentialsPlugin.Instance.Torch.Invoke(() =>
             {
-                var manager = TorchBase.Instance.CurrentSession.Managers.GetManager<CommandManager>();
+                var manager = EssentialsPlugin.Instance.Torch.CurrentSession.Managers.GetManager<CommandManager>();
                 manager?.HandleCommandFromServer(autoCommand.Command);
             });
         }

Essentials/EssentialsConfig.cs

@@ -5,32 +5,43 @@
 using System.Text;
 using System.Threading.Tasks;
 using Torch;
+using Torch.Views;
 
 namespace Essentials
 {
     public class EssentialsConfig : ViewModel
     {
-        public ObservableCollection<AutoCommand> AutoCommands { get; } = new ObservableCollection<AutoCommand>();
-
+        public ObservableCollection<AutoCommand> AutoCommands
+        {
+            get { return _autoCommands; }
+            set { SetValue(ref _autoCommands, value); }
+        }
+
         private string _motd;
         public string Motd { get => _motd; set => SetValue(ref _motd, value); }
 
         private string _newUserMotd;
         public string NewUserMotd { get => _newUserMotd; set => SetValue(ref _newUserMotd, value); }
 
         private string _motdUrl;
+        [Display(Name = "MotdURL", Description = "Sets a URL to show to players when they connect. Opens in the steam overlay, if enabled.")]
         public string MotdUrl { get => _motdUrl; set => SetValue(ref _motdUrl, value); }
 
         private bool _stopShips;
+        [Display(Name = "Stop entities on start", Description = "Stop all entities in the world when the server starts.")]
         public bool StopShipsOnStart { get => _stopShips; set => SetValue(ref _stopShips, value); }
 
         private bool _utilityShowPosition;
+        private ObservableCollection<AutoCommand> _autoCommands = new ObservableCollection<AutoCommand>();
+
+        [Display(Name = "Grid list show position",Description = "Show users the position of all grids they own in the grids list command.")]
         public bool UtilityShowPosition
         {
             get => _utilityShowPosition;
             set => SetValue(ref _utilityShowPosition, value);
         }
 
+        [Display(Visible=false)]
         public ObservableCollection<ulong> KnownSteamIds { get; } = new ObservableCollection<ulong>();
     }
 }

Essentials/EssentialsPlugin.cs

@@ -22,6 +22,7 @@
 using Torch.Mod;
 using Torch.Mod.Messages;
 using Torch.Session;
+using Torch.Views;
 using VRage.Game;
 using VRage.Game.Entity;
 using VRage.Game.ModAPI;
@@ -35,15 +36,15 @@ public class EssentialsPlugin : TorchPluginBase, IWpfPlugin
 
         private TorchSessionManager _sessionManager;
 
-        private EssentialsControl _control;
+        private UserControl _control;
         private Persistent<EssentialsConfig> _config;
         public static readonly Logger Log = LogManager.GetLogger("Essentials");
         private HashSet<ulong> _motdOnce = new HashSet<ulong>();
 
         public static EssentialsPlugin Instance { get; private set; }
 
         /// <inheritdoc />
-        public UserControl GetControl() => _control ?? (_control = new EssentialsControl(this));
+        public UserControl GetControl() => _control ?? (_control = new PropertyGrid(){DataContext=Config, IsEnabled = false});
 
         public void Save()
         {
@@ -74,6 +75,11 @@ private void SessionChanged(ITorchSession session, TorchSessionState state)
                     MyEntities.OnEntityAdd += MotdOnce;
                     if(Config.StopShipsOnStart)
                         StopShips();
+                    _control.Dispatcher.Invoke(() =>
+                                               {
+                                                   _control.IsEnabled = true;
+                                                   _control.DataContext = Config;
+                                               });
                     break;
                 case TorchSessionState.Unloading:
                     mpMan.PlayerLeft -= ResetMotdOnce;