Properly initialize GameInventoryItems (#2504)

Clear ImDrawListSplitter when disposing SeStringDrawState

.github/generate_changelog.py

@@ -8,7 +8,8 @@ import re
 import sys
 import json
 import argparse
-from typing import List, Tuple, Optional
+import os
+from typing import List, Tuple, Optional, Dict, Any
 
 
 def run_git_command(args: List[str]) -> str:
@@ -55,46 +56,132 @@ def get_submodule_commit(submodule_path: str, tag: str) -> Optional[str]:
         return None
 
 
-def get_commits_between_tags(tag1: str, tag2: str) -> List[Tuple[str, str]]:
+def get_repo_info() -> Tuple[str, str]:
-    """Get commits between two tags. Returns list of (message, author) tuples."""
+    """Get repository owner and name from git remote."""
+    try:
+        remote_url = run_git_command(["config", "--get", "remote.origin.url"])
+
+        # Handle both HTTPS and SSH URLs
+        # SSH: git@github.com:owner/repo.git
+        # HTTPS: https://github.com/owner/repo.git
+        match = re.search(r'github\.com[:/](.+?)/(.+?)(?:\.git)?$', remote_url)
+        if match:
+            owner = match.group(1)
+            repo = match.group(2)
+            return owner, repo
+        else:
+            print("Error: Could not parse GitHub repository from remote URL", file=sys.stderr)
+            sys.exit(1)
+    except:
+        print("Error: Could not get git remote URL", file=sys.stderr)
+        sys.exit(1)
+
+
+def get_commits_between_tags(tag1: str, tag2: str) -> List[str]:
+    """Get commit SHAs between two tags."""
     log_output = run_git_command([
         "log",
         f"{tag2}..{tag1}",
-        "--format=%s|%an|%h"
+        "--format=%H"
     ])
 
-    commits = []
+    commits = [sha.strip() for sha in log_output.split("\n") if sha.strip()]
-    for line in log_output.split("\n"):
-        if "|" in line:
-            message, author, sha = line.split("|", 2)
-            commits.append((message.strip(), author.strip(), sha.strip()))
-    
     return commits
 
 
-def filter_commits(commits: List[Tuple[str, str]], ignore_patterns: List[str]) -> List[Tuple[str, str]]:
+def get_pr_for_commit(commit_sha: str, owner: str, repo: str, token: str) -> Optional[Dict[str, Any]]:
-    """Filter out commits matching any of the ignore patterns."""
+    """Get PR information for a commit using GitHub API."""
+    try:
+        import requests
+    except ImportError:
+        print("Error: requests library is required. Install it with: pip install requests", file=sys.stderr)
+        sys.exit(1)
+
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+    }
+
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    url = f"https://api.github.com/repos/{owner}/{repo}/commits/{commit_sha}/pulls"
+
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        prs = response.json()
+
+        if prs and len(prs) > 0:
+            # Return the first PR (most relevant one)
+            pr = prs[0]
+            return {
+                "number": pr["number"],
+                "title": pr["title"],
+                "author": pr["user"]["login"],
+                "url": pr["html_url"]
+            }
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 404:
+            # Commit might not be associated with a PR
+            return None
+        elif e.response.status_code == 403:
+            print("Warning: GitHub API rate limit exceeded. Consider providing a token.", file=sys.stderr)
+            return None
+        else:
+            print(f"Warning: Failed to fetch PR for commit {commit_sha[:7]}: {e}", file=sys.stderr)
+            return None
+    except Exception as e:
+        print(f"Warning: Error fetching PR for commit {commit_sha[:7]}: {e}", file=sys.stderr)
+        return None
+
+    return None
+
+
+def get_prs_between_tags(tag1: str, tag2: str, owner: str, repo: str, token: str) -> List[Dict[str, Any]]:
+    """Get PRs between two tags using GitHub API."""
+    commits = get_commits_between_tags(tag1, tag2)
+    print(f"Found {len(commits)} commits, fetching PR information...")
+
+    prs = []
+    seen_pr_numbers = set()
+
+    for i, commit_sha in enumerate(commits, 1):
+        if i % 10 == 0:
+            print(f"Progress: {i}/{len(commits)} commits processed...")
+
+        pr_info = get_pr_for_commit(commit_sha, owner, repo, token)
+        if pr_info and pr_info["number"] not in seen_pr_numbers:
+            seen_pr_numbers.add(pr_info["number"])
+            prs.append(pr_info)
+
+    return prs
+
+
+def filter_prs(prs: List[Dict[str, Any]], ignore_patterns: List[str]) -> List[Dict[str, Any]]:
+    """Filter out PRs matching any of the ignore patterns."""
     compiled_patterns = [re.compile(pattern) for pattern in ignore_patterns]
 
     filtered = []
-    for message, author, sha in commits:
+    for pr in prs:
-        if not any(pattern.search(message) for pattern in compiled_patterns):
+        if not any(pattern.search(pr["title"]) for pattern in compiled_patterns):
-            filtered.append((message, author, sha))
+            filtered.append(pr)
 
     return filtered
 
 
-def generate_changelog(version: str, prev_version: str, commits: List[Tuple[str, str]], 
+def generate_changelog(version: str, prev_version: str, prs: List[Dict[str, Any]],
-                      cs_commit_new: Optional[str], cs_commit_old: Optional[str]) -> str:
+                      cs_commit_new: Optional[str], cs_commit_old: Optional[str],
+                      owner: str, repo: str) -> str:
     """Generate markdown changelog."""
     # Calculate statistics
-    commit_count = len(commits)
+    pr_count = len(prs)
-    unique_authors = len(set(author for _, author, _ in commits))
+    unique_authors = len(set(pr["author"] for pr in prs))
 
     changelog = f"# Dalamud Release v{version}\n\n"
     changelog += f"We just released Dalamud v{version}, which should be available to users within a few minutes. "
-    changelog += f"This release includes **{commit_count} commit{'s' if commit_count != 1 else ''} from {unique_authors} contributor{'s' if unique_authors != 1 else ''}**.\n"
+    changelog += f"This release includes **{pr_count} PR{'s' if pr_count != 1 else ''} from {unique_authors} contributor{'s' if unique_authors != 1 else ''}**.\n"
-    changelog += f"[Click here](<https://github.com/goatcorp/Dalamud/compare/{prev_version}...{version}>) to see all Dalamud changes.\n\n"
+    changelog += f"[Click here](<https://github.com/{owner}/{repo}/compare/{prev_version}...{version}>) to see all Dalamud changes.\n\n"
 
     if cs_commit_new and cs_commit_old and cs_commit_new != cs_commit_old:
         changelog += f"It ships with an updated **FFXIVClientStructs [`{cs_commit_new[:7]}`](<https://github.com/aers/FFXIVClientStructs/commit/{cs_commit_new}>)**.\n"
@@ -104,8 +191,8 @@ def generate_changelog(version: str, prev_version: str, commits: List[Tuple[str,
 
     changelog += "## Dalamud Changes\n\n"
 
-    for message, author, sha in commits:
+    for pr in prs:
-        changelog += f"* {message} (by **{author}** as [`{sha}`](<https://github.com/goatcorp/Dalamud/commit/{sha}>))\n"
+        changelog += f"* {pr['title']} ([#**{pr['number']}**](<{pr['url']}>) by **{pr['author']}**)\n"
 
     return changelog
 
@@ -158,11 +245,16 @@ def main():
         required=True,
         help="Discord webhook URL"
     )
+    parser.add_argument(
+        "--github-token",
+        default=os.environ.get("GITHUB_TOKEN"),
+        help="GitHub API token (or set GITHUB_TOKEN env var). Increases rate limit."
+    )
     parser.add_argument(
         "--ignore",
         action="append",
         default=[],
-        help="Regex patterns to ignore commits (can be specified multiple times)"
+        help="Regex patterns to ignore PRs (can be specified multiple times)"
     )
     parser.add_argument(
         "--submodule-path",
@@ -172,6 +264,10 @@ def main():
 
     args = parser.parse_args()
 
+    # Get repository info
+    owner, repo = get_repo_info()
+    print(f"Repository: {owner}/{repo}")
+
     # Get the last two tags
     latest_tag, previous_tag = get_last_two_tags()
     print(f"Generating changelog between {previous_tag} and {latest_tag}")
@@ -185,17 +281,18 @@ def main():
     if cs_commit_old:
         print(f"FFXIVClientStructs commit (old): {cs_commit_old[:7]}")
 
-    # Get commits between tags
+    # Get PRs between tags
-    commits = get_commits_between_tags(latest_tag, previous_tag)
+    prs = get_prs_between_tags(latest_tag, previous_tag, owner, repo, args.github_token)
-    print(f"Found {len(commits)} commits")
+    prs.reverse()
+    print(f"Found {len(prs)} PRs")
 
-    # Filter commits
+    # Filter PRs
-    filtered_commits = filter_commits(commits, args.ignore)
+    filtered_prs = filter_prs(prs, args.ignore)
-    print(f"After filtering: {len(filtered_commits)} commits")
+    print(f"After filtering: {len(filtered_prs)} PRs")
 
     # Generate changelog
-    changelog = generate_changelog(latest_tag, previous_tag, filtered_commits, 
+    changelog = generate_changelog(latest_tag, previous_tag, filtered_prs,
-                                   cs_commit_new, cs_commit_old)
+                                   cs_commit_new, cs_commit_old, owner, repo)
 
     print("\n" + "="*50)
     print("Generated Changelog:")

.github/workflows/generate-changelog.yml

@@ -6,6 +6,8 @@ on:
     tags:
       - '*'
 
+permissions: read-all
+
 jobs:
   generate-changelog:
     runs-on: ubuntu-latest
@@ -28,14 +30,14 @@ jobs:
           pip install requests
 
       - name: Generate and post changelog
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GIT_TERMINAL_PROMPT: 0
         run: |
           python .github/generate_changelog.py \
             --webhook-url "${{ secrets.DISCORD_CHANGELOG_WEBHOOK_URL }}" \
-            --ignore "^Merge" \
+            --ignore "Update ClientStructs" \
-            --ignore "^build:" \
+            --ignore "^build:"
-            --ignore "^docs:"
-        env:
-          GIT_TERMINAL_PROMPT: 0
 
       - name: Upload changelog as artifact
         if: always()

.github/workflows/main.yml

@@ -1,9 +1,10 @@
 name: Build Dalamud
 on: [push, pull_request, workflow_dispatch]
 
+# Globally blocking because of git pushes in deploy step
 concurrency:
-  group: build_dalamud_${{ github.ref_name }}
+  group: build_dalamud_${{ github.repository_owner }}
-  cancel-in-progress: true
+  cancel-in-progress: false
 
 jobs:
   build:

Dalamud.Boot/crashhandler_shared.h

@@ -6,6 +6,8 @@
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
 
+#define CUSTOM_EXCEPTION_EXTERNAL_EVENT 0x12345679
+
 struct exception_info
 {
     LPEXCEPTION_POINTERS pExceptionPointers;

Dalamud.Boot/dllmain.cpp

@@ -331,6 +331,51 @@ HRESULT WINAPI InitializeImpl(LPVOID lpParam, HANDLE hMainThreadContinue) {
         logging::I("VEH was disabled manually");
     }
 
+    // ============================== CLR Reporting =================================== //
+
+    // This is pretty horrible - CLR just doesn't provide a way for us to handle these events, and the API for it
+    // was pushed back to .NET 11, so we have to hook ReportEventW and catch them ourselves for now.
+    // Ideally all of this will go away once they get to it.
+    static std::shared_ptr<hooks::global_import_hook<decltype(ReportEventW)>> s_report_event_hook;
+    s_report_event_hook = std::make_shared<hooks::global_import_hook<decltype(ReportEventW)>>(
+        "advapi32.dll!ReportEventW (global import, hook_clr_report_event)", L"advapi32.dll", "ReportEventW");
+    s_report_event_hook->set_detour([hook = s_report_event_hook.get()](
+        HANDLE hEventLog,
+        WORD wType,
+        WORD wCategory,
+        DWORD dwEventID,
+        PSID lpUserSid,
+        WORD wNumStrings,
+        DWORD dwDataSize,
+        LPCWSTR* lpStrings,
+        LPVOID lpRawData)-> BOOL {
+
+        // Check for CLR Error Event IDs
+        // https://github.com/dotnet/runtime/blob/v10.0.0/src/coreclr/vm/eventreporter.cpp#L370
+        if (dwEventID != 1026 && // ERT_UnhandledException: The process was terminated due to an unhandled exception
+            dwEventID != 1025 && // ERT_ManagedFailFast: The application requested process termination through System.Environment.FailFast
+            dwEventID != 1023 && // ERT_UnmanagedFailFast: The process was terminated due to an internal error in the .NET Runtime
+            dwEventID != 1027 && // ERT_StackOverflow: The process was terminated due to a stack overflow
+            dwEventID != 1028)   // ERT_CodeContractFailed: The application encountered a bug.  A managed code contract (precondition, postcondition, object invariant, or assert) failed
+        {
+            return hook->call_original(hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
+        }
+
+        if (wNumStrings == 0 || lpStrings == nullptr) {
+            logging::W("ReportEventW called with no strings.");
+            return hook->call_original(hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
+        }
+
+        // In most cases, DalamudCrashHandler will kill us now, so call original here to make sure we still write to the event log.
+        const BOOL original_ret = hook->call_original(hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData);
+
+        const std::wstring error_details(lpStrings[0]);
+        veh::raise_external_event(error_details);
+
+        return original_ret;
+    });
+    logging::I("ReportEventW hook installed.");
+
     // ============================== Dalamud ==================================== //
 
     if (static_cast<int>(g_startInfo.BootWaitMessageBox) & static_cast<int>(DalamudStartInfo::WaitMessageboxFlags::BeforeDalamudEntrypoint))

Dalamud.Boot/veh.cpp

@@ -31,6 +31,8 @@ HANDLE g_crashhandler_process = nullptr;
 HANDLE g_crashhandler_event = nullptr;
 HANDLE g_crashhandler_pipe_write = nullptr;
 
+wchar_t g_external_event_info[16384] = L"";
+
 std::recursive_mutex g_exception_handler_mutex;
 
 std::chrono::time_point<std::chrono::system_clock> g_time_start;
@@ -190,7 +192,11 @@ LONG exception_handler(EXCEPTION_POINTERS* ex)
     DuplicateHandle(GetCurrentProcess(), g_crashhandler_event, g_crashhandler_process, &exinfo.hEventHandle, 0, TRUE, DUPLICATE_SAME_ACCESS);
 
     std::wstring stackTrace;
-    if (!g_clr)
+    if (ex->ExceptionRecord->ExceptionCode == CUSTOM_EXCEPTION_EXTERNAL_EVENT)
+    {
+        stackTrace = std::wstring(g_external_event_info);
+    }
+    else if (!g_clr)
     {
         stackTrace = L"(no CLR stack trace available)";
     }
@@ -251,6 +257,12 @@ LONG WINAPI structured_exception_handler(EXCEPTION_POINTERS* ex)
 
 LONG WINAPI vectored_exception_handler(EXCEPTION_POINTERS* ex)
 {
+    // special case for CLR exceptions, always trigger crash handler
+    if (ex->ExceptionRecord->ExceptionCode == CUSTOM_EXCEPTION_EXTERNAL_EVENT)
+    {
+        return exception_handler(ex);
+    }
+
     if (ex->ExceptionRecord->ExceptionCode == 0x12345678)
     {
         // pass
@@ -434,3 +446,16 @@ bool veh::remove_handler()
     }
     return false;
 }
+
+void veh::raise_external_event(const std::wstring& info)
+{
+    const auto info_size = std::min(info.size(), std::size(g_external_event_info) - 1);
+    wcsncpy_s(g_external_event_info, info.c_str(), info_size);
+    RaiseException(CUSTOM_EXCEPTION_EXTERNAL_EVENT, 0, 0, nullptr);
+}
+
+extern "C" __declspec(dllexport) void BootVehRaiseExternalEventW(LPCWSTR info)
+{
+    const std::wstring info_wstr(info);
+    veh::raise_external_event(info_wstr);
+}

Dalamud.Boot/veh.h

@@ -4,4 +4,5 @@ namespace veh
 {
     bool add_handler(bool doFullDump, const std::string& workingDirectory);
     bool remove_handler();
+    void raise_external_event(const std::wstring& info);
 }

Dalamud/Dalamud.csproj

@@ -6,7 +6,7 @@
 
     <PropertyGroup Label="Feature">
         <Description>XIV Launcher addon framework</Description>
-        <DalamudVersion>13.0.0.12</DalamudVersion>
+        <DalamudVersion>13.0.0.16</DalamudVersion>
         <AssemblyVersion>$(DalamudVersion)</AssemblyVersion>
         <Version>$(DalamudVersion)</Version>
         <FileVersion>$(DalamudVersion)</FileVersion>

Dalamud/Data/DataManager.cs

@@ -82,8 +82,13 @@ internal sealed class DataManager : IInternalDisposableService, IDataManager
                         var tsInfo =
                             JsonConvert.DeserializeObject<LauncherTroubleshootingInfo>(
                                 dalamud.StartInfo.TroubleshootingPackData);
-                        this.HasModifiedGameDataFiles =
+
-                            tsInfo?.IndexIntegrity is LauncherTroubleshootingInfo.IndexIntegrityResult.Failed or LauncherTroubleshootingInfo.IndexIntegrityResult.Exception;
+                        // Don't fail for IndexIntegrityResult.Exception, since the check during launch has a very small timeout
+                        // this.HasModifiedGameDataFiles =
+                        //     tsInfo?.IndexIntegrity is LauncherTroubleshootingInfo.IndexIntegrityResult.Failed;
+
+                        // TODO: Put above back when check in XL is fixed
+                        this.HasModifiedGameDataFiles = false;
 
                         if (this.HasModifiedGameDataFiles)
                             Log.Verbose("Game data integrity check failed!\n{TsData}", dalamud.StartInfo.TroubleshootingPackData);

Dalamud/EntryPoint.cs

@@ -292,7 +292,6 @@ public sealed class EntryPoint
                 }
 
                 var pluginInfo = string.Empty;
-                var supportText = ", please visit us on Discord for more help";
                 try
                 {
                     var pm = Service<PluginManager>.GetNullable();
@@ -300,9 +299,6 @@ public sealed class EntryPoint
                     if (plugin != null)
                     {
                         pluginInfo = $"Plugin that caused this:\n{plugin.Name}\n\nClick \"Yes\" and remove it.\n\n";
-
-                        if (plugin.IsThirdParty)
-                            supportText = string.Empty;
                     }
                 }
                 catch
@@ -310,31 +306,18 @@ public sealed class EntryPoint
                     // ignored
                 }
 
-                const MESSAGEBOX_STYLE flags = MESSAGEBOX_STYLE.MB_YESNO | MESSAGEBOX_STYLE.MB_ICONERROR | MESSAGEBOX_STYLE.MB_SYSTEMMODAL;
-                var result = Windows.Win32.PInvoke.MessageBox(
-                    new HWND(Process.GetCurrentProcess().MainWindowHandle),
-                    $"An internal error in a Dalamud plugin occurred.\nThe game must close.\n\n{ex.GetType().Name}\n{info}\n\n{pluginInfo}More information has been recorded separately{supportText}.\n\nDo you want to disable all plugins the next time you start the game?",
-                    "Dalamud",
-                    flags);
-
-                if (result == MESSAGEBOX_RESULT.IDYES)
-                {
-                    Log.Information("User chose to disable plugins on next launch...");
-                    var config = Service<DalamudConfiguration>.Get();
-                    config.PluginSafeMode = true;
-                    config.ForceSave();
-                }
-
                 Log.CloseAndFlush();
-                Environment.Exit(-1);
+
+                ErrorHandling.CrashWithContext($"{ex}\n\n{info}\n\n{pluginInfo}");
                 break;
             default:
                 Log.Fatal("Unhandled SEH object on AppDomain: {Object}", args.ExceptionObject);
 
                 Log.CloseAndFlush();
-                Environment.Exit(-1);
                 break;
         }
+
+        Environment.Exit(-1);
     }
 
     private static void OnUnhandledExceptionStallDebug(object sender, UnhandledExceptionEventArgs args)

Dalamud/Game/Addon/Events/AddonEventManager.cs

@@ -9,7 +9,6 @@ using Dalamud.Logging.Internal;
 using Dalamud.Plugin.Internal.Types;
 using Dalamud.Plugin.Services;
 
-using FFXIVClientStructs.FFXIV.Client.UI;
 using FFXIVClientStructs.FFXIV.Component.GUI;
 
 namespace Dalamud.Game.Addon.Events;
@@ -32,25 +31,21 @@ internal unsafe class AddonEventManager : IInternalDisposableService
 
     private readonly AddonLifecycleEventListener finalizeEventListener;
 
-    private readonly AddonEventManagerAddressResolver address;
+    private readonly Hook<AtkUnitManager.Delegates.UpdateCursor> onUpdateCursor;
-    private readonly Hook<UpdateCursorDelegate> onUpdateCursor;
 
     private readonly ConcurrentDictionary<Guid, PluginEventController> pluginEventControllers;
 
-    private AddonCursorType? cursorOverride;
+    private AtkCursor.CursorType? cursorOverride;
 
     [ServiceManager.ServiceConstructor]
-    private AddonEventManager(TargetSigScanner sigScanner)
+    private AddonEventManager()
     {
-        this.address = new AddonEventManagerAddressResolver();
-        this.address.Setup(sigScanner);
-
         this.pluginEventControllers = new ConcurrentDictionary<Guid, PluginEventController>();
         this.pluginEventControllers.TryAdd(DalamudInternalKey, new PluginEventController());
 
         this.cursorOverride = null;
 
-        this.onUpdateCursor = Hook<UpdateCursorDelegate>.FromAddress(this.address.UpdateCursor, this.UpdateCursorDetour);
+        this.onUpdateCursor = Hook<AtkUnitManager.Delegates.UpdateCursor>.FromAddress(AtkUnitManager.Addresses.UpdateCursor.Value, this.UpdateCursorDetour);
 
         this.finalizeEventListener = new AddonLifecycleEventListener(AddonEvent.PreFinalize, string.Empty, this.OnAddonFinalize);
         this.addonLifecycle.RegisterListener(this.finalizeEventListener);
@@ -58,8 +53,6 @@ internal unsafe class AddonEventManager : IInternalDisposableService
         this.onUpdateCursor.Enable();
     }
 
-    private delegate nint UpdateCursorDelegate(RaptureAtkModule* module);
-
     /// <inheritdoc/>
     void IInternalDisposableService.DisposeService()
     {
@@ -117,7 +110,7 @@ internal unsafe class AddonEventManager : IInternalDisposableService
     /// Force the game cursor to be the specified cursor.
     /// </summary>
     /// <param name="cursor">Which cursor to use.</param>
-    internal void SetCursor(AddonCursorType cursor) => this.cursorOverride = cursor;
+    internal void SetCursor(AddonCursorType cursor) => this.cursorOverride = (AtkCursor.CursorType)cursor;
 
     /// <summary>
     /// Un-forces the game cursor.
@@ -168,7 +161,7 @@ internal unsafe class AddonEventManager : IInternalDisposableService
         }
     }
 
-    private nint UpdateCursorDetour(RaptureAtkModule* module)
+    private void UpdateCursorDetour(AtkUnitManager* thisPtr)
     {
         try
         {
@@ -176,13 +169,14 @@ internal unsafe class AddonEventManager : IInternalDisposableService
 
             if (this.cursorOverride is not null && atkStage is not null)
             {
-                var cursor = (AddonCursorType)atkStage->AtkCursor.Type;
+                ref var atkCursor = ref atkStage->AtkCursor;
-                if (cursor != this.cursorOverride)
+
+                if (atkCursor.Type != this.cursorOverride)
                 {
-                    AtkStage.Instance()->AtkCursor.SetCursorType((AtkCursor.CursorType)this.cursorOverride, 1);
+                    atkCursor.SetCursorType((AtkCursor.CursorType)this.cursorOverride, 1);
                 }
 
-                return nint.Zero;
+                return;
             }
         }
         catch (Exception e)
@@ -190,7 +184,7 @@ internal unsafe class AddonEventManager : IInternalDisposableService
             Log.Error(e, "Exception in UpdateCursorDetour.");
         }
 
-        return this.onUpdateCursor!.Original(module);
+        this.onUpdateCursor!.Original(thisPtr);
     }
 }
 

