JonKazama-Hellion
d5735d8dcc
Smoke-test round 4 surfaced a clean reproducer: a Party or Linkshell tab with channel /p, then Settings → Save, popped the input back to /tell <pinned-partner> on the next interaction. Two bugs combined: 1. Configuration.UpdateFrom captured only Messages+LastSendUnread from the live state during the persistent-tab merge. CurrentChannel was not preserved, so a Settings save overwrote the runtime channel state with the settings-time snapshot. If the user switched channel in-game between Settings-open and Settings-save, that switch was lost. Live CurrentChannel now joins Messages and LastSendUnread in the per-Identifier preservation tuple. 2. TabSwitched seeded a new tab's CurrentChannel from previousTab via reference copy (`newTab.CurrentChannel = previousTab.CurrentChannel`). That left both tabs sharing the same UsedChannel instance, so a later mutation on one bled into the other — exactly the path that carried a pinned tell-target onto Party. Switched to a deep clone (UsedChannel.Clone(), same Cherry-Pick-Patch-B pattern from v1.4.6) plus a Debug log so the next smoke can confirm at a glance which previous tab donated its channel state. Pre-existing ChatTwo upstream pattern; v1.4.7 just made it visible because pinned tabs are now the kind of long-lived tell-target that sticks around for the seed path to grab.
929 lines
32 KiB
C#
Executable File
929 lines
32 KiB
C#
Executable File
using System.Collections;
|
||
using Dalamud;
|
||
using Dalamud.Bindings.ImGui;
|
||
using Dalamud.Configuration;
|
||
using Dalamud.Game.ClientState.Keys;
|
||
using Dalamud.Game.Text.SeStringHandling.Payloads;
|
||
using Dalamud.Interface.FontIdentifier;
|
||
using HellionChat.Code;
|
||
using HellionChat.GameFunctions.Types;
|
||
using HellionChat.Resources;
|
||
using HellionChat.Util;
|
||
|
||
namespace HellionChat;
|
||
|
||
[Serializable]
|
||
public class ConfigKeyBind
|
||
{
|
||
public ModifierFlag Modifier;
|
||
public VirtualKey Key;
|
||
|
||
public override string ToString()
|
||
{
|
||
var modString = "";
|
||
if (Modifier.HasFlag(ModifierFlag.Ctrl))
|
||
modString += Language.Keybind_Modifier_Ctrl + " + ";
|
||
if (Modifier.HasFlag(ModifierFlag.Shift))
|
||
modString += Language.Keybind_Modifier_Shift + " + ";
|
||
if (Modifier.HasFlag(ModifierFlag.Alt))
|
||
modString += Language.Keybind_Modifier_Alt + " + ";
|
||
return modString + Key.GetFancyName();
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public class Configuration : IPluginConfiguration
|
||
{
|
||
private const int LatestVersion = 17;
|
||
|
||
public int Version { get; set; } = LatestVersion;
|
||
|
||
// Slug-based; ThemeRegistry resolves the object at runtime.
|
||
public string Theme = "hellion-arctic";
|
||
|
||
// Global window opacity, applied across all themes.
|
||
public float WindowOpacity = 0.85f;
|
||
|
||
// Reserved for future UI toggles; pre-declared to avoid a migration later.
|
||
public bool ReduceMotion;
|
||
|
||
// v1.2.1: default flipped false → true. Compact single-line layout is
|
||
// more readable than the card-rows layout introduced in v1.2.0.
|
||
public bool UseCompactDensity = true;
|
||
|
||
// Privacy by Default master switch. Set false to restore upstream behaviour.
|
||
public bool PrivacyFilterEnabled = true;
|
||
|
||
// Empty set means the migration has not run yet — see Plugin.cs v6→v7.
|
||
public HashSet<ChatType> PrivacyPersistChannels = [];
|
||
|
||
// Failsafe for ChatTypes added by future FFXIV patches. New configs default
|
||
// to the failsafe via PrivacyDefaults; existing configs keep their saved
|
||
// choice because the deserializer overrides this initializer.
|
||
public bool PrivacyPersistUnknownChannels = Privacy
|
||
.PrivacyDefaults
|
||
.DefaultPersistUnknownChannels;
|
||
|
||
// F3.2: dedup unknown-ChatType warnings so a chatty filter doesn't spam
|
||
// the log every frame. NonSerialized so the warning fires once per
|
||
// runtime, not once-ever-per-install.
|
||
[NonSerialized]
|
||
private readonly HashSet<ChatType> _warnedUnknownChannels = new();
|
||
|
||
public bool IsAllowedForStorage(ChatType type)
|
||
{
|
||
if (!PrivacyFilterEnabled)
|
||
return true;
|
||
if (PrivacyPersistChannels.Contains(type))
|
||
return true;
|
||
|
||
// F3.2: log first occurrence of a ChatType the running build doesn't
|
||
// recognise — i.e. one a future FFXIV patch may have added. Known
|
||
// types the user opted out of are routed through the failsafe
|
||
// silently, like before.
|
||
if (!Enum.IsDefined(typeof(ChatType), type) && _warnedUnknownChannels.Add(type))
|
||
{
|
||
Plugin.LogProxy.Warning(
|
||
"PrivacyFilter: unrecognised ChatType {Type} — falling back to PrivacyPersistUnknownChannels={Persist}.",
|
||
type,
|
||
PrivacyPersistUnknownChannels
|
||
);
|
||
}
|
||
|
||
return PrivacyPersistUnknownChannels;
|
||
}
|
||
|
||
// Retention master switch defaults to false — plugin will not delete
|
||
// history until the user explicitly opts in.
|
||
public bool RetentionEnabled;
|
||
public int RetentionDefaultDays = 30;
|
||
public Dictionary<ChatType, int> RetentionPerChannelDays = [];
|
||
public DateTimeOffset RetentionLastRunAt = DateTimeOffset.MinValue;
|
||
public bool FirstRunCompleted;
|
||
public bool UseHellionFont = true;
|
||
public bool ShowHonorificTitleInHeader = true;
|
||
|
||
// v1.4.7 opt-in: renders the Honorific glow outline when the title carries
|
||
// a Glow colour. Default OFF — keeps v1.4.6 visuals untouched for users
|
||
// who don't care, and dodges the per-frame DrawList overhead on low-end
|
||
// hardware. Gradient (Color3 / GradientColourSet) is parsed but rendered
|
||
// as the primary Color until a later cycle ports the animation.
|
||
public bool ShowHonorificGlow;
|
||
public bool EnableAutoTellTabs = true;
|
||
public int AutoTellTabsLimit = 15;
|
||
public bool AutoTellTabsCompactDisplay;
|
||
public int AutoTellTabsHistoryPreload = 20;
|
||
|
||
// Sidebar width in pixels. Default 44 mirrors the icon-only layout from
|
||
// v1.2.0; users can widen up to 160 to fit a section-header line like
|
||
// "Active Tells (3)" without truncation.
|
||
public int SidebarWidth = 44;
|
||
public bool AutoTellTabsShowGreetedToggle;
|
||
public bool SeenPopOutInputHint;
|
||
public bool PopOutInputEnabled = true;
|
||
public bool SeenPopOutHeaderHint;
|
||
public bool AutoTellTabsOpenAsPopout;
|
||
|
||
public int GetRetentionDays(ChatType type)
|
||
{
|
||
if (RetentionPerChannelDays.TryGetValue(type, out var userOverride))
|
||
return userOverride;
|
||
if (Privacy.PrivacyDefaults.DefaultRetentionDays.TryGetValue(type, out var specDefault))
|
||
return specDefault;
|
||
return RetentionDefaultDays;
|
||
}
|
||
|
||
public bool HideChat = true;
|
||
public bool HideDuringCutscenes = true;
|
||
public bool HideWhenNotLoggedIn = true;
|
||
public bool HideWhenUiHidden = true;
|
||
public bool HideInLoadingScreens;
|
||
public bool HideInBattle;
|
||
|
||
// v1.2.1: default flipped false → true for consistency with other hide defaults.
|
||
public bool HideInNewGamePlusMenu = true;
|
||
public bool HideWhenInactive;
|
||
public int InactivityHideTimeout = 10;
|
||
public bool InactivityHideActiveDuringBattle = true;
|
||
|
||
[Obsolete("Use InactivityHideChannelsV2 instead")]
|
||
public Dictionary<ChatType, ChatSource> InactivityHideChannels = [];
|
||
|
||
public Dictionary<ChatType, (ChatSource, ChatSource)> InactivityHideChannelsV2 = [];
|
||
public bool InactivityHideExtraChatAll = true;
|
||
public HashSet<Guid> InactivityHideExtraChatChannels = [];
|
||
public bool ShowHideButton = true;
|
||
public bool NativeItemTooltips = true;
|
||
public bool PrettierTimestamps = true;
|
||
public bool MoreCompactPretty;
|
||
public bool HideSameTimestamps = true;
|
||
public bool ShowNoviceNetwork;
|
||
public bool SidebarTabView = true;
|
||
public bool PrintChangelog = true;
|
||
public bool OnlyPreviewIf;
|
||
public int PreviewMinimum = 1;
|
||
public PreviewPosition PreviewPosition = PreviewPosition.Inside;
|
||
public CommandHelpSide CommandHelpSide = CommandHelpSide.None;
|
||
public KeybindMode KeybindMode = KeybindMode.Strict;
|
||
public LanguageOverride LanguageOverride = LanguageOverride.None;
|
||
public bool CanMove = true;
|
||
public bool CanResize = true;
|
||
public bool ShowTitleBar = true;
|
||
public bool ShowPopOutTitleBar = true;
|
||
public bool DatabaseBattleMessages;
|
||
public bool LoadPreviousSession;
|
||
public bool FilterIncludePreviousSessions;
|
||
public bool SortAutoTranslate;
|
||
public bool CollapseDuplicateMessages;
|
||
public bool CollapseKeepUniqueLinks;
|
||
public bool PlaySounds = true;
|
||
public bool KeepInputFocus = true;
|
||
public int MaxLinesToRender = 2_500; // 1-10000
|
||
public bool Use24HourClock = true;
|
||
public bool ShowEmotes = true;
|
||
public HashSet<string> BlockedEmotes = [];
|
||
public bool FontsEnabled = true;
|
||
public ExtraGlyphRanges ExtraGlyphRanges = 0;
|
||
public float FontSizeV2 = 12.75f;
|
||
public float SymbolsFontSizeV2 = 12.75f;
|
||
public SingleFontSpec GlobalFontV2 = new()
|
||
{
|
||
// dalamud only ships KR as regular, which chat2 used previously for global fonts
|
||
FontId = new DalamudAssetFontAndFamilyId(DalamudAsset.NotoSansCjkRegular),
|
||
SizePt = 12.75f,
|
||
};
|
||
public SingleFontSpec JapaneseFontV2 = new()
|
||
{
|
||
FontId = new DalamudAssetFontAndFamilyId(DalamudAsset.NotoSansCjkMedium),
|
||
SizePt = 12.75f,
|
||
};
|
||
public bool ItalicEnabled;
|
||
public SingleFontSpec ItalicFontV2 = new()
|
||
{
|
||
FontId = new DalamudAssetFontAndFamilyId(DalamudAsset.NotoSansCjkRegular),
|
||
SizePt = 12.75f,
|
||
};
|
||
|
||
public float TooltipOffset;
|
||
|
||
public Dictionary<ChatType, uint> ChatColours = BuildDefaultChatColours();
|
||
|
||
private static Dictionary<ChatType, uint> BuildDefaultChatColours()
|
||
{
|
||
var defaults = new Dictionary<ChatType, uint>();
|
||
foreach (
|
||
var (channel, colour) in HellionChat.Resources.ChatColourPresets.All["Hellion"].Colours
|
||
)
|
||
defaults[channel] = colour;
|
||
return defaults;
|
||
}
|
||
|
||
public bool ColorSelectedInputChannelButton = true;
|
||
public List<Tab> Tabs = [];
|
||
|
||
public ConfigKeyBind? ChatTabForward;
|
||
public ConfigKeyBind? ChatTabBackward;
|
||
|
||
public void UpdateFrom(Configuration other, bool backToOriginal)
|
||
{
|
||
if (backToOriginal)
|
||
foreach (var tab in Tabs.Where(t => t.PopOut))
|
||
tab.PopOut = false;
|
||
|
||
HideChat = other.HideChat;
|
||
HideDuringCutscenes = other.HideDuringCutscenes;
|
||
HideWhenNotLoggedIn = other.HideWhenNotLoggedIn;
|
||
HideWhenUiHidden = other.HideWhenUiHidden;
|
||
HideInLoadingScreens = other.HideInLoadingScreens;
|
||
HideInBattle = other.HideInBattle;
|
||
HideInNewGamePlusMenu = other.HideInNewGamePlusMenu;
|
||
HideWhenInactive = other.HideWhenInactive;
|
||
InactivityHideTimeout = other.InactivityHideTimeout;
|
||
InactivityHideActiveDuringBattle = other.InactivityHideActiveDuringBattle;
|
||
InactivityHideChannelsV2 = other.InactivityHideChannelsV2.ToDictionary(
|
||
pair => pair.Key,
|
||
pair => pair.Value
|
||
);
|
||
InactivityHideExtraChatAll = other.InactivityHideExtraChatAll;
|
||
InactivityHideExtraChatChannels = other.InactivityHideExtraChatChannels.ToHashSet();
|
||
ShowHideButton = other.ShowHideButton;
|
||
NativeItemTooltips = other.NativeItemTooltips;
|
||
PrettierTimestamps = other.PrettierTimestamps;
|
||
MoreCompactPretty = other.MoreCompactPretty;
|
||
HideSameTimestamps = other.HideSameTimestamps;
|
||
ShowNoviceNetwork = other.ShowNoviceNetwork;
|
||
SidebarTabView = other.SidebarTabView;
|
||
PrintChangelog = other.PrintChangelog;
|
||
OnlyPreviewIf = other.OnlyPreviewIf;
|
||
PreviewMinimum = other.PreviewMinimum;
|
||
PreviewPosition = other.PreviewPosition;
|
||
CommandHelpSide = other.CommandHelpSide;
|
||
KeybindMode = other.KeybindMode;
|
||
LanguageOverride = other.LanguageOverride;
|
||
CanMove = other.CanMove;
|
||
CanResize = other.CanResize;
|
||
ShowTitleBar = other.ShowTitleBar;
|
||
ShowPopOutTitleBar = other.ShowPopOutTitleBar;
|
||
DatabaseBattleMessages = other.DatabaseBattleMessages;
|
||
LoadPreviousSession = other.LoadPreviousSession;
|
||
FilterIncludePreviousSessions = other.FilterIncludePreviousSessions;
|
||
SortAutoTranslate = other.SortAutoTranslate;
|
||
CollapseDuplicateMessages = other.CollapseDuplicateMessages;
|
||
CollapseKeepUniqueLinks = other.CollapseKeepUniqueLinks;
|
||
PlaySounds = other.PlaySounds;
|
||
KeepInputFocus = other.KeepInputFocus;
|
||
MaxLinesToRender = other.MaxLinesToRender;
|
||
Use24HourClock = other.Use24HourClock;
|
||
ShowEmotes = other.ShowEmotes;
|
||
// Deep-copy so settings window edits don't leak into live config before Save.
|
||
BlockedEmotes = new HashSet<string>(other.BlockedEmotes);
|
||
FontsEnabled = other.FontsEnabled;
|
||
ItalicEnabled = other.ItalicEnabled;
|
||
ExtraGlyphRanges = other.ExtraGlyphRanges;
|
||
FontSizeV2 = other.FontSizeV2;
|
||
GlobalFontV2 = other.GlobalFontV2;
|
||
JapaneseFontV2 = other.JapaneseFontV2;
|
||
ItalicFontV2 = other.ItalicFontV2;
|
||
SymbolsFontSizeV2 = other.SymbolsFontSizeV2;
|
||
TooltipOffset = other.TooltipOffset;
|
||
ChatColours = other.ChatColours.ToDictionary(entry => entry.Key, entry => entry.Value);
|
||
ColorSelectedInputChannelButton = other.ColorSelectedInputChannelButton;
|
||
|
||
// Keep live temp tabs alive across UpdateFrom — a settings save must
|
||
// not destroy open tell conversations. Pinned TempTabs are persistent
|
||
// and come through `other` like regular tabs; unpinned TempTabs are
|
||
// session-only and held from the local state. For persistent tabs
|
||
// (incl. pinned), capture live runtime state by Identifier and restore
|
||
// it onto the freshly cloned tabs — CurrentChannel is critical because
|
||
// the user may have switched channel in-game between settings-open
|
||
// and settings-save, and we'd otherwise overwrite that with the
|
||
// settings-time snapshot.
|
||
var liveUnpinnedTempTabs = Tabs.Where(TabLifecycleHelpers.IsInUnpinnedPool).ToList();
|
||
var livePersistentSession = Tabs.Where(t => !TabLifecycleHelpers.IsInUnpinnedPool(t))
|
||
.ToDictionary(t => t.Identifier, t => (t.Messages, t.LastSendUnread, t.CurrentChannel));
|
||
|
||
Tabs = other
|
||
.Tabs.Where(t => !t.IsTempTab || t.IsPinned)
|
||
.Select(t =>
|
||
{
|
||
var clone = t.Clone();
|
||
if (livePersistentSession.TryGetValue(clone.Identifier, out var live))
|
||
{
|
||
clone.Messages = live.Messages;
|
||
clone.LastSendUnread = live.LastSendUnread;
|
||
clone.CurrentChannel = live.CurrentChannel;
|
||
}
|
||
return clone;
|
||
})
|
||
.ToList();
|
||
Tabs.AddRange(liveUnpinnedTempTabs);
|
||
|
||
ChatTabForward = other.ChatTabForward;
|
||
ChatTabBackward = other.ChatTabBackward;
|
||
|
||
PrivacyFilterEnabled = other.PrivacyFilterEnabled;
|
||
PrivacyPersistChannels = [.. other.PrivacyPersistChannels];
|
||
PrivacyPersistUnknownChannels = other.PrivacyPersistUnknownChannels;
|
||
|
||
RetentionEnabled = other.RetentionEnabled;
|
||
RetentionDefaultDays = other.RetentionDefaultDays;
|
||
RetentionPerChannelDays = other.RetentionPerChannelDays.ToDictionary(
|
||
p => p.Key,
|
||
p => p.Value
|
||
);
|
||
RetentionLastRunAt = other.RetentionLastRunAt;
|
||
|
||
FirstRunCompleted = other.FirstRunCompleted;
|
||
UseHellionFont = other.UseHellionFont;
|
||
ShowHonorificTitleInHeader = other.ShowHonorificTitleInHeader;
|
||
ShowHonorificGlow = other.ShowHonorificGlow;
|
||
|
||
// v1.1.0 theme engine fields
|
||
Theme = other.Theme;
|
||
WindowOpacity = other.WindowOpacity;
|
||
ReduceMotion = other.ReduceMotion;
|
||
UseCompactDensity = other.UseCompactDensity;
|
||
|
||
EnableAutoTellTabs = other.EnableAutoTellTabs;
|
||
AutoTellTabsLimit = other.AutoTellTabsLimit;
|
||
AutoTellTabsCompactDisplay = other.AutoTellTabsCompactDisplay;
|
||
AutoTellTabsHistoryPreload = other.AutoTellTabsHistoryPreload;
|
||
SidebarWidth = other.SidebarWidth;
|
||
AutoTellTabsShowGreetedToggle = other.AutoTellTabsShowGreetedToggle;
|
||
|
||
SeenPopOutInputHint = other.SeenPopOutInputHint;
|
||
PopOutInputEnabled = other.PopOutInputEnabled;
|
||
SeenPopOutHeaderHint = other.SeenPopOutHeaderHint;
|
||
AutoTellTabsOpenAsPopout = other.AutoTellTabsOpenAsPopout;
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public enum UnreadMode
|
||
{
|
||
All,
|
||
Unseen,
|
||
None,
|
||
}
|
||
|
||
public static class UnreadModeExt
|
||
{
|
||
internal static string Name(this UnreadMode mode) =>
|
||
mode switch
|
||
{
|
||
UnreadMode.All => Language.UnreadMode_All,
|
||
UnreadMode.Unseen => Language.UnreadMode_Unseen,
|
||
UnreadMode.None => Language.UnreadMode_None,
|
||
_ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null),
|
||
};
|
||
|
||
internal static string? Tooltip(this UnreadMode mode) =>
|
||
mode switch
|
||
{
|
||
UnreadMode.All => Language.UnreadMode_All_Tooltip,
|
||
UnreadMode.Unseen => Language.UnreadMode_Unseen_Tooltip,
|
||
UnreadMode.None => Language.UnreadMode_None_Tooltip,
|
||
_ => null,
|
||
};
|
||
}
|
||
|
||
[Serializable]
|
||
public class Tab
|
||
{
|
||
public string Name = Language.Tab_DefaultName;
|
||
|
||
// Optional FontAwesome glyph name; null falls back to TabIconMapping default.
|
||
public string? Icon = null;
|
||
|
||
[Obsolete("Removed in favor of SelectedChannels")]
|
||
public Dictionary<ChatType, ChatSource> ChatCodes = new();
|
||
|
||
public Dictionary<ChatType, (ChatSource, ChatSource)> SelectedChannels = new();
|
||
public bool ExtraChatAll;
|
||
public HashSet<Guid> ExtraChatChannels = [];
|
||
|
||
public UnreadMode UnreadMode = UnreadMode.Unseen;
|
||
public bool UnhideOnActivity;
|
||
public bool DisplayTimestamp = true;
|
||
public InputChannel? Channel;
|
||
public bool PopOut;
|
||
public bool IndependentOpacity;
|
||
public float Opacity = 100f;
|
||
public bool InputDisabled;
|
||
|
||
public bool CanMove = true;
|
||
public bool CanResize = true;
|
||
|
||
public bool IndependentHide;
|
||
public bool HideDuringCutscenes = true;
|
||
public bool HideWhenNotLoggedIn = true;
|
||
public bool HideWhenUiHidden = true;
|
||
public bool HideInLoadingScreens;
|
||
public bool HideInBattle;
|
||
public bool HideWhenInactive;
|
||
|
||
public bool IsTempTab;
|
||
|
||
// Pinned TempTabs survive plugin reload and logout — tester feedback from
|
||
// Jin (v1.4.7). Pinned tabs live in their own pool (MaxPinnedTempTabs)
|
||
// separate from the AutoTellTabsLimit bucket.
|
||
public bool IsPinned;
|
||
public bool AllSenderMessages;
|
||
public TellTarget TellTarget = TellTarget.Empty();
|
||
|
||
[NonSerialized]
|
||
public uint Unread;
|
||
|
||
[NonSerialized]
|
||
public uint LastSendUnread;
|
||
|
||
[NonSerialized]
|
||
public long LastActivity;
|
||
|
||
[NonSerialized]
|
||
public MessageList Messages = new();
|
||
|
||
[NonSerialized]
|
||
public UsedChannel CurrentChannel = new();
|
||
|
||
[NonSerialized]
|
||
public Guid Identifier = Guid.NewGuid();
|
||
|
||
// Session-only greeted flag for club-greeter workflows.
|
||
[NonSerialized]
|
||
public bool IsGreeted;
|
||
|
||
// Separate validation keys per cache so TellTarget changes don't
|
||
// cause GetTint and GetIcon to strand each other with stale entries.
|
||
[NonSerialized]
|
||
internal string? _cachedTintTellName;
|
||
|
||
[NonSerialized]
|
||
internal uint _cachedTintTellWorld;
|
||
|
||
[NonSerialized]
|
||
internal uint _cachedTellTint;
|
||
|
||
[NonSerialized]
|
||
internal string? _cachedIconTellName;
|
||
|
||
[NonSerialized]
|
||
internal uint _cachedIconTellWorld;
|
||
|
||
[NonSerialized]
|
||
internal string? _cachedTellIcon;
|
||
|
||
public bool Matches(Message message)
|
||
{
|
||
if (!message.Matches(SelectedChannels, ExtraChatAll, ExtraChatChannels))
|
||
return false;
|
||
|
||
// Temp tabs are bound to a single conversation partner — other tells
|
||
// matching the channel filter must not land here.
|
||
if (IsTempTab && TellTarget?.IsSet() == true)
|
||
return ChunkUtil.MatchesSender(message, TellTarget.Name, TellTarget.World);
|
||
|
||
return true;
|
||
}
|
||
|
||
public void AddMessage(Message message, bool unread = true)
|
||
{
|
||
Messages.AddPrune(message, MessageManager.MessageDisplayLimit);
|
||
if (!unread)
|
||
return;
|
||
|
||
Unread += 1;
|
||
if (
|
||
message.Matches(
|
||
Plugin.Config.InactivityHideChannelsV2,
|
||
Plugin.Config.InactivityHideExtraChatAll,
|
||
Plugin.Config.InactivityHideExtraChatChannels
|
||
)
|
||
)
|
||
LastActivity = Environment.TickCount64;
|
||
}
|
||
|
||
public void Clear() => Messages.Clear();
|
||
|
||
public Tab Clone()
|
||
{
|
||
return new Tab
|
||
{
|
||
Name = Name,
|
||
SelectedChannels = SelectedChannels.ToDictionary(pair => pair.Key, pair => pair.Value),
|
||
ExtraChatAll = ExtraChatAll,
|
||
ExtraChatChannels = ExtraChatChannels.ToHashSet(),
|
||
UnreadMode = UnreadMode,
|
||
UnhideOnActivity = UnhideOnActivity,
|
||
Unread = Unread,
|
||
LastActivity = LastActivity,
|
||
DisplayTimestamp = DisplayTimestamp,
|
||
Channel = Channel,
|
||
PopOut = PopOut,
|
||
IndependentOpacity = IndependentOpacity,
|
||
Opacity = Opacity,
|
||
Identifier = Identifier,
|
||
InputDisabled = InputDisabled,
|
||
CurrentChannel = CurrentChannel.Clone(),
|
||
CanMove = CanMove,
|
||
CanResize = CanResize,
|
||
IndependentHide = IndependentHide,
|
||
HideDuringCutscenes = HideDuringCutscenes,
|
||
HideWhenNotLoggedIn = HideWhenNotLoggedIn,
|
||
HideWhenUiHidden = HideWhenUiHidden,
|
||
HideInLoadingScreens = HideInLoadingScreens,
|
||
HideInBattle = HideInBattle,
|
||
HideWhenInactive = HideWhenInactive,
|
||
IsTempTab = IsTempTab,
|
||
IsPinned = IsPinned,
|
||
AllSenderMessages = AllSenderMessages,
|
||
TellTarget = TellTarget.Clone(),
|
||
IsGreeted = IsGreeted,
|
||
};
|
||
}
|
||
|
||
/// Ordered message list with duplicate ID tracking, sorting and mutex protection.
|
||
public class MessageList
|
||
{
|
||
private readonly SemaphoreSlim LockSlim = new(1, 1);
|
||
|
||
private readonly List<Message> Messages;
|
||
private readonly HashSet<Guid> TrackedMessageIds;
|
||
|
||
public MessageList()
|
||
{
|
||
Messages = [];
|
||
TrackedMessageIds = [];
|
||
}
|
||
|
||
public MessageList(int initialCapacity)
|
||
{
|
||
Messages = new List<Message>(initialCapacity);
|
||
TrackedMessageIds = new HashSet<Guid>(initialCapacity);
|
||
}
|
||
|
||
public void AddPrune(Message message, int max)
|
||
{
|
||
LockSlim.Wait(-1);
|
||
try
|
||
{
|
||
AddLocked(message);
|
||
PruneMaxLocked(max);
|
||
}
|
||
finally
|
||
{
|
||
LockSlim.Release();
|
||
}
|
||
}
|
||
|
||
public void AddSortPrune(IEnumerable<Message> messages, int max)
|
||
{
|
||
LockSlim.Wait(-1);
|
||
try
|
||
{
|
||
foreach (var message in messages)
|
||
AddLocked(message);
|
||
|
||
SortLocked();
|
||
PruneMaxLocked(max);
|
||
}
|
||
finally
|
||
{
|
||
LockSlim.Release();
|
||
}
|
||
}
|
||
|
||
private void AddLocked(Message message)
|
||
{
|
||
if (TrackedMessageIds.Contains(message.Id))
|
||
return;
|
||
|
||
Messages.Add(message);
|
||
TrackedMessageIds.Add(message.Id);
|
||
}
|
||
|
||
public void Clear()
|
||
{
|
||
LockSlim.Wait(-1);
|
||
try
|
||
{
|
||
Messages.Clear();
|
||
TrackedMessageIds.Clear();
|
||
}
|
||
finally
|
||
{
|
||
LockSlim.Release();
|
||
}
|
||
}
|
||
|
||
private void SortLocked()
|
||
{
|
||
Messages.Sort((a, b) => a.Date.CompareTo(b.Date));
|
||
}
|
||
|
||
private void PruneMaxLocked(int max)
|
||
{
|
||
while (Messages.Count > max)
|
||
{
|
||
TrackedMessageIds.Remove(Messages[0].Id);
|
||
Messages.RemoveAt(0);
|
||
}
|
||
}
|
||
|
||
/// Current message count. Lock-per-read is acceptable for 1×/sec status bar polling.
|
||
public int Count
|
||
{
|
||
get
|
||
{
|
||
LockSlim.Wait(-1);
|
||
try
|
||
{
|
||
return Messages.Count;
|
||
}
|
||
finally
|
||
{
|
||
LockSlim.Release();
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Returns an array copy of the message list for usage outside of main thread.
|
||
public async Task<Message[]> GetCopy(int millisecondsTimeout = -1)
|
||
{
|
||
await LockSlim.WaitAsync(millisecondsTimeout);
|
||
try
|
||
{
|
||
return Messages.ToArray();
|
||
}
|
||
finally
|
||
{
|
||
LockSlim.Release();
|
||
}
|
||
}
|
||
|
||
/// Returns a read-only list while holding a reader lock. Use with a using statement.
|
||
public RLockedMessageList GetReadOnly(int millisecondsTimeout = -1)
|
||
{
|
||
LockSlim.Wait(millisecondsTimeout);
|
||
return new RLockedMessageList(LockSlim, Messages);
|
||
}
|
||
|
||
public class RLockedMessageList(SemaphoreSlim lockSlim, List<Message> messages)
|
||
: IReadOnlyList<Message>,
|
||
IDisposable
|
||
{
|
||
public IEnumerator<Message> GetEnumerator()
|
||
{
|
||
return messages.GetEnumerator();
|
||
}
|
||
|
||
IEnumerator IEnumerable.GetEnumerator()
|
||
{
|
||
return GetEnumerator();
|
||
}
|
||
|
||
public int Count => messages.Count;
|
||
|
||
public Message this[int index] => messages[index];
|
||
|
||
public void Dispose()
|
||
{
|
||
lockSlim.Release();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public class UsedChannel
|
||
{
|
||
public InputChannel Channel = InputChannel.Invalid;
|
||
public List<Chunk> Name = [];
|
||
public TellTarget? TellTarget;
|
||
|
||
public bool UseTempChannel;
|
||
public InputChannel TempChannel = InputChannel.Invalid;
|
||
public TellTarget? TempTellTarget;
|
||
|
||
public void ResetTempChannel()
|
||
{
|
||
UseTempChannel = false;
|
||
TempTellTarget = null;
|
||
TempChannel = InputChannel.Invalid;
|
||
}
|
||
|
||
public void SetChannel(InputChannel channel)
|
||
{
|
||
Channel = channel;
|
||
}
|
||
|
||
// ---------------------------------------------------------------
|
||
// Cherry-picked from ChatTwo upstream f35b7d3 (Infiziert90, 2026-05-12)
|
||
// - Deep-clone the UsedChannel so Tab.Clone() no longer shares
|
||
// channel state (incl. TellTarget) with its origin Tab. Previously
|
||
// a reference copy: PopOut and Temp tabs mutated each other.
|
||
// - Name is intentionally a reference copy (matches upstream); it
|
||
// gets reassigned on every channel switch anyway.
|
||
// TEST-MIRROR: ../../Hellion Build test/_Helpers/UsedChannelCloneTests.cs
|
||
// ---------------------------------------------------------------
|
||
public UsedChannel Clone()
|
||
{
|
||
return new UsedChannel
|
||
{
|
||
Channel = Channel,
|
||
Name = Name,
|
||
TellTarget = TellTarget?.Clone(),
|
||
|
||
UseTempChannel = UseTempChannel,
|
||
TempChannel = TempChannel,
|
||
TempTellTarget = TempTellTarget?.Clone(),
|
||
};
|
||
}
|
||
}
|
||
|
||
[Serializable]
|
||
public enum PreviewPosition
|
||
{
|
||
None,
|
||
Inside,
|
||
Top,
|
||
Bottom,
|
||
Tooltip,
|
||
}
|
||
|
||
public static class PreviewPositionExt
|
||
{
|
||
public static string Name(this PreviewPosition position) =>
|
||
position switch
|
||
{
|
||
PreviewPosition.None => Language.Options_Preview_None,
|
||
PreviewPosition.Inside => Language.Options_Preview_Inside,
|
||
PreviewPosition.Top => Language.Options_Preview_Top,
|
||
PreviewPosition.Bottom => Language.Options_Preview_Bottom,
|
||
PreviewPosition.Tooltip => Language.Options_Preview_Tooltip,
|
||
_ => throw new ArgumentOutOfRangeException(nameof(position), position, null),
|
||
};
|
||
}
|
||
|
||
[Serializable]
|
||
public enum CommandHelpSide
|
||
{
|
||
None,
|
||
Left,
|
||
Right,
|
||
}
|
||
|
||
public static class CommandHelpSideExt
|
||
{
|
||
public static string Name(this CommandHelpSide side) =>
|
||
side switch
|
||
{
|
||
CommandHelpSide.None => Language.CommandHelpSide_None,
|
||
CommandHelpSide.Left => Language.CommandHelpSide_Left,
|
||
CommandHelpSide.Right => Language.CommandHelpSide_Right,
|
||
_ => throw new ArgumentOutOfRangeException(nameof(side), side, null),
|
||
};
|
||
}
|
||
|
||
[Serializable]
|
||
public enum KeybindMode
|
||
{
|
||
Flexible,
|
||
Strict,
|
||
}
|
||
|
||
public static class KeybindModeExt
|
||
{
|
||
public static string Name(this KeybindMode mode) =>
|
||
mode switch
|
||
{
|
||
KeybindMode.Flexible => Language.KeybindMode_Flexible_Name,
|
||
KeybindMode.Strict => Language.KeybindMode_Strict_Name,
|
||
_ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null),
|
||
};
|
||
|
||
public static string? Tooltip(this KeybindMode mode) =>
|
||
mode switch
|
||
{
|
||
KeybindMode.Flexible => Language.KeybindMode_Flexible_Tooltip,
|
||
KeybindMode.Strict => Language.KeybindMode_Strict_Tooltip,
|
||
_ => null,
|
||
};
|
||
}
|
||
|
||
[Serializable]
|
||
public enum LanguageOverride
|
||
{
|
||
None,
|
||
ChineseSimplified,
|
||
ChineseTraditional,
|
||
Dutch,
|
||
English,
|
||
French,
|
||
German,
|
||
Greek,
|
||
|
||
// Italian,
|
||
Japanese,
|
||
|
||
// Korean,
|
||
// Norwegian,
|
||
PortugueseBrazil,
|
||
Romanian,
|
||
Russian,
|
||
Spanish,
|
||
Swedish,
|
||
}
|
||
|
||
public static class LanguageOverrideExt
|
||
{
|
||
public static string Name(this LanguageOverride mode) =>
|
||
mode switch
|
||
{
|
||
LanguageOverride.None => Language.LanguageOverride_None,
|
||
LanguageOverride.ChineseSimplified => "简体中文",
|
||
LanguageOverride.ChineseTraditional => "繁體中文",
|
||
LanguageOverride.Dutch => "Nederlands",
|
||
LanguageOverride.English => "English",
|
||
LanguageOverride.French => "Français",
|
||
LanguageOverride.German => "Deutsch",
|
||
LanguageOverride.Greek => "Ελληνικά",
|
||
// LanguageOverride.Italian => "Italiano",
|
||
LanguageOverride.Japanese => "日本語",
|
||
// LanguageOverride.Korean => "한국어 (Korean)",
|
||
// LanguageOverride.Norwegian => "Norsk",
|
||
LanguageOverride.PortugueseBrazil => "Português do Brasil",
|
||
LanguageOverride.Romanian => "Română",
|
||
LanguageOverride.Russian => "Русский",
|
||
LanguageOverride.Spanish => "Español",
|
||
LanguageOverride.Swedish => "Svenska",
|
||
_ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null),
|
||
};
|
||
|
||
public static string Code(this LanguageOverride mode) =>
|
||
mode switch
|
||
{
|
||
LanguageOverride.None => "",
|
||
LanguageOverride.ChineseSimplified => "zh-hans",
|
||
LanguageOverride.ChineseTraditional => "zh-hant",
|
||
LanguageOverride.Dutch => "nl",
|
||
LanguageOverride.English => "en",
|
||
LanguageOverride.French => "fr",
|
||
LanguageOverride.German => "de",
|
||
LanguageOverride.Greek => "el",
|
||
// LanguageOverride.Italian => "it",
|
||
LanguageOverride.Japanese => "ja",
|
||
// LanguageOverride.Korean => "ko",
|
||
// LanguageOverride.Norwegian => "no",
|
||
LanguageOverride.PortugueseBrazil => "pt-br",
|
||
LanguageOverride.Romanian => "ro",
|
||
LanguageOverride.Russian => "ru",
|
||
LanguageOverride.Spanish => "es",
|
||
LanguageOverride.Swedish => "sv",
|
||
_ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null),
|
||
};
|
||
}
|
||
|
||
[Serializable]
|
||
[Flags]
|
||
public enum ExtraGlyphRanges
|
||
{
|
||
ChineseFull = 1 << 0,
|
||
ChineseSimplifiedCommon = 1 << 1,
|
||
Cyrillic = 1 << 2,
|
||
Japanese = 1 << 3,
|
||
Korean = 1 << 4,
|
||
Thai = 1 << 5,
|
||
Vietnamese = 1 << 6,
|
||
}
|
||
|
||
public static class ExtraGlyphRangesExt
|
||
{
|
||
public static string Name(this ExtraGlyphRanges ranges) =>
|
||
ranges switch
|
||
{
|
||
ExtraGlyphRanges.ChineseFull => Language.ExtraGlyphRanges_ChineseFull_Name,
|
||
ExtraGlyphRanges.ChineseSimplifiedCommon =>
|
||
Language.ExtraGlyphRanges_ChineseSimplifiedCommon_Name,
|
||
ExtraGlyphRanges.Cyrillic => Language.ExtraGlyphRanges_Cyrillic_Name,
|
||
ExtraGlyphRanges.Japanese => Language.ExtraGlyphRanges_Japanese_Name,
|
||
ExtraGlyphRanges.Korean => Language.ExtraGlyphRanges_Korean_Name,
|
||
ExtraGlyphRanges.Thai => Language.ExtraGlyphRanges_Thai_Name,
|
||
ExtraGlyphRanges.Vietnamese => Language.ExtraGlyphRanges_Vietnamese_Name,
|
||
_ => throw new ArgumentOutOfRangeException(nameof(ranges), ranges, null),
|
||
};
|
||
|
||
public static unsafe nint Range(this ExtraGlyphRanges ranges) =>
|
||
ranges switch
|
||
{
|
||
ExtraGlyphRanges.ChineseFull => (nint)ImGui.GetIO().Fonts.GetGlyphRangesChineseFull(),
|
||
ExtraGlyphRanges.ChineseSimplifiedCommon => (nint)
|
||
ImGui.GetIO().Fonts.GetGlyphRangesChineseSimplifiedCommon(),
|
||
ExtraGlyphRanges.Cyrillic => (nint)ImGui.GetIO().Fonts.GetGlyphRangesCyrillic(),
|
||
ExtraGlyphRanges.Japanese => (nint)ImGui.GetIO().Fonts.GetGlyphRangesJapanese(),
|
||
ExtraGlyphRanges.Korean => (nint)ImGui.GetIO().Fonts.GetGlyphRangesKorean(),
|
||
ExtraGlyphRanges.Thai => (nint)ImGui.GetIO().Fonts.GetGlyphRangesThai(),
|
||
ExtraGlyphRanges.Vietnamese => (nint)ImGui.GetIO().Fonts.GetGlyphRangesVietnamese(),
|
||
_ => throw new ArgumentOutOfRangeException(nameof(ranges), ranges, null),
|
||
};
|
||
}
|