View Integration for View Loadout Group Files

src/NexusMods.Abstractions.GameLocators/GamePath.cs

@@ -134,6 +134,11 @@ public int CompareTo(GamePath other)
     /// is allowed to be a temporary id and will be replaced with the actual id the value is transacted
     /// </summary>
     public (EntityId, LocationId, RelativePath) ToGamePathParentTuple(EntityId id) => (id, LocationId, Path);
+
+    /// <summary>
+    /// Gives you an empty path.
+    /// </summary>
+    public static GamePath Empty(LocationId locationId) => new(locationId, RelativePath.Empty);
 }
 
 /// <summary>

src/NexusMods.App.UI/Controls/TreeDataGrid/SharedColumns.cs

@@ -1,6 +1,5 @@
 using JetBrains.Annotations;
 using NexusMods.App.UI.Extensions;
-using NexusMods.App.UI.Pages.ItemContentsFileTree.New;
 
 namespace NexusMods.App.UI.Controls;
 
@@ -57,4 +56,67 @@ public static int Compare<TKey>(CompositeItemModel<TKey> a, CompositeItemModel<T
         public static string GetColumnHeader() => "Size";
         public static string GetColumnTemplateResourceKey() => ColumnTemplateResourceKey;
     }
+
+    /// <summary>
+    /// Represents a file or folder name, accompanied by a file or folder icon.
+    /// </summary>
+    [UsedImplicitly]
+    public sealed class NameWithFileIcon : ICompositeColumnDefinition<NameWithFileIcon>
+    {
+        public static int Compare<TKey>(CompositeItemModel<TKey> a, CompositeItemModel<TKey> b) where TKey : notnull
+        {
+            var aValue = a.GetOptional<StringComponent>(StringComponentKey);
+            var bValue = b.GetOptional<StringComponent>(StringComponentKey);
+            return aValue.Compare(bValue);
+        }
+
+        public const string ColumnTemplateResourceKey = Prefix + "NameWithFileIcon";
+        public static readonly ComponentKey StringComponentKey = ComponentKey.From(ColumnTemplateResourceKey + "_" + nameof(StringComponent));
+        public static readonly ComponentKey IconComponentKey = ComponentKey.From(ColumnTemplateResourceKey + "_" + nameof(UnifiedIconComponent));
+
+        public static string GetColumnHeader() => "Name";
+        public static string GetColumnTemplateResourceKey() => ColumnTemplateResourceKey;
+    }
+
+    /// <summary>
+    /// Represents a count of files that lives under a folder. 
+    /// </summary>
+    [UsedImplicitly]
+    public sealed class FileCount : ICompositeColumnDefinition<FileCount>
+    {
+        public static int Compare<TKey>(CompositeItemModel<TKey> a, CompositeItemModel<TKey> b) where TKey : notnull
+        {
+            var aValue = a.GetOptional<UInt32Component>(ComponentKey);
+            var bValue = b.GetOptional<UInt32Component>(ComponentKey);
+            // Assuming ValueComponent has a comparable Value property or implements IComparable
+            // Adjust the comparison logic if ValueComponent comparison needs specific handling
+            return aValue.Compare(bValue); 
+        }
+
+        public const string ColumnTemplateResourceKey = Prefix + nameof(FileCount);
+        public static readonly ComponentKey ComponentKey = ComponentKey.From(ColumnTemplateResourceKey + "_" + "FileCount");
+
+        public static string GetColumnHeader() => "File Count";
+        public static string GetColumnTemplateResourceKey() => ColumnTemplateResourceKey;
+    }
+
+    /// <summary>
+    /// A variant of <see cref="ItemSize"/> used with <see cref="CompositeItemModel{GamePath}"/> as opposed to
+    /// <see cref="CompositeItemModel{EntityId}"/>
+    /// </summary>
+    [UsedImplicitly]
+    public sealed class ItemSizeOverGamePath : ICompositeColumnDefinition<ItemSizeOverGamePath>
+    {
+        public static int Compare<TKey>(CompositeItemModel<TKey> a, CompositeItemModel<TKey> b) where TKey : notnull
+        {
+            var aValue = a.GetOptional<SizeComponent>(key: ComponentKey);
+            var bValue = b.GetOptional<SizeComponent>(key: ComponentKey);
+            return aValue.Compare(bValue);
+        }
+
+        public const string ColumnTemplateResourceKey = Prefix + "_GamePath_" + nameof(ItemSize);
+        public static readonly ComponentKey ComponentKey = ComponentKey.From(ColumnTemplateResourceKey + "_GamePath_" + nameof(SizeComponent));
+        public static string GetColumnHeader() => "Size";
+        public static string GetColumnTemplateResourceKey() => ColumnTemplateResourceKey;
+    }
 }

