From 85c7ce8a5d8dbe7e049143932528e9d74d0394ca Mon Sep 17 00:00:00 2001
From: Prozon <104065803+Prozon@users.noreply.github.com>
Date: Mon, 15 Jun 2026 08:20:32 -0700
Subject: [PATCH] Reverting Change To Configs

Reverting changes from config fix.

Incompatible with Nexus at this time. I'll re-do to try to implement reverse compatibility or look into adjusting Nexus' method.
---
 Torch.Server/Managers/InstanceManager.cs |   6 +-
 Torch.Server/Views/ConfigControl.xaml.cs |  48 ++--
 Torch.Server/Views/ModsControl.xaml.cs   | 289 ++++++++++++++++++++---
 3 files changed, 278 insertions(+), 65 deletions(-)

diff --git a/Torch.Server/Managers/InstanceManager.cs b/Torch.Server/Managers/InstanceManager.cs
index 57885062..e08ce0d2 100644
--- a/Torch.Server/Managers/InstanceManager.cs
+++ b/Torch.Server/Managers/InstanceManager.cs
@@ -199,12 +199,12 @@ private void ImportWorldConfig(bool modsOnly = true)
             }
         }
 
-        public bool SaveConfig()
+        public void SaveConfig()
         {
             if (((TorchServer)Torch).HasRun)
             {
                 Log.Warn("Checkpoint cache is stale, not saving dedicated config.");
-                return false;
+                return;
             }
             
             DedicatedConfig.Save(Path.Combine(Torch.Config.InstancePath, CONFIG_NAME));
@@ -238,8 +238,6 @@ public bool SaveConfig()
                 Log.Error("Failed to write sandbox config, changes will not appear on server");
                 Log.Error(e);
             }
-
-            return true;
         }
 
         /// <summary>
diff --git a/Torch.Server/Views/ConfigControl.xaml.cs b/Torch.Server/Views/ConfigControl.xaml.cs
index 41e94bc4..0441683d 100644
--- a/Torch.Server/Views/ConfigControl.xaml.cs
+++ b/Torch.Server/Views/ConfigControl.xaml.cs
@@ -41,8 +41,7 @@ public ConfigControl(TorchServer server)
             
             _server.PropertyChanged += (sender, args) =>
             {
-                if (args.PropertyName == nameof(TorchServer.CanRun) ||
-                    args.PropertyName == nameof(TorchServer.HasRun))
+                if (args.PropertyName == nameof(TorchServer.CanRun))
                 {
                     Dispatcher.Invoke(SetReadOnly);
                 }
@@ -167,59 +166,58 @@ private void RoleEdit_Onlick(object sender, RoutedEventArgs e)
         
         private void SetReadOnly()
         {
-            // Config is only editable before the first start of the session. After the server
-            // has run the checkpoint is stale and saving is blocked, so the
-            // entire panel is locked even after a stop.
-            bool editable = _server.CanRun && !_server.HasRun;
-
             foreach (var textbox in GetAllChildren<TextBox>(this))
             {
-                // Track fields that are inherently read-only (Such as AnalyticsToken)
-                // so they stay read-only even when the panel is editable.
-                if (textbox.IsReadOnly && textbox.Tag == null)
-                    textbox.Tag = "InherentlyReadOnly";
-
-                bool inherentlyReadOnly = textbox.Tag as string == "InherentlyReadOnly";
-
-                // Gray out when the panel is locked, otherwise enable- but keep
-                // inherently-read-only fields non-editable.
-                textbox.IsEnabled = editable;
-                textbox.IsReadOnly = !editable || inherentlyReadOnly;
+                // Don't make inherently read-only textboxes editable
+                // (e.g., AnalyticsToken with ReadOnly=true in DisplayAttribute)
+                if (!_server.CanRun)
+                    textbox.IsReadOnly = true;
+                // Only make editable if it wasn't marked as inherently read-only
+                // We use Tag to track this - PropertyGrid doesn't set Tag on TextBoxes
+                else if (textbox.Tag as string != "InherentlyReadOnly")
+                {
+                    // Check if this is the first time and textbox is already read-only
+                    // If so, mark it as inherently read-only
+                    if (textbox.IsReadOnly && textbox.Tag == null)
+                        textbox.Tag = "InherentlyReadOnly";
+                    else
+                        textbox.IsReadOnly = false;
+                }
             }
 
             foreach (var button in GetAllChildren<Button>(this))
             {
-                button.IsEnabled = editable;
+                button.IsEnabled = _server.CanRun;
             }
 
             foreach (var comboBox in GetAllChildren<ComboBox>(this))
             {
-                comboBox.IsEnabled = editable;
+                comboBox.IsEnabled = _server.CanRun;
             }
             
             foreach (var slider in GetAllChildren<Slider>(this))
             {
-                slider.IsEnabled = editable;
+                slider.IsEnabled = _server.CanRun;
             }
             
             foreach (var checkbox in GetAllChildren<CheckBox>(this))
             {
-                checkbox.IsEnabled = editable;
+                checkbox.IsEnabled = _server.CanRun;
             }
             
             foreach (var toggleButton in GetAllChildren<ToggleButton>(this))
             {
-                toggleButton.IsEnabled = editable;
+                toggleButton.IsEnabled = _server.CanRun;
             }
             
             foreach (var radioButton in GetAllChildren<RadioButton>(this))
             {
-                radioButton.IsEnabled = editable;
+                radioButton.IsEnabled = _server.CanRun;
             }
             
             foreach (var listBox in GetAllChildren<ListBox>(this))
             {
-                listBox.IsEnabled = editable;
+                listBox.IsEnabled = _server.CanRun;
             }
         }
     }