Dalamud/Game/Addon/Events/AddonEventManagerAddressResolver.cs

@@ -1,21 +0,0 @@
-namespace Dalamud.Game.Addon.Events;
-
-/// <summary>
-/// AddonEventManager memory address resolver.
-/// </summary>
-internal class AddonEventManagerAddressResolver : BaseAddressResolver
-{
-    /// <summary>
-    /// Gets the address of the AtkModule UpdateCursor method.
-    /// </summary>
-    public nint UpdateCursor { get; private set; }
-
-    /// <summary>
-    /// Scan for and setup any configured address pointers.
-    /// </summary>
-    /// <param name="scanner">The signature scanner to facilitate setup.</param>
-    protected override void Setup64Bit(ISigScanner scanner)
-    {
-        this.UpdateCursor = scanner.ScanText("48 89 74 24 ?? 48 89 7C 24 ?? 41 56 48 83 EC 20 4C 8B F1 E8 ?? ?? ?? ?? 49 8B CE"); // unnamed in CS
-    }
-}

Dalamud/Game/Inventory/GameInventory.cs

@@ -305,7 +305,8 @@ internal class GameInventory : IInternalDisposableService
     private GameInventoryItem[] CreateItemsArray(int length)
     {
         var items = new GameInventoryItem[length];
-        items.Initialize();
+        foreach (ref var item in items.AsSpan())
+            item = new();
         return items;
     }
 

Dalamud/Game/Player/PlayerState.cs

@@ -77,7 +77,7 @@ internal unsafe class PlayerState : IServiceType, IPlayerState
     public RowRef<ClassJob> ClassJob => this.IsLoaded ? LuminaUtils.CreateRef<ClassJob>(CSPlayerState.Instance()->CurrentClassJobId) : default;
 
     /// <inheritdoc/>
-    public short Level => this.IsLoaded ? CSPlayerState.Instance()->CurrentLevel : default;
+    public short Level => this.IsLoaded && this.ClassJob.IsValid ? this.GetClassJobLevel(this.ClassJob.Value) : this.EffectiveLevel;
 
     /// <inheritdoc/>
     public bool IsLevelSynced => this.IsLoaded && CSPlayerState.Instance()->IsLevelSynced;

Dalamud/Game/Text/Noun/NounParams.cs

@@ -60,8 +60,8 @@ internal record struct NounParams()
     /// </summary>
     public readonly int ColumnOffset => this.SheetName switch
     {
-        // See "E8 ?? ?? ?? ?? 44 8B 6B 08"
+        // See "E8 ?? ?? ?? ?? 44 8B 66 ?? 8B E8"
-        nameof(LSheets.BeastTribe) => 10,
+        nameof(LSheets.BeastTribe) => 11,
         nameof(LSheets.DeepDungeonItem) => 1,
         nameof(LSheets.DeepDungeonEquipment) => 1,
         nameof(LSheets.DeepDungeonMagicStone) => 1,

Dalamud/Interface/ImGuiBackend/InputHandler/Win32InputHandler.StaticLookupFunctions.cs

@@ -299,11 +299,12 @@ internal sealed partial class Win32InputHandler
 
     private static void ViewportFlagsToWin32Styles(ImGuiViewportFlags flags, out int style, out int exStyle)
     {
-        style = (int)(flags.HasFlag(ImGuiViewportFlags.NoDecoration) ? WS.WS_POPUP : WS.WS_OVERLAPPEDWINDOW);
+        style = (flags & ImGuiViewportFlags.NoDecoration) != 0 ? unchecked((int)WS.WS_POPUP) : WS.WS_OVERLAPPEDWINDOW;
-        exStyle =
+        exStyle = (flags & ImGuiViewportFlags.NoTaskBarIcon) != 0 ? WS.WS_EX_TOOLWINDOW : WS.WS_EX_APPWINDOW;
-            (int)(flags.HasFlag(ImGuiViewportFlags.NoTaskBarIcon) ? WS.WS_EX_TOOLWINDOW : (uint)WS.WS_EX_APPWINDOW);
         exStyle |= WS.WS_EX_NOREDIRECTIONBITMAP;
-        if (flags.HasFlag(ImGuiViewportFlags.TopMost))
+        if ((flags & ImGuiViewportFlags.TopMost) != 0)
             exStyle |= WS.WS_EX_TOPMOST;
+        if ((flags & ImGuiViewportFlags.NoInputs) != 0)
+            exStyle |= WS.WS_EX_TRANSPARENT | WS.WS_EX_LAYERED;
     }
 }

Dalamud/Interface/ImGuiBackend/InputHandler/Win32InputHandler.cs

@@ -7,7 +7,9 @@ using System.Runtime.InteropServices;
 using System.Text;
 
 using Dalamud.Bindings.ImGui;
+using Dalamud.Console;
 using Dalamud.Memory;
+using Dalamud.Utility;
 
 using Serilog;
 
@@ -34,11 +36,14 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
     private readonly HCURSOR[] cursors;
 
     private readonly WndProcDelegate wndProcDelegate;
-    private readonly bool[] imguiMouseIsDown;
     private readonly nint platformNamePtr;
 
+    private readonly IConsoleVariable<bool> cvLogMouseEvents;
+
     private ViewportHandler viewportHandler;
 
+    private int mouseButtonsDown;
+    private bool mouseTracked;
     private long lastTime;
 
     private nint iniPathPtr;
@@ -64,7 +69,8 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
         io.BackendFlags |= ImGuiBackendFlags.HasMouseCursors |
                            ImGuiBackendFlags.HasSetMousePos |
                            ImGuiBackendFlags.RendererHasViewports |
-                           ImGuiBackendFlags.PlatformHasViewports;
+                           ImGuiBackendFlags.PlatformHasViewports |
+                           ImGuiBackendFlags.HasMouseHoveredViewport;
 
         this.platformNamePtr = Marshal.StringToHGlobalAnsi("imgui_impl_win32_c#");
         io.Handle->BackendPlatformName = (byte*)this.platformNamePtr;
@@ -74,8 +80,6 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
         if (io.ConfigFlags.HasFlag(ImGuiConfigFlags.ViewportsEnable))
             this.viewportHandler = new(this);
 
-        this.imguiMouseIsDown = new bool[5];
-
         this.cursors = new HCURSOR[9];
         this.cursors[(int)ImGuiMouseCursor.Arrow] = LoadCursorW(default, IDC.IDC_ARROW);
         this.cursors[(int)ImGuiMouseCursor.TextInput] = LoadCursorW(default, IDC.IDC_IBEAM);
@@ -86,6 +90,11 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
         this.cursors[(int)ImGuiMouseCursor.ResizeNwse] = LoadCursorW(default, IDC.IDC_SIZENWSE);
         this.cursors[(int)ImGuiMouseCursor.Hand] = LoadCursorW(default, IDC.IDC_HAND);
         this.cursors[(int)ImGuiMouseCursor.NotAllowed] = LoadCursorW(default, IDC.IDC_NO);
+
+        this.cvLogMouseEvents = Service<ConsoleManager>.Get().AddVariable(
+            "imgui.log_mouse_events",
+            "Log mouse events to console for debugging",
+            false);
     }
 
     /// <summary>
@@ -95,8 +104,6 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
 
     private delegate LRESULT WndProcDelegate(HWND hWnd, uint uMsg, WPARAM wparam, LPARAM lparam);
 
-    private delegate BOOL MonitorEnumProcDelegate(HMONITOR monitor, HDC hdc, RECT* rect, LPARAM lparam);
-
     /// <inheritdoc/>
     public bool UpdateCursor { get; set; } = true;
 