src/NexusMods.App.UI/Controls/TreeDataGrid/UInt32Component.cs

@@ -0,0 +1,18 @@
+using R3;
+namespace NexusMods.App.UI.Controls;
+
+/// <summary>
+/// Component based on <see cref="uint"/>; for XAML binding convenience.
+/// </summary>
+public class UInt32Component : AValueComponent<uint>, IItemModelComponent<UInt32Component>, IComparable<UInt32Component>
+{
+    public UInt32Component(uint initialValue, IObservable<uint> valueObservable, bool subscribeWhenCreated = false, bool observeOutsideUiThread = false) : base(initialValue, valueObservable, subscribeWhenCreated,
+        observeOutsideUiThread
+    ) { }
+    public UInt32Component(uint initialValue, Observable<uint> valueObservable, bool subscribeWhenCreated = false, bool observeOutsideUiThread = false) : base(initialValue, valueObservable, subscribeWhenCreated,
+        observeOutsideUiThread
+    ) { }
+    public UInt32Component(uint value) : base(value) { }
+    /// <inheritdoc />
+    public int CompareTo(UInt32Component? other) => Value.Value.CompareTo(other?.Value.Value ?? 0);
+}

src/NexusMods.App.UI/Helpers/DisposableObservableWrapper.cs

@@ -0,0 +1,45 @@
+namespace NexusMods.App.UI.Helpers;
+
+/// <summary>
+/// A wrapper that ties the lifetime of an external object with an <see cref="IObservable{T}"/>.
+/// This allows an external resource, such as a 'wrapper' or 'adapter' to be disposed when the wrapped observable is disposed.
+/// </summary>
+/// <remarks>
+/// Use this if you want to use an adapter or wrapper around an observable and want to dispose the adapter/wrapper with it.
+/// 
+/// <code>
+/// // Where you normally would return 'observable' but want to wrap it.
+/// var adapter = new SomeAdapter(_connection, observable);
+/// return new DisposableObservableWrapper(adapter.WrappedObservable(), adapter);
+/// </code>
+/// </remarks>
+/// <typeparam name="T">The type of the elements in the sequence.</typeparam>
+public class DisposableObservableWrapper<T>(IObservable<T> source, IDisposable additionalResource) : IObservable<T>, IDisposable
+{
+    private readonly IObservable<T> _source = source ?? throw new ArgumentNullException(nameof(source));
+    private readonly IDisposable _additionalResource = additionalResource ?? throw new ArgumentNullException(nameof(additionalResource));
+    private bool _disposed;
+
+    /// <inheritdoc />
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, nameof(DisposableObservableWrapper<T>));
+        return _source.Subscribe(observer);
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        if (_disposed)
+            return;
+
+        _disposed = true;
+
+        // Dispose the additional resource when this wrapper is disposed
+        _additionalResource.Dispose();
+
+        // If the source is also IDisposable, dispose it too
+        if (_source is IDisposable disposableSource)
+            disposableSource.Dispose();
+    }
+}

src/NexusMods.App.UI/Helpers/TreeDataGrid/New/FolderGenerator/GamePathTreeItemWithPath.cs

@@ -0,0 +1,30 @@
+using NexusMods.Abstractions.GameLocators;
+using NexusMods.Abstractions.Loadouts;
+using NexusMods.MnemonicDB.Abstractions;
+namespace NexusMods.App.UI.Helpers.TreeDataGrid.New.FolderGenerator;
+
+/// <summary>
+/// Adapter for <see cref="LoadoutItem.ReadOnly"/> for <see cref="ITreeItemWithPath"/>.
+/// </summary>
+public readonly struct GamePathTreeItemWithPath : ITreeItemWithPath
+{
+    private readonly GamePath _path;
+
+    /// <summary/>
+    public GamePathTreeItemWithPath(GamePath item) => _path = item;
+
+    /// <inheritdoc />
+    public GamePath GetPath() => _path;
+
+    /// <summary/>
+    public static implicit operator GamePathTreeItemWithPath(GamePath path) => new(path);
+}
+
+/// <summary>
+/// A factory for creating <see cref="GamePathTreeItemWithPath"/> from <see cref="EntityId"/>.
+/// And a database connection.
+/// </summary>
+public readonly struct GamePathTreeItemWithPathFactory : ITreeItemWithPathFactory<GamePath, GamePathTreeItemWithPath>
+{
+    public GamePathTreeItemWithPath CreateItem(GamePath key) => new(key);
+}