v1.0.8.23: Main Menu bar; Duty List transparent background

Made-with: Cursor

Config/ConfigurationManager.cs

@@ -45,6 +45,7 @@ namespace HSUI.Config
         private MainConfigWindow _mainConfigWindow;
         private ChangelogWindow _changelogWindow;
         private GridWindow _gridWindow;
+        private ControllerBarKeybindsWindow _controllerBarKeybindsWindow;
 
         public bool IsConfigWindowOpened => _mainConfigWindow.IsOpen;
         public bool IsChangelogWindowOpened => _changelogWindow.IsOpen;
@@ -145,11 +146,13 @@ namespace HSUI.Config
             string changelog = LoadChangelog();
             _changelogWindow = new ChangelogWindow("HSUI Changelog v" + Plugin.Version, changelog);
             _gridWindow = new GridWindow("Grid ##HSUI");
+            _controllerBarKeybindsWindow = new ControllerBarKeybindsWindow();
 
             _windowSystem = new WindowSystem("HSUI_Windows");
             _windowSystem.AddWindow(_mainConfigWindow);
             _windowSystem.AddWindow(_changelogWindow);
             _windowSystem.AddWindow(_gridWindow);
+            _windowSystem.AddWindow(_controllerBarKeybindsWindow);
 
             CheckVersion();
 
@@ -336,6 +339,11 @@ namespace HSUI.Config
             _changelogWindow.IsOpen = true;
         }
 
+        public void OpenControllerBarKeybindsWindow()
+        {
+            _controllerBarKeybindsWindow.IsOpen = true;
+        }
+
         public void Draw()
         {
             _windowSystem.Draw();
@@ -687,9 +695,21 @@ namespace HSUI.Config
             typeof(Hotbar8BarConfig),
             typeof(Hotbar9BarConfig),
             typeof(Hotbar10BarConfig),
+            typeof(ControllerHotbarsConfig),
+            typeof(ControllerBar1Config),
+            typeof(ControllerBar2Config),
+            typeof(ControllerBar3Config),
+            typeof(ControllerBar4Config),
+            typeof(ControllerBar5Config),
+            typeof(ControllerBar6Config),
+            typeof(ControllerBar7Config),
+            typeof(ControllerBar8Config),
+            typeof(ControllerBarKeybindsConfig),
             typeof(PullTimerConfig),
             typeof(LimitBreakConfig),
             typeof(MPTickerConfig),
+            typeof(DutyListScenarioConfig),
+            typeof(MainMenuConfig),
 
             // Colors
             typeof(TanksColorConfig),
@@ -706,7 +726,6 @@ namespace HSUI.Config
 
             // Visibility
             typeof(GlobalVisibilityConfig),
-            typeof(HotbarsVisibilityConfig),
 
             // Misc
             typeof(HUDOptionsConfig),

Config/Windows/ControllerBarKeybindsWindow.cs

@@ -0,0 +1,245 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using Dalamud.Game.ClientState.GamePad;
+using Dalamud.Game.ClientState.Keys;
+using Dalamud.Interface.Windowing;
+using HSUI.Config;
+using HSUI.Interface.GeneralElements;
+using Dalamud.Bindings.ImGui;
+
+namespace HSUI.Config.Windows
+{
+    public class ControllerBarKeybindsWindow : Window
+    {
+        private ControllerBarKeybindsConfig? _config;
+        private int _selectedBar = 1;
+        private int _listeningBar = -1;
+        private int _listeningSlot = -1;
+        private HashSet<VirtualKey>? _listeningLastKeys;
+        private HashSet<GamepadButtons>? _listeningLastPads;
+
+        private const int SlotsPerBar = 8;
+        private static readonly GamepadButtons[] ModifierButtons = { GamepadButtons.L1, GamepadButtons.L2, GamepadButtons.R1, GamepadButtons.R2 };
+        private static readonly VirtualKey[] ModifierKeys = { VirtualKey.LSHIFT, VirtualKey.RSHIFT, VirtualKey.LCONTROL, VirtualKey.RCONTROL, VirtualKey.LMENU, VirtualKey.RMENU };
+        private const float CellSize = 44;
+        private const float Pad = 4;
+        private const float Gap = 8;
+
+        public ControllerBarKeybindsWindow() : base("Controller bar keybinds")
+        {
+            Size = new Vector2(520, 380);
+            SizeCondition = ImGuiCond.FirstUseEver;
+            Flags = ImGuiWindowFlags.NoScrollbar;
+        }
+
+        public override void Draw()
+        {
+            _config = ConfigurationManager.Instance?.GetConfigObject<ControllerBarKeybindsConfig>();
+            if (_config == null) return;
+
+            ImGui.Text("Assign keyboard or gamepad buttons to controller cross bar slots.");
+            ImGui.Spacing();
+
+            // Bar selector
+            ImGui.Text("Cross bar:");
+            ImGui.SameLine(100);
+            for (int b = 1; b <= 8; b++)
+            {
+                if (b > 1) ImGui.SameLine();
+                if (ImGui.Button($"{(b == _selectedBar ? "[" : " ")}{b}{(b == _selectedBar ? "]" : " ")}", new Vector2(32, 0)))
+                    _selectedBar = b;
+            }
+            ImGui.Spacing();
+            ImGui.Separator();
+            ImGui.Spacing();
+
+            if (_listeningBar >= 0 && _listeningSlot >= 0)
+            {
+                ImGui.TextColored(new Vector4(1, 0.8f, 0, 1), "Hold trigger (L2/R2/L1/R1) or modifier (Shift/Ctrl/Alt), then press a key or button. Or press a key/button alone.");
+                ImGui.SameLine();
+                if (ImGui.Button("Cancel"))
+                {
+                    _listeningBar = -1;
+                    _listeningSlot = -1;
+                    _listeningLastKeys = null;
+                    _listeningLastPads = null;
+                }
+                PollAndAssign();
+            }
+            else
+            {
+                ImGui.Text($"Bar {_selectedBar} — click a slot, then hold modifiers (e.g. L2) and press a button. Right-click to clear.");
+            }
+
+            ImGui.Spacing();
+
+            // Two crosses side by side (same layout as CrossBarHud)
+            float leftCrossW = 3 * (CellSize + Pad);
+            float startX = ImGui.GetCursorScreenPos().X;
+            float startY = ImGui.GetCursorScreenPos().Y;
+
+            for (int slot = 0; slot < SlotsPerBar; slot++)
+            {
+                (int col, int row) = GetCrossSlotLayout(slot);
+                float x = startX + (slot < 4 ? col * (CellSize + Pad) : leftCrossW + Gap + col * (CellSize + Pad));
+                float y = startY + row * (CellSize + Pad);
+
+                ImGui.SetCursorScreenPos(new Vector2(x, y));
+                string current = _config.GetKeybind(_selectedBar, slot);
+                string label = string.IsNullOrEmpty(current) ? "None" : GetKeybindDisplayName(current);
+                bool listening = _listeningBar == _selectedBar && _listeningSlot == slot;
+
+                if (listening)
+                    ImGui.PushStyleColor(ImGuiCol.Button, new Vector4(0.4f, 0.6f, 0.2f, 0.8f));
+                if (ImGui.Button($"##bar{_selectedBar}_slot{slot}", new Vector2(CellSize, CellSize)))
+                {
+                    _listeningBar = _selectedBar;
+                    _listeningSlot = slot;
+                }
+                if (listening) ImGui.PopStyleColor();
+
+                if (ImGui.IsItemHovered())
+                {
+                    if (ImGui.IsMouseClicked(ImGuiMouseButton.Right))
+                    {
+                        _config.SetKeybind(_selectedBar, slot, "");
+                        ConfigurationManager.Instance?.SaveConfigurations();
+                    }
+                }
+
+                string shortLabel = label.Length > 6 ? label.Substring(0, 6) + "…" : label;
+                Vector2 textSize = ImGui.CalcTextSize(shortLabel);
+                ImGui.SetCursorScreenPos(new Vector2(x + (CellSize - textSize.X) * 0.5f, y + (CellSize - textSize.Y) * 0.5f));
+                ImGui.Text(shortLabel);
+            }
+
+            ImGui.SetCursorScreenPos(new Vector2(startX, startY + 3 * (CellSize + Pad) + 20));
+            ImGui.Spacing();
+            if (ImGui.Button("Close"))
+                IsOpen = false;
+        }
+
+        private static (int col, int row) GetCrossSlotLayout(int slotIndex)
+        {
+            if (slotIndex < 4)
+                return slotIndex switch { 0 => (1, 0), 1 => (0, 1), 2 => (2, 1), _ => (1, 2) };
+            int i = slotIndex - 4;
+            return i switch { 0 => (1, 0), 1 => (0, 1), 2 => (2, 1), _ => (1, 2) };
+        }
+
+        private void PollAndAssign()
+        {
+            var currentKeys = new HashSet<VirtualKey>();
+            var currentPads = new HashSet<GamepadButtons>();
+
+            if (Plugin.KeyState != null)
+            {
+                foreach (var vk in Plugin.KeyState.GetValidVirtualKeys())
+                {
+                    if (vk == VirtualKey.ESCAPE) continue;
+                    if (Plugin.KeyState[vk])
+                        currentKeys.Add(vk);
+                }
+            }
+            if (Plugin.GamepadState != null)
+            {
+                foreach (var btn in GetGamepadButtonsToPoll())
+                {
+                    if (Plugin.GamepadState.Raw(btn) > 0.5f)
+                        currentPads.Add(btn);
+                }
+            }
+
+            // First frame of listening: record state as "last" and wait for next frame
+            if (_listeningLastKeys == null)
+            {
+                _listeningLastKeys = new HashSet<VirtualKey>(currentKeys);
+                _listeningLastPads = new HashSet<GamepadButtons>(currentPads);
+                return;
+            }
+
+            var modifierKeySet = new HashSet<VirtualKey>(ModifierKeys);
+            var modifierPadSet = new HashSet<GamepadButtons>(ModifierButtons);
+
+            var heldModifierKeys = new HashSet<VirtualKey>(currentKeys.Where(k => modifierKeySet.Contains(k) && _listeningLastKeys.Contains(k)));
+            var heldModifierPads = new HashSet<GamepadButtons>(currentPads.Where(b => modifierPadSet.Contains(b) && _listeningLastPads!.Contains(b)));
+
+            string? triggerPart = null;
+            foreach (var vk in Plugin.KeyState?.GetValidVirtualKeys() ?? Array.Empty<VirtualKey>())
+            {
+                if (vk == VirtualKey.ESCAPE) continue;
+                if (currentKeys.Contains(vk) && !_listeningLastKeys.Contains(vk))
+                {
+                    triggerPart = "Key:" + vk;
+                    break;
+                }
+            }
+            if (triggerPart == null && Plugin.GamepadState != null)
+            {
+                foreach (var btn in GetGamepadButtonsToPoll())
+                {
+                    if (currentPads.Contains(btn) && !_listeningLastPads!.Contains(btn))
+                    {
+                        triggerPart = "Pad:" + btn;
+                        break;
+                    }
+                }
+            }
+
+            _listeningLastKeys = new HashSet<VirtualKey>(currentKeys);
+            _listeningLastPads = new HashSet<GamepadButtons>(currentPads);
+
+            if (triggerPart == null) return;
+
+            var parts = new List<string>();
+            foreach (var vk in heldModifierKeys.OrderBy(k => k.ToString()))
+                parts.Add("Key:" + vk);
+            foreach (var btn in heldModifierPads.OrderBy(b => b.ToString()))
+                parts.Add("Pad:" + btn);
+            parts.Add(triggerPart);
+
+            string assigned = string.Join("+", parts);
+            if (_listeningBar >= 0 && _listeningSlot >= 0 && _config != null)
+            {
+                _config.SetKeybind(_listeningBar, _listeningSlot, assigned);
+                ConfigurationManager.Instance?.SaveConfigurations();
+                _listeningBar = -1;
+                _listeningSlot = -1;
+                _listeningLastKeys = null;
+                _listeningLastPads = null;
+            }
+        }
+
+        private static IEnumerable<GamepadButtons> GetGamepadButtonsToPoll()
+        {
+            return new[]
+            {
+                GamepadButtons.DpadUp, GamepadButtons.DpadDown, GamepadButtons.DpadLeft, GamepadButtons.DpadRight,
+                GamepadButtons.North, GamepadButtons.South, GamepadButtons.West, GamepadButtons.East,
+                GamepadButtons.L1, GamepadButtons.L2, GamepadButtons.L3,
+                GamepadButtons.R1, GamepadButtons.R2, GamepadButtons.R3,
+                GamepadButtons.Start, GamepadButtons.Select
+            };
+        }
+
+        private static string GetKeybindDisplayName(string value)
+        {
+            if (string.IsNullOrEmpty(value)) return "None";
+            var parts = value.Split('+');
+            var display = new List<string>();
+            foreach (var p in parts)
+            {
+                string s = p.Trim();
+                if (s.StartsWith("Key:", StringComparison.OrdinalIgnoreCase))
+                    display.Add(s.Length > 4 ? s.Substring(4).Replace("VK_", "") : s);
+                else if (s.StartsWith("Pad:", StringComparison.OrdinalIgnoreCase))
+                    display.Add(s.Length > 4 ? s.Substring(4) : s);
+                else
+                    display.Add(s);
+            }
+            return string.Join(" + ", display);
+        }
+    }
+}

Enums/ElementKind.cs

@@ -40,6 +40,9 @@ public enum ElementKind : uint
     EnemyList = 0xB8BD6685,      // _EnemyList_a
 
     // Misc HUD
+    MainMenu = 0x8AF95A70,        // _MainCommand_a (Main Menu)
+    ToDoList = 0xA29100D2,        // _ToDoList_a (Duty List)
+    ScenarioTree = 0x88EE6357,    // ScenarioTree_a (Scenario Guide)
     ExperienceBar = 0x21E53CCE,  // _Exp_a
     LimitGauge = 0xC79F450A,     // _LimitBreak_a
     StatusEffects = 0x4A569616,  // _Status_a

HSUI.csproj

@@ -9,9 +9,9 @@
 
 	<PropertyGroup>
 		<AssemblyName>HSUI</AssemblyName>
-		<AssemblyVersion>1.0.8.14</AssemblyVersion>
-		<FileVersion>1.0.8.14</FileVersion>
-		<InformationalVersion>1.0.8.14</InformationalVersion>
+		<AssemblyVersion>1.0.8.23</AssemblyVersion>
+		<FileVersion>1.0.8.23</FileVersion>
+		<InformationalVersion>1.0.8.23</InformationalVersion>
 	</PropertyGroup>
 
 	<PropertyGroup>
@@ -56,4 +56,18 @@
 		<PackageReference Include="Colourful" Version="3.2.0" />
 		<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
 	</ItemGroup>
+
+	<!-- Deploy Release build to devPlugins so the game loads it automatically -->
+	<Target Name="DeployToDevPlugins" AfterTargets="Build" Condition="'$(Configuration)'=='Release'">
+		<PropertyGroup>
+			<_HomeDir>$([System.Environment]::GetEnvironmentVariable('HOME'))</_HomeDir>
+			<_UserProfile>$([System.Environment]::GetEnvironmentVariable('USERPROFILE'))</_UserProfile>
+			<DevPluginsDir Condition="'$(_HomeDir)' != ''">$(_HomeDir)/.xlcore/devPlugins/HSUI</DevPluginsDir>
+			<DevPluginsDir Condition="'$(DevPluginsDir)' == '' and '$(_UserProfile)' != ''">$(_UserProfile)/.xlcore/devPlugins/HSUI</DevPluginsDir>
+			<DevPluginsDir Condition="'$(DevPluginsDir)' == ''">$(UserProfile)/.xlcore/devPlugins/HSUI</DevPluginsDir>
+		</PropertyGroup>
+		<MakeDir Directories="$(DevPluginsDir)" Condition="'$(DevPluginsDir)' != '' and !Exists('$(DevPluginsDir)')" />
+		<Copy SourceFiles="$(OutputPath)HSUI.dll" DestinationFolder="$(DevPluginsDir)" SkipUnchangedFiles="true" Condition="'$(DevPluginsDir)' != '' and Exists('$(DevPluginsDir)')" />
+		<Message Importance="high" Text="Deployed HSUI.dll to $(DevPluginsDir)" Condition="'$(DevPluginsDir)' != ''" />
+	</Target>
 </Project>

HSUI.json

@@ -2,7 +2,7 @@
   "Author": "Knack117",
   "Name": "HSUI",
   "InternalName": "HSUI",
-  "AssemblyVersion": "1.0.8.14",
+  "AssemblyVersion": "1.0.8.23",
   "Description": "HSUI provides a highly configurable HUD replacement for FFXIV, recreated from DelvUI using KamiToolKit, FFXIVClientStructs, and Dalamud. Features unit frames, castbars, job gauges, nameplates, party frames, status effects, enemy list, configurable hotbars with drag-and-drop, and profiles.",
   "ApplicableVersion": "any",
   "RepoUrl": "https://github.com/Knack117/HSUI",

Helpers/ActionBarsManager.cs

@@ -7,6 +7,8 @@ using FFXIVClientStructs.FFXIV.Client.Game;
 using FFXIVClientStructs.FFXIV.Client.System.String;
 using FFXIVClientStructs.FFXIV.Client.UI;
 using FFXIVClientStructs.FFXIV.Client.UI.Misc;
+using HSUI.Config;
+using HSUI.Interface.GeneralElements;
 using KamiToolKit.Controllers;
 using static FFXIVClientStructs.FFXIV.Client.Game.ActionManager;
 
@@ -192,6 +194,148 @@ namespace HSUI.Helpers
             return list;
         }
 
+        /// <summary>Scratch bar/slot used to build SlotInfo or execute from (type, id) without touching game bars 1-8. Bar 10 slot 0.</summary>
+        internal const int ScratchBarIndex = 10;
+        internal const int ScratchSlotIndex = 0;
+
+        /// <summary>Get SlotInfo for a single (type, id) by temporarily writing to scratch slot and reading. Used for controller bars.</summary>
+        private unsafe SlotInfo GetSlotInfoViaScratch(RaptureHotbarModule.HotbarSlotType slotType, uint commandId)
+        {
+            var module = RaptureHotbarModule.Instance();
+            if (module == null || !module->ModuleReady)
+                return new SlotInfo(0, true, false, 0, 0, 0, 0, "", 0, 0);
+            int barIdx = ScratchBarIndex - 1;
+            var slotPtr = module->GetSlotById((uint)barIdx, (uint)ScratchSlotIndex);
+            if (slotPtr == null)
+                return new SlotInfo(0, true, false, 0, 0, 0, 0, "", 0, 0);
+            uint saveType = (uint)slotPtr->CommandType;
+            uint saveId = slotPtr->CommandId;
+            try
+            {
+                slotPtr->Set(slotType, commandId);
+                slotPtr->LoadIconId();
+                if (slotType == RaptureHotbarModule.HotbarSlotType.Item)
+                    slotPtr->LoadCostDataForSlot(true);
+                var list = GetSlotData(ScratchBarIndex, 1);
+                return list.Count > 0 ? list[0] : new SlotInfo(0, true, false, 0, 0, 0, 0, "", 0, 0);
+            }
+            finally
+            {
+                slotPtr->Set((RaptureHotbarModule.HotbarSlotType)saveType, saveId);
+                slotPtr->LoadIconId();
+            }
+        }
+
+        /// <summary>Get slot data for a controller cross bar (1-8) from persisted controller storage. Returns 8 SlotInfos.</summary>
+        public unsafe List<SlotInfo> GetControllerSlotData(int barIndex, int slotCount)
+        {
+            var list = new List<SlotInfo>(slotCount);
+            var barConfig = ControllerBarConfig.GetBarConfig(barIndex);
+            if (barConfig == null)
+            {
+                for (int i = 0; i < slotCount; i++)
+                    list.Add(new SlotInfo(0, true, false, 0, 0, 0, 0, "", 0, 0));
+                return list;
+            }
+            barConfig.EnsureSlotsPadded();
+            int count = Math.Min(slotCount, barConfig.Slots.Count);
+            for (int i = 0; i < count; i++)
+            {
+                var entry = barConfig.Slots[i];
+                var type = (RaptureHotbarModule.HotbarSlotType)entry.SlotType;
+                uint id = entry.CommandId;
+                if (entry.IsEmpty)
+                {
+                    list.Add(new SlotInfo(0, true, false, 0, 0, 0, 0, "", 0, 0));
+                    continue;
+                }
+                list.Add(GetSlotInfoViaScratch(type, id));
+            }
+            while (list.Count < slotCount)
+                list.Add(new SlotInfo(0, true, false, 0, 0, 0, 0, "", 0, 0));
+            return list;
+        }
+
+        /// <summary>Place payload on a controller bar slot (persisted in config only). Bar 1-8, slot 0-7.</summary>
+        public void PlacePayloadOnControllerSlot(int barIndex, int slotIndex, RaptureHotbarModule.HotbarSlotType slotType, uint commandId)
+        {
+            var barConfig = ControllerBarConfig.GetBarConfig(barIndex);
+            if (barConfig == null) return;
+            barConfig.EnsureSlotsPadded();
+            int s = Math.Clamp(slotIndex, 0, ControllerBarConfig.CrossSlotCount - 1);
+            while (barConfig.Slots.Count <= s)
+                barConfig.Slots.Add(new ControllerSlotData { SlotType = (int)RaptureHotbarModule.HotbarSlotType.Empty, CommandId = 0 });
+            barConfig.Slots[s] = new ControllerSlotData { SlotType = (int)slotType, CommandId = commandId };
+            ConfigurationManager.Instance?.SaveConfigurations();
+        }
+
+        /// <summary>Clear a controller bar slot. Bar 1-8, slot 0-7.</summary>
+        public bool ClearControllerSlot(int barIndex, int slotIndex)
+        {
+            var barConfig = ControllerBarConfig.GetBarConfig(barIndex);
+            if (barConfig == null) return false;
+            barConfig.EnsureSlotsPadded();
+            int s = Math.Clamp(slotIndex, 0, ControllerBarConfig.CrossSlotCount - 1);
+            if (s >= barConfig.Slots.Count) return true;
+            barConfig.Slots[s] = new ControllerSlotData { SlotType = (int)RaptureHotbarModule.HotbarSlotType.Empty, CommandId = 0 };
+            ConfigurationManager.Instance?.SaveConfigurations();
+            return true;
+        }
+
+        /// <summary>Swap two controller bar slots. Bars 1-8, slots 0-7.</summary>
+        public bool SwapControllerSlots(int barA, int slotA, int barB, int slotB)
+        {
+            var configA = ControllerBarConfig.GetBarConfig(barA);
+            var configB = ControllerBarConfig.GetBarConfig(barB);
+            if (configA == null || configB == null) return false;
+            configA.EnsureSlotsPadded();
+            configB.EnsureSlotsPadded();
+            int a = Math.Clamp(slotA, 0, ControllerBarConfig.CrossSlotCount - 1);
+            int b = Math.Clamp(slotB, 0, ControllerBarConfig.CrossSlotCount - 1);
+            if (barA == barB && a == b) return true;
+            if (a >= configA.Slots.Count || b >= configB.Slots.Count) return false;
+            var tmp = configA.Slots[a];
+            configA.Slots[a] = configB.Slots[b];
+            configB.Slots[b] = tmp;
+            ConfigurationManager.Instance?.SaveConfigurations();
+            return true;
+        }
+
+        /// <summary>Execute a controller bar slot by (type, id) via scratch slot. Bar 1-8, slot 0-7.</summary>
+        public unsafe bool ExecuteControllerSlot(int barIndex, int slotIndex)
+        {
+            var barConfig = ControllerBarConfig.GetBarConfig(barIndex);
+            if (barConfig == null) return false;
+            barConfig.EnsureSlotsPadded();
+            int s = Math.Clamp(slotIndex, 0, ControllerBarConfig.CrossSlotCount - 1);
+            if (s >= barConfig.Slots.Count) return false;
+            var entry = barConfig.Slots[s];
+            if (entry.IsEmpty) return false;
+            var slotType = (RaptureHotbarModule.HotbarSlotType)entry.SlotType;
+            uint commandId = entry.CommandId;
+
+            var module = RaptureHotbarModule.Instance();
+            if (module == null || !module->ModuleReady) return false;
+            var slotPtr = module->GetSlotById((uint)(ScratchBarIndex - 1), (uint)ScratchSlotIndex);
+            if (slotPtr == null) return false;
+            uint saveType = (uint)slotPtr->CommandType;
+            uint saveId = slotPtr->CommandId;
+            try
+            {
+                slotPtr->Set(slotType, commandId);
+                slotPtr->LoadIconId();
+                if (slotType == RaptureHotbarModule.HotbarSlotType.Item)
+                    slotPtr->LoadCostDataForSlot(true);
+                module->ExecuteSlotById((uint)(ScratchBarIndex - 1), (uint)ScratchSlotIndex);
+                return true;
+            }
+            finally
+            {
+                slotPtr->Set((RaptureHotbarModule.HotbarSlotType)saveType, saveId);
+                slotPtr->LoadIconId();
+            }
+        }
+
         /// <summary>
         /// Gets cooldown for a hotbar slot. For Action/GeneralAction/PetAction, uses ActionManager recast API
         /// (more accurate for adjusted IDs, recast groups). Falls back to slot's GetSlotActionCooldownPercentage for Items/Macros.