@@ -155,6 +162,7 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
     public void NewFrame(int targetWidth, int targetHeight)
     {
         var io = ImGui.GetIO();
+        var focusedWindow = GetForegroundWindow();
 
         io.DisplaySize.X = targetWidth;
         io.DisplaySize.Y = targetHeight;
@@ -168,9 +176,9 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
 
         this.viewportHandler.UpdateMonitors();
 
-        this.UpdateMousePos();
+        this.UpdateMouseData(focusedWindow);
 
-        this.ProcessKeyEventsWorkarounds();
+        this.ProcessKeyEventsWorkarounds(focusedWindow);
 
         // TODO: need to figure out some way to unify all this
         // The bottom case works(?) if the caller hooks SetCursor, but otherwise causes fps issues
@@ -224,6 +232,40 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
 
         switch (msg)
         {
+            case WM.WM_MOUSEMOVE:
+            {
+                if (!this.mouseTracked)
+                {
+                    var tme = new TRACKMOUSEEVENT
+                    {
+                        cbSize = (uint)sizeof(TRACKMOUSEEVENT),
+                        dwFlags = TME.TME_LEAVE,
+                        hwndTrack = hWndCurrent,
+                    };
+                    this.mouseTracked = TrackMouseEvent(&tme);
+                }
+
+                var mousePos = new POINT(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+                if ((io.ConfigFlags & ImGuiConfigFlags.ViewportsEnable) != 0)
+                    ClientToScreen(hWndCurrent, &mousePos);
+                io.AddMousePosEvent(mousePos.x, mousePos.y);
+                break;
+            }
+
+            case WM.WM_MOUSELEAVE:
+            {
+                this.mouseTracked = false;
+                var mouseScreenPos = new POINT(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+                ClientToScreen(hWndCurrent, &mouseScreenPos);
+                if (this.ViewportFromPoint(mouseScreenPos).IsNull)
+                {
+                    var fltMax = ImGuiNative.GETFLTMAX();
+                    io.AddMousePosEvent(-fltMax, -fltMax);
+                }
+
+                break;
+            }
+
             case WM.WM_LBUTTONDOWN:
             case WM.WM_LBUTTONDBLCLK:
             case WM.WM_RBUTTONDOWN:
@@ -233,14 +275,25 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
             case WM.WM_XBUTTONDOWN:
             case WM.WM_XBUTTONDBLCLK:
             {
+                if (this.cvLogMouseEvents.Value)
+                {
+                    Log.Verbose(
+                        "Handle MouseDown {Btn} WantCaptureMouse: {Want} mouseButtonsDown: {Down}",
+                        GetButton(msg, wParam),
+                        io.WantCaptureMouse,
+                        this.mouseButtonsDown);
+                }
+
                 var button = GetButton(msg, wParam);
                 if (io.WantCaptureMouse)
                 {
-                    if (!ImGui.IsAnyMouseDown() && GetCapture() == nint.Zero)
+                    if (this.mouseButtonsDown == 0 && GetCapture() == nint.Zero)
+                    {
                         SetCapture(hWndCurrent);
+                    }
 
-                    io.MouseDown[button] = true;
+                    this.mouseButtonsDown |= 1 << button;
-                    this.imguiMouseIsDown[button] = true;
+                    io.AddMouseButtonEvent(button, true);
                     return default(LRESULT);
                 }
 
@@ -255,14 +308,29 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
             case WM.WM_MBUTTONUP:
             case WM.WM_XBUTTONUP:
             {
-                var button = GetButton(msg, wParam);
+                if (this.cvLogMouseEvents.Value)
-                if (io.WantCaptureMouse && this.imguiMouseIsDown[button])
                 {
-                    if (!ImGui.IsAnyMouseDown() && GetCapture() == hWndCurrent)
+                    Log.Verbose(
-                        ReleaseCapture();
+                        "Handle MouseUp   {Btn} WantCaptureMouse: {Want} mouseButtonsDown: {Down}",
+                        GetButton(msg, wParam),
+                        io.WantCaptureMouse,
+                        this.mouseButtonsDown);
+                }
 
-                    io.MouseDown[button] = false;
+                var button = GetButton(msg, wParam);
-                    this.imguiMouseIsDown[button] = false;
+
+                // Need to check if we captured the button event away from the game here, otherwise the game might get
+                // a down event but no up event, causing the cursor to get stuck.
+                // Can happen if WantCaptureMouse becomes true in between down and up
+                if (io.WantCaptureMouse && (this.mouseButtonsDown & (1 << button)) != 0)
+                {
+                    this.mouseButtonsDown &= ~(1 << button);
+                    if (this.mouseButtonsDown == 0 && GetCapture() == hWndCurrent)
+                    {
+                        ReleaseCapture();
+                    }
+
+                    io.AddMouseButtonEvent(button, false);
                     return default(LRESULT);
                 }
 
@@ -272,7 +340,7 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
             case WM.WM_MOUSEWHEEL:
                 if (io.WantCaptureMouse)
                 {
-                    io.MouseWheel += GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA;
+                    io.AddMouseWheelEvent(0, GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA);
                     return default(LRESULT);
                 }
 
@@ -280,7 +348,7 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
             case WM.WM_MOUSEHWHEEL:
                 if (io.WantCaptureMouse)
                 {
-                    io.MouseWheelH += GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA;
+                    io.AddMouseWheelEvent(GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA, 0);
                     return default(LRESULT);
                 }
 
@@ -374,66 +442,89 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
                 this.viewportHandler.UpdateMonitors();
                 break;
 
-            case WM.WM_KILLFOCUS when hWndCurrent == this.hWnd:
+            case WM.WM_SETFOCUS when hWndCurrent == this.hWnd:
-                if (!ImGui.IsAnyMouseDown() && GetCapture() == hWndCurrent)
+                io.AddFocusEvent(true);
-                    ReleaseCapture();
+                break;
 
-                ImGui.GetIO().WantCaptureMouse = false;
+            case WM.WM_KILLFOCUS when hWndCurrent == this.hWnd:
-                ImGui.ClearWindowFocus();
+                io.AddFocusEvent(false);
+                // if (!ImGui.IsAnyMouseDown() && GetCapture() == hWndCurrent)
+                //     ReleaseCapture();
+                //
+                // ImGui.GetIO().WantCaptureMouse = false;
+                // ImGui.ClearWindowFocus();
                 break;
         }
 
         return null;
     }
 
-    private void UpdateMousePos()
+    private void UpdateMouseData(HWND focusedWindow)
     {
         var io = ImGui.GetIO();
-        var pt = default(POINT);
 
-        // Depending on if Viewports are enabled, we have to change how we process
+        var mouseScreenPos = default(POINT);
-        // the cursor position. If viewports are enabled, we pass the absolute cursor
+        var hasMouseScreenPos = GetCursorPos(&mouseScreenPos) != 0;
-        // position to ImGui. Otherwise, we use the old method of passing client-local
+
-        // mouse position to ImGui.
+        var isAppFocused =
-        if (io.ConfigFlags.HasFlag(ImGuiConfigFlags.ViewportsEnable))
+            focusedWindow != default
+            && (focusedWindow == this.hWnd
+                || IsChild(focusedWindow, this.hWnd)
+                || !ImGui.FindViewportByPlatformHandle(focusedWindow).IsNull);
+
+        if (isAppFocused)
         {
+            // (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
+            // When multi-viewports are enabled, all Dear ImGui positions are same as OS positions.
             if (io.WantSetMousePos)
             {
-                SetCursorPos((int)io.MousePos.X, (int)io.MousePos.Y);
+                var pos = new POINT((int)io.MousePos.X, (int)io.MousePos.Y);
+                if ((io.ConfigFlags & ImGuiConfigFlags.ViewportsEnable) != 0)
+                    ClientToScreen(this.hWnd, &pos);
+                SetCursorPos(pos.x, pos.y);
+            }
         }
 
-            if (GetCursorPos(&pt))
+        // (Optional) Fallback to provide mouse position when focused (WM_MOUSEMOVE already provides this when hovered or captured)
+        if (!io.WantSetMousePos && !this.mouseTracked && hasMouseScreenPos)
         {
-                io.MousePos.X = pt.x;
+            // Single viewport mode: mouse position in client window coordinates (io.MousePos is (0,0) when the mouse is on the upper-left corner of the app window)
-                io.MousePos.Y = pt.y;
+            // (This is the position you can get with ::GetCursorPos() + ::ScreenToClient() or WM_MOUSEMOVE.)
-            }
+            // Multi-viewport mode: mouse position in OS absolute coordinates (io.MousePos is (0,0) when the mouse is on the upper-left of the primary monitor)
-            else
+            // (This is the position you can get with ::GetCursorPos() or WM_MOUSEMOVE + ::ClientToScreen(). In theory adding viewport->Pos to a client position would also be the same.)
+            var mousePos = mouseScreenPos;
+            if ((io.ConfigFlags & ImGuiConfigFlags.ViewportsEnable) == 0)
             {
-                io.MousePos.X = float.MinValue;
+                // Use game window, otherwise, positions are calculated based on the focused window which might not be the game.
-                io.MousePos.Y = float.MinValue;
+                // Leads to offsets.
-            }
+                ClientToScreen(this.hWnd, &mousePos);
-        }
-        else
-        {
-            if (io.WantSetMousePos)
-            {
-                pt.x = (int)io.MousePos.X;
-                pt.y = (int)io.MousePos.Y;
-                ClientToScreen(this.hWnd, &pt);
-                SetCursorPos(pt.x, pt.y);
             }
 
-            if (GetCursorPos(&pt) && ScreenToClient(this.hWnd, &pt))
+            io.AddMousePosEvent(mousePos.x, mousePos.y);
+        }
+
+        // (Optional) When using multiple viewports: call io.AddMouseViewportEvent() with the viewport the OS mouse cursor is hovering.
+        // If ImGuiBackendFlags_HasMouseHoveredViewport is not set by the backend, Dear imGui will ignore this field and infer the information using its flawed heuristic.
+        // - [X] Win32 backend correctly ignore viewports with the _NoInputs flag (here using ::WindowFromPoint with WM_NCHITTEST + HTTRANSPARENT in WndProc does that)
+        //       Some backend are not able to handle that correctly. If a backend report an hovered viewport that has the _NoInputs flag (e.g. when dragging a window
+        //       for docking, the viewport has the _NoInputs flag in order to allow us to find the viewport under), then Dear ImGui is forced to ignore the value reported
+        //       by the backend, and use its flawed heuristic to guess the viewport behind.
+        // - [X] Win32 backend correctly reports this regardless of another viewport behind focused and dragged from (we need this to find a useful drag and drop target).
+        if (hasMouseScreenPos)
         {
-                io.MousePos.X = pt.x;
+            var viewport = this.ViewportFromPoint(mouseScreenPos);
-                io.MousePos.Y = pt.y;
+            io.AddMouseViewportEvent(!viewport.IsNull ? viewport.ID : 0u);
         }
         else
         {
-                io.MousePos.X = float.MinValue;
+            io.AddMouseViewportEvent(0);
-                io.MousePos.Y = float.MinValue;
         }
     }
+
+    private ImGuiViewportPtr ViewportFromPoint(POINT mouseScreenPos)
+    {
+        var hoveredHwnd = WindowFromPoint(mouseScreenPos);
+        return hoveredHwnd != default ? ImGui.FindViewportByPlatformHandle(hoveredHwnd) : default;
     }
 
     private bool UpdateMouseCursor()
@@ -451,7 +542,7 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
         return true;
     }
 
-    private void ProcessKeyEventsWorkarounds()
+    private void ProcessKeyEventsWorkarounds(HWND focusedWindow)
     {
         // Left & right Shift keys: when both are pressed together, Windows tend to not generate the WM_KEYUP event for the first released one.
         if (ImGui.IsKeyDown(ImGuiKey.LeftShift) && !IsVkDown(VK.VK_LSHIFT))
@@ -480,7 +571,7 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
         {
             // See: https://github.com/goatcorp/ImGuiScene/pull/13
             // > GetForegroundWindow from winuser.h is a surprisingly expensive function.
-            var isForeground = GetForegroundWindow() == this.hWnd;
+            var isForeground = focusedWindow == this.hWnd;
             for (var i = (int)ImGuiKey.NamedKeyBegin; i < (int)ImGuiKey.NamedKeyEnd; i++)
             {
                 // Skip raising modifier keys if the game is focused.
@@ -646,14 +737,7 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
                 return;
 
             var pio = ImGui.GetPlatformIO();
-
+            ImGui.GetPlatformIO().Handle->Monitors.Free();
-            if (ImGui.GetPlatformIO().Handle->Monitors.Data != null)
-            {
-                // We allocated the platform monitor data in OnUpdateMonitors ourselves,
-                // so we have to free it ourselves to ImGui doesn't try to, or else it will crash
-                Marshal.FreeHGlobal(new IntPtr(ImGui.GetPlatformIO().Handle->Monitors.Data));
-                ImGui.GetPlatformIO().Handle->Monitors = default;
-            }
 
             fixed (char* windowClassNamePtr = WindowClassName)
             {
@@ -693,23 +777,26 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
             // Here we use a manual ImVector overload, free the existing monitor data,
             // and allocate our own, as we are responsible for telling ImGui about monitors
             var pio = ImGui.GetPlatformIO();
-            var numMonitors = GetSystemMetrics(SM.SM_CMONITORS);
+            pio.Handle->Monitors.Resize(0);
-            var data = Marshal.AllocHGlobal(Marshal.SizeOf<ImGuiPlatformMonitor>() * numMonitors);
-            if (pio.Handle->Monitors.Data != null)
-                Marshal.FreeHGlobal(new IntPtr(pio.Handle->Monitors.Data));
-            pio.Handle->Monitors = new(numMonitors, numMonitors, (ImGuiPlatformMonitor*)data.ToPointer());
 
-            // ImGuiPlatformIOPtr platformIO = ImGui.GetPlatformIO();
+            EnumDisplayMonitors(default, null, &EnumDisplayMonitorsCallback, default);
-            // Marshal.FreeHGlobal(platformIO.Handle->Monitors.Data);
-            // int numMonitors = GetSystemMetrics(SystemMetric.SM_CMONITORS);
-            // nint data = Marshal.AllocHGlobal(Marshal.SizeOf<ImGuiPlatformMonitor>() * numMonitors);
-            // platformIO.Handle->Monitors = new ImVector(numMonitors, numMonitors, data);
 
-            var monitorIndex = -1;
+            Log.Information("Monitors set up!");
-            var enumfn = new MonitorEnumProcDelegate(
+            foreach (ref var monitor in pio.Handle->Monitors)
-                (hMonitor, _, _, _) =>
+            {
+                Log.Information(
+                    "Monitor: {MainPos} {MainSize} {WorkPos} {WorkSize}",
+                    monitor.MainPos,
+                    monitor.MainSize,
+                    monitor.WorkPos,
+                    monitor.WorkSize);
+            }
+
+            return;
+
+            [UnmanagedCallersOnly]
+            static BOOL EnumDisplayMonitorsCallback(HMONITOR hMonitor, HDC hdc, RECT* rect, LPARAM lParam)
             {
-                    monitorIndex++;
                 var info = new MONITORINFO { cbSize = (uint)sizeof(MONITORINFO) };
                 if (!GetMonitorInfoW(hMonitor, &info))
                     return true;
@@ -718,33 +805,21 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
                 var monitorRb = new Vector2(info.rcMonitor.right, info.rcMonitor.bottom);
                 var workLt = new Vector2(info.rcWork.left, info.rcWork.top);
                 var workRb = new Vector2(info.rcWork.right, info.rcWork.bottom);
+
                 // Give ImGui the info for this display
-
+                var imMonitor = new ImGuiPlatformMonitor
-                    ref var imMonitor = ref ImGui.GetPlatformIO().Monitors.Ref(monitorIndex);
-                    imMonitor.MainPos = monitorLt;
-                    imMonitor.MainSize = monitorRb - monitorLt;
-                    imMonitor.WorkPos = workLt;
-                    imMonitor.WorkSize = workRb - workLt;
-                    imMonitor.DpiScale = 1f;
-                    return true;
-                });
-            EnumDisplayMonitors(
-                default,
-                null,
-                (delegate* unmanaged<HMONITOR, HDC, RECT*, LPARAM, BOOL>)Marshal.GetFunctionPointerForDelegate(enumfn),
-                default);
-
-            Log.Information("Monitors set up!");
-            for (var i = 0; i < numMonitors; i++)
                 {
-                var monitor = pio.Handle->Monitors[i];
+                    MainPos = monitorLt,
-                Log.Information(
+                    MainSize = monitorRb - monitorLt,
-                    "Monitor {Index}: {MainPos} {MainSize} {WorkPos} {WorkSize}",
+                    WorkPos = workLt,
-                    i,
+                    WorkSize = workRb - workLt,
-                    monitor.MainPos,
+                    DpiScale = 1f,
-                    monitor.MainSize,
+                };
-                    monitor.WorkPos,
+                if ((info.dwFlags & MONITORINFOF_PRIMARY) != 0)
-                    monitor.WorkSize);
+                    ImGui.GetPlatformIO().Monitors.PushFront(imMonitor);
+                else
+                    ImGui.GetPlatformIO().Monitors.PushBack(imMonitor);
+                return true;
             }
         }
 
@@ -794,6 +869,9 @@ internal sealed unsafe partial class Win32InputHandler : IImGuiInputHandler
                     null);
             }
 
+            if (data->Hwnd == 0)
+                Util.Fatal($"CreateWindowExW failed: {GetLastError()}", "ImGui Viewport error");
+
             data->HwndOwned = true;
             viewport.PlatformRequestResize = false;
             viewport.PlatformHandle = viewport.PlatformHandleRaw = data->Hwnd;

Dalamud/Interface/ImGuiSeStringRenderer/Internal/SeStringColorStackSet.cs

@@ -15,10 +15,6 @@ namespace Dalamud.Interface.ImGuiSeStringRenderer.Internal;
 /// <summary>Color stacks to use while evaluating a SeString.</summary>
 internal sealed class SeStringColorStackSet
 {
-    /// <summary>Parsed <see cref="UIColor"/>, containing colors to use with <see cref="MacroCode.ColorType"/> and
-    /// <see cref="MacroCode.EdgeColorType"/>.</summary>
-    private readonly uint[,] colorTypes;
-
     /// <summary>Foreground color stack while evaluating a SeString for rendering.</summary>
     /// <remarks>Touched only from the main thread.</remarks>
     private readonly List<uint> colorStack = [];
@@ -39,30 +35,38 @@ internal sealed class SeStringColorStackSet
         foreach (var row in uiColor)
             maxId = (int)Math.Max(row.RowId, maxId);
 
-        this.colorTypes = new uint[maxId + 1, 4];
+        this.ColorTypes = new uint[maxId + 1, 4];
         foreach (var row in uiColor)
         {
             // Contains ABGR.
-            this.colorTypes[row.RowId, 0] = row.Dark;
+            this.ColorTypes[row.RowId, 0] = row.Dark;
-            this.colorTypes[row.RowId, 1] = row.Light;
+            this.ColorTypes[row.RowId, 1] = row.Light;
-            this.colorTypes[row.RowId, 2] = row.ClassicFF;
+            this.ColorTypes[row.RowId, 2] = row.ClassicFF;
-            this.colorTypes[row.RowId, 3] = row.ClearBlue;
+            this.ColorTypes[row.RowId, 3] = row.ClearBlue;
         }
 
         if (BitConverter.IsLittleEndian)
         {
             // ImGui wants RGBA in LE.
-            fixed (uint* p = this.colorTypes)
+            fixed (uint* p = this.ColorTypes)
             {
-                foreach (ref var r in new Span<uint>(p, this.colorTypes.GetLength(0) * this.colorTypes.GetLength(1)))
+                foreach (ref var r in new Span<uint>(p, this.ColorTypes.GetLength(0) * this.ColorTypes.GetLength(1)))
                     r = BinaryPrimitives.ReverseEndianness(r);
             }
         }
     }
 
+    /// <summary>Initializes a new instance of the <see cref="SeStringColorStackSet"/> class.</summary>
+    /// <param name="colorTypes">Color types.</param>
+    public SeStringColorStackSet(uint[,] colorTypes) => this.ColorTypes = colorTypes;
+
     /// <summary>Gets a value indicating whether at least one color has been pushed to the edge color stack.</summary>
     public bool HasAdditionalEdgeColor { get; private set; }
 
+    /// <summary>Gets the parsed <see cref="UIColor"/> containing colors to use with <see cref="MacroCode.ColorType"/>
+    /// and <see cref="MacroCode.EdgeColorType"/>.</summary>
+    public uint[,] ColorTypes { get; }
+
     /// <summary>Resets the colors in the stack.</summary>
     /// <param name="drawState">Draw state.</param>
     internal void Initialize(scoped ref SeStringDrawState drawState)
@@ -191,9 +195,9 @@ internal sealed class SeStringColorStackSet
         }
 
         // Opacity component is ignored.
-        var color = themeIndex >= 0 && themeIndex < this.colorTypes.GetLength(1) &&
+        var color = themeIndex >= 0 && themeIndex < this.ColorTypes.GetLength(1) &&
-                    colorTypeIndex < this.colorTypes.GetLength(0)
+                    colorTypeIndex < this.ColorTypes.GetLength(0)
-                        ? this.colorTypes[colorTypeIndex, themeIndex]
+                        ? this.ColorTypes[colorTypeIndex, themeIndex]
                         : 0u;
 
         rgbaStack.Add(color | 0xFF000000u);

Dalamud/Interface/ImGuiSeStringRenderer/Internal/SeStringRenderer.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 
@@ -25,7 +26,7 @@ namespace Dalamud.Interface.ImGuiSeStringRenderer.Internal;
 
 /// <summary>Draws SeString.</summary>
 [ServiceManager.EarlyLoadedService]
-internal unsafe class SeStringRenderer : IInternalDisposableService
+internal class SeStringRenderer : IServiceType
 {
     private const int ImGuiContextCurrentWindowOffset = 0x3FF0;
     private const int ImGuiWindowDcOffset = 0x118;
@@ -47,28 +48,19 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
 
     /// <summary>Parsed text fragments from a SeString.</summary>
     /// <remarks>Touched only from the main thread.</remarks>
-    private readonly List<TextFragment> fragments = [];
+    private readonly List<TextFragment> fragmentsMainThread = [];
 
     /// <summary>Color stacks to use while evaluating a SeString for rendering.</summary>
     /// <remarks>Touched only from the main thread.</remarks>
-    private readonly SeStringColorStackSet colorStackSet;
+    private readonly SeStringColorStackSet colorStackSetMainThread;
-
-    /// <summary>Splits a draw list so that different layers of a single glyph can be drawn out of order.</summary>
-    private ImDrawListSplitter* splitter = ImGui.ImDrawListSplitter();
 
     [ServiceManager.ServiceConstructor]
     private SeStringRenderer(DataManager dm, TargetSigScanner sigScanner)
     {
-        this.colorStackSet = new(dm.Excel.GetSheet<UIColor>());
+        this.colorStackSetMainThread = new(dm.Excel.GetSheet<UIColor>());
         this.gfd = dm.GetFile<GfdFile>("common/font/gfdata.gfd")!;
     }
 
-    /// <summary>Finalizes an instance of the <see cref="SeStringRenderer"/> class.</summary>
-    ~SeStringRenderer() => this.ReleaseUnmanagedResources();
-
-    /// <inheritdoc/>
-    void IInternalDisposableService.DisposeService() => this.ReleaseUnmanagedResources();
-
     /// <summary>Compiles and caches a SeString from a text macro representation.</summary>
     /// <param name="text">SeString text macro representation.
     /// Newline characters will be normalized to newline payloads.</param>
@@ -80,6 +72,44 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
                 text.ReplaceLineEndings("<br>"),
                 new() { ExceptionMode = MacroStringParseExceptionMode.EmbedError }));
 
+    /// <summary>Creates a draw data that will draw the given SeString onto it.</summary>
+    /// <param name="sss">SeString to render.</param>
+    /// <param name="drawParams">Parameters for drawing.</param>
+    /// <returns>A new self-contained draw data.</returns>
+    public unsafe BufferBackedImDrawData CreateDrawData(
+        ReadOnlySeStringSpan sss,
+        scoped in SeStringDrawParams drawParams = default)
+    {
+        if (drawParams.TargetDrawList is not null)
+        {
+            throw new ArgumentException(
+                $"{nameof(SeStringDrawParams.TargetDrawList)} may not be specified.",
+                nameof(drawParams));
+        }
+
+        var dd = BufferBackedImDrawData.Create();
+
+        try
+        {
+            var size = this.Draw(sss, drawParams with { TargetDrawList = dd.ListPtr }).Size;
+
+            var offset = drawParams.ScreenOffset ?? Vector2.Zero;
+            foreach (var vtx in new Span<ImDrawVert>(dd.ListPtr.VtxBuffer.Data, dd.ListPtr.VtxBuffer.Size))
+                offset = Vector2.Min(offset, vtx.Pos);
+
+            dd.Data.DisplayPos = offset;
+            dd.Data.DisplaySize = size - offset;
+            dd.Data.Valid = 1;
+            dd.UpdateDrawDataStatistics();
+            return dd;
+        }
+        catch
+        {
+            dd.Dispose();
+            throw;
+        }
+    }
+
     /// <summary>Compiles and caches a SeString from a text macro representation, and then draws it.</summary>
     /// <param name="text">SeString text macro representation.
     /// Newline characters will be normalized to newline payloads.</param>
