ToxicMushroom/Penumbra
1
0
Fork 0
mirror of https://github.com/xivdev/Penumbra.git synced 2025-12-12 10:17:22 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Change folder handling and introduce drag & drop for folders

Browse source
This commit is contained in:
Ottermandias 2021-08-08 12:43:12 +02:00
parent ec99887387
commit 2532e73f9d
21 changed files with 1690 additions and 651 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Penumbra/Configuration.cs
View file

@ -29,6 +29,9 @@ namespace Penumbra
public string CurrentCollection { get; set; } = "Default";
public string DefaultCollection { get; set; } = "Default";
public string ForcedCollection { get; set; } = "";
public bool SortFoldersFirst { get; set; } = false;
public Dictionary< string, string > CharacterCollections { get; set; } = new();
public Dictionary< string, string > ModSortOrder { get; set; } = new();

60
Penumbra/Mod/ModData.cs
View file

@ -1,11 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Dalamud.Plugin;
using Penumbra.Mods;
using Penumbra.Util;
namespace Penumbra.Mod
{
public struct SortOrder : IComparable<SortOrder>
{
public ModFolder ParentFolder { get; set; }
private string _sortOrderName;
public string SortOrderName
{
get => _sortOrderName;
set => _sortOrderName = value.Replace( '/', '\\' );
}
public string SortOrderPath
=> ParentFolder.FullName;
public string FullName
{
get
{
var path = SortOrderPath;
return path.Any() ? $"{path}/{SortOrderName}" : SortOrderName;
}
}
public SortOrder( ModFolder parentFolder, string name )
{
ParentFolder = parentFolder;
_sortOrderName = name.Replace( '/', '\\' );
}
public string FullPath
=> SortOrderPath.Any() ? $"{SortOrderPath}/{SortOrderName}" : SortOrderName;
public int CompareTo( SortOrder other )
=> string.Compare(FullPath, other.FullPath, StringComparison.InvariantCultureIgnoreCase );
}
// ModData contains all permanent information about a mod,
// and is independent of collections or settings.
// It only changes when the user actively changes the mod or their filesystem.
@ -14,17 +54,22 @@ namespace Penumbra.Mod
public DirectoryInfo BasePath;
public ModMeta Meta;
public ModResources Resources;
public string SortOrder;
public SortOrder SortOrder;
public SortedList< string, object? > ChangedItems { get; } = new();
public string LowerChangedItemsString { get; private set; } = string.Empty;
public FileInfo MetaFile { get; set; }
private ModData( DirectoryInfo basePath, ModMeta meta, ModResources resources )
private ModData( ModFolder parentFolder, DirectoryInfo basePath, ModMeta meta, ModResources resources )
{
BasePath = basePath;
Meta = meta;
Resources = resources;
MetaFile = MetaFileInfo( basePath );
SortOrder = meta.Name.Replace( '/', '\\' );
SortOrder = new SortOrder( parentFolder, Meta.Name );
SortOrder.ParentFolder.AddMod( this );
ComputeChangedItems();
}
@ -44,12 +89,14 @@ namespace Penumbra.Mod
{
identifier.Identify( ChangedItems, path );
}
LowerChangedItemsString = string.Join( "\0", ChangedItems.Keys.Select( k => k.ToLowerInvariant() ) );
}
public static FileInfo MetaFileInfo( DirectoryInfo basePath )
=> new( Path.Combine( basePath.FullName, "meta.json" ) );
public static ModData? LoadMod( DirectoryInfo basePath )
public static ModData? LoadMod( ModFolder parentFolder, DirectoryInfo basePath )
{
basePath.Refresh();
if( !basePath.Exists )
@ -77,10 +124,13 @@ namespace Penumbra.Mod
data.SetManipulations( meta, basePath );
}
return new ModData( basePath, meta, data );
return new ModData( parentFolder, basePath, meta, data );
}
public void SaveMeta()
=> Meta.SaveToFile( MetaFile );
public override string ToString()
=> SortOrder.FullPath;
}
}

45
Penumbra/Mod/ModMeta.cs
View file

@ -13,8 +13,37 @@ namespace Penumbra.Mod
public class ModMeta
{
public uint FileVersion { get; set; }
public string Name { get; set; } = "Mod";
public string Author { get; set; } = "";
public string Name
{
get => _name;
set
{
_name = value;
LowerName = value.ToLowerInvariant();
}
}
private string _name = "Mod";
[JsonIgnore]
public string LowerName { get; private set; } = "mod";
private string _author = "";
public string Author
{
get => _author;
set
{
_author = value;
LowerAuthor = value.ToLowerInvariant();
}
}
[JsonIgnore]
public string LowerAuthor { get; private set; } = "";
public string Description { get; set; } = "";
public string Version { get; set; } = "";
public string Website { get; set; } = "";
@ -66,8 +95,8 @@ namespace Penumbra.Mod
new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore } );
if( meta != null )
{
meta.FileHash = text.GetHashCode();
meta.HasGroupsWithConfig = meta.Groups.Values.Any( g => g.SelectionType == SelectType.Multi || g.Options.Count > 1 );
meta.FileHash = text.GetHashCode();
meta.RefreshHasGroupsWithConfig();
}
return meta;
@ -79,6 +108,14 @@ namespace Penumbra.Mod
}
}
public bool RefreshHasGroupsWithConfig()
{
var oldValue = HasGroupsWithConfig;
HasGroupsWithConfig = Groups.Values.Any( g => g.Options.Count > 1 || g.SelectionType == SelectType.Multi && g.Options.Count == 1 );
return oldValue != HasGroupsWithConfig;
}
public void SaveToFile( FileInfo filePath )
{
try

8
Penumbra/Mods/CollectionManager.cs
View file

@ -38,7 +38,7 @@ namespace Penumbra.Mods
{
foreach( var collection in Collections.Values.Where( c => c.Cache != null ) )
{
collection.CreateCache( _manager.BasePath, _manager.Mods, false );
collection.CreateCache( _manager.BasePath, _manager.StructuredMods.AllMods(_manager.Config.SortFoldersFirst) );
}
}
@ -57,10 +57,6 @@ namespace Penumbra.Mods
if( metaChanges )
{
collection.UpdateSetting( mod );
if( nameChange )
{
collection.Cache?.SortMods();
}
}
if( fileChanges.HasFlag( ResourceChange.Files )
@ -143,7 +139,7 @@ namespace Penumbra.Mods
{
if( collection.Cache == null && collection.Name != string.Empty )
{
collection.CreateCache( _manager.BasePath, _manager.Mods, false );
collection.CreateCache( _manager.BasePath, _manager.StructuredMods.AllMods(_manager.Config.SortFoldersFirst) );
}
}

61
Penumbra/Mods/ModCollection.cs
View file

@ -35,60 +35,55 @@ namespace Penumbra.Mods
Settings = settings.ToDictionary( kvp => kvp.Key, kvp => kvp.Value.DeepCopy() );
}
private bool CleanUnavailableSettings( Dictionary< string, ModData > data )
public Mod.Mod GetMod( ModData mod )
{
if( Settings.Count <= data.Count )
if( Settings.TryGetValue( mod.BasePath.Name, out var settings ) )
{
return false;
return new Mod.Mod( settings, mod );
}
List< string > removeList = new();
foreach( var settingKvp in Settings )
{
if( !data.ContainsKey( settingKvp.Key ) )
{
removeList.Add( settingKvp.Key );
}
}
var newSettings = ModSettings.DefaultSettings( mod.Meta );
Settings.Add( mod.BasePath.Name, newSettings );
Save( Service< DalamudPluginInterface >.Get() );
return new Mod.Mod( newSettings, mod );
}
private bool CleanUnavailableSettings( Dictionary< string, ModData > data )
{
var removeList = Settings.Where( settingKvp => !data.ContainsKey( settingKvp.Key ) ).ToArray();
foreach( var s in removeList )
{
Settings.Remove( s );
Settings.Remove( s.Key );
}
return removeList.Count > 0;
return removeList.Length > 0;
}
public void CreateCache( DirectoryInfo modDirectory, Dictionary< string, ModData > data, bool cleanUnavailable = false )
public void CreateCache( DirectoryInfo modDirectory, IEnumerable< ModData > data )
{
Cache = new ModCollectionCache( Name, modDirectory );
var changedSettings = false;
foreach( var modKvp in data )
foreach( var mod in data )
{
if( Settings.TryGetValue( modKvp.Key, out var settings ) )
if( Settings.TryGetValue( mod.BasePath.Name, out var settings ) )
{
Cache.AvailableMods.Add( new Mod.Mod( settings, modKvp.Value ) );
Cache.AddMod( settings, mod );
}
else
{
changedSettings = true;
var newSettings = ModSettings.DefaultSettings( modKvp.Value.Meta );
Settings.Add( modKvp.Key, newSettings );
Cache.AvailableMods.Add( new Mod.Mod( newSettings, modKvp.Value ) );
var newSettings = ModSettings.DefaultSettings( mod.Meta );
Settings.Add( mod.BasePath.Name, newSettings );
Cache.AddMod( newSettings, mod );
}
}
if( cleanUnavailable )
{
changedSettings |= CleanUnavailableSettings( data );
}
if( changedSettings )
{
Save( Service< DalamudPluginInterface >.Get() );
}
Cache.SortMods();
CalculateEffectiveFileList( modDirectory, true, false );
}
@ -129,6 +124,8 @@ namespace Penumbra.Mods
public void CalculateEffectiveFileList( DirectoryInfo modDir, bool withMetaManipulations, bool activeCollection )
{
PluginLog.Verbose( "Recalculating effective file list for {CollectionName} [{WithMetaManipulations}] [{IsActiveCollection}]", Name,
withMetaManipulations, activeCollection );
Cache ??= new ModCollectionCache( Name, modDir );
UpdateSettings();
Cache.CalculateEffectiveFileList();
@ -233,14 +230,10 @@ namespace Penumbra.Mods
return;
}
if( Settings.TryGetValue( data.BasePath.Name, out var settings ) )
{
Cache.AddMod( settings, data );
}
else
{
Cache.AddMod( ModSettings.DefaultSettings( data.Meta ), data );
}
Cache.AddMod( Settings.TryGetValue( data.BasePath.Name, out var settings )
? settings
: ModSettings.DefaultSettings( data.Meta ),
data );
}
public string? ResolveSwappedOrReplacementPath( GamePath gameResourcePath )