diff --git a/Torch.Server/Views/ModsControl.xaml.cs b/Torch.Server/Views/ModsControl.xaml.cs
index 3fc7ec25..16b93640 100644
--- a/Torch.Server/Views/ModsControl.xaml.cs
+++ b/Torch.Server/Views/ModsControl.xaml.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
-using System.Threading;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
@@ -14,68 +16,283 @@
 using System.Windows.Media.Imaging;
 using System.Windows.Navigation;
 using System.Windows.Shapes;
-using Sandbox.Engine.Networking;
+using System.Runtime.CompilerServices;
+using System.Windows.Threading;
 using VRage.Game;
+using NLog;
+using Sandbox.Engine.Networking;
+using Torch.API;
+using Torch.Server.Managers;
+using Torch.API.Managers;
+using Torch.Server.ViewModels;
+using Torch.Server.Annotations;
+using Torch.Collections;
+using Torch.Utils;
+using Torch.Views;
 
-namespace Torch.Server
+namespace Torch.Server.Views
 {
     /// <summary>
-    /// Interaction logic for ModsControl.xaml
+    /// Interaction logic for ModListControl.xaml
     /// </summary>
-    public partial class ModsControl : UserControl
+    public partial class ModListControl : UserControl, INotifyPropertyChanged
     {
-        public ModsControl()
+        private static Logger Log = LogManager.GetLogger(nameof(ModListControl));
+        private InstanceManager _instanceManager;
+        ModItemInfo _draggedMod;
+        bool _hasOrderChanged = false;
+        bool _isSortedByLoadOrder = true;
+        private readonly ITorchConfig _config;
+
+        //private List<BindingExpression> _bindingExpressions = new List<BindingExpression>();
+        /// <summary>
+        /// Constructor for ModListControl 
+        /// </summary>
+        public ModListControl()
         {
             InitializeComponent();
+            _instanceManager = TorchBase.Instance.Managers.GetManager<InstanceManager>();
+            _instanceManager.InstanceLoaded += _instanceManager_InstanceLoaded;
+            _config = TorchBase.Instance.Config;
+            //var mods = _instanceManager.DedicatedConfig?.Mods;
+            //if( mods != null)
+            //    DataContext = new ObservableCollection<MyObjectBuilder_Checkpoint.ModItem>();
+            DataContext = _instanceManager.DedicatedConfig?.Mods;
+            UgcServiceTypeBox.ItemsSource = new[]
+            {
+                new KeyValuePair<string, string>("Steam", "steam"),
+                new KeyValuePair<string, string>("Mod.Io", "mod.io")
+            };
+            // Gets called once all children are loaded
+            //Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(ApplyStyles));
+        }
+
+        private void ModListControl_SizeChanged(object sender, SizeChangedEventArgs e)
+        {
+            throw new NotImplementedException();
         }
 
-        private void addBtn_Click(object sender, RoutedEventArgs e)
+        private void ResetSorting()
         {
-            ulong[] mods;
-            if (!string.IsNullOrEmpty(ModIdBox.Text))
+            CollectionViewSource.GetDefaultView(ModList.ItemsSource).SortDescriptions.Clear();
+        }
+
+
+        private void _instanceManager_InstanceLoaded(ConfigDedicatedViewModel obj)
+        {
+            Log.Info("Instance loaded.");
+            Dispatcher.Invoke(() => {
+                DataContext = obj?.Mods ?? new MtObservableList<ModItemInfo>();
+                UpdateLayout();
+                ((MtObservableList<ModItemInfo>)DataContext).CollectionChanged += OnModlistUpdate;
+            });
+        }
+
+        private void OnModlistUpdate(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            ModList.Items.Refresh();
+            //if (e.Action == NotifyCollectionChangedAction.Remove)
+            //    _instanceManager.SaveConfig();
+        }
+
+        private void SaveBtn_OnClick(object sender, RoutedEventArgs e)
+        {
+            _instanceManager.SaveConfig();
+        }
+
+
+        private void AddBtn_OnClick(object sender, RoutedEventArgs e)
+        {
+            if (TryExtractId(AddModIDTextBox.Text, out ulong id))
             {
-                mods = new ulong[1];
-                ulong.TryParse(ModIdBox.Text, out mods[0]);
+                var mod = new ModItemInfo(ModItemUtils.Create(id, UgcServiceTypeBox.SelectedValue?.ToString()));
+                
+                _instanceManager.DedicatedConfig.Mods.Add(mod);
+                Task.Run(mod.UpdateModInfoAsync)
+                    .ContinueWith((t) =>
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            _instanceManager.DedicatedConfig.Save();
+                        });
+                    });
+                AddModIDTextBox.Text = "";
             }
             else
             {
-                var dialog = new AddModsDialog();
-                dialog.ShowDialog();
-                mods = dialog.Result;
+                AddModIDTextBox.BorderBrush = Brushes.Red;
+                Log.Warn("Invalid mod id!");
+                MessageBox.Show("Invalid mod id!");
             }
