Penumbra/Penumbra/UI/ConfigWindow.ModsTab.cs

using ImGuiNET;
using OtterGui;
using OtterGui.Raii;
using Penumbra.Collections;
using Penumbra.UI.Classes;
using System;
using System.Linq;
using System.Numerics;
using Dalamud.Interface;
using OtterGui.Widgets;
using Penumbra.Api.Enums;

namespace Penumbra.UI;

public partial class ConfigWindow
{
    private class ModsTab : ITab
    {
        private readonly ModFileSystemSelector _selector;
        private readonly ModPanel              _panel;
        private readonly Penumbra              _penumbra;

        public ModsTab(ModFileSystemSelector selector, ModPanel panel, Penumbra penumbra)
        {
            _selector = selector;
            _panel    = panel;
            _penumbra = penumbra;
        }

        public bool IsVisible
            => Penumbra.ModManager.Valid;

        public ReadOnlySpan<byte> Label
            => "Mods"u8;

        public void DrawHeader()
            => OpenTutorial( BasicTutorialSteps.Mods );

        public void DrawContent()
        {
            try
            {
                _selector.Draw( GetModSelectorSize() );
                ImGui.SameLine();
                using var group = ImRaii.Group();
                DrawHeaderLine();

                using var style = ImRaii.PushStyle( ImGuiStyleVar.ItemSpacing, Vector2.Zero );

                using( var child = ImRaii.Child( "##ModsTabMod", new Vector2( -1, Penumbra.Config.HideRedrawBar ? 0 : -ImGui.GetFrameHeight() ),
                          true, ImGuiWindowFlags.HorizontalScrollbar ) )
                {
                    style.Pop();
                    if( child )
                    {
                        _panel.Draw( _selector );
                    }

                    style.Push( ImGuiStyleVar.ItemSpacing, Vector2.Zero );
                }

                style.Push( ImGuiStyleVar.FrameRounding, 0 );
                DrawRedrawLine();
            }
            catch( Exception e )
            {
                Penumbra.Log.Error( $"Exception thrown during ModPanel Render:\n{e}" );
                Penumbra.Log.Error( $"{Penumbra.ModManager.Count} Mods\n"
                  + $"{Penumbra.CollectionManager.Current.AnonymizedName} Current Collection\n"
                  + $"{Penumbra.CollectionManager.Current.Settings.Count} Settings\n"
                  + $"{_selector.SortMode.Name} Sort Mode\n"
                  + $"{_selector.SelectedLeaf?.Name ?? "NULL"} Selected Leaf\n"
                  + $"{_selector.Selected?.Name     ?? "NULL"} Selected Mod\n"
                  + $"{string.Join( ", ", Penumbra.CollectionManager.Current.Inheritance.Select( c => c.AnonymizedName ) )} Inheritances\n"
                  + $"{_selector.SelectedSettingCollection.AnonymizedName} Collection\n" );
            }
        }

        private void DrawRedrawLine()
        {
            if( Penumbra.Config.HideRedrawBar )
            {
                SkipTutorial( BasicTutorialSteps.Redrawing );
                return;
            }

            var frameHeight = new Vector2( 0, ImGui.GetFrameHeight() );
            var frameColor = ImGui.GetColorU32( ImGuiCol.FrameBg );
            using( var _ = ImRaii.Group() )
            {
                using( var font = ImRaii.PushFont( UiBuilder.IconFont ) )
                {
                    ImGuiUtil.DrawTextButton( FontAwesomeIcon.InfoCircle.ToIconString(), frameHeight, frameColor );
                    ImGui.SameLine();
                }

                ImGuiUtil.DrawTextButton( "Redraw:        ", frameHeight, frameColor );
            }

            var hovered = ImGui.IsItemHovered();
            OpenTutorial( BasicTutorialSteps.Redrawing );
            if( hovered )
            {
                ImGui.SetTooltip( $"The supported modifiers for '/penumbra redraw' are:\n{SupportedRedrawModifiers}" );
            }

            void DrawButton( Vector2 size, string label, string lower )
            {
                if( ImGui.Button( label, size ) )
                {
                    if( lower.Length > 0 )
                    {
                        _penumbra.ObjectReloader.RedrawObject( lower, RedrawType.Redraw );
                    }
                    else
                    {
                        _penumbra.ObjectReloader.RedrawAll( RedrawType.Redraw );
                    }
                }

                ImGuiUtil.HoverTooltip( lower.Length > 0 ? $"Execute '/penumbra redraw {lower}'." : $"Execute '/penumbra redraw'." );
            }

            using var disabled = ImRaii.Disabled( Dalamud.ClientState.LocalPlayer == null );
            ImGui.SameLine();
            var buttonWidth = frameHeight with { X = ImGui.GetContentRegionAvail().X / 4 };
            DrawButton( buttonWidth, "All", string.Empty );
            ImGui.SameLine();
            DrawButton( buttonWidth, "Self", "self" );
            ImGui.SameLine();
            DrawButton( buttonWidth, "Target", "target" );
            ImGui.SameLine();
            DrawButton( frameHeight with { X = ImGui.GetContentRegionAvail().X - 1 }, "Focus", "focus" );
        }