28
Penumbra/Mods/ModCollectionCache.cs
View file

@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Lumina.Data.Parsing;
using Penumbra.GameData.Util;
using Penumbra.Meta;
using Penumbra.Mod;
@ -12,7 +13,7 @@ namespace Penumbra.Mods
// It will only be setup if a collection gets activated in any way.
public class ModCollectionCache
{
public readonly List< Mod.Mod > AvailableMods = new();
public readonly List<Mod.Mod> AvailableMods = new();
public readonly Dictionary< GamePath, FileInfo > ResolvedFiles = new();
public readonly Dictionary< GamePath, GamePath > SwappedFiles = new();
@ -21,12 +22,6 @@ namespace Penumbra.Mods
public ModCollectionCache( string collectionName, DirectoryInfo modDir )
=> MetaManipulations = new MetaManager( collectionName, ResolvedFiles, modDir );
public void SortMods()
{
AvailableMods.Sort( ( m1, m2 )
=> string.Compare( m1.Data.SortOrder, m2.Data.SortOrder, StringComparison.InvariantCultureIgnoreCase ) );
}
private void AddFiles( Dictionary< GamePath, Mod.Mod > registeredFiles, Mod.Mod mod )
{
foreach( var file in mod.Data.Resources.ModFiles )
@ -82,8 +77,7 @@ namespace Penumbra.Mods
{
MetaManipulations.Reset( false );
foreach( var mod in AvailableMods.Where( m => m.Settings.Enabled && m.Data.Resources.MetaManipulations.Count > 0 )
.OrderByDescending( m => m.Settings.Priority ) )
foreach( var mod in AvailableMods.Where( m => m.Settings.Enabled && m.Data.Resources.MetaManipulations.Count > 0 ) )
{
mod.Cache.ClearMetaConflicts();
AddManipulations( mod );
@ -98,7 +92,7 @@ namespace Penumbra.Mods
SwappedFiles.Clear();
var registeredFiles = new Dictionary< GamePath, Mod.Mod >();
foreach( var mod in AvailableMods.Where( m => m.Settings.Enabled ).OrderByDescending( m => m.Settings.Priority ) )
foreach( var mod in AvailableMods.Where( m => m.Settings.Enabled ) )
{
mod.Cache.ClearFileConflicts();
AddFiles( registeredFiles, mod );
@ -131,10 +125,20 @@ namespace Penumbra.Mods
}
}
private class PriorityComparer : IComparer< Mod.Mod >
{
public int Compare( Mod.Mod x, Mod.Mod y )
=> x.Settings.Priority.CompareTo( y.Settings.Priority );
}
private static readonly PriorityComparer Comparer = new();
public void AddMod( ModSettings settings, ModData data )
{
AvailableMods.Add( new Mod.Mod( settings, data ) );
SortMods();
var newMod = new Mod.Mod( settings, data );
var idx = AvailableMods.BinarySearch( newMod, Comparer );
idx = idx < 0 ? ~idx : idx;
AvailableMods.Insert( idx, newMod );
if( settings.Enabled )
{
CalculateEffectiveFileList();

251
Penumbra/Mods/ModFileSystem.cs Normal file
View file

@ -0,0 +1,251 @@
using System;
using System.Linq;
using Penumbra.Mod;
using Penumbra.Util;
namespace Penumbra.Mods
{
public static partial class ModFileSystem
{
// The root folder that should be used as the base for all structured mods.
public static ModFolder Root = ModFolder.CreateRoot();
// Find a specific mod folder by its path from Root.
// Returns true if the folder was found, and false if not.
// The out parameter will contain the furthest existing folder.
public static bool Find( string path, out ModFolder folder )
{
var split = path.Split( new[] { '/' }, StringSplitOptions.RemoveEmptyEntries );
folder = Root;
foreach( var part in split )
{
if( !folder.FindSubFolder( part, out folder ) )
{
return false;
}
}
return true;
}
// Rename the SortOrderName of a single mod. Slashes are replaced by Backslashes.
// Saves and returns true if anything changed.
public static bool Rename( this ModData mod, string newName )
{
if( RenameNoSave( mod, newName ) )
{
SaveMod( mod );
return true;
}
return false;
}
// Rename the target folder, merging it and its subfolders if the new name already exists.
// Saves all mods manipulated thus, and returns true if anything changed.
public static bool Rename( this ModFolder target, string newName )
{
if( RenameNoSave( target, newName ) )
{
SaveModChildren( target );
return true;
}
return false;
}
// Move a single mod to the target folder.
// Returns true and saves if anything changed.
public static bool Move( this ModData mod, ModFolder target )
{
if( MoveNoSave( mod, target ) )
{
SaveMod( mod );
return true;
}
return false;
}
// Move a mod to the filesystem location specified by sortOrder and rename its SortOrderName.
// Creates all necessary Subfolders.
// Does NOT save.
public static void Move( this ModData mod, string sortOrder )
{
var split = sortOrder.Split( new[] { '/' }, StringSplitOptions.RemoveEmptyEntries );
var folder = Root;
for( var i = 0; i < split.Length - 1; ++i )
{
folder = folder.FindOrCreateSubFolder( split[ i ] ).Item1;
}
MoveNoSave( mod, folder );
RenameNoSave( mod, split.Last() );
}
// Moves folder to target.
// If an identically named subfolder of target already exists, merges instead.
// Root is not movable.
public static bool Move( this ModFolder folder, ModFolder target )
{
if( MoveNoSave( folder, target ) )
{
SaveModChildren( target );
return true;
}
return false;
}
// Merge source with target, moving all direct mod children of source to target,
// and moving all subfolders of source to target, or merging them with targets subfolders if they exist.
// Returns true and saves if anything changed.
public static bool Merge( this ModFolder source, ModFolder target )
{
if( MergeNoSave( source, target ) )
{
SaveModChildren( target );
return true;
}
return false;
}
}
// Internal stuff.
public static partial class ModFileSystem
{
// Reset all sort orders for all descendants of the given folder.
// Assumes that it is not called on Root, and thus does not remove unnecessary SortOrder entries.
private static void SaveModChildren( ModFolder target )
{
var config = Service< Configuration >.Get();
foreach( var mod in target.AllMods( true ) )
{
config.ModSortOrder[ mod.BasePath.Name ] = mod.SortOrder.FullName;
}
config.Save();
}
// Sets and saves the sort order of a single mod, removing the entry if it is unnecessary.
private static void SaveMod( ModData mod )
{
var config = Service< Configuration >.Get();
if( ReferenceEquals( mod.SortOrder.ParentFolder, Root )
&& string.Equals( mod.SortOrder.SortOrderName, mod.Meta.Name.Replace( '/', '\\' ), StringComparison.InvariantCultureIgnoreCase ) )
{
config.ModSortOrder.Remove( mod.BasePath.Name );
}
else
{
config.ModSortOrder[ mod.BasePath.Name ] = mod.SortOrder.FullName;
}
config.Save();
}
private static bool RenameNoSave( this ModFolder target, string newName )
{
if( ReferenceEquals( target, Root ) )
{
throw new InvalidOperationException( "Can not rename root." );
}
newName = newName.Replace( '/', '\\' );
if( target.Name == newName )
{
return false;
}
if( target.Parent!.FindSubFolder( newName, out var preExisting ) )
{
MergeNoSave( target, preExisting );
}
else
{
var parent = target.Parent;
parent.RemoveFolderIgnoreEmpty( target );
target.Name = newName;
parent.FindOrAddSubFolder( target );
}
return true;
}
private static bool RenameNoSave( ModData mod, string newName )
{
newName = newName.Replace( '/', '\\' );
if( mod.SortOrder.SortOrderName == newName )
{
return false;
}
mod.SortOrder.ParentFolder.RemoveModIgnoreEmpty( mod );
mod.SortOrder = new SortOrder( mod.SortOrder.ParentFolder, newName );
mod.SortOrder.ParentFolder.AddMod( mod );
return true;
}
private static bool MoveNoSave( ModData mod, ModFolder target )
{
var oldParent = mod.SortOrder.ParentFolder;
if( ReferenceEquals( target, oldParent ) )
{
return false;
}
oldParent.RemoveMod( mod );
mod.SortOrder = new SortOrder( target, mod.SortOrder.SortOrderName );
target.AddMod( mod );
return true;
}
private static bool MergeNoSave( ModFolder source, ModFolder target )
{
if( ReferenceEquals( source, target ) )
{
return false;
}
var any = false;
while( source.SubFolders.Count > 0 )
{
any |= MoveNoSave( source.SubFolders.First(), target );
}
while( source.Mods.Count > 0 )
{
any |= MoveNoSave( source.Mods.First(), target );
}
source.Parent?.RemoveSubFolder( source );
return any || source.Parent != null;
}
private static bool MoveNoSave( ModFolder folder, ModFolder target )
{
// Moving a folder into itself is not permitted.
if( ReferenceEquals( folder, target ) )
{
return false;
}
if( ReferenceEquals( target, folder.Parent! ) )
{
return false;
}
folder.Parent!.RemoveSubFolder( folder );
var subFolderIdx = target.FindOrAddSubFolder( folder );
if( subFolderIdx > 0 )
{
var main = target.SubFolders[ subFolderIdx ];
MergeNoSave( folder, main );
}
return true;
}
}
}

243
Penumbra/Mods/ModFolder.cs Normal file
View file

@ -0,0 +1,243 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Penumbra.Mod;
namespace Penumbra.Mods
{
public partial class ModFolder
{
public ModFolder? Parent;
public string FullName
{
get
{
var parentPath = Parent?.FullName ?? string.Empty;
return parentPath.Any() ? $"{parentPath}/{Name}" : Name;
}
}
private string _name = string.Empty;
public string Name
{
get => _name;
set => _name = value.Replace( '/', '\\' );
}
public List< ModFolder > SubFolders { get; } = new();
public List< ModData > Mods { get; } = new();
public ModFolder( ModFolder parent, string name )
{
Parent = parent;
Name = name;
}
public override string ToString()
=> FullName;
public int TotalDescendantMods()
=> Mods.Count + SubFolders.Sum( f => f.TotalDescendantMods() );
public int TotalDescendantFolders()
=> SubFolders.Sum( f => f.TotalDescendantFolders() );
// Return all descendant mods in the specified order.
public IEnumerable< ModData > AllMods( bool foldersFirst )
{
if( foldersFirst )
{
return SubFolders.SelectMany( f => f.AllMods( foldersFirst ) ).Concat( Mods );
}
return GetSortedEnumerator().SelectMany( f =>
{
if( f is ModFolder folder )
{
return folder.AllMods( false );
}
return new[] { ( ModData )f };
} );
}
// Return all descendant subfolders.
public IEnumerable< ModFolder > AllFolders()
=> SubFolders.SelectMany( f => f.AllFolders() ).Prepend( this );
// Iterate through all descendants in the specified order, returning subfolders as well as mods.
public IEnumerable< object > GetItems( bool foldersFirst )
=> foldersFirst ? SubFolders.Cast< object >().Concat( Mods ) : GetSortedEnumerator();
// Find a subfolder by name. Returns true and sets folder to it if it exists.
public bool FindSubFolder( string name, out ModFolder folder )
{
var subFolder = new ModFolder( this, name );
var idx = SubFolders.BinarySearch( subFolder, FolderComparer );
folder = idx >= 0 ? SubFolders[ idx ] : this;
return idx >= 0;
}
// Checks if an equivalent subfolder as folder already exists and returns its index.
// If it does not exist, inserts folder as a subfolder and returns the new index.
// Also sets this as folders parent.
public int FindOrAddSubFolder( ModFolder folder )
{
var idx = SubFolders.BinarySearch( folder, FolderComparer );
if( idx >= 0 )
{
return idx;
}
idx = ~idx;
SubFolders.Insert( idx, folder );
folder.Parent = this;
return idx;
}
// Checks if a subfolder with the given name already exists and returns it and its index.
// If it does not exists, creates and inserts it and returns the new subfolder and its index.
public (ModFolder, int) FindOrCreateSubFolder( string name )
{
var subFolder = new ModFolder( this, name );
var idx = FindOrAddSubFolder( subFolder );
return ( SubFolders[ idx ], idx );
}
// Remove folder as a subfolder if it exists.
// If this folder is empty afterwards, remove it from its parent.
public void RemoveSubFolder( ModFolder folder )
{
RemoveFolderIgnoreEmpty( folder );
CheckEmpty();
}
// Add the given mod as a child, if it is not already a child.
// Returns the index of the found or inserted mod.
public int AddMod( ModData mod )
{
var idx = Mods.BinarySearch( mod, ModComparer );
if( idx >= 0 )
{
return idx;
}
idx = ~idx;
Mods.Insert( idx, mod );
return idx;
}
// Remove mod as a child if it exists.
// If this folder is empty afterwards, remove it from its parent.
public void RemoveMod( ModData mod )
{
RemoveModIgnoreEmpty( mod );
CheckEmpty();
}
}
// Internals
public partial class ModFolder
{
// Create a Root folder without parent.
internal static ModFolder CreateRoot()
=> new( null!, string.Empty );
internal class ModFolderComparer : IComparer< ModFolder >
{
// Compare only the direct folder names since this is only used inside an enumeration of subfolders of one folder.
public int Compare( ModFolder x, ModFolder y )
=> ReferenceEquals( x, y )
? 0
: string.Compare( x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase );
}
internal class ModDataComparer : IComparer< ModData >
{
// Compare only the direct SortOrderNames since this is only used inside an enumeration of direct mod children of one folder.
// Since mod SortOrderNames do not have to be unique inside a folder, also compare their BasePaths (and thus their identity) if necessary.
public int Compare( ModData x, ModData y )
{
if( ReferenceEquals( x, y ) )
{
return 0;
}
var cmp = string.Compare( x.SortOrder.SortOrderName, y.SortOrder.SortOrderName, StringComparison.InvariantCultureIgnoreCase );
if( cmp != 0 )
{
return cmp;
}
return string.Compare( x.BasePath.Name, y.BasePath.Name, StringComparison.InvariantCulture );
}
}
private static readonly ModFolderComparer FolderComparer = new();
private static readonly ModDataComparer ModComparer = new();
// Get an enumerator for actually sorted objects instead of folder-first objects.
private IEnumerable< object > GetSortedEnumerator()
{
var modIdx = 0;
foreach( var folder in SubFolders )
{
var folderString = folder.Name;
for( ; modIdx < Mods.Count; ++modIdx )
{
var mod = Mods[ modIdx ];
var modString = mod.SortOrder.SortOrderName;
if( string.Compare( folderString, modString, StringComparison.InvariantCultureIgnoreCase ) > 0 )
{
yield return mod;
}
else
{
break;
}
}
yield return folder;
}
for( ; modIdx < Mods.Count; ++modIdx )
{
yield return Mods[ modIdx ];
}
}
private void CheckEmpty()
{
if( Mods.Count == 0 && SubFolders.Count == 0 )
{
Parent?.RemoveSubFolder( this );
}
}
// Remove a subfolder but do not remove this folder from its parent if it is empty afterwards.
internal void RemoveFolderIgnoreEmpty( ModFolder folder )
{
var idx = SubFolders.BinarySearch( folder, FolderComparer );
if( idx < 0 )
{
return;
}
SubFolders[ idx ].Parent = null;
SubFolders.RemoveAt( idx );
}
// Remove a mod, but do not remove this folder from its parent if it is empty afterwards.
internal void RemoveModIgnoreEmpty( ModData mod )
{
var idx = Mods.BinarySearch( mod, ModComparer );
if( idx >= 0 )
{
Mods.RemoveAt( idx );
}
}
}
}

56
Penumbra/Mods/ModManager.cs
View file

@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.IO;
using System.Linq;
using Dalamud.Plugin;
using ImGuiScene;
using Penumbra.GameData.Util;
using Penumbra.Meta;
using Penumbra.Mod;
@ -17,6 +18,8 @@ namespace Penumbra.Mods
public DirectoryInfo BasePath { get; private set; } = null!;
public Dictionary< string, ModData > Mods { get; } = new();
public ModFolder StructuredMods { get; } = ModFileSystem.Root;
public CollectionManager Collections { get; }
public bool Valid { get; private set; }
@ -53,25 +56,45 @@ namespace Penumbra.Mods
DiscoverMods();
}
private void SetModOrders( Configuration config )
private bool SetSortOrderPath( ModData mod, string path )
{
mod.Move( path );
var fixedPath = mod.SortOrder.FullPath;
if( !fixedPath.Any() || string.Equals( fixedPath, mod.Meta.Name, StringComparison.InvariantCultureIgnoreCase ) )
{
Config.ModSortOrder.Remove( mod.BasePath.Name );
return true;
}
if( path != fixedPath )
{
Config.ModSortOrder[ mod.BasePath.Name ] = fixedPath;
return true;
}
return false;
}
private void SetModStructure()
{
var changes = false;
foreach( var kvp in config.ModSortOrder.ToArray() )
foreach( var kvp in Config.ModSortOrder.ToArray() )
{
if( Mods.TryGetValue( kvp.Key, out var mod ) )
if( kvp.Value.Any() && Mods.TryGetValue( kvp.Key, out var mod ) )
{
mod.SortOrder = string.Join( "/", kvp.Value.Trim().Split( new[] { "/" }, StringSplitOptions.RemoveEmptyEntries ) );
changes |= SetSortOrderPath( mod, kvp.Value );
}
else
{
changes = true;
config.ModSortOrder.Remove( kvp.Key );
Config.ModSortOrder.Remove( kvp.Key );
}
}
if( changes )
{
config.Save();
Config.Save();
}
}
@ -96,7 +119,7 @@ namespace Penumbra.Mods
{
foreach( var modFolder in BasePath.EnumerateDirectories() )
{
var mod = ModData.LoadMod( modFolder );
var mod = ModData.LoadMod( StructuredMods, modFolder );
if( mod == null )
{
continue;
@ -105,7 +128,7 @@ namespace Penumbra.Mods
Mods.Add( modFolder.Name, mod );
}
SetModOrders( _plugin.Configuration );
SetModStructure();
}
Collections.RecreateCaches();
@ -132,7 +155,7 @@ namespace Penumbra.Mods
public bool AddMod( DirectoryInfo modFolder )
{
var mod = ModData.LoadMod( modFolder );
var mod = ModData.LoadMod( StructuredMods, modFolder );
if( mod == null )
{
return false;
@ -140,7 +163,10 @@ namespace Penumbra.Mods
if( Config.ModSortOrder.TryGetValue( mod.BasePath.Name, out var sortOrder ) )
{
mod.SortOrder = sortOrder;
if( SetSortOrderPath( mod, sortOrder ) )
{
Config.Save();
}
}
if( Mods.ContainsKey( modFolder.Name ) )
@ -173,11 +199,17 @@ namespace Penumbra.Mods
mod.ComputeChangedItems();
if( Config.ModSortOrder.TryGetValue( mod.BasePath.Name, out var sortOrder ) )
{
mod.SortOrder = sortOrder;
mod.Move( sortOrder );
var path = mod.SortOrder.FullPath;
if( path != sortOrder )
{
Config.ModSortOrder[ mod.BasePath.Name ] = path;
Config.Save();
}
}
else
{
mod.SortOrder = mod.Meta.Name.Replace( '/', '\\' );
mod.SortOrder = new SortOrder( StructuredMods, mod.Meta.Name );
}
}

23
Penumbra/Mods/ModManagerEditExtensions.cs
View file

@ -22,42 +22,31 @@ namespace Penumbra.Mods
mod.Meta.Name = newName;
mod.SaveMeta();
foreach( var collection in manager.Collections.Collections.Values.Where( c => c.Cache != null ) )
{
collection.Cache!.SortMods();
}
return true;
}
public static bool ChangeSortOrder( this ModManager manager, ModData mod, string newSortOrder )
{
newSortOrder = string.Join( "/", newSortOrder.Trim().Split( new[] { "/" }, StringSplitOptions.RemoveEmptyEntries ) );
if( mod.SortOrder == newSortOrder )
if( string.Equals(mod.SortOrder.FullPath, newSortOrder, StringComparison.InvariantCultureIgnoreCase ) )
{
return false;
}
var modName = mod.Meta.Name.Replace( '/', '\\' );
if( newSortOrder == string.Empty || newSortOrder == modName )
var inRoot = new SortOrder( manager.StructuredMods, mod.Meta.Name );
if( newSortOrder == string.Empty || newSortOrder == inRoot.SortOrderName )
{
mod.SortOrder = modName;
mod.SortOrder = inRoot;
manager.Config.ModSortOrder.Remove( mod.BasePath.Name );
}
else
{
mod.SortOrder = newSortOrder;
manager.Config.ModSortOrder[ mod.BasePath.Name ] = newSortOrder;
mod.Move( newSortOrder );
manager.Config.ModSortOrder[ mod.BasePath.Name ] = mod.SortOrder.FullPath;
}
manager.Config.Save();
foreach( var collection in manager.Collections.Collections.Values.Where( c => c.Cache != null ) )
{
collection.Cache!.SortMods();
}
return true;
}

11
Penumbra/Plugin.cs
View file

@ -39,13 +39,20 @@ namespace Penumbra
private WebServer? _webServer;
public static void SaveConfiguration()
{
var pi = Service< DalamudPluginInterface >.Get();
var config = Service< Configuration >.Get();
pi.SavePluginConfig( config );
}
public void Initialize( DalamudPluginInterface pluginInterface )
{
PluginInterface = pluginInterface;
Service< DalamudPluginInterface >.Set( PluginInterface );
GameData.GameData.GetIdentifier( PluginInterface );
Configuration = Configuration.Load( PluginInterface );
Configuration = Configuration.Load( PluginInterface );
Service< Configuration >.Set( Configuration );
SoundShit = new MusicManager( this );
SoundShit.DisableStreaming();

10
Penumbra/UI/MenuTabs/TabCollections.cs
View file

@ -14,6 +14,7 @@ namespace Penumbra.UI
{
private class TabCollections
{
public const string LabelCurrentCollection = "Current Collection";
private readonly Selector _selector;
private readonly ModManager _manager;
private string _collectionNames = null!;
@ -130,11 +131,11 @@ namespace Penumbra.UI
}
}
private void DrawCurrentCollectionSelector()
public void DrawCurrentCollectionSelector(bool tooltip)
{
var index = _currentCollectionIndex;
var combo = ImGui.Combo( "Current Collection", ref index, _collectionNames );
if( ImGui.IsItemHovered() )
var combo = ImGui.Combo( LabelCurrentCollection, ref index, _collectionNames );
if( tooltip && ImGui.IsItemHovered() )
{
ImGui.SetTooltip(
"This collection will be modified when using the Installed Mods tab and making changes. It does not apply to anything by itself." );
@ -145,6 +146,7 @@ namespace Penumbra.UI
_manager.Collections.SetCurrentCollection( _collections[ index + 1 ] );
_currentCollectionIndex = index;
_selector.ReloadSelection();
_selector.Cache.ResetModList();
}
}
@ -277,7 +279,7 @@ namespace Penumbra.UI
return;
}
DrawCurrentCollectionSelector();
DrawCurrentCollectionSelector(true);
ImGui.Dummy( new Vector2( 0, 10 ) );
DrawNewCollectionInput();

46
Penumbra/UI/MenuTabs/TabInstalled/ModFilter.cs Normal file
View file

@ -0,0 +1,46 @@
using System;
namespace Penumbra.UI
{
[Flags]
public enum ModFilter
{
Enabled = 1 << 0,
Disabled = 1 << 1,
NoConflict = 1 << 2,
SolvedConflict = 1 << 3,
UnsolvedConflict = 1 << 4,
HasNoMetaManipulations = 1 << 5,
HasMetaManipulations = 1 << 6,
HasNoFileSwaps = 1 << 7,
HasFileSwaps = 1 << 8,
HasConfig = 1 << 9,
HasNoConfig = 1 << 10,
HasNoFiles = 1 << 11,
HasFiles = 1 << 12,
};
public static class ModFilterExtensions
{
public const ModFilter UnfilteredStateMods = ( ModFilter )( ( 1 << 13 ) - 1 );
public static string ToName( this ModFilter filter )
=> filter switch
{
ModFilter.Enabled => "Enabled",
ModFilter.Disabled => "Disabled",
ModFilter.NoConflict => "No Conflicts",
ModFilter.SolvedConflict => "Solved Conflicts",
ModFilter.UnsolvedConflict => "Unsolved Conflicts",
ModFilter.HasNoMetaManipulations => "No Meta Manipulations",
ModFilter.HasMetaManipulations => "Meta Manipulations",
ModFilter.HasNoFileSwaps => "No File Swaps",
ModFilter.HasFileSwaps => "File Swaps",
ModFilter.HasNoConfig => "No Configuration",
ModFilter.HasConfig => "Configuration",
ModFilter.HasNoFiles => "No Files",
ModFilter.HasFiles => "Files",
_ => throw new ArgumentOutOfRangeException( nameof( filter ), filter, null ),
};
}
}

262
Penumbra/UI/MenuTabs/TabInstalled/ModListCache.cs Normal file
View file

@ -0,0 +1,262 @@
using System.Collections.Generic;
using System.Linq;
using Dalamud.Plugin;
using Penumbra.Mods;
namespace Penumbra.UI
{
public class ModListCache
{
public const uint DisabledModColor = 0xFF666666u;
public const uint ConflictingModColor = 0xFFAAAAFFu;
public const uint HandledConflictModColor = 0xFF88DDDDu;
private readonly ModManager _manager;
private readonly List< Mod.Mod > _modsInOrder = new();
private readonly List< (bool visible, uint color) > _visibleMods = new();
private readonly Dictionary< ModFolder, (bool visible, bool enabled) > _visibleFolders = new();
private string _modFilter = "";
private string _modFilterChanges = "";
private string _modFilterAuthor = "";
private ModFilter _stateFilter = ModFilterExtensions.UnfilteredStateMods;
public ModFilter StateFilter
{
get => _stateFilter;
set
{
var diff = _stateFilter != value;
_stateFilter = value;
if( diff )
{
ResetFilters();
}
}
}
public ModListCache( ModManager manager )
{
_manager = manager;
ResetModList();
}
public int Count
=> _modsInOrder.Count;
public void RemoveMod( Mod.Mod mod )
{
var idx = _modsInOrder.IndexOf( mod );
if( idx >= 0 )
{
_modsInOrder.RemoveAt( idx );
_visibleMods.RemoveAt( idx );
UpdateFolders();
}
}
private void UpdateFolders()
{
_visibleFolders.Clear();
for( var i = 0; i < _modsInOrder.Count; ++i )
{
if( _visibleMods[ i ].visible )
{
_visibleFolders[ _modsInOrder[ i ].Data.SortOrder.ParentFolder ] = ( true, true );
}
}
}
public void SetTextFilter( string filter )
{
var lower = filter.ToLowerInvariant();
if( lower.StartsWith( "c:" ) )
{
_modFilterChanges = lower.Substring( 2 );
_modFilter = string.Empty;
_modFilterAuthor = string.Empty;
}
else if( lower.StartsWith( "a:" ) )
{
_modFilterAuthor = lower.Substring( 2 );
_modFilter = string.Empty;
_modFilterChanges = string.Empty;
}
else
{
_modFilter = lower;
_modFilterAuthor = string.Empty;
_modFilterChanges = string.Empty;
}
ResetFilters();
}
public void ResetModList()
{
_modsInOrder.Clear();
_visibleMods.Clear();
_visibleFolders.Clear();
PluginLog.Verbose( "Resetting mod selector list..." );
if( !_modsInOrder.Any() )
{
foreach( var modData in _manager.StructuredMods.AllMods( _manager.Config.SortFoldersFirst ) )
{
var mod = _manager.Collections.CurrentCollection.GetMod( modData );
_modsInOrder.Add( mod );
_visibleMods.Add( CheckFilters( mod ) );
}
}
}
public void ResetFilters()
{
_visibleMods.Clear();
_visibleFolders.Clear();
PluginLog.Verbose( "Resetting mod selector filters..." );
foreach( var mod in _modsInOrder )
{
_visibleMods.Add( CheckFilters( mod ) );
}
}
public (Mod.Mod? mod, int idx) GetModByName( string name )
{
for( var i = 0; i < Count; ++i )
{
if( _modsInOrder[ i ].Data.Meta.Name == name )
{
return ( _modsInOrder[ i ], i );
}
}
return ( null, 0 );
}
public (Mod.Mod? mod, int idx) GetModByBasePath( string basePath )
{
for( var i = 0; i < Count; ++i )
{
if( _modsInOrder[ i ].Data.BasePath.Name == basePath )
{
return ( _modsInOrder[ i ], i );
}
}
return ( null, 0 );
}
public (bool visible, bool enabled) GetFolder( ModFolder folder )
=> _visibleFolders.TryGetValue( folder, out var ret ) ? ret : ( false, false );
public (Mod.Mod?, bool visible, uint color) GetMod( int idx )
=> idx >= 0 && idx < _modsInOrder.Count
? ( _modsInOrder[ idx ], _visibleMods[ idx ].visible, _visibleMods[ idx ].color )
: ( null, false, 0 );
private bool CheckFlags( int count, ModFilter hasNoFlag, ModFilter hasFlag )
{
if( count == 0 )
{
if( StateFilter.HasFlag( hasNoFlag ) )
{
return false;
}
}
else if( StateFilter.HasFlag( hasFlag ) )
{
return false;
}
return true;
}
private (bool, uint) CheckFilters( Mod.Mod mod )
{
var ret = ( false, 0u );
if( _modFilter.Any() && !mod.Data.Meta.LowerName.Contains( _modFilter ) )
{
return ret;
}
if( _modFilterAuthor.Any() && !mod.Data.Meta.LowerAuthor.Contains( _modFilterAuthor ) )
{
return ret;
}
if( _modFilterChanges.Any() && !mod.Data.LowerChangedItemsString.Contains( _modFilterChanges ) )
{
return ret;
}
if( CheckFlags( mod.Data.Resources.ModFiles.Count, ModFilter.HasNoFiles, ModFilter.HasFiles ) )
{
return ret;
}
if( CheckFlags( mod.Data.Meta.FileSwaps.Count, ModFilter.HasNoFileSwaps, ModFilter.HasFileSwaps ) )
{
return ret;
}
if( CheckFlags( mod.Data.Resources.MetaManipulations.Count, ModFilter.HasNoMetaManipulations,
ModFilter.HasMetaManipulations ) )
{
return ret;
}
if( CheckFlags( mod.Data.Meta.HasGroupsWithConfig ? 1 : 0, ModFilter.HasNoConfig, ModFilter.HasConfig ) )
{
return ret;
}
if( !mod.Settings.Enabled )
{
if( !StateFilter.HasFlag( ModFilter.Disabled ) || !StateFilter.HasFlag( ModFilter.NoConflict ) )
{
return ret;
}
ret.Item2 = ret.Item2 == 0 ? DisabledModColor : ret.Item2;
}
if( mod.Settings.Enabled && !StateFilter.HasFlag( ModFilter.Enabled ) )
{
return ret;
}
if( mod.Cache.Conflicts.Any() )
{
if( mod.Cache.Conflicts.Keys.Any( m => m.Settings.Priority == mod.Settings.Priority ) )
{
if( !StateFilter.HasFlag( ModFilter.UnsolvedConflict ) )
{
return ret;
}
ret.Item2 = ret.Item2 == 0 ? ConflictingModColor : ret.Item2;
}
else
{
if( !StateFilter.HasFlag( ModFilter.SolvedConflict ) )
{
return ret;
}
ret.Item2 = ret.Item2 == 0 ? HandledConflictModColor : ret.Item2;
}
}
else if( !StateFilter.HasFlag( ModFilter.NoConflict ) )
{
return ret;
}
ret.Item1 = true;
_visibleFolders[ mod.Data.SortOrder.ParentFolder ] = ( true, true );
return ret;
}
}
}

37
Penumbra/UI/MenuTabs/TabInstalled/TabInstalledDetails.cs
View file

@ -431,6 +431,19 @@ namespace Penumbra.UI
if( changed )
{
_selector.SaveCurrentMod();
// Since files may have changed, we need to recompute effective files.
foreach( var collection in _modManager.Collections.Collections.Values
.Where( c => c.Cache != null && c.Settings[ Mod!.Data.BasePath.Name ].Enabled ) )
{
collection.CalculateEffectiveFileList( _modManager.BasePath, false,
collection == _modManager.Collections.ActiveCollection );
}
// If the mod is enabled in the current collection, its conflicts may have changed.
if( Mod!.Settings.Enabled )
{
_selector.Cache.ResetFilters();
}
}
}
@ -558,14 +571,12 @@ namespace Penumbra.UI
if( ImGui.Checkbox( label, ref enabled ) && oldEnabled != enabled )
{
Mod.Settings.Settings[ group.GroupName ] ^= 1 << idx;
if( Mod.Settings.Enabled && _modManager.Collections.CurrentCollection.Cache != null )
{
_modManager.Collections.CurrentCollection.CalculateEffectiveFileList( Mod.Data.BasePath,
Mod.Data.Resources.MetaManipulations.Count > 0,
_modManager.Collections.CurrentCollection == _modManager.Collections.ActiveCollection );
}
Save();
// If the mod is enabled, recalculate files and filters.
if( Mod.Settings.Enabled )
{
_base.RecalculateCurrent( Mod.Data.Resources.MetaManipulations.Count > 0 );
}
}
}
@ -599,14 +610,12 @@ namespace Penumbra.UI
&& code != Mod.Settings.Settings[ group.GroupName ] )
{
Mod.Settings.Settings[ group.GroupName ] = code;
if( Mod.Settings.Enabled && _modManager.Collections.CurrentCollection.Cache != null )
{
_modManager.Collections.CurrentCollection.CalculateEffectiveFileList( Mod.Data.BasePath,
Mod.Data.Resources.MetaManipulations.Count > 0,
_modManager.Collections.CurrentCollection == _modManager.Collections.ActiveCollection );
}
Save();
// If the mod is enabled, recalculate files and filters.
if( Mod.Settings.Enabled )
{
_base.RecalculateCurrent( Mod.Data.Resources.MetaManipulations.Count > 0 );
}
}
}

39
Penumbra/UI/MenuTabs/TabInstalled/TabInstalledDetailsEdit.cs
View file

@ -111,7 +111,10 @@ namespace Penumbra.UI
var groupName = group.GroupName;
if( Custom.ImGuiCustom.BeginFramedGroupEdit( ref groupName ) )
{
_modManager.ChangeModGroup( group.GroupName, groupName, Mod.Data );
if( _modManager.ChangeModGroup( group.GroupName, groupName, Mod.Data ) && Mod.Data.Meta.RefreshHasGroupsWithConfig() )
{
_selector.Cache.ResetFilters();
}
}
}
@ -127,6 +130,10 @@ namespace Penumbra.UI
group.Options.Add( new Option()
{ OptionName = newOption, OptionDesc = "", OptionFiles = new Dictionary< RelPath, HashSet< GamePath > >() } );
_selector.SaveCurrentMod();
if( Mod!.Data.Meta.RefreshHasGroupsWithConfig() )
{
_selector.Cache.ResetFilters();
}
}
}
@ -163,6 +170,11 @@ namespace Penumbra.UI
{ OptionName = newName, OptionDesc = opt.OptionDesc, OptionFiles = opt.OptionFiles };
_selector.SaveCurrentMod();
}
if( Mod!.Data.Meta.RefreshHasGroupsWithConfig() )
{
_selector.Cache.ResetFilters();
}
}
}
@ -176,7 +188,10 @@ namespace Penumbra.UI
var groupName = group.GroupName;
if( ImGui.InputText( $"##{groupName}_add", ref groupName, 64, ImGuiInputTextFlags.EnterReturnsTrue ) )
{
_modManager.ChangeModGroup( group.GroupName, groupName, Mod.Data );
if( _modManager.ChangeModGroup( group.GroupName, groupName, Mod.Data ) && Mod.Data.Meta.RefreshHasGroupsWithConfig() )
{
_selector.Cache.ResetFilters();
}
}
}
@ -220,6 +235,11 @@ namespace Penumbra.UI
}
}
}
if( Mod.Data.Meta.RefreshHasGroupsWithConfig() )
{
_selector.Cache.ResetFilters();
}
}
if( code != oldSetting )
@ -247,6 +267,7 @@ namespace Penumbra.UI
ImGuiInputTextFlags.EnterReturnsTrue ) )
{
_modManager.ChangeModGroup( "", newGroup, Mod.Data, SelectType.Single );
// Adds empty group, so can not change filters.
}
}
@ -259,6 +280,7 @@ namespace Penumbra.UI
ImGuiInputTextFlags.EnterReturnsTrue ) )
{
_modManager.ChangeModGroup( "", newGroup, Mod.Data, SelectType.Multi );
// Adds empty group, so can not change filters.
}
}
@ -298,7 +320,6 @@ namespace Penumbra.UI
var arrowWidth = ImGui.CalcTextSize( arrow ).X;
ImGui.PopFont();
var width = ( ImGui.GetWindowWidth() - arrowWidth - 4 * ImGui.GetStyle().ItemSpacing.X ) / 2;
for( var idx = 0; idx < swaps.Length + 1; ++idx )
{
@ -325,10 +346,8 @@ namespace Penumbra.UI
}
_selector.SaveCurrentMod();
if( Mod.Settings.Enabled )
{
_selector.ReloadCurrentMod();
}
_selector.ReloadCurrentMod();
_selector.Cache.ResetModList();
}
}
@ -350,10 +369,8 @@ namespace Penumbra.UI
{
Meta.FileSwaps[ key ] = newValue;
_selector.SaveCurrentMod();
if( Mod.Settings.Enabled )
{
_selector.ReloadCurrentMod();
}
_selector.ReloadCurrentMod();
_selector.Cache.ResetModList();
}
}
}