@@ -581,7 +725,23 @@ namespace HSUI.Helpers
             }
         }
 
-        /// <summary>Clear a hotbar slot. hotbarIndex 1-10, slotIndex 0-based.</summary>
+        /// <summary>Place a drag-drop payload (game or HSUI) onto a slot. hotbarIndex 1-10, slotIndex 0-based.</summary>
+        public static unsafe void PlacePayloadOnSlot(int hotbarIndex, int slotIndex, RaptureHotbarModule.HotbarSlotType slotType, uint commandId)
+        {
+            var module = RaptureHotbarModule.Instance();
+            if (module == null || !module->ModuleReady) return;
+            int barIdx = Math.Clamp(hotbarIndex, 1, 10) - 1;
+            int slot = Math.Clamp(slotIndex, 0, 11);
+            ref var displayBar = ref module->StandardHotbars[barIdx];
+            var slotPtr = displayBar.GetHotbarSlot((uint)slot);
+            if (slotPtr == null) return;
+            slotPtr->Set(slotType, commandId);
+            slotPtr->LoadIconId();
+            if (slotType == RaptureHotbarModule.HotbarSlotType.Item)
+                slotPtr->LoadCostDataForSlot(true);
+            SetAndSaveSlotInternal(module, (uint)barIdx, (uint)slot, slotType, commandId, slotPtr);
+        }
+
         public unsafe bool ClearSlot(int hotbarIndex, int slotIndex)
         {
             var module = RaptureHotbarModule.Instance();

Helpers/ClipRectsHelper.cs

@@ -1,3 +1,4 @@
+using Dalamud.Game.ClientState.Conditions;
 using HSUI.Config;
 using HSUI.Interface.GeneralElements;
 using FFXIVClientStructs.FFXIV.Client.UI;
@@ -335,6 +336,56 @@ namespace HSUI.Helpers
             return null;
         }
 