+        }
+        private void RemoveBtn_OnClick(object sender, RoutedEventArgs e)
+        {
+            var modList = ((MtObservableList<ModItemInfo>)DataContext);
+            if (ModList.SelectedItem is ModItemInfo mod && modList.Contains(mod))
+                modList.Remove(mod);
+        }
 
-            //foreach (var id in mods)
-            //{
-            //    var details = SteamHelper.GetItemDetails(id);
-            //    if (details.FileType != WorkshopFileType.Community)
-            //        continue;
+        private bool TryExtractId(string input, out ulong result)
+        {
+            var match = Regex.Match(input, @"(?<=id=)\d+").Value;
+
+            bool success;
+            if (string.IsNullOrEmpty(match))
+                success = ulong.TryParse(input, out result);
+            else
+                success = ulong.TryParse(match, out result);
 
-            //    var item = SteamHelper.GetModItem(details);
-            //    var desc = details.Description.Length < 500 ? details.Description : details.Description.Substring(0, 500);
-            //    ModList.Items.Add(new ModViewModel(item, desc));
-            //}
+            return success;
         }
 
-        private void modList_OnMouseDoubleClick(object sender, MouseButtonEventArgs e)
+        private void ModList_Sorting(object sender, DataGridSortingEventArgs e)
         {
-            var box = (ListView)sender;
-            if (box.SelectedItem == null)
-                return;
+            Log.Info($"Sorting by '{e.Column.Header}'");
+            if (e.Column == ModList.Columns[0])
+            {
+                var dataView = CollectionViewSource.GetDefaultView(ModList.ItemsSource);
+                dataView.SortDescriptions.Clear();
+                dataView.Refresh();
+                _isSortedByLoadOrder = true;
+            }
+            else
+                _isSortedByLoadOrder = false;
+        }
 
-            var id = ((ModViewModel)box.SelectedItem).PublishedFileId;
-            Process.Start($"http://steamcommunity.com/sharedfiles/filedetails/?id={id}");
+        private void ModList_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            //return;
+
+            _draggedMod = (ModItemInfo) TryFindRowAtPoint((UIElement) sender, e.GetPosition(ModList))?.DataContext;
+
+            //DraggedMod = (ModItemInfo) ModList.SelectedItem;
         }
 