@@ -113,28 +143,44 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
     /// <param name="imGuiId">ImGui ID, if link functionality is desired.</param>
     /// <param name="buttonFlags">Button flags to use on link interaction.</param>
     /// <returns>Interaction result of the rendered text.</returns>
-    public SeStringDrawResult Draw(
+    public unsafe SeStringDrawResult Draw(
         ReadOnlySeStringSpan sss,
         scoped in SeStringDrawParams drawParams = default,
         ImGuiId imGuiId = default,
         ImGuiButtonFlags buttonFlags = ImGuiButtonFlags.MouseButtonDefault)
     {
-        // Drawing is only valid if done from the main thread anyway, especially with interactivity.
+        // Interactivity is supported only from the main thread.
+        if (!imGuiId.IsEmpty())
             ThreadSafety.AssertMainThread();
 
         if (drawParams.TargetDrawList is not null && imGuiId)
             throw new ArgumentException("ImGuiId cannot be set if TargetDrawList is manually set.", nameof(imGuiId));
 
-        // This also does argument validation for drawParams. Do it here.
+        using var cleanup = new DisposeSafety.ScopedFinalizer();
-        var state = new SeStringDrawState(sss, drawParams, this.colorStackSet, this.splitter);
 
-        // Reset and initialize the state.
+        ImFont* font = null;
-        this.fragments.Clear();
+        if (drawParams.Font.HasValue)
-        this.colorStackSet.Initialize(ref state);
+            font = drawParams.Font.Value;
+
+        // API14: Remove commented out code
+        if (ThreadSafety.IsMainThread /* && drawParams.TargetDrawList is null */ && font is null)
+            font = ImGui.GetFont();
+        if (font is null)
+            throw new ArgumentException("Specified font is empty.");
+
+        // This also does argument validation for drawParams. Do it here.
+        // `using var` makes a struct read-only, but we do want to modify it.
+        using var stateStorage = new SeStringDrawState(
+            sss,
+            drawParams,
+            ThreadSafety.IsMainThread ? this.colorStackSetMainThread : new(this.colorStackSetMainThread.ColorTypes),
+            ThreadSafety.IsMainThread ? this.fragmentsMainThread : [],
+            font);
+        ref var state = ref Unsafe.AsRef(in stateStorage);
 
         // Analyze the provided SeString and break it up to text fragments.
         this.CreateTextFragments(ref state);
-        var fragmentSpan = CollectionsMarshal.AsSpan(this.fragments);
+        var fragmentSpan = CollectionsMarshal.AsSpan(state.Fragments);
 
         // Calculate size.
         var size = Vector2.Zero;
@@ -147,25 +193,18 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
 
         state.SplitDrawList();
 
-        // Handle cases where ImGui.AlignTextToFramePadding has been called.
-        var context = ImGui.GetCurrentContext();
-        var currLineTextBaseOffset = 0f;
-        if (!context.IsNull)
-        {
-            var currentWindow = context.CurrentWindow;
-            if (!currentWindow.IsNull)
-            {
-                currLineTextBaseOffset = currentWindow.DC.CurrLineTextBaseOffset;
-            }
-        }
-
         var itemSize = size;
+        if (drawParams.TargetDrawList is null)
+        {
+            // Handle cases where ImGui.AlignTextToFramePadding has been called.
+            var currLineTextBaseOffset = ImGui.GetCurrentContext().CurrentWindow.DC.CurrLineTextBaseOffset;
             if (currLineTextBaseOffset != 0f)
             {
                 itemSize.Y += 2 * currLineTextBaseOffset;
                 foreach (ref var f in fragmentSpan)
                     f.Offset += new Vector2(0, currLineTextBaseOffset);
             }
+        }
 
         // Draw all text fragments.
         var lastRune = default(Rune);
@@ -280,15 +319,6 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
         return displayRune.Value != 0;
     }
 
-    private void ReleaseUnmanagedResources()
-    {
-        if (this.splitter is not null)
-        {
-            this.splitter->Destroy();
-            this.splitter = null;
-        }
-    }
-
     /// <summary>Creates text fragment, taking line and word breaking into account.</summary>
     /// <param name="state">Draw state.</param>
     private void CreateTextFragments(ref SeStringDrawState state)
@@ -391,7 +421,7 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
                 var overflows = Math.Max(w, xy.X + fragment.VisibleWidth) > state.WrapWidth;
 
                 // Test if the fragment does not fit into the current line and the current line is not empty.
-                if (xy.X != 0 && this.fragments.Count > 0 && !this.fragments[^1].BreakAfter && overflows)
+                if (xy.X != 0 && state.Fragments.Count > 0 && !state.Fragments[^1].BreakAfter && overflows)
                 {
                     // Introduce break if this is the first time testing the current break unit or the current fragment
                     // is an entity.
@@ -401,7 +431,7 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
                         xy.X = 0;
                         xy.Y += state.LineHeight;
                         w = 0;
-                        CollectionsMarshal.AsSpan(this.fragments)[^1].BreakAfter = true;
+                        CollectionsMarshal.AsSpan(state.Fragments)[^1].BreakAfter = true;
                         fragment.Offset = xy;
 
                         // Now that the fragment is given its own line, test if it overflows again.
@@ -419,16 +449,16 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
                         fragment = this.CreateFragment(state, prev, curr, true, xy, link, entity, remainingWidth);
                     }
                 }
-                else if (this.fragments.Count > 0 && xy.X != 0)
+                else if (state.Fragments.Count > 0 && xy.X != 0)
                 {
                     // New fragment fits into the current line, and it has a previous fragment in the same line.
                     // If the previous fragment ends with a soft hyphen, adjust its width so that the width of its
                     // trailing soft hyphens are not considered.
-                    if (this.fragments[^1].EndsWithSoftHyphen)
+                    if (state.Fragments[^1].EndsWithSoftHyphen)
-                        xy.X += this.fragments[^1].AdvanceWidthWithoutSoftHyphen - this.fragments[^1].AdvanceWidth;
+                        xy.X += state.Fragments[^1].AdvanceWidthWithoutSoftHyphen - state.Fragments[^1].AdvanceWidth;
 
                     // Adjust this fragment's offset from kerning distance.
-                    xy.X += state.CalculateScaledDistance(this.fragments[^1].LastRune, fragment.FirstRune);
+                    xy.X += state.CalculateScaledDistance(state.Fragments[^1].LastRune, fragment.FirstRune);
                     fragment.Offset = xy;
                 }
 
@@ -439,7 +469,7 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
                 w = Math.Max(w, xy.X + fragment.VisibleWidth);
                 xy.X += fragment.AdvanceWidth;
                 prev = fragment.To;