+        /// <summary>
+        /// Returns true when the given area overlaps a game addon (e.g. dialogue box) and should not be drawn on top of it.
+        /// Used by hotbars when "Show HUD during dialogue" is on, to avoid cooldown overlays bleeding through dialogue.
+        /// Uses full clip rects when Window Clipping is enabled, otherwise a minimal dialogue-addon check.
+        /// </summary>
+        public bool SlotOverlapsGameAddon(Vector2 pos, Vector2 size)
+        {
+            // When Window Clipping is enabled, use full clip rects (all game addons)
+            ClipRect? clipRect = GetClipRectForArea(pos, size);
+            if (clipRect.HasValue) { return true; }
+
+            // When "Show HUD during dialogue" is on and we're in dialogue, check dialogue addons
+            // (works even when full Window Clipping is disabled)
+            var hudOptions = ConfigurationManager.Instance?.GetConfigObject<HUDOptionsConfig>();
+            if (hudOptions?.ShowHudDuringDialogue != true) { return false; }
+            if (!Plugin.Condition[ConditionFlag.OccupiedInQuestEvent] && !Plugin.Condition[ConditionFlag.OccupiedInEvent])
+            { return false; }
+
+            return GetClipRectForDialogueAddon(pos, size).HasValue;
+        }
+
+        private static readonly string[] _dialogueAddonNames = { "Talk", "SelectString", "SelectIconString", "Journal" };
+
+        private unsafe ClipRect? GetClipRectForDialogueAddon(Vector2 pos, Vector2 size)
+        {
+            ClipRect area = new ClipRect(pos, pos + size);
+
+            foreach (string addonName in _dialogueAddonNames)
+            {
+                try
+                {
+                    var addon = (AtkUnitBase*)Plugin.GameGui.GetAddonByName(addonName, 1).Address;
+                    if (addon == null || addon->RootNode == null || !addon->IsVisible) { continue; }
+
+                    float margin = 5 * addon->Scale;
+                    Vector2 addonPos = new Vector2(addon->X + addon->RootNode->X * addon->Scale + margin,
+                        addon->Y + addon->RootNode->Y * addon->Scale + margin);
+                    Vector2 addonSize = new Vector2(
+                        addon->RootNode->Width * addon->Scale - margin * 2,
+                        addon->RootNode->Height * addon->Scale - margin * 2);
+                    ClipRect addonRect = new ClipRect(addonPos, addonPos + addonSize);
+
+                    if (addonRect.IntersectsWith(area)) { return addonRect; }
+                }
+                catch { }
+            }
+
+            return null;
+        }
+
         public static ClipRect[] GetInvertedClipRects(ClipRect clipRect)
         {
             float maxX = ImGui.GetMainViewport().Size.X;

Helpers/ControllerBarKeybindExecutor.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using Dalamud.Game.ClientState.GamePad;
+using Dalamud.Game.ClientState.Keys;
+using Dalamud.Plugin.Services;
+using HSUI.Config;
+using HSUI.Interface.GeneralElements;
+
+namespace HSUI.Helpers
+{
+    /// <summary>Polls controller bar keybinds and executes slots when keys/buttons are pressed. Supports combinations (e.g. L2+South).</summary>
+    public static class ControllerBarKeybindExecutor
+    {
+        private static readonly Dictionary<string, bool> _triggerWasDown = new Dictionary<string, bool>();
+
+        public static void Process(IFramework framework)
+        {
+            try
+            {
+                if (!ControllerHotbarsConfig.GetEffectiveControllerHotbarsEnabled())
+                    return;
+
+                var keybindsConfig = ConfigurationManager.Instance?.GetConfigObject<ControllerBarKeybindsConfig>();
+                if (keybindsConfig == null)
+                    return;
+
+                if (ActionBarsManager.Instance == null)
+                    return;
+
+                for (int bar = 1; bar <= ControllerBarKeybindsConfig.Bars; bar++)
+                {
+                    for (int slot = 0; slot < ControllerBarKeybindsConfig.SlotsPerBar; slot++)
+                    {
+                        string binding = keybindsConfig.GetKeybind(bar, slot);
+                        if (string.IsNullOrEmpty(binding)) continue;
+
+                        bool triggered = IsKeybindTriggered(binding);
+                        if (triggered)
+                            ActionBarsManager.Instance.ExecuteControllerSlot(bar, slot);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Plugin.Logger?.Warning($"[HSUI ControllerBarKeybinds] Process: {ex.Message}");
+            }
+        }
+
+        /// <summary>True when all modifiers are held and the trigger key/button was just pressed (edge).</summary>
+        private static bool IsKeybindTriggered(string binding)
+        {
+            if (string.IsNullOrEmpty(binding)) return false;
+
+            string[] parts = binding.Split('+');
+            for (int i = 0; i < parts.Length; i++)
+                parts[i] = parts[i].Trim();
+
+            if (parts.Length == 0) return false;
+            if (parts.Length == 1)
+            {
+                bool down = IsSingleKeybindDown(parts[0]);
+                if (!_triggerWasDown.TryGetValue(binding, out bool wasDown)) wasDown = false;
+                _triggerWasDown[binding] = down;
+                return down && !wasDown;
+            }
+
+            string triggerPart = parts[parts.Length - 1];
+            for (int i = 0; i < parts.Length - 1; i++)
+            {
+                if (!IsSingleKeybindDown(parts[i]))
+                    return false;
+            }
+            bool triggerDown = IsSingleKeybindDown(triggerPart);
+            if (!_triggerWasDown.TryGetValue(binding, out bool triggerWasDown))
+                triggerWasDown = false;
+            _triggerWasDown[binding] = triggerDown;
+            return triggerDown && !triggerWasDown;
+        }
+
+        private static bool IsSingleKeybindDown(string part)
+        {
+            if (string.IsNullOrEmpty(part)) return false;
+
+            if (part.StartsWith("Key:", StringComparison.OrdinalIgnoreCase))
+            {
+                string vkStr = part.Substring(4).Trim();
+                if (Plugin.KeyState == null) return false;
+                if (Enum.TryParse<VirtualKey>(vkStr, true, out var vk)
+                    && Plugin.KeyState.IsVirtualKeyValid((int)vk))
+                    return Plugin.KeyState[vk];
+                return false;
+            }
+
+            if (part.StartsWith("Pad:", StringComparison.OrdinalIgnoreCase))
+            {
+                string padStr = part.Substring(4).Trim();
+                if (Plugin.GamepadState == null) return false;
+                if (Enum.TryParse<GamepadButtons>(padStr, true, out var btn))
+                    return Plugin.GamepadState.Raw(btn) > 0.5f;
+                return false;
+            }
+
+            return false;
+        }
+    }
+}

Helpers/ControllerHotbarHelper.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Runtime.InteropServices;
+using Dalamud.Game.ClientState.GamePad;
+using Dalamud.Plugin.Services;
+using FFXIVClientStructs.FFXIV.Client.System.Framework;
+using FFXIVClientStructs.FFXIV.Client.UI.Misc;
+using HSUI.Interface.GeneralElements;
+
+namespace HSUI.Helpers
+{
+    /// <summary>Provides current cross hotbar trigger state (L2/R2) and game controller-mode detection for sync with game client.</summary>
+    public static class ControllerHotbarHelper
+    {
+        private static IGamepadState? _gamepadState;
+
+        public static void SetGamepadState(IGamepadState? gamepadState)
+        {
+            _gamepadState = gamepadState;
+        }
+
+        /// <summary>True when the game's Character Configuration has controller (gamepad) mode enabled. Reads the PadMode config option so bar mode follows the toggle and does not switch on input.</summary>
+        public static unsafe bool IsGameInControllerMode()
+        {
+            try
+            {
+                Framework* framework = Framework.Instance();
+                if (framework == null) return false;
+                int option = (int)ConfigOption.PadMode;
+                if (framework->SystemConfig.SystemConfigBase.UiConfig.ConfigCount <= option)
+                    return false;
+                uint value = framework->SystemConfig.SystemConfigBase.UiConfig.ConfigEntry[option].Value.UInt;
+                // PadMode: 0 = keyboard/mouse, 1 = gamepad
+                return value != 0;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>Returns the current trigger combo for which cross bar should be visible. Uses L2/R2 from gamepad.</summary>
+        public static CrossBarTrigger GetCurrentTrigger()
+        {
+            if (_gamepadState == null)
+                return CrossBarTrigger.None;
+
+            try
+            {
+                // Raw returns float (analog); treat as pressed when > 0.5
+                bool l2 = _gamepadState.Raw(GamepadButtons.L2) > 0.5f;
+                bool r2 = _gamepadState.Raw(GamepadButtons.R2) > 0.5f;
+
+                if (l2 && r2)
+                {
+                    // Both held - could distinguish L2 then R2 vs R2 then L2 by order; for now use L2R2
+                    return CrossBarTrigger.L2R2;
+                }
+                if (l2) return CrossBarTrigger.L2;
+                if (r2) return CrossBarTrigger.R2;
+                return CrossBarTrigger.None;
+            }
+            catch
+            {
+                return CrossBarTrigger.None;
+            }
+        }
+    }
+}

Helpers/DrawHelper.cs

@@ -334,7 +334,7 @@ namespace HSUI.Helpers
             DrawGradientFilledRect(cursorPos, new Vector2(Math.Max(1, barSize.X * shield), h), color, drawList);
         }
 
-        public static void DrawInWindow(string name, Vector2 pos, Vector2 size, bool needsInput, Action<ImDrawListPtr> drawAction)
+        public static void DrawInWindow(string name, Vector2 pos, Vector2 size, bool needsInput, Action<ImDrawListPtr> drawAction, bool allowInputInClipRect = false)
         {
             const ImGuiWindowFlags windowFlags = ImGuiWindowFlags.NoTitleBar |
                                                  ImGuiWindowFlags.NoScrollbar |
@@ -344,7 +344,7 @@ namespace HSUI.Helpers
 
             bool inputs = InputsHelper.Instance?.IsProxyEnabled == true ? false : needsInput;
 
-            DrawInWindow(name, pos, size, inputs, false, windowFlags, drawAction);
+            DrawInWindow(name, pos, size, inputs, false, windowFlags, drawAction, allowInputInClipRect);
         }
 
         public static void DrawInWindow(
@@ -354,13 +354,17 @@ namespace HSUI.Helpers
             bool needsInput,
             bool needsWindow,
             ImGuiWindowFlags windowFlags,
-            Action<ImDrawListPtr> drawAction)
+            Action<ImDrawListPtr> drawAction,
+            bool allowInputInClipRect = false)
         {
 
             if (!ClipRectsHelper.Instance.Enabled || ClipRectsHelper.Instance.Mode == WindowClippingMode.Performance)
             {
-                drawAction(ImGui.GetWindowDrawList());
-                return;
+                if (!needsInput && !needsWindow)
+                {
+                    drawAction(ImGui.GetWindowDrawList());
+                    return;
+                }
             }
 
             windowFlags |= ImGuiWindowFlags.NoSavedSettings | ImGuiWindowFlags.NoFocusOnAppearing | ImGuiWindowFlags.NoBringToFrontOnFocus;
@@ -405,7 +409,7 @@ namespace HSUI.Helpers
                 if (ClipRectsHelper.Instance.Mode == WindowClippingMode.Hide) { return; }
 
                 ImGuiWindowFlags flags = windowFlags;
-                if (needsInput && clipRect.Value.Contains(ImGui.GetMousePos()))
+                if (needsInput && !allowInputInClipRect && clipRect.Value.Contains(ImGui.GetMousePos()))
                 {
                     flags |= ImGuiWindowFlags.NoInputs;
                 }

Helpers/InputsHelper.cs

@@ -475,6 +475,9 @@ namespace HSUI.Helpers
                 // When leaving PvP, force load PvE hotbars so HSUI bars don't keep showing PvP actions.
                 ActionBarsManager.TryRestorePvEHotbarsAfterLeavePvP();
 
+                // Controller bar custom keybinds (when controller hotbars enabled)
+                ControllerBarKeybindExecutor.Process(framework);
+
                 // Keep WndProc hooked when: proxy mode (for mouseover) OR we need to block game drag
                 // release (so dropping on HSUI action bar doesn't execute the ability).
                 bool needHook = IsProxyEnabled || ShouldBlockGameDragRelease();
@@ -567,6 +570,7 @@ namespace HSUI.Helpers
 
             _wndHandle = hWnd;
             _wndProcDelegate = WndProcDetour;
+            _wndProcHandle = GCHandle.Alloc(_wndProcDelegate, GCHandleType.Normal); // Prevent GC of delegate while hooked
             _wndProcPtr = Marshal.GetFunctionPointerForDelegate(_wndProcDelegate);
             _imguiWndProcPtr = SetWindowLongPtr(hWnd, GWL_WNDPROC, _wndProcPtr);
 
@@ -593,6 +597,8 @@ namespace HSUI.Helpers
             }
             finally
             {
+                if (_wndProcHandle.IsAllocated)
+                    _wndProcHandle.Free();
                 _wndHandle = IntPtr.Zero;
                 _imguiWndProcPtr = IntPtr.Zero;
                 _wndProcPtr = IntPtr.Zero;
@@ -614,6 +620,7 @@ namespace HSUI.Helpers
 
         private IntPtr _wndHandle = IntPtr.Zero;
         private WndProcDelegate _wndProcDelegate = null!;
+        private GCHandle _wndProcHandle; // Keeps delegate alive while WndProc is hooked; freed in RestoreWndProc
         private IntPtr _wndProcPtr = IntPtr.Zero;
         private IntPtr _imguiWndProcPtr = IntPtr.Zero;
 

Helpers/MainMenuHelper.cs

@@ -0,0 +1,434 @@
+using AtkValueType = FFXIVClientStructs.FFXIV.Component.GUI.ValueType;
+using FFXIVClientStructs.FFXIV.Client.System.Framework;
+using FFXIVClientStructs.FFXIV.Client.UI;
+using FFXIVClientStructs.FFXIV.Client.UI.Agent;
+using FFXIVClientStructs.FFXIV.Client.UI.Misc;
+using FFXIVClientStructs.FFXIV.Component.GUI;
+using Lumina.Excel;
+using Lumina.Excel.Sheets;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace HSUI.Helpers
+{
+    public readonly struct MainMenuEntry
+    {
+        public uint CommandId { get; }
+        public uint IconId { get; }
+        public string Name { get; }
+
+        public MainMenuEntry(uint commandId, uint iconId, string name)
+        {
+            CommandId = commandId;
+            IconId = iconId;
+            Name = name ?? "";
+        }
+    }
+
+    public static class MainMenuHelper
+    {
+        /// <summary>Names of the 7 top-level Main Menu categories. Clicking these opens the context menu, not a direct action.</summary>
+        private static readonly string[] MainMenuCategoryNames =
+        {
+            "Character", "Duty", "Logs", "Travel", "Party", "Social", "System"
+        };
+
+        /// <summary>Fixed icon IDs for categories (from sheet). Used for display; command row is still resolved by name.</summary>
+        private static readonly IReadOnlyDictionary<string, uint> FixedCategoryIconIds = new Dictionary<string, uint>(StringComparer.OrdinalIgnoreCase)
+        {
+            { "Duty", 5 },
+            { "Logs", 21 },
+            { "Travel", 7 },
+            { "Social", 20 }
+        };
+
+        /// <summary>Categories that must use the category header row (smallest RowId in MainCommandCategory) so the context menu matches the game bar.</summary>
+        private static readonly HashSet<string> UseCategoryHeaderForMenu = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            "Logs",
+            "Travel"
+        };
+
+        /// <summary>Submenu item names that uniquely identify the Logs category (from default game context menu).</summary>
+        private static readonly string[] LogsCategoryAnchorNames = { "Hunting Log", "Sightseeing Log", "Crafting Log", "Gathering Log", "Fishing Log", "Fish Guide", "Orchestrion List", "Challenge Log" };
+
+        /// <summary>Submenu item names that uniquely identify the Travel category (from default game context menu).</summary>
+        private static readonly string[] TravelCategoryAnchorNames = { "Aether Currents", "Mount Speed", "Shared FATE", "Map", "Teleport", "Return" };
+
+        /// <summary>Get the 7 top-level Main Menu categories (Character, Duty, Logs, Travel, Party, Social, System) that are enabled. Clicking these opens the context menu.</summary>
+        public static List<MainMenuEntry> GetEnabledMainCommands()
+        {
+            var list = new List<MainMenuEntry>();
+            try
+            {
+                var sheet = Plugin.DataManager.GetExcelSheet<MainCommand>();
+                if (sheet == null) return list;
+
+                return GetEnabledMainCommandsUnsafe(list, sheet);
+            }
+            catch (Exception ex)
+            {
+                Plugin.Logger.Warning($"[HSUI] MainMenuHelper.GetEnabledMainCommands: {ex.Message}");
+            }
+
+            return list;
+        }
+
+        /// <summary>True if the sheet row name matches the main menu category (exact or flexible).</summary>
+        private static bool MatchesCategoryName(string rowName, string categoryName)
+        {
+            if (string.IsNullOrEmpty(rowName)) return false;
+            string r = rowName.Trim();
+            if (string.Equals(r, categoryName, StringComparison.OrdinalIgnoreCase))
+                return true;
+            if (string.Equals(categoryName, "Duty", StringComparison.OrdinalIgnoreCase))
+                return r.IndexOf("Duty", StringComparison.OrdinalIgnoreCase) >= 0;
+            if (string.Equals(categoryName, "Travel", StringComparison.OrdinalIgnoreCase))
+                return r.IndexOf("Travel", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Teleport", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Return", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Aetheryte", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Port", StringComparison.OrdinalIgnoreCase) >= 0;
+            if (string.Equals(categoryName, "Party", StringComparison.OrdinalIgnoreCase))
+                return r.IndexOf("Party", StringComparison.OrdinalIgnoreCase) >= 0;
+            if (string.Equals(categoryName, "Logs", StringComparison.OrdinalIgnoreCase))
+                return r.IndexOf("Log", StringComparison.OrdinalIgnoreCase) >= 0
+                    || string.Equals(r, "Journal", StringComparison.OrdinalIgnoreCase)
+                    || r.IndexOf("Quest", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Completion", StringComparison.OrdinalIgnoreCase) >= 0;
+            if (string.Equals(categoryName, "Social", StringComparison.OrdinalIgnoreCase))
+                return r.IndexOf("Social", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Friend", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Contact", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Linkshell", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Free Company", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Fellowship", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Group", StringComparison.OrdinalIgnoreCase) >= 0;
+            if (string.Equals(categoryName, "System", StringComparison.OrdinalIgnoreCase))
+                return r.IndexOf("System", StringComparison.OrdinalIgnoreCase) >= 0
+                    || r.IndexOf("Config", StringComparison.OrdinalIgnoreCase) >= 0;
+            return false;
+        }
+
+        /// <summary>Get the category header row ID (smallest RowId in the same MainCommandCategory). For Logs/Travel we identify the category by submenu item names from the default game menu.</summary>
+        private static unsafe uint GetCategoryHeaderCommandId(string categoryName, Lumina.Excel.ExcelSheet<MainCommand> sheet, AgentHUD* agentHud)
+        {
+            uint categoryGroupId = 0;
+            string[]? anchorNames = null;
+            if (string.Equals(categoryName, "Logs", StringComparison.OrdinalIgnoreCase))
+                anchorNames = LogsCategoryAnchorNames;
+            else if (string.Equals(categoryName, "Travel", StringComparison.OrdinalIgnoreCase))
+                anchorNames = TravelCategoryAnchorNames;
+
+            if (anchorNames != null)
+            {
+                // Find category by a row that matches one of the known submenu names (e.g. "Hunting Log", "Aether Currents").
+                foreach (var row in sheet)
+                {
+                    uint id = row.RowId;
+                    if (id == 0) continue;
+                    if (!agentHud->IsMainCommandEnabled(id)) continue;
+                    string name = "";
+                    try { name = row.Name.ToString(); }
+                    catch { }
+                    name = name?.Trim() ?? "";
+                    foreach (string anchor in anchorNames)
+                    {
+                        if (name.IndexOf(anchor, StringComparison.OrdinalIgnoreCase) >= 0)
+                        {
+                            try { categoryGroupId = row.MainCommandCategory.RowId; break; }
+                            catch { }
+                            break;
+                        }
+                    }
+                    if (categoryGroupId != 0) break;
+                }
+            }
+
+            if (categoryGroupId == 0)
+            {
+                // Fallback: exact "Logs"/"Travel" or flexible category name match
+                bool exactOnly = string.Equals(categoryName, "Logs", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(categoryName, "Travel", StringComparison.OrdinalIgnoreCase);
+                foreach (var row in sheet)
+                {
+                    uint id = row.RowId;
+                    if (id == 0) continue;
+                    string name = "";
+                    try { name = row.Name.ToString(); }
+                    catch { }
+                    if (exactOnly && !string.Equals(name.Trim(), categoryName, StringComparison.OrdinalIgnoreCase))
+                        continue;
+                    if (!exactOnly && !MatchesCategoryName(name, categoryName))
+                        continue;
+                    if (!agentHud->IsMainCommandEnabled(id))
+                        continue;
+                    try { categoryGroupId = row.MainCommandCategory.RowId; break; }
+                    catch { }
+                }
+            }
+            if (categoryGroupId == 0)
+            {
+                foreach (var row in sheet)
+                {
+                    uint id = row.RowId;
+                    if (id == 0) continue;
+                    string name = "";
+                    try { name = row.Name.ToString(); }
+                    catch { }
+                    if (!MatchesCategoryName(name, categoryName) || !agentHud->IsMainCommandEnabled(id))
+                        continue;
+                    try { categoryGroupId = row.MainCommandCategory.RowId; break; }
+                    catch { }
+                }
+            }
+
+            if (categoryGroupId == 0) return 0;
+            uint headerId = 0;
+            foreach (var row in sheet)
+            {
+                if (row.RowId == 0) continue;
+                try { if (row.MainCommandCategory.RowId != categoryGroupId) continue; }
+                catch { continue; }
+                if (!agentHud->IsMainCommandEnabled(row.RowId)) continue;
+                if (headerId == 0 || row.RowId < headerId)
+                    headerId = row.RowId;
+            }
+            return headerId;
+        }
+
+        private static unsafe List<MainMenuEntry> GetEnabledMainCommandsUnsafe(List<MainMenuEntry> list, Lumina.Excel.ExcelSheet<MainCommand> sheet)
+        {
+            var agentHud = AgentHUD.Instance();
+            if (agentHud == null) return list;
+
+            foreach (string categoryName in MainMenuCategoryNames)
+            {
+                // Logs and Travel: use category header row so context menu matches game bar.
+                if (UseCategoryHeaderForMenu.Contains(categoryName))
+                {
+                    uint headerId = GetCategoryHeaderCommandId(categoryName, sheet, agentHud);
+                    if (headerId != 0)
+                    {
+                        uint iconId = 0;
+                        if (FixedCategoryIconIds.TryGetValue(categoryName, out uint fixedIconId))
+                            iconId = fixedIconId;
+                        if (iconId == 0)
+                            iconId = GetFallbackIconIdForCategory(categoryName);
+                        list.Add(new MainMenuEntry(headerId, iconId, categoryName));
+                        continue;
+                    }
+                }
+
+                foreach (var row in sheet)
+                {
+                    uint id = row.RowId;
+                    if (id == 0) continue;
+
+                    string name = "";
+                    try { name = row.Name.ToString(); }
+                    catch { }
+
+                    if (!MatchesCategoryName(name, categoryName))
+                        continue;
+                    if (!agentHud->IsMainCommandEnabled(id))
+                        continue;
+
+                    // Icon: use fixed icon ID for Duty/Logs/Travel/Social (from sheet); others use sheet → game → fallback.
+                    uint iconId = 0;
+                    if (FixedCategoryIconIds.TryGetValue(categoryName, out uint fixedIconId))
+                        iconId = fixedIconId;
+                    if (iconId == 0)
+                    {
+                        try { iconId = (uint)row.Icon; }
+                        catch { }
+                    }
+                    if (iconId == 0)
+                        iconId = GetIconIdForMainCommand(id);
+                    if (iconId == 0)
+                        iconId = GetFallbackIconIdForCategory(categoryName);
+
+                    list.Add(new MainMenuEntry(id, iconId, categoryName));
+                    break;
+                }
+            }
+
+            return list;
+        }
+
+        /// <summary>Resolve icon for a Main Command. Uses RaptureHotbarModule when sheet row.Icon is 0.</summary>
+        public static unsafe uint GetIconIdForMainCommand(uint commandId)
+        {
+            try
+            {
+                var module = RaptureHotbarModule.Instance();
+                if (module != null && module->ModuleReady)
+                {
+                    var bar = module->StandardHotbars[0];
+                    var slot = bar.GetHotbarSlot(0);
+                    if (slot != null)
+                    {
+                        int gameIcon = slot->GetIconIdForSlot(RaptureHotbarModule.HotbarSlotType.MainCommand, commandId);
+                        if (gameIcon > 0) return (uint)gameIcon;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Plugin.Logger.Warning($"[HSUI] MainMenuHelper.GetIconIdForMainCommand({commandId}): {ex.Message}");
+            }
+            return 0;
+        }
+
+        /// <summary>Fallback icon when game and sheet both return 0. Duty = 61002 (exclamation) to match default bar.</summary>
+        private static uint GetFallbackIconIdForCategory(string categoryName)
+        {
+            return (categoryName?.ToLowerInvariant()) switch
+            {
+                "character" => 61001,
+                "duty" => 61002,
+                "logs" => 61003,
+                "travel" => 61004,
+                "party" => 61005,
+                "social" => 61006,
+                "system" => 61007,
+                _ => 0
+            };
+        }
+
+        /// <summary>Execute a main command by ID (e.g. Character, Social, Collection).</summary>
+        public static unsafe void ExecuteMainCommand(uint commandId)
+        {
+            try
+            {
+                var uiModule = Framework.Instance()->GetUIModule();
+                if (uiModule == null) return;
+
+                uiModule->ExecuteMainCommand(commandId);
+            }
+            catch (Exception ex)
+            {
+                Plugin.Logger.Warning($"[HSUI] MainMenuHelper.ExecuteMainCommand({commandId}): {ex.Message}");
+            }
+        }
+
+        /// <summary>Open the context submenu for a category, or execute directly if no submenu. When sub-commands exist, the HUD shows a custom context menu; otherwise executes the command.</summary>
+        public static unsafe void OpenSubmenuOrExecute(uint categoryCommandId)
+        {
+            var subIds = GetSubCommandIds(categoryCommandId);
+            if (subIds != null && subIds.Count > 0)
+                return; // Caller should use GetSubCommandEntries and show custom menu; we don't call OpenSystemMenu (crashes)
+            ExecuteMainCommand(categoryCommandId);
+        }
+
+        /// <summary>Get sub-command entries (id + display name) for the category. Same options as the default main menu bar context menu. Returns empty if category has no sub-commands.</summary>
+        public static List<(uint CommandId, string Name)> GetSubCommandEntries(uint categoryCommandId)
+        {
+            var list = new List<(uint, string)>();
+            try
+            {
+                var subIds = GetSubCommandIds(categoryCommandId);
+                if (subIds == null || subIds.Count == 0) return list;
+
+                var sheet = Plugin.DataManager.GetExcelSheet<MainCommand>();
+                if (sheet == null) return list;
+
+                foreach (uint id in subIds)
+                {
+                    string name = "";
+                    if (sheet.TryGetRow(id, out var row))
+                    {
+                        try { name = row.Name.ToString(); }
+                        catch { }
+                    }
+                    if (string.IsNullOrEmpty(name)) name = $"#{id}";
+                    list.Add((id, name));
+                }
+            }
+            catch (Exception ex)
+            {
+                Plugin.Logger.Warning($"[HSUI] MainMenuHelper.GetSubCommandEntries({categoryCommandId}): {ex.Message}");
+            }
+            return list;
+        }
+
+        /// <summary>Get MainCommand IDs that belong to the same category as the given command (for submenu).</summary>
+        private static unsafe List<uint> GetSubCommandIds(uint categoryCommandId)
+        {
+            var list = new List<uint>();
+            try
+            {
+                var sheet = Plugin.DataManager.GetExcelSheet<MainCommand>();
+                if (sheet == null) return list;
+
+                var agentHud = AgentHUD.Instance();
+                if (agentHud == null) return list;
+
+                if (!sheet.TryGetRow(categoryCommandId, out var categoryRow)) return list;
+
+                uint categoryGroupId;
+                try
+                {
+                    categoryGroupId = categoryRow.MainCommandCategory.RowId;
+                }
+                catch { return list; }
+
+                foreach (var row in sheet)
+                {
+                    if (row.RowId == 0) continue;
+                    try
+                    {
+                        if (row.MainCommandCategory.RowId != categoryGroupId) continue;
+                    }
+                    catch { continue; }
+                    if (!agentHud->IsMainCommandEnabled(row.RowId)) continue;
+                    list.Add(row.RowId);
+                }
+            }
+            catch (Exception ex)
+            {
+                Plugin.Logger.Warning($"[HSUI] MainMenuHelper.GetSubCommandIds({categoryCommandId}): {ex.Message}");
+            }
+            return list;
+        }
+
+        /// <summary>Open the game's system menu with the given MainCommand IDs (context submenu).</summary>
+        private static unsafe void OpenSystemMenuWithCommands(List<uint> commandIds)
+        {
+            if (commandIds == null || commandIds.Count == 0) return;
+            if (commandIds.Count > 17) return; // game limit
+
+            var agentHud = AgentHUD.Instance();
+            if (agentHud == null) return;
+
+            int count = commandIds.Count;
+            int allocSize = 5 + 17 + 18; // atkValueArgs layout: [4]=size, [5..21]=commands, [23..]=optional name strings
+            var ptr = (AtkValue*)Marshal.AllocHGlobal(allocSize * sizeof(AtkValue));
+            try
+            {
+                // Zero entire buffer so the game never reads garbage as string pointers (prevents crash in Utf8String.SetString)
+                for (int i = 0; i < allocSize; i++)
+                {
+                    ptr[i].Type = AtkValueType.Null;
+                    ptr[i].Int = 0;
+                }
+
+                ptr[4].ChangeType(AtkValueType.UInt);
+                ptr[4].UInt = (uint)count;
+
+                for (int i = 0; i < count; i++)
+                {
+                    ptr[5 + i].ChangeType(AtkValueType.Int);
+                    ptr[5 + i].Int = (int)commandIds[i];
+                }
+
+                agentHud->OpenSystemMenu(ptr, (uint)count);
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(new IntPtr(ptr));
+            }
+        }
+    }
+}

Helpers/TooltipsHelper.cs

@@ -8,11 +8,27 @@ using HSUI.Interface.GeneralElements;
 using Dalamud.Bindings.ImGui;
 using FFXIVClientStructs.FFXIV.Client.Game.Object;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Numerics;
 using System.Text;
+using System.Text.RegularExpressions;
 
 namespace HSUI.Helpers
 {
+    /// <summary>Colored segment for game-style tooltip formatting.</summary>
+    public readonly struct TooltipSegment
+    {
+        public readonly string Text;
+        public readonly Vector4 Color;
+
+        public TooltipSegment(string text, Vector4 color)
+        {
+            Text = text ?? "";
+            Color = color;
+        }
+    }
+
     /// <summary>When showing an ID in the tooltip title, use Action for action IDs or Status for status effect IDs.</summary>
     public enum TooltipIdKind
     {
@@ -54,7 +70,7 @@ namespace HSUI.Helpers
         }
         #endregion
 
-        private float MaxWidth => Math.Max(160, 340 * ImGuiHelpers.GlobalScale * _config.TooltipScale);
+        private float MaxWidth => Math.Max(160, _config.TooltipMaxWidth * ImGuiHelpers.GlobalScale * _config.TooltipScale);
         private float Margin => Math.Max(4, 5 * ImGuiHelpers.GlobalScale * _config.TooltipScale);
 
         private TooltipsConfig _config => ConfigurationManager.Instance.GetConfigObject<TooltipsConfig>();
@@ -65,20 +81,30 @@ namespace HSUI.Helpers
         private Vector2 _titleSize;
         private string? _previousRawText = null;
         private uint? _currentIconId = null;
+        private List<TooltipSegment>? _formattedSegments = null;
 
         private Vector2 _position;
         private Vector2 _size;
 
         private bool _dataIsValid = false;
 
+        /// <summary>Set when an HUD element (e.g. Main Menu) has the mouse over it this frame. World object tooltip will not show.</summary>
+        private bool _mouseOverHudElement = false;
+
         private const float IconSize = 24f;
 
-        public void ShowTooltipOnCursor(string text, string? title = null, uint id = 0, string name = "", uint? iconId = null, TooltipIdKind idKind = TooltipIdKind.None)
+        /// <summary>Call when the mouse is over an interactive HUD element so world object tooltip is not shown.</summary>
+        public void NotifyMouseOverHudElement()
         {
-            ShowTooltip(text, ImGui.GetMousePos(), title, id, name, iconId, idKind);
+            _mouseOverHudElement = true;
         }
 
-        public void ShowTooltip(string text, Vector2 position, string? title = null, uint id = 0, string name = "", uint? iconId = null, TooltipIdKind idKind = TooltipIdKind.None)
+        public void ShowTooltipOnCursor(string text, string? title = null, uint id = 0, string name = "", uint? iconId = null, TooltipIdKind idKind = TooltipIdKind.None, List<TooltipSegment>? formattedText = null)
+        {
+            ShowTooltip(text, ImGui.GetMousePos(), title, id, name, iconId, idKind, formattedText);
+        }
+
+        public void ShowTooltip(string text, Vector2 position, string? title = null, uint id = 0, string name = "", uint? iconId = null, TooltipIdKind idKind = TooltipIdKind.None, List<TooltipSegment>? formattedText = null)
         {
             if (text == null)
             {
@@ -95,8 +121,15 @@ namespace HSUI.Helpers
             }
 
             _currentIconId = iconId;
+            _formattedSegments = formattedText;
 
-            // calcualte title size
+            // When showing a simple tooltip with no title (e.g. HUD), clear previous title/body so we don't mix with last frame's world tooltip
+            if (title == null)
+            {
+                _currentTooltipTitle = null;
+            }
+
+            // calculate title size
             _titleSize = Vector2.Zero;
             if (title != null)
             {
@@ -124,20 +157,42 @@ namespace HSUI.Helpers
                 }
             }
 
-            // calculate text size
+            // calculate text size (build combined text from segments for sizing)
             string fontIdForText = _config.FontID ?? FontsConfig.DefaultSmallFontKey;
             using (FontsManager.Instance.PushFont(fontIdForText))
             {
-                _textSize = ImGui.CalcTextSize(_currentTooltipText, false, MaxWidth);
+                float lineHeight = ImGui.GetTextLineHeight();
+                if (_formattedSegments != null && _formattedSegments.Count > 0)
+                {
+                    var sb = new StringBuilder();
+                    int newlineCount = 0;
+                    foreach (var seg in _formattedSegments)
+                    {
+                        sb.Append(seg.Text);
+                        if (seg.Text == "\n") newlineCount++;
+                    }
+                    _textSize = ImGui.CalcTextSize(sb.ToString(), false, MaxWidth);
+                    // Account for Dummy spacing between sections (each \n adds compactSpacing)
+                    float compactSpacing = Math.Max(2, lineHeight * _config.TooltipLineSpacing);
+                    _textSize.Y += newlineCount * compactSpacing;
+                }
+                else
+                {
+                    _textSize = ImGui.CalcTextSize(_currentTooltipText, false, MaxWidth);
+                }
             }
 
-            float contentWidth = Math.Max(_titleSize.X, _textSize.X);
-            float contentHeight = _titleSize.Y + _textSize.Y;
-            float iconSizeScaled = IconSize * ImGuiHelpers.GlobalScale * _config.TooltipScale;
+            float fontScale = Math.Max(0.7f, _config.TooltipFontScale);
+            float contentWidth = Math.Max(_titleSize.X, _textSize.X) * fontScale;
+            float contentHeight = (_titleSize.Y + _textSize.Y) * fontScale;
+            float iconSizeScaled = IconSize * ImGuiHelpers.GlobalScale * _config.TooltipScale * _config.TooltipIconScale;
             float iconGap = _currentIconId.HasValue && _currentIconId.Value > 0 ? iconSizeScaled + Margin : 0;
+            // Add buffer to prevent clipping (font/scale changes, rounding, padding)
+            float heightBuffer = _config.TooltipHeightBuffer;
+            float minContentHeight = contentHeight + heightBuffer;
             _size = new Vector2(
                 contentWidth + iconGap + Margin * 2,
-                Math.Max(contentHeight, _currentIconId.HasValue && _currentIconId.Value > 0 ? iconSizeScaled : 0) + Margin * 2);
+                Math.Max(minContentHeight, _currentIconId.HasValue && _currentIconId.Value > 0 ? iconSizeScaled + Margin * 2 : 0) + Margin * 2);
 
             // position tooltip using the given coordinates as bottom center
             position.X = position.X - _size.X / 2f;
@@ -159,19 +214,17 @@ namespace HSUI.Helpers
         /// </summary>
         public void ShowWorldObjectTooltip()
         {
+            // Don't overwrite if an HUD element already set a tooltip this frame (e.g. Main Menu icon)
+            if (_dataIsValid)
+                return;
+            // Don't show world tooltip when mouse is over an interactive HUD element (e.g. Main Menu bar)
+            if (_mouseOverHudElement)
+                return;
             try
             {
                 _worldTooltipConfig ??= ConfigurationManager.Instance.GetConfigObject<WorldObjectTooltipConfig>();
                 if (_worldTooltipConfig == null || !_worldTooltipConfig.Enabled)
                     return;
-            }
-            catch (Exception ex)
-            {
-                // Config not ready yet or not found - silently skip
-                if (_config.DebugTooltips)
-                    Plugin.Logger.Warning($"[HSUI Tooltip] WorldObjectTooltipConfig not available: {ex.Message}");
-                return;
-            }
 
             IGameObject? mouseOverTarget = Plugin.TargetManager.MouseOverTarget;
             if (mouseOverTarget == null)
@@ -254,6 +307,13 @@ namespace HSUI.Helpers
             {
                 ShowTooltipOnCursor(body, name, 0, "", iconId);
             }
+            }
+            catch (Exception ex)
+            {
+                // Config not ready yet or not found - silently skip
+                if (_config.DebugTooltips)
+                    Plugin.Logger.Warning($"[HSUI Tooltip] WorldObjectTooltipConfig not available: {ex.Message}");
+            }
         }
 
         private static unsafe uint? GetWorldObjectIconId(IGameObject gameObject)
@@ -270,6 +330,42 @@ namespace HSUI.Helpers
         public void RemoveTooltip()
         {
             _dataIsValid = false;
+            _mouseOverHudElement = false;
+            _formattedSegments = null;
+        }
+
+        private void DrawTooltipBody()
+        {
+            if (_formattedSegments != null && _formattedSegments.Count > 0)
+            {
+                bool afterNewline = true;
+                float lineHeight = ImGui.GetTextLineHeight();
+                float compactSpacing = Math.Max(2, lineHeight * _config.TooltipLineSpacing);
+
+                foreach (var seg in _formattedSegments)
+                {
+                    if (seg.Text == "\n")
+                    {
+                        ImGui.Dummy(new Vector2(0, compactSpacing));
+                        afterNewline = true;
+                    }
+                    else if (!string.IsNullOrEmpty(seg.Text))
+                    {
+                        if (!afterNewline)
+                            ImGui.SameLine(0, 0);
+                        string text = afterNewline ? seg.Text.TrimStart() : seg.Text;
+                        if (!string.IsNullOrEmpty(text))
+                        {
+                            ImGui.TextColored(seg.Color, text);
+                            afterNewline = false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                ImGui.TextColored(_config.TextColor.Vector, _currentTooltipText);
+            }
         }
 
         public void Draw()
@@ -303,6 +399,7 @@ namespace HSUI.Helpers
 
             ImGui.PushStyleVar(ImGuiStyleVar.WindowRounding, 0);
             ImGui.Begin("DelvUI_tooltip", windowFlags);
+            ImGui.SetWindowFontScale(_config.TooltipFontScale);
             var drawList = ImGui.GetWindowDrawList();
 
             drawList.AddRectFilled(_position, _position + _size, _config.BackgroundColor.Base);
@@ -316,7 +413,7 @@ namespace HSUI.Helpers
             float globalScaleCorrection = -15 + 15 * ImGuiHelpers.GlobalScale;
 
             string fontId = _config.FontID ?? FontsConfig.DefaultSmallFontKey;
-            float iconSizeScaled = IconSize * ImGuiHelpers.GlobalScale * _config.TooltipScale;
+            float iconSizeScaled = IconSize * ImGuiHelpers.GlobalScale * _config.TooltipScale * _config.TooltipIconScale;
             float iconGap = (_currentIconId.HasValue && _currentIconId.Value > 0) ? iconSizeScaled + Margin : 0;
             float wrapWidth = (_currentIconId.HasValue && _currentIconId.Value > 0)
                 ? _size.X - iconGap - Margin * 2
@@ -342,19 +439,19 @@ namespace HSUI.Helpers
                     ImGui.PopTextWrapPos();
                 }
 
-                // text
+                // text (formatted or plain)
                 using (FontsManager.Instance.PushFont(fontId))
                 {
                     cursorPos = new Vector2(textBlockX, Margin + _titleSize.Y);
                     ImGui.SetCursorPos(cursorPos);
                     ImGui.PushTextWrapPos(cursorPos.X + wrapWidth + globalScaleCorrection);
-                    ImGui.TextColored(_config.TextColor.Vector, _currentTooltipText);
+                    DrawTooltipBody();
                     ImGui.PopTextWrapPos();
                 }
             }
             else
             {
-                // text
+                // text (formatted or plain)
                 using (FontsManager.Instance.PushFont(fontId))
                 {
                     var cursorPos = new Vector2(textBlockX, Margin);
@@ -362,11 +459,12 @@ namespace HSUI.Helpers
 
                     ImGui.SetCursorPos(cursorPos);
                     ImGui.PushTextWrapPos(cursorPos.X + textWidth + globalScaleCorrection);
-                    ImGui.TextColored(_config.TextColor.Vector, _currentTooltipText);
+                    DrawTooltipBody();
                     ImGui.PopTextWrapPos();
                 }
             }
 
+            ImGui.SetWindowFontScale(1f);
             ImGui.End();
             ImGui.PopStyleVar();
 
@@ -375,6 +473,236 @@ namespace HSUI.Helpers
             RemoveTooltip();
         }
 
+        /// <summary>
+        /// Parses action/ability description text into colored segments for game-style tooltips.
+        /// Adds newlines before section headers and colors: section labels (Additional Effect, Duration) green,
+        /// status names (e.g. Blood of the Dragon) yellow, secondary labels grey.
+        /// </summary>
+        public static List<TooltipSegment> FormatActionTooltip(string description, Vector4 textColor, Vector4 sectionLabelColor, Vector4 statusNameColor)
+        {
+            var result = new List<TooltipSegment>();
+            if (string.IsNullOrEmpty(description))
+                return result;
+
+            // Pattern: section labels to color (Additional Effect, Duration, X Effect, Maximum Charges, job gauge costs, Combo, roles)
+            // Job gauge/resource costs: Soul (RPR), Blood/Beast (DRK/WAR), Kenki/Ninki (SAM/NIN), Cartridge (GNB), Oath (PLD), Lily (WHM), etc.
+            var sectionRegex = new Regex(@"\b(Additional Effect:|Duration:|Maximum Charges:|Blood Gauge Cost:|Soul Gauge Cost:|Beast Gauge Cost:|Kenki Gauge Cost:|Kenki Cost:|Ninki Gauge Cost:|Ninki Cost:|Cartridge Cost:|Oath Gauge Cost:|Lily Cost:|Polyglot Cost:|Addersgall Cost:|Addersting Cost:|Astral Sign Cost:|Lunar Sign Cost:|Battery Gauge Cost:|Heat Gauge Cost:|[A-Za-z][A-Za-z0-9\s]*\s+Cost:|Combo Action:|Combo Potency:|Combo Bonus:|Tank:|Melee:|Ranged:|Caster:|Healer:|[A-Za-z][A-Za-z0-9\s]+ Effect:)", RegexOptions.None);
+            // Pattern: "Grants X X Effect:" - captures status name X
+            var grantsRegex = new Regex(@"Grants\s+(.+?)\s+\1\s+Effect:", RegexOptions.Singleline);
+
+            int lastEnd = 0;
+            foreach (Match m in sectionRegex.Matches(description))
+            {
+                string chunk = description.Substring(lastEnd, m.Index - lastEnd).TrimEnd();
+                if (!string.IsNullOrEmpty(chunk))
+                {
+                    // Check for "Grants StatusName" in this chunk to color status name yellow
+                    var grantsMatch = grantsRegex.Match(chunk);
+                    if (grantsMatch.Success)
+                    {
+                        string statusName = grantsMatch.Groups[1].Value.Trim();
+                        string grantsPrefix = "Grants " + statusName;
+                        int idx = chunk.IndexOf(grantsPrefix, StringComparison.Ordinal);
+                        if (idx >= 0)
+                        {
+                            if (idx > 0)
+                                result.Add(new TooltipSegment(chunk.Substring(0, idx), textColor));
+                            result.Add(new TooltipSegment("Grants ", textColor));
+                            result.Add(new TooltipSegment(statusName + " ", statusNameColor));
+                            int after = idx + grantsPrefix.Length;
+                            if (after < chunk.Length)
+                                result.Add(new TooltipSegment(chunk.Substring(after), textColor));
+                        }
+                        else
+                            result.Add(new TooltipSegment(chunk, textColor));
+                    }
+                    else
+                        result.Add(new TooltipSegment(chunk, textColor));
+                }
+
+                result.Add(new TooltipSegment("\n", textColor));
+                result.Add(new TooltipSegment(m.Value + " ", sectionLabelColor));
+                // Add newline so description wraps below label like stock game (not floating beside it)
+                if (m.Value.IndexOf("Effect:", StringComparison.OrdinalIgnoreCase) >= 0)
+                    result.Add(new TooltipSegment("\n", textColor));
+                lastEnd = m.Index + m.Length;
+            }
+            if (lastEnd < description.Length)
+            {
+                string tail = description.Substring(lastEnd).TrimStart();
+                if (!string.IsNullOrEmpty(tail))
+                {
+                    string valuePart = "";
+                    string notePart = "";
+                    bool hasValue = false;
+
+                    int newlineIdx = tail.IndexOf('\n');
+                    if (newlineIdx >= 0)
+                    {
+                        // "2\nCannot be executed..." - value on first line, note on next
+                        valuePart = tail.Substring(0, newlineIdx).TrimEnd();
+                        notePart = tail.Substring(newlineIdx + 1).TrimStart();
+                        hasValue = Regex.IsMatch(valuePart, @"^\d+[ms]?$");
+                    }
+                    else
+                    {
+                        // "2 Cannot be executed while bound." - value + space + note (no newline)
+                        var valueNoteMatch = Regex.Match(tail, @"^(\d+[ms]?)\s+([A-Z].+)$", RegexOptions.Singleline);
+                        if (valueNoteMatch.Success)
+                        {
+                            valuePart = valueNoteMatch.Groups[1].Value;
+                            notePart = valueNoteMatch.Groups[2].Value;
+                            hasValue = true;
+                        }
+                        else if (Regex.IsMatch(tail, @"^\d+[ms]?$"))
+                        {
+                            // Plain value only: "50" (Blood Gauge Cost), "2" (charges) - stay on same line as label
+                            valuePart = tail;
+                            hasValue = true;
+                        }
+                    }
+
+                    // Add valuePart when present - section content (e.g. "Restore party HP..." for Healer, "2" for charges)
+                    if (!string.IsNullOrEmpty(valuePart))
+                    {
+                        result.Add(new TooltipSegment(valuePart, textColor));
+                    }
+                    if (!string.IsNullOrEmpty(notePart))
+                    {
+                        result.Add(new TooltipSegment("\n", textColor));
+                        result.Add(new TooltipSegment(notePart, textColor));
+                    }
+                    else if (!hasValue)
+                    {
+                        // Standalone note: "(Duration can be extended...)", "Cannot be executed...", footnotes
+                        result.Add(new TooltipSegment("\n", textColor));
+                        result.Add(new TooltipSegment(tail, textColor));
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Builds formatted segments from a full action tooltip body (stats + description).
+        /// Used when UseGameStyleFormatting is enabled.
+        /// Stats are placed first, then exactly one newline, then description below.
+        /// </summary>
+        public static List<TooltipSegment>? BuildFormattedActionTooltipBody(string body, TooltipsConfig config)
+        {
+            if (string.IsNullOrEmpty(body) || !config.UseGameStyleFormatting)
+                return null;
+
+            var result = new List<TooltipSegment>();
+            var textColor = config.TextColor.Vector;
+            var sectionColor = config.SectionLabelColor.Vector;
+            var statusColor = config.StatusNameColor.Vector;
+            var secondaryColor = config.SecondaryLabelColor.Vector;
+
+            var blocks = body.Split(new[] { "\n\n" }, StringSplitOptions.None);
+            bool hasStats = false;
+
+            // Job gauge/resource cost line pattern (e.g. "Soul Gauge Cost: 50", "Lily Cost: 1") - treat as own section with section color
+            var gaugeCostLineRegex = new Regex(@"^(.+?\s+Cost:)\s*(.*)$", RegexOptions.None);
+            // Stats block: may contain "Potency: X", "Cast: ... | Recast: ...", and job gauge cost lines.
+            // Once we hit a line that doesn't match any of these, treat it and the rest as description (don't drop it).
+            List<string> descBlocks = new List<string>();
+            bool inDescription = false;
+            for (int i = 0; i < blocks.Length; i++)
+            {
+                string block = blocks[i].Trim();
+                var lines = block.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                List<string> descLinesInBlock = new List<string>();
+                foreach (string line in lines)
+                {
+                    string part = line.Trim();
+                    if (inDescription)
+                    {
+                        descLinesInBlock.Add(part);
+                        continue;
+                    }
+                    if (part.StartsWith("Potency:", StringComparison.OrdinalIgnoreCase))
+                    {
+                        if (hasStats) result.Add(new TooltipSegment("\n", textColor));
+                        result.Add(new TooltipSegment("Potency:", secondaryColor));
+                        result.Add(new TooltipSegment(" " + part.Substring(8).TrimStart(), textColor));
+                        hasStats = true;
+                    }
+                    else if (part.Contains("Cast:") || part.Contains("Recast:"))
+                    {
+                        if (hasStats) result.Add(new TooltipSegment("\n", textColor));
+                        var statsSegs = FormatActionStats(part, textColor, secondaryColor);
+                        result.AddRange(statsSegs);
+                        hasStats = true;
+                    }
+                    else if (gaugeCostLineRegex.IsMatch(part))
+                    {
+                        var match = gaugeCostLineRegex.Match(part);
+                        string label = match.Groups[1].Value.TrimEnd();
+                        string value = match.Groups[2].Value.Trim();
+                        if (hasStats) result.Add(new TooltipSegment("\n", textColor));
+                        result.Add(new TooltipSegment(label + (string.IsNullOrEmpty(value) ? "" : " "), sectionColor));
+                        if (!string.IsNullOrEmpty(value))
+                            result.Add(new TooltipSegment(value, textColor));
+                        hasStats = true;
+                    }
+                    else
+                    {
+                        inDescription = true;
+                        descLinesInBlock.Add(part);
+                    }
+                }
+                if (descLinesInBlock.Count > 0)
+                    descBlocks.Add(string.Join("\n", descLinesInBlock));
+                if (inDescription)
+                {
+                    descBlocks.AddRange(blocks.Skip(i + 1).Select(b => b.Trim()).Where(b => b.Length > 0));
+                    break;
+                }
+            }
+
+            // Description: exactly one newline after stats, then description with compact section spacing
+            string desc = string.Join("\n\n", descBlocks).Trim();
+            if (!string.IsNullOrEmpty(desc))
+            {
+                if (hasStats) result.Add(new TooltipSegment("\n", textColor));
+                var descSegs = FormatActionTooltip(desc, textColor, sectionColor, statusColor);
+                result.AddRange(descSegs);
+            }
+
+            return result.Count > 0 ? result : null;
+        }
+
+        /// <summary>
+        /// Formats action stats (Cast, Recast, Range, Radius) as colored segments.
+        /// </summary>
+        public static List<TooltipSegment> FormatActionStats(string statsLine, Vector4 textColor, Vector4 secondaryLabelColor)
+        {
+            var result = new List<TooltipSegment>();
+            if (string.IsNullOrEmpty(statsLine))
+                return result;
+
+            // statsLine format: "Cast: Instant | Recast: 60.0s | Range: 15y | Radius: 15y"
+            var parts = statsLine.Split(new[] { " | " }, StringSplitOptions.None);
+            for (int i = 0; i < parts.Length; i++)
+            {
+                if (i > 0)
+                    result.Add(new TooltipSegment(" | ", textColor));
+                int colonIdx = parts[i].IndexOf(':');
+                if (colonIdx >= 0)
+                {
+                    result.Add(new TooltipSegment(parts[i].Substring(0, colonIdx + 1), secondaryLabelColor));
+                    result.Add(new TooltipSegment(parts[i].Substring(colonIdx + 1), textColor));
+                }
+                else
+                {
+                    result.Add(new TooltipSegment(parts[i], textColor));
+                }
+            }
+            return result;
+        }
+
         private Vector2 ConstrainPosition(Vector2 position, Vector2 size)
         {
             var screenSize = ImGui.GetWindowViewport().Size;
@@ -412,21 +740,57 @@ namespace HSUI.Helpers
         public string? FontID = null;
 
         [DragFloat("Tooltip Scale", min = 0.5f, max = 2f, help = "Scale the tooltip window size. Useful for large resolutions.")]
-        [Order(6)]
+        [Order(5)]
         public float TooltipScale = 1f;
 
-        [Checkbox("Show Status Effects IDs")]
+        [DragFloat("Tooltip Max Width", min = 160f, max = 600f, help = "Maximum width of the tooltip box in pixels.")]
+        [Order(6)]
+        public float TooltipMaxWidth = 340f;
+
+        [DragFloat("Line Spacing", min = 0.2f, max = 1.5f, help = "Spacing between lines and sections (1 = normal, lower = compact).")]
         [Order(7)]
+        public float TooltipLineSpacing = 0.6f;
+
+        [DragFloat("Font Scale", min = 0.7f, max = 1.5f, help = "Scale factor for tooltip font size.")]
+        [Order(8)]
+        public float TooltipFontScale = 1f;
+
+        [DragFloat("Icon Scale", min = 0.5f, max = 2f, help = "Scale factor for the ability/status icon in tooltips.")]
+        [Order(9)]
+        public float TooltipIconScale = 1f;
+
+        [DragFloat("Height Buffer", min = 0f, max = 80f, help = "Extra space at bottom of tooltip to prevent clipping. Adjust if text is cut off.")]
+        [Order(10)]
+        public float TooltipHeightBuffer = 28f;
+
+        [Checkbox("Show Status Effects IDs")]
+        [Order(11)]
         public bool ShowStatusIDs = false;
 
         [Checkbox("Show Action ID", help = "Show action ID in hotbar and action tooltips.")]
-        [Order(8)]
+        [Order(12)]
         public bool ShowActionIDs = false;
 
         [Checkbox("Show Source Name")]
-        [Order(10)]
+        [Order(13)]
         public bool ShowSourceName = false;
 
+        [Checkbox("Game-style formatting", help = "Color section labels (Additional Effect, Duration) green, status names yellow, and add new lines between sections like the base game tooltips.")]
+        [Order(14)]
+        public bool UseGameStyleFormatting = true;
+
+        [ColorEdit4("Section Label Color", help = "Color for labels like 'Additional Effect:', 'Duration:'.")]
+        [Order(15)]
+        public PluginConfigColor SectionLabelColor = new PluginConfigColor(new(0f, 255f / 255f, 0f, 1f));
+
+        [ColorEdit4("Status Name Color", help = "Color for buff/status effect names like 'Blood of the Dragon'.")]
+        [Order(16)]
+        public PluginConfigColor StatusNameColor = new PluginConfigColor(new(255f / 255f, 255f / 255f, 0f, 1f));
+
+        [ColorEdit4("Secondary Label Color", help = "Color for Cast, Recast, Range, Radius labels.")]
+        [Order(17)]
+        public PluginConfigColor SecondaryLabelColor = new PluginConfigColor(new(204f / 255f, 204f / 255f, 204f / 255f, 1f));
+
         [ColorEdit4("Background Color")]
         [Order(15)]
         public PluginConfigColor BackgroundColor = new PluginConfigColor(new(19f / 255f, 19f / 255f, 19f / 255f, 190f / 250f));

Interface/DraggableHudElement.cs

@@ -256,6 +256,13 @@ namespace HSUI.Interface
         {
             return (new List<Vector2>(), new List<Vector2>());
         }
+
+        /// <summary>Returns the screen-space bounding box of the element for hover detection (e.g. visibility "hide unless hovered").</summary>
+        public virtual (Vector2 min, Vector2 max) GetScreenBounds(Vector2 origin)
+        {
+            var basePos = origin + ParentPos();
+            return (basePos + MinPos, basePos + MaxPos);
+        }
         #endregion
     }
 

Interface/GeneralElements/ActionBarsHud.cs

@@ -39,19 +39,19 @@ namespace HSUI.Interface.GeneralElements
         /// <summary>When we had a game drag and the user released, suppress all slot clicks this frame (release is not a click).</summary>
         private bool _suppressSlotClicksAfterDragRelease;
 
-        private const string SlotPayloadType = "HSUI_HOTBAR_SLOT";
+        internal const string SlotPayloadType = "HSUI_HOTBAR_SLOT";
         private const int SlotsPerBar = 12;
 
-        private static int _imGuiDragSourceSlotId = -1;
-        private static bool _anyHotbarAcceptedDrop;
-        private static int _lastOverlayFrame = -1;
+        internal static int _imGuiDragSourceSlotId = -1;
+        internal static bool _anyHotbarAcceptedDrop;
+        internal static int _lastOverlayFrame = -1;
         /// <summary>Deferred clear when release-outside: set when no overlay accepted, executed next frame.</summary>
-        private static int _pendingReleaseOutsideSlotId = -1;
+        internal static int _pendingReleaseOutsideSlotId = -1;
         /// <summary>To avoid PICKUP log spam: only log when we first start dragging a new slot.</summary>
-        private static int _lastLoggedPickupSlotId = -1;
+        internal static int _lastLoggedPickupSlotId = -1;
 
-        /// <summary>Encode hotbar (1-10) and slot (0-11) into internal slot id (0-119).</summary>
-        private static int ToSlotId(int hotbarIndex, int slotIndex)
+        /// <summary>Encode hotbar (1-10) and slot (0-11) into internal slot id (0-119). Controller bars use 1-8 and 0-7.</summary>
+        internal static int ToSlotId(int hotbarIndex, int slotIndex)
         {
             int bar = Math.Clamp(hotbarIndex, 1, 10) - 1;
             int slot = Math.Clamp(slotIndex, 0, 11);
@@ -59,32 +59,22 @@ namespace HSUI.Interface.GeneralElements
         }
 
         /// <summary>Decode internal slot id to hotbar (1-10) and slot (0-11). Returns (-1,-1) if invalid.</summary>
-        private static (int hotbarIndex, int slotIndex) FromSlotId(int slotId)
+        internal static (int hotbarIndex, int slotIndex) FromSlotId(int slotId)
         {
             if (slotId < 0 || slotId >= 10 * SlotsPerBar) return (-1, -1);
             return (slotId / SlotsPerBar + 1, slotId % SlotsPerBar);
         }
 
         [StructLayout(LayoutKind.Sequential)]
-        private struct SlotDragPayload
+        internal struct SlotDragPayload
         {
             public int SlotId;
         }
 
         /// <summary>
-        /// Visibility for HSUI Action Bars is driven by Visibility → Hotbars (Hotbar 1–10), not the per-element config.
+        /// Visibility for HSUI Action Bars is configured per hotbar in each Hotbar 1–10 menu.
         /// </summary>
-        public VisibilityConfig VisibilityConfig => GetHotbarVisibilityConfig();
-
-        private VisibilityConfig GetHotbarVisibilityConfig()
-        {
-            var hotbars = ConfigurationManager.Instance?.GetConfigObject<HotbarsVisibilityConfig>();
-            if (hotbars == null) return Config.VisibilityConfig;
-            var list = hotbars.GetHotbarConfigs();
-            int idx = Config.HotbarIndex - 1;
-            if (idx < 0 || idx >= list.Count) return Config.VisibilityConfig;
-            return list[idx];
-        }
+        public VisibilityConfig VisibilityConfig => Config.VisibilityConfig;
 
         public IGameObject? Actor { get; set; }
 
@@ -118,6 +108,9 @@ namespace HSUI.Interface.GeneralElements
         {
             if (!Config.Enabled || Actor == null)
                 return;
+            // When controller hotbars are effectively enabled (manual or sync with game), normal hotbars are hidden
+            if (ControllerHotbarsConfig.GetEffectiveControllerHotbarsEnabled())
+                return;
 
             if (ActionBarsManager.Instance == null)
                 return;
@@ -184,15 +177,20 @@ namespace HSUI.Interface.GeneralElements
 
                                 if (showCd && slot.CooldownPercent > 0 && _pendingSlotIconIndex != i)
                                 {
-                                    float total = 100f;
-                                    float elapsed = total - slot.CooldownPercent;
-                                    DrawHelper.DrawIconCooldown(pos, size, elapsed, total, drawList);
-                                    if (showCdNumbers && slot.CooldownSecondsLeft > 0)
+                                    // Skip cooldown overlay when slot overlaps game UI (e.g. dialogue box)
+                                    // to avoid hotbar cooldowns showing through during "Show HUD during dialogue"
+                                    if (!ClipRectsHelper.Instance.SlotOverlapsGameAddon(pos, size))
                                     {
-                                        string cdText = slot.CooldownSecondsLeft.ToString();
-                                        Vector2 textSize = ImGui.CalcTextSize(cdText);
-                                        Vector2 textPos = pos + (size - textSize) * 0.5f;
-                                        DrawHelper.DrawOutlinedText(cdText, textPos, 0xFFFFFFFF, 0xFF000000, drawList, 1);
+                                        float total = 100f;
+                                        float elapsed = total - slot.CooldownPercent;
+                                        DrawHelper.DrawIconCooldown(pos, size, elapsed, total, drawList);
+                                        if (showCdNumbers && slot.CooldownSecondsLeft > 0)
+                                        {
+                                            string cdText = slot.CooldownSecondsLeft.ToString();
+                                            Vector2 textSize = ImGui.CalcTextSize(cdText);
+                                            Vector2 textPos = pos + (size - textSize) * 0.5f;
+                                            DrawHelper.DrawOutlinedText(cdText, textPos, 0xFFFFFFFF, 0xFF000000, drawList, 1);
+                                        }
                                     }
                                 }
 
@@ -370,7 +368,9 @@ namespace HSUI.Interface.GeneralElements
                             if (!string.IsNullOrEmpty(title) || !string.IsNullOrEmpty(text))
                             {
                                 string body = string.IsNullOrEmpty(text) ? title : text;
-                                TooltipsHelper.Instance.ShowTooltipOnCursor(body, title, slot.ActionId, "", slot.IconId > 0 ? slot.IconId : null, Helpers.TooltipIdKind.Action);
+                                var tooltipConfig = ConfigurationManager.Instance?.GetConfigObject<HSUI.Helpers.TooltipsConfig>();
+                                var formatted = tooltipConfig != null ? TooltipsHelper.BuildFormattedActionTooltipBody(body, tooltipConfig) : null;
+                                TooltipsHelper.Instance.ShowTooltipOnCursor(body, title, slot.ActionId, "", slot.IconId > 0 ? slot.IconId : null, Helpers.TooltipIdKind.Action, formatted);
                                 if (IsTooltipDebugEnabled())
                                     Plugin.Logger.Information($"[HSUI Tooltip DBG] ActionBar tooltip (main overlay): slot={i} title='{title}'");
                             }
@@ -429,7 +429,9 @@ namespace HSUI.Interface.GeneralElements
                         if (!string.IsNullOrEmpty(title) || !string.IsNullOrEmpty(text))
                         {
                             string body = string.IsNullOrEmpty(text) ? title : text;
-                            TooltipsHelper.Instance.ShowTooltipOnCursor(body, title, slot.ActionId, "", slot.IconId > 0 ? slot.IconId : null, Helpers.TooltipIdKind.Action);
+                            var tooltipConfig = ConfigurationManager.Instance?.GetConfigObject<HSUI.Helpers.TooltipsConfig>();
+                            var formatted = tooltipConfig != null ? TooltipsHelper.BuildFormattedActionTooltipBody(body, tooltipConfig) : null;
+                            TooltipsHelper.Instance.ShowTooltipOnCursor(body, title, slot.ActionId, "", slot.IconId > 0 ? slot.IconId : null, Helpers.TooltipIdKind.Action, formatted);
                             if (IsTooltipDebugEnabled())
                                 Plugin.Logger.Information($"[HSUI Tooltip DBG] ActionBar tooltip (overlay): slot={i} title='{title}'");
                         }
@@ -492,7 +494,7 @@ namespace HSUI.Interface.GeneralElements
             return true;
         }
 
-        private static HotbarsConfig? GetHotbarsConfig() =>
+        internal static HotbarsConfig? GetHotbarsConfig() =>
             ConfigurationManager.Instance?.GetConfigObject<HotbarsConfig>();
 
         private static (int Type, int Int1, int Int2, double LastTime) _lastDragNoPayloadLog;
@@ -511,7 +513,7 @@ namespace HSUI.Interface.GeneralElements
             return true;
         }
 
-        private static unsafe bool IsGameDragging()
+        internal static unsafe bool IsGameDragging()
         {
             var stage = AtkStage.Instance();
             if (stage == null) return false;
@@ -519,7 +521,7 @@ namespace HSUI.Interface.GeneralElements
             return dm->IsDragging;
         }
 
-        private static unsafe bool TryGetSlotPayload(ImGuiPayloadPtr payload, out SlotDragPayload src)
+        internal static unsafe bool TryGetSlotPayload(ImGuiPayloadPtr payload, out SlotDragPayload src)
         {
             if (payload.Data == null || payload.DataSize < sizeof(SlotDragPayload))
             {
@@ -530,7 +532,7 @@ namespace HSUI.Interface.GeneralElements
             return true;
         }
 
-        private static void SetSlotPayload(SlotDragPayload pl)
+        internal static void SetSlotPayload(SlotDragPayload pl)
         {
             var type = new ImU8String(SlotPayloadType);
             var data = MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref pl, 1));
@@ -836,10 +838,10 @@ namespace HSUI.Interface.GeneralElements
         }
 
         /// <summary>
-        /// Gets drag payload from game/Dalamud. When game reports Item drag, prioritize HoveredItem
-        /// (HoveredAction can be stale from previous hotbar hover). Preserves full item id including HQ flag.
+        /// Gets drag payload from game/Dalamud. When game reports Item drag, prioritize HoveredItem.
+        /// Used by ActionBarsHud and CrossBarHud for drag-drop.
         /// </summary>
-        private static unsafe bool TryGetDragPayload(out RaptureHotbarModule.HotbarSlotType slotType, out uint id)
+        internal static unsafe bool TryGetDragPayload(out RaptureHotbarModule.HotbarSlotType slotType, out uint id)
         {
             slotType = RaptureHotbarModule.HotbarSlotType.Empty;
             id = 0;
@@ -1090,7 +1092,7 @@ namespace HSUI.Interface.GeneralElements
             };
         }
 
-        private static unsafe uint GetIconIdForPayload(RaptureHotbarModule.HotbarSlotType slotType, uint id)
+        internal static unsafe uint GetIconIdForPayload(RaptureHotbarModule.HotbarSlotType slotType, uint id)
         {
             // id 0 is valid for GearSet (first gearset in list) and Macro; don't short-circuit for those
             if (id == 0 && slotType != RaptureHotbarModule.HotbarSlotType.GearSet && slotType != RaptureHotbarModule.HotbarSlotType.Macro)
@@ -1151,6 +1153,19 @@ namespace HSUI.Interface.GeneralElements
             catch { return 0; }
         }
 
+        /// <summary>Public for CrossBarHud and other consumers. Returns (title, body) for a hotbar slot.</summary>
+        public static (string title, string text) GetSlotTooltipPublic(ActionBarsManager.SlotInfo slot)
+        {
+            try
+            {
+                return GetSlotTooltip(slot);
+            }
+            catch
+            {
+                return ("", "");
+            }
+        }
+
         private static unsafe (string title, string text) GetSlotTooltip(ActionBarsManager.SlotInfo slot)
         {
             try

Interface/GeneralElements/ControllerBarKeybindsConfig.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using Dalamud.Bindings.ImGui;
+using HSUI.Config;
+using HSUI.Config.Attributes;
+using HSUI.Helpers;
+
+namespace HSUI.Interface.GeneralElements
+{
+    /// <summary>Stores custom keybinds for controller cross bars (8 bars × 8 slots). Format: "Key:VK_X" or "Pad:South", empty = unset.</summary>
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Keybinds", 0)]
+    public class ControllerBarKeybindsConfig : PluginConfigObject
+    {
+        public const int Bars = 8;
+        public const int SlotsPerBar = 8;
+        public const int TotalSlots = Bars * SlotsPerBar;
+
+        /// <summary>Index = (bar-1)*8 + slot. Value = "Key:VK_1" or "Pad:South" or "" for unset.</summary>
+        public List<string> KeybindStrings { get; set; } = new List<string>();
+
+        [ManualDraw]
+        public bool DrawOpenKeybindsButton(ref bool changed)
+        {
+            if (ImGui.Button("Setup controller bar keybinds", new Vector2(260, 28)))
+            {
+                ConfigurationManager.Instance?.OpenControllerBarKeybindsWindow();
+                return false;
+            }
+            if (ImGui.IsItemHovered())
+                ImGui.SetTooltip("Open the keybind setup window to assign keyboard or gamepad buttons to each slot on the controller cross bars. These keybinds are independent of the game's keybind settings.");
+            return false;
+        }
+
+        public new static ControllerBarKeybindsConfig DefaultConfig() => new ControllerBarKeybindsConfig();
+
+        /// <summary>Get keybind for bar 1-8, slot 0-7. Returns "" if unset.</summary>
+        public string GetKeybind(int bar, int slot)
+        {
+            int idx = (bar - 1) * SlotsPerBar + slot;
+            if (idx < 0 || idx >= TotalSlots) return "";
+            EnsureCapacity();
+            return KeybindStrings.ElementAtOrDefault(idx) ?? "";
+        }
+
+        /// <summary>Set keybind for bar 1-8, slot 0-7. Value format: "Key:VK_X" or "Pad:South", or "" to clear.</summary>
+        public void SetKeybind(int bar, int slot, string value)
+        {
+            int idx = (bar - 1) * SlotsPerBar + slot;
+            if (idx < 0 || idx >= TotalSlots) return;
+            EnsureCapacity();
+            KeybindStrings[idx] = value ?? "";
+        }
+
+        private void EnsureCapacity()
+        {
+            while (KeybindStrings.Count < TotalSlots)
+                KeybindStrings.Add("");
+        }
+    }
+}

Interface/GeneralElements/ControllerHotbarsConfig.cs

@@ -0,0 +1,448 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HSUI.Config;
+using HSUI.Config.Attributes;
+using HSUI.Enums;
+using HSUI.Helpers;
+using HSUI.Interface;
+using System.Numerics;
+using Dalamud.Bindings.ImGui;
+using FFXIVClientStructs.FFXIV.Client.UI.Misc;
+
+namespace HSUI.Interface.GeneralElements
+{
+    /// <summary>Persisted slot content for one controller cross bar slot. Not shown in config UI.</summary>
+    public class ControllerSlotData
+    {
+        public int SlotType { get; set; }
+        public uint CommandId { get; set; }
+
+        public bool IsEmpty => SlotType == (int)RaptureHotbarModule.HotbarSlotType.Empty || (SlotType != (int)RaptureHotbarModule.HotbarSlotType.Macro && SlotType != (int)RaptureHotbarModule.HotbarSlotType.GearSet && CommandId == 0);
+    }
+
+    /// <summary>Which trigger combo shows this cross bar. Matches FFXIV cross hotbar sets (no trigger, L2, R2, L2+R2, R2+L2, then double-tap variants).</summary>
+    public enum CrossBarTrigger
+    {
+        None = 0,   // Bar 1: always visible when no trigger held
+        L2 = 1,
+        R2 = 2,
+        L2R2 = 3,  // L2 then R2
+        R2L2 = 4,  // R2 then L2
+        L2Double = 5,
+        R2Double = 6,
+        L2R2Double = 7,
+        R2L2Double = 8,
+    }
+
+    /// <summary>Config for one controller cross bar (8 slots in cross layout). Slot data is stored separately from game hotbars so controller and normal bars can differ.</summary>
+    public class ControllerBarConfig : AnchorablePluginConfigObject
+    {
+        internal int HotbarIndex { get; set; } = 1; // 1-8
+
+        /// <summary>Persisted slot contents for this cross bar (8 slots). Not drawn in config UI. Empty slots are SlotType=0 (Empty), CommandId=0.</summary>
+        public List<ControllerSlotData> Slots = new List<ControllerSlotData>();
+
+        [Combo("Show when", new string[] { "No trigger", "L2", "R2", "L2 + R2", "R2 + L2", "L2 double-tap", "R2 double-tap", "L2+R2 double", "R2+L2 double" })]
+        [Order(18)]
+        public int TriggerCombo = 0; // CrossBarTrigger
+
+        [DragInt2("Slot Size", min = 24, max = 96)]
+        [Order(22)]
+        public Vector2 SlotSize = new Vector2(40, 40);
+
+        [DragInt("Slot Padding", min = 0, max = 16)]
+        [Order(23)]
+        public int SlotPadding = 2;
+
+        [Checkbox("Show Cooldown Overlay")]
+        [Order(24)]
+        public bool ShowCooldownOverlay = true;
+
+        [Checkbox("Show Cooldown Numbers")]
+        [Order(25)]
+        public bool ShowCooldownNumbers = true;
+
+        [Checkbox("Show Border")]
+        [Order(26)]
+        public bool ShowBorder = true;
+
+        [Checkbox("Show Tooltips")]
+        [Order(27)]
+        public bool ShowTooltips = true;
+
+        [Checkbox("Show Keybinds")]
+        [Order(28)]
+        public bool ShowSlotNumbers = true;
+
+        [Checkbox("Show Charge Count")]
+        [Order(29)]
+        public bool ShowChargeCount = true;
+
+        [Checkbox("Show Combo Highlight")]
+        [Order(30)]
+        public bool ShowComboHighlight = true;
+
+        [Checkbox("Show Keypress Flash")]
+        [Order(31)]
+        public bool ShowKeypressFlash = true;
+
+        [NestedConfig("Combo Highlight", 32)]
+        public ComboHighlightConfig ComboHighlightConfig = new();
+
+        [NestedConfig("Visibility", 70)]
+        public VisibilityConfig VisibilityConfig = new VisibilityConfig();
+
+        /// <summary>Cross layout: 8 slots. Left 4 (vertical) + Right 4 (vertical). Slot indices 0-3 left, 4-7 right.</summary>
+        public const int CrossSlotCount = 8;
+
+        public CrossBarTrigger Trigger => (CrossBarTrigger)Math.Clamp(TriggerCombo, 0, 8);
+
+        public static ControllerBarConfig DefaultConfig(int hotbarIndex)
+        {
+            var config = new ControllerBarConfig { HotbarIndex = hotbarIndex };
+            ApplyDefaults(config, hotbarIndex);
+            return config;
+        }
+
+        public static void ApplyDefaults(ControllerBarConfig config, int hotbarIndex)
+        {
+            var viewport = ImGui.GetMainViewport().Size;
+            float yOffset = 60 + (hotbarIndex - 1) * 50;
+            config.Position = new Vector2(0, -viewport.Y * 0.5f + yOffset);
+            config.Anchor = DrawAnchor.Center;
+            // Two crosses side by side: 3 cells each (slot+pad), gap between
+            float cell = 40 + 2;
+            config.Size = new Vector2(3 * cell + 4 + 3 * cell, 3 * cell);
+            config.HotbarIndex = hotbarIndex;
+        }
+
+        /// <summary>Get the controller bar config for bar 1-8. Returns null if config not available.</summary>
+        public static ControllerBarConfig? GetBarConfig(int barIndex)
+        {
+            var cfg = ConfigurationManager.Instance;
+            if (cfg == null || barIndex < 1 || barIndex > 8) return null;
+            return barIndex switch
+            {
+                1 => cfg.GetConfigObject<ControllerBar1Config>(),
+                2 => cfg.GetConfigObject<ControllerBar2Config>(),
+                3 => cfg.GetConfigObject<ControllerBar3Config>(),
+                4 => cfg.GetConfigObject<ControllerBar4Config>(),
+                5 => cfg.GetConfigObject<ControllerBar5Config>(),
+                6 => cfg.GetConfigObject<ControllerBar6Config>(),
+                7 => cfg.GetConfigObject<ControllerBar7Config>(),
+                8 => cfg.GetConfigObject<ControllerBar8Config>(),
+                _ => null
+            };
+        }
+
+        /// <summary>Get slot data for this bar, padded to 8 entries. Caller can use index 0..7.</summary>
+        public void EnsureSlotsPadded()
+        {
+            while (Slots.Count < ControllerBarConfig.CrossSlotCount)
+                Slots.Add(new ControllerSlotData { SlotType = (int)RaptureHotbarModule.HotbarSlotType.Empty, CommandId = 0 });
+        }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("General", 0)]
+    public class ControllerHotbarsConfig : PluginConfigObject
+    {
+        [Checkbox("Use controller hotbars", help = "When enabled (and sync below is off), normal HSUI hotbars are hidden and the cross hotbars are shown. When sync with game is on, this is ignored and bar mode follows the game.")]
+        [Order(1, collapseWith = null)]
+        public new bool Enabled = false;
+
+        [Checkbox("Sync bar mode with game client", help = "When enabled, the plugin follows the game's Character Configuration toggle (Mouse and Gamepad Mode). Controller hotbars when gamepad mode is on, normal hotbars when keyboard/mouse mode is on. The 'Use controller hotbars' checkbox is ignored while sync is on.")]
+        [Order(2, collapseWith = null)]
+        public bool SyncBarModeWithGameClient = false;
+
+        /// <summary>True when controller hotbars should be shown: either sync is on and game is in controller mode, or sync is off and Enabled is true.</summary>
+        public static bool GetEffectiveControllerHotbarsEnabled()
+        {
+            var config = ConfigurationManager.Instance?.GetConfigObject<ControllerHotbarsConfig>();
+            if (config == null) return false;
+            if (config.SyncBarModeWithGameClient)
+                return ControllerHotbarHelper.IsGameInControllerMode();
+            return config.Enabled;
+        }
+
+        [ManualDraw]
+        public bool DrawRestoreControllerBarsButton(ref bool changed)
+        {
+            ImGuiHelper.DrawSeparator(2, 1);
+            if (ImGui.Button("Restore controller bar layout", new Vector2(220, 24)))
+            {
+                RestoreControllerBarsToDefaults();
+                changed = true;
+                return true;
+            }
+            if (ImGui.IsItemHovered())
+                ImGui.SetTooltip("Reset positions, layout, and display settings for all 8 controller cross bars to default. Use if your controller bars are misplaced or broken.");
+            return false;
+        }
+
+        [ManualDraw]
+        public bool DrawCloneButton(ref bool changed)
+        {
+            ImGuiHelper.DrawSeparator(2, 1);
+            if (ImGui.Button("Clone layout from normal hotbars", new Vector2(240, 24)))
+            {
+                CloneLayoutFromNormalHotbars();
+                changed = true;
+                return true;
+            }
+            if (ImGui.IsItemHovered())
+                ImGui.SetTooltip("Copy position, size, and display settings from Hotbar 1–8 to the controller cross bars. Does not change actions in the slots.");
+            return false;
+        }
+
+        [ManualDraw]
+        public bool DrawCloneActionsButton(ref bool changed)
+        {
+            if (ImGui.Button("Copy normal hotbars 1–8 → controller bars", new Vector2(280, 24)))
+            {
+                CloneActionsFromNormalHotbars();
+                changed = true;
+                return true;
+            }
+            if (ImGui.IsItemHovered())
+                ImGui.SetTooltip("Copy slot contents from normal Hotbar 1–8 into controller bar storage. Use this to mirror your keyboard hotbar setup onto the controller bars. Normal and controller bars are stored separately, so this does not overwrite your normal bars.");
+            return false;
+        }
+
+        [ManualDraw]
+        public bool DrawCopyControllerToNormalButton(ref bool changed)
+        {
+            if (ImGui.Button("Copy controller bars → normal hotbars 1–8", new Vector2(280, 24)))
+            {
+                CopyControllerBarsToNormalHotbars();
+                changed = true;
+                return true;
+            }
+            if (ImGui.IsItemHovered())
+                ImGui.SetTooltip("Copy controller bar slot contents into normal Hotbar 1–8. This overwrites the current normal hotbar 1–8 layout with your controller bar layout.");
+            return false;
+        }
+
+        public new static ControllerHotbarsConfig DefaultConfig() => new();
+
+        private static void CloneLayoutFromNormalHotbars()
+        {
+            var cfg = ConfigurationManager.Instance;
+            if (cfg == null) return;
+            var normal = new AnchorablePluginConfigObject?[]
+            {
+                cfg.GetConfigObject<Hotbar1BarConfig>(),
+                cfg.GetConfigObject<Hotbar2BarConfig>(),
+                cfg.GetConfigObject<Hotbar3BarConfig>(),
+                cfg.GetConfigObject<Hotbar4BarConfig>(),
+                cfg.GetConfigObject<Hotbar5BarConfig>(),
+                cfg.GetConfigObject<Hotbar6BarConfig>(),
+                cfg.GetConfigObject<Hotbar7BarConfig>(),
+                cfg.GetConfigObject<Hotbar8BarConfig>()
+            };
+            var controller = new ControllerBarConfig?[]
+            {
+                cfg.GetConfigObject<ControllerBar1Config>(),
+                cfg.GetConfigObject<ControllerBar2Config>(),
+                cfg.GetConfigObject<ControllerBar3Config>(),
+                cfg.GetConfigObject<ControllerBar4Config>(),
+                cfg.GetConfigObject<ControllerBar5Config>(),
+                cfg.GetConfigObject<ControllerBar6Config>(),
+                cfg.GetConfigObject<ControllerBar7Config>(),
+                cfg.GetConfigObject<ControllerBar8Config>()
+            };
+            for (int i = 0; i < 8; i++)
+            {
+                if (normal[i] is HotbarBarConfig n && controller[i] is ControllerBarConfig c)
+                {
+                    c.Position = n.Position;
+                    c.Anchor = n.Anchor;
+                    c.SlotSize = n.SlotSize;
+                    c.SlotPadding = n.SlotPadding;
+                    c.ShowCooldownOverlay = n.ShowCooldownOverlay;
+                    c.ShowCooldownNumbers = n.ShowCooldownNumbers;
+                    c.ShowBorder = n.ShowBorder;
+                    c.ShowTooltips = n.ShowTooltips;
+                    c.ShowSlotNumbers = n.ShowSlotNumbers;
+                    c.ShowChargeCount = n.ShowChargeCount;
+                    c.ShowComboHighlight = n.ShowComboHighlight;
+                    c.ShowKeypressFlash = n.ShowKeypressFlash;
+                    c.ComboHighlightConfig.Color = n.ComboHighlightConfig.Color;
+                    c.ComboHighlightConfig.ShowGlow = n.ComboHighlightConfig.ShowGlow;
+                    c.ComboHighlightConfig.LineStyle = n.ComboHighlightConfig.LineStyle;
+                    c.ComboHighlightConfig.Thickness = n.ComboHighlightConfig.Thickness;
+                }
+            }
+        }
+
+        private static unsafe void CloneActionsFromNormalHotbars()
+        {
+            if (ActionBarsManager.Instance == null) return;
+            var module = RaptureHotbarModule.Instance();
+            if (module == null || !module->ModuleReady) return;
+
+            for (int bar = 1; bar <= 8; bar++)
+            {
+                var barConfig = ControllerBarConfig.GetBarConfig(bar);
+                if (barConfig == null) continue;
+                barConfig.EnsureSlotsPadded();
+                int barIdx = bar - 1;
+                ref var displayBar = ref module->StandardHotbars[barIdx];
+                for (int slot = 0; slot < ControllerBarConfig.CrossSlotCount; slot++)
+                {
+                    var slotPtr = displayBar.GetHotbarSlot((uint)slot);
+                    if (slotPtr == null) continue;
+                    var slotType = slotPtr->IsEmpty && slotPtr->CommandType != RaptureHotbarModule.HotbarSlotType.GearSet
+                        ? RaptureHotbarModule.HotbarSlotType.Empty
+                        : slotPtr->CommandType;
+                    uint id = slotPtr->IsEmpty ? 0u : slotPtr->CommandId;
+                    while (barConfig.Slots.Count <= slot)
+                        barConfig.Slots.Add(new ControllerSlotData { SlotType = (int)RaptureHotbarModule.HotbarSlotType.Empty, CommandId = 0 });
+                    barConfig.Slots[slot] = new ControllerSlotData { SlotType = (int)slotType, CommandId = id };
+                }
+            }
+            ConfigurationManager.Instance?.SaveConfigurations();
+            Plugin.Logger?.Information("[HSUI] Copied normal hotbars 1–8 to controller bar storage.");
+        }
+
+        private static unsafe void CopyControllerBarsToNormalHotbars()
+        {
+            if (ActionBarsManager.Instance == null) return;
+            var module = RaptureHotbarModule.Instance();
+            if (module == null || !module->ModuleReady) return;
+
+            for (int bar = 1; bar <= 8; bar++)
+            {
+                var barConfig = ControllerBarConfig.GetBarConfig(bar);
+                if (barConfig == null) continue;
+                barConfig.EnsureSlotsPadded();
+                int barIdx = bar - 1;
+                ref var displayBar = ref module->StandardHotbars[barIdx];
+                for (int slot = 0; slot < ControllerBarConfig.CrossSlotCount && slot < barConfig.Slots.Count; slot++)
+                {
+                    var entry = barConfig.Slots[slot];
+                    var slotType = (RaptureHotbarModule.HotbarSlotType)entry.SlotType;
+                    uint id = entry.CommandId;
+                    var slotPtr = displayBar.GetHotbarSlot((uint)slot);
+                    if (slotPtr == null) continue;
+                    slotPtr->Set(slotType, id);
+                    slotPtr->LoadIconId();
+                    if (slotType == RaptureHotbarModule.HotbarSlotType.Item)
+                        slotPtr->LoadCostDataForSlot(true);
+                    ActionBarsManager.SetAndSaveSlotInternal(module, (uint)barIdx, (uint)slot, slotType, id, slotPtr);
+                }
+            }
+            Plugin.Logger?.Information("[HSUI] Copied controller bar storage to normal hotbars 1–8.");
+        }
+
+        private static void RestoreControllerBarsToDefaults()
+        {
+            var cfg = ConfigurationManager.Instance;
+            if (cfg == null) return;
+            var bars = new (ControllerBarConfig? config, int index)[]
+            {
+                (cfg.GetConfigObject<ControllerBar1Config>(), 1),
+                (cfg.GetConfigObject<ControllerBar2Config>(), 2),
+                (cfg.GetConfigObject<ControllerBar3Config>(), 3),
+                (cfg.GetConfigObject<ControllerBar4Config>(), 4),
+                (cfg.GetConfigObject<ControllerBar5Config>(), 5),
+                (cfg.GetConfigObject<ControllerBar6Config>(), 6),
+                (cfg.GetConfigObject<ControllerBar7Config>(), 7),
+                (cfg.GetConfigObject<ControllerBar8Config>(), 8)
+            };
+            foreach (var (bar, idx) in bars)
+            {
+                if (bar == null) continue;
+                bar.Enabled = true;
+                ControllerBarConfig.ApplyDefaults(bar, idx);
+                bar.TriggerCombo = idx - 1; // Bar 1 = None(0), Bar 2 = L2(1), ... Bar 8 = R2L2Double(7)
+                bar.SlotSize = new Vector2(40, 40);
+                bar.SlotPadding = 2;
+                bar.ShowCooldownOverlay = true;
+                bar.ShowCooldownNumbers = true;
+                bar.ShowBorder = true;
+                bar.ShowTooltips = true;
+                bar.ShowSlotNumbers = true;
+                bar.ShowChargeCount = true;
+                bar.ShowComboHighlight = true;
+                bar.ShowKeypressFlash = true;
+                bar.ComboHighlightConfig = new ComboHighlightConfig();
+                bar.VisibilityConfig = new VisibilityConfig();
+            }
+        }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 1", 0)]
+    public class ControllerBar1Config : ControllerBarConfig
+    {
+        public ControllerBar1Config() => HotbarIndex = 1;
+        public new static ControllerBar1Config DefaultConfig() { var c = new ControllerBar1Config(); ApplyDefaults(c, 1); return c; }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 2", 0)]
+    public class ControllerBar2Config : ControllerBarConfig
+    {
+        public ControllerBar2Config() => HotbarIndex = 2;
+        public new static ControllerBar2Config DefaultConfig() { var c = new ControllerBar2Config(); ApplyDefaults(c, 2); return c; }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 3", 0)]
+    public class ControllerBar3Config : ControllerBarConfig
+    {
+        public ControllerBar3Config() => HotbarIndex = 3;
+        public new static ControllerBar3Config DefaultConfig() { var c = new ControllerBar3Config(); ApplyDefaults(c, 3); return c; }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 4", 0)]
+    public class ControllerBar4Config : ControllerBarConfig
+    {
+        public ControllerBar4Config() => HotbarIndex = 4;
+        public new static ControllerBar4Config DefaultConfig() { var c = new ControllerBar4Config(); ApplyDefaults(c, 4); return c; }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 5", 0)]
+    public class ControllerBar5Config : ControllerBarConfig
+    {
+        public ControllerBar5Config() => HotbarIndex = 5;
+        public new static ControllerBar5Config DefaultConfig() { var c = new ControllerBar5Config(); ApplyDefaults(c, 5); return c; }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 6", 0)]
+    public class ControllerBar6Config : ControllerBarConfig
+    {
+        public ControllerBar6Config() => HotbarIndex = 6;
+        public new static ControllerBar6Config DefaultConfig() { var c = new ControllerBar6Config(); ApplyDefaults(c, 6); return c; }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 7", 0)]
+    public class ControllerBar7Config : ControllerBarConfig
+    {
+        public ControllerBar7Config() => HotbarIndex = 7;
+        public new static ControllerBar7Config DefaultConfig() { var c = new ControllerBar7Config(); ApplyDefaults(c, 7); return c; }
+    }
+
+    [Exportable(false)]
+    [Section("Controller Hotbars", true)]
+    [SubSection("Cross Bar 8", 0)]
+    public class ControllerBar8Config : ControllerBarConfig
+    {
+        public ControllerBar8Config() => HotbarIndex = 8;
+        public new static ControllerBar8Config DefaultConfig() { var c = new ControllerBar8Config(); ApplyDefaults(c, 8); return c; }
+    }
+}

Interface/GeneralElements/CrossBarHud.cs

@@ -0,0 +1,515 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Dalamud.Game.ClientState.Objects.Types;
+using HSUI.Config;
+using HSUI.Enums;
+using HSUI.Helpers;
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface.Utility;
+using FFXIVClientStructs.FFXIV.Client.Game;
+using FFXIVClientStructs.FFXIV.Client.UI;
+using FFXIVClientStructs.FFXIV.Client.UI.Misc;
+using FFXIVClientStructs.FFXIV.Component.GUI;
+using static FFXIVClientStructs.FFXIV.Client.Game.ActionManager;
+using LuminaAction = Lumina.Excel.Sheets.Action;
+
+namespace HSUI.Interface.GeneralElements
+{
+    /// <summary>Draws one controller cross hotbar (8 slots in cross layout). Visible only when controller hotbars are enabled and trigger state matches.</summary>
+    public class CrossBarHud : DraggableHudElement, IHudElementWithActor, IHudElementWithVisibilityConfig
+    {
+        private ControllerBarConfig Config => (ControllerBarConfig)_config;
+
+        private bool _wasDragging;
+        private uint _dragId;
+        private RaptureHotbarModule.HotbarSlotType _dragSlotType;
+        private int _pendingSlotIconIndex = -1;
+        private uint _pendingSlotIconId;
+        private int _pendingSlotIconFramesLeft;
+        private int _lastFrameDroppedOnSlot = -1;
+        private bool _suppressSlotClicksAfterDragRelease;
+
+        public IGameObject? Actor { get; set; }
+
+        public VisibilityConfig VisibilityConfig => Config.VisibilityConfig;
+
+        public CrossBarHud(ControllerBarConfig config, string displayName) : base(config, displayName) { }
+
+        protected override (List<Vector2>, List<Vector2>) ChildrenPositionsAndSizes()
+        {
+            var size = BarSize();
+            return (new List<Vector2> { Config.Position }, new List<Vector2> { size });
+        }
+
+        private Vector2 BarSize()
+        {
+            // Two crosses side by side: each cross is 3 cells (slot+pad); gap between crosses
+            float cellW = Config.SlotSize.X + Config.SlotPadding;
+            float cellH = Config.SlotSize.Y + Config.SlotPadding;
+            float gap = Config.SlotPadding * 2;
+            float w = 3 * cellW + gap + 3 * cellW;
+            float h = 3 * cellH;
+            return new Vector2(w, h);
+        }
+
+        /// <summary>Cross layout like the game: left cross (slots 0-3) = top/left/right/bottom around center; right cross (slots 4-7) same.</summary>
+        private Vector2 GetSlotPositionCross(int slotIndex, Vector2 slotSize, int pad)
+        {
+            float cellW = slotSize.X + pad;
+            float cellH = slotSize.Y + pad;
+            float leftCrossWidth = 3 * cellW;
+            float gap = pad * 2f;
+
+            if (slotIndex < 4)
+            {
+                // Left cross: 3x3 grid, slots at (1,0), (0,1), (2,1), (1,2)
+                int col = slotIndex switch { 0 => 1, 1 => 0, 2 => 2, _ => 1 };
+                int row = slotIndex switch { 0 => 0, 1 => 1, 2 => 1, _ => 2 };
+                return new Vector2(col * cellW, row * cellH);
+            }
+            else
+            {
+                // Right cross: same 3x3 pattern, offset by left cross + gap
+                int i = slotIndex - 4;
+                int col = i switch { 0 => 1, 1 => 0, 2 => 2, _ => 1 };
+                int row = i switch { 0 => 0, 1 => 1, 2 => 1, _ => 2 };
+                return new Vector2(leftCrossWidth + gap + col * cellW, row * cellH);
+            }
+        }
+
+        private const float DropMargin = 24f;
+
+        /// <summary>Hit test: returns slot index 0-7 if pos is over a cross slot, else -1.</summary>
+        private int GetSlotIndexAtPositionCross(Vector2 topLeft, Vector2 slotSize, int pad, Vector2 pos)
+        {
+            Vector2 barSize = new Vector2(
+                3 * (slotSize.X + pad) + pad * 2f + 3 * (slotSize.X + pad),
+                3 * (slotSize.Y + pad));
+            if (pos.X < topLeft.X || pos.X >= topLeft.X + barSize.X || pos.Y < topLeft.Y || pos.Y >= topLeft.Y + barSize.Y)
+                return -1;
+            int best = -1;
+            float bestDistSq = float.MaxValue;
+            for (int i = 0; i < ControllerBarConfig.CrossSlotCount; i++)
+            {
+                var slotOffset = GetSlotPositionCross(i, slotSize, pad);
+                float cx = topLeft.X + slotOffset.X + slotSize.X * 0.5f;
+                float cy = topLeft.Y + slotOffset.Y + slotSize.Y * 0.5f;
+                float dx = pos.X - cx, dy = pos.Y - cy;
+                float slotHalfW = slotSize.X * 0.5f + DropMargin;
+                float slotHalfH = slotSize.Y * 0.5f + DropMargin;
+                if (Math.Abs(dx) <= slotHalfW && Math.Abs(dy) <= slotHalfH)
+                {
+                    float distSq = dx * dx + dy * dy;
+                    if (distSq < bestDistSq) { bestDistSq = distSq; best = i; }
+                }
+            }
+            return best;
+        }
+
+        private unsafe void HandleDragDropCross(Vector2 topLeft, Vector2 barSize, Vector2 slotSize, int pad)
+        {
+            if (_pendingSlotIconIndex >= 0 && _pendingSlotIconFramesLeft > 0)
+            {
+                _pendingSlotIconFramesLeft--;
+                if (_pendingSlotIconFramesLeft <= 0)
+                    _pendingSlotIconIndex = -1;
+            }
+            else if (_pendingSlotIconIndex >= 0)
+                _pendingSlotIconIndex = -1;
+
+            var stage = AtkStage.Instance();
+            if (stage == null) return;
+            var dm = (AtkDragDropManager*)Unsafe.AsPointer(ref stage->DragDropManager);
+            bool dragging = dm->IsDragging;
+
+            if (dragging)
+            {
+                if (ActionBarsHud.GetHotbarsConfig()?.GeneralOptions?.EnableDragDropFromGame != false &&
+                    ActionBarsHud.TryGetDragPayload(out var slotType, out var id))
+                {
+                    _dragSlotType = slotType;
+                    _dragId = id;
+                    _wasDragging = true;
+
+                    var mp = ImGui.GetMousePos();
+                    int idx = GetSlotIndexAtPositionCross(topLeft, slotSize, pad, mp);
+                    if (idx >= 0)
+                        InputsHelper.SuppressExecuteSlotByIdAfterDrop((uint)(ActionBarsManager.ScratchBarIndex - 1), (uint)ActionBarsManager.ScratchSlotIndex, 500);
+
+                    if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
+                    {
+                        int releaseIdx = GetSlotIndexAtPositionCross(topLeft, slotSize, pad, mp);
+                        if (releaseIdx >= 0 && slotType != RaptureHotbarModule.HotbarSlotType.Empty &&
+                            (id != 0 || slotType == RaptureHotbarModule.HotbarSlotType.Macro || slotType == RaptureHotbarModule.HotbarSlotType.GearSet))
+                        {
+                            if (!ImGui.GetIO().KeyShift)
+                            {
+                                try
+                                {
+                                    ActionBarsManager.Instance?.PlacePayloadOnControllerSlot(Config.HotbarIndex, releaseIdx, slotType, id);
+                                    uint iconId = ActionBarsHud.GetIconIdForPayload(slotType, id);
+                                    if (iconId != 0)
+                                    {
+                                        _pendingSlotIconIndex = releaseIdx;
+                                        _pendingSlotIconId = iconId;
+                                        _pendingSlotIconFramesLeft = 300;
+                                    }
+                                    _lastFrameDroppedOnSlot = releaseIdx;
+                                    InputsHelper.SuppressExecuteSlotByIdAfterDrop((uint)(ActionBarsManager.ScratchBarIndex - 1), (uint)ActionBarsManager.ScratchSlotIndex, 300);
+                                    if (slotType == RaptureHotbarModule.HotbarSlotType.Action ||
+                                        slotType == RaptureHotbarModule.HotbarSlotType.GeneralAction ||
+                                        slotType == RaptureHotbarModule.HotbarSlotType.CraftAction ||
+                                        slotType == RaptureHotbarModule.HotbarSlotType.PetAction)
+                                        InputsHelper.SuppressUseActionAfterDrop(id, 300);
+                                }
+                                catch (Exception ex)
+                                {
+                                    Plugin.Logger.Warning($"[HSUI CrossBar DragDrop] Drop failed: {ex.Message}");
+                                }
+                            }
+                            try { dm->CancelDragDrop(true, true); }
+                            catch { }
+                        }
+                        else
+                        {
+                            try { dm->CancelDragDrop(true, true); }
+                            catch { }
+                        }
+                        _wasDragging = false;
+                    }
+                }
+                else
+                {
+                    _dragSlotType = RaptureHotbarModule.HotbarSlotType.Empty;
+                    _dragId = 0;
+                    _wasDragging = true;
+                    if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
+                    {
+                        try { dm->CancelDragDrop(true, true); }
+                        catch { }
+                        _wasDragging = false;
+                    }
+                }
+                return;
+            }
+
+            if (_wasDragging)
+            {
+                _suppressSlotClicksAfterDragRelease = true;
+                var mp = ImGui.GetMousePos();
+                int idx = GetSlotIndexAtPositionCross(topLeft, slotSize, pad, mp);
+                if (idx >= 0)
+                {
+                    var slotType = _dragSlotType;
+                    var id = _dragId;
+                    bool hasValidPayload = slotType != RaptureHotbarModule.HotbarSlotType.Empty &&
+                        (id != 0 || slotType == RaptureHotbarModule.HotbarSlotType.Macro || slotType == RaptureHotbarModule.HotbarSlotType.GearSet);
+                    if (hasValidPayload)
+                    {
+                        if (ImGui.GetIO().KeyShift)
+                        {
+                            try { dm->CancelDragDrop(true, true); }
+                            catch { }
+                            ActionBarsManager.Instance?.ClearControllerSlot(Config.HotbarIndex, idx);
+                            _lastFrameDroppedOnSlot = idx;
+                            _wasDragging = false;
+                            return;
+                        }
+                        try
+                        {
+                            ActionBarsManager.Instance?.PlacePayloadOnControllerSlot(Config.HotbarIndex, idx, slotType, id);
+                            try { dm->CancelDragDrop(true, true); }
+                            catch { }
+                            uint iconId = ActionBarsHud.GetIconIdForPayload(slotType, id);
+                            if (iconId != 0)
+                            {
+                                _pendingSlotIconIndex = idx;
+                                _pendingSlotIconId = iconId;
+                                _pendingSlotIconFramesLeft = 300;
+                            }
+                            _lastFrameDroppedOnSlot = idx;
+                            InputsHelper.SuppressExecuteSlotByIdAfterDrop((uint)(ActionBarsManager.ScratchBarIndex - 1), (uint)ActionBarsManager.ScratchSlotIndex, 300);
+                            if (slotType == RaptureHotbarModule.HotbarSlotType.Action ||
+                                slotType == RaptureHotbarModule.HotbarSlotType.GeneralAction ||
+                                slotType == RaptureHotbarModule.HotbarSlotType.CraftAction ||
+                                slotType == RaptureHotbarModule.HotbarSlotType.PetAction)
+                                InputsHelper.SuppressUseActionAfterDrop(id, 300);
+                        }
+                        catch (Exception ex)
+                        {
+                            Plugin.Logger.Warning($"[HSUI CrossBar DragDrop] Drop failed: {ex.Message}");
+                        }
+                    }
+                }
+                _wasDragging = false;
+            }
+        }
+
+        public override void DrawChildren(Vector2 origin)
+        {
+            if (!ControllerHotbarsConfig.GetEffectiveControllerHotbarsEnabled() || Actor == null)
+                return;
+            if (ControllerHotbarHelper.GetCurrentTrigger() != Config.Trigger)
+                return;
+            if (ActionBarsManager.Instance == null)
+                return;
+
+            _lastFrameDroppedOnSlot = -1;
+            _suppressSlotClicksAfterDragRelease = false;
+
+            var barSize = BarSize();
+            var topLeft = Utils.GetAnchoredPosition(origin + Config.Position, barSize, Config.Anchor);
+            var slotSize = Config.SlotSize;
+            int pad = Config.SlotPadding;
+            bool showCd = Config.ShowCooldownOverlay;
+            bool showCdNumbers = Config.ShowCooldownNumbers;
+            bool showBorder = Config.ShowBorder;
+
+            AddDrawAction(Config.StrataLevel, () =>
+            {
+                HandleDragDropCross(topLeft, barSize, slotSize, pad);
+                var slots = ActionBarsManager.Instance.GetControllerSlotData(Config.HotbarIndex, ControllerBarConfig.CrossSlotCount);
+
+                void DrawBarContent(ImDrawListPtr drawList)
+                {
+                    using (FontsManager.Instance.PushFont(FontsConfig.DefaultSmallFontKey))
+                    {
+                        for (int i = 0; i < slots.Count; i++)
+                        {
+                            var slot = slots[i];
+                            uint displayIconId = slot.IconId;
+                            bool isEmpty = slot.IsEmpty;
+                            bool usePending = _pendingSlotIconIndex == i && _pendingSlotIconId != 0;
+                            if (usePending)
+                            {
+                                displayIconId = _pendingSlotIconId;
+                                isEmpty = false;
+                            }
+
+                            var slotOffset = GetSlotPositionCross(i, slotSize, pad);
+                            var pos = topLeft + slotOffset;
+                            var size = new Vector2(slotSize.X, slotSize.Y);
+                            bool hovered = !isEmpty && ImGui.IsMouseHoveringRect(pos, pos + size);
+
+                            if (isEmpty)
+                            {
+                                drawList.AddRectFilled(pos, pos + size, 0x22000000);
+                                if (showBorder)
+                                    drawList.AddRect(pos, pos + size, 0xFF444444);
+                            }
+                            else
+                            {
+                                uint color = hovered ? 0xFFFFFFFF : (slot.IsUsable ? 0xFFFFFFFF : 0xAA888888);
+                                bool isComboNext = Config.ShowComboHighlight && IsComboNextAction(slot);
+                                DrawHelper.DrawIcon(displayIconId, pos, size, showBorder && !hovered && !isComboNext, color, drawList);
+
+                                if (hovered && showBorder)
+                                    drawList.AddRect(pos, pos + size, 0xFF88CCFF, 0, ImDrawFlags.None, 2);
+                                else if (isComboNext)
+                                {
+                                    var ch = Config.ComboHighlightConfig;
+                                    DrawHelper.DrawComboHighlightRect(drawList, pos, pos + size,
+                                        ch.Color.Base, ch.Thickness, ch.ShowGlow, ch.LineStyle);
+                                }
+
+                                if (showCd && slot.CooldownPercent > 0 && _pendingSlotIconIndex != i)
+                                {
+                                    // Skip cooldown overlay when slot overlaps game UI (e.g. dialogue box)
+                                    // to avoid hotbar cooldowns showing through during "Show HUD during dialogue"
+                                    if (!ClipRectsHelper.Instance.SlotOverlapsGameAddon(pos, size))
+                                    {
+                                        float total = 100f;
+                                        float elapsed = total - slot.CooldownPercent;
+                                        DrawHelper.DrawIconCooldown(pos, size, elapsed, total, drawList);
+                                        if (showCdNumbers && slot.CooldownSecondsLeft > 0)
+                                        {
+                                            string cdText = slot.CooldownSecondsLeft.ToString();
+                                            Vector2 textSize = ImGui.CalcTextSize(cdText);
+                                            Vector2 textPos = pos + (size - textSize) * 0.5f;
+                                            DrawHelper.DrawOutlinedText(cdText, textPos, 0xFFFFFFFF, 0xFF000000, drawList, 1);
+                                        }
+                                    }
+                                }
+
+                                if (Config.ShowKeypressFlash)
+                                {
+                                    float flashAlpha = InputsHelper.GetKeypressFlashAlpha(Config.HotbarIndex, i, 0.2);
+                                    if (flashAlpha > 0.001f)
+                                    {
+                                        byte a = (byte)(flashAlpha * 0.5f * 255);
+                                        drawList.AddRectFilled(pos, pos + size, (uint)(a << 24 | 0xFFFFFF));
+                                    }
+                                }
+                            }
+
+                            if (Config.ShowSlotNumbers && !slot.IsEmpty)
+                            {
+                                string label = !string.IsNullOrWhiteSpace(slot.KeybindHint)
+                                    ? slot.KeybindHint
+                                    : ActionBarsManager.GetDefaultKeybindLabel(Config.HotbarIndex, i);
+                                Vector2 labelSize = ImGui.CalcTextSize(label);
+                                Vector2 labelPos = new Vector2(pos.X + size.X - labelSize.X - 2, pos.Y + size.Y - labelSize.Y - 2);
+                                DrawHelper.DrawOutlinedText(label, labelPos, 0xFFFFFFFF, 0xFF000000, drawList, 1);
+                            }
+
+                            if (Config.ShowChargeCount && !slot.IsEmpty && slot.MaxCharges > 1)
+                            {
+                                string chargeText = slot.CurrentCharges.ToString();
+                                Vector2 chargeSize = ImGui.CalcTextSize(chargeText);
+                                Vector2 chargePos = new Vector2(pos.X + 2, pos.Y + 2);
+                                DrawHelper.DrawOutlinedText(chargeText, chargePos, 0xFFFFFFFF, 0xFF000000, drawList, 1);
+                            }
+                        }
+                    }
+                }
+
+                DrawHelper.DrawInWindow(ID + "_crossbar", topLeft, barSize, false, DrawBarContent);
+            });
+
+            // Overlay for click, drag-drop and tooltip
+            AddDrawAction(StrataLevel.HIGHEST, () =>
+            {
+                var slots = ActionBarsManager.Instance.GetControllerSlotData(Config.HotbarIndex, ControllerBarConfig.CrossSlotCount);
+                var flags = ImGuiWindowFlags.NoTitleBar | ImGuiWindowFlags.NoScrollbar | ImGuiWindowFlags.NoBackground
+                    | ImGuiWindowFlags.NoResize | ImGuiWindowFlags.NoMove | ImGuiWindowFlags.NoSavedSettings
+                    | ImGuiWindowFlags.NoFocusOnAppearing | ImGuiWindowFlags.NoBringToFrontOnFocus
+                    | ImGuiWindowFlags.NoNav;
+
+                string overlayId = $"HSUI_CrossBar{Config.HotbarIndex}_input";
+                ImGui.SetCursorScreenPos(topLeft);
+                if (!ImGui.BeginChild(overlayId, barSize, false, flags))
+                {
+                    ImGui.EndChild();
+                    return;
+                }
+
+                int frame = ImGui.GetFrameCount();
+                if (frame != ActionBarsHud._lastOverlayFrame)
+                {
+                    ActionBarsHud._lastOverlayFrame = frame;
+                    ActionBarsHud._anyHotbarAcceptedDrop = false;
+                    if (ActionBarsHud._pendingReleaseOutsideSlotId >= 0 && ActionBarsHud.GetHotbarsConfig()?.GeneralOptions?.EnableReleaseOutsideToClear != false)
+                    {
+                        var (bar, slot) = ActionBarsHud.FromSlotId(ActionBarsHud._pendingReleaseOutsideSlotId);
+                        if (bar >= 1 && bar <= 8 && slot >= 0 && slot < ControllerBarConfig.CrossSlotCount)
+                            ActionBarsManager.Instance?.ClearControllerSlot(bar, slot);
+                        ActionBarsHud._pendingReleaseOutsideSlotId = -1;
+                    }
+                }
+
+                bool acceptedDrop = false;
+                for (int i = 0; i < ControllerBarConfig.CrossSlotCount; i++)
+                {
+                    var slotOffset = GetSlotPositionCross(i, slotSize, pad);
+                    var slotPos = topLeft + slotOffset;
+                    ImGui.SetCursorScreenPos(slotPos);
+                    bool clicked = ImGui.InvisibleButton($"##{overlayId}_slot_{i}", slotSize);
+                    bool isHovered = ImGui.IsItemHovered();
+                    bool isActive = ImGui.IsItemActive();
+
+                    bool shiftHeld = ImGui.GetIO().KeyShift;
+                    int targetSlotId = ActionBarsHud.ToSlotId(Config.HotbarIndex, i);
+
+                    if (ActionBarsHud.GetHotbarsConfig()?.GeneralOptions?.EnableShiftDragToRearrange != false && ImGui.BeginDragDropTarget())
+                    {
+                        var payload = ImGui.AcceptDragDropPayload(ActionBarsHud.SlotPayloadType);
+                        if (payload != ImGuiPayloadPtr.Null && payload.IsDataType(ActionBarsHud.SlotPayloadType) && ActionBarsHud.TryGetSlotPayload(payload, out var src))
+                        {
+                            acceptedDrop = true;
+                            ActionBarsHud._anyHotbarAcceptedDrop = true;
+                            ActionBarsHud._imGuiDragSourceSlotId = -1;
+                            ActionBarsHud._pendingReleaseOutsideSlotId = -1;
+                            ActionBarsHud._lastLoggedPickupSlotId = -1;
+                            if (src.SlotId != targetSlotId)
+                            {
+                                var (srcBar, srcSlot) = ActionBarsHud.FromSlotId(src.SlotId);
+                                if (srcBar >= 1 && srcSlot >= 0 && srcBar <= 8 && srcSlot < ControllerBarConfig.CrossSlotCount)
+                                    ActionBarsManager.Instance?.SwapControllerSlots(srcBar, srcSlot, Config.HotbarIndex, i);
+                            }
+                        }
+                        ImGui.EndDragDropTarget();
+                    }
+
+                    if (ActionBarsHud.GetHotbarsConfig()?.GeneralOptions?.EnableShiftDragToRearrange != false && !ActionBarsHud.IsGameDragging() && shiftHeld && i < slots.Count && !slots[i].IsEmpty && isActive && ImGui.IsMouseDragging(ImGuiMouseButton.Left))
+                    {
+                        if (ImGui.BeginDragDropSource(ImGuiDragDropFlags.None))
+                        {
+                            ActionBarsHud._imGuiDragSourceSlotId = targetSlotId;
+                            ActionBarsHud.SetSlotPayload(new ActionBarsHud.SlotDragPayload { SlotId = targetSlotId });
+                            var icon = TexturesHelper.GetTextureFromIconId(slots[i].IconId);
+                            if (icon != null)
+                                ImGui.Image(icon.Handle, new Vector2(32, 32));
+                            ImGui.EndDragDropSource();
+                        }
+                    }
+
+                    if (clicked && !acceptedDrop && !ImGui.IsMouseDragging(ImGuiMouseButton.Left) && i < slots.Count && !slots[i].IsEmpty)
+                    {
+                        if (_suppressSlotClicksAfterDragRelease || i == _lastFrameDroppedOnSlot)
+                        {
+                            _suppressSlotClicksAfterDragRelease = false;
+                            _lastFrameDroppedOnSlot = -1;
+                        }
+                        else if (shiftHeld)
+                        {
+                            ActionBarsManager.Instance?.ClearControllerSlot(Config.HotbarIndex, i);
+                        }
+                        else
+                        {
+                            ActionBarsManager.Instance?.ExecuteControllerSlot(Config.HotbarIndex, i);
+                        }
+                    }
+
+                    if (Config.ShowTooltips && isHovered && i < slots.Count)
+                    {
+                        var slot = slots[i];
+                        if (!slot.IsEmpty)
+                        {
+                            var (title, text) = ActionBarsHud.GetSlotTooltipPublic(slot);
+                            if (!string.IsNullOrEmpty(title) || !string.IsNullOrEmpty(text))
+                            {
+                                string body = string.IsNullOrEmpty(text) ? title : text;
+                                var tooltipConfig = ConfigurationManager.Instance?.GetConfigObject<TooltipsConfig>();
+                                var formatted = tooltipConfig != null ? TooltipsHelper.BuildFormattedActionTooltipBody(body, tooltipConfig) : null;
+                                TooltipsHelper.Instance.ShowTooltipOnCursor(body, title, slot.ActionId, "", slot.IconId > 0 ? slot.IconId : null, TooltipIdKind.Action, formatted);
+                            }
+                        }
+                    }
+                }
+
+                if (ActionBarsHud.GetHotbarsConfig()?.GeneralOptions?.EnableReleaseOutsideToClear != false && ImGui.GetIO().KeyShift && ActionBarsHud._imGuiDragSourceSlotId >= 0 &&
+                    ImGui.IsMouseReleased(ImGuiMouseButton.Left) && !ActionBarsHud._anyHotbarAcceptedDrop)
+                {
+                    ActionBarsHud._pendingReleaseOutsideSlotId = ActionBarsHud._imGuiDragSourceSlotId;
+                    ActionBarsHud._imGuiDragSourceSlotId = -1;
+                    ActionBarsHud._lastLoggedPickupSlotId = -1;
+                }
+
+                ImGui.EndChild();
+            });
+        }
+
+        private static bool IsComboNextAction(ActionBarsManager.SlotInfo slot)
+        {
+            if (slot.IsEmpty || slot.ActionId == 0) return false;
+            try
+            {
+                var slotType = slot.SlotType;
+                var actionType = slotType switch
+                {
+                    RaptureHotbarModule.HotbarSlotType.Action => ActionType.Action,
+                    RaptureHotbarModule.HotbarSlotType.GeneralAction => ActionType.GeneralAction,
+                    RaptureHotbarModule.HotbarSlotType.CraftAction => ActionType.CraftAction,
+                    RaptureHotbarModule.HotbarSlotType.PetAction => ActionType.PetAction,
+                    _ => (ActionType?)null
+                };
+                if (!actionType.HasValue) return false;
+                return SpellHelper.Instance.IsActionHighlighted(slot.ActionId, actionType.Value);
+            }
+            catch { return false; }
+        }
+    }
+}

Interface/GeneralElements/DutyListScenarioConfig.cs

@@ -0,0 +1,72 @@
+using Dalamud.Bindings.ImGui;
+using HSUI.Config;
+using HSUI.Config.Attributes;
+using HSUI.Enums;
+using System.Numerics;
+
+namespace HSUI.Interface.GeneralElements
+{
+    [Section("Other Elements")]
+    [SubSection("Duty List & Scenario Guide", 0)]
+    public class DutyListScenarioConfig : AnchorablePluginConfigObject
+    {
+        [Checkbox("Show Quest Icons")]
+        [Order(20)]
+        public bool ShowQuestIcons = true;
+
+        [DragInt("Icon Size", min = 12, max = 48)]
+        [Order(21, collapseWith = nameof(ShowQuestIcons))]
+        public int IconSize = 24;
+
+        [DragFloat("Font Scale", min = 0.5f, max = 2f)]
+        [Order(23)]
+        public float FontScale = 1f;
+
+        [Font("Font")]
+        [Order(24)]
+        public string FontID = "Default";
+
+        [ColorEdit4("Text Color")]
+        [Order(30)]
+        public PluginConfigColor TextColor = new(new Vector4(1f, 1f, 1f, 1f));
+
+        [ColorEdit4("Background Color")]
+        [Order(31)]
+        public PluginConfigColor BackgroundColor = new(new Vector4(0f, 0f, 0f, 0f));
+
+        [ColorEdit4("Divider Color")]
+        [Order(32)]
+        public PluginConfigColor DividerColor = new(new Vector4(1f, 1f, 1f, 0.6f));
+
+        [Checkbox("Show Duty Finder section when in queue")]
+        [Order(35)]
+        public bool ShowDutyFinderSection = true;
+
+        [ColorEdit4("Duty Finder title color")]
+        [Order(36, collapseWith = nameof(ShowDutyFinderSection))]
+        public PluginConfigColor DutyFinderTitleColor = new(new Vector4(1f, 0.85f, 0.2f, 1f));
+
+        [ColorEdit4("Duty Finder detail color")]
+        [Order(37, collapseWith = nameof(ShowDutyFinderSection))]
+        public PluginConfigColor DutyFinderDetailColor = new(new Vector4(0.4f, 0.75f, 1f, 1f));
+
+        [NestedConfig("Visibility", 70)]
+        public VisibilityConfig VisibilityConfig = new();
+
+        public DutyListScenarioConfig()
+        {
+            Size = new Vector2(320, 200);
+        }
+
+        public new static DutyListScenarioConfig DefaultConfig()
+        {
+            var config = new DutyListScenarioConfig
+            {
+                Position = new Vector2(ImGui.GetMainViewport().Size.X * 0.38f, -ImGui.GetMainViewport().Size.Y * 0.35f),
+                Size = new Vector2(320, 200),
+                Anchor = DrawAnchor.TopRight
+            };
+            return config;
+        }
+    }
+}

Interface/GeneralElements/DutyListScenarioHud.cs

@@ -0,0 +1,281 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using HSUI.Config;
+using HSUI.Helpers;
+using HSUI.Interface;
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace HSUI.Interface.GeneralElements
+{
+    public class DutyListScenarioHud : DraggableHudElement, IHudElementWithVisibilityConfig
+    {
+        private DutyListScenarioConfig Config => (DutyListScenarioConfig)_config;
+        public VisibilityConfig VisibilityConfig => Config.VisibilityConfig;
+
+        public DutyListScenarioHud(DutyListScenarioConfig config, string displayName)
+            : base(config, displayName) { }
+
+        protected override (List<Vector2>, List<Vector2>) ChildrenPositionsAndSizes()
+        {
+            return (new List<Vector2> { Config.Position }, new List<Vector2> { Config.Size });
+        }
+
+        /// <summary>Screen-space bounds for visibility "hide unless hovered" must match the draw position exactly.</summary>
+        public override (Vector2 min, Vector2 max) GetScreenBounds(Vector2 origin)
+        {
+            Vector2 topLeft = Utils.GetAnchoredPosition(origin + ParentPos() + Config.Position, Config.Size, Config.Anchor);
+            return (topLeft, topLeft + Config.Size);
+        }
+
+        public override void DrawChildren(Vector2 origin)
+        {
+            if (!Config.Enabled)
+                return;
+
+            var dutyListEntries = DutyListScenarioHelper.GetDutyListEntries();
+            var scenarioEntries = DutyListScenarioHelper.GetScenarioGuideEntries();
+            var dutyFinderInfo = DutyListScenarioHelper.GetDutyFinderQueueInfo();
+            var dutyInfo = DutyListScenarioHelper.GetDutyInfo();
+
+            bool hasDutyList = dutyListEntries.Count > 0;
+            bool hasScenario = scenarioEntries.Count > 0;
+            // Show queue info when in queue; show duty info when in duty (not in queue). Same section, different content.
+            bool hasDutyFinder = Config.ShowDutyFinderSection && dutyFinderInfo != null;
+            bool hasDutyInfo = Config.ShowDutyFinderSection && dutyInfo != null;
+
+            if (!hasDutyList && !hasScenario && !hasDutyFinder && !hasDutyInfo)
+                return;
+
+            Vector2 basePos = Utils.GetAnchoredPosition(origin + Config.Position, Config.Size, Config.Anchor);
+            Vector2 iconSize = new Vector2(Config.IconSize, Config.IconSize);
+            float lineHeight = Config.IconSize + 4;
+            float padding = 6;
+            float contentWidth = Config.Size.X - padding * 2;
+
+            AddDrawAction(Config.StrataLevel, () =>
+            {
+                DrawHelper.DrawInWindow(ID, basePos, Config.Size, true, (drawList) =>
+                {
+                    uint bgColor = Config.BackgroundColor.Base;
+                    if ((bgColor & 0xFF000000) != 0)
+                        drawList.AddRectFilled(basePos, basePos + Config.Size, bgColor, 4);
+                    drawList.PushClipRect(basePos, basePos + Config.Size, true);
+
+                    float y = basePos.Y + padding;
+                    uint textColor = Config.TextColor.Base;
+
+                    if (Config.FontID != "Default" && FontsManager.Instance != null)
+                    {
+                        using (FontsManager.Instance.PushFont(Config.FontID))
+                        {
+                            ImGui.SetWindowFontScale(Config.FontScale);
+                            DrawContent(drawList, ref y, basePos.X + padding, contentWidth, lineHeight, iconSize, textColor, hasDutyList, hasScenario, hasDutyFinder, hasDutyInfo, dutyListEntries, scenarioEntries, dutyFinderInfo, dutyInfo);
+                            ImGui.SetWindowFontScale(1);
+                        }
+                    }
+                    else
+                    {
+                        ImGui.PushFont(UiBuilder.DefaultFont);
+                        ImGui.SetWindowFontScale(Config.FontScale);
+                        DrawContent(drawList, ref y, basePos.X + padding, contentWidth, lineHeight, iconSize, textColor, hasDutyList, hasScenario, hasDutyFinder, hasDutyInfo, dutyListEntries, scenarioEntries, dutyFinderInfo, dutyInfo);
+                        ImGui.SetWindowFontScale(1);
+                        ImGui.PopFont();
+                    }
+                    drawList.PopClipRect();
+                });
+            });
+        }
+
+        private static string TruncateText(string text, float maxWidth)
+        {
+            if (ImGui.CalcTextSize(text).X <= maxWidth)
+                return text;
+            string suffix = "...";
+            while (text.Length > 1 && ImGui.CalcTextSize(text + suffix).X > maxWidth)
+                text = text[..^1];
+            return text + suffix;
+        }
+
+        private void DrawContent(
+            ImDrawListPtr drawList,
+            ref float y,
+            float x,
+            float contentWidth,
+            float lineHeight,
+            Vector2 iconSize,
+            uint textColor,
+            bool hasDutyList,
+            bool hasScenario,
+            bool hasDutyFinder,
+            bool hasDutyInfo,
+            List<DutyListScenarioHelper.DutyListEntry> dutyListEntries,
+            List<DutyListScenarioHelper.ScenarioGuideEntry> scenarioEntries,
+            DutyListScenarioHelper.DutyFinderQueueInfo? dutyFinderInfo,
+            DutyListScenarioHelper.DutyInfo? dutyInfo)
+        {
+            const uint TankIconId = 62581;
+            const uint HealerIconId = 62582;
+            const uint DPSIconId = 62583;
+
+            if (hasDutyInfo && dutyInfo != null)
+            {
+                uint titleColor = Config.DutyFinderTitleColor.Base;
+                uint detailColor = Config.DutyFinderDetailColor.Base;
+
+                drawList.AddText(new Vector2(x, y), titleColor, "Duty Information");
+                y += lineHeight;
+
+                string dutyText = TruncateText(dutyInfo.DutyName, contentWidth);
+                drawList.AddText(new Vector2(x, y), detailColor, dutyText);
+                y += lineHeight;
+
+                if (!string.IsNullOrEmpty(dutyInfo.TimerText))
+                {
+                    drawList.AddText(new Vector2(x, y), detailColor, TruncateText(dutyInfo.TimerText, contentWidth));
+                    y += lineHeight;
+                }
+
+                foreach (var obj in dutyInfo.Objectives)
+                {
+                    string line = string.IsNullOrWhiteSpace(obj.Text) ? "???" : obj.Text;
+                    if (!string.IsNullOrWhiteSpace(obj.Progress))
+                        line += ": " + obj.Progress;
+                    drawList.AddText(new Vector2(x, y), detailColor, TruncateText(line, contentWidth));
+                    y += lineHeight;
+                }
+
+                y += 4;
+                if (hasScenario || hasDutyList)
+                {
+                    float divY = y + 2;
+                    drawList.AddRectFilled(new Vector2(x, divY), new Vector2(x + contentWidth, divY + 2f), Config.DividerColor.Base);
+                    y += 8;
+                }
+            }
+            else if (hasDutyFinder && dutyFinderInfo != null)
+            {
+                uint titleColor = Config.DutyFinderTitleColor.Base;
+                uint detailColor = Config.DutyFinderDetailColor.Base;
+
+                drawList.AddText(new Vector2(x, y), titleColor, "Duty Finder");
+                y += lineHeight;
+
+                string dutyText = TruncateText(dutyFinderInfo.DutyName, contentWidth);
+                drawList.AddText(new Vector2(x, y), detailColor, dutyText);
+                y += lineHeight;
+
+                string statusText = TruncateText(dutyFinderInfo.StatusText, contentWidth);
+                drawList.AddText(new Vector2(x, y), detailColor, statusText);
+                y += lineHeight;
+
+                float roleX = x;
+                roleX += 4;
+                DrawHelper.DrawIcon(TankIconId, new Vector2(roleX, y), new Vector2(iconSize.X * 0.8f, iconSize.Y * 0.8f), false, detailColor, drawList);
+                roleX += iconSize.X * 0.8f + 2;
+                drawList.AddText(new Vector2(roleX, y), detailColor, $":{dutyFinderInfo.TanksFound}/{dutyFinderInfo.TanksNeeded}");
+                roleX += ImGui.CalcTextSize($":{dutyFinderInfo.TanksFound}/{dutyFinderInfo.TanksNeeded}").X + 6;
+                DrawHelper.DrawIcon(HealerIconId, new Vector2(roleX, y), new Vector2(iconSize.X * 0.8f, iconSize.Y * 0.8f), false, detailColor, drawList);
+                roleX += iconSize.X * 0.8f + 2;
+                drawList.AddText(new Vector2(roleX, y), detailColor, $":{dutyFinderInfo.HealersFound}/{dutyFinderInfo.HealersNeeded}");
+                roleX += ImGui.CalcTextSize($":{dutyFinderInfo.HealersFound}/{dutyFinderInfo.HealersNeeded}").X + 6;
+                DrawHelper.DrawIcon(DPSIconId, new Vector2(roleX, y), new Vector2(iconSize.X * 0.8f, iconSize.Y * 0.8f), false, detailColor, drawList);
+                roleX += iconSize.X * 0.8f + 2;
+                drawList.AddText(new Vector2(roleX, y), detailColor, $":{dutyFinderInfo.DPSFound}/{dutyFinderInfo.DPSNeeded}");
+                y += lineHeight;
+
+                string elapsedStr = $"{(int)dutyFinderInfo.TimeElapsed.TotalMinutes}:{dutyFinderInfo.TimeElapsed.Seconds:D2}";
+                string timeLine = "Time Elapsed: " + elapsedStr;
+                if (!string.IsNullOrEmpty(dutyFinderInfo.AverageWaitText))
+                    timeLine += " / Average Wait Time: " + dutyFinderInfo.AverageWaitText;
+                timeLine = TruncateText(timeLine, contentWidth);
+                drawList.AddText(new Vector2(x, y), detailColor, timeLine);
+                y += lineHeight + 4;
+
+                if (hasScenario || hasDutyList)
+                {
+                    float divY = y + 2;
+                    drawList.AddRectFilled(new Vector2(x, divY), new Vector2(x + contentWidth, divY + 2f), Config.DividerColor.Base);
+                    y += 8;
+                }
+            }
+
+            if (hasScenario)
+            {
+                foreach (var entry in scenarioEntries)
+                {
+                    float lineX = x;
+                    if (Config.ShowQuestIcons && entry.IconId != 0)
+                    {
+                        DrawHelper.DrawIcon(entry.IconId, new Vector2(lineX, y), iconSize, false, textColor, drawList);
+                        lineX += iconSize.X + 4;
+                    }
+
+                    string text = TruncateText($"{entry.Label}: Lv. {entry.Level} {entry.QuestName}", contentWidth - (lineX - x));
+                    var textSize = ImGui.CalcTextSize(text);
+                    drawList.AddText(new Vector2(lineX, y), textColor, text);
+
+                    // Use full line height for hit area so the second line (Job) doesn't get covered by the first (MSQ)
+                    if (ImGui.IsMouseHoveringRect(new Vector2(lineX, y), new Vector2(x + contentWidth, y + lineHeight))
+                        && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
+                    {
+                        DutyListScenarioHelper.OpenMapForQuestIssuer(entry.QuestRowId);
+                    }
+
+                    y += lineHeight;
+                }
+                if (hasDutyList)
+                {
+                    float divY = y + 2;
+                    drawList.AddRectFilled(new Vector2(x, divY), new Vector2(x + contentWidth, divY + 2f), Config.DividerColor.Base);
+                    y += 8;
+                }
+            }
+
+            if (hasDutyList)
+            {
+                uint objectiveColor = ImGui.ColorConvertFloat4ToU32(new Vector4(0.78f, 0.78f, 0.78f, 1f));
+
+                foreach (var entry in dutyListEntries)
+                {
+                    float lineX = x;
+                    if (Config.ShowQuestIcons && entry.IconId != 0)
+                    {
+                        DrawHelper.DrawIcon(entry.IconId, new Vector2(lineX, y), iconSize, false, textColor, drawList);
+                        lineX += iconSize.X + 4;
+                    }
+
+                    string nameText = TruncateText(entry.QuestName, contentWidth - (lineX - x));
+                    var nameSize = ImGui.CalcTextSize(nameText);
+                    drawList.AddText(new Vector2(lineX, y), textColor, nameText);
+
+                    if (entry.QuestId != 0
+                        && ImGui.IsMouseHoveringRect(new Vector2(lineX, y), new Vector2(lineX + nameSize.X, y + nameSize.Y))
+                        && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
+                    {
+                        DutyListScenarioHelper.OpenJournalForQuest(entry.QuestId);
+                    }
+
+                    y += lineHeight;
+
+                    if (!string.IsNullOrWhiteSpace(entry.ObjectiveText))
+                    {
+                        float objX = lineX + 8;
+                        string objText = TruncateText("• " + entry.ObjectiveText, contentWidth - (objX - x));
+                        var objSize = ImGui.CalcTextSize(objText);
+                        drawList.AddText(new Vector2(objX, y), objectiveColor, objText);
+
+                        if (entry.QuestId != 0
+                            && ImGui.IsMouseHoveringRect(new Vector2(objX, y), new Vector2(objX + objSize.X, y + objSize.Y))
+                            && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
+                        {
+                            DutyListScenarioHelper.OpenMapForQuestObjective(entry.QuestId, entry.Sequence);
+                        }
+
+                        y += lineHeight;
+                    }
+                }
+            }
+        }
+    }
+}

Interface/GeneralElements/HUDOptionsConfig.cs

@@ -70,6 +70,12 @@ namespace HSUI.Interface.GeneralElements
         [Order(50)]
         public bool HideDefaultPulltimer = false;
 
+        [Checkbox("Show HUD during dialogue and interaction", help =
+            "When enabled, HSUI stays visible (including hotbars and other elements) when talking to NPCs or interacting with objects.\n" +
+            "When disabled, only the castbar is shown during dialogue and interaction (after a short delay), matching the game's default behavior.")]
+        [Order(55)]
+        public bool ShowHudDuringDialogue = true;
+
         [Checkbox("Use Regional Number Format", help = "When enabled, HSUI will use your system's regional format settings when showing numbers.\nWhen disabled, HSUI will use English number formatting instead.", separator = true)]
         [Order(60)]
         public bool UseRegionalNumberFormats = true;

Interface/GeneralElements/HotbarsConfig.cs

@@ -153,23 +153,9 @@ namespace HSUI.Interface.GeneralElements
             {
                 if (bar == null) continue;
                 bar.Enabled = true;
+                bar.VisibilityConfig.CopyFrom(new VisibilityConfig());
                 HotbarBarConfig.ApplyDefaults(bar, idx);
             }
-            var vis = cfg.GetConfigObject<HotbarsVisibilityConfig>();
-            if (vis != null)
-            {
-                var defaults = new VisibilityConfig();
-                vis.HotbarConfig1.CopyFrom(defaults);
-                vis.HotbarConfig2.CopyFrom(defaults);
-                vis.HotbarConfig3.CopyFrom(defaults);
-                vis.HotbarConfig4.CopyFrom(defaults);
-                vis.HotbarConfig5.CopyFrom(defaults);
-                vis.HotbarConfig6.CopyFrom(defaults);
-                vis.HotbarConfig7.CopyFrom(defaults);
-                vis.HotbarConfig8.CopyFrom(defaults);
-                vis.HotbarConfig9.CopyFrom(defaults);
-                vis.HotbarConfig10.CopyFrom(defaults);
-            }
         }
     }
 

Interface/GeneralElements/HotbarsVisibilityConfig.cs

@@ -1,71 +0,0 @@
-using HSUI.Config;
-using HSUI.Config.Attributes;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace HSUI.Interface.GeneralElements
-{
-    [Disableable(false)]
-    [Exportable(false)]
-    [Section("Visibility")]
-    [SubSection("Hotbars", 0)]
-    public class HotbarsVisibilityConfig : PluginConfigObject
-    {
-        public new static HotbarsVisibilityConfig DefaultConfig() { return new HotbarsVisibilityConfig(); }
-
-        [NestedConfig("Hotbar 1", 50)]
-        public VisibilityConfig HotbarConfig1 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 2", 51)]
-        public VisibilityConfig HotbarConfig2 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 3", 52)]
-        public VisibilityConfig HotbarConfig3 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 4", 53)]
-        public VisibilityConfig HotbarConfig4 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 5", 54)]
-        public VisibilityConfig HotbarConfig5 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 6", 55)]
-        public VisibilityConfig HotbarConfig6 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 7", 56)]
-        public VisibilityConfig HotbarConfig7 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 8", 57)]
-        public VisibilityConfig HotbarConfig8 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 9", 58)]
-        public VisibilityConfig HotbarConfig9 = new VisibilityConfig();
-
-        [NestedConfig("Hotbar 10", 59)]
-        public VisibilityConfig HotbarConfig10 = new VisibilityConfig();
-
-        [NestedConfig("Cross Hotbar", 60)]
-        public VisibilityConfig HotbarConfigCross = new VisibilityConfig();
-
-        private List<VisibilityConfig> _configs;
-        public List<VisibilityConfig> GetHotbarConfigs() => _configs;
-
-        public HotbarsVisibilityConfig()
-        {
-            _configs = new List<VisibilityConfig>() {
-                HotbarConfig1,
-                HotbarConfig2,
-                HotbarConfig3,
-                HotbarConfig4,
-                HotbarConfig5,
-                HotbarConfig6,
-                HotbarConfig7,
-                HotbarConfig8,
-                HotbarConfig9,
-                HotbarConfig10
-            };
-        }
-    }
-}

Interface/GeneralElements/MainMenuConfig.cs

@@ -0,0 +1,61 @@
+using Dalamud.Bindings.ImGui;
+using HSUI.Config;
+using HSUI.Config.Attributes;
+using HSUI.Enums;
+using System.Numerics;
+
+namespace HSUI.Interface.GeneralElements
+{
+    [Section("Other Elements")]
+    [SubSection("Main Menu", 0)]
+    public class MainMenuConfig : AnchorablePluginConfigObject
+    {
+        [Combo("Layout", new[] { "Horizontal", "Vertical" })]
+        [Order(18)]
+        public int LayoutDirection = 0; // 0 = horizontal, 1 = vertical
+
+        [DragInt("Icon Size", min = 16, max = 64)]
+        [Order(20)]
+        public int IconSize = 36;
+
+        [DragInt("Spacing", min = 0, max = 24)]
+        [Order(21)]
+        public int Spacing = 4;
+
+        [ColorEdit4("Background Color")]
+        [Order(30)]
+        public PluginConfigColor BackgroundColor = new(new Vector4(0f, 0f, 0f, 0.6f));
+
+        [ColorEdit4("Icon Tint")]
+        [Order(31)]
+        public PluginConfigColor IconTint = new(new Vector4(1f, 1f, 1f, 1f));
+
+        [ColorEdit4("Hover Tint")]
+        [Order(32)]
+        public PluginConfigColor HoverTint = new(new Vector4(1f, 1f, 1f, 1f));
+
+        [Checkbox("Show Labels")]
+        [Order(35)]
+        public bool ShowLabels = false;
+
+        [NestedConfig("Visibility", 70)]
+        public VisibilityConfig VisibilityConfig = new();
+
+        public MainMenuConfig()
+        {
+            // Width fits 7 icons (36px) + 6 gaps (4px) + 8 margin = 284
+            Size = new Vector2(284, 48);
+        }
+
+        public new static MainMenuConfig DefaultConfig()
+        {
+            var viewport = ImGui.GetMainViewport().Size;
+            return new MainMenuConfig
+            {
+                Position = new Vector2(0, viewport.Y * 0.5f - 24),
+                Size = new Vector2(284, 48),
+                Anchor = DrawAnchor.Bottom
+            };
+        }
+    }
+}

Interface/GeneralElements/MainMenuHud.cs

@@ -0,0 +1,190 @@
+using Dalamud.Bindings.ImGui;
+using HSUI.Config;
+using HSUI.Helpers;
+using HSUI.Interface;
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace HSUI.Interface.GeneralElements
+{
+    public class MainMenuHud : DraggableHudElement, IHudElementWithVisibilityConfig
+    {
+        private const float BarPadding = 0f;
+        private const float BackgroundRounding = 6f;
+        /// <summary>Extra padding around content when drawing the background so the bar doesn't extend past the icons.</summary>
+        private const float BackgroundEdgePad = 2f;
+
+        private MainMenuConfig Config => (MainMenuConfig)_config;
+        public VisibilityConfig VisibilityConfig => Config.VisibilityConfig;
+
+        /// <summary>When set, the context menu with these entries should be shown (same frame or next). Cleared when popup closes.</summary>
+        private List<(uint CommandId, string Name)>? _contextMenuEntries = null;
+
+        public MainMenuHud(MainMenuConfig config, string displayName)
+            : base(config, displayName) { }
+
+        protected override (List<Vector2>, List<Vector2>) ChildrenPositionsAndSizes()
+        {
+            return (new List<Vector2> { Config.Position }, new List<Vector2> { Config.Size });
+        }
+
+        public override (Vector2 min, Vector2 max) GetScreenBounds(Vector2 origin)
+        {
+            Vector2 topLeft = Utils.GetAnchoredPosition(origin + ParentPos() + Config.Position, Config.Size, Config.Anchor);
+            return (topLeft, topLeft + Config.Size);
+        }
+
+        public override void DrawChildren(Vector2 origin)
+        {
+            if (!Config.Enabled)
+                return;
+
+            var entries = MainMenuHelper.GetEnabledMainCommands();
+            if (entries.Count == 0)
+                return;
+
+            Vector2 basePos = Utils.GetAnchoredPosition(origin + Config.Position, Config.Size, Config.Anchor);
+            Vector2 iconSize = new Vector2(Config.IconSize, Config.IconSize);
+            bool horizontal = Config.LayoutDirection == 0;
+
+            AddDrawAction(Config.StrataLevel, () =>
+            {
+                DrawHelper.DrawInWindow(ID, basePos, Config.Size, true, (drawListParam) =>
+                {
+                    var drawList = ImGui.GetWindowDrawList();
+
+                    // Compute total content size and starting position so icons are centered in the bar
+                    int count = entries.Count;
+                    float contentW, contentH;
+                    if (horizontal)
+                    {
+                        contentW = count * iconSize.X + (count > 0 ? (count - 1) * Config.Spacing : 0);
+                        if (Config.ShowLabels)
+                        {
+                            for (int i = 0; i < count; i++)
+                                contentW += ImGui.CalcTextSize(entries[i].Name).X + Config.Spacing;
+                        }
+                        contentH = iconSize.Y;
+                    }
+                    else
+                    {
+                        contentW = iconSize.X;
+                        contentH = 0;
+                        foreach (var e in entries)
+                        {
+                            float h = iconSize.Y + Config.Spacing;
+                            if (Config.ShowLabels && !string.IsNullOrEmpty(e.Name))
+                                h += ImGui.CalcTextSize(e.Name).Y + 2;
+                            contentH += h;
+                        }
+                        if (contentH > 0) contentH -= Config.Spacing;
+                    }
+                    float startX = basePos.X + BarPadding + Math.Max(0, (Config.Size.X - 2f * BarPadding - contentW) / 2f);
+                    float startY = basePos.Y + BarPadding + Math.Max(0, (Config.Size.Y - 2f * BarPadding - contentH) / 2f);
+
+                    // Draw background only over the content area so no gray bar shows on left/right
+                    Vector2 bgMin = new Vector2(startX - BackgroundEdgePad, basePos.Y);
+                    Vector2 bgMax = new Vector2(startX + contentW + BackgroundEdgePad, basePos.Y + Config.Size.Y);
+                    if (!horizontal)
+                    {
+                        bgMin = new Vector2(basePos.X, startY - BackgroundEdgePad);
+                        bgMax = new Vector2(basePos.X + Config.Size.X, startY + contentH + BackgroundEdgePad);
+                    }
+                    drawList.AddRectFilled(bgMin, bgMax, Config.BackgroundColor.Base, BackgroundRounding);
+                    drawList.PushClipRect(basePos, basePos + Config.Size, true);
+
+                    float x = startX;
+                    float y = startY;
+                    int index = 0;
+
+                    foreach (var entry in entries)
+                    {
+                        Vector2 iconPos = horizontal
+                            ? new Vector2(x, basePos.Y + (Config.Size.Y - iconSize.Y) / 2f)
+                            : new Vector2(basePos.X + (Config.Size.X - iconSize.X) / 2f, y);
+                        Vector2 iconEnd = iconPos + iconSize;
+
+                        // Use InvisibleButton so ImGui tracks hover/click for this icon
+                        ImGui.SetCursorScreenPos(iconPos);
+                        ImGui.InvisibleButton($"##mainmenu_icon_{ID}_{index}", iconSize);
+                        bool hovered = ImGui.IsItemHovered();
+
+                        uint tint = Config.IconTint.Base;
+                        if (hovered)
+                        {
+                            tint = Config.HoverTint.Base;
+                            TooltipsHelper.Instance.NotifyMouseOverHudElement();
+                            TooltipsHelper.Instance.ShowTooltipOnCursor(entry.Name);
+                        }
+
+                        if (ImGui.IsItemClicked(ImGuiMouseButton.Left) || ImGui.IsItemClicked(ImGuiMouseButton.Right))
+                        {
+                            var subEntries = MainMenuHelper.GetSubCommandEntries(entry.CommandId);
+                            if (subEntries != null && subEntries.Count > 0)
+                            {
+                                _contextMenuEntries = subEntries;
+                                ImGui.OpenPopup("HSUI_MainMenu_Context");
+                                ImGui.SetNextWindowPos(ImGui.GetMousePos());
+                            }
+                            else
+                            {
+                                MainMenuHelper.ExecuteMainCommand(entry.CommandId);
+                            }
+                        }
+
+                        if (entry.IconId != 0)
+                            DrawHelper.DrawIcon(entry.IconId, iconPos, iconSize, false, tint, drawList);
+
+                        float labelH = 0;
+                        if (Config.ShowLabels && !string.IsNullOrEmpty(entry.Name))
+                        {
+                            float labelW = ImGui.CalcTextSize(entry.Name).X;
+                            labelH = ImGui.CalcTextSize(entry.Name).Y;
+                            Vector2 labelPos = horizontal
+                                ? new Vector2(iconPos.X + iconSize.X + Config.Spacing, basePos.Y + (Config.Size.Y - labelH) / 2f)
+                                : new Vector2(basePos.X + (Config.Size.X - labelW) / 2f, iconPos.Y + iconSize.Y + 2);
+                            drawList.AddText(labelPos, Config.IconTint.Base, entry.Name);
+                        }
+
+                        if (horizontal)
+                        {
+                            float advance = iconSize.X + Config.Spacing;
+                            if (Config.ShowLabels) advance += ImGui.CalcTextSize(entry.Name).X + Config.Spacing;
+                            x += advance;
+                        }
+                        else
+                        {
+                            y += iconSize.Y + 2 + labelH + Config.Spacing;
+                        }
+                        index++;
+                    }
+
+                    drawList.PopClipRect();
+
+                    // Draw context menu popup (same options as default main menu bar)
+                    if (ImGui.BeginPopup("HSUI_MainMenu_Context", ImGuiWindowFlags.NoMove))
+                    {
+                        if (_contextMenuEntries != null)
+                        {
+                            foreach (var (cmdId, name) in _contextMenuEntries)
+                            {
+                                if (ImGui.Selectable(name))
+                                {
+                                    uint commandId = cmdId;
+                                    Plugin.Framework.RunOnFrameworkThread(() => MainMenuHelper.ExecuteMainCommand(commandId));
+                                    ImGui.CloseCurrentPopup();
+                                }
+                            }
+                        }
+                        ImGui.EndPopup();
+                    }
+                    else
+                    {
+                        _contextMenuEntries = null;
+                    }
+                }, true);
+            });
+        }
+    }
+}

Interface/GeneralElements/VisibilityConfig.cs

@@ -1,3 +1,4 @@
+using Dalamud.Bindings.ImGui;
 using Dalamud.Game.ClientState.Conditions;
 using Dalamud.Game.ClientState.Objects.Enums;
 using Dalamud.Game.ClientState.Objects.SubKinds;
@@ -6,12 +7,17 @@ using HSUI.Config.Attributes;
 using HSUI.Interface.GeneralElements;
 using HSUI.Interface.Party;
 using System.Linq;
+using System.Numerics;
 
 namespace HSUI.Interface
 {
     [Exportable(false)]
     public class VisibilityConfig : PluginConfigObject
     {
+        [Checkbox("Hide unless hovered", help = "When enabled, the element is hidden until the cursor hovers over it. Requires HUD to be locked.")]
+        [Order(4)]
+        public bool HideUnlessHovered = false;
+
         [Checkbox("Hide outside of combat")]
         [Order(5)]
         public bool HideOutsideOfCombat = false;
@@ -96,6 +102,18 @@ namespace HSUI.Interface
             if (element != null && element.GetType() == typeof(PlayerCastbarHud)) { return true; }
             if (element != null && !element.GetConfig().Enabled) { return false; }
 
+            // Hide unless hovered: element is visible only when the cursor is over it
+            if (HideUnlessHovered && element is DraggableHudElement draggable)
+            {
+                Vector2 origin = ImGui.GetMainViewport().Size / 2f;
+                var hudOptions = ConfigurationManager.Instance?.GetConfigObject<HUDOptionsConfig>();
+                if (hudOptions != null && hudOptions.UseGlobalHudShift)
+                    origin += hudOptions.HudOffset;
+                var (min, max) = draggable.GetScreenBounds(origin);
+                if (!ImGui.IsMouseHoveringRect(min, max))
+                    return false;
+            }
+
             // Alliance frames only matter in alliance raids (duty). HideInDuty would hide them exactly when needed.
             bool isAllianceFrames = element != null && element.GetType() == typeof(AllianceFramesHud);
 
@@ -144,6 +162,7 @@ namespace HSUI.Interface
         {
             Enabled = config.Enabled;
 
+            HideUnlessHovered = config.HideUnlessHovered;
             HideOutsideOfCombat = config.HideOutsideOfCombat;
             HideInCombat = config.HideInCombat;
             HideInGoldSaucer = config.HideInGoldSaucer;

Interface/HudHelper.cs

@@ -30,6 +30,8 @@ namespace HSUI.Interface
         private bool _hidingCastBar = false;
         private Vector2 _pullTimerPos = Vector2.Zero;
         private bool _hidingPullTimer = false;
+        private bool _hidingDutyListOffScreen = false;
+        private bool _toDoListVisibleBeforeHide = true;
 
         public HudHelper()
         {
@@ -63,6 +65,7 @@ namespace HSUI.Interface
                     SetGameHudElementsHidden(Array.Empty<uint>(), true);
                     UpdateDefaultCastBar(true);
                     UpdateDefaultPulltimer(true);
+                    UpdateDefaultDutyList(true);
                     UpdateDefaultNameplates(true);
                     UpdateJobGauges(true);
                 }
@@ -107,6 +110,7 @@ namespace HSUI.Interface
                 UpdateJobGauges();
                 UpdateDefaultHudElementsHidden();
                 UpdateDefaultCastBar();
+                UpdateDefaultDutyList();
                 UpdateDefaultNameplates();
             }
             catch (Exception ex)
@@ -253,6 +257,18 @@ namespace HSUI.Interface
             if (enemyList?.Enabled == true)
                 AddElements(ElementKind.EnemyList);
 
+            var dutyListScenario = ConfigurationManager.Instance?.GetConfigObject<DutyListScenarioConfig>();
+            if (dutyListScenario?.Enabled == true)
+            {
+                // Only hide Scenario Tree via layout. Keep ToDoList in layout so it stays created/updated; we move it off-screen in UpdateDefaultDutyList so we can read objective text.
+                AddElements(ElementKind.ScenarioTree);
+            }
+
+            var mainMenu = ConfigurationManager.Instance?.GetConfigObject<MainMenuConfig>();
+            // Disabled while troubleshooting: keep game's Main Menu visible so we can compare behavior.
+            // if (mainMenu?.Enabled == true)
+            //     AddElements(ElementKind.MainMenu);
+
             // NamePlate is not in HUD Layout config; use UpdateDefaultNameplates (IsVisible) for that
             if (IsCurrentJobHudEnabled())
             {
@@ -293,6 +309,8 @@ namespace HSUI.Interface
 
         /// <summary>Visibility (ByteValue2) of game HUD elements before we hid them. Restored on disable/unload.</summary>
         private readonly Dictionary<uint, byte> _gameHudVisibilityBeforeHide = new();
+        /// <summary>When we force-show ToDoList for off-screen text reading, save its ByteValue2 here to restore on disable.</summary>
+        private readonly Dictionary<uint, byte> _gameHudForceShowBeforeRestore = new();
 
         private unsafe void SetGameHudElementsHidden(uint[] hashesToHide, bool forceRestore)
         {
@@ -316,6 +334,17 @@ namespace HSUI.Interface
                     hasChanges = true;
                 }
                 _gameHudVisibilityBeforeHide.Clear();
+
+                foreach (ref var entry in entries)
+                {
+                    if (!_gameHudForceShowBeforeRestore.TryGetValue(entry.AddonNameHash, out byte saved))
+                        continue;
+                    if (entry.ByteValue2 == saved)
+                        continue;
+                    entry.ByteValue2 = saved;
+                    hasChanges = true;
+                }
+                _gameHudForceShowBeforeRestore.Clear();
             }
             else
             {
@@ -330,6 +359,44 @@ namespace HSUI.Interface
                     entry.ByteValue2 = 0x0;
                     hasChanges = true;
                 }
+
+                // When Duty List/Scenario is enabled, force-show the Duty List (ToDoList) so the addon is created and we can move it off-screen for text reading
+                var dutyListScenario = ConfigurationManager.Instance?.GetConfigObject<DutyListScenarioConfig>();
+                if (dutyListScenario?.Enabled == true)
+                {
+                    uint toDoListHash = (uint)ElementKind.ToDoList;
+                    foreach (ref var entry in entries)
+                    {
+                        if (entry.AddonNameHash != toDoListHash)
+                            continue;
+                        if (!_gameHudForceShowBeforeRestore.ContainsKey(entry.AddonNameHash))
+                            _gameHudForceShowBeforeRestore[entry.AddonNameHash] = entry.ByteValue2;
+                        if (entry.ByteValue2 != 0x0)
+                            continue;
+                        entry.ByteValue2 = 0x1;
+                        hasChanges = true;
+                        break;
+                    }
+                }
+                else
+                {
+                    uint toDoListHash = (uint)ElementKind.ToDoList;
+                    if (_gameHudForceShowBeforeRestore.TryGetValue(toDoListHash, out byte saved))
+                    {
+                        foreach (ref var entry in entries)
+                        {
+                            if (entry.AddonNameHash != toDoListHash)
+                                continue;
+                            if (entry.ByteValue2 != saved)
+                            {
+                                entry.ByteValue2 = saved;
+                                hasChanges = true;
+                            }
+                            _gameHudForceShowBeforeRestore.Remove(toDoListHash);
+                            break;
+                        }
+                    }
+                }
             }
 
             if (hasChanges)
@@ -418,6 +485,45 @@ namespace HSUI.Interface
             return;
         }
 
+        /// <summary>When Duty List/Scenario is enabled, hide the game's Duty List addon with IsVisible=false so it stays at layout position and remains populated for objective text; restore on disable.</summary>
+        private unsafe void UpdateDefaultDutyList(bool forceRestore = false)
+        {
+            var dutyListScenario = ConfigurationManager.Instance?.GetConfigObject<DutyListScenarioConfig>();
+            bool shouldHide = !forceRestore && (dutyListScenario?.Enabled ?? false);
+
+            if (shouldHide && !_hidingDutyListOffScreen)
+            {
+                Plugin.AddonLifecycle.RegisterListener(AddonEvent.PreDraw, "_ToDoList", (addonEvent, args) =>
+                {
+                    AtkUnitBase* addon = (AtkUnitBase*)args.Addon.Address;
+                    if (addon == null) return;
+                    addon->IsVisible = false;
+                });
+
+                var addon = (AtkUnitBase*)Plugin.GameGui.GetAddonByName("_ToDoList", 1).Address;
+                if (addon == null) addon = (AtkUnitBase*)Plugin.GameGui.GetAddonByName("_ToDoList", 0).Address;
+                if (addon != null)
+                {
+                    _toDoListVisibleBeforeHide = addon->IsVisible;
+                    addon->IsVisible = false;
+                }
+
+                _hidingDutyListOffScreen = true;
+            }
+            else if ((forceRestore || !shouldHide) && _hidingDutyListOffScreen)
+            {
+                Plugin.AddonLifecycle.UnregisterListener(AddonEvent.PreDraw, "_ToDoList");
+
+                var addon = (AtkUnitBase*)Plugin.GameGui.GetAddonByName("_ToDoList", 1).Address;
+                if (addon == null) addon = (AtkUnitBase*)Plugin.GameGui.GetAddonByName("_ToDoList", 0).Address;
+                if (addon != null)
+                    addon->IsVisible = _toDoListVisibleBeforeHide;
+
+                _toDoListVisibleBeforeHide = true;
+                _hidingDutyListOffScreen = false;
+            }
+        }
+
         private static readonly Dictionary<uint, Type> _jobIdToConfigType = new()
         {
             [JobIDs.PLD] = typeof(PaladinConfig), [JobIDs.WAR] = typeof(WarriorConfig),

Interface/HudManager.cs

@@ -425,10 +425,37 @@ namespace HSUI.Interface
                 _hudElementsUsingPlayer.Add(barHud);
             }
 
+            ControllerBarConfig[] controllerBarConfigs = new ControllerBarConfig[]
+            {
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar1Config>(),
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar2Config>(),
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar3Config>(),
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar4Config>(),
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar5Config>(),
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar6Config>(),
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar7Config>(),
+                ConfigurationManager.Instance.GetConfigObject<ControllerBar8Config>()
+            };
+            for (int i = 0; i < controllerBarConfigs.Length; i++)
+            {
+                var barConfig = controllerBarConfigs[i];
+                var crossBarHud = new CrossBarHud(barConfig, $"Cross Bar {i + 1}");
+                _hudElements.Add(barConfig, crossBarHud);
+                _hudElementsUsingPlayer.Add(crossBarHud);
+            }
+
             var partyCooldownsConfig = ConfigurationManager.Instance.GetConfigObject<PartyCooldownsConfig>();
             var partyCooldownsHud = new PartyCooldownsHud(partyCooldownsConfig, "Party Cooldowns");
             _hudElements.Add(partyCooldownsConfig, partyCooldownsHud);
             _hudElementsWithPreview.Add(partyCooldownsHud);
+
+            var dutyListScenarioConfig = ConfigurationManager.Instance.GetConfigObject<DutyListScenarioConfig>();
+            var dutyListScenarioHud = new DutyListScenarioHud(dutyListScenarioConfig, "Duty List & Scenario Guide");
+            _hudElements.Add(dutyListScenarioConfig, dutyListScenarioHud);
+
+            var mainMenuConfig = ConfigurationManager.Instance.GetConfigObject<MainMenuConfig>();
+            var mainMenuHud = new MainMenuHud(mainMenuConfig, "Main Menu");
+            _hudElements.Add(mainMenuConfig, mainMenuHud);
         }
 
         public void Draw(uint jobId)
@@ -557,6 +584,15 @@ namespace HSUI.Interface
                 return false;
             }
 
+            // When "Show HUD during dialogue" is on, keep HSUI visible during NPC dialogue and object interaction
+            // even if the game hides the parameter bar
+            var hudOptions = ConfigurationManager.Instance?.GetConfigObject<HUDOptionsConfig>();
+            if (hudOptions?.ShowHudDuringDialogue == true &&
+                (Plugin.Condition[ConditionFlag.OccupiedInQuestEvent] || Plugin.Condition[ConditionFlag.OccupiedInEvent]))
+            {
+                return true;
+            }
+
             AtkUnitBase* parameterWidget = (AtkUnitBase*)Plugin.GameGui.GetAddonByName("_ParameterWidget", 1).Address;
             AtkUnitBase* fadeMiddleWidget = (AtkUnitBase*)Plugin.GameGui.GetAddonByName("FadeMiddle", 1).Address;
 
@@ -568,6 +604,10 @@ namespace HSUI.Interface
 
         protected bool ShouldOnlyShowCastbar()
         {
+            var hudOptions = ConfigurationManager.Instance?.GetConfigObject<HUDOptionsConfig>();
+            if (hudOptions?.ShowHudDuringDialogue == true)
+                return false;
+
             // when in quest dialogs and events, hide everything except castbars
             // this includes talking to npcs or interacting with quest related stuff
             if (Plugin.Condition[ConditionFlag.OccupiedInQuestEvent] ||

Plugin.cs

@@ -43,6 +43,8 @@ namespace HSUI
         public static IAddonLifecycle AddonLifecycle { get; private set; } = null!;
         public static IChatGui Chat { get; private set; } = null!;
         public static ISeStringEvaluator SeStringEvaluator { get; private set; } = null!;
+        public static IKeyState? KeyState { get; private set; }
+        public static IGamepadState? GamepadState { get; private set; }
 
         public static ISharedImmediateTexture? BannerTexture;
 
@@ -78,7 +80,9 @@ namespace HSUI
             ITextureProvider textureProvider,
             IAddonLifecycle addonLifecycle,
             IChatGui chat,
-            ISeStringEvaluator seStringEvaluator)
+            ISeStringEvaluator seStringEvaluator,
+            IGamepadState? gamepadState = null,
+            IKeyState? keyState = null)
         {
             BuddyList = buddyList;
             ClientState = clientState;
@@ -100,6 +104,8 @@ namespace HSUI
             AddonLifecycle = addonLifecycle;
             Chat = chat;
             SeStringEvaluator = seStringEvaluator;
+            KeyState = keyState;
+            GamepadState = gamepadState;
 
             if (pluginInterface.AssemblyLocation.DirectoryName != null)
             {
@@ -134,6 +140,7 @@ namespace HSUI
             PartyCooldownsManager.Initialize();
             PullTimerHelper.Initialize();
             ActionBarsManager.Initialize();
+            ControllerHotbarHelper.SetGamepadState(GamepadState);
             TextTagsHelper.Initialize();
             TooltipsHelper.Initialize();
             ActionChatLinkHelper.Initialize();

changelog.md

@@ -1,3 +1,33 @@
+# 1.0.8.23
+- **Main Menu**: New customizable main menu bar replacing the game's bar. Correct icons (Duty, Logs, Travel, Social) and context menus; Logs/Travel identified by submenu names. Background drawn only behind icons (no extra side padding). Crash fix when executing from context menu (RunOnFrameworkThread).
+- **Duty List & Scenario Guide**: Background transparent by default; optional skip draw when fully transparent.
+
+# 1.0.8.22
+- **Duty List & Scenario Guide**: Fix "Hide unless hovered" visibility option — override GetScreenBounds() so hover hit-test matches drawn panel.
+- **Tooltips**: Job gauge/resource costs (Soul Gauge, Beast Gauge, Lily, Kenki, etc.) now show as section with label color. Fix tooltip break when stats and description share first block.
+
+# 1.0.8.21
+- **Duty List & Scenario Guide**: Duty Information when inside a duty (dungeon/trial/raid) — shows duty name, elapsed timer, and objectives. Replaces queue info with in-duty info when BoundByDuty. Objective progress shown as "X out of Y step(s)" with checkmark when completed (replaces raw 0/1:0). Average wait time from queue status messages (static format preferred); multiple queued duties supported; redundant "Average Wait Time" label fixed.
+
+# 1.0.8.20
+- **Duty List & Scenario Guide**: New combined HUD element replacing the game's Duty List and Scenario Guide. Shows active quests and levequests with quest icons, plus Main Scenario and Job Quest hints. Configurable position, size, font, colors, and visibility.
+- **Hotbars**: Fixed cooldown overlays showing through game UI (e.g. dialogue box) when "Show HUD during dialogue and interaction" is enabled. Hotbar cooldown timers and numbers are now skipped for slots that overlap dialogue, select, or journal addons.
+
+# 1.0.8.19
+- **Hotbars**: Visibility settings moved from Visibility → Hotbars to each Hotbar 1–10 menu. The Visibility → Hotbars tab has been removed.
+
+# 1.0.8.18
+- **Visibility**: "Hide unless hovered" — per-element option in Visibility to hide any UI element unless the cursor is over it (requires HUD locked).
+
+# 1.0.8.17
+- **Controller Hotbars**: Add 8 cross bars (L2/R2 style) separate from normal hotbars 1-8. Controller bar slot data stored in config (not game StandardHotbars) so layouts can differ per mode. Drag-and-drop on controller bars: from game, shift+drag rearrange, release outside to clear. Independent keybinds with modifier+trigger combinations (e.g. L2+South). Optional sync bar mode with game client (Character Config Mouse/Gamepad toggle). Clone/copy actions: normal hotbars ↔ controller bars. Restore controller bar layout button.
+
+# 1.0.8.16
+- **HUD Options**: "Show HUD during dialogue and interaction" — when enabled, hotbars and the rest of HSUI stay visible when talking to NPCs or interacting with objects (default on). When disabled, only the castbar is shown during dialogue after a short delay.
+
+# 1.0.8.15
+- **Tooltips**: Game-style formatting with section labels, tail alignment, and config options. TooltipSegment and colored formatting (section labels green, status names yellow). Sections: Additional Effect, Duration, Maximum Charges, Blood Gauge Cost, Combo, role labels. Tail text left-aligned on own line; section values stay on same line as labels. Config: Use Game-style formatting, Section/Status/Secondary colors, Tooltip Max Width, Line Spacing, Font Scale, Icon Scale, Height Buffer slider.
+
 # 1.0.8.14
 - **Mouse GCD Indicator**: New HUD element (Other Elements → Mouse GCD Indicator) — circular GCD ring drawn around the cursor. Configurable radius, thickness, colors, queue indicator, and cursor center offset so the ring aligns with the cursor graphic.
 

pluginmaster.json

@@ -1 +1 @@
-[{"Author":"Knack117","Name":"HSUI","Punchline":"A modern HUD replacement built for customization.","Description":"HSUI provides a highly configurable HUD replacement for FFXIV, recreated from DelvUI using KamiToolKit, FFXIVClientStructs, and Dalamud. Features unit frames, castbars, job gauges, nameplates, party frames, status effects, enemy list, configurable hotbars with drag-and-drop, and profiles.","Changelog":"1.0.8.14: Mouse GCD Indicator (ring around cursor). 1.0.8.13: Item tooltips now show. 1.0.8.12: Item/HQ icons now draw on hotbar. 1.0.8.11: Hotbar tooltip crash fix (Lumina GetRow). 1.0.8.10: Hotbar crash fix when dragging inventory items; Release builds strip PDBs. 1.0.8.9: Gearset persists on slot (fix CommandId 0 treated as empty). 1.0.8.8: Gearset drag-drop fix; allow first gearset (index 0) on bar. 1.0.8.7: Fixed Gearset/Job Gear Set icon clearing when first equipment slot changes. 1.0.8.6: Crafting action tooltips now show full description instead of action name. 1.0.8.4: Alliance Frames 1 and 2 fix in raids; crafting action tooltips; Hide in duty no longer hides alliance frames. 1.0.8.3: Fix left-click staying broken after disable. 1.0.8.2: Charge icons stay lit until all charges spent.","InternalName":"HSUI","AssemblyVersion":"1.0.8.14","RepoUrl":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI","ApplicableVersion":"any","Tags":["UI","HUD","Unit Frames","Nameplates","Party Frames","Hotbars"],"CategoryTags":["UI"],"DalamudApiLevel":14,"IconUrl":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/raw/branch/main/Media/Images/icon.png","ImageUrls":[],"DownloadLinkInstall":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/releases/download/v1.0.8.14/latest.zip","IsHide":false,"IsTestingExclusive":false,"DownloadLinkTesting":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/releases/download/v1.0.8.14/latest.zip","DownloadLinkUpdate":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/releases/download/v1.0.8.14/latest.zip","LastUpdate":"1760486400"}]
+[{"Author":"Knack117","Name":"HSUI","Punchline":"A modern HUD replacement built for customization.","Description":"HSUI provides a highly configurable HUD replacement for FFXIV, recreated from DelvUI using KamiToolKit, FFXIVClientStructs, and Dalamud. Features unit frames, castbars, job gauges, nameplates, party frames, status effects, enemy list, configurable hotbars with drag-and-drop, and profiles.","Changelog":"1.0.8.23: Main Menu bar; Duty List & Scenario Guide transparent background. 1.0.8.22: Duty List hide-unless-hovered fix; tooltips job gauge costs. 1.0.8.21: Duty List in-duty info. 1.0.8.20: Fixed cooldown overlays showing through game UI (dialogue box) when Show HUD during dialogue enabled. 1.0.8.19: Hotbar visibility moved to per-hotbar menus; removed Visibility Hotbars tab. 1.0.8.18: Visibility \"Hide unless hovered\" option. 1.0.8.17: Controller hotbars (cross layout, separate storage, sync with game). 1.0.8.16: Show HUD during dialogue and interaction. 1.0.8.15: Tooltips game-style formatting. 1.0.8.14: Mouse GCD Indicator. 1.0.8.13: Item tooltips now show. 1.0.8.12: Item/HQ icons now draw on hotbar. 1.0.8.11: Hotbar tooltip crash fix. 1.0.8.10: Hotbar crash fix when dragging inventory items. 1.0.8.9: Gearset persists on slot. 1.0.8.8: Gearset drag-drop fix. 1.0.8.7: Fixed Gearset icon clearing. 1.0.8.6: Crafting action tooltips full description. 1.0.8.4: Alliance Frames 1 and 2 fix; Hide in duty no longer hides alliance frames. 1.0.8.3: Fix left-click staying broken after disable. 1.0.8.2: Charge icons stay lit until all charges spent.","InternalName":"HSUI","AssemblyVersion":"1.0.8.23","RepoUrl":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI","ApplicableVersion":"any","Tags":["UI","HUD","Unit Frames","Nameplates","Party Frames","Hotbars"],"CategoryTags":["UI"],"DalamudApiLevel":14,"IconUrl":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/raw/branch/main/Media/Images/icon.png","ImageUrls":[],"DownloadLinkInstall":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/releases/download/v1.0.8.23/latest.zip","IsHide":false,"IsTestingExclusive":false,"DownloadLinkTesting":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/releases/download/v1.0.8.23/latest.zip","DownloadLinkUpdate":"http://brassnet.ddns.net:33983/KnackAtNite/HSUI/releases/download/v1.0.8.23/latest.zip","LastUpdate":"1772500800"}]