-        private void remBtn_Click(object sender, RoutedEventArgs e)
+        private static DataGridRow TryFindRowAtPoint(UIElement reference, Point point)
         {
-            var box = (ListView)sender;
-            if (box.SelectedItems == null || box.SelectedItems.Count == 0)
+            var element = reference.InputHitTest(point) as DependencyObject;
+            if (element == null)
+                return null;
+            if (element is DataGridRow row)
+                return row;
+            else
+                return TryFindParent<DataGridRow>(element);
+        }
+
+        private static T TryFindParent<T>(DependencyObject child) where T : DependencyObject
+        {
+            DependencyObject parent;
+            if (child == null)
+                return null;
+            if (child is ContentElement contentElement)
+            {
+                parent = ContentOperations.GetParent(contentElement);
+                if (parent == null && child is FrameworkContentElement fce)
+                    parent = fce.Parent;
+            }
+            else
+            {
+                parent = VisualTreeHelper.GetParent(child);
+            }
+
+            if (parent is T result)
+                return result;
+            else
+                return TryFindParent<T>(parent);
+        }
+
+        private void UserControl_MouseMove(object sender, MouseEventArgs e)
+        {
+            if (_draggedMod == null)
+                return;
+
+            if (!_isSortedByLoadOrder)
                 return;
 
-            foreach (var item in box.SelectedItems)
+            var targetMod = (ModItemInfo)TryFindRowAtPoint((UIElement)sender, e.GetPosition(ModList))?.DataContext;
+            if( targetMod != null && !ReferenceEquals(_draggedMod, targetMod))
+            {
+                _hasOrderChanged = true;
+                var modList = (MtObservableList<ModItemInfo>)DataContext;
+                modList.Move(modList.IndexOf(targetMod), _draggedMod);
+                //modList.RemoveAt(modList.IndexOf(_draggedMod));
+                //modList.Insert(modList.IndexOf(targetMod), _draggedMod);
+                ModList.Items.Refresh();
+                ModList.SelectedItem = _draggedMod;
+            }
+        }
+
+        private void ModList_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
+        {
+            if (!_isSortedByLoadOrder)
             {
-                box.Items.Remove(item);
+                var targetMod = (ModItemInfo)TryFindRowAtPoint((UIElement)sender, e.GetPosition(ModList))?.DataContext;
+                if (targetMod != null && !ReferenceEquals(_draggedMod, targetMod))
+                {
+                    var msg = "Drag and drop is only available when sorted by load order!";
+                    Log.Warn(msg);
+                    MessageBox.Show(msg);
+                }
             }
+            //if (DraggedMod != null && HasOrderChanged)
+                //Log.Info("Dragging over, saving...");
+                //_instanceManager.SaveConfig();
+            _draggedMod = null;
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        private void ModList_Selected(object sender, SelectedCellsChangedEventArgs e)
+        {
+            if (_draggedMod != null)
+                ModList.SelectedItem = _draggedMod;
+            else if( e.AddedCells.Count > 0)
+                ModList.SelectedItem = e.AddedCells[0].Item;
+        }
+
+        private void BulkButton_OnClick(object sender, RoutedEventArgs e)
+        {
+            var editor = new CollectionEditor();
+
+            //let's see just how poorly we can do this
+            var modList = ((MtObservableList<ModItemInfo>)DataContext).ToList();
+            var idList = modList.Select(m => m.ToString()).ToList();
+            var tasks = new List<Task>();
+            //blocking
+            editor.Edit<string>(idList, "Mods");
+
+            modList.Clear();
+            modList.AddRange(idList.Select(id =>
+            {
+                if (!ModItemUtils.TryParse(id, out var item))
+                    return null;
+                
+                var info = new ModItemInfo(item);
+                tasks.Add(Task.Run(info.UpdateModInfoAsync));
+                return info;
+            }).Where(b => b != null));
+            
+            _instanceManager.DedicatedConfig.Mods.Clear();
+            foreach (var mod in modList)
+                _instanceManager.DedicatedConfig.Mods.Add(mod);
+
+            Task.Run(async () =>
+            {
+                await Task.WhenAll(tasks);
+                _instanceManager.DedicatedConfig.Save();
+            });
+        }
+
+        private void UgcServiceTypeBox_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if ((string) UgcServiceTypeBox.SelectedValue == UGCServiceType.Steam.ToString() &&
+                _config.UgcServiceType == UGCServiceType.EOS)
+                MessageBox.Show("Steam workshop is not available with current ugc service!");
         }
-    }
+    } 
 }