-                this.fragments.Add(fragment);
+                state.Fragments.Add(fragment);
 
                 if (fragment.BreakAfter)
                 {
@@ -491,7 +521,7 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
                     if (gfdTextureSrv != 0)
                     {
                         state.Draw(
-                            new ImTextureID(gfdTextureSrv),
+                            new(gfdTextureSrv),
                             offset + new Vector2(x, MathF.Round((state.LineHeight - size.Y) / 2)),
                             size,
                             useHq ? gfdEntry.HqUv0 : gfdEntry.Uv0,
@@ -528,7 +558,7 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
 
         return;
 
-        static nint GetGfdTextureSrv()
+        static unsafe nint GetGfdTextureSrv()
         {
             var uim = UIModule.Instance();
             if (uim is null)
@@ -553,7 +583,7 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
     /// <summary>Determines a bitmap icon to display for the given SeString payload.</summary>
     /// <param name="sss">Byte span that should include a SeString payload.</param>
     /// <returns>Icon to display, or <see cref="None"/> if it should not be displayed as an icon.</returns>
-    private BitmapFontIcon GetBitmapFontIconFor(ReadOnlySpan<byte> sss)
+    private unsafe BitmapFontIcon GetBitmapFontIconFor(ReadOnlySpan<byte> sss)
     {
         var e = new ReadOnlySeStringSpan(sss).GetEnumerator();
         if (!e.MoveNext() || e.Current.MacroCode is not MacroCode.Icon and not MacroCode.Icon2)
@@ -710,38 +740,4 @@ internal unsafe class SeStringRenderer : IInternalDisposableService
             firstDisplayRune ?? default,
             lastNonSoftHyphenRune);
     }
-
-    /// <summary>Represents a text fragment in a SeString span.</summary>
-    /// <param name="From">Starting byte offset (inclusive) in a SeString.</param>
-    /// <param name="To">Ending byte offset (exclusive) in a SeString.</param>
-    /// <param name="Link">Byte offset of the link that decorates this text fragment, or <c>-1</c> if none.</param>
-    /// <param name="Offset">Offset in pixels w.r.t. <see cref="SeStringDrawParams.ScreenOffset"/>.</param>
-    /// <param name="Entity">Replacement entity, if any.</param>
-    /// <param name="VisibleWidth">Visible width of this text fragment. This is the width required to draw everything
-    /// without clipping.</param>
-    /// <param name="AdvanceWidth">Advance width of this text fragment. This is the width required to add to the cursor
-    /// to position the next fragment correctly.</param>
-    /// <param name="AdvanceWidthWithoutSoftHyphen">Same with <paramref name="AdvanceWidth"/>, but trimming all the
-    /// trailing soft hyphens.</param>
-    /// <param name="BreakAfter">Whether to insert a line break after this text fragment.</param>
-    /// <param name="EndsWithSoftHyphen">Whether this text fragment ends with one or more soft hyphens.</param>
-    /// <param name="FirstRune">First rune in this text fragment.</param>
-    /// <param name="LastRune">Last rune in this text fragment, for the purpose of calculating kerning distance with
-    /// the following text fragment in the same line, if any.</param>
-    private record struct TextFragment(
-        int From,
-        int To,
-        int Link,
-        Vector2 Offset,
-        SeStringReplacementEntity Entity,
-        float VisibleWidth,
-        float AdvanceWidth,
-        float AdvanceWidthWithoutSoftHyphen,
-        bool BreakAfter,
-        bool EndsWithSoftHyphen,
-        Rune FirstRune,
-        Rune LastRune)
-    {
-        public bool IsSoftHyphenVisible => this.EndsWithSoftHyphen && this.BreakAfter;
-    }
 }

Dalamud/Interface/ImGuiSeStringRenderer/Internal/TextFragment.cs

@@ -0,0 +1,39 @@
+using System.Numerics;
+using System.Text;
+
+namespace Dalamud.Interface.ImGuiSeStringRenderer.Internal;
+
+/// <summary>Represents a text fragment in a SeString span.</summary>
+/// <param name="From">Starting byte offset (inclusive) in a SeString.</param>
+/// <param name="To">Ending byte offset (exclusive) in a SeString.</param>
+/// <param name="Link">Byte offset of the link that decorates this text fragment, or <c>-1</c> if none.</param>
+/// <param name="Offset">Offset in pixels w.r.t. <see cref="SeStringDrawParams.ScreenOffset"/>.</param>
+/// <param name="Entity">Replacement entity, if any.</param>
+/// <param name="VisibleWidth">Visible width of this text fragment. This is the width required to draw everything
+/// without clipping.</param>
+/// <param name="AdvanceWidth">Advance width of this text fragment. This is the width required to add to the cursor
+/// to position the next fragment correctly.</param>
+/// <param name="AdvanceWidthWithoutSoftHyphen">Same with <paramref name="AdvanceWidth"/>, but trimming all the
+/// trailing soft hyphens.</param>
+/// <param name="BreakAfter">Whether to insert a line break after this text fragment.</param>
+/// <param name="EndsWithSoftHyphen">Whether this text fragment ends with one or more soft hyphens.</param>
+/// <param name="FirstRune">First rune in this text fragment.</param>
+/// <param name="LastRune">Last rune in this text fragment, for the purpose of calculating kerning distance with
+/// the following text fragment in the same line, if any.</param>
+internal record struct TextFragment(
+    int From,
+    int To,
+    int Link,
+    Vector2 Offset,
+    SeStringReplacementEntity Entity,
+    float VisibleWidth,
+    float AdvanceWidth,
+    float AdvanceWidthWithoutSoftHyphen,
+    bool BreakAfter,
+    bool EndsWithSoftHyphen,
+    Rune FirstRune,
+    Rune LastRune)
+{
+    /// <summary>Gets a value indicating whether the fragment ends with a visible soft hyphen.</summary>
+    public bool IsSoftHyphenVisible => this.EndsWithSoftHyphen && this.BreakAfter;
+}

Dalamud/Interface/ImGuiSeStringRenderer/SeStringDrawParams.cs

@@ -12,7 +12,11 @@ public record struct SeStringDrawParams
     /// <summary>Gets or sets the target draw list.</summary>
     /// <value>Target draw list, <c>default(ImDrawListPtr)</c> to not draw, or <c>null</c> to use
     /// <see cref="ImGui.GetWindowDrawList"/> (the default).</value>
-    /// <remarks>If this value is set, <see cref="ImGui.Dummy"/> will not be called, and ImGui ID will be ignored.
+    /// <remarks>
+    /// If this value is set, <see cref="ImGui.Dummy"/> will not be called, and ImGui ID will be ignored.
+    /// You <b>must</b> specify a valid draw list, a valid font via <see cref="Font"/> and <see cref="FontSize"/> if you set this value,
+    /// since the renderer will not be able to retrieve them from ImGui context.
+    /// Must be set when drawing off the main thread.
     /// </remarks>
     public ImDrawListPtr? TargetDrawList { get; set; }
 
@@ -21,16 +25,20 @@ public record struct SeStringDrawParams
     public SeStringReplacementEntity.GetEntityDelegate? GetEntity { get; set; }
 
     /// <summary>Gets or sets the screen offset of the left top corner.</summary>
-    /// <value>Screen offset to draw at, or <c>null</c> to use <see cref="ImGui.GetCursorScreenPos()"/>.</value>
+    /// <value>Screen offset to draw at, or <c>null</c> to use <see cref="ImGui.GetCursorScreenPos()"/>, if no <see cref="TargetDrawList"/>
+    /// is specified. Otherwise, you must specify it (for example, by passing <see cref="ImGui.GetCursorScreenPos()"/> when passing the window
+    /// draw list.</value>
     public Vector2? ScreenOffset { get; set; }
 
     /// <summary>Gets or sets the font to use.</summary>
     /// <value>Font to use, or <c>null</c> to use <see cref="ImGui.GetFont"/> (the default).</value>
+    /// <remarks>Must be set when specifying a target draw-list or drawing off the main thread.</remarks>
     public ImFontPtr? Font { get; set; }
 
     /// <summary>Gets or sets the font size.</summary>
     /// <value>Font size in pixels, or <c>0</c> to use the current ImGui font size <see cref="ImGui.GetFontSize"/>.
     /// </value>
+    /// <remarks>Must be set when specifying a target draw-list or drawing off the main thread.</remarks>
     public float? FontSize { get; set; }
 
     /// <summary>Gets or sets the line height ratio.</summary>

Dalamud/Interface/ImGuiSeStringRenderer/SeStringDrawState.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -6,7 +7,10 @@ using System.Text;
 using Dalamud.Bindings.ImGui;
 using Dalamud.Interface.ImGuiSeStringRenderer.Internal;
 using Dalamud.Interface.Utility;
+using Dalamud.Utility;
+
 using FFXIVClientStructs.FFXIV.Component.GUI;
+
 using Lumina.Text.Payloads;
 using Lumina.Text.ReadOnly;
 
@@ -14,51 +18,93 @@ namespace Dalamud.Interface.ImGuiSeStringRenderer;
 
 /// <summary>Calculated values from <see cref="SeStringDrawParams"/> using ImGui styles.</summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe ref struct SeStringDrawState
+public unsafe ref struct SeStringDrawState : IDisposable
 {
     private static readonly int ChannelCount = Enum.GetValues<SeStringDrawChannel>().Length;
 
     private readonly ImDrawList* drawList;
-    private readonly SeStringColorStackSet colorStackSet;
+
-    private readonly ImDrawListSplitter* splitter;
+    private ImDrawListSplitter splitter;
 
     /// <summary>Initializes a new instance of the <see cref="SeStringDrawState"/> struct.</summary>
     /// <param name="span">Raw SeString byte span.</param>
     /// <param name="ssdp">Instance of <see cref="SeStringDrawParams"/> to initialize from.</param>
     /// <param name="colorStackSet">Instance of <see cref="SeStringColorStackSet"/> to use.</param>
-    /// <param name="splitter">Instance of ImGui Splitter to use.</param>
+    /// <param name="fragments">Fragments.</param>
+    /// <param name="font">Font to use.</param>
     internal SeStringDrawState(
         ReadOnlySpan<byte> span,
         scoped in SeStringDrawParams ssdp,
         SeStringColorStackSet colorStackSet,
-        ImDrawListSplitter* splitter)
+        List<TextFragment> fragments,
+        ImFont* font)
     {
-        this.colorStackSet = colorStackSet;
-        this.splitter = splitter;
-        this.drawList = ssdp.TargetDrawList ?? ImGui.GetWindowDrawList();
         this.Span = span;
-        this.GetEntity = ssdp.GetEntity;
+        this.ColorStackSet = colorStackSet;
+        this.Fragments = fragments;
+        this.Font = font;
+
+        if (ssdp.TargetDrawList is null)
+        {
+            if (!ThreadSafety.IsMainThread)
+            {
+                throw new ArgumentException(
+                    $"{nameof(ssdp.TargetDrawList)} must be set to render outside the main thread.");
+            }
+
+            this.drawList = ssdp.TargetDrawList ?? ImGui.GetWindowDrawList();
             this.ScreenOffset = ssdp.ScreenOffset ?? ImGui.GetCursorScreenPos();
-        this.ScreenOffset = new(MathF.Round(this.ScreenOffset.X), MathF.Round(this.ScreenOffset.Y));
-        this.Font = ssdp.EffectiveFont;
             this.FontSize = ssdp.FontSize ?? ImGui.GetFontSize();
+            this.WrapWidth = ssdp.WrapWidth ?? ImGui.GetContentRegionAvail().X;
+            this.Color = ssdp.Color ?? ImGui.GetColorU32(ImGuiCol.Text);
+            this.LinkHoverBackColor = ssdp.LinkHoverBackColor ?? ImGui.GetColorU32(ImGuiCol.ButtonHovered);
+            this.LinkActiveBackColor = ssdp.LinkActiveBackColor ?? ImGui.GetColorU32(ImGuiCol.ButtonActive);
+            this.ThemeIndex = ssdp.ThemeIndex ?? AtkStage.Instance()->AtkUIColorHolder->ActiveColorThemeType;
+        }
+        else
+        {
+            this.drawList = ssdp.TargetDrawList.Value;
+            this.ScreenOffset = ssdp.ScreenOffset ?? Vector2.Zero;
+
+            // API14: Remove, always throw
+            if (ThreadSafety.IsMainThread)
+            {
+                this.ScreenOffset = ssdp.ScreenOffset ?? ImGui.GetCursorScreenPos();
+                this.FontSize = ssdp.FontSize ?? ImGui.GetFontSize();
+            }
+            else
+            {
+                throw new ArgumentException(
+                    $"{nameof(ssdp.FontSize)} must be set when specifying a target draw list, as it cannot be fetched from the ImGui state.");
+            }
+
+            // this.FontSize = ssdp.FontSize ?? throw new ArgumentException(
+            //                     $"{nameof(ssdp.FontSize)} must be set when specifying a target draw list, as it cannot be fetched from the ImGui state.");
+            this.WrapWidth = ssdp.WrapWidth ?? float.MaxValue;
+            this.Color = ssdp.Color ?? uint.MaxValue;
+            this.LinkHoverBackColor = 0; // Interactivity is unused outside the main thread.
+            this.LinkActiveBackColor = 0; // Interactivity is unused outside the main thread.
+            this.ThemeIndex = ssdp.ThemeIndex ?? 0;
+        }
+
+        this.splitter = default;
+        this.GetEntity = ssdp.GetEntity;
+        this.ScreenOffset = new(MathF.Round(this.ScreenOffset.X), MathF.Round(this.ScreenOffset.Y));
         this.FontSizeScale = this.FontSize / this.Font->FontSize;
         this.LineHeight = MathF.Round(ssdp.EffectiveLineHeight);
-        this.WrapWidth = ssdp.WrapWidth ?? ImGui.GetContentRegionAvail().X;
         this.LinkUnderlineThickness = ssdp.LinkUnderlineThickness ?? 0f;
         this.Opacity = ssdp.EffectiveOpacity;
         this.EdgeOpacity = (ssdp.EdgeStrength ?? 0.25f) * ssdp.EffectiveOpacity;
-        this.Color = ssdp.Color ?? ImGui.GetColorU32(ImGuiCol.Text);
         this.EdgeColor = ssdp.EdgeColor ?? 0xFF000000;
         this.ShadowColor = ssdp.ShadowColor ?? 0xFF000000;
-        this.LinkHoverBackColor = ssdp.LinkHoverBackColor ?? ImGui.GetColorU32(ImGuiCol.ButtonHovered);
-        this.LinkActiveBackColor = ssdp.LinkActiveBackColor ?? ImGui.GetColorU32(ImGuiCol.ButtonActive);
         this.ForceEdgeColor = ssdp.ForceEdgeColor;
-        this.ThemeIndex = ssdp.ThemeIndex ?? AtkStage.Instance()->AtkUIColorHolder->ActiveColorThemeType;
         this.Bold = ssdp.Bold;
         this.Italic = ssdp.Italic;
         this.Edge = ssdp.Edge;
         this.Shadow = ssdp.Shadow;
+
+        this.ColorStackSet.Initialize(ref this);
+        fragments.Clear();
     }
 
     /// <inheritdoc cref="SeStringDrawParams.TargetDrawList"/>
@@ -135,7 +181,7 @@ public unsafe ref struct SeStringDrawState
 
     /// <summary>Gets a value indicating whether the edge should be drawn.</summary>
     public readonly bool ShouldDrawEdge =>
-        (this.Edge || this.colorStackSet.HasAdditionalEdgeColor) && this.EdgeColor >= 0x1000000;
+        (this.Edge || this.ColorStackSet.HasAdditionalEdgeColor) && this.EdgeColor >= 0x1000000;
 
     /// <summary>Gets a value indicating whether the edge should be drawn.</summary>
     public readonly bool ShouldDrawShadow => this is { Shadow: true, ShadowColor: >= 0x1000000 };
@@ -143,11 +189,20 @@ public unsafe ref struct SeStringDrawState
     /// <summary>Gets a value indicating whether the edge should be drawn.</summary>
     public readonly bool ShouldDrawForeground => this is { Color: >= 0x1000000 };
 
+    /// <summary>Gets the color stacks.</summary>
+    internal SeStringColorStackSet ColorStackSet { get; }
+
+    /// <summary>Gets the text fragments.</summary>
+    internal List<TextFragment> Fragments { get; }
+
+    /// <inheritdoc/>
+    public void Dispose() => this.splitter.ClearFreeMemory();
+
     /// <summary>Sets the current channel in the ImGui draw list splitter.</summary>
     /// <param name="channelIndex">Channel to switch to.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public readonly void SetCurrentChannel(SeStringDrawChannel channelIndex) =>
+    public void SetCurrentChannel(SeStringDrawChannel channelIndex) =>
-        this.splitter->SetCurrentChannel(this.drawList, (int)channelIndex);
+        this.splitter.SetCurrentChannel(this.drawList, (int)channelIndex);
 
     /// <summary>Draws a single texture.</summary>
     /// <param name="igTextureId">ImGui texture ID to draw from.</param>
@@ -216,7 +271,7 @@ public unsafe ref struct SeStringDrawState
     /// <summary>Draws a single glyph using current styling configurations.</summary>
     /// <param name="g">Glyph to draw.</param>
     /// <param name="offset">Offset of the glyph in pixels w.r.t. <see cref="ScreenOffset"/>.</param>
-    internal readonly void DrawGlyph(scoped in ImGuiHelpers.ImFontGlyphReal g, Vector2 offset)
+    internal void DrawGlyph(scoped in ImGuiHelpers.ImFontGlyphReal g, Vector2 offset)
     {
         var texId = this.Font->ContainerAtlas->Textures.Ref<ImFontAtlasTexture>(g.TextureIndex).TexID;
         var xy0 = new Vector2(
@@ -268,7 +323,7 @@ public unsafe ref struct SeStringDrawState
     /// <param name="offset">Offset of the glyph in pixels w.r.t.
     /// <see cref="SeStringDrawParams.ScreenOffset"/>.</param>
     /// <param name="advanceWidth">Advance width of the glyph.</param>
-    internal readonly void DrawLinkUnderline(Vector2 offset, float advanceWidth)
+    internal void DrawLinkUnderline(Vector2 offset, float advanceWidth)
     {
         if (this.LinkUnderlineThickness < 1f)
             return;
@@ -350,15 +405,15 @@ public unsafe ref struct SeStringDrawState
         switch (payload.MacroCode)
         {
             case MacroCode.Color:
-                this.colorStackSet.HandleColorPayload(ref this, payload);
+                this.ColorStackSet.HandleColorPayload(ref this, payload);
                 return true;
 
             case MacroCode.EdgeColor:
-                this.colorStackSet.HandleEdgeColorPayload(ref this, payload);
+                this.ColorStackSet.HandleEdgeColorPayload(ref this, payload);
                 return true;
 
             case MacroCode.ShadowColor:
-                this.colorStackSet.HandleShadowColorPayload(ref this, payload);
+                this.ColorStackSet.HandleShadowColorPayload(ref this, payload);
                 return true;
 
             case MacroCode.Bold when payload.TryGetExpression(out var e) && e.TryGetUInt(out var u):
@@ -379,11 +434,11 @@ public unsafe ref struct SeStringDrawState
                 return true;
 
             case MacroCode.ColorType:
-                this.colorStackSet.HandleColorTypePayload(ref this, payload);
+                this.ColorStackSet.HandleColorTypePayload(ref this, payload);
                 return true;
 
             case MacroCode.EdgeColorType:
-                this.colorStackSet.HandleEdgeColorTypePayload(ref this, payload);
+                this.ColorStackSet.HandleEdgeColorTypePayload(ref this, payload);
                 return true;
 
             default:
@@ -393,10 +448,9 @@ public unsafe ref struct SeStringDrawState
 
     /// <summary>Splits the draw list.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal readonly void SplitDrawList() =>
+    internal void SplitDrawList() => this.splitter.Split(this.drawList, ChannelCount);
-        this.splitter->Split(this.drawList, ChannelCount);
 
     /// <summary>Merges the draw list.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal readonly void MergeDrawList() => this.splitter->Merge(this.drawList);
+    internal void MergeDrawList() => this.splitter.Merge(this.drawList);
 }

Dalamud/Interface/Internal/DalamudInterface.cs

@@ -533,6 +533,13 @@ internal class DalamudInterface : IInternalDisposableService
             this.creditsDarkeningAnimation.Restart();
     }
 
+    /// <inheritdoc cref="DataWindow.GetWidget{T}"/>
+    public T GetDataWindowWidget<T>() where T : IDataWindowWidget => this.dataWindow.GetWidget<T>();
+
+    /// <summary>Sets the data window current widget.</summary>
+    /// <param name="widget">Widget to set current.</param>
+    public void SetDataWindowWidget(IDataWindowWidget widget) => this.dataWindow.CurrentWidget = widget;
+
     private void OnDraw()
     {
         this.FrameCount++;
@@ -660,6 +667,10 @@ internal class DalamudInterface : IInternalDisposableService
     {
         if (this.isImGuiDrawDevMenu)
         {
+            using var barColor = ImRaii.PushColor(ImGuiCol.WindowBg, new Vector4(0.060f, 0.060f, 0.060f, 0.773f));
+            barColor.Push(ImGuiCol.MenuBarBg, Vector4.Zero);
+            barColor.Push(ImGuiCol.Border, Vector4.Zero);
+            barColor.Push(ImGuiCol.BorderShadow, Vector4.Zero);
             if (ImGui.BeginMainMenuBar())
             {
                 var pluginManager = Service<PluginManager>.Get();
@@ -832,6 +843,11 @@ internal class DalamudInterface : IInternalDisposableService
                             ImGui.PopStyleVar();
                         }
 
+                        if (ImGui.MenuItem("Raise external event through boot"))
+                        {
+                            ErrorHandling.CrashWithContext("Tést");
+                        }
+
                         ImGui.EndMenu();
                     }
 

Dalamud/Interface/Internal/Windows/Data/DataWindow.cs

@@ -68,7 +68,7 @@ internal class DataWindow : Window, IDisposable
 
     private bool isExcept;
     private bool selectionCollapsed;
-    private IDataWindowWidget currentWidget;
+
     private bool isLoaded;
 
     /// <summary>
@@ -82,9 +82,12 @@ internal class DataWindow : Window, IDisposable
 
         this.RespectCloseHotkey = false;
         this.orderedModules = this.modules.OrderBy(module => module.DisplayName);
-        this.currentWidget = this.orderedModules.First();
+        this.CurrentWidget = this.orderedModules.First();
     }
 
+    /// <summary>Gets or sets the current widget.</summary>
+    public IDataWindowWidget CurrentWidget { get; set; }
+
     /// <inheritdoc/>
     public void Dispose() => this.modules.OfType<IDisposable>().AggregateToDisposable().Dispose();
 
@@ -99,6 +102,20 @@ internal class DataWindow : Window, IDisposable
     {
     }
 
+    /// <summary>Gets the data window widget of the specified type.</summary>
+    /// <typeparam name="T">Type of the data window widget to find.</typeparam>
+    /// <returns>Found widget.</returns>
+    public T GetWidget<T>() where T : IDataWindowWidget
+    {
+        foreach (var m in this.modules)
+        {
+            if (m is T w)
+                return w;
+        }
+
+        throw new ArgumentException($"No widget of type {typeof(T).FullName} found.");
+    }
+
     /// <summary>
     /// Set the DataKind dropdown menu.
     /// </summary>
@@ -110,7 +127,7 @@ internal class DataWindow : Window, IDisposable
 
         if (this.modules.FirstOrDefault(module => module.IsWidgetCommand(dataKind)) is { } targetModule)
         {
-            this.currentWidget = targetModule;
+            this.CurrentWidget = targetModule;
         }
         else
         {
@@ -153,9 +170,9 @@ internal class DataWindow : Window, IDisposable
             {
                 foreach (var widget in this.orderedModules)
                 {
-                    if (ImGui.Selectable(widget.DisplayName, this.currentWidget == widget))
+                    if (ImGui.Selectable(widget.DisplayName, this.CurrentWidget == widget))
                     {
-                        this.currentWidget = widget;
+                        this.CurrentWidget = widget;
                     }
                 }
 
@@ -206,9 +223,9 @@ internal class DataWindow : Window, IDisposable
 
                 try
                 {
-                    if (this.currentWidget is { Ready: true })
+                    if (this.CurrentWidget is { Ready: true })
                     {
-                        this.currentWidget.Draw();
+                        this.CurrentWidget.Draw();
                     }
                     else
                     {

Dalamud/Interface/Internal/Windows/Data/Widgets/FontAwesomeTestWidget.cs

@@ -1,9 +1,15 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
+using System.Threading.Tasks;
 
 using Dalamud.Bindings.ImGui;
+using Dalamud.Interface.Components;
+using Dalamud.Interface.Textures.Internal;
 using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Internal;
+
+using Lumina.Text.ReadOnly;
 
 namespace Dalamud.Interface.Internal.Windows.Data.Widgets;
 
@@ -87,12 +93,30 @@ internal class FontAwesomeTestWidget : IDataWindowWidget
         ImGuiHelpers.ScaledDummy(10f);
         for (var i = 0; i < this.icons?.Count; i++)
         {
+            if (this.icons[i] == FontAwesomeIcon.None)
+                continue;
+
+            ImGui.AlignTextToFramePadding();
             ImGui.Text($"0x{(int)this.icons[i].ToIconChar():X}");
             ImGuiHelpers.ScaledRelativeSameLine(50f);
             ImGui.Text($"{this.iconNames?[i]}");
             ImGuiHelpers.ScaledRelativeSameLine(280f);
             ImGui.PushFont(this.useFixedWidth ? InterfaceManager.IconFontFixedWidth : InterfaceManager.IconFont);
             ImGui.Text(this.icons[i].ToIconString());
+            ImGuiHelpers.ScaledRelativeSameLine(320f);
+            if (this.useFixedWidth
+                    ? ImGui.Button($"{(char)this.icons[i]}##FontAwesomeIconButton{i}")
+                    : ImGuiComponents.IconButton($"##FontAwesomeIconButton{i}", this.icons[i]))
+            {
+                _ = Service<DevTextureSaveMenu>.Get().ShowTextureSaveMenuAsync(
+                    this.DisplayName,
+                    this.icons[i].ToString(),
+                    Task.FromResult(
+                        Service<TextureManager>.Get().CreateTextureFromSeString(
+                            ReadOnlySeString.FromText(this.icons[i].ToIconString()),
+                            new() { Font = ImGui.GetFont(), FontSize = ImGui.GetFontSize() })));
+            }
+
             ImGui.PopFont();
             ImGuiHelpers.ScaledDummy(2f);
         }

Dalamud/Interface/Internal/Windows/Data/Widgets/SeStringRendererTestWidget.cs

@@ -1,5 +1,6 @@
 using System.Numerics;
 using System.Text;
+using System.Threading.Tasks;
 
 using Dalamud.Bindings.ImGui;
 using Dalamud.Data;
@@ -9,11 +10,13 @@ using Dalamud.Interface.ImGuiSeStringRenderer;
 using Dalamud.Interface.ImGuiSeStringRenderer.Internal;
 using Dalamud.Interface.Textures.Internal;
 using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Internal;
 using Dalamud.Storage.Assets;
 using Dalamud.Utility;
 using FFXIVClientStructs.FFXIV.Component.GUI;
 using Lumina.Excel.Sheets;
 using Lumina.Text;
+using Lumina.Text.Parse;
 using Lumina.Text.Payloads;
 using Lumina.Text.ReadOnly;
 
@@ -56,11 +59,11 @@ internal unsafe class SeStringRendererTestWidget : IDataWindowWidget
     /// <inheritdoc/>
     public void Draw()
     {
-        var t2 = ImGui.ColorConvertU32ToFloat4(this.style.Color ?? ImGui.GetColorU32(ImGuiCol.Text));
+        var t2 = ImGui.ColorConvertU32ToFloat4(this.style.Color ??= ImGui.GetColorU32(ImGuiCol.Text));
         if (ImGui.ColorEdit4("Color", ref t2))
             this.style.Color = ImGui.ColorConvertFloat4ToU32(t2);
 
-        t2 = ImGui.ColorConvertU32ToFloat4(this.style.EdgeColor ?? 0xFF000000u);
+        t2 = ImGui.ColorConvertU32ToFloat4(this.style.EdgeColor ??= 0xFF000000u);
         if (ImGui.ColorEdit4("Edge Color", ref t2))
             this.style.EdgeColor = ImGui.ColorConvertFloat4ToU32(t2);
 
@@ -69,27 +72,27 @@ internal unsafe class SeStringRendererTestWidget : IDataWindowWidget
         if (ImGui.Checkbox("Forced"u8, ref t))
             this.style.ForceEdgeColor = t;
 
-        t2 = ImGui.ColorConvertU32ToFloat4(this.style.ShadowColor ?? 0xFF000000u);
+        t2 = ImGui.ColorConvertU32ToFloat4(this.style.ShadowColor ??= 0xFF000000u);
-        if (ImGui.ColorEdit4("Shadow Color", ref t2))
+        if (ImGui.ColorEdit4("Shadow Color"u8, ref t2))
             this.style.ShadowColor = ImGui.ColorConvertFloat4ToU32(t2);
 
-        t2 = ImGui.ColorConvertU32ToFloat4(this.style.LinkHoverBackColor ?? ImGui.GetColorU32(ImGuiCol.ButtonHovered));
+        t2 = ImGui.ColorConvertU32ToFloat4(this.style.LinkHoverBackColor ??= ImGui.GetColorU32(ImGuiCol.ButtonHovered));
-        if (ImGui.ColorEdit4("Link Hover Color", ref t2))
+        if (ImGui.ColorEdit4("Link Hover Color"u8, ref t2))
             this.style.LinkHoverBackColor = ImGui.ColorConvertFloat4ToU32(t2);
 
-        t2 = ImGui.ColorConvertU32ToFloat4(this.style.LinkActiveBackColor ?? ImGui.GetColorU32(ImGuiCol.ButtonActive));
+        t2 = ImGui.ColorConvertU32ToFloat4(this.style.LinkActiveBackColor ??= ImGui.GetColorU32(ImGuiCol.ButtonActive));
-        if (ImGui.ColorEdit4("Link Active Color", ref t2))
+        if (ImGui.ColorEdit4("Link Active Color"u8, ref t2))
             this.style.LinkActiveBackColor = ImGui.ColorConvertFloat4ToU32(t2);
 
-        var t3 = this.style.LineHeight ?? 1f;
+        var t3 = this.style.LineHeight ??= 1f;
         if (ImGui.DragFloat("Line Height"u8, ref t3, 0.01f, 0.4f, 3f, "%.02f"))
             this.style.LineHeight = t3;
 
-        t3 = this.style.Opacity ?? ImGui.GetStyle().Alpha;
+        t3 = this.style.Opacity ??= 1f;
         if (ImGui.DragFloat("Opacity"u8, ref t3, 0.005f, 0f, 1f, "%.02f"))
             this.style.Opacity = t3;
 
-        t3 = this.style.EdgeStrength ?? 0.25f;
+        t3 = this.style.EdgeStrength ??= 0.25f;
         if (ImGui.DragFloat("Edge Strength"u8, ref t3, 0.005f, 0f, 1f, "%.02f"))
             this.style.EdgeStrength = t3;
 
@@ -174,6 +177,24 @@ internal unsafe class SeStringRendererTestWidget : IDataWindowWidget
             ImGuiHelpers.SeStringWrapped(this.logkind.Value.Data.Span, this.style);
         }
 
+        if (ImGui.CollapsingHeader("Draw into drawlist"))
+        {
+            ImGuiHelpers.ScaledDummy(100);
+            ImGui.SetCursorScreenPos(ImGui.GetItemRectMin() + ImGui.GetStyle().FramePadding);
+            var clipMin = ImGui.GetItemRectMin() + ImGui.GetStyle().FramePadding;
+            var clipMax = ImGui.GetItemRectMax() - ImGui.GetStyle().FramePadding;
+            clipMin.Y = MathF.Max(clipMin.Y, ImGui.GetWindowPos().Y);
+            clipMax.Y = MathF.Min(clipMax.Y, ImGui.GetWindowPos().Y + ImGui.GetWindowHeight());
+
+            var dl = ImGui.GetWindowDrawList();
+            dl.PushClipRect(clipMin, clipMax);
+            ImGuiHelpers.CompileSeStringWrapped(
+                "<icon(1)>Test test<icon(1)>",
+                new SeStringDrawParams
+                    { Color = 0xFFFFFFFF, WrapWidth = float.MaxValue, TargetDrawList = dl });
+            dl.PopClipRect();
+        }
+
         if (ImGui.CollapsingHeader("Addon Table"u8))
         {
             if (ImGui.BeginTable("Addon Sheet"u8, 3))
@@ -240,6 +261,27 @@ internal unsafe class SeStringRendererTestWidget : IDataWindowWidget
                     Service<SeStringRenderer>.Get().CompileAndCache(this.testString).Data.Span));
         }
 
+        ImGui.SameLine();
+
+        if (ImGui.Button("Copy as Image"))
+        {
+            _ = Service<DevTextureSaveMenu>.Get().ShowTextureSaveMenuAsync(
+                this.DisplayName,
+                $"From {nameof(SeStringRendererTestWidget)}",
+                Task.FromResult(
+                    Service<TextureManager>.Get().CreateTextureFromSeString(
+                        ReadOnlySeString.FromMacroString(
+                            this.testString,
+                            new(ExceptionMode: MacroStringParseExceptionMode.EmbedError)),
+                        this.style with
+                        {
+                            Font = ImGui.GetFont(),
+                            FontSize = ImGui.GetFontSize(),
+                            WrapWidth = ImGui.GetContentRegionAvail().X,
+                            ThemeIndex = AtkStage.Instance()->AtkUIColorHolder->ActiveColorThemeType,
+                        })));
+        }
+
         ImGuiHelpers.ScaledDummy(3);
         ImGuiHelpers.CompileSeStringWrapped(
             "Optional features implemented for the following test input:<br>" +

Dalamud/Interface/Internal/Windows/Data/Widgets/TexWidget.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Numerics;
@@ -306,12 +306,12 @@ internal class TexWidget : IDataWindowWidget
                         pres->Release();
 
                         ImGui.Text($"RC: Resource({rcres})/View({rcsrv})");
-                        ImGui.Text(source.ToString());
+                        ImGui.Text($"{source.Width} x {source.Height} | {source}");
                     }
                     else
                     {
-                        ImGui.Text("RC: -"u8);
+                        ImGui.Text("RC: -");
-                        ImGui.Text(" "u8);
+                        ImGui.Text(string.Empty);
                     }
                 }
 
@@ -342,6 +342,10 @@ internal class TexWidget : IDataWindowWidget
         runLater?.Invoke();
     }
 
+    /// <summary>Adds a texture wrap for debug display purposes.</summary>
+    /// <param name="textureTask">Task returning a texture.</param>
+    public void AddTexture(Task<IDalamudTextureWrap> textureTask) => this.addedTextures.Add(new(Api10: textureTask));
+
     private unsafe void DrawBlame(List<TextureManager.IBlameableDalamudTextureWrap> allBlames)
     {
         var im = Service<InterfaceManager>.Get();

Dalamud/Interface/Internal/Windows/SelfTest/Steps/NounProcessorSelfTestStep.cs

@@ -191,6 +191,29 @@ internal class NounProcessorSelfTestStep : ISelfTestStep
         new(nameof(LSheets.Item), 44348, ClientLanguage.French, 2, (int)FrenchArticleType.PossessiveFirstPerson, 1, "mes mémoquartz inhabituels fantasmagoriques"),
         new(nameof(LSheets.Item), 44348, ClientLanguage.French, 2, (int)FrenchArticleType.PossessiveSecondPerson, 1, "tes mémoquartz inhabituels fantasmagoriques"),
         new(nameof(LSheets.Item), 44348, ClientLanguage.French, 2, (int)FrenchArticleType.PossessiveThirdPerson, 1, "ses mémoquartz inhabituels fantasmagoriques"),
+
+        // ColumnOffset tests
+
+        new(nameof(LSheets.BeastTribe), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Indefinite, 1, "a Amalj'aa"),
+        new(nameof(LSheets.BeastTribe), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Definite, 1, "the Amalj'aa"),
+
+        new(nameof(LSheets.DeepDungeonEquipment), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Indefinite, 1, "an aetherpool arm"),
+        new(nameof(LSheets.DeepDungeonEquipment), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Definite, 1, "the aetherpool arm"),
+
+        new(nameof(LSheets.DeepDungeonItem), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Indefinite, 1, "a pomander of safety"),
+        new(nameof(LSheets.DeepDungeonItem), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Definite, 1, "the pomander of safety"),
+
+        new(nameof(LSheets.DeepDungeonMagicStone), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Indefinite, 1, "a splinter of Inferno magicite"),
+        new(nameof(LSheets.DeepDungeonMagicStone), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Definite, 1, "the splinter of Inferno magicite"),
+
+        new(nameof(LSheets.DeepDungeonDemiclone), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Indefinite, 1, "an Unei demiclone"),
+        new(nameof(LSheets.DeepDungeonDemiclone), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Definite, 1, "the Unei demiclone"),
+
+        new(nameof(LSheets.Glasses), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Indefinite, 1, "a pair of oval spectacles"),
+        new(nameof(LSheets.Glasses), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Definite, 1, "the pair of oval spectacles"),
+
+        new(nameof(LSheets.GlassesStyle), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Indefinite, 1, "a shaded spectacles"),
+        new(nameof(LSheets.GlassesStyle), 1, ClientLanguage.English, 1, (int)EnglishArticleType.Definite, 1, "the shaded spectacles"),
     ];
 
     private enum GermanCases

Dalamud/Interface/Internal/Windows/TitleScreenMenuWindow.cs

@@ -86,7 +86,8 @@ internal class TitleScreenMenuWindow : Window, IDisposable
         : base(
             "TitleScreenMenuOverlay",
             ImGuiWindowFlags.NoTitleBar | ImGuiWindowFlags.AlwaysAutoResize | ImGuiWindowFlags.NoScrollbar |
-            ImGuiWindowFlags.NoBackground | ImGuiWindowFlags.NoFocusOnAppearing | ImGuiWindowFlags.NoNavFocus)
+            ImGuiWindowFlags.NoBackground | ImGuiWindowFlags.NoFocusOnAppearing | ImGuiWindowFlags.NoNavFocus |
+            ImGuiWindowFlags.NoDocking)
     {
         this.showTsm = consoleManager.AddVariable("dalamud.show_tsm", "Show the Title Screen Menu", true);
 

Dalamud/Interface/ManagedFontAtlas/IFontHandle.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 
 using Dalamud.Bindings.ImGui;
 
@@ -33,10 +34,22 @@ public interface IFontHandle : IDisposable
     /// </summary>
     /// <remarks>
     /// Use <see cref="Push"/> directly if you want to keep the current ImGui font if the font is not ready.<br />
-    /// Alternatively, use <see cref="WaitAsync"/> to wait for this property to become <c>true</c>.
+    /// Alternatively, use <see cref="WaitAsync()"/> to wait for this property to become <c>true</c>.
     /// </remarks>
     bool Available { get; }
 
+    /// <summary>
+    /// Attempts to lock the fully constructed instance of <see cref="ImFontPtr"/> corresponding to the this
+    /// <see cref="IFontHandle"/>, for use in any thread.<br />
+    /// Modification of the font will exhibit undefined behavior if some other thread also uses the font.
+    /// </summary>
+    /// <param name="errorMessage">The error message, if any.</param>
+    /// <returns>
+    /// An instance of <see cref="ILockedImFont"/> that <b>must</b> be disposed after use on success;
+    /// <c>null</c> with <paramref name="errorMessage"/> populated on failure.
+    /// </returns>
+    ILockedImFont? TryLock(out string? errorMessage);
+
     /// <summary>
     /// Locks the fully constructed instance of <see cref="ImFontPtr"/> corresponding to the this
     /// <see cref="IFontHandle"/>, for use in any thread.<br />
@@ -92,4 +105,11 @@ public interface IFontHandle : IDisposable
     /// </summary>
     /// <returns>A task containing this <see cref="IFontHandle"/>.</returns>
     Task<IFontHandle> WaitAsync();
+
+    /// <summary>
+    /// Waits for <see cref="Available"/> to become <c>true</c>.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A task containing this <see cref="IFontHandle"/>.</returns>
+    Task<IFontHandle> WaitAsync(CancellationToken cancellationToken);
 }

Dalamud/Interface/ManagedFontAtlas/Internals/FontHandle.cs

@@ -238,12 +238,17 @@ internal abstract class FontHandle : IFontHandle
     }
 
     /// <inheritdoc/>
-    public Task<IFontHandle> WaitAsync()
+    public Task<IFontHandle> WaitAsync() => this.WaitAsync(CancellationToken.None);
+
+    /// <inheritdoc/>
+    public Task<IFontHandle> WaitAsync(CancellationToken cancellationToken)
     {
         if (this.Available)
             return Task.FromResult<IFontHandle>(this);
 
         var tcs = new TaskCompletionSource<IFontHandle>(TaskCreationOptions.RunContinuationsAsynchronously);
+        cancellationToken.Register(() => tcs.TrySetCanceled());
+
         this.ImFontChanged += OnImFontChanged;
         this.Disposed += OnDisposed;
         if (this.Available)

Dalamud/Interface/Textures/Internal/TextureManager.FromSeString.cs

@@ -0,0 +1,35 @@
+using Dalamud.Interface.ImGuiSeStringRenderer;
+using Dalamud.Interface.ImGuiSeStringRenderer.Internal;
+using Dalamud.Interface.Textures.TextureWraps;
+using Dalamud.Utility;
+
+namespace Dalamud.Interface.Textures.Internal;
+
+/// <summary>Service responsible for loading and disposing ImGui texture wraps.</summary>
+internal sealed partial class TextureManager
+{
+    [ServiceManager.ServiceDependency]
+    private readonly SeStringRenderer seStringRenderer = Service<SeStringRenderer>.Get();
+
+    /// <inheritdoc/>
+    public IDalamudTextureWrap CreateTextureFromSeString(
+        ReadOnlySpan<byte> text,
+        scoped in SeStringDrawParams drawParams = default,
+        string? debugName = null)
+    {
+        ThreadSafety.AssertMainThread();
+        using var dd = this.seStringRenderer.CreateDrawData(text, drawParams);
+        var texture = this.CreateDrawListTexture(debugName ?? nameof(this.CreateTextureFromSeString));
+        try
+        {
+            texture.Size = dd.Data.DisplaySize;
+            texture.Draw(dd.DataPtr);
+            return texture;
+        }
+        catch
+        {
+            texture.Dispose();
+            throw;
+        }
+    }
+}

Dalamud/Interface/Textures/Internal/TextureManager.cs

@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using Dalamud.Configuration.Internal;
 using Dalamud.Data;
 using Dalamud.Game;
+using Dalamud.Interface.ImGuiSeStringRenderer.Internal;
 using Dalamud.Interface.Internal;
 using Dalamud.Interface.Textures.Internal.SharedImmediateTextures;
 using Dalamud.Interface.Textures.TextureWraps;

Dalamud/Interface/Textures/Internal/TextureManagerPluginScoped.cs

@@ -6,6 +6,7 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
+using Dalamud.Interface.ImGuiSeStringRenderer;
 using Dalamud.Interface.Internal;
 using Dalamud.Interface.Textures.TextureWraps;
 using Dalamud.IoC;
@@ -283,6 +284,18 @@ internal sealed class TextureManagerPluginScoped
         return textureWrap;
     }
 
+    /// <inheritdoc/>
+    public IDalamudTextureWrap CreateTextureFromSeString(
+        ReadOnlySpan<byte> text,
+        scoped in SeStringDrawParams drawParams = default,
+        string? debugName = null)
+    {
+        var manager = this.ManagerOrThrow;
+        var textureWrap = manager.CreateTextureFromSeString(text, drawParams, debugName);
+        manager.Blame(textureWrap, this.plugin);
+        return textureWrap;
+    }
+
     /// <inheritdoc/>
     public IEnumerable<IBitmapCodecInfo> GetSupportedImageDecoderInfos() =>
         this.ManagerOrThrow.Wic.GetSupportedDecoderInfos();

Dalamud/Interface/UiBuilder.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
 
 using Dalamud.Bindings.ImGui;
@@ -691,7 +692,8 @@ public sealed class UiBuilder : IDisposable, IUiBuilder
         FontAtlasAutoRebuildMode autoRebuildMode,
         bool isGlobalScaled = true,
         string? debugName = null) =>
-        this.scopedFinalizer.Add(Service<FontAtlasFactory>
+        this.scopedFinalizer.Add(
+            Service<FontAtlasFactory>
                 .Get()
                 .CreateFontAtlas(
                     this.namespaceName + ":" + (debugName ?? "custom"),
@@ -868,6 +870,15 @@ public sealed class UiBuilder : IDisposable, IUiBuilder
             // Note: do not dispose w; we do not own it
         }
 
+        public ILockedImFont? TryLock(out string? errorMessage)
+        {
+            if (this.wrapped is { } w)
+                return w.TryLock(out errorMessage);
+
+            errorMessage = nameof(ObjectDisposedException);
+            return null;
+        }
+
         public ILockedImFont Lock() =>
             this.wrapped?.Lock() ?? throw new ObjectDisposedException(nameof(FontHandleWrapper));
 
@@ -876,7 +887,13 @@ public sealed class UiBuilder : IDisposable, IUiBuilder
         public void Pop() => this.WrappedNotDisposed.Pop();
 
         public Task<IFontHandle> WaitAsync() =>
-            this.WrappedNotDisposed.WaitAsync().ContinueWith(_ => (IFontHandle)this);
+            this.wrapped?.WaitAsync().ContinueWith(_ => (IFontHandle)this)
+            ?? Task.FromException<IFontHandle>(new ObjectDisposedException(nameof(FontHandleWrapper)));
+
+        public Task<IFontHandle> WaitAsync(CancellationToken cancellationToken) =>
+            this.wrapped?.WaitAsync(cancellationToken)
+                .ContinueWith(_ => (IFontHandle)this, cancellationToken)
+            ?? Task.FromException<IFontHandle>(new ObjectDisposedException(nameof(FontHandleWrapper)));
 
         public override string ToString() =>
             $"{nameof(FontHandleWrapper)}({this.wrapped?.ToString() ?? "disposed"})";

Dalamud/Interface/Utility/BufferBackedImDrawData.cs

@@ -0,0 +1,92 @@
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+using Dalamud.Bindings.ImGui;
+
+namespace Dalamud.Interface.Utility;
+
+/// <summary>Wrapper aroundx <see cref="ImDrawData"/> containing one <see cref="ImDrawList"/>.</summary>
+public unsafe struct BufferBackedImDrawData : IDisposable
+{
+    private nint buffer;
+
+    /// <summary>Initializes a new instance of the <see cref="BufferBackedImDrawData"/> struct.</summary>
+    /// <param name="buffer">Address of buffer to use.</param>
+    private BufferBackedImDrawData(nint buffer) => this.buffer = buffer;
+
+    /// <summary>Gets the <see cref="ImDrawData"/> stored in this buffer.</summary>
+    public readonly ref ImDrawData Data => ref ((DataStruct*)this.buffer)->Data;
+
+    /// <summary>Gets the <see cref="ImDrawDataPtr"/> stored in this buffer.</summary>
+    public readonly ImDrawDataPtr DataPtr => new((ImDrawData*)Unsafe.AsPointer(ref this.Data));
+
+    /// <summary>Gets the <see cref="ImDrawList"/> stored in this buffer.</summary>
+    public readonly ref ImDrawList List => ref ((DataStruct*)this.buffer)->List;
+
+    /// <summary>Gets the <see cref="ImDrawListPtr"/> stored in this buffer.</summary>
+    public readonly ImDrawListPtr ListPtr => new((ImDrawList*)Unsafe.AsPointer(ref this.List));
+
+    /// <summary>Creates a new instance of <see cref="BufferBackedImDrawData"/>.</summary>
+    /// <returns>A new instance of <see cref="BufferBackedImDrawData"/>.</returns>
+    public static BufferBackedImDrawData Create()
+    {
+        if (ImGui.GetCurrentContext().IsNull || ImGui.GetIO().FontDefault.Handle is null)
+            throw new("ImGui is not ready");
+
+        var res = new BufferBackedImDrawData(Marshal.AllocHGlobal(sizeof(DataStruct)));
+        var ds = (DataStruct*)res.buffer;
+        *ds = default;
+
+        var atlas = ImGui.GetIO().Fonts;
+        ds->SharedData = *ImGui.GetDrawListSharedData().Handle;
+        ds->SharedData.TexIdCommon = atlas.Textures[atlas.TextureIndexCommon].TexID;
+        ds->SharedData.TexUvWhitePixel = atlas.TexUvWhitePixel;
+        ds->SharedData.TexUvLines = (Vector4*)Unsafe.AsPointer(ref atlas.TexUvLines[0]);
+        ds->SharedData.Font = ImGui.GetIO().FontDefault;
+        ds->SharedData.FontSize = ds->SharedData.Font->FontSize;
+        ds->SharedData.ClipRectFullscreen = new(
+            float.NegativeInfinity,
+            float.NegativeInfinity,
+            float.PositiveInfinity,
+            float.PositiveInfinity);
+
+        ds->List.Data = &ds->SharedData;
+        ds->ListPtr = &ds->List;
+        ds->Data.CmdLists = &ds->ListPtr;
+        ds->Data.CmdListsCount = 1;
+        ds->Data.FramebufferScale = Vector2.One;
+
+        res.ListPtr._ResetForNewFrame();
+        res.ListPtr.PushClipRectFullScreen();
+        res.ListPtr.PushTextureID(new(atlas.TextureIndexCommon));
+        return res;
+    }
+
+    /// <summary>Updates the statistics information stored in <see cref="DataPtr"/> from <see cref="ListPtr"/>.</summary>
+    public readonly void UpdateDrawDataStatistics()
+    {
+        this.Data.TotalIdxCount = this.List.IdxBuffer.Size;
+        this.Data.TotalVtxCount = this.List.VtxBuffer.Size;
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        if (this.buffer != 0)
+        {
+            this.ListPtr._ClearFreeMemory();
+            Marshal.FreeHGlobal(this.buffer);
+            this.buffer = 0;
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct DataStruct
+    {
+        public ImDrawData Data;
+        public ImDrawList* ListPtr;
+        public ImDrawList List;
+        public ImDrawListSharedData SharedData;
+    }
+}

Dalamud/Interface/Utility/ImGuiHelpers.cs

@@ -575,6 +575,15 @@ public static partial class ImGuiHelpers
     public static unsafe ImFontPtr OrElse(this ImFontPtr self, ImFontPtr other) =>
         self.IsNull ? other : self;
 
+    /// <summary>Creates a draw data that will draw the given SeString onto it.</summary>
+    /// <param name="sss">SeString to render.</param>
+    /// <param name="style">Initial rendering style.</param>
+    /// <returns>A new self-contained draw data.</returns>
+    internal static BufferBackedImDrawData CreateDrawData(
+        ReadOnlySpan<byte> sss,
+        scoped in SeStringDrawParams style = default) =>
+        Service<SeStringRenderer>.Get().CreateDrawData(sss, style);
+
     /// <summary>
     /// Mark 4K page as used, after adding a codepoint to a font.
     /// </summary>

Dalamud/Interface/Utility/Internal/DevTextureSaveMenu.cs

@@ -6,10 +6,12 @@ using System.Text;
 using System.Threading.Tasks;
 
 using Dalamud.Bindings.ImGui;
+using Dalamud.Game;
 using Dalamud.Interface.ImGuiFileDialog;
 using Dalamud.Interface.ImGuiNotification;
 using Dalamud.Interface.ImGuiNotification.Internal;
 using Dalamud.Interface.Internal;
+using Dalamud.Interface.Internal.Windows.Data.Widgets;
 using Dalamud.Interface.Textures.Internal;
 using Dalamud.Interface.Textures.TextureWraps;
 using Serilog;
@@ -33,6 +35,14 @@ internal sealed class DevTextureSaveMenu : IInternalDisposableService
         this.interfaceManager.Draw += this.InterfaceManagerOnDraw;
     }
 
+    private enum ContextMenuActionType
+    {
+        None,
+        SaveAsFile,
+        CopyToClipboard,
+        SendToTexWidget,
+    }
+
     /// <inheritdoc/>
     void IInternalDisposableService.DisposeService() => this.interfaceManager.Draw -= this.InterfaceManagerOnDraw;
 
@@ -66,15 +76,16 @@ internal sealed class DevTextureSaveMenu : IInternalDisposableService
             var textureManager = await Service<TextureManager>.GetAsync();
             var popupName = $"{nameof(this.ShowTextureSaveMenuAsync)}_{textureWrap.Handle.Handle:X}";
 
+            ContextMenuActionType action;
             BitmapCodecInfo? encoder;
             {
                 var first = true;
                 var encoders = textureManager.Wic.GetSupportedEncoderInfos().ToList();
-                var tcs = new TaskCompletionSource<BitmapCodecInfo?>(
+                var tcs = new TaskCompletionSource<(ContextMenuActionType Action, BitmapCodecInfo? Codec)>(
                     TaskCreationOptions.RunContinuationsAsynchronously);
                 Service<InterfaceManager>.Get().Draw += DrawChoices;
 
-                encoder = await tcs.Task;
+                (action, encoder) = await tcs.Task;
 
                 [SuppressMessage("ReSharper", "AccessToDisposedClosure", Justification = "This shall not escape")]
                 void DrawChoices()
@@ -98,13 +109,20 @@ internal sealed class DevTextureSaveMenu : IInternalDisposableService
                     }
 
                     if (ImGui.Selectable("Copy"u8))
-                        tcs.TrySetResult(null);
+                        tcs.TrySetResult((ContextMenuActionType.CopyToClipboard, null));
+                    if (ImGui.Selectable("Send to TexWidget"u8))
+                        tcs.TrySetResult((ContextMenuActionType.SendToTexWidget, null));
+
+                    ImGui.Separator();
+
                     foreach (var encoder2 in encoders)
                     {
                         if (ImGui.Selectable(encoder2.Name))
-                            tcs.TrySetResult(encoder2);
+                            tcs.TrySetResult((ContextMenuActionType.SaveAsFile, encoder2));
                     }
 
+                    ImGui.Separator();
+
                     const float previewImageWidth = 320;
                     var size = textureWrap.Size;
                     if (size.X > previewImageWidth)
@@ -120,12 +138,28 @@ internal sealed class DevTextureSaveMenu : IInternalDisposableService
                 }
             }
 
-            if (encoder is null)
+            switch (action)
             {
+                case ContextMenuActionType.CopyToClipboard:
                     isCopy = true;
                     await textureManager.CopyToClipboardAsync(textureWrap, name, true);
+                    break;
+
+                case ContextMenuActionType.SendToTexWidget:
+                {
+                    var framework = await Service<Framework>.GetAsync();
+                    var dalamudInterface = await Service<DalamudInterface>.GetAsync();
+                    await framework.RunOnFrameworkThread(
+                        () =>
+                        {
+                            var texWidget = dalamudInterface.GetDataWindowWidget<TexWidget>();
+                            dalamudInterface.SetDataWindowWidget(texWidget);
+                            texWidget.AddTexture(Task.FromResult(textureWrap.CreateWrapSharingLowLevelResource()));
+                        });
+                    break;
                 }
-            else
+
+                case ContextMenuActionType.SaveAsFile when encoder is not null:
                 {
                     var props = new Dictionary<string, object>();
                     if (encoder.ContainerGuid == GUID.GUID_ContainerFormatTiff)
@@ -164,6 +198,8 @@ internal sealed class DevTextureSaveMenu : IInternalDisposableService
                         Process.Start(new ProcessStartInfo(path) { UseShellExecute = true });
                         n.Notification.DismissNow();
                     };
+                    break;
+                }
             }
         }
         catch (Exception e)

Dalamud/Interface/Windowing/Persistence/PresetModel.cs

@@ -53,6 +53,7 @@ internal class PresetModel
         /// <summary>
         /// Gets a value indicating whether this preset is in the default state.
         /// </summary>
+        [JsonIgnore]
         public bool IsDefault =>
             !this.IsPinned &&
             !this.IsClickThrough &&

Dalamud/Interface/Windowing/Window.cs

@@ -1,9 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Numerics;
-using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 
 using CheapLoc;
@@ -19,10 +16,13 @@ using Dalamud.Interface.Utility.Internal;
 using Dalamud.Interface.Utility.Raii;
 using Dalamud.Interface.Windowing.Persistence;
 using Dalamud.Logging.Internal;
-using Dalamud.Utility;
 
 using FFXIVClientStructs.FFXIV.Client.UI;
 
+using TerraFX.Interop.Windows;
+
+using static TerraFX.Interop.Windows.Windows;
+
 namespace Dalamud.Interface.Windowing;
 
 /// <summary>
@@ -31,11 +31,15 @@ namespace Dalamud.Interface.Windowing;
 public abstract class Window
 {
     private const float FadeInOutTime = 0.072f;
+    private const string AdditionsPopupName = "WindowSystemContextActions";
 
     private static readonly ModuleLog Log = new("WindowSystem");
 
     private static bool wasEscPressedLastFrame = false;
 
+    private readonly TitleBarButton additionsButton;
+    private readonly List<TitleBarButton> allButtons = [];
+
     private bool internalLastIsOpen = false;
     private bool internalIsOpen = false;
     private bool internalIsPinned = false;
@@ -72,6 +76,20 @@ public abstract class Window
         this.WindowName = name;
         this.Flags = flags;
         this.ForceMainWindow = forceMainWindow;
+
+        this.additionsButton = new()
+        {
+            Icon = FontAwesomeIcon.Bars,
+            IconOffset = new Vector2(2.5f, 1),
+            Click = _ =>
+            {
+                this.internalIsClickthrough = false;
+                this.presetDirty = true;
+                ImGui.OpenPopup(AdditionsPopupName);
+            },
+            Priority = int.MinValue,
+            AvailableClickthrough = true,
+        };
     }
 
     /// <summary>
@@ -425,8 +443,17 @@ public abstract class Window
                 UIGlobals.PlaySoundEffect(this.OnOpenSfxId);
         }
 
+        var isErrorStylePushed = false;
+        if (!this.hasError)
+        {
             this.PreDraw();
             this.ApplyConditionals();
+        }
+        else
+        {
+            Style.StyleModelV1.DalamudStandard.Push();
+            isErrorStylePushed = true;
+        }
 
         if (this.ForceMainWindow)
             ImGuiHelpers.ForceNextWindowMainViewport();
@@ -448,10 +475,22 @@ public abstract class Window
         var flags = this.Flags;
 
         if (this.internalIsPinned || this.internalIsClickthrough)
+        {
             flags |= ImGuiWindowFlags.NoMove | ImGuiWindowFlags.NoResize;
+        }
 
         if (this.internalIsClickthrough)
+        {
             flags |= ImGuiWindowFlags.NoInputs | ImGuiWindowFlags.NoNav | ImGuiWindowFlags.NoCollapse | ImGuiWindowFlags.NoScrollWithMouse | ImGuiWindowFlags.NoMouseInputs;
+        }
+
+        // If we have an error, reset all flags to default, and unlock window size.
+        if (this.hasError)
+        {
+            flags = ImGuiWindowFlags.None;
+            ImGui.SetNextWindowCollapsed(false, ImGuiCond.Once);
+            ImGui.SetNextWindowSizeConstraints(Vector2.Zero, Vector2.PositiveInfinity);
+        }
 
         if (this.CanShowCloseButton ? ImGui.Begin(this.WindowName, ref this.internalIsOpen, flags) : ImGui.Begin(this.WindowName, flags))
         {
@@ -461,14 +500,12 @@ public abstract class Window
                 ImGuiP.GetCurrentWindow().InheritNoInputs = this.internalIsClickthrough;
             }
 
-            // Not supported yet on non-main viewports
+            if (ImGui.GetWindowViewport().ID != ImGui.GetMainViewport().ID)
-            if ((this.internalIsPinned || this.internalIsClickthrough || this.internalAlpha.HasValue) &&
-                ImGui.GetWindowViewport().ID != ImGui.GetMainViewport().ID)
             {
-                this.internalAlpha = null;
+                if ((flags & ImGuiWindowFlags.NoInputs) == ImGuiWindowFlags.NoInputs)
-                this.internalIsPinned = false;
+                    ImGui.GetWindowViewport().Flags |= ImGuiViewportFlags.NoInputs;
-                this.internalIsClickthrough = false;
+                else
-                this.presetDirty = true;
+                    ImGui.GetWindowViewport().Flags &= ~ImGuiViewportFlags.NoInputs;
             }
 
             if (this.hasError)
@@ -492,7 +529,6 @@ public abstract class Window
             }
         }
 