44
Penumbra/UI/MenuTabs/TabInstalled/TabInstalledModPanel.cs
View file

@ -74,8 +74,11 @@ namespace Penumbra.UI
var name = Meta!.Name;
if( Custom.ImGuiCustom.InputOrText( _editMode, LabelEditName, ref name, 64 ) && _modManager.RenameMod( name, Mod!.Data ) )
{
_selector.RenameCurrentModLower( name );
_selector.SelectModByDir( Mod.Data.BasePath.Name );
if( !_modManager.Config.ModSortOrder.ContainsKey( Mod!.Data.BasePath.Name ) && Mod.Data.Rename( name ) )
{
_selector.Cache.ResetModList();
}
}
}
@ -119,6 +122,7 @@ namespace Penumbra.UI
{
Meta.Author = author;
_selector.SaveCurrentMod();
_selector.Cache.ResetFilters();
}
ImGui.EndGroup();
@ -200,13 +204,8 @@ namespace Penumbra.UI
if( ImGui.InputInt( "Priority", ref priority, 0 ) && priority != Mod!.Settings.Priority )
{
Mod.Settings.Priority = priority;
var collection = _modManager.Collections.CurrentCollection;
collection.Save( _base._plugin.PluginInterface! );
if( collection.Cache != null )
{
collection.CalculateEffectiveFileList( _modManager.BasePath, Mod.Data.Resources.MetaManipulations.Count > 0,
collection == _modManager.Collections.ActiveCollection );
}
_selector.Cache.ResetFilters();
_base.SaveCurrentCollection( Mod.Data.Resources.MetaManipulations.Count > 0 );
}
if( ImGui.IsItemHovered() )
@ -222,23 +221,19 @@ namespace Penumbra.UI
if( ImGui.Checkbox( LabelModEnabled, ref enabled ) )
{
Mod.Settings.Enabled = enabled;
var collection = _modManager.Collections.CurrentCollection;
collection.Save( _base._plugin.PluginInterface! );
if( collection.Cache != null )
{
collection.CalculateEffectiveFileList( _modManager.BasePath, Mod.Data.Resources.MetaManipulations.Count > 0,
collection == _modManager.Collections.ActiveCollection );
}
_selector.Cache.ResetFilters();
_base.SaveCurrentCollection( Mod.Data.Resources.MetaManipulations.Count > 0 );
}
}
public static bool DrawSortOrder( ModData mod, ModManager manager, Selector selector )
{
var currentSortOrder = mod.SortOrder;
var currentSortOrder = mod.SortOrder.FullPath;
ImGui.SetNextItemWidth( 300 );
if( ImGui.InputText( "Sort Order", ref currentSortOrder, 256, ImGuiInputTextFlags.EnterReturnsTrue ) )
{
manager.ChangeSortOrder( mod, currentSortOrder );
selector.Cache.ResetModList();
selector.SelectModByDir( mod.BasePath.Name );
return true;
}
@ -337,7 +332,6 @@ namespace Penumbra.UI
{
Service< ModManager >.Get()!.RenameModFolder( Mod.Data, newDir, false );
_selector.ResetModNamesLower();
_selector.SelectModByDir( _newName );
closeParent = true;
@ -400,7 +394,6 @@ namespace Penumbra.UI
}
}
private void DrawRenameModFolderButton()
{
DrawRenameModFolderPopup();
@ -452,7 +445,9 @@ namespace Penumbra.UI
if( ImGui.IsItemHovered() )
{
ImGui.SetTooltip(
"Force a recomputation of the metadata_manipulations.json file from all .meta files in the folder.\nAlso reloads the mod.\nBe aware that this removes all manually added metadata changes." );
"Force a recomputation of the metadata_manipulations.json file from all .meta files in the folder.\n"
+ "Also reloads the mod.\n"
+ "Be aware that this removes all manually added metadata changes." );
}
}
@ -507,11 +502,6 @@ namespace Penumbra.UI
public void Draw()
{
if( Mod == null )
{
return;
}
try
{
var ret = ImGui.BeginChild( LabelModPanel, AutoFillSize, true );
@ -520,6 +510,12 @@ namespace Penumbra.UI
return;
}
if( Mod == null )
{
ImGui.EndChild();
return;
}
DrawHeaderLine();
// Next line with fixed distance.

1046
Penumbra/UI/MenuTabs/TabInstalled/TabInstalledSelector.cs
View file

File diff suppressed because it is too large Load diff

13
Penumbra/UI/MenuTabs/TabSettings.cs
View file

@ -22,6 +22,7 @@ namespace Penumbra.UI
private const string LabelEnabled = "Enable Mods";
private const string LabelEnabledPlayerWatch = "Enable automatic Character Redraws";
private const string LabelWaitFrames = "Wait Frames";
private const string LabelSortFoldersFirst = "Sort Mod Folders Before Mods";
private const string LabelScaleModSelector = "Scale Mod Selector With Window Size";
private const string LabelShowAdvanced = "Show Advanced Settings";
private const string LabelLogLoadedFiles = "Log all loaded files";
@ -100,6 +101,17 @@ namespace Penumbra.UI
}
}
private void DrawSortFoldersFirstBox()
{
var foldersFirst = _config.SortFoldersFirst;
if( ImGui.Checkbox( LabelSortFoldersFirst, ref foldersFirst ) )
{
_config.SortFoldersFirst = foldersFirst;
_base._menu.InstalledTab.Selector.Cache.ResetModList();
_configChanged = true;
}
}
private void DrawScaleModSelectorBox()
{
var scaleModSelector = _config.ScaleModSelector;
@ -238,6 +250,7 @@ namespace Penumbra.UI
Custom.ImGuiCustom.VerticalDistance( DefaultVerticalSpace );
DrawScaleModSelectorBox();
DrawSortFoldersFirstBox();
DrawShowAdvancedBox();
if( _config.ShowAdvanced )

25
Penumbra/UI/SettingsInterface.cs
View file

@ -16,6 +16,7 @@ namespace Penumbra.UI
private readonly ManageModsButton _manageModsButton;
private readonly MenuBar _menuBar;
private readonly SettingsMenu _menu;
private readonly ModManager _modManager;
public SettingsInterface( Plugin plugin )
{
@ -23,6 +24,7 @@ namespace Penumbra.UI
_manageModsButton = new ManageModsButton( this );
_menuBar = new MenuBar( this );
_menu = new SettingsMenu( this );
_modManager = Service< ModManager >.Get();
}
public void FlipVisibility()
@ -40,12 +42,27 @@ namespace Penumbra.UI
private void ReloadMods()
{
_menu.InstalledTab.Selector.ResetModNamesLower();
_menu.InstalledTab.Selector.ClearSelection();
_modManager.DiscoverMods( _plugin.Configuration.ModDirectory );
_menu.InstalledTab.Selector.Cache.ResetModList();
}
var modManager = Service< ModManager >.Get();
modManager.DiscoverMods( _plugin.Configuration.ModDirectory );
_menu.InstalledTab.Selector.ResetModNamesLower();
private void SaveCurrentCollection( bool recalculateMeta )
{
var current = _modManager.Collections.CurrentCollection;
current.Save( _plugin.PluginInterface );
RecalculateCurrent( recalculateMeta );
}
private void RecalculateCurrent( bool recalculateMeta )
{
var current = _modManager.Collections.CurrentCollection;
if( current.Cache != null )
{
current.CalculateEffectiveFileList( _modManager.BasePath, recalculateMeta,
current == _modManager.Collections.ActiveCollection );
_menu.InstalledTab.Selector.Cache.ResetFilters();
}
}
}
}