        // Draw the header line that can quick switch between collections.
        private void DrawHeaderLine()
        {
            using var style = ImRaii.PushStyle( ImGuiStyleVar.FrameRounding, 0 ).Push( ImGuiStyleVar.ItemSpacing, Vector2.Zero );
            var buttonSize = new Vector2( ImGui.GetContentRegionAvail().X / 8f, 0 );

            using( var _ = ImRaii.Group() )
            {
                DrawDefaultCollectionButton( 3 * buttonSize );
                ImGui.SameLine();
                DrawInheritedCollectionButton( 3 * buttonSize );
                ImGui.SameLine();
                DrawCollectionSelector( "##collectionSelector", 2 * buttonSize.X, CollectionType.Current, false );
            }

            OpenTutorial( BasicTutorialSteps.CollectionSelectors );

            if( !Penumbra.CollectionManager.CurrentCollectionInUse )
            {
                ImGuiUtil.DrawTextButton( "The currently selected collection is not used in any way.", -Vector2.UnitX, Colors.PressEnterWarningBg );
            }
        }

        private static void DrawDefaultCollectionButton( Vector2 width )
        {
            var name = $"{DefaultCollection} ({Penumbra.CollectionManager.Default.Name})";
            var isCurrent = Penumbra.CollectionManager.Default == Penumbra.CollectionManager.Current;
            var isEmpty = Penumbra.CollectionManager.Default == ModCollection.Empty;
            var tt = isCurrent ? $"The current collection is already the configured {DefaultCollection}."
                : isEmpty ? $"The {DefaultCollection} is configured to be empty."
                                 : $"Set the {SelectedCollection} to the configured {DefaultCollection}.";
            if( ImGuiUtil.DrawDisabledButton( name, width, tt, isCurrent || isEmpty ) )
            {
                Penumbra.CollectionManager.SetCollection( Penumbra.CollectionManager.Default, CollectionType.Current );
            }
        }

        private void DrawInheritedCollectionButton( Vector2 width )
        {
            var noModSelected = _selector.Selected == null;
            var collection = _selector.SelectedSettingCollection;
            var modInherited = collection != Penumbra.CollectionManager.Current;
            var (name, tt) = (noModSelected, modInherited) switch
            {
                (true, _ ) => ("Inherited Collection", "No mod selected."),
                (false, true ) => ($"Inherited Collection ({collection.Name})",
                    "Set the current collection to the collection the selected mod inherits its settings from."),
                (false, false ) => ("Not Inherited", "The selected mod does not inherit its settings."),
            };
            if( ImGuiUtil.DrawDisabledButton( name, width, tt, noModSelected || !modInherited ) )
            {
                Penumbra.CollectionManager.SetCollection( collection, CollectionType.Current );
            }
        }

        // Get the correct size for the mod selector based on current config.
        private static float GetModSelectorSize()
        {
            var absoluteSize = Math.Clamp( Penumbra.Config.ModSelectorAbsoluteSize, Configuration.Constants.MinAbsoluteSize,
                Math.Min( Configuration.Constants.MaxAbsoluteSize, ImGui.GetContentRegionAvail().X - 100 ) );
            var relativeSize = Penumbra.Config.ScaleModSelector
                ? Math.Clamp( Penumbra.Config.ModSelectorScaledSize, Configuration.Constants.MinScaledSize, Configuration.Constants.MaxScaledSize )
                : 0;
            return !Penumbra.Config.ScaleModSelector
                ? absoluteSize
                : Math.Max( absoluteSize, relativeSize * ImGui.GetContentRegionAvail().X / 100 );
        }
    }
}