-        const string additionsPopupName = "WindowSystemContextActions";
         var flagsApplicableForTitleBarIcons = !flags.HasFlag(ImGuiWindowFlags.NoDecoration) &&
                                               !flags.HasFlag(ImGuiWindowFlags.NoTitleBar);
         var showAdditions = (this.AllowPinning || this.AllowClickthrough) &&
@@ -503,13 +539,8 @@ public abstract class Window
         {
             ImGui.PushStyleVar(ImGuiStyleVar.Alpha, 1f);
 
-            if (ImGui.BeginPopup(additionsPopupName, ImGuiWindowFlags.NoMove))
+            if (ImGui.BeginPopup(AdditionsPopupName, ImGuiWindowFlags.NoMove))
             {
-                var isAvailable = ImGuiHelpers.CheckIsWindowOnMainViewport();
-
-                if (!isAvailable)
-                    ImGui.BeginDisabled();
-
                 if (this.internalIsClickthrough)
                     ImGui.BeginDisabled();
 
@@ -557,21 +588,11 @@ public abstract class Window
                     this.presetDirty = true;
                 }
 
-                if (isAvailable)
+                ImGui.TextColored(
-                {
+                    ImGuiColors.DalamudGrey,
-                    ImGui.TextColored(ImGuiColors.DalamudGrey,
+                    Loc.Localize(
-                                      Loc.Localize("WindowSystemContextActionClickthroughDisclaimer",
+                        "WindowSystemContextActionClickthroughDisclaimer",
                         "Open this menu again by clicking the three dashes to disable clickthrough."));
-                }
-                else
-                {
-                    ImGui.TextColored(ImGuiColors.DalamudGrey,
-                                      Loc.Localize("WindowSystemContextActionViewportDisclaimer",
-                                                   "These features are only available if this window is inside the game window."));
-                }
-
-                if (!isAvailable)
-                    ImGui.EndDisabled();
 
                 if (ImGui.Button(Loc.Localize("WindowSystemContextActionPrintWindow", "Print window")))
                     printWindow = true;
@@ -582,34 +603,15 @@ public abstract class Window
             ImGui.PopStyleVar();
         }
 
-        unsafe
-        {
-            var window = ImGuiP.GetCurrentWindow();
-
-            ImRect outRect;
-            ImGuiP.TitleBarRect(&outRect, window);
-
-            var additionsButton = new TitleBarButton
-            {
-                Icon = FontAwesomeIcon.Bars,
-                IconOffset = new Vector2(2.5f, 1),
-                Click = _ =>
-                {
-                    this.internalIsClickthrough = false;
-                    this.presetDirty = false;
-                    ImGui.OpenPopup(additionsPopupName);
-                },
-                Priority = int.MinValue,
-                AvailableClickthrough = true,
-            };
-
         if (flagsApplicableForTitleBarIcons)
         {
-                this.DrawTitleBarButtons(window, flags, outRect,
+            this.allButtons.Clear();
-                                         showAdditions
+            this.allButtons.EnsureCapacity(this.TitleBarButtons.Count + 1);
-                                             ? this.TitleBarButtons.Append(additionsButton)
+            this.allButtons.AddRange(this.TitleBarButtons);
-                                             : this.TitleBarButtons);
+            if (showAdditions)
-            }
+                this.allButtons.Add(this.additionsButton);
+            this.allButtons.Sort(static (a, b) => b.Priority - a.Priority);
+            this.DrawTitleBarButtons();
         }
 
         if (wasFocused)
@@ -670,7 +672,14 @@ public abstract class Window
                 Task.FromResult<IDalamudTextureWrap>(tex));
         }
 