30
Penumbra/UI/SettingsMenu.cs
View file

@ -14,23 +14,23 @@ namespace Penumbra.UI
public static readonly Vector2 MinSettingsSize = new( 800, 450 );
public static readonly Vector2 MaxSettingsSize = new( 69420, 42069 );
private readonly SettingsInterface _base;
private readonly TabSettings _settingsTab;
private readonly TabImport _importTab;
private readonly TabBrowser _browserTab;
private readonly TabCollections _collectionsTab;
public readonly TabInstalled InstalledTab;
private readonly TabEffective _effectiveTab;
private readonly SettingsInterface _base;
private readonly TabSettings _settingsTab;
private readonly TabImport _importTab;
private readonly TabBrowser _browserTab;
internal readonly TabCollections CollectionsTab;
internal readonly TabInstalled InstalledTab;
private readonly TabEffective _effectiveTab;
public SettingsMenu( SettingsInterface ui )
{
_base = ui;
_settingsTab = new TabSettings( _base );
_importTab = new TabImport( _base );
_browserTab = new TabBrowser();
InstalledTab = new TabInstalled( _base );
_collectionsTab = new TabCollections( InstalledTab.Selector );
_effectiveTab = new TabEffective();
_base = ui;
_settingsTab = new TabSettings( _base );
_importTab = new TabImport( _base );
_browserTab = new TabBrowser();
InstalledTab = new TabInstalled( _base );
CollectionsTab = new TabCollections( InstalledTab.Selector );
_effectiveTab = new TabEffective();
}
#if DEBUG
@ -62,7 +62,7 @@ namespace Penumbra.UI
ImGui.BeginTabBar( PenumbraSettingsLabel );
_settingsTab.Draw();
_collectionsTab.Draw();
CollectionsTab.Draw();
_importTab.Draw();
if( Service< ModManager >.Get().Valid && !_importTab.IsImporting() )