+        if (isErrorStylePushed)
+        {
+            Style.StyleModelV1.DalamudStandard.Pop();
+        }
+        else
+        {
             this.PostDraw();
+        }
 
         this.PostHandlePreset(persistence);
 
@@ -766,8 +775,11 @@ public abstract class Window
         }
     }
 
-    private unsafe void DrawTitleBarButtons(ImGuiWindowPtr window, ImGuiWindowFlags flags, ImRect titleBarRect, IEnumerable<TitleBarButton> buttons)
+    private unsafe void DrawTitleBarButtons()
     {
+        var window = ImGuiP.GetCurrentWindow();
+        var flags = window.Flags;
+        var titleBarRect = window.TitleBarRect();
         ImGui.PushClipRect(ImGui.GetWindowPos(), ImGui.GetWindowPos() + ImGui.GetWindowSize(), false);
 
         var style = ImGui.GetStyle();
@@ -802,26 +814,22 @@ public abstract class Window
             var max = pos + new Vector2(fontSize, fontSize);
             ImRect bb = new(pos, max);
             var isClipped = !ImGuiP.ItemAdd(bb, id, null, 0);
-            bool hovered, held;
+            bool hovered, held, pressed;
-            var pressed = false;
 
             if (this.internalIsClickthrough)
             {
-                hovered = false;
-                held = false;
-
                 // ButtonBehavior does not function if the window is clickthrough, so we have to do it ourselves
-                if (ImGui.IsMouseHoveringRect(pos, max))
+                var pad = ImGui.GetStyle().TouchExtraPadding;
-                {
+                var rect = new ImRect(pos - pad, max + pad);
-                    hovered = true;
+                hovered = rect.Contains(ImGui.GetMousePos());
+
+                // Temporarily enable inputs
+                // This will be reset on next frame, and then enabled again if it is still being hovered
+                if (hovered && ImGui.GetWindowViewport().ID != ImGui.GetMainViewport().ID)
+                    ImGui.GetWindowViewport().Flags &= ~ImGuiViewportFlags.NoInputs;
 
                 // We can't use ImGui native functions here, because they don't work with clickthrough
-                    if ((Windows.Win32.PInvoke.GetKeyState((int)VirtualKey.LBUTTON) & 0x8000) != 0)
+                pressed = held = hovered && (GetKeyState(VK.VK_LBUTTON) & 0x8000) != 0;
-                    {
-                        held = true;
-                        pressed = true;
-                    }
-                }
             }
             else
             {
@@ -850,10 +858,10 @@ public abstract class Window
             return pressed;
         }
 
-        foreach (var button in buttons.OrderBy(x => x.Priority))
+        foreach (var button in this.allButtons)
         {
             if (this.internalIsClickthrough && !button.AvailableClickthrough)
-                return;
+                continue;
 
             Vector2 position = new(titleBarRect.Max.X - padR - buttonSize, titleBarRect.Min.Y + style.FramePadding.Y);
             padR += buttonSize + style.ItemInnerSpacing.X;
@@ -897,7 +905,7 @@ public abstract class Window
     private void DrawErrorMessage()
     {
         // TODO: Once window systems are services, offer to reload the plugin
-        ImGui.TextColoredWrapped(ImGuiColors.DalamudRed,Loc.Localize("WindowSystemErrorOccurred", "An error occurred while rendering this window. Please contact the developer for details."));
+        ImGui.TextColoredWrapped(ImGuiColors.DalamudRed, Loc.Localize("WindowSystemErrorOccurred", "An error occurred while rendering this window. Please contact the developer for details."));
 
         ImGuiHelpers.ScaledDummy(5);
 
@@ -1004,7 +1012,7 @@ public abstract class Window
         /// <summary>
         /// Gets or sets an action that is called when the button is clicked.
         /// </summary>
-        public Action<ImGuiMouseButton> Click { get; set; }
+        public Action<ImGuiMouseButton>? Click { get; set; }
 
         /// <summary>
         /// Gets or sets the priority the button shall be shown in.

Dalamud/Plugin/Services/IPlayerState.cs

@@ -79,7 +79,7 @@ public interface IPlayerState : IDalamudService
     bool IsLevelSynced { get; }
 
     /// <summary>
-    /// Gets the effective level of the local character.
+    /// Gets the effective level of the local character, taking level sync into account.
     /// </summary>
     short EffectiveLevel { get; }
 

Dalamud/Plugin/Services/ITextureProvider.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Reflection;
@@ -6,6 +6,7 @@ using System.Threading;
 using System.Threading.Tasks;
 
 using Dalamud.Bindings.ImGui;
+using Dalamud.Interface.ImGuiSeStringRenderer;
 using Dalamud.Interface.Internal.Windows.Data.Widgets;
 using Dalamud.Interface.Textures;
 using Dalamud.Interface.Textures.TextureWraps;
@@ -186,6 +187,17 @@ public interface ITextureProvider : IDalamudService
         string? debugName = null,
         CancellationToken cancellationToken = default);
 
+    /// <summary>Creates a texture by drawing a SeString onto it.</summary>
+    /// <param name="text">SeString to render.</param>
+    /// <param name="drawParams">Parameters for drawing.</param>
+    /// <param name="debugName">Name for debug display purposes.</param>
+    /// <returns>The new texture.</returns>
+    /// <remarks>Can be only be used from the main thread.</remarks>
+    public IDalamudTextureWrap CreateTextureFromSeString(
+        ReadOnlySpan<byte> text,
+        scoped in SeStringDrawParams drawParams = default,
+        string? debugName = null);
+
     /// <summary>Gets the supported bitmap decoders.</summary>
     /// <returns>The supported bitmap decoders.</returns>
     /// <remarks>

Dalamud/Utility/ErrorHandling.cs

@@ -0,0 +1,21 @@
+using System.Runtime.InteropServices;
+
+namespace Dalamud.Utility;
+
+/// <summary>
+/// Utilities for handling errors inside Dalamud.
+/// </summary>
+internal static partial class ErrorHandling
+{
+    /// <summary>
+    /// Crash the game at this point, and show the crash handler with the supplied context.
+    /// </summary>
+    /// <param name="context">The context to show in the crash handler.</param>
+    public static void CrashWithContext(string context)
+    {
+        BootVehRaiseExternalEvent(context);
+    }
+
+    [LibraryImport("Dalamud.Boot.dll", EntryPoint = "BootVehRaiseExternalEventW", StringMarshalling = StringMarshalling.Utf16)]
+    private static partial void BootVehRaiseExternalEvent(string info);
+}

DalamudCrashHandler/DalamudCrashHandler.cpp

@@ -292,35 +292,43 @@ std::wstring to_address_string(const DWORD64 address, const bool try_ptrderef =
 
 void print_exception_info(HANDLE hThread, const EXCEPTION_POINTERS& ex, const CONTEXT& ctx, std::wostringstream& log) {
     std::vector<EXCEPTION_RECORD> exRecs;
-    if (ex.ExceptionRecord) {
+    if (ex.ExceptionRecord)
+    {
         size_t rec_index = 0;
         size_t read;
-        exRecs.emplace_back();
+
         for (auto pRemoteExRec = ex.ExceptionRecord;
-             pRemoteExRec
+             pRemoteExRec && rec_index < 64;
-             && rec_index < 64
+             rec_index++)
-             && ReadProcessMemory(g_hProcess, pRemoteExRec, &exRecs.back(), sizeof exRecs.back(), &read)
+        {
-             && read >= offsetof(EXCEPTION_RECORD, ExceptionInformation)
+            exRecs.emplace_back();
-             && read >= static_cast<size_t>(reinterpret_cast<const char*>(&exRecs.back().ExceptionInformation[exRecs.back().NumberParameters]) - reinterpret_cast<const char*>(&exRecs.back()));
+
-             rec_index++) {
+            if (!ReadProcessMemory(g_hProcess, pRemoteExRec, &exRecs.back(), sizeof exRecs.back(), &read)
+                || read < offsetof(EXCEPTION_RECORD, ExceptionInformation)
+                || read < static_cast<size_t>(reinterpret_cast<const char*>(&exRecs.back().ExceptionInformation[exRecs.
+                    back().NumberParameters]) - reinterpret_cast<const char*>(&exRecs.back())))
+            {
+                exRecs.pop_back();
+                break;
+            }
 
             log << std::format(L"\nException Info #{}\n", rec_index);
             log << std::format(L"Address: {:X}\n", exRecs.back().ExceptionCode);
             log << std::format(L"Flags: {:X}\n", exRecs.back().ExceptionFlags);
             log << std::format(L"Address: {:X}\n", reinterpret_cast<size_t>(exRecs.back().ExceptionAddress));
-            if (!exRecs.back().NumberParameters)
+            if (exRecs.back().NumberParameters)
-                continue;
+            {
                 log << L"Parameters: ";
-            for (DWORD i = 0; i < exRecs.back().NumberParameters; ++i) {
+                for (DWORD i = 0; i < exRecs.back().NumberParameters; ++i)
+                {
                     if (i != 0)
                         log << L", ";
                     log << std::format(L"{:X}", exRecs.back().ExceptionInformation[i]);
                 }
+            }
 
             pRemoteExRec = exRecs.back().ExceptionRecord;
-            exRecs.emplace_back();
         }
-        exRecs.pop_back();
     }
 
     log << L"\nCall Stack\n{";
@@ -930,9 +938,19 @@ int main() {
             } while (false);
         }
 
+        const bool is_external_event = exinfo.ExceptionRecord.ExceptionCode == CUSTOM_EXCEPTION_EXTERNAL_EVENT;
+
         std::wostringstream log;
+
+        if (!is_external_event)
+        {
             log << std::format(L"Unhandled native exception occurred at {}", to_address_string(exinfo.ContextRecord.Rip, false)) << std::endl;
             log << std::format(L"Code: {:X}", exinfo.ExceptionRecord.ExceptionCode) << std::endl;
+        }
+        else
+        {
+            log << L"CLR error occurred" << std::endl;
+        }
 
         if (shutup)
             log << L"======= Crash handler was globally muted(shutdown?) =======" << std::endl;
@@ -949,9 +967,19 @@ int main() {
         if (pProgressDialog)
             pProgressDialog->SetLine(3, L"Refreshing Module List", FALSE, NULL);
 
+        std::wstring window_log_str;
+
+        // Cut the log here for external events, the rest is unreadable and doesn't matter since we can't get
+        // symbols for mixed-mode stacks yet.
+        if (is_external_event)
+            window_log_str = log.str();
+
         SymRefreshModuleList(GetCurrentProcess());
         print_exception_info(exinfo.hThreadHandle, exinfo.ExceptionPointers, exinfo.ContextRecord, log);
-        const auto window_log_str = log.str();
+
+        if (!is_external_event)
+            window_log_str = log.str();
+
         print_exception_info_extended(exinfo.ExceptionPointers, exinfo.ContextRecord, log);
         std::wofstream(logPath) << log.str();
 
@@ -986,8 +1014,8 @@ int main() {
         config.pButtons = buttons;
         config.cButtons = ARRAYSIZE(buttons);
         config.nDefaultButton = IdButtonRestart;
-        config.pszExpandedControlText = L"Hide stack trace";
+        config.pszExpandedControlText = L"Hide further information";
-        config.pszCollapsedControlText = L"Stack trace for plugin developers";
+        config.pszCollapsedControlText = L"Further information for developers";
         config.pszExpandedInformation = window_log_str.c_str();
         config.pszWindowTitle = L"Dalamud Crash Handler";
         config.pRadioButtons = radios;

imgui/Dalamud.Bindings.ImGui/ImVector.cs

@@ -1,7 +1,12 @@
-using System.Runtime.CompilerServices;
+using System.Collections;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace Dalamud.Bindings.ImGui;
 
+/// <summary>
+/// A structure representing a dynamic array for unmanaged types.
+/// </summary>
 public unsafe struct ImVector
 {
     public readonly int Size;
@@ -15,23 +20,23 @@ public unsafe struct ImVector
         Data = data;
     }
 
-    public ref T Ref<T>(int index)
+    public readonly ref T Ref<T>(int index) => ref Unsafe.AsRef<T>((byte*)this.Data + (index * Unsafe.SizeOf<T>()));
-    {
-        return ref Unsafe.AsRef<T>((byte*)Data + index * Unsafe.SizeOf<T>());
-    }
 
-    public IntPtr Address<T>(int index)
+    public readonly nint Address<T>(int index) => (nint)((byte*)this.Data + (index * Unsafe.SizeOf<T>()));
-    {
-        return (IntPtr)((byte*)Data + index * Unsafe.SizeOf<T>());
-    }
 }
 
 /// <summary>
 /// A structure representing a dynamic array for unmanaged types.
 /// </summary>
 /// <typeparam name="T">The type of elements in the vector, must be unmanaged.</typeparam>
-public unsafe struct ImVector<T> where T : unmanaged
+[StructLayout(LayoutKind.Sequential)]
+public unsafe struct ImVector<T> : IEnumerable<T>
+    where T : unmanaged
 {
+    private int size;
+    private int capacity;
+    private T* data;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ImVector{T}"/> struct with the specified size, capacity, and data pointer.
     /// </summary>
@@ -45,11 +50,6 @@ public unsafe struct ImVector<T> where T : unmanaged
         this.data = data;
     }
 
-    private int size;
-    private int capacity;
-    private unsafe T* data;
-
-
     /// <summary>
     /// Gets or sets the element at the specified index.
     /// </summary>
@@ -58,80 +58,72 @@ public unsafe struct ImVector<T> where T : unmanaged
     /// <exception cref="IndexOutOfRangeException">Thrown when the index is out of range.</exception>
     public T this[int index]
     {
-        get
+        readonly get
-        {
-            if (index < 0 || index >= size)
         {
+            if (index < 0 || index >= this.size)
                 throw new IndexOutOfRangeException();
-            }
+            return this.data[index];
-            return data[index];
         }
         set
         {
-            if (index < 0 || index >= size)
+            if (index < 0 || index >= this.size)
-            {
                 throw new IndexOutOfRangeException();
-            }
+            this.data[index] = value;
-            data[index] = value;
         }
     }
 
     /// <summary>
     /// Gets a pointer to the first element of the vector.
     /// </summary>
-    public readonly T* Data => data;
+    public readonly T* Data => this.data;
 
     /// <summary>
     /// Gets a pointer to the first element of the vector.
     /// </summary>
-    public readonly T* Front => data;
+    public readonly T* Front => this.data;
 
     /// <summary>
     /// Gets a pointer to the last element of the vector.
     /// </summary>
-    public readonly T* Back => size > 0 ? data + size - 1 : null;
+    public readonly T* Back => this.size > 0 ? this.data + this.size - 1 : null;
 
     /// <summary>
     /// Gets or sets the capacity of the vector.
     /// </summary>
     public int Capacity
     {
-        readonly get => capacity;
+        readonly get => this.capacity;
         set
         {
-            if (capacity == value)
+            ArgumentOutOfRangeException.ThrowIfLessThan(value, this.size, nameof(Capacity));
-            {
+            if (this.capacity == value)
                 return;
-            }
 
-            if (data == null)
+            if (this.data == null)
             {
-                data = (T*)ImGui.MemAlloc((nuint)(value * sizeof(T)));
+                this.data = (T*)ImGui.MemAlloc((nuint)(value * sizeof(T)));
             }
             else
             {
-                int newSize = Math.Min(size, value);
+                var newSize = Math.Min(this.size, value);
-                T* newData = (T*)ImGui.MemAlloc((nuint)(value * sizeof(T)));
+                var newData = (T*)ImGui.MemAlloc((nuint)(value * sizeof(T)));
-                Buffer.MemoryCopy(data, newData, (nuint)(value * sizeof(T)), (nuint)(newSize * sizeof(T)));
+                Buffer.MemoryCopy(this.data, newData, (nuint)(value * sizeof(T)), (nuint)(newSize * sizeof(T)));
-                ImGui.MemFree(data);
+                ImGui.MemFree(this.data);
-                data = newData;
+                this.data = newData;
-                size = newSize;
+                this.size = newSize;
             }
 
-            capacity = value;
+            this.capacity = value;
 
             // Clear the rest of the data
-            for (int i = size; i < capacity; i++)
+            new Span<T>(this.data + this.size, this.capacity - this.size).Clear();
-            {
-                data[i] = default;
-            }
         }
     }
 
     /// <summary>
     /// Gets the number of elements in the vector.
     /// </summary>
-    public readonly int Size => size;
+    public readonly int Size => this.size;
 
     /// <summary>
     /// Grows the capacity of the vector to at least the specified value.
@@ -139,10 +131,8 @@ public unsafe struct ImVector<T> where T : unmanaged
     /// <param name="newCapacity">The new capacity.</param>
     public void Grow(int newCapacity)
     {
-        if (newCapacity > capacity)
+        var newCapacity2 = this.capacity > 0 ? this.capacity + (this.capacity / 2) : 8;
-        {
+        this.Capacity = newCapacity2 > newCapacity ? newCapacity2 : newCapacity;
-            Capacity = newCapacity * 2;
-        }
     }
 
     /// <summary>
@@ -151,11 +141,9 @@ public unsafe struct ImVector<T> where T : unmanaged
     /// <param name="size">The minimum capacity required.</param>
     public void EnsureCapacity(int size)
     {
-        if (size > capacity)
+        if (size > this.capacity)
-        {
             Grow(size);
     }
-    }
 
     /// <summary>
     /// Resizes the vector to the specified size.
@@ -164,25 +152,46 @@ public unsafe struct ImVector<T> where T : unmanaged
     public void Resize(int newSize)
     {
         EnsureCapacity(newSize);
-        size = newSize;
+        this.size = newSize;
     }
 
     /// <summary>
     /// Clears all elements from the vector.
     /// </summary>
-    public void Clear()
+    public void Clear() => this.size = 0;
+
+    /// <summary>
+    /// Adds an element to the end of the vector.
+    /// </summary>
+    /// <param name="value">The value to add.</param>
+    [OverloadResolutionPriority(1)]
+    public void PushBack(T value)
     {
-        size = 0;
+        this.EnsureCapacity(this.size + 1);
+        this.data[this.size++] = value;
     }
 
     /// <summary>
     /// Adds an element to the end of the vector.
     /// </summary>
     /// <param name="value">The value to add.</param>
-    public void PushBack(T value)
+    [OverloadResolutionPriority(2)]
+    public void PushBack(in T value)
     {
-        EnsureCapacity(size + 1);
+        EnsureCapacity(this.size + 1);
-        data[size++] = value;
+        this.data[this.size++] = value;
+    }
+
+    /// <summary>
+    /// Adds an element to the front of the vector.
+    /// </summary>
+    /// <param name="value">The value to add.</param>
+    public void PushFront(in T value)
+    {
+        if (this.size == 0)
+            this.PushBack(value);
+        else
+            this.Insert(0, value);
     }
 
     /// <summary>
@@ -190,48 +199,126 @@ public unsafe struct ImVector<T> where T : unmanaged
     /// </summary>
     public void PopBack()
     {
-        if (size > 0)
+        if (this.size > 0)
         {
-            size--;
+            this.size--;
         }
     }
 
+    public ref T Insert(int index, in T v) {
+        ArgumentOutOfRangeException.ThrowIfNegative(index, nameof(index));
+        ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, this.size, nameof(index));
+        this.EnsureCapacity(this.size + 1);
+        if (index < this.size)
+        {
+            Buffer.MemoryCopy(
+                this.data + index,
+                this.data + index + 1,
+                (this.size - index) * sizeof(T),
+                (this.size - index) * sizeof(T));
+        }
+
+        this.data[index] = v;
+        this.size++;
+        return ref this.data[index];
+    }
+
+    public Span<T> InsertRange(int index, ReadOnlySpan<T> v)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(index, nameof(index));
+        ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, this.size, nameof(index));
+        this.EnsureCapacity(this.size + v.Length);
+        if (index < this.size)
+        {
+            Buffer.MemoryCopy(
+                this.data + index,
+                this.data + index + v.Length,
+                (this.size - index) * sizeof(T),
+                (this.size - index) * sizeof(T));
+        }
+
+        var dstSpan = new Span<T>(this.data + index, v.Length);
+        v.CopyTo(new(this.data + index, v.Length));
+        this.size += v.Length;
+        return dstSpan;
+    }
+
     /// <summary>
     /// Frees the memory allocated for the vector.
     /// </summary>
     public void Free()
     {
-        if (data != null)
+        if (this.data != null)
         {
-            ImGui.MemFree(data);
+            ImGui.MemFree(this.data);
-            data = null;
+            this.data = null;
-            size = 0;
+            this.size = 0;
-            capacity = 0;
+            this.capacity = 0;
         }
     }
 
-    public ref T Ref(int index)
+    public readonly ref T Ref(int index)
     {
-        return ref Unsafe.AsRef<T>((byte*)Data + index * Unsafe.SizeOf<T>());
+        return ref Unsafe.AsRef<T>((byte*)Data + (index * Unsafe.SizeOf<T>()));
     }
 
-    public ref TCast Ref<TCast>(int index)
+    public readonly ref TCast Ref<TCast>(int index)
     {
-        return ref Unsafe.AsRef<TCast>((byte*)Data + index * Unsafe.SizeOf<TCast>());
+        return ref Unsafe.AsRef<TCast>((byte*)Data + (index * Unsafe.SizeOf<TCast>()));
     }
 
-    public void* Address(int index)
+    public readonly void* Address(int index)
     {
-        return (byte*)Data + index * Unsafe.SizeOf<T>();
+        return (byte*)Data + (index * Unsafe.SizeOf<T>());
     }
 
-    public void* Address<TCast>(int index)
+    public readonly void* Address<TCast>(int index)
     {
-        return (byte*)Data + index * Unsafe.SizeOf<TCast>();
+        return (byte*)Data + (index * Unsafe.SizeOf<TCast>());
     }
 
-    public ImVector* ToUntyped()
+    public readonly ImVector* ToUntyped()
     {
-        return (ImVector*)Unsafe.AsPointer(ref this);
+        return (ImVector*)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
+    }
+
+    public readonly Span<T> AsSpan() => new(this.data, this.size);
+
+    public readonly Enumerator GetEnumerator() => new(this.data, this.data + this.size);
+
+    readonly IEnumerator<T> IEnumerable<T>.GetEnumerator() => this.GetEnumerator();
+
+    readonly IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
+
+    public struct Enumerator(T* begin, T* end) : IEnumerator<T>, IEnumerable<T>
+    {
+        private T* current = null;
+
+        public readonly ref T Current => ref *this.current;
+
+        readonly T IEnumerator<T>.Current => this.Current;
+
+        readonly object IEnumerator.Current => this.Current;
+
+        public bool MoveNext()
+        {
+            var next = this.current == null ? begin : this.current + 1;
+            if (next == end)
+                return false;
+            this.current = next;
+            return true;
+        }
+
+        public void Reset() => this.current = null;
+
+        public readonly Enumerator GetEnumerator() => new(begin, end);
+
+        readonly void IDisposable.Dispose()
+        {
+        }
+
+        readonly IEnumerator<T> IEnumerable<T>.GetEnumerator() => this.GetEnumerator();
+
+        readonly IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
     }
 }

lib/FFXIVClientStructs

@@ -1 +1 @@
-Subproject commit e5f586630ef06fa48d5dc0d8c0fa679323093c77
+Subproject commit 6f339d8f725fa6922449f7e5c584ca6b8fa2fb19

lib/cimgui

@@ -1 +1 @@
-Subproject commit 27c8565f631b004c3266373890e41ecc627f775b
+Subproject commit bc327296758d57d3bdc963cb6ce71dd5b0c7e54c