Initial

MareSynchronos/UI/CharaDataHubUi.Functions.cs

@@ -0,0 +1,196 @@
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Dto.CharaData;
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.Services.CharaData.Models;
+using System.Text;
+
+namespace MareSynchronos.UI;
+
+internal sealed partial class CharaDataHubUi
+{
+	private static string GetAccessTypeString(AccessTypeDto dto) => dto switch
+	{
+		AccessTypeDto.AllPairs => "All Pairs",
+		AccessTypeDto.ClosePairs => "Direct Pairs",
+		AccessTypeDto.Individuals => "Specified",
+		AccessTypeDto.Public => "Everyone",
+        _ => ((int)dto).ToString()
+	};
+
+	private static string GetShareTypeString(ShareTypeDto dto) => dto switch
+    {
+        ShareTypeDto.Private => "Code Only",
+        ShareTypeDto.Shared => "Shared",
+        _ => ((int)dto).ToString()
+    };
+
+	private static string GetWorldDataTooltipText(PoseEntryExtended poseEntry)
+	{
+		if (!poseEntry.HasWorldData) return "This Pose has no world data attached.";
+		return poseEntry.WorldDataDescriptor;
+	}
+
+
+	private void GposeMetaInfoAction(Action<CharaDataMetaInfoExtendedDto?> gposeActionDraw, string actionDescription, CharaDataMetaInfoExtendedDto? dto, bool hasValidGposeTarget, bool isSpawning)
+	{
+		StringBuilder sb = new StringBuilder();
+
+		sb.AppendLine(actionDescription);
+		bool isDisabled = false;
+
+		void AddErrorStart(StringBuilder sb)
+		{
+			sb.Append(UiSharedService.TooltipSeparator);
+			sb.AppendLine("Cannot execute:");
+		}
+
+		if (dto == null)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- No metainfo present");
+			isDisabled = true;
+		}
+		if (!dto?.CanBeDownloaded ?? false)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- Character is not downloadable");
+			isDisabled = true;
+		}
+		if (!_uiSharedService.IsInGpose)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- Requires to be in GPose");
+			isDisabled = true;
+		}
+		if (!hasValidGposeTarget && !isSpawning)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- Requires a valid GPose target");
+			isDisabled = true;
+		}
+		if (isSpawning && !_charaDataManager.BrioAvailable)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- Requires Brio to be installed.");
+			isDisabled = true;
+		}
+
+		using (ImRaii.Group())
+		{
+			using var dis = ImRaii.Disabled(isDisabled);
+			gposeActionDraw.Invoke(dto);
+		}
+		if (sb.Length > 0)
+		{
+			UiSharedService.AttachToolTip(sb.ToString());
+		}
+	}
+
+	private void GposePoseAction(Action poseActionDraw, string poseDescription, bool hasValidGposeTarget)
+	{
+		StringBuilder sb = new StringBuilder();
+
+		sb.AppendLine(poseDescription);
+		bool isDisabled = false;
+
+		void AddErrorStart(StringBuilder sb)
+		{
+			sb.Append(UiSharedService.TooltipSeparator);
+			sb.AppendLine("Cannot execute:");
+		}
+
+		if (!_uiSharedService.IsInGpose)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- Requires to be in GPose");
+			isDisabled = true;
+		}
+		if (!hasValidGposeTarget)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- Requires a valid GPose target");
+			isDisabled = true;
+		}
+		if (!_charaDataManager.BrioAvailable)
+		{
+			if (!isDisabled) AddErrorStart(sb);
+			sb.AppendLine("- Requires Brio to be installed.");
+			isDisabled = true;
+		}
+
+		using (ImRaii.Group())
+		{
+			using var dis = ImRaii.Disabled(isDisabled);
+			poseActionDraw.Invoke();
+		}
+		if (sb.Length > 0)
+		{
+			UiSharedService.AttachToolTip(sb.ToString());
+		}
+	}
+
+	private void SetWindowSizeConstraints(bool? inGposeTab = null)
+	{
+		SizeConstraints = new()
+		{
+			MinimumSize = new((inGposeTab ?? false) ? 400 : 1000, 500),
+			MaximumSize = new((inGposeTab ?? false) ? 400 : 1000, 2000)
+		};
+	}
+
+	private void UpdateFilteredFavorites()
+	{
+		_ = Task.Run(async () =>
+		{
+			if (_charaDataManager.DownloadMetaInfoTask != null)
+			{
+				await _charaDataManager.DownloadMetaInfoTask.ConfigureAwait(false);
+			}
+			Dictionary<string, (CharaDataFavorite, CharaDataMetaInfoExtendedDto?, bool)> newFiltered = [];
+			foreach (var favorite in _configService.Current.FavoriteCodes)
+			{
+				var uid = favorite.Key.Split(":")[0];
+				var note = _serverConfigurationManager.GetNoteForUid(uid) ?? string.Empty;
+				bool hasMetaInfo = _charaDataManager.TryGetMetaInfo(favorite.Key, out var metaInfo);
+				bool addFavorite =
+					(string.IsNullOrEmpty(_filterCodeNote)
+						|| (note.Contains(_filterCodeNote, StringComparison.OrdinalIgnoreCase)
+						|| uid.Contains(_filterCodeNote, StringComparison.OrdinalIgnoreCase)))
+					&& (string.IsNullOrEmpty(_filterDescription)
+						|| (favorite.Value.CustomDescription.Contains(_filterDescription, StringComparison.OrdinalIgnoreCase)
+						|| (metaInfo != null && metaInfo!.Description.Contains(_filterDescription, StringComparison.OrdinalIgnoreCase))))
+					&& (!_filterPoseOnly
+						|| (metaInfo != null && metaInfo!.HasPoses))
+					&& (!_filterWorldOnly
+						|| (metaInfo != null && metaInfo!.HasWorldData));
+				if (addFavorite)
+				{
+					newFiltered[favorite.Key] = (favorite.Value, metaInfo, hasMetaInfo);
+				}
+			}
+
+			_filteredFavorites = newFiltered;
+		});
+	}
+
+	private void UpdateFilteredItems()
+	{
+		if (_charaDataManager.GetSharedWithYouTask == null)
+		{
+			_filteredDict = _charaDataManager.SharedWithYouData
+				.SelectMany(k => k.Value)
+				.Where(k =>
+					(!_sharedWithYouDownloadableFilter || k.CanBeDownloaded)
+					&& (string.IsNullOrEmpty(_sharedWithYouDescriptionFilter) || k.Description.Contains(_sharedWithYouDescriptionFilter, StringComparison.OrdinalIgnoreCase)))
+				.GroupBy(k => k.Uploader)
+				.ToDictionary(k =>
+				{
+					var note = _serverConfigurationManager.GetNoteForUid(k.Key.UID);
+					if (note == null) return k.Key.AliasOrUID;
+					return $"{note} ({k.Key.AliasOrUID})";
+				}, k => k.ToList(), StringComparer.OrdinalIgnoreCase)
+				.Where(k => (string.IsNullOrEmpty(_sharedWithYouOwnerFilter) || k.Key.Contains(_sharedWithYouOwnerFilter, StringComparison.OrdinalIgnoreCase)))
+				.OrderBy(k => k.Key, StringComparer.OrdinalIgnoreCase).ToDictionary();
+		}
+	}
+}

MareSynchronos/UI/CharaDataHubUi.GposeTogether.cs

@@ -0,0 +1,227 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.Services.CharaData.Models;
+
+namespace MareSynchronos.UI;
+
+internal sealed partial class CharaDataHubUi
+{
+    private string _joinLobbyId = string.Empty;
+    private void DrawGposeTogether()
+    {
+        if (!_charaDataManager.BrioAvailable)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+            UiSharedService.DrawGroupedCenteredColorText("BRIO IS MANDATORY FOR GPOSE TOGETHER.", ImGuiColors.DalamudRed);
+            ImGuiHelpers.ScaledDummy(5);
+        }
+
+        if (!_uiSharedService.ApiController.IsConnected)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+            UiSharedService.DrawGroupedCenteredColorText("CANNOT USE GPOSE TOGETHER WHILE DISCONNECTED FROM THE SERVER.", ImGuiColors.DalamudRed);
+            ImGuiHelpers.ScaledDummy(5);
+        }
+
+        _uiSharedService.BigText("GPose Together");
+        DrawHelpFoldout("GPose together is a way to do multiplayer GPose sessions and collaborations." + UiSharedService.DoubleNewLine
+            + "GPose together requires Brio to function. Only Brio is also supported for the actual posing interactions. Attempting to pose using other tools will lead to conflicts and exploding characters." + UiSharedService.DoubleNewLine
+            + "To use GPose together you either create or join a GPose Together Lobby. After you and other people have joined, make sure that everyone is on the same map. "
+            + "It is not required for you to be on the same server, DC or instance. Users that are on the same map will be drawn as moving purple wisps in the overworld, so you can easily find each other." + UiSharedService.DoubleNewLine
+            + "Once you are close to each other you can initiate GPose. You must either assign or spawn characters for each of the lobby users. Their own poses and positions to their character will be automatically applied." + Environment.NewLine
+            + "Pose and location data during GPose are updated approximately every few seconds.");
+
+        using var disabled = ImRaii.Disabled(!_charaDataManager.BrioAvailable || !_uiSharedService.ApiController.IsConnected);
+
+        UiSharedService.DistanceSeparator();
+        _uiSharedService.BigText("Lobby Controls");
+        if (string.IsNullOrEmpty(_charaDataGposeTogetherManager.CurrentGPoseLobbyId))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Plus, "Create New GPose Together Lobby"))
+            {
+                _charaDataGposeTogetherManager.CreateNewLobby();
+            }
+            ImGuiHelpers.ScaledDummy(5);
+            ImGui.SetNextItemWidth(250);
+            ImGui.InputTextWithHint("##lobbyId", "GPose Lobby Id", ref _joinLobbyId, 30);
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowRight, "Join GPose Together Lobby"))
+            {
+                _charaDataGposeTogetherManager.JoinGPoseLobby(_joinLobbyId);
+                _joinLobbyId = string.Empty;
+            }
+            if (!string.IsNullOrEmpty(_charaDataGposeTogetherManager.LastGPoseLobbyId)
+                && _uiSharedService.IconTextButton(FontAwesomeIcon.LongArrowAltRight, $"Rejoin Last Lobby {_charaDataGposeTogetherManager.LastGPoseLobbyId}"))
+            {
+                _charaDataGposeTogetherManager.JoinGPoseLobby(_charaDataGposeTogetherManager.LastGPoseLobbyId);
+            }
+        }
+        else
+        {
+            ImGui.AlignTextToFramePadding();
+            ImGui.TextUnformatted("GPose Lobby");
+            ImGui.SameLine();
+            UiSharedService.ColorTextWrapped(_charaDataGposeTogetherManager.CurrentGPoseLobbyId, ImGuiColors.ParsedGreen);
+            ImGui.SameLine();
+            if (_uiSharedService.IconButton(FontAwesomeIcon.Clipboard))
+            {
+                ImGui.SetClipboardText(_charaDataGposeTogetherManager.CurrentGPoseLobbyId);
+            }
+            UiSharedService.AttachToolTip("Copy Lobby ID to clipboard.");
+            using (ImRaii.Disabled(!UiSharedService.CtrlPressed()))
+            {
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowLeft, "Leave GPose Lobby"))
+                {
+                    _charaDataGposeTogetherManager.LeaveGPoseLobby();
+                }
+            }
+            UiSharedService.AttachToolTip("Leave the current GPose lobby." + UiSharedService.TooltipSeparator + "Hold CTRL and click to leave.");
+        }
+        UiSharedService.DistanceSeparator();
+        using (ImRaii.Disabled(string.IsNullOrEmpty(_charaDataGposeTogetherManager.CurrentGPoseLobbyId)))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowUp, "Send Updated Character Data"))
+            {
+                _ = _charaDataGposeTogetherManager.PushCharacterDownloadDto();
+            }
+            UiSharedService.AttachToolTip("This will send your current appearance, pose and world data to all users in the lobby.");
+            if (!_uiSharedService.IsInGpose)
+            {
+                ImGuiHelpers.ScaledDummy(5);
+                UiSharedService.DrawGroupedCenteredColorText("Assigning users to characters is only available in GPose.", ImGuiColors.DalamudYellow, 300);
+            }
+            UiSharedService.DistanceSeparator();
+            ImGui.TextUnformatted("Users In Lobby");
+            var gposeCharas = _dalamudUtilService.GetGposeCharactersFromObjectTable();
+            var self = _dalamudUtilService.GetPlayerCharacter();
+            gposeCharas = gposeCharas.Where(c => c != null && !string.Equals(c.Name.TextValue, self.Name.TextValue, StringComparison.Ordinal)).ToList();
+
+            using (ImRaii.Child("charaChild", new(0, 0), false, ImGuiWindowFlags.AlwaysAutoResize))
+            {
+                ImGuiHelpers.ScaledDummy(3);
+
+                if (!_charaDataGposeTogetherManager.UsersInLobby.Any() && !string.IsNullOrEmpty(_charaDataGposeTogetherManager.CurrentGPoseLobbyId))
+                {
+                    UiSharedService.DrawGroupedCenteredColorText("No other users in current GPose lobby", ImGuiColors.DalamudYellow);
+                }
+                else
+                {
+                    foreach (var user in _charaDataGposeTogetherManager.UsersInLobby)
+                    {
+                        DrawLobbyUser(user, gposeCharas);
+                    }
+                }
+            }
+        }
+    }
+
+    private void DrawLobbyUser(GposeLobbyUserData user,
+        IEnumerable<Dalamud.Game.ClientState.Objects.Types.ICharacter?> gposeCharas)
+    {
+        using var id = ImRaii.PushId(user.UserData.UID);
+        using var indent = ImRaii.PushIndent(5f);
+        var sameMapAndServer = _charaDataGposeTogetherManager.IsOnSameMapAndServer(user);
+        var width = ImGui.GetContentRegionAvail().X - 5;
+        UiSharedService.DrawGrouped(() =>
+        {
+            var availWidth = ImGui.GetContentRegionAvail().X;
+            ImGui.AlignTextToFramePadding();
+            var note = _serverConfigurationManager.GetNoteForUid(user.UserData.UID);
+            var userText = note == null ? user.UserData.AliasOrUID : $"{note} ({user.UserData.AliasOrUID})";
+            UiSharedService.ColorText(userText, ImGuiColors.ParsedGreen);
+
+            var buttonsize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.ArrowRight).X;
+            var buttonsize2 = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Plus).X;
+            ImGui.SameLine();
+            ImGui.SetCursorPosX(availWidth - (buttonsize + buttonsize2 + ImGui.GetStyle().ItemSpacing.X));
+            using (ImRaii.Disabled(!_uiSharedService.IsInGpose || user.CharaData == null || user.Address == nint.Zero))
+            {
+                if (_uiSharedService.IconButton(FontAwesomeIcon.ArrowRight))
+                {
+                    _ = _charaDataGposeTogetherManager.ApplyCharaData(user);
+                }
+            }
+            UiSharedService.AttachToolTip("Apply newly received character data to selected actor." + UiSharedService.TooltipSeparator + "Note: If the button is grayed out, the latest data has already been applied.");
+            ImGui.SameLine();
+            using (ImRaii.Disabled(!_uiSharedService.IsInGpose || user.CharaData == null || sameMapAndServer.SameEverything))
+            {
+                if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+                {
+                    _ = _charaDataGposeTogetherManager.SpawnAndApplyData(user);
+                }
+            }
+            UiSharedService.AttachToolTip("Spawn new actor, apply character data and and assign it to this user." + UiSharedService.TooltipSeparator + "Note: If the button is grayed out, " +
+                "the user has not sent any character data or you are on the same map, server and instance. If the latter is the case, join a group with that user and assign the character to them.");
+
+
+            using (ImRaii.Group())
+            {
+                UiSharedService.ColorText("Map Info", ImGuiColors.DalamudGrey);
+                ImGui.SameLine();
+                _uiSharedService.IconText(FontAwesomeIcon.ExternalLinkSquareAlt, ImGuiColors.DalamudGrey);
+            }
+            UiSharedService.AttachToolTip(user.WorldDataDescriptor + UiSharedService.TooltipSeparator);
+
+            ImGui.SameLine();
+            _uiSharedService.IconText(FontAwesomeIcon.Map, sameMapAndServer.SameMap ? ImGuiColors.ParsedGreen : ImGuiColors.DalamudRed);
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Left) && user.WorldData != null)
+            {
+                _dalamudUtilService.SetMarkerAndOpenMap(new(user.WorldData.Value.PositionX, user.WorldData.Value.PositionY, user.WorldData.Value.PositionZ), user.Map);
+            }
+            UiSharedService.AttachToolTip((sameMapAndServer.SameMap ? "You are on the same map." : "You are not on the same map.") + UiSharedService.TooltipSeparator
+                + "Note: Click to open the users location on your map." + Environment.NewLine
+                + "Note: For GPose synchronization to work properly, you must be on the same map.");
+
+            ImGui.SameLine();
+            _uiSharedService.IconText(FontAwesomeIcon.Globe, sameMapAndServer.SameServer ? ImGuiColors.ParsedGreen : ImGuiColors.DalamudRed);
+            UiSharedService.AttachToolTip((sameMapAndServer.SameMap ? "You are on the same server." : "You are not on the same server.") + UiSharedService.TooltipSeparator
+                + "Note: GPose synchronization is not dependent on the current server, but you will have to spawn a character for the other lobby users.");
+
+            ImGui.SameLine();
+            _uiSharedService.IconText(FontAwesomeIcon.Running, sameMapAndServer.SameEverything ? ImGuiColors.ParsedGreen : ImGuiColors.DalamudRed);
+            UiSharedService.AttachToolTip(sameMapAndServer.SameEverything ? "You are in the same instanced area." : "You are not the same instanced area." + UiSharedService.TooltipSeparator +
+                "Note: Users not in your instance, but on the same map, will be drawn as floating wisps." + Environment.NewLine
+                + "Note: GPose synchronization is not dependent on the current instance, but you will have to spawn a character for the other lobby users.");
+
+            using (ImRaii.Disabled(!_uiSharedService.IsInGpose))
+            {
+                ImGui.SetNextItemWidth(200);
+                using (var combo = ImRaii.Combo("##character", string.IsNullOrEmpty(user.AssociatedCharaName) ? "No character assigned" : CharaName(user.AssociatedCharaName)))
+                {
+                    if (combo)
+                    {
+                        foreach (var chara in gposeCharas)
+                        {
+                            if (chara == null) continue;
+
+                            if (ImGui.Selectable(CharaName(chara.Name.TextValue), chara.Address == user.Address))
+                            {
+                                user.AssociatedCharaName = chara.Name.TextValue;
+                                user.Address = chara.Address;
+                            }
+                        }
+                    }
+                }
+                ImGui.SameLine();
+                using (ImRaii.Disabled(user.Address == nint.Zero))
+                {
+                    if (_uiSharedService.IconButton(FontAwesomeIcon.Trash))
+                    {
+                        user.AssociatedCharaName = string.Empty;
+                        user.Address = nint.Zero;
+                    }
+                }
+                UiSharedService.AttachToolTip("Unassign Actor for this user");
+                if (_uiSharedService.IsInGpose && user.Address == nint.Zero)
+                {
+                    ImGui.SameLine();
+                    _uiSharedService.IconText(FontAwesomeIcon.ExclamationTriangle, ImGuiColors.DalamudRed);
+                    UiSharedService.AttachToolTip("No valid character assigned for this user. Pose data will not be applied.");
+                }
+            }
+        }, 5, width);
+        ImGuiHelpers.ScaledDummy(5);
+    }
+}

MareSynchronos/UI/CharaDataHubUi.McdOnline.cs

@@ -0,0 +1,851 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Dto.CharaData;
+using MareSynchronos.Services.CharaData.Models;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+internal sealed partial class CharaDataHubUi
+{
+    private void DrawEditCharaData(CharaDataFullExtendedDto? dataDto)
+    {
+        using var imguiid = ImRaii.PushId(dataDto?.Id ?? "NoData");
+
+        if (dataDto == null)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+            UiSharedService.DrawGroupedCenteredColorText("Select an entry above to edit its data.", ImGuiColors.DalamudYellow);
+            return;
+        }
+
+        var updateDto = _charaDataManager.GetUpdateDto(dataDto.Id);
+
+        if (updateDto == null)
+        {
+            UiSharedService.DrawGroupedCenteredColorText("Something went awfully wrong and there's no update DTO. Try updating Character Data via the button above.", ImGuiColors.DalamudYellow);
+            return;
+        }
+
+        bool canUpdate = updateDto.HasChanges;
+        if (canUpdate || _charaDataManager.CharaUpdateTask != null)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+        }
+
+        var indent = ImRaii.PushIndent(10f);
+        if (canUpdate || _charaDataManager.UploadTask != null)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+            UiSharedService.DrawGrouped(() =>
+            {
+                if (canUpdate)
+                {
+                    ImGui.AlignTextToFramePadding();
+                    UiSharedService.ColorTextWrapped("Warning: You have unsaved changes!", ImGuiColors.DalamudRed);
+                    ImGui.SameLine();
+                    using (ImRaii.Disabled(_charaDataManager.CharaUpdateTask != null && !_charaDataManager.CharaUpdateTask.IsCompleted))
+                    {
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowCircleUp, "Save to Server"))
+                        {
+                            _charaDataManager.UploadCharaData(dataDto.Id);
+                        }
+                        ImGui.SameLine();
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Undo, "Undo all changes"))
+                        {
+                            updateDto.UndoChanges();
+                        }
+                    }
+                    if (_charaDataManager.CharaUpdateTask != null && !_charaDataManager.CharaUpdateTask.IsCompleted)
+                    {
+                        UiSharedService.ColorTextWrapped("Updating data on server, please wait.", ImGuiColors.DalamudYellow);
+                    }
+                }
+
+                if (!_charaDataManager.UploadTask?.IsCompleted ?? false)
+                {
+                    DisableDisabled(() =>
+                    {
+                        if (_charaDataManager.UploadProgress != null)
+                        {
+                            UiSharedService.ColorTextWrapped(_charaDataManager.UploadProgress.Value ?? string.Empty, ImGuiColors.DalamudYellow);
+                        }
+                        if ((!_charaDataManager.UploadTask?.IsCompleted ?? false) && _uiSharedService.IconTextButton(FontAwesomeIcon.Ban, "Cancel Upload"))
+                        {
+                            _charaDataManager.CancelUpload();
+                        }
+                        else if (_charaDataManager.UploadTask?.IsCompleted ?? false)
+                        {
+                            var color = UiSharedService.GetBoolColor(_charaDataManager.UploadTask.Result.Success);
+                            UiSharedService.ColorTextWrapped(_charaDataManager.UploadTask.Result.Output, color);
+                        }
+                    });
+                }
+                else if (_charaDataManager.UploadTask?.IsCompleted ?? false)
+                {
+                    var color = UiSharedService.GetBoolColor(_charaDataManager.UploadTask.Result.Success);
+                    UiSharedService.ColorTextWrapped(_charaDataManager.UploadTask.Result.Output, color);
+                }
+            });
+        }
+        indent.Dispose();
+
+        if (canUpdate || _charaDataManager.CharaUpdateTask != null)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+        }
+
+        using var child = ImRaii.Child("editChild", new(0, 0), false, ImGuiWindowFlags.AlwaysAutoResize);
+
+        DrawEditCharaDataGeneral(dataDto, updateDto);
+        ImGuiHelpers.ScaledDummy(5);
+        DrawEditCharaDataAccessAndSharing(updateDto);
+        ImGuiHelpers.ScaledDummy(5);
+        DrawEditCharaDataAppearance(dataDto, updateDto);
+        ImGuiHelpers.ScaledDummy(5);
+        DrawEditCharaDataPoses(updateDto);
+    }
+
+    private void DrawEditCharaDataAccessAndSharing(CharaDataExtendedUpdateDto updateDto)
+    {
+        _uiSharedService.BigText("Access and Sharing");
+
+        ImGui.SetNextItemWidth(200);
+        var dtoAccessType = updateDto.AccessType;
+        if (ImGui.BeginCombo("Access Restrictions", GetAccessTypeString(dtoAccessType)))
+        {
+            foreach (var accessType in Enum.GetValues(typeof(AccessTypeDto)).Cast<AccessTypeDto>())
+            {
+                if (ImGui.Selectable(GetAccessTypeString(accessType), accessType == dtoAccessType))
+                {
+                    updateDto.AccessType = accessType;
+                }
+            }
+
+            ImGui.EndCombo();
+        }
+        _uiSharedService.DrawHelpText("You can control who has access to your character data based on the access restrictions." + UiSharedService.TooltipSeparator
+            + "Specified: Only people and syncshells you directly specify in 'Specific Individuals / Syncshells' can access this character data" + Environment.NewLine
+            + "Direct Pairs: Only people you have directly paired can access this character data" + Environment.NewLine
+            + "All Pairs: All people you have paired can access this character data" + Environment.NewLine
+            + "Everyone: Everyone can access this character data" + UiSharedService.TooltipSeparator
+            + "Note: To access your character data the person in question requires to have the code. Exceptions for 'Shared' data, see 'Sharing' below." + Environment.NewLine
+            + "Note: For 'Direct' and 'All Pairs' the pause state plays a role. Paused people will not be able to access your character data." + Environment.NewLine
+            + "Note: Directly specified Individuals or Syncshells in the 'Specific Individuals / Syncshells' list will be able to access your character data regardless of pause or pair state.");
+
+        DrawSpecific(updateDto);
+
+        ImGui.SetNextItemWidth(200);
+        var dtoShareType = updateDto.ShareType;
+        using (ImRaii.Disabled(dtoAccessType == AccessTypeDto.Public))
+        {
+            if (ImGui.BeginCombo("Sharing", GetShareTypeString(dtoShareType)))
+            {
+                foreach (var shareType in Enum.GetValues(typeof(ShareTypeDto)).Cast<ShareTypeDto>())
+                {
+                    if (ImGui.Selectable(GetShareTypeString(shareType), shareType == dtoShareType))
+                    {
+                        updateDto.ShareType = shareType;
+                    }
+                }
+
+                ImGui.EndCombo();
+            }
+        }
+        _uiSharedService.DrawHelpText("This regulates how you want to distribute this character data." + UiSharedService.TooltipSeparator
+            + "Code Only: People require to have the code to download this character data" + Environment.NewLine
+            + "Shared: People that are allowed through 'Access Restrictions' will have this character data entry displayed in 'Shared with You' (it can also be accessed through the code)" + UiSharedService.TooltipSeparator
+            + "Note: Shared is incompatible with Access Restriction 'Everyone'");
+
+        ImGuiHelpers.ScaledDummy(10f);
+    }
+
+    private void DrawEditCharaDataAppearance(CharaDataFullExtendedDto dataDto, CharaDataExtendedUpdateDto updateDto)
+    {
+        _uiSharedService.BigText("Appearance");
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowRight, "Set Appearance to Current Appearance"))
+        {
+            _charaDataManager.SetAppearanceData(dataDto.Id);
+        }
+        _uiSharedService.DrawHelpText("This will overwrite the appearance data currently stored in this Character Data entry with your current appearance.");
+        ImGui.SameLine();
+        using (ImRaii.Disabled(dataDto.HasMissingFiles || !updateDto.IsAppearanceEqual || _charaDataManager.DataApplicationTask != null))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.CheckCircle, "Preview Saved Apperance on Self"))
+            {
+                _charaDataManager.ApplyDataToSelf(dataDto);
+            }
+        }
+        _uiSharedService.DrawHelpText("This will download and apply the saved character data to yourself. Once loaded it will automatically revert itself within 15 seconds." + UiSharedService.TooltipSeparator
+            + "Note: Weapons will not be displayed correctly unless using the same job as the saved data.");
+
+        ImGui.TextUnformatted("Contains Glamourer Data");
+        ImGui.SameLine();
+        bool hasGlamourerdata = !string.IsNullOrEmpty(updateDto.GlamourerData);
+        ImGui.SameLine(200);
+        _uiSharedService.BooleanToColoredIcon(hasGlamourerdata, false);
+
+        ImGui.TextUnformatted("Contains Files");
+        var hasFiles = (updateDto.FileGamePaths ?? []).Any() || (dataDto.OriginalFiles.Any());
+        ImGui.SameLine(200);
+        _uiSharedService.BooleanToColoredIcon(hasFiles, false);
+        if (hasFiles && updateDto.IsAppearanceEqual)
+        {
+            ImGui.SameLine();
+            ImGuiHelpers.ScaledDummy(20, 1);
+            ImGui.SameLine();
+            var pos = ImGui.GetCursorPosX();
+            ImGui.NewLine();
+            ImGui.SameLine(pos);
+            ImGui.TextUnformatted($"{dataDto.FileGamePaths.DistinctBy(k => k.HashOrFileSwap).Count()} unique file hashes (original upload: {dataDto.OriginalFiles.DistinctBy(k => k.HashOrFileSwap).Count()} file hashes)");
+            ImGui.NewLine();
+            ImGui.SameLine(pos);
+            ImGui.TextUnformatted($"{dataDto.FileGamePaths.Count} associated game paths");
+            ImGui.NewLine();
+            ImGui.SameLine(pos);
+            ImGui.TextUnformatted($"{dataDto.FileSwaps!.Count} file swaps");
+            ImGui.NewLine();
+            ImGui.SameLine(pos);
+            if (!dataDto.HasMissingFiles)
+            {
+                UiSharedService.ColorTextWrapped("All files to download this character data are present on the server", ImGuiColors.HealerGreen);
+            }
+            else
+            {
+                UiSharedService.ColorTextWrapped($"{dataDto.MissingFiles.DistinctBy(k => k.HashOrFileSwap).Count()} files to download this character data are missing on the server", ImGuiColors.DalamudRed);
+                ImGui.NewLine();
+                ImGui.SameLine(pos);
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowCircleUp, "Attempt to upload missing files and restore Character Data"))
+                {
+                    _charaDataManager.UploadMissingFiles(dataDto.Id);
+                }
+            }
+        }
+        else if (hasFiles && !updateDto.IsAppearanceEqual)
+        {
+            ImGui.SameLine();
+            ImGuiHelpers.ScaledDummy(20, 1);
+            ImGui.SameLine();
+            UiSharedService.ColorTextWrapped("New data was set. It may contain files that require to be uploaded (will happen on Saving to server)", ImGuiColors.DalamudYellow);
+        }
+
+        ImGui.TextUnformatted("Contains Manipulation Data");
+        bool hasManipData = !string.IsNullOrEmpty(updateDto.ManipulationData);
+        ImGui.SameLine(200);
+        _uiSharedService.BooleanToColoredIcon(hasManipData, false);
+
+        ImGui.TextUnformatted("Contains Customize+ Data");
+        ImGui.SameLine();
+        bool hasCustomizeData = !string.IsNullOrEmpty(updateDto.CustomizeData);
+        ImGui.SameLine(200);
+        _uiSharedService.BooleanToColoredIcon(hasCustomizeData, false);
+    }
+
+    private void DrawEditCharaDataGeneral(CharaDataFullExtendedDto dataDto, CharaDataExtendedUpdateDto updateDto)
+    {
+        _uiSharedService.BigText("General");
+        string code = dataDto.FullId;
+        using (ImRaii.Disabled())
+        {
+            ImGui.SetNextItemWidth(200);
+            ImGui.InputText("##CharaDataCode", ref code, 255, ImGuiInputTextFlags.ReadOnly);
+        }
+        ImGui.SameLine();
+        ImGui.TextUnformatted("Chara Data Code");
+        ImGui.SameLine();
+        if (_uiSharedService.IconButton(FontAwesomeIcon.Copy))
+        {
+            ImGui.SetClipboardText(code);
+        }
+        UiSharedService.AttachToolTip("Copy Code to Clipboard");
+
+        string creationTime = dataDto.CreatedDate.ToLocalTime().ToString();
+        string updateTime = dataDto.UpdatedDate.ToLocalTime().ToString();
+        string downloadCount = dataDto.DownloadCount.ToString();
+        using (ImRaii.Disabled())
+        {
+            ImGui.SetNextItemWidth(200);
+            ImGui.InputText("##CreationDate", ref creationTime, 255, ImGuiInputTextFlags.ReadOnly);
+        }
+        ImGui.SameLine();
+        ImGui.TextUnformatted("Creation Date");
+        ImGui.SameLine();
+        ImGuiHelpers.ScaledDummy(20);
+        ImGui.SameLine();
+        using (ImRaii.Disabled())
+        {
+            ImGui.SetNextItemWidth(200);
+            ImGui.InputText("##LastUpdate", ref updateTime, 255, ImGuiInputTextFlags.ReadOnly);
+        }
+        ImGui.SameLine();
+        ImGui.TextUnformatted("Last Update Date");
+        ImGui.SameLine();
+        ImGuiHelpers.ScaledDummy(23);
+        ImGui.SameLine();
+        using (ImRaii.Disabled())
+        {
+            ImGui.SetNextItemWidth(50);
+            ImGui.InputText("##DlCount", ref downloadCount, 255, ImGuiInputTextFlags.ReadOnly);
+        }
+        ImGui.SameLine();
+        ImGui.TextUnformatted("Download Count");
+
+        string description = updateDto.Description;
+        ImGui.SetNextItemWidth(735);
+        if (ImGui.InputText("##Description", ref description, 200))
+        {
+            updateDto.Description = description;
+        }
+        ImGui.SameLine();
+        ImGui.TextUnformatted("Description");
+        _uiSharedService.DrawHelpText("Description for this Character Data." + UiSharedService.TooltipSeparator
+            + "Note: the description will be visible to anyone who can access this character data. See 'Access Restrictions' and 'Sharing' below.");
+
+        var expiryDate = updateDto.ExpiryDate;
+        bool isExpiring = expiryDate != DateTime.MaxValue;
+        if (ImGui.Checkbox("Expires", ref isExpiring))
+        {
+            updateDto.SetExpiry(isExpiring);
+        }
+        _uiSharedService.DrawHelpText("If expiration is enabled, the uploaded character data will be automatically deleted from the server at the specified date.");
+        using (ImRaii.Disabled(!isExpiring))
+        {
+            ImGui.SameLine();
+            ImGui.SetNextItemWidth(100);
+            if (ImGui.BeginCombo("Year", expiryDate.Year.ToString()))
+            {
+                for (int year = DateTime.UtcNow.Year; year < DateTime.UtcNow.Year + 4; year++)
+                {
+                    if (ImGui.Selectable(year.ToString(), year == expiryDate.Year))
+                    {
+                        updateDto.SetExpiry(year, expiryDate.Month, expiryDate.Day);
+                    }
+                }
+                ImGui.EndCombo();
+            }
+            ImGui.SameLine();
+
+            int daysInMonth = DateTime.DaysInMonth(expiryDate.Year, expiryDate.Month);
+            ImGui.SetNextItemWidth(100);
+            if (ImGui.BeginCombo("Month", expiryDate.Month.ToString()))
+            {
+                for (int month = 1; month <= 12; month++)
+                {
+                    if (ImGui.Selectable(month.ToString(), month == expiryDate.Month))
+                    {
+                        updateDto.SetExpiry(expiryDate.Year, month, expiryDate.Day);
+                    }
+                }
+                ImGui.EndCombo();
+            }
+            ImGui.SameLine();
+
+            ImGui.SetNextItemWidth(100);
+            if (ImGui.BeginCombo("Day", expiryDate.Day.ToString()))
+            {
+                for (int day = 1; day <= daysInMonth; day++)
+                {
+                    if (ImGui.Selectable(day.ToString(), day == expiryDate.Day))
+                    {
+                        updateDto.SetExpiry(expiryDate.Year, expiryDate.Month, day);
+                    }
+                }
+                ImGui.EndCombo();
+            }
+        }
+        ImGuiHelpers.ScaledDummy(5);
+
+        using (ImRaii.Disabled(!UiSharedService.CtrlPressed()))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Delete Character Data"))
+            {
+                _ = _charaDataManager.DeleteCharaData(dataDto);
+                SelectedDtoId = string.Empty;
+            }
+        }
+        if (!UiSharedService.CtrlPressed())
+        {
+            UiSharedService.AttachToolTip("Hold CTRL and click to delete the current data. This operation is irreversible.");
+        }
+    }
+
+    private void DrawEditCharaDataPoses(CharaDataExtendedUpdateDto updateDto)
+    {
+        _uiSharedService.BigText("Poses");
+        var poseCount = updateDto.PoseList.Count();
+        using (ImRaii.Disabled(poseCount >= maxPoses))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Plus, "Add new Pose"))
+            {
+                updateDto.AddPose();
+            }
+        }
+        ImGui.SameLine();
+        using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, poseCount == maxPoses))
+            ImGui.TextUnformatted($"{poseCount}/{maxPoses} poses attached");
+        ImGuiHelpers.ScaledDummy(5);
+
+        using var indent = ImRaii.PushIndent(10f);
+        int poseNumber = 1;
+
+        if (!_uiSharedService.IsInGpose && _charaDataManager.BrioAvailable)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+            UiSharedService.DrawGroupedCenteredColorText("To attach pose and world data you need to be in GPose.", ImGuiColors.DalamudYellow);
+            ImGuiHelpers.ScaledDummy(5);
+        }
+        else if (!_charaDataManager.BrioAvailable)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+            UiSharedService.DrawGroupedCenteredColorText("To attach pose and world data Brio requires to be installed.", ImGuiColors.DalamudRed);
+            ImGuiHelpers.ScaledDummy(5);
+        }
+
+        foreach (var pose in updateDto.PoseList)
+        {
+            ImGui.AlignTextToFramePadding();
+            using var id = ImRaii.PushId("pose" + poseNumber);
+            ImGui.TextUnformatted(poseNumber.ToString());
+
+            if (pose.Id == null)
+            {
+                ImGui.SameLine(50);
+                _uiSharedService.IconText(FontAwesomeIcon.Plus, ImGuiColors.DalamudYellow);
+                UiSharedService.AttachToolTip("This pose has not been added to the server yet. Save changes to upload this Pose data.");
+            }
+
+            bool poseHasChanges = updateDto.PoseHasChanges(pose);
+            if (poseHasChanges)
+            {
+                ImGui.SameLine(50);
+                _uiSharedService.IconText(FontAwesomeIcon.ExclamationTriangle, ImGuiColors.DalamudYellow);
+                UiSharedService.AttachToolTip("This pose has changes that have not been saved to the server yet.");
+            }
+
+            ImGui.SameLine(75);
+            if (pose.Description == null && pose.WorldData == null && pose.PoseData == null)
+            {
+                UiSharedService.ColorText("Pose scheduled for deletion", ImGuiColors.DalamudYellow);
+            }
+            else
+            {
+                var desc = pose.Description ?? string.Empty;
+                if (ImGui.InputTextWithHint("##description", "Description", ref desc, 100))
+                {
+                    pose.Description = desc;
+                    updateDto.UpdatePoseList();
+                }
+                ImGui.SameLine();
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Delete"))
+                {
+                    updateDto.RemovePose(pose);
+                }
+
+                ImGui.SameLine();
+                ImGuiHelpers.ScaledDummy(10, 1);
+                ImGui.SameLine();
+                bool hasPoseData = !string.IsNullOrEmpty(pose.PoseData);
+                _uiSharedService.IconText(FontAwesomeIcon.Running, UiSharedService.GetBoolColor(hasPoseData));
+                UiSharedService.AttachToolTip(hasPoseData
+                    ? "This Pose entry has pose data attached"
+                    : "This Pose entry has no pose data attached");
+                ImGui.SameLine();
+
+                using (ImRaii.Disabled(!_uiSharedService.IsInGpose || !(_charaDataManager.AttachingPoseTask?.IsCompleted ?? true) || !_charaDataManager.BrioAvailable))
+                {
+                    using var poseid = ImRaii.PushId("poseSet" + poseNumber);
+                    if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+                    {
+                        _charaDataManager.AttachPoseData(pose, updateDto);
+                    }
+                    UiSharedService.AttachToolTip("Apply current pose data to pose");
+                }
+                ImGui.SameLine();
+                using (ImRaii.Disabled(!hasPoseData))
+                {
+                    using var poseid = ImRaii.PushId("poseDelete" + poseNumber);
+                    if (_uiSharedService.IconButton(FontAwesomeIcon.Trash))
+                    {
+                        pose.PoseData = string.Empty;
+                        updateDto.UpdatePoseList();
+                    }
+                    UiSharedService.AttachToolTip("Delete current pose data from pose");
+                }
+
+                ImGui.SameLine();
+                ImGuiHelpers.ScaledDummy(10, 1);
+                ImGui.SameLine();
+                var worldData = pose.WorldData ?? default;
+                bool hasWorldData = worldData != default;
+                _uiSharedService.IconText(FontAwesomeIcon.Globe, UiSharedService.GetBoolColor(hasWorldData));
+                var tooltipText = !hasWorldData ? "This Pose has no world data attached." : "This Pose has world data attached.";
+                if (hasWorldData)
+                {
+                    tooltipText += UiSharedService.TooltipSeparator + "Click to show location on map";
+                }
+                UiSharedService.AttachToolTip(tooltipText);
+                if (hasWorldData && ImGui.IsItemClicked(ImGuiMouseButton.Left))
+                {
+                    _dalamudUtilService.SetMarkerAndOpenMap(position: new Vector3(worldData.PositionX, worldData.PositionY, worldData.PositionZ),
+                        _dalamudUtilService.MapData.Value[worldData.LocationInfo.MapId].Map);
+                }
+                ImGui.SameLine();
+                using (ImRaii.Disabled(!_uiSharedService.IsInGpose || !(_charaDataManager.AttachingPoseTask?.IsCompleted ?? true) || !_charaDataManager.BrioAvailable))
+                {
+                    using var worldId = ImRaii.PushId("worldSet" + poseNumber);
+                    if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+                    {
+                        _charaDataManager.AttachWorldData(pose, updateDto);
+                    }
+                    UiSharedService.AttachToolTip("Apply current world position data to pose");
+                }
+                ImGui.SameLine();
+                using (ImRaii.Disabled(!hasWorldData))
+                {
+                    using var worldId = ImRaii.PushId("worldDelete" + poseNumber);
+                    if (_uiSharedService.IconButton(FontAwesomeIcon.Trash))
+                    {
+                        pose.WorldData = default(WorldData);
+                        updateDto.UpdatePoseList();
+                    }
+                    UiSharedService.AttachToolTip("Delete current world position data from pose");
+                }
+            }
+
+            if (poseHasChanges)
+            {
+                ImGui.SameLine();
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Undo, "Undo"))
+                {
+                    updateDto.RevertDeletion(pose);
+                }
+            }
+
+            poseNumber++;
+        }
+    }
+
+    private void DrawMcdOnline()
+    {
+        _uiSharedService.BigText("Online Character Data");
+
+        DrawHelpFoldout("In this tab you can create, view and edit your own Character Data that is stored on the server." + Environment.NewLine + Environment.NewLine
+            + "Character Data Online functions similar to the previous MCDF standard for exporting your character, except that you do not have to send a file to the other person but solely a code." + Environment.NewLine + Environment.NewLine
+            + "There would be a bit too much to explain here on what you can do here in its entirety, however, all elements in this tab have help texts attached what they are used for. Please review them carefully." + Environment.NewLine + Environment.NewLine
+            + "Be mindful that when you share your Character Data with other people there is a chance that, with the help of unsanctioned 3rd party plugins, your appearance could be stolen irreversibly, just like when using MCDF.");
+
+        ImGuiHelpers.ScaledDummy(5);
+        using (ImRaii.Disabled((!_charaDataManager.GetAllDataTask?.IsCompleted ?? false)
+            || (_charaDataManager.DataGetTimeoutTask != null && !_charaDataManager.DataGetTimeoutTask.IsCompleted)))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowCircleDown, "Download your Online Character Data from Server"))
+            {
+                _ = _charaDataManager.GetAllData(_disposalCts.Token);
+            }
+        }
+        if (_charaDataManager.DataGetTimeoutTask != null && !_charaDataManager.DataGetTimeoutTask.IsCompleted)
+        {
+            UiSharedService.AttachToolTip("You can only refresh all character data from server every minute. Please wait.");
+        }
+
+        using (var table = ImRaii.Table("Own Character Data", 12, ImGuiTableFlags.RowBg | ImGuiTableFlags.SizingFixedFit | ImGuiTableFlags.ScrollY,
+            new Vector2(ImGui.GetWindowContentRegionMax().X - ImGui.GetWindowContentRegionMin().X, 110)))
+        {
+            if (table)
+            {
+                ImGui.TableSetupColumn("", ImGuiTableColumnFlags.WidthFixed, 18);
+                ImGui.TableSetupColumn("", ImGuiTableColumnFlags.WidthFixed, 18);
+                ImGui.TableSetupColumn("Code");
+                ImGui.TableSetupColumn("Description", ImGuiTableColumnFlags.WidthStretch);
+                ImGui.TableSetupColumn("Created");
+                ImGui.TableSetupColumn("Updated");
+                ImGui.TableSetupColumn("Download Count", ImGuiTableColumnFlags.WidthFixed, 18);
+                ImGui.TableSetupColumn("Downloadable", ImGuiTableColumnFlags.WidthFixed, 18);
+                ImGui.TableSetupColumn("Files", ImGuiTableColumnFlags.WidthFixed, 32);
+                ImGui.TableSetupColumn("Glamourer", ImGuiTableColumnFlags.WidthFixed, 18);
+                ImGui.TableSetupColumn("Customize+", ImGuiTableColumnFlags.WidthFixed, 18);
+                ImGui.TableSetupColumn("Expires", ImGuiTableColumnFlags.WidthFixed, 18);
+                ImGui.TableSetupScrollFreeze(0, 1);
+                ImGui.TableHeadersRow();
+                foreach (var entry in _charaDataManager.OwnCharaData.Values.OrderBy(b => b.CreatedDate))
+                {
+                    var uDto = _charaDataManager.GetUpdateDto(entry.Id);
+                    ImGui.TableNextColumn();
+                    if (string.Equals(entry.Id, SelectedDtoId, StringComparison.Ordinal))
+                        _uiSharedService.IconText(FontAwesomeIcon.CaretRight);
+
+                    ImGui.TableNextColumn();
+                    DrawAddOrRemoveFavorite(entry);
+
+                    ImGui.TableNextColumn();
+                    var idText = entry.FullId;
+                    if (uDto?.HasChanges ?? false)
+                    {
+                        UiSharedService.ColorText(idText, ImGuiColors.DalamudYellow);
+                        UiSharedService.AttachToolTip("This entry has unsaved changes");
+                    }
+                    else
+                    {
+                        ImGui.TextUnformatted(idText);
+                    }
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(entry.Description);
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+                    UiSharedService.AttachToolTip(entry.Description);
+
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(entry.CreatedDate.ToLocalTime().ToString());
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(entry.UpdatedDate.ToLocalTime().ToString());
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(entry.DownloadCount.ToString());
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+
+                    ImGui.TableNextColumn();
+                    bool isDownloadable = !entry.HasMissingFiles
+                        && !string.IsNullOrEmpty(entry.GlamourerData);
+                    _uiSharedService.BooleanToColoredIcon(isDownloadable, false);
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+                    UiSharedService.AttachToolTip(isDownloadable ? "Can be downloaded by others" : "Cannot be downloaded: Has missing files or data, please review this entry manually");
+
+                    ImGui.TableNextColumn();
+                    var count = entry.FileGamePaths.Concat(entry.FileSwaps).Count();
+                    ImGui.TextUnformatted(count.ToString());
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+                    UiSharedService.AttachToolTip(count == 0 ? "No File data attached" : "Has File data attached");
+
+                    ImGui.TableNextColumn();
+                    bool hasGlamourerData = !string.IsNullOrEmpty(entry.GlamourerData);
+                    _uiSharedService.BooleanToColoredIcon(hasGlamourerData, false);
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+                    UiSharedService.AttachToolTip(string.IsNullOrEmpty(entry.GlamourerData) ? "No Glamourer data attached" : "Has Glamourer data attached");
+
+                    ImGui.TableNextColumn();
+                    bool hasCustomizeData = !string.IsNullOrEmpty(entry.CustomizeData);
+                    _uiSharedService.BooleanToColoredIcon(hasCustomizeData, false);
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+                    UiSharedService.AttachToolTip(string.IsNullOrEmpty(entry.CustomizeData) ? "No Customize+ data attached" : "Has Customize+ data attached");
+
+                    ImGui.TableNextColumn();
+                    FontAwesomeIcon eIcon = FontAwesomeIcon.None;
+                    if (!Equals(DateTime.MaxValue, entry.ExpiryDate))
+                        eIcon = FontAwesomeIcon.Clock;
+                    _uiSharedService.IconText(eIcon, ImGuiColors.DalamudYellow);
+                    if (ImGui.IsItemClicked()) SelectedDtoId = entry.Id;
+                    if (eIcon != FontAwesomeIcon.None)
+                    {
+                        UiSharedService.AttachToolTip($"This entry will expire on {entry.ExpiryDate.ToLocalTime()}");
+                    }
+                }
+            }
+        }
+
+        using (ImRaii.Disabled(!_charaDataManager.Initialized || _charaDataManager.DataCreationTask != null || _charaDataManager.OwnCharaData.Count == _charaDataManager.MaxCreatableCharaData))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Plus, "New Character Data Entry"))
+            {
+                _charaDataManager.CreateCharaDataEntry(_closalCts.Token);
+                _selectNewEntry = true;
+            }
+        }
+        if (_charaDataManager.DataCreationTask != null)
+        {
+            UiSharedService.AttachToolTip("You can only create new character data every few seconds. Please wait.");
+        }
+        if (!_charaDataManager.Initialized)
+        {
+            UiSharedService.AttachToolTip("Please use the button \"Get Own Chara Data\" once before you can add new data entries.");
+        }
+
+        if (_charaDataManager.Initialized)
+        {
+            ImGui.SameLine();
+            ImGui.AlignTextToFramePadding();
+            UiSharedService.TextWrapped($"Chara Data Entries on Server: {_charaDataManager.OwnCharaData.Count}/{_charaDataManager.MaxCreatableCharaData}");
+            if (_charaDataManager.OwnCharaData.Count == _charaDataManager.MaxCreatableCharaData)
+            {
+                ImGui.AlignTextToFramePadding();
+                UiSharedService.ColorTextWrapped("You have reached the maximum Character Data entries and cannot create more.", ImGuiColors.DalamudYellow);
+            }
+        }
+
+        if (_charaDataManager.DataCreationTask != null && !_charaDataManager.DataCreationTask.IsCompleted)
+        {
+            UiSharedService.ColorTextWrapped("Creating new character data entry on server...", ImGuiColors.DalamudYellow);
+        }
+        else if (_charaDataManager.DataCreationTask != null && _charaDataManager.DataCreationTask.IsCompleted)
+        {
+            var color = _charaDataManager.DataCreationTask.Result.Success ? ImGuiColors.HealerGreen : ImGuiColors.DalamudRed;
+            UiSharedService.ColorTextWrapped(_charaDataManager.DataCreationTask.Result.Output, color);
+        }
+
+        ImGuiHelpers.ScaledDummy(10);
+        ImGui.Separator();
+
+        var charaDataEntries = _charaDataManager.OwnCharaData.Count;
+        if (charaDataEntries != _dataEntries && _selectNewEntry && _charaDataManager.OwnCharaData.Any())
+        {
+            SelectedDtoId = _charaDataManager.OwnCharaData.OrderBy(o => o.Value.CreatedDate).Last().Value.Id;
+            _selectNewEntry = false;
+        }
+        _dataEntries = _charaDataManager.OwnCharaData.Count;
+
+        _ = _charaDataManager.OwnCharaData.TryGetValue(SelectedDtoId, out var dto);
+        DrawEditCharaData(dto);
+    }
+
+    bool _selectNewEntry = false;
+    int _dataEntries = 0;
+
+    private void DrawSpecific(CharaDataExtendedUpdateDto updateDto)
+    {
+        UiSharedService.DrawTree("Access for Specific Individuals / Syncshells", () =>
+        {
+            using (ImRaii.PushId("user"))
+            {
+                using (ImRaii.Group())
+                {
+                    InputComboHybrid("##AliasToAdd", "##AliasToAddPicker", ref _specificIndividualAdd, _pairManager.DirectPairs,
+                        static pair => (pair.UserData.UID, pair.UserData.Alias, pair.UserData.AliasOrUID, pair.GetNoteOrName()));
+                    ImGui.SameLine();
+                    using (ImRaii.Disabled(string.IsNullOrEmpty(_specificIndividualAdd)
+                        || updateDto.UserList.Any(f => string.Equals(f.UID, _specificIndividualAdd, StringComparison.Ordinal) || string.Equals(f.Alias, _specificIndividualAdd, StringComparison.Ordinal))))
+                    {
+                        if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+                        {
+                            updateDto.AddUserToList(_specificIndividualAdd);
+                            _specificIndividualAdd = string.Empty;
+                        }
+                    }
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted("UID/Vanity UID to Add");
+                    _uiSharedService.DrawHelpText("Users added to this list will be able to access this character data regardless of your pause or pair state with them." + UiSharedService.TooltipSeparator
+                        + "Note: Mistyped entries will be automatically removed on updating data to server.");
+
+                    using (var lb = ImRaii.ListBox("Allowed Individuals", new(200, 200)))
+                    {
+                        foreach (var user in updateDto.UserList)
+                        {
+                            var userString = string.IsNullOrEmpty(user.Alias) ? user.UID : $"{user.Alias} ({user.UID})";
+                            if (ImGui.Selectable(userString, string.Equals(user.UID, _selectedSpecificUserIndividual, StringComparison.Ordinal)))
+                            {
+                                _selectedSpecificUserIndividual = user.UID;
+                            }
+                        }
+                    }
+
+                    using (ImRaii.Disabled(string.IsNullOrEmpty(_selectedSpecificUserIndividual)))
+                    {
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Remove selected User"))
+                        {
+                            updateDto.RemoveUserFromList(_selectedSpecificUserIndividual);
+                            _selectedSpecificUserIndividual = string.Empty;
+                        }
+                    }
+                }
+            }
+            ImGui.SameLine();
+            ImGuiHelpers.ScaledDummy(20);
+            ImGui.SameLine();
+
+            using (ImRaii.PushId("group"))
+            {
+                using (ImRaii.Group())
+                {
+                    InputComboHybrid("##GroupAliasToAdd", "##GroupAliasToAddPicker", ref _specificGroupAdd, _pairManager.Groups.Keys,
+                        group => (group.GID, group.Alias, group.AliasOrGID, _serverConfigurationManager.GetNoteForGid(group.GID)));
+                    ImGui.SameLine();
+                    using (ImRaii.Disabled(string.IsNullOrEmpty(_specificGroupAdd)
+                        || updateDto.GroupList.Any(f => string.Equals(f.GID, _specificGroupAdd, StringComparison.Ordinal) || string.Equals(f.Alias, _specificGroupAdd, StringComparison.Ordinal))))
+                    {
+                        if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+                        {
+                            updateDto.AddGroupToList(_specificGroupAdd);
+                            _specificGroupAdd = string.Empty;
+                        }
+                    }
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted("GID/Vanity GID to Add");
+                    _uiSharedService.DrawHelpText("Users in Syncshells added to this list will be able to access this character data regardless of your pause or pair state with them." + UiSharedService.TooltipSeparator
+                        + "Note: Mistyped entries will be automatically removed on updating data to server.");
+
+                    using (var lb = ImRaii.ListBox("Allowed Syncshells", new(200, 200)))
+                    {
+                        foreach (var group in updateDto.GroupList)
+                        {
+                            var userString = string.IsNullOrEmpty(group.Alias) ? group.GID : $"{group.Alias} ({group.GID})";
+                            if (ImGui.Selectable(userString, string.Equals(group.GID, _selectedSpecificGroupIndividual, StringComparison.Ordinal)))
+                            {
+                                _selectedSpecificGroupIndividual = group.GID;
+                            }
+                        }
+                    }
+
+                    using (ImRaii.Disabled(string.IsNullOrEmpty(_selectedSpecificGroupIndividual)))
+                    {
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Remove selected Syncshell"))
+                        {
+                            updateDto.RemoveGroupFromList(_selectedSpecificGroupIndividual);
+                            _selectedSpecificGroupIndividual = string.Empty;
+                        }
+                    }
+                }
+            }
+
+            ImGui.Separator();
+            ImGuiHelpers.ScaledDummy(5);
+        });
+    }
+
+    private void InputComboHybrid<T>(string inputId, string comboId, ref string value, IEnumerable<T> comboEntries,
+        Func<T, (string Id, string? Alias, string AliasOrId, string? Note)> parseEntry)
+    {
+        const float ComponentWidth = 200;
+        ImGui.SetNextItemWidth(ComponentWidth - ImGui.GetFrameHeight());
+        ImGui.InputText(inputId, ref value, 20);
+        ImGui.SameLine(0.0f, 0.0f);
+
+        using var combo = ImRaii.Combo(comboId, string.Empty, ImGuiComboFlags.NoPreview | ImGuiComboFlags.PopupAlignLeft);
+        if (!combo)
+        {
+            return;
+        }
+
+        if (_openComboHybridEntries is null || !string.Equals(_openComboHybridId, comboId, StringComparison.Ordinal))
+        {
+            var valueSnapshot = value;
+            _openComboHybridEntries = comboEntries
+                .Select(parseEntry)
+                .Where(entry => entry.Id.Contains(valueSnapshot, StringComparison.OrdinalIgnoreCase)
+                    || (entry.Alias is not null && entry.Alias.Contains(valueSnapshot, StringComparison.OrdinalIgnoreCase))
+                    || (entry.Note is not null && entry.Note.Contains(valueSnapshot, StringComparison.OrdinalIgnoreCase)))
+                .OrderBy(entry => entry.Note is null ? entry.AliasOrId : $"{entry.Note} ({entry.AliasOrId})", StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+            _openComboHybridId = comboId;
+        }
+        _comboHybridUsedLastFrame = true;
+
+        // Is there a better way to handle this?
+        var width = ComponentWidth - 2 * ImGui.GetStyle().FramePadding.X - (_openComboHybridEntries.Length > 8 ? ImGui.GetStyle().ScrollbarSize : 0);
+        foreach (var (id, alias, aliasOrId, note) in _openComboHybridEntries)
+        {
+            var selected = !string.IsNullOrEmpty(value)
+                && (string.Equals(id, value, StringComparison.Ordinal) || string.Equals(alias, value, StringComparison.Ordinal));
+            using var font = ImRaii.PushFont(UiBuilder.MonoFont, note is null);
+            if (ImGui.Selectable(note is null ? aliasOrId : $"{note} ({aliasOrId})", selected, ImGuiSelectableFlags.None, new(width, 0)))
+            {
+                value = aliasOrId;
+            }
+        }
+    }
+}

MareSynchronos/UI/CharaDataHubUi.NearbyPoses.cs

@@ -0,0 +1,207 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+internal partial class CharaDataHubUi
+{
+    private void DrawNearbyPoses()
+    {
+        _uiSharedService.BigText("Poses Nearby");
+
+        DrawHelpFoldout("This tab will show you all Shared World Poses nearby you." + Environment.NewLine + Environment.NewLine
+                        + "Shared World Poses are poses in character data that have world data attached to them and are set to shared. "
+                        + "This means that all data that is in 'Shared with You' that has a pose with world data attached to it will be shown here if you are nearby." + Environment.NewLine
+                        + "By default all poses that are shared will be shown. Poses taken in housing areas will by default only be shown on the correct world and location." + Environment.NewLine + Environment.NewLine
+                        + "Shared World Poses will appear in the world as floating wisps, as well as in the list below. You can mouse over a Shared World Pose in the list for it to get highlighted in the world." + Environment.NewLine + Environment.NewLine
+                        + "You can apply Shared World Poses to yourself or spawn the associated character to pose with them." + Environment.NewLine + Environment.NewLine
+                        + "You can adjust the filter and change further settings in the 'Settings & Filter' foldout.");
+
+        UiSharedService.DrawTree("Settings & Filters", () =>
+        {
+            string filterByUser = _charaDataNearbyManager.UserNoteFilter;
+            if (ImGui.InputTextWithHint("##filterbyuser", "Filter by User", ref filterByUser, 50))
+            {
+                _charaDataNearbyManager.UserNoteFilter = filterByUser;
+            }
+            bool onlyCurrent = _configService.Current.NearbyOwnServerOnly;
+            if (ImGui.Checkbox("Only show Poses on current world", ref onlyCurrent))
+            {
+                _configService.Current.NearbyOwnServerOnly = onlyCurrent;
+                _configService.Save();
+            }
+            _uiSharedService.DrawHelpText("Show the location of shared Poses with World Data from current world only");
+            bool showOwn = _configService.Current.NearbyShowOwnData;
+            if (ImGui.Checkbox("Also show your own data", ref showOwn))
+            {
+                _configService.Current.NearbyShowOwnData = showOwn;
+                _configService.Save();
+            }
+            _uiSharedService.DrawHelpText("Show your own Poses as well");
+            bool ignoreHousing = _configService.Current.NearbyIgnoreHousingLimitations;
+            if (ImGui.Checkbox("Ignore Housing Limitations", ref ignoreHousing))
+            {
+                _configService.Current.NearbyIgnoreHousingLimitations = ignoreHousing;
+                _configService.Save();
+            }
+            _uiSharedService.DrawHelpText("Display all poses in their location regardless of housing limitations. (Ignoring Ward, Plot, Room)" + UiSharedService.TooltipSeparator
+                + "Note: Poses that utilize housing props, furniture, etc. will not be displayed correctly if not spawned in the right location.");
+            bool showWisps = _configService.Current.NearbyDrawWisps;
+            if (ImGui.Checkbox("Show Pose Wisps in the overworld", ref showWisps))
+            {
+                _configService.Current.NearbyDrawWisps = showWisps;
+                _configService.Save();
+            }
+            _uiSharedService.DrawHelpText("Draw floating wisps where other's poses are in the world.");
+            int poseDetectionDistance = _configService.Current.NearbyDistanceFilter;
+            ImGui.SetNextItemWidth(100);
+            if (ImGui.SliderInt("Detection Distance", ref poseDetectionDistance, 5, 1000))
+            {
+                _configService.Current.NearbyDistanceFilter = poseDetectionDistance;
+                _configService.Save();
+            }
+            _uiSharedService.DrawHelpText("Maximum distance in which poses will be shown. Set it to the maximum if you want to see all poses on the current map.");
+            bool alwaysShow = _configService.Current.NearbyShowAlways;
+            if (ImGui.Checkbox("Keep active outside Poses Nearby tab", ref alwaysShow))
+            {
+                _configService.Current.NearbyShowAlways = alwaysShow;
+                _configService.Save();
+            }
+            _uiSharedService.DrawHelpText("Continue the calculation of position of wisps etc. active outside of the 'Poses Nearby' tab." + UiSharedService.TooltipSeparator
+                + "Note: The wisps etc. will disappear during combat and performing.");
+        });
+
+        if (!_uiSharedService.IsInGpose)
+        {
+            ImGuiHelpers.ScaledDummy(5);
+            UiSharedService.DrawGroupedCenteredColorText("Spawning and applying pose data is only available in GPose.", ImGuiColors.DalamudYellow);
+            ImGuiHelpers.ScaledDummy(5);
+        }
+
+        DrawUpdateSharedDataButton();
+
+        UiSharedService.DistanceSeparator();
+
+        using var child = ImRaii.Child("nearbyPosesChild", new(0, 0), false, ImGuiWindowFlags.AlwaysAutoResize);
+
+        ImGuiHelpers.ScaledDummy(3f);
+
+        using var indent = ImRaii.PushIndent(5f);
+        if (_charaDataNearbyManager.NearbyData.Count == 0)
+        {
+            UiSharedService.DrawGroupedCenteredColorText("No Shared World Poses found nearby.", ImGuiColors.DalamudYellow);
+        }
+
+        bool wasAnythingHovered = false;
+        int i = 0;
+        foreach (var pose in _charaDataNearbyManager.NearbyData.OrderBy(v => v.Value.Distance))
+        {
+            using var poseId = ImRaii.PushId("nearbyPose" + (i++));
+            var pos = ImGui.GetCursorPos();
+            var circleDiameter = 60f;
+            var circleOriginX = ImGui.GetWindowContentRegionMax().X - circleDiameter - pos.X;
+            float circleOffsetY = 0;
+
+            UiSharedService.DrawGrouped(() =>
+            {
+                string? userNote = _serverConfigurationManager.GetNoteForUid(pose.Key.MetaInfo.Uploader.UID);
+                var noteText = pose.Key.MetaInfo.IsOwnData ? "YOU" : (userNote == null ? pose.Key.MetaInfo.Uploader.AliasOrUID : $"{userNote} ({pose.Key.MetaInfo.Uploader.AliasOrUID})");
+                ImGui.TextUnformatted("Pose by");
+                ImGui.SameLine();
+                UiSharedService.ColorText(noteText, ImGuiColors.ParsedGreen);
+                using (ImRaii.Group())
+                {
+                    UiSharedService.ColorText("Character Data Description", ImGuiColors.DalamudGrey);
+                    ImGui.SameLine();
+                    _uiSharedService.IconText(FontAwesomeIcon.ExternalLinkAlt, ImGuiColors.DalamudGrey);
+                }
+                UiSharedService.AttachToolTip(pose.Key.MetaInfo.Description);
+                UiSharedService.ColorText("Description", ImGuiColors.DalamudGrey);
+                ImGui.SameLine();
+                UiSharedService.TextWrapped(pose.Key.Description ?? "No Pose Description was set", circleOriginX);
+                var posAfterGroup = ImGui.GetCursorPos();
+                var groupHeightCenter = (posAfterGroup.Y - pos.Y) / 2;
+                circleOffsetY = (groupHeightCenter - circleDiameter / 2);
+                if (circleOffsetY < 0) circleOffsetY = 0;
+                ImGui.SetCursorPos(new Vector2(circleOriginX, pos.Y));
+                ImGui.Dummy(new Vector2(circleDiameter, circleDiameter));
+                UiSharedService.AttachToolTip("Click to open corresponding map and set map marker" + UiSharedService.TooltipSeparator
+                    + pose.Key.WorldDataDescriptor);
+                if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+                {
+                    _dalamudUtilService.SetMarkerAndOpenMap(pose.Key.Position, pose.Key.Map);
+                }
+                ImGui.SetCursorPos(posAfterGroup);
+                if (_uiSharedService.IsInGpose)
+                {
+                    GposePoseAction(() =>
+                    {
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowRight, "Apply Pose"))
+                        {
+                            _charaDataManager.ApplyFullPoseDataToGposeTarget(pose.Key);
+                        }
+                    }, $"Apply pose and position to {CharaName(_gposeTarget)}", _hasValidGposeTarget);
+                    ImGui.SameLine();
+                    GposeMetaInfoAction((_) =>
+                    {
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Plus, "Spawn and Pose"))
+                        {
+                            _charaDataManager.SpawnAndApplyWorldTransform(pose.Key.MetaInfo, pose.Key);
+                        }
+                    }, "Spawn actor and apply pose and position", pose.Key.MetaInfo, _hasValidGposeTarget, true);
+                }
+            });
+            if (ImGui.IsItemHovered())
+            {
+                wasAnythingHovered = true;
+                _nearbyHovered = pose.Key;
+            }
+            var drawList = ImGui.GetWindowDrawList();
+            var circleRadius = circleDiameter / 2f;
+            var windowPos = ImGui.GetWindowPos();
+            var scrollX = ImGui.GetScrollX();
+            var scrollY = ImGui.GetScrollY();
+            var circleCenter = new Vector2(windowPos.X + circleOriginX + circleRadius - scrollX, windowPos.Y + pos.Y + circleRadius + circleOffsetY - scrollY);
+            var rads = pose.Value.Direction * (Math.PI / 180);
+
+            float halfConeAngleRadians = 15f * (float)Math.PI / 180f;
+            Vector2 baseDir1 = new Vector2((float)Math.Sin(rads - halfConeAngleRadians), -(float)Math.Cos(rads - halfConeAngleRadians));
+            Vector2 baseDir2 = new Vector2((float)Math.Sin(rads + halfConeAngleRadians), -(float)Math.Cos(rads + halfConeAngleRadians));
+
+            Vector2 coneBase1 = circleCenter + baseDir1 * circleRadius;
+            Vector2 coneBase2 = circleCenter + baseDir2 * circleRadius;
+
+            // Draw the cone as a filled triangle
+            drawList.AddTriangleFilled(circleCenter, coneBase1, coneBase2, UiSharedService.Color(ImGuiColors.ParsedGreen));
+            drawList.AddCircle(circleCenter, circleDiameter / 2, UiSharedService.Color(ImGuiColors.DalamudWhite), 360, 2);
+            var distance = pose.Value.Distance.ToString("0.0") + "y";
+            var textSize = ImGui.CalcTextSize(distance);
+            drawList.AddText(new Vector2(circleCenter.X - textSize.X / 2, circleCenter.Y + textSize.Y / 3f), UiSharedService.Color(ImGuiColors.DalamudWhite), distance);
+
+            ImGuiHelpers.ScaledDummy(3);
+        }
+
+        if (!wasAnythingHovered) _nearbyHovered = null;
+        _charaDataNearbyManager.SetHoveredVfx(_nearbyHovered);
+    }
+
+    private void DrawUpdateSharedDataButton()
+    {
+        using (ImRaii.Disabled(_charaDataManager.GetAllDataTask != null
+            || (_charaDataManager.GetSharedWithYouTimeoutTask != null && !_charaDataManager.GetSharedWithYouTimeoutTask.IsCompleted)))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.ArrowCircleDown, "Update Data Shared With You"))
+            {
+                _ = _charaDataManager.GetAllSharedData(_disposalCts.Token).ContinueWith(u => UpdateFilteredItems());
+            }
+        }
+        if (_charaDataManager.GetSharedWithYouTimeoutTask != null && !_charaDataManager.GetSharedWithYouTimeoutTask.IsCompleted)
+        {
+            UiSharedService.AttachToolTip("You can only refresh all character data from server every minute. Please wait.");
+        }
+    }
+}

MareSynchronos/UI/CompactUI.cs

@@ -0,0 +1,640 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using Dalamud.Utility;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.API.Dto.User;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.UI.Components;
+using MareSynchronos.UI.Handlers;
+using MareSynchronos.WebAPI;
+using MareSynchronos.WebAPI.Files;
+using MareSynchronos.WebAPI.Files.Models;
+using MareSynchronos.WebAPI.SignalR.Utils;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Globalization;
+using System.Numerics;
+using System.Reflection;
+
+namespace MareSynchronos.UI;
+
+public class CompactUi : WindowMediatorSubscriberBase
+{
+    public float TransferPartHeight;
+    public float WindowContentWidth;
+    private readonly ApiController _apiController;
+    private readonly MareConfigService _configService;
+    private readonly ConcurrentDictionary<GameObjectHandler, Dictionary<string, FileDownloadStatus>> _currentDownloads = new();
+    private readonly FileUploadManager _fileTransferManager;
+    private readonly GroupPanel _groupPanel;
+    private readonly PairGroupsUi _pairGroupsUi;
+    private readonly PairManager _pairManager;
+    private readonly SelectGroupForPairUi _selectGroupForPairUi;
+    private readonly SelectPairForGroupUi _selectPairsForGroupUi;
+    private readonly ServerConfigurationManager _serverManager;
+    private readonly Stopwatch _timeout = new();
+    private readonly CharaDataManager _charaDataManager;
+    private readonly UidDisplayHandler _uidDisplayHandler;
+    private readonly UiSharedService _uiSharedService;
+    private bool _buttonState;
+    private string _characterOrCommentFilter = string.Empty;
+    private Pair? _lastAddedUser;
+    private string _lastAddedUserComment = string.Empty;
+    private Vector2 _lastPosition = Vector2.One;
+    private Vector2 _lastSize = Vector2.One;
+    private string _pairToAdd = string.Empty;
+    private int _secretKeyIdx = -1;
+    private bool _showModalForUserAddition;
+    private bool _showSyncShells;
+    private bool _wasOpen;
+
+    public CompactUi(ILogger<CompactUi> logger, UiSharedService uiShared, MareConfigService configService, ApiController apiController, PairManager pairManager, ChatService chatService,
+        ServerConfigurationManager serverManager, MareMediator mediator, FileUploadManager fileTransferManager, UidDisplayHandler uidDisplayHandler, CharaDataManager charaDataManager,
+        PerformanceCollectorService performanceCollectorService)
+        : base(logger, mediator, "###ElezenSyncMainUI", performanceCollectorService)
+    {
+        _uiSharedService = uiShared;
+        _configService = configService;
+        _apiController = apiController;
+        _pairManager = pairManager;
+        _serverManager = serverManager;
+        _fileTransferManager = fileTransferManager;
+        _uidDisplayHandler = uidDisplayHandler;
+        _charaDataManager = charaDataManager;
+        var tagHandler = new TagHandler(_serverManager);
+
+        _groupPanel = new(this, uiShared, _pairManager, chatService, uidDisplayHandler, _configService, _serverManager, _charaDataManager);
+        _selectGroupForPairUi = new(tagHandler, uidDisplayHandler, _uiSharedService);
+        _selectPairsForGroupUi = new(tagHandler, uidDisplayHandler);
+        _pairGroupsUi = new(configService, tagHandler, uidDisplayHandler, apiController, _selectPairsForGroupUi, _uiSharedService);
+
+#if DEBUG
+        string dev = "Dev Build";
+        var ver = Assembly.GetExecutingAssembly().GetName().Version!;
+        WindowName = $"Elezen Sync {dev} ({ver.Major}.{ver.Minor}.{ver.Build})###ElezenSyncMainUIDev";
+        Toggle();
+#else
+        var ver = Assembly.GetExecutingAssembly().GetName().Version!;
+        WindowName = "Elezen Sync " + ver.Major + "." + ver.Minor + "." + ver.Build + "###ElezenSyncMainUI";
+#endif
+        Mediator.Subscribe<SwitchToMainUiMessage>(this, (_) => IsOpen = true);
+        Mediator.Subscribe<SwitchToIntroUiMessage>(this, (_) => IsOpen = false);
+        Mediator.Subscribe<CutsceneStartMessage>(this, (_) => UiSharedService_GposeStart());
+        Mediator.Subscribe<CutsceneEndMessage>(this, (_) => UiSharedService_GposeEnd());
+        Mediator.Subscribe<DownloadStartedMessage>(this, (msg) => _currentDownloads[msg.DownloadId] = msg.DownloadStatus);
+        Mediator.Subscribe<DownloadFinishedMessage>(this, (msg) => _currentDownloads.TryRemove(msg.DownloadId, out _));
+
+        Flags |= ImGuiWindowFlags.NoDocking;
+
+        SizeConstraints = new WindowSizeConstraints()
+        {
+            MinimumSize = new Vector2(350, 400),
+            MaximumSize = new Vector2(350, 2000),
+        };
+    }
+
+    protected override void DrawInternal()
+    {
+        if (_serverManager.CurrentApiUrl.Equals(ApiController.ElezenServiceUri, StringComparison.Ordinal))
+            UiSharedService.AccentColor = new Vector4(1.0f, 0.8666f, 0.06666f, 1.0f);
+        else
+            UiSharedService.AccentColor = ImGuiColors.ParsedGreen;
+        ImGui.SetCursorPosY(ImGui.GetCursorPosY() - ImGui.GetStyle().WindowPadding.Y - 1f * ImGuiHelpers.GlobalScale + ImGui.GetStyle().ItemSpacing.Y);
+        WindowContentWidth = UiSharedService.GetWindowContentRegionWidth();
+        if (!_apiController.IsCurrentVersion)
+        {
+            var ver = _apiController.CurrentClientVersion;
+            var unsupported = "UNSUPPORTED VERSION";
+            using (_uiSharedService.UidFont.Push())
+            {
+                var uidTextSize = ImGui.CalcTextSize(unsupported);
+                ImGui.SetCursorPosX((ImGui.GetWindowContentRegionMax().X + ImGui.GetWindowContentRegionMin().X) / 2 - uidTextSize.X / 2);
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextColored(ImGuiColors.DalamudRed, unsupported);
+            }
+            UiSharedService.ColorTextWrapped($"Your Elezen installation is out of date, the current version is {ver.Major}.{ver.Minor}.{ver.Build}. " +
+                $"It is highly recommended to keep Elezen up to date. Open /xlplugins and update the plugin.", ImGuiColors.DalamudRed);
+        }
+
+        using (ImRaii.PushId("header")) DrawUIDHeader();
+        ImGui.Separator();
+        using (ImRaii.PushId("serverstatus")) DrawServerStatus();
+
+        if (_apiController.ServerState is ServerState.Connected)
+        {
+            var hasShownSyncShells = _showSyncShells;
+
+            ImGui.PushFont(UiBuilder.IconFont);
+            if (!hasShownSyncShells)
+            {
+                ImGui.PushStyleColor(ImGuiCol.Button, ImGui.GetStyle().Colors[(int)ImGuiCol.ButtonHovered]);
+            }
+            if (ImGui.Button(FontAwesomeIcon.User.ToIconString(), new Vector2((UiSharedService.GetWindowContentRegionWidth() - ImGui.GetWindowContentRegionMin().X) / 2, 30 * ImGuiHelpers.GlobalScale)))
+            {
+                _showSyncShells = false;
+            }
+            if (!hasShownSyncShells)
+            {
+                ImGui.PopStyleColor();
+            }
+            ImGui.PopFont();
+            UiSharedService.AttachToolTip("Individual pairs");
+
+            ImGui.SameLine();
+
+            ImGui.PushFont(UiBuilder.IconFont);
+            if (hasShownSyncShells)
+            {
+                ImGui.PushStyleColor(ImGuiCol.Button, ImGui.GetStyle().Colors[(int)ImGuiCol.ButtonHovered]);
+            }
+            if (ImGui.Button(FontAwesomeIcon.UserFriends.ToIconString(), new Vector2((UiSharedService.GetWindowContentRegionWidth() - ImGui.GetWindowContentRegionMin().X) / 2, 30 * ImGuiHelpers.GlobalScale)))
+            {
+                _showSyncShells = true;
+            }
+            if (hasShownSyncShells)
+            {
+                ImGui.PopStyleColor();
+            }
+            ImGui.PopFont();
+
+            UiSharedService.AttachToolTip("Syncshells");
+
+            ImGui.Separator();
+            if (!hasShownSyncShells)
+            {
+                using (ImRaii.PushId("pairlist")) DrawPairList();
+            }
+            else
+            {
+                using (ImRaii.PushId("syncshells")) _groupPanel.DrawSyncshells();
+            }
+            ImGui.Separator();
+            using (ImRaii.PushId("transfers")) DrawTransfers();
+            TransferPartHeight = ImGui.GetCursorPosY() - TransferPartHeight;
+            using (ImRaii.PushId("group-user-popup")) _selectPairsForGroupUi.Draw(_pairManager.DirectPairs);
+            using (ImRaii.PushId("grouping-popup")) _selectGroupForPairUi.Draw();
+        }
+
+        if (_configService.Current.OpenPopupOnAdd && _pairManager.LastAddedUser != null)
+        {
+            _lastAddedUser = _pairManager.LastAddedUser;
+            _pairManager.LastAddedUser = null;
+            ImGui.OpenPopup("Set Notes for New User");
+            _showModalForUserAddition = true;
+            _lastAddedUserComment = string.Empty;
+        }
+
+        if (ImGui.BeginPopupModal("Set Notes for New User", ref _showModalForUserAddition, UiSharedService.PopupWindowFlags))
+        {
+            if (_lastAddedUser == null)
+            {
+                _showModalForUserAddition = false;
+            }
+            else
+            {
+                UiSharedService.TextWrapped($"You have successfully added {_lastAddedUser.UserData.AliasOrUID}. Set a local note for the user in the field below:");
+                ImGui.InputTextWithHint("##noteforuser", $"Note for {_lastAddedUser.UserData.AliasOrUID}", ref _lastAddedUserComment, 100);
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Note"))
+                {
+                    _serverManager.SetNoteForUid(_lastAddedUser.UserData.UID, _lastAddedUserComment);
+                    _lastAddedUser = null;
+                    _lastAddedUserComment = string.Empty;
+                    _showModalForUserAddition = false;
+                }
+            }
+            UiSharedService.SetScaledWindowSize(275);
+            ImGui.EndPopup();
+        }
+
+        var pos = ImGui.GetWindowPos();
+        var size = ImGui.GetWindowSize();
+        if (_lastSize != size || _lastPosition != pos)
+        {
+            _lastSize = size;
+            _lastPosition = pos;
+            Mediator.Publish(new CompactUiChange(_lastSize, _lastPosition));
+        }
+    }
+
+    public override void OnClose()
+    {
+        _uidDisplayHandler.Clear();
+        base.OnClose();
+    }
+
+    private void DrawAddCharacter()
+    {
+        ImGui.Dummy(new(10));
+        var keys = _serverManager.CurrentServer!.SecretKeys;
+        if (keys.Any())
+        {
+            if (_secretKeyIdx == -1) _secretKeyIdx = keys.First().Key;
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Plus, "Add current character with secret key"))
+            {
+                _serverManager.CurrentServer!.Authentications.Add(new MareConfiguration.Models.Authentication()
+                {
+                    CharacterName = _uiSharedService.PlayerName,
+                    WorldId = _uiSharedService.WorldId,
+                    SecretKeyIdx = _secretKeyIdx
+                });
+
+                _serverManager.Save();
+
+                _ = _apiController.CreateConnections();
+            }
+
+            _uiSharedService.DrawCombo("Secret Key##addCharacterSecretKey", keys, (f) => f.Value.FriendlyName, (f) => _secretKeyIdx = f.Key);
+        }
+        else
+        {
+            UiSharedService.ColorTextWrapped("No secret keys are configured for the current server.", ImGuiColors.DalamudYellow);
+        }
+    }
+
+    private void DrawAddPair()
+    {
+        var buttonSize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Plus);
+        ImGui.SetNextItemWidth(UiSharedService.GetWindowContentRegionWidth() - ImGui.GetWindowContentRegionMin().X - buttonSize.X);
+        ImGui.InputTextWithHint("##otheruid", "Other players UID/Alias", ref _pairToAdd, 20);
+        ImGui.SameLine(ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth() - buttonSize.X);
+        var canAdd = !_pairManager.DirectPairs.Any(p => string.Equals(p.UserData.UID, _pairToAdd, StringComparison.Ordinal) || string.Equals(p.UserData.Alias, _pairToAdd, StringComparison.Ordinal));
+        using (ImRaii.Disabled(!canAdd))
+        {
+            if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+            {
+                _ = _apiController.UserAddPair(new(new(_pairToAdd)));
+                _pairToAdd = string.Empty;
+            }
+            UiSharedService.AttachToolTip("Pair with " + (_pairToAdd.IsNullOrEmpty() ? "other user" : _pairToAdd));
+        }
+
+        ImGuiHelpers.ScaledDummy(2);
+    }
+
+    private void DrawFilter()
+    {
+        var playButtonSize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Play);
+
+        var users = GetFilteredUsers();
+        var userCount = users.Count;
+
+        var spacing = userCount > 0
+            ? playButtonSize.X + ImGui.GetStyle().ItemSpacing.X
+            : 0;
+
+        ImGui.SetNextItemWidth(WindowContentWidth - spacing);
+        ImGui.InputTextWithHint("##filter", "Filter for UID/notes", ref _characterOrCommentFilter, 255);
+
+        if (userCount == 0) return;
+
+        var pausedUsers = users.Where(u => u.UserPair!.OwnPermissions.IsPaused() && u.UserPair.OtherPermissions.IsPaired()).ToList();
+        var resumedUsers = users.Where(u => !u.UserPair!.OwnPermissions.IsPaused() && u.UserPair.OtherPermissions.IsPaired()).ToList();
+
+        if (!pausedUsers.Any() && !resumedUsers.Any()) return;
+        ImGui.SameLine();
+
+        switch (_buttonState)
+        {
+            case true when !pausedUsers.Any():
+                _buttonState = false;
+                break;
+
+            case false when !resumedUsers.Any():
+                _buttonState = true;
+                break;
+
+            case true:
+                users = pausedUsers;
+                break;
+
+            case false:
+                users = resumedUsers;
+                break;
+        }
+
+        if (_timeout.ElapsedMilliseconds > 5000)
+            _timeout.Reset();
+
+        var button = _buttonState ? FontAwesomeIcon.Play : FontAwesomeIcon.Pause;
+
+        using (ImRaii.Disabled(_timeout.IsRunning))
+        {
+            if (_uiSharedService.IconButton(button) && UiSharedService.CtrlPressed())
+            {
+                foreach (var entry in users)
+                {
+                    var perm = entry.UserPair!.OwnPermissions;
+                    perm.SetPaused(!perm.IsPaused());
+                    _ = _apiController.UserSetPairPermissions(new UserPermissionsDto(entry.UserData, perm));
+                }
+
+                _timeout.Start();
+                _buttonState = !_buttonState;
+            }
+            if (!_timeout.IsRunning)
+                UiSharedService.AttachToolTip($"Hold Control to {(button == FontAwesomeIcon.Play ? "resume" : "pause")} pairing with {users.Count} out of {userCount} displayed users.");
+            else
+                UiSharedService.AttachToolTip($"Next execution is available at {(5000 - _timeout.ElapsedMilliseconds) / 1000} seconds");
+        }
+    }
+
+    private void DrawPairList()
+    {
+        using (ImRaii.PushId("addpair")) DrawAddPair();
+        using (ImRaii.PushId("pairs")) DrawPairs();
+        TransferPartHeight = ImGui.GetCursorPosY();
+        using (ImRaii.PushId("filter")) DrawFilter();
+    }
+
+    private void DrawPairs()
+    {
+        var ySize = TransferPartHeight == 0
+            ? 1
+            : (ImGui.GetWindowContentRegionMax().Y - ImGui.GetWindowContentRegionMin().Y) - TransferPartHeight - ImGui.GetCursorPosY();
+        var users = GetFilteredUsers().OrderBy(u => u.GetPairSortKey(), StringComparer.Ordinal);
+
+        var onlineUsers = users.Where(u => u.UserPair!.OtherPermissions.IsPaired() && (u.IsOnline || u.UserPair!.OwnPermissions.IsPaused())).Select(c => new DrawUserPair("Online" + c.UserData.UID, c, _uidDisplayHandler, _apiController, Mediator, _selectGroupForPairUi, _uiSharedService, _charaDataManager)).ToList();
+        var visibleUsers = users.Where(u => u.IsVisible).Select(c => new DrawUserPair("Visible" + c.UserData.UID, c, _uidDisplayHandler, _apiController, Mediator, _selectGroupForPairUi, _uiSharedService, _charaDataManager)).ToList();
+        var offlineUsers = users.Where(u => !u.UserPair!.OtherPermissions.IsPaired() || (!u.IsOnline && !u.UserPair!.OwnPermissions.IsPaused())).Select(c => new DrawUserPair("Offline" + c.UserData.UID, c, _uidDisplayHandler, _apiController, Mediator, _selectGroupForPairUi, _uiSharedService, _charaDataManager)).ToList();
+
+        ImGui.BeginChild("list", new Vector2(WindowContentWidth, ySize), border: false);
+
+        _pairGroupsUi.Draw(visibleUsers, onlineUsers, offlineUsers);
+
+        ImGui.EndChild();
+    }
+
+    private void DrawServerStatus()
+    {
+        var buttonSize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Link);
+        var userCount = _apiController.OnlineUsers.ToString(CultureInfo.InvariantCulture);
+        var userSize = ImGui.CalcTextSize(userCount);
+        var textSize = ImGui.CalcTextSize("Users Online");
+        string shardConnection = string.Equals(_apiController.ServerInfo.ShardName, "Main", StringComparison.OrdinalIgnoreCase) ? string.Empty : $"Shard: {_apiController.ServerInfo.ShardName}";
+        var shardTextSize = ImGui.CalcTextSize(shardConnection);
+        var printShard = !string.IsNullOrEmpty(_apiController.ServerInfo.ShardName) && shardConnection != string.Empty;
+
+        if (_apiController.ServerState is ServerState.Connected)
+        {
+            ImGui.SetCursorPosX((ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth()) / 2 - (userSize.X + textSize.X) / 2 - ImGui.GetStyle().ItemSpacing.X / 2);
+            if (!printShard) ImGui.AlignTextToFramePadding();
+            ImGui.TextColored(ImGuiColors.ParsedGreen, userCount);
+            ImGui.SameLine();
+            if (!printShard) ImGui.AlignTextToFramePadding();
+            ImGui.TextUnformatted("Users Online");
+        }
+        else
+        {
+            ImGui.AlignTextToFramePadding();
+            ImGui.TextColored(ImGuiColors.DalamudRed, "Not connected to any server");
+        }
+
+        if (printShard)
+        {
+            ImGui.SetCursorPosY(ImGui.GetCursorPosY() - ImGui.GetStyle().ItemSpacing.Y);
+            ImGui.SetCursorPosX((ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth()) / 2 - shardTextSize.X / 2);
+            ImGui.TextUnformatted(shardConnection);
+        }
+
+        ImGui.SameLine();
+        if (printShard)
+        {
+            ImGui.SetCursorPosY(ImGui.GetCursorPosY() - ((userSize.Y + textSize.Y) / 2 + shardTextSize.Y) / 2 - ImGui.GetStyle().ItemSpacing.Y + buttonSize.Y / 2);
+        }
+        var color = UiSharedService.GetBoolColor(!_serverManager.CurrentServer!.FullPause);
+        var connectedIcon = !_serverManager.CurrentServer.FullPause ? FontAwesomeIcon.Link : FontAwesomeIcon.Unlink;
+
+        if (_apiController.ServerState is ServerState.Connected)
+        {
+            ImGui.SetCursorPosX(0 + ImGui.GetStyle().ItemSpacing.X);
+            if (_uiSharedService.IconButton(FontAwesomeIcon.UserCircle))
+            {
+                Mediator.Publish(new UiToggleMessage(typeof(EditProfileUi)));
+            }
+            UiSharedService.AttachToolTip("Edit your Profile");
+        }
+
+        ImGui.SameLine(ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth() - buttonSize.X);
+        if (printShard)
+        {
+            ImGui.SetCursorPosY(ImGui.GetCursorPosY() - ((userSize.Y + textSize.Y) / 2 + shardTextSize.Y) / 2 - ImGui.GetStyle().ItemSpacing.Y + buttonSize.Y / 2);
+        }
+
+        if (_apiController.ServerState is not (ServerState.Reconnecting or ServerState.Disconnecting))
+        {
+            ImGui.PushStyleColor(ImGuiCol.Text, color);
+            if (_uiSharedService.IconButton(connectedIcon))
+            {
+                _serverManager.CurrentServer.FullPause = !_serverManager.CurrentServer.FullPause;
+                _serverManager.Save();
+                _ = _apiController.CreateConnections();
+            }
+            ImGui.PopStyleColor();
+            UiSharedService.AttachToolTip(!_serverManager.CurrentServer.FullPause ? "Disconnect from " + _serverManager.CurrentServer.ServerName : "Connect to " + _serverManager.CurrentServer.ServerName);
+        }
+    }
+
+    private void DrawTransfers()
+    {
+        var currentUploads = _fileTransferManager.CurrentUploads.ToList();
+
+        if (currentUploads.Any())
+        {
+            ImGui.AlignTextToFramePadding();
+            _uiSharedService.IconText(FontAwesomeIcon.Upload);
+            ImGui.SameLine(35 * ImGuiHelpers.GlobalScale);
+
+            var totalUploads = currentUploads.Count;
+
+            var doneUploads = currentUploads.Count(c => c.IsTransferred);
+            var totalUploaded = currentUploads.Sum(c => c.Transferred);
+            var totalToUpload = currentUploads.Sum(c => c.Total);
+
+            ImGui.TextUnformatted($"{doneUploads}/{totalUploads}");
+            var uploadText = $"({UiSharedService.ByteToString(totalUploaded)}/{UiSharedService.ByteToString(totalToUpload)})";
+            var textSize = ImGui.CalcTextSize(uploadText);
+            ImGui.SameLine(WindowContentWidth - textSize.X);
+            ImGui.TextUnformatted(uploadText);
+        }
+
+        var currentDownloads = _currentDownloads.SelectMany(d => d.Value.Values).ToList();
+
+        if (currentDownloads.Any())
+        {
+            ImGui.AlignTextToFramePadding();
+            _uiSharedService.IconText(FontAwesomeIcon.Download);
+            ImGui.SameLine(35 * ImGuiHelpers.GlobalScale);
+
+            var totalDownloads = currentDownloads.Sum(c => c.TotalFiles);
+            var doneDownloads = currentDownloads.Sum(c => c.TransferredFiles);
+            var totalDownloaded = currentDownloads.Sum(c => c.TransferredBytes);
+            var totalToDownload = currentDownloads.Sum(c => c.TotalBytes);
+
+            ImGui.TextUnformatted($"{doneDownloads}/{totalDownloads}");
+            var downloadText =
+                $"({UiSharedService.ByteToString(totalDownloaded)}/{UiSharedService.ByteToString(totalToDownload)})";
+            var textSize = ImGui.CalcTextSize(downloadText);
+            ImGui.SameLine(WindowContentWidth - textSize.X);
+            ImGui.TextUnformatted(downloadText);
+        }
+
+        var bottomButtonWidth = (WindowContentWidth - ImGui.GetStyle().ItemSpacing.X) / 2;
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.PersonCircleQuestion, "Character Analysis", bottomButtonWidth))
+        {
+            Mediator.Publish(new UiToggleMessage(typeof(DataAnalysisUi)));
+        }
+
+        ImGui.SameLine();
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Running, "Character Data Hub", bottomButtonWidth))
+        {
+            Mediator.Publish(new UiToggleMessage(typeof(CharaDataHubUi)));
+        }
+
+        ImGui.SameLine();
+    }
+
+    private void DrawUIDHeader()
+    {
+        var uidText = GetUidText();
+        var buttonSizeX = 0f;
+        Vector2 uidTextSize;
+
+        using (_uiSharedService.UidFont.Push())
+        {
+            uidTextSize = ImGui.CalcTextSize(uidText);
+        }
+
+        var originalPos = ImGui.GetCursorPos();
+        ImGui.SetWindowFontScale(1.5f);
+        var buttonSize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Cog);
+        buttonSizeX -= buttonSize.X - ImGui.GetStyle().ItemSpacing.X * 2;
+        ImGui.SameLine(ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth() - buttonSize.X);
+        ImGui.SetCursorPosY(originalPos.Y + uidTextSize.Y / 2 - buttonSize.Y / 2);
+        if (_uiSharedService.IconButton(FontAwesomeIcon.Cog))
+        {
+            Mediator.Publish(new OpenSettingsUiMessage());
+        }
+        UiSharedService.AttachToolTip("Open the Elezen Settings");
+
+        ImGui.SameLine(); //Important to draw the uidText consistently
+        ImGui.SetCursorPos(originalPos);
+
+        if (_apiController.ServerState is ServerState.Connected)
+        {
+            buttonSizeX += _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Copy).X - ImGui.GetStyle().ItemSpacing.X * 2;
+            ImGui.SetCursorPosY(originalPos.Y + uidTextSize.Y / 2 - buttonSize.Y / 2);
+            if (_uiSharedService.IconButton(FontAwesomeIcon.Copy))
+            {
+                ImGui.SetClipboardText(_apiController.DisplayName);
+            }
+            UiSharedService.AttachToolTip("Copy your UID to clipboard");
+            ImGui.SameLine();
+        }
+        ImGui.SetWindowFontScale(1f);
+
+        ImGui.SetCursorPosY(originalPos.Y + buttonSize.Y / 2 - uidTextSize.Y / 2 - ImGui.GetStyle().ItemSpacing.Y / 2);
+        ImGui.SetCursorPosX((ImGui.GetWindowContentRegionMax().X + ImGui.GetWindowContentRegionMin().X) / 2 + buttonSizeX - uidTextSize.X / 2);
+        using (_uiSharedService.UidFont.Push())
+            ImGui.TextColored(GetUidColor(), uidText);
+
+        if (_apiController.ServerState is not ServerState.Connected)
+        {
+            UiSharedService.ColorTextWrapped(GetServerError(), GetUidColor());
+            if (_apiController.ServerState is ServerState.NoSecretKey)
+            {
+                DrawAddCharacter();
+            }
+        }
+    }
+
+    private List<Pair> GetFilteredUsers()
+    {
+        return _pairManager.DirectPairs.Where(p =>
+        {
+            if (_characterOrCommentFilter.IsNullOrEmpty()) return true;
+            return p.UserData.AliasOrUID.Contains(_characterOrCommentFilter, StringComparison.OrdinalIgnoreCase) ||
+                   (p.GetNote()?.Contains(_characterOrCommentFilter, StringComparison.OrdinalIgnoreCase) ?? false) ||
+                   (p.PlayerName?.Contains(_characterOrCommentFilter, StringComparison.OrdinalIgnoreCase) ?? false);
+        }).ToList();
+    }
+
+    private string GetServerError()
+    {
+        return _apiController.ServerState switch
+        {
+            ServerState.Connecting => "Attempting to connect to the server.",
+            ServerState.Reconnecting => "Connection to server interrupted, attempting to reconnect to the server.",
+            ServerState.Disconnected => "You are currently disconnected from the sync server.",
+            ServerState.Disconnecting => "Disconnecting from the server",
+            ServerState.Unauthorized => "Server Response: " + _apiController.AuthFailureMessage,
+            ServerState.Offline => "Your selected sync server is currently offline.",
+            ServerState.VersionMisMatch =>
+                "Your plugin or the server you are connecting to is out of date. Please update your plugin now. If you already did so, contact the server provider to update their server to the latest version.",
+            ServerState.RateLimited => "You are rate limited for (re)connecting too often. Disconnect, wait 10 minutes and try again.",
+            ServerState.Connected => string.Empty,
+            ServerState.NoSecretKey => "You have no secret key set for this current character. Use the button below or open the settings and set a secret key for the current character. You can reuse the same secret key for multiple characters.",
+            ServerState.MultiChara => "Your Character Configuration has multiple characters configured with same name and world. You will not be able to connect until you fix this issue. Remove the duplicates from the configuration in Settings -> Service Settings -> Character Management and reconnect manually after.",
+            _ => string.Empty
+        };
+    }
+
+    private Vector4 GetUidColor()
+    {
+        return _apiController.ServerState switch
+        {
+            ServerState.Connecting => ImGuiColors.DalamudYellow,
+            ServerState.Reconnecting => ImGuiColors.DalamudRed,
+            ServerState.Connected => UiSharedService.AccentColor,
+            ServerState.Disconnected => ImGuiColors.DalamudYellow,
+            ServerState.Disconnecting => ImGuiColors.DalamudYellow,
+            ServerState.Unauthorized => ImGuiColors.DalamudRed,
+            ServerState.VersionMisMatch => ImGuiColors.DalamudRed,
+            ServerState.Offline => ImGuiColors.DalamudRed,
+            ServerState.RateLimited => ImGuiColors.DalamudYellow,
+            ServerState.NoSecretKey => ImGuiColors.DalamudYellow,
+            ServerState.MultiChara => ImGuiColors.DalamudYellow,
+            _ => ImGuiColors.DalamudRed
+        };
+    }
+
+    private string GetUidText()
+    {
+        return _apiController.ServerState switch
+        {
+            ServerState.Reconnecting => "Reconnecting",
+            ServerState.Connecting => "Connecting",
+            ServerState.Disconnected => "Disconnected",
+            ServerState.Disconnecting => "Disconnecting",
+            ServerState.Unauthorized => "Unauthorized",
+            ServerState.VersionMisMatch => "Version mismatch",
+            ServerState.Offline => "Unavailable",
+            ServerState.RateLimited => "Rate Limited",
+            ServerState.NoSecretKey => "No Secret Key",
+            ServerState.MultiChara => "Duplicate Characters",
+            ServerState.Connected => _apiController.DisplayName,
+            _ => string.Empty
+        };
+    }
+
+    private void UiSharedService_GposeEnd()
+    {
+        IsOpen = _wasOpen;
+    }
+
+    private void UiSharedService_GposeStart()
+    {
+        _wasOpen = IsOpen;
+        IsOpen = false;
+    }
+}

MareSynchronos/UI/Components/DrawGroupPair.cs

@@ -0,0 +1,376 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.API.Dto.Group;
+using MareSynchronos.API.Dto.User;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.UI.Handlers;
+using MareSynchronos.WebAPI;
+
+namespace MareSynchronos.UI.Components;
+
+public class DrawGroupPair : DrawPairBase
+{
+    protected readonly MareMediator _mediator;
+    private readonly GroupPairFullInfoDto _fullInfoDto;
+    private readonly GroupFullInfoDto _group;
+    private readonly CharaDataManager _charaDataManager;
+
+    public DrawGroupPair(string id, Pair entry, ApiController apiController,
+        MareMediator mareMediator, GroupFullInfoDto group, GroupPairFullInfoDto fullInfoDto,
+        UidDisplayHandler handler, UiSharedService uiSharedService, CharaDataManager charaDataManager)
+        : base(id, entry, apiController, handler, uiSharedService)
+    {
+        _group = group;
+        _fullInfoDto = fullInfoDto;
+        _mediator = mareMediator;
+        _charaDataManager = charaDataManager;
+    }
+
+    protected override void DrawLeftSide(float textPosY, float originalY)
+    {
+        var entryUID = _pair.UserData.AliasOrUID;
+        var entryIsMod = _fullInfoDto.GroupPairStatusInfo.IsModerator();
+        var entryIsOwner = string.Equals(_pair.UserData.UID, _group.OwnerUID, StringComparison.Ordinal);
+        var entryIsPinned = _fullInfoDto.GroupPairStatusInfo.IsPinned();
+        var presenceIcon = _pair.IsVisible ? FontAwesomeIcon.Eye : (_pair.IsOnline ? FontAwesomeIcon.Link : FontAwesomeIcon.Unlink);
+        var presenceColor = (_pair.IsOnline || _pair.IsVisible) ? ImGuiColors.ParsedGreen : ImGuiColors.DalamudRed;
+        var presenceText = entryUID + " is offline";
+
+        ImGui.SetCursorPosY(textPosY);
+        if (_pair.IsPaused)
+        {
+            presenceIcon = FontAwesomeIcon.Question;
+            presenceColor = ImGuiColors.DalamudGrey;
+            presenceText = entryUID + " online status is unknown (paused)";
+
+            ImGui.PushFont(UiBuilder.IconFont);
+            UiSharedService.ColorText(FontAwesomeIcon.PauseCircle.ToIconString(), ImGuiColors.DalamudYellow);
+            ImGui.PopFont();
+
+            UiSharedService.AttachToolTip("Pairing status with " + entryUID + " is paused");
+        }
+        else
+        {
+            ImGui.PushFont(UiBuilder.IconFont);
+            UiSharedService.ColorText(FontAwesomeIcon.Check.ToIconString(), ImGuiColors.ParsedGreen);
+            ImGui.PopFont();
+
+            UiSharedService.AttachToolTip("You are paired with " + entryUID);
+        }
+
+        if (_pair.IsOnline && !_pair.IsVisible) presenceText = entryUID + " is online";
+        else if (_pair.IsOnline && _pair.IsVisible) presenceText = entryUID + " is visible: " + _pair.PlayerName + Environment.NewLine + "Click to target this player";
+
+        ImGui.SameLine();
+        ImGui.SetCursorPosY(textPosY);
+        ImGui.PushFont(UiBuilder.IconFont);
+        UiSharedService.ColorText(presenceIcon.ToIconString(), presenceColor);
+        ImGui.PopFont();
+        if (_pair.IsVisible)
+        {
+            if (ImGui.IsItemClicked())
+            {
+                _mediator.Publish(new TargetPairMessage(_pair));
+            }
+            if (_pair.LastAppliedDataBytes >= 0)
+            {
+                presenceText += UiSharedService.TooltipSeparator;
+                presenceText += ((!_pair.IsVisible) ? "(Last) " : string.Empty) + "Mods Info" + Environment.NewLine;
+                presenceText += "Files Size: " + UiSharedService.ByteToString(_pair.LastAppliedDataBytes, true);
+                if (_pair.LastAppliedApproximateVRAMBytes >= 0)
+                {
+                    presenceText += Environment.NewLine + "Approx. VRAM Usage: " + UiSharedService.ByteToString(_pair.LastAppliedApproximateVRAMBytes, true);
+                }
+                if (_pair.LastAppliedDataTris >= 0)
+                {
+                    presenceText += Environment.NewLine + "Triangle Count (excl. Vanilla): "
+                        + (_pair.LastAppliedDataTris > 1000 ? (_pair.LastAppliedDataTris / 1000d).ToString("0.0'k'") : _pair.LastAppliedDataTris);
+                }
+            }
+        }
+        UiSharedService.AttachToolTip(presenceText);
+
+        if (entryIsOwner)
+        {
+            ImGui.SameLine();
+            ImGui.SetCursorPosY(textPosY);
+            ImGui.PushFont(UiBuilder.IconFont);
+            ImGui.TextUnformatted(FontAwesomeIcon.Crown.ToIconString());
+            ImGui.PopFont();
+            UiSharedService.AttachToolTip("User is owner of this Syncshell");
+        }
+        else if (entryIsMod)
+        {
+            ImGui.SameLine();
+            ImGui.SetCursorPosY(textPosY);
+            ImGui.PushFont(UiBuilder.IconFont);
+            ImGui.TextUnformatted(FontAwesomeIcon.UserShield.ToIconString());
+            ImGui.PopFont();
+            UiSharedService.AttachToolTip("User is moderator of this Syncshell");
+        }
+        else if (entryIsPinned)
+        {
+            ImGui.SameLine();
+            ImGui.SetCursorPosY(textPosY);
+            ImGui.PushFont(UiBuilder.IconFont);
+            ImGui.TextUnformatted(FontAwesomeIcon.Thumbtack.ToIconString());
+            ImGui.PopFont();
+            UiSharedService.AttachToolTip("User is pinned in this Syncshell");
+        }
+    }
+
+    protected override float DrawRightSide(float textPosY, float originalY)
+    {
+        var entryUID = _fullInfoDto.UserAliasOrUID;
+        var entryIsMod = _fullInfoDto.GroupPairStatusInfo.IsModerator();
+        var entryIsOwner = string.Equals(_pair.UserData.UID, _group.OwnerUID, StringComparison.Ordinal);
+        var entryIsPinned = _fullInfoDto.GroupPairStatusInfo.IsPinned();
+        var userIsOwner = string.Equals(_group.OwnerUID, _apiController.UID, StringComparison.OrdinalIgnoreCase);
+        var userIsModerator = _group.GroupUserInfo.IsModerator();
+
+        var soundsDisabled = _fullInfoDto.GroupUserPermissions.IsDisableSounds();
+        var animDisabled = _fullInfoDto.GroupUserPermissions.IsDisableAnimations();
+        var vfxDisabled = _fullInfoDto.GroupUserPermissions.IsDisableVFX();
+        var individualSoundsDisabled = (_pair.UserPair?.OwnPermissions.IsDisableSounds() ?? false) || (_pair.UserPair?.OtherPermissions.IsDisableSounds() ?? false);
+        var individualAnimDisabled = (_pair.UserPair?.OwnPermissions.IsDisableAnimations() ?? false) || (_pair.UserPair?.OtherPermissions.IsDisableAnimations() ?? false);
+        var individualVFXDisabled = (_pair.UserPair?.OwnPermissions.IsDisableVFX() ?? false) || (_pair.UserPair?.OtherPermissions.IsDisableVFX() ?? false);
+
+        bool showShared = _charaDataManager.SharedWithYouData.TryGetValue(_pair.UserData, out var sharedData);
+        bool showInfo = (individualAnimDisabled || individualSoundsDisabled || animDisabled || soundsDisabled);
+        bool showPlus = _pair.UserPair == null;
+        bool showBars = (userIsOwner || (userIsModerator && !entryIsMod && !entryIsOwner)) || !_pair.IsPaused;
+
+        var spacing = ImGui.GetStyle().ItemSpacing.X;
+        var permIcon = (individualAnimDisabled || individualSoundsDisabled || individualVFXDisabled) ? FontAwesomeIcon.ExclamationTriangle
+            : ((soundsDisabled || animDisabled || vfxDisabled) ? FontAwesomeIcon.InfoCircle : FontAwesomeIcon.None);
+        var runningIconWidth = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Running).X;
+        var infoIconWidth = UiSharedService.GetIconSize(permIcon).X;
+        var plusButtonWidth = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Plus).X;
+        var barButtonWidth = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Bars).X;
+
+        var pos = ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth() + spacing
+            - (showShared ? (runningIconWidth + spacing) : 0)
+            - (showInfo ? (infoIconWidth + spacing) : 0)
+            - (showPlus ? (plusButtonWidth + spacing) : 0)
+            - (showBars ? (barButtonWidth + spacing) : 0);
+
+        ImGui.SameLine(pos);
+
+        if (showShared)
+        {
+            _uiSharedService.IconText(FontAwesomeIcon.Running);
+
+            UiSharedService.AttachToolTip($"This user has shared {sharedData!.Count} Character Data Sets with you." + UiSharedService.TooltipSeparator
+                + "Click to open the Character Data Hub and show the entries.");
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+            {
+                _mediator.Publish(new OpenCharaDataHubWithFilterMessage(_pair.UserData));
+            }
+            ImGui.SameLine();
+        }
+
+        if (individualAnimDisabled || individualSoundsDisabled)
+        {
+            ImGui.SetCursorPosY(textPosY);
+            ImGui.PushStyleColor(ImGuiCol.Text, ImGuiColors.DalamudYellow);
+            _uiSharedService.IconText(permIcon);
+            ImGui.PopStyleColor();
+            if (ImGui.IsItemHovered())
+            {
+                ImGui.BeginTooltip();
+
+                ImGui.TextUnformatted("Individual User permissions");
+
+                if (individualSoundsDisabled)
+                {
+                    var userSoundsText = "Sound sync disabled with " + _pair.UserData.AliasOrUID;
+                    _uiSharedService.IconText(FontAwesomeIcon.VolumeOff);
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted(userSoundsText);
+                    ImGui.NewLine();
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted("You: " + (_pair.UserPair!.OwnPermissions.IsDisableSounds() ? "Disabled" : "Enabled") + ", They: " + (_pair.UserPair!.OtherPermissions.IsDisableSounds() ? "Disabled" : "Enabled"));
+                }
+
+                if (individualAnimDisabled)
+                {
+                    var userAnimText = "Animation sync disabled with " + _pair.UserData.AliasOrUID;
+                    _uiSharedService.IconText(FontAwesomeIcon.Stop);
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted(userAnimText);
+                    ImGui.NewLine();
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted("You: " + (_pair.UserPair!.OwnPermissions.IsDisableAnimations() ? "Disabled" : "Enabled") + ", They: " + (_pair.UserPair!.OtherPermissions.IsDisableAnimations() ? "Disabled" : "Enabled"));
+                }
+
+                if (individualVFXDisabled)
+                {
+                    var userVFXText = "VFX sync disabled with " + _pair.UserData.AliasOrUID;
+                    _uiSharedService.IconText(FontAwesomeIcon.Circle);
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted(userVFXText);
+                    ImGui.NewLine();
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted("You: " + (_pair.UserPair!.OwnPermissions.IsDisableVFX() ? "Disabled" : "Enabled") + ", They: " + (_pair.UserPair!.OtherPermissions.IsDisableVFX() ? "Disabled" : "Enabled"));
+                }
+
+                ImGui.EndTooltip();
+            }
+            ImGui.SameLine();
+        }
+        else if ((animDisabled || soundsDisabled))
+        {
+            ImGui.SetCursorPosY(textPosY);
+            _uiSharedService.IconText(permIcon);
+            if (ImGui.IsItemHovered())
+            {
+                ImGui.BeginTooltip();
+
+                ImGui.TextUnformatted("Syncshell User permissions");
+
+                if (soundsDisabled)
+                {
+                    var userSoundsText = "Sound sync disabled by " + _pair.UserData.AliasOrUID;
+                    _uiSharedService.IconText(FontAwesomeIcon.VolumeOff);
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted(userSoundsText);
+                }
+
+                if (animDisabled)
+                {
+                    var userAnimText = "Animation sync disabled by " + _pair.UserData.AliasOrUID;
+                    _uiSharedService.IconText(FontAwesomeIcon.Stop);
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted(userAnimText);
+                }
+
+                if (vfxDisabled)
+                {
+                    var userVFXText = "VFX sync disabled by " + _pair.UserData.AliasOrUID;
+                    _uiSharedService.IconText(FontAwesomeIcon.Circle);
+                    ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                    ImGui.TextUnformatted(userVFXText);
+                }
+
+                ImGui.EndTooltip();
+            }
+            ImGui.SameLine();
+        }
+
+        if (showPlus)
+        {
+            ImGui.SetCursorPosY(originalY);
+
+            if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+            {
+                _ = _apiController.UserAddPair(new UserDto(new(_pair.UserData.UID)));
+            }
+            UiSharedService.AttachToolTip("Pair with " + entryUID + " individually");
+            ImGui.SameLine();
+        }
+
+        if (showBars)
+        {
+            ImGui.SetCursorPosY(originalY);
+
+            if (_uiSharedService.IconButton(FontAwesomeIcon.Bars))
+            {
+                ImGui.OpenPopup("Popup");
+            }
+        }
+
+        if (ImGui.BeginPopup("Popup"))
+        {
+            if ((userIsModerator || userIsOwner) && !(entryIsMod || entryIsOwner))
+            {
+                var pinText = entryIsPinned ? "Unpin user" : "Pin user";
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Thumbtack, pinText))
+                {
+                    ImGui.CloseCurrentPopup();
+                    var userInfo = _fullInfoDto.GroupPairStatusInfo ^ GroupUserInfo.IsPinned;
+                    _ = _apiController.GroupSetUserInfo(new GroupPairUserInfoDto(_fullInfoDto.Group, _fullInfoDto.User, userInfo));
+                }
+                UiSharedService.AttachToolTip("Pin this user to the Syncshell. Pinned users will not be deleted in case of a manually initiated Syncshell clean");
+
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Remove user") && UiSharedService.CtrlPressed())
+                {
+                    ImGui.CloseCurrentPopup();
+                    _ = _apiController.GroupRemoveUser(_fullInfoDto);
+                }
+
+                UiSharedService.AttachToolTip("Hold CTRL and click to remove user " + (_pair.UserData.AliasOrUID) + " from Syncshell");
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.UserSlash, "Ban User"))
+                {
+                    ImGui.CloseCurrentPopup();
+                    _mediator.Publish(new OpenBanUserPopupMessage(_pair, _group));
+                }
+                UiSharedService.AttachToolTip("Ban user from this Syncshell");
+            }
+
+            if (userIsOwner)
+            {
+                string modText = entryIsMod ? "Demod user" : "Mod user";
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.UserShield, modText) && UiSharedService.CtrlPressed())
+                {
+                    ImGui.CloseCurrentPopup();
+                    var userInfo = _fullInfoDto.GroupPairStatusInfo ^ GroupUserInfo.IsModerator;
+                    _ = _apiController.GroupSetUserInfo(new GroupPairUserInfoDto(_fullInfoDto.Group, _fullInfoDto.User, userInfo));
+                }
+                UiSharedService.AttachToolTip("Hold CTRL to change the moderator status for " + (_fullInfoDto.UserAliasOrUID) + Environment.NewLine +
+                    "Moderators can kick, ban/unban, pin/unpin users and clear the Syncshell.");
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Crown, "Transfer Ownership") && UiSharedService.CtrlPressed() && UiSharedService.ShiftPressed())
+                {
+                    ImGui.CloseCurrentPopup();
+                    _ = _apiController.GroupChangeOwnership(_fullInfoDto);
+                }
+                UiSharedService.AttachToolTip("Hold CTRL and SHIFT and click to transfer ownership of this Syncshell to " + (_fullInfoDto.UserAliasOrUID) + Environment.NewLine + "WARNING: This action is irreversible.");
+            }
+
+            if (userIsOwner || (userIsModerator && !(entryIsMod || entryIsOwner)))
+                ImGui.Separator();
+
+            if (_pair.IsVisible)
+            {
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Eye, "Target player"))
+                {
+                    _mediator.Publish(new TargetPairMessage(_pair));
+                    ImGui.CloseCurrentPopup();
+                }
+            }
+            if (!_pair.IsPaused)
+            {
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.User, "Open Profile"))
+                {
+                    _displayHandler.OpenProfile(_pair);
+                    ImGui.CloseCurrentPopup();
+                }
+            }
+            if (_pair.IsVisible)
+            {
+#if DEBUG
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.PersonCircleQuestion, "Open Analysis"))
+                {
+                    _displayHandler.OpenAnalysis(_pair);
+                    ImGui.CloseCurrentPopup();
+                }
+#endif
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Sync, "Reload last data"))
+                {
+                    _pair.ApplyLastReceivedData(forced: true);
+                    ImGui.CloseCurrentPopup();
+                }
+                UiSharedService.AttachToolTip("This reapplies the last received character data to this character");
+            }
+            ImGui.EndPopup();
+        }
+
+        return pos - spacing;
+    }
+}

MareSynchronos/UI/Components/DrawPairBase.cs

@@ -0,0 +1,65 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.UI.Handlers;
+using MareSynchronos.WebAPI;
+
+namespace MareSynchronos.UI.Components;
+
+public abstract class DrawPairBase
+{
+    protected readonly ApiController _apiController;
+    protected readonly UidDisplayHandler _displayHandler;
+    protected readonly UiSharedService _uiSharedService;
+    protected Pair _pair;
+    private readonly string _id;
+
+    protected DrawPairBase(string id, Pair entry, ApiController apiController, UidDisplayHandler uIDDisplayHandler, UiSharedService uiSharedService)
+    {
+        _id = id;
+        _pair = entry;
+        _apiController = apiController;
+        _displayHandler = uIDDisplayHandler;
+        _uiSharedService = uiSharedService;
+    }
+
+    public string ImGuiID => _id;
+    public string UID => _pair.UserData.UID;
+
+    public void DrawPairedClient()
+    {
+        var originalY = ImGui.GetCursorPosY();
+        var pauseIconSize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Play);
+        var textSize = ImGui.CalcTextSize(_pair.UserData.AliasOrUID);
+
+        var startPos = ImGui.GetCursorStartPos();
+
+        var framePadding = ImGui.GetStyle().FramePadding;
+        var lineHeight = textSize.Y + framePadding.Y * 2;
+
+        var off = startPos.Y;
+        var height = UiSharedService.GetWindowContentRegionHeight();
+
+        if ((originalY + off) < -lineHeight || (originalY + off) > height)
+        {
+            ImGui.Dummy(new System.Numerics.Vector2(0f, lineHeight));
+            return;
+        }
+
+        var textPosY = originalY + pauseIconSize.Y / 2 - textSize.Y / 2;
+        DrawLeftSide(textPosY, originalY);
+        ImGui.SameLine();
+        var posX = ImGui.GetCursorPosX();
+        var rightSide = DrawRightSide(textPosY, originalY);
+        DrawName(originalY, posX, rightSide);
+    }
+
+    protected abstract void DrawLeftSide(float textPosY, float originalY);
+
+    protected abstract float DrawRightSide(float textPosY, float originalY);
+
+    private void DrawName(float originalY, float leftSide, float rightSide)
+    {
+        _displayHandler.DrawPairText(_id, _pair, leftSide, originalY, () => rightSide - leftSide);
+    }
+}

MareSynchronos/UI/Components/DrawUserPair.cs

@@ -0,0 +1,306 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.API.Dto.User;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.UI.Handlers;
+using MareSynchronos.WebAPI;
+using System.Numerics;
+
+namespace MareSynchronos.UI.Components;
+
+public class DrawUserPair : DrawPairBase
+{
+    protected readonly MareMediator _mediator;
+    private readonly SelectGroupForPairUi _selectGroupForPairUi;
+    private readonly CharaDataManager _charaDataManager;
+
+    public DrawUserPair(string id, Pair entry, UidDisplayHandler displayHandler, ApiController apiController,
+        MareMediator mareMediator, SelectGroupForPairUi selectGroupForPairUi,
+        UiSharedService uiSharedService, CharaDataManager charaDataManager)
+        : base(id, entry, apiController, displayHandler, uiSharedService)
+    {
+        if (_pair.UserPair == null) throw new ArgumentException("Pair must be UserPair", nameof(entry));
+        _pair = entry;
+        _selectGroupForPairUi = selectGroupForPairUi;
+        _mediator = mareMediator;
+        _charaDataManager = charaDataManager;
+    }
+
+    public bool IsOnline => _pair.IsOnline;
+    public bool IsVisible => _pair.IsVisible;
+    public UserPairDto UserPair => _pair.UserPair!;
+
+    protected override void DrawLeftSide(float textPosY, float originalY)
+    {
+        FontAwesomeIcon connectionIcon;
+        Vector4 connectionColor;
+        string connectionText;
+        if (!(_pair.UserPair!.OwnPermissions.IsPaired() && _pair.UserPair!.OtherPermissions.IsPaired()))
+        {
+            connectionIcon = FontAwesomeIcon.ArrowUp;
+            connectionText = _pair.UserData.AliasOrUID + " has not added you back";
+            connectionColor = ImGuiColors.DalamudRed;
+        }
+        else if (_pair.UserPair!.OwnPermissions.IsPaused() || _pair.UserPair!.OtherPermissions.IsPaused())
+        {
+            connectionIcon = FontAwesomeIcon.PauseCircle;
+            connectionText = "Pairing status with " + _pair.UserData.AliasOrUID + " is paused";
+            connectionColor = ImGuiColors.DalamudYellow;
+        }
+        else
+        {
+            connectionIcon = FontAwesomeIcon.Check;
+            connectionText = "You are paired with " + _pair.UserData.AliasOrUID;
+            connectionColor = ImGuiColors.ParsedGreen;
+        }
+
+        ImGui.SetCursorPosY(textPosY);
+        ImGui.PushFont(UiBuilder.IconFont);
+        UiSharedService.ColorText(connectionIcon.ToIconString(), connectionColor);
+        ImGui.PopFont();
+        UiSharedService.AttachToolTip(connectionText);
+        if (_pair is { IsOnline: true, IsVisible: true })
+        {
+            ImGui.SameLine();
+            ImGui.SetCursorPosY(textPosY);
+            ImGui.PushFont(UiBuilder.IconFont);
+            UiSharedService.ColorText(FontAwesomeIcon.Eye.ToIconString(), ImGuiColors.ParsedGreen);
+            if (ImGui.IsItemClicked())
+            {
+                _mediator.Publish(new TargetPairMessage(_pair));
+            }
+            ImGui.PopFont();
+            var visibleTooltip = _pair.UserData.AliasOrUID + " is visible: " + _pair.PlayerName! + Environment.NewLine + "Click to target this player";
+            if (_pair.LastAppliedDataBytes >= 0)
+            {
+                visibleTooltip += UiSharedService.TooltipSeparator;
+                visibleTooltip += ((!_pair.IsVisible) ? "(Last) " : string.Empty) + "Mods Info" + Environment.NewLine;
+                visibleTooltip += "Files Size: " + UiSharedService.ByteToString(_pair.LastAppliedDataBytes, true);
+                if (_pair.LastAppliedApproximateVRAMBytes >= 0)
+                {
+                    visibleTooltip += Environment.NewLine + "Approx. VRAM Usage: " + UiSharedService.ByteToString(_pair.LastAppliedApproximateVRAMBytes, true);
+                }
+                if (_pair.LastAppliedDataTris >= 0)
+                {
+                    visibleTooltip += Environment.NewLine + "Triangle Count (excl. Vanilla): "
+                        + (_pair.LastAppliedDataTris > 1000 ? (_pair.LastAppliedDataTris / 1000d).ToString("0.0'k'") : _pair.LastAppliedDataTris);
+                }
+            }
+
+            UiSharedService.AttachToolTip(visibleTooltip);
+        }
+    }
+
+    protected override float DrawRightSide(float textPosY, float originalY)
+    {
+        var pauseIcon = _pair.UserPair!.OwnPermissions.IsPaused() ? FontAwesomeIcon.Play : FontAwesomeIcon.Pause;
+        var pauseIconSize = _uiSharedService.GetIconButtonSize(pauseIcon);
+        var barButtonSize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Bars);
+        var entryUID = _pair.UserData.AliasOrUID;
+        var spacingX = ImGui.GetStyle().ItemSpacing.X;
+        var windowEndX = ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth();
+        var rightSidePos = windowEndX - barButtonSize.X;
+
+        // Flyout Menu
+        ImGui.SameLine(rightSidePos);
+        ImGui.SetCursorPosY(originalY);
+
+        if (_uiSharedService.IconButton(FontAwesomeIcon.Bars))
+        {
+            ImGui.OpenPopup("User Flyout Menu");
+        }
+        if (ImGui.BeginPopup("User Flyout Menu"))
+        {
+            using (ImRaii.PushId($"buttons-{_pair.UserData.UID}")) DrawPairedClientMenu(_pair);
+            ImGui.EndPopup();
+        }
+
+        // Pause (mutual pairs only)
+        if (_pair.UserPair!.OwnPermissions.IsPaired() && _pair.UserPair!.OtherPermissions.IsPaired())
+        {
+            rightSidePos -= pauseIconSize.X + spacingX;
+            ImGui.SameLine(rightSidePos);
+            ImGui.SetCursorPosY(originalY);
+            if (_uiSharedService.IconButton(pauseIcon))
+            {
+                var perm = _pair.UserPair!.OwnPermissions;
+                perm.SetPaused(!perm.IsPaused());
+                _ = _apiController.UserSetPairPermissions(new(_pair.UserData, perm));
+            }
+            UiSharedService.AttachToolTip(!_pair.UserPair!.OwnPermissions.IsPaused()
+                ? "Pause pairing with " + entryUID
+                : "Resume pairing with " + entryUID);
+
+
+            var individualSoundsDisabled = (_pair.UserPair?.OwnPermissions.IsDisableSounds() ?? false) || (_pair.UserPair?.OtherPermissions.IsDisableSounds() ?? false);
+            var individualAnimDisabled = (_pair.UserPair?.OwnPermissions.IsDisableAnimations() ?? false) || (_pair.UserPair?.OtherPermissions.IsDisableAnimations() ?? false);
+            var individualVFXDisabled = (_pair.UserPair?.OwnPermissions.IsDisableVFX() ?? false) || (_pair.UserPair?.OtherPermissions.IsDisableVFX() ?? false);
+
+            // Icon for individually applied permissions
+            if (individualSoundsDisabled || individualAnimDisabled || individualVFXDisabled)
+            {
+                var icon = FontAwesomeIcon.ExclamationTriangle;
+                var iconwidth = _uiSharedService.GetIconButtonSize(icon);
+
+                rightSidePos -= iconwidth.X + spacingX / 2f;
+                ImGui.SameLine(rightSidePos);
+
+                ImGui.PushStyleColor(ImGuiCol.Text, ImGuiColors.DalamudYellow);
+                _uiSharedService.IconText(icon);
+                ImGui.PopStyleColor();
+                if (ImGui.IsItemHovered())
+                {
+                    ImGui.BeginTooltip();
+
+                    ImGui.TextUnformatted("Individual User permissions");
+
+                    if (individualSoundsDisabled)
+                    {
+                        var userSoundsText = "Sound sync disabled with " + _pair.UserData.AliasOrUID;
+                        _uiSharedService.IconText(FontAwesomeIcon.VolumeOff);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(userSoundsText);
+                        ImGui.NewLine();
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted("You: " + (_pair.UserPair!.OwnPermissions.IsDisableSounds() ? "Disabled" : "Enabled") + ", They: " + (_pair.UserPair!.OtherPermissions.IsDisableSounds() ? "Disabled" : "Enabled"));
+                    }
+
+                    if (individualAnimDisabled)
+                    {
+                        var userAnimText = "Animation sync disabled with " + _pair.UserData.AliasOrUID;
+                        _uiSharedService.IconText(FontAwesomeIcon.Stop);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(userAnimText);
+                        ImGui.NewLine();
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted("You: " + (_pair.UserPair!.OwnPermissions.IsDisableAnimations() ? "Disabled" : "Enabled") + ", They: " + (_pair.UserPair!.OtherPermissions.IsDisableAnimations() ? "Disabled" : "Enabled"));
+                    }
+
+                    if (individualVFXDisabled)
+                    {
+                        var userVFXText = "VFX sync disabled with " + _pair.UserData.AliasOrUID;
+                        _uiSharedService.IconText(FontAwesomeIcon.Circle);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(userVFXText);
+                        ImGui.NewLine();
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted("You: " + (_pair.UserPair!.OwnPermissions.IsDisableVFX() ? "Disabled" : "Enabled") + ", They: " + (_pair.UserPair!.OtherPermissions.IsDisableVFX() ? "Disabled" : "Enabled"));
+                    }
+
+                    ImGui.EndTooltip();
+                }
+            }
+        }
+
+        // Icon for shared character data
+        if (_charaDataManager.SharedWithYouData.TryGetValue(_pair.UserData, out var sharedData))
+        {
+            var icon = FontAwesomeIcon.Running;
+            var iconwidth = _uiSharedService.GetIconButtonSize(icon);
+            rightSidePos -= iconwidth.X + spacingX / 2f;
+            ImGui.SameLine(rightSidePos);
+            _uiSharedService.IconText(icon);
+
+            UiSharedService.AttachToolTip($"This user has shared {sharedData.Count} Character Data Sets with you." + UiSharedService.TooltipSeparator
+                + "Click to open the Character Data Hub and show the entries.");
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+            {
+                _mediator.Publish(new OpenCharaDataHubWithFilterMessage(_pair.UserData));
+            }
+        }
+
+        return rightSidePos - spacingX;
+    }
+
+    private void DrawPairedClientMenu(Pair entry)
+    {
+        if (entry.IsVisible)
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Eye, "Target player"))
+            {
+                _mediator.Publish(new TargetPairMessage(entry));
+                ImGui.CloseCurrentPopup();
+            }
+        }
+        if (!entry.IsPaused)
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.User, "Open Profile"))
+            {
+                _displayHandler.OpenProfile(entry);
+                ImGui.CloseCurrentPopup();
+            }
+            UiSharedService.AttachToolTip("Opens the profile for this user in a new window");
+        }
+        if (entry.IsVisible)
+        {
+#if DEBUG
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.PersonCircleQuestion, "Open Analysis"))
+            {
+                _displayHandler.OpenAnalysis(_pair);
+                ImGui.CloseCurrentPopup();
+            }
+#endif
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Sync, "Reload last data"))
+            {
+                entry.ApplyLastReceivedData(forced: true);
+                ImGui.CloseCurrentPopup();
+            }
+            UiSharedService.AttachToolTip("This reapplies the last received character data to this character");
+        }
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.PlayCircle, "Cycle pause state"))
+        {
+            _ = _apiController.CyclePause(entry.UserData);
+            ImGui.CloseCurrentPopup();
+        }
+        var entryUID = entry.UserData.AliasOrUID;
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Folder, "Pair Groups"))
+        {
+            _selectGroupForPairUi.Open(entry);
+        }
+        UiSharedService.AttachToolTip("Choose pair groups for " + entryUID);
+
+        var isDisableSounds = entry.UserPair!.OwnPermissions.IsDisableSounds();
+        string disableSoundsText = isDisableSounds ? "Enable sound sync" : "Disable sound sync";
+        var disableSoundsIcon = isDisableSounds ? FontAwesomeIcon.VolumeUp : FontAwesomeIcon.VolumeMute;
+        if (_uiSharedService.IconTextButton(disableSoundsIcon, disableSoundsText))
+        {
+            var permissions = entry.UserPair.OwnPermissions;
+            permissions.SetDisableSounds(!isDisableSounds);
+            _ = _apiController.UserSetPairPermissions(new UserPermissionsDto(entry.UserData, permissions));
+        }
+
+        var isDisableAnims = entry.UserPair!.OwnPermissions.IsDisableAnimations();
+        string disableAnimsText = isDisableAnims ? "Enable animation sync" : "Disable animation sync";
+        var disableAnimsIcon = isDisableAnims ? FontAwesomeIcon.Running : FontAwesomeIcon.Stop;
+        if (_uiSharedService.IconTextButton(disableAnimsIcon, disableAnimsText))
+        {
+            var permissions = entry.UserPair.OwnPermissions;
+            permissions.SetDisableAnimations(!isDisableAnims);
+            _ = _apiController.UserSetPairPermissions(new UserPermissionsDto(entry.UserData, permissions));
+        }
+
+        var isDisableVFX = entry.UserPair!.OwnPermissions.IsDisableVFX();
+        string disableVFXText = isDisableVFX ? "Enable VFX sync" : "Disable VFX sync";
+        var disableVFXIcon = isDisableVFX ? FontAwesomeIcon.Sun : FontAwesomeIcon.Circle;
+        if (_uiSharedService.IconTextButton(disableVFXIcon, disableVFXText))
+        {
+            var permissions = entry.UserPair.OwnPermissions;
+            permissions.SetDisableVFX(!isDisableVFX);
+            _ = _apiController.UserSetPairPermissions(new UserPermissionsDto(entry.UserData, permissions));
+        }
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Unpair Permanently") && UiSharedService.CtrlPressed())
+        {
+            _ = _apiController.UserRemovePair(new(entry.UserData));
+        }
+        UiSharedService.AttachToolTip("Hold CTRL and click to unpair permanently from " + entryUID);
+    }
+}

MareSynchronos/UI/Components/GroupPanel.cs

@@ -0,0 +1,703 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using Dalamud.Utility;
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Data.Comparer;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.API.Dto.Group;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.UI.Components;
+using MareSynchronos.UI.Handlers;
+using MareSynchronos.WebAPI;
+using System.Globalization;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+internal sealed class GroupPanel
+{
+    private readonly Dictionary<string, bool> _expandedGroupState = new(StringComparer.Ordinal);
+    private readonly CompactUi _mainUi;
+    private readonly PairManager _pairManager;
+    private readonly ChatService _chatService;
+    private readonly MareConfigService _mareConfig;
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly CharaDataManager _charaDataManager;
+    private readonly Dictionary<string, bool> _showGidForEntry = new(StringComparer.Ordinal);
+    private readonly UidDisplayHandler _uidDisplayHandler;
+    private readonly UiSharedService _uiShared;
+    private List<BannedGroupUserDto> _bannedUsers = new();
+    private int _bulkInviteCount = 10;
+    private List<string> _bulkOneTimeInvites = new();
+    private string _editGroupComment = string.Empty;
+    private string _editGroupEntry = string.Empty;
+    private bool _errorGroupCreate = false;
+    private bool _errorGroupJoin;
+    private bool _isPasswordValid;
+    private GroupPasswordDto? _lastCreatedGroup = null;
+    private bool _modalBanListOpened;
+    private bool _modalBulkOneTimeInvitesOpened;
+    private bool _modalChangePwOpened;
+    private string _newSyncShellPassword = string.Empty;
+    private bool _showModalBanList = false;
+    private bool _showModalBulkOneTimeInvites = false;
+    private bool _showModalChangePassword;
+    private bool _showModalCreateGroup;
+    private bool _showModalEnterPassword;
+    private string _syncShellPassword = string.Empty;
+    private string _syncShellToJoin = string.Empty;
+
+    public GroupPanel(CompactUi mainUi, UiSharedService uiShared, PairManager pairManager, ChatService chatServivce,
+        UidDisplayHandler uidDisplayHandler, MareConfigService mareConfig, ServerConfigurationManager serverConfigurationManager,
+        CharaDataManager charaDataManager)
+    {
+        _mainUi = mainUi;
+        _uiShared = uiShared;
+        _pairManager = pairManager;
+        _chatService = chatServivce;
+        _uidDisplayHandler = uidDisplayHandler;
+        _mareConfig = mareConfig;
+        _serverConfigurationManager = serverConfigurationManager;
+        _charaDataManager = charaDataManager;
+    }
+
+    private ApiController ApiController => _uiShared.ApiController;
+
+    public void DrawSyncshells()
+    {
+        using (ImRaii.PushId("addsyncshell")) DrawAddSyncshell();
+        using (ImRaii.PushId("syncshelllist")) DrawSyncshellList();
+        _mainUi.TransferPartHeight = ImGui.GetCursorPosY();
+    }
+
+    private void DrawAddSyncshell()
+    {
+        var buttonSize = _uiShared.GetIconButtonSize(FontAwesomeIcon.Plus);
+        ImGui.SetNextItemWidth(UiSharedService.GetWindowContentRegionWidth() - ImGui.GetWindowContentRegionMin().X - buttonSize.X);
+        ImGui.InputTextWithHint("##syncshellid", "Syncshell GID/Alias (leave empty to create)", ref _syncShellToJoin, 20);
+        ImGui.SameLine(ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth() - buttonSize.X);
+
+        bool userCanJoinMoreGroups = _pairManager.GroupPairs.Count < ApiController.ServerInfo.MaxGroupsJoinedByUser;
+        bool userCanCreateMoreGroups = _pairManager.GroupPairs.Count(u => string.Equals(u.Key.Owner.UID, ApiController.UID, StringComparison.Ordinal)) < ApiController.ServerInfo.MaxGroupsCreatedByUser;
+        bool alreadyInGroup = _pairManager.GroupPairs.Select(p => p.Key).Any(p => string.Equals(p.Group.Alias, _syncShellToJoin, StringComparison.Ordinal)
+            || string.Equals(p.Group.GID, _syncShellToJoin, StringComparison.Ordinal));
+
+        if (alreadyInGroup) ImGui.BeginDisabled();
+        if (_uiShared.IconButton(FontAwesomeIcon.Plus))
+        {
+            if (!string.IsNullOrEmpty(_syncShellToJoin))
+            {
+                if (userCanJoinMoreGroups)
+                {
+                    _errorGroupJoin = false;
+                    _showModalEnterPassword = true;
+                    ImGui.OpenPopup("Enter Syncshell Password");
+                }
+            }
+            else
+            {
+                if (userCanCreateMoreGroups)
+                {
+                    _lastCreatedGroup = null;
+                    _errorGroupCreate = false;
+                    _showModalCreateGroup = true;
+                    ImGui.OpenPopup("Create Syncshell");
+                }
+            }
+        }
+        UiSharedService.AttachToolTip(_syncShellToJoin.IsNullOrEmpty()
+            ? (userCanCreateMoreGroups ? "Create Syncshell" : $"You cannot create more than {ApiController.ServerInfo.MaxGroupsCreatedByUser} Syncshells")
+            : (userCanJoinMoreGroups ? "Join Syncshell" + _syncShellToJoin : $"You cannot join more than {ApiController.ServerInfo.MaxGroupsJoinedByUser} Syncshells"));
+
+        if (alreadyInGroup) ImGui.EndDisabled();
+
+        if (ImGui.BeginPopupModal("Enter Syncshell Password", ref _showModalEnterPassword, UiSharedService.PopupWindowFlags))
+        {
+            UiSharedService.TextWrapped("Before joining any Syncshells please be aware that you will be automatically paired with everyone in the Syncshell.");
+            ImGui.Separator();
+            UiSharedService.TextWrapped("Enter the password for Syncshell " + _syncShellToJoin + ":");
+            ImGui.SetNextItemWidth(-1);
+            ImGui.InputTextWithHint("##password", _syncShellToJoin + " Password", ref _syncShellPassword, 255, ImGuiInputTextFlags.Password);
+            if (_errorGroupJoin)
+            {
+                UiSharedService.ColorTextWrapped($"An error occured during joining of this Syncshell: you either have joined the maximum amount of Syncshells ({ApiController.ServerInfo.MaxGroupsJoinedByUser}), " +
+                    $"it does not exist, the password you entered is wrong, you already joined the Syncshell, the Syncshell is full ({ApiController.ServerInfo.MaxGroupUserCount} users) or the Syncshell has closed invites.",
+                    new Vector4(1, 0, 0, 1));
+            }
+            if (ImGui.Button("Join " + _syncShellToJoin))
+            {
+                var shell = _syncShellToJoin;
+                var pw = _syncShellPassword;
+                _errorGroupJoin = !ApiController.GroupJoin(new(new GroupData(shell), pw)).Result;
+                if (!_errorGroupJoin)
+                {
+                    _syncShellToJoin = string.Empty;
+                    _showModalEnterPassword = false;
+                }
+                _syncShellPassword = string.Empty;
+            }
+            UiSharedService.SetScaledWindowSize(290);
+            ImGui.EndPopup();
+        }
+
+        if (ImGui.BeginPopupModal("Create Syncshell", ref _showModalCreateGroup, UiSharedService.PopupWindowFlags))
+        {
+            UiSharedService.TextWrapped("Press the button below to create a new Syncshell.");
+            ImGui.SetNextItemWidth(200 * ImGuiHelpers.GlobalScale);
+            if (ImGui.Button("Create Syncshell"))
+            {
+                try
+                {
+                    _lastCreatedGroup = ApiController.GroupCreate().Result;
+                }
+                catch
+                {
+                    _lastCreatedGroup = null;
+                    _errorGroupCreate = true;
+                }
+            }
+
+            if (_lastCreatedGroup != null)
+            {
+                ImGui.Separator();
+                _errorGroupCreate = false;
+                ImGui.TextUnformatted("Syncshell ID: " + _lastCreatedGroup.Group.GID);
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextUnformatted("Syncshell Password: " + _lastCreatedGroup.Password);
+                ImGui.SameLine();
+                if (_uiShared.IconButton(FontAwesomeIcon.Copy))
+                {
+                    ImGui.SetClipboardText(_lastCreatedGroup.Password);
+                }
+                UiSharedService.TextWrapped("You can change the Syncshell password later at any time.");
+            }
+
+            if (_errorGroupCreate)
+            {
+                UiSharedService.ColorTextWrapped("You are already owner of the maximum amount of Syncshells (3) or joined the maximum amount of Syncshells (6). Relinquish ownership of your own Syncshells to someone else or leave existing Syncshells.",
+                    new Vector4(1, 0, 0, 1));
+            }
+
+            UiSharedService.SetScaledWindowSize(350);
+            ImGui.EndPopup();
+        }
+
+        ImGuiHelpers.ScaledDummy(2);
+    }
+
+    private void DrawSyncshell(GroupFullInfoDto groupDto, List<Pair> pairsInGroup)
+    {
+        int shellNumber = _serverConfigurationManager.GetShellNumberForGid(groupDto.GID);
+
+        var name = groupDto.Group.Alias ?? groupDto.GID;
+        if (!_expandedGroupState.TryGetValue(groupDto.GID, out bool isExpanded))
+        {
+            isExpanded = false;
+            _expandedGroupState.Add(groupDto.GID, isExpanded);
+        }
+
+        var icon = isExpanded ? FontAwesomeIcon.CaretSquareDown : FontAwesomeIcon.CaretSquareRight;
+        _uiShared.IconText(icon);
+        if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+        {
+            _expandedGroupState[groupDto.GID] = !_expandedGroupState[groupDto.GID];
+        }
+        ImGui.SameLine();
+
+        var textIsGid = true;
+        string groupName = groupDto.GroupAliasOrGID;
+
+        if (string.Equals(groupDto.OwnerUID, ApiController.UID, StringComparison.Ordinal))
+        {
+            ImGui.PushFont(UiBuilder.IconFont);
+            ImGui.TextUnformatted(FontAwesomeIcon.Crown.ToIconString());
+            ImGui.PopFont();
+            UiSharedService.AttachToolTip("You are the owner of Syncshell " + groupName);
+            ImGui.SameLine();
+        }
+        else if (groupDto.GroupUserInfo.IsModerator())
+        {
+            ImGui.PushFont(UiBuilder.IconFont);
+            ImGui.TextUnformatted(FontAwesomeIcon.UserShield.ToIconString());
+            ImGui.PopFont();
+            UiSharedService.AttachToolTip("You are a moderator of Syncshell " + groupName);
+            ImGui.SameLine();
+        }
+
+        _showGidForEntry.TryGetValue(groupDto.GID, out var showGidInsteadOfName);
+        var groupComment = _serverConfigurationManager.GetNoteForGid(groupDto.GID);
+        if (!showGidInsteadOfName && !string.IsNullOrEmpty(groupComment))
+        {
+            groupName = groupComment;
+            textIsGid = false;
+        }
+
+        if (!string.Equals(_editGroupEntry, groupDto.GID, StringComparison.Ordinal))
+        {
+            var shellConfig = _serverConfigurationManager.GetShellConfigForGid(groupDto.GID);
+            if (!_mareConfig.Current.DisableSyncshellChat && shellConfig.Enabled)
+            {
+                ImGui.TextUnformatted($"[{shellNumber}]");
+                UiSharedService.AttachToolTip("Chat command prefix: /ss" + shellNumber);
+            }
+            if (textIsGid) ImGui.PushFont(UiBuilder.MonoFont);
+            ImGui.SameLine();
+            ImGui.TextUnformatted(groupName);
+            if (textIsGid) ImGui.PopFont();
+            UiSharedService.AttachToolTip("Left click to switch between GID display and comment" + Environment.NewLine +
+                          "Right click to change comment for " + groupName + Environment.NewLine + Environment.NewLine
+                          + "Users: " + (pairsInGroup.Count + 1) + ", Owner: " + groupDto.OwnerAliasOrUID);
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+            {
+                var prevState = textIsGid;
+                if (_showGidForEntry.ContainsKey(groupDto.GID))
+                {
+                    prevState = _showGidForEntry[groupDto.GID];
+                }
+
+                _showGidForEntry[groupDto.GID] = !prevState;
+            }
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Right))
+            {
+                _serverConfigurationManager.SetNoteForGid(_editGroupEntry, _editGroupComment);
+                _editGroupComment = _serverConfigurationManager.GetNoteForGid(groupDto.GID) ?? string.Empty;
+                _editGroupEntry = groupDto.GID;
+                _chatService.MaybeUpdateShellName(shellNumber);
+            }
+        }
+        else
+        {
+            var buttonSizes = _uiShared.GetIconButtonSize(FontAwesomeIcon.Bars).X + _uiShared.GetIconButtonSize(FontAwesomeIcon.LockOpen).X;
+            ImGui.SetNextItemWidth(UiSharedService.GetWindowContentRegionWidth() - ImGui.GetCursorPosX() - buttonSizes - ImGui.GetStyle().ItemSpacing.X * 2);
+            if (ImGui.InputTextWithHint("", "Comment/Notes", ref _editGroupComment, 255, ImGuiInputTextFlags.EnterReturnsTrue))
+            {
+                _serverConfigurationManager.SetNoteForGid(groupDto.GID, _editGroupComment);
+                _editGroupEntry = string.Empty;
+                _chatService.MaybeUpdateShellName(shellNumber);
+            }
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Right))
+            {
+                _editGroupEntry = string.Empty;
+            }
+            UiSharedService.AttachToolTip("Hit ENTER to save\nRight click to cancel");
+        }
+
+
+        using (ImRaii.PushId(groupDto.GID + "settings")) DrawSyncShellButtons(groupDto, pairsInGroup);
+
+        if (_showModalBanList && !_modalBanListOpened)
+        {
+            _modalBanListOpened = true;
+            ImGui.OpenPopup("Manage Banlist for " + groupDto.GID);
+        }
+
+        if (!_showModalBanList) _modalBanListOpened = false;
+
+        if (ImGui.BeginPopupModal("Manage Banlist for " + groupDto.GID, ref _showModalBanList, UiSharedService.PopupWindowFlags))
+        {
+            if (_uiShared.IconTextButton(FontAwesomeIcon.Retweet, "Refresh Banlist from Server"))
+            {
+                _bannedUsers = ApiController.GroupGetBannedUsers(groupDto).Result;
+            }
+
+            if (ImGui.BeginTable("bannedusertable" + groupDto.GID, 6, ImGuiTableFlags.RowBg | ImGuiTableFlags.SizingStretchProp | ImGuiTableFlags.ScrollY))
+            {
+                ImGui.TableSetupColumn("UID", ImGuiTableColumnFlags.None, 1);
+                ImGui.TableSetupColumn("Alias", ImGuiTableColumnFlags.None, 1);
+                ImGui.TableSetupColumn("By", ImGuiTableColumnFlags.None, 1);
+                ImGui.TableSetupColumn("Date", ImGuiTableColumnFlags.None, 2);
+                ImGui.TableSetupColumn("Reason", ImGuiTableColumnFlags.None, 3);
+                ImGui.TableSetupColumn("Actions", ImGuiTableColumnFlags.None, 1);
+
+                ImGui.TableHeadersRow();
+
+                foreach (var bannedUser in _bannedUsers.ToList())
+                {
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(bannedUser.UID);
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(bannedUser.UserAlias ?? string.Empty);
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(bannedUser.BannedBy);
+                    ImGui.TableNextColumn();
+                    ImGui.TextUnformatted(bannedUser.BannedOn.ToLocalTime().ToString(CultureInfo.CurrentCulture));
+                    ImGui.TableNextColumn();
+                    UiSharedService.TextWrapped(bannedUser.Reason);
+                    ImGui.TableNextColumn();
+                    if (_uiShared.IconTextButton(FontAwesomeIcon.Check, "Unban#" + bannedUser.UID))
+                    {
+                        _ = ApiController.GroupUnbanUser(bannedUser);
+                        _bannedUsers.RemoveAll(b => string.Equals(b.UID, bannedUser.UID, StringComparison.Ordinal));
+                    }
+                }
+
+                ImGui.EndTable();
+            }
+            UiSharedService.SetScaledWindowSize(700, 300);
+            ImGui.EndPopup();
+        }
+
+        if (_showModalChangePassword && !_modalChangePwOpened)
+        {
+            _modalChangePwOpened = true;
+            ImGui.OpenPopup("Change Syncshell Password");
+        }
+
+        if (!_showModalChangePassword) _modalChangePwOpened = false;
+
+        if (ImGui.BeginPopupModal("Change Syncshell Password", ref _showModalChangePassword, UiSharedService.PopupWindowFlags))
+        {
+            UiSharedService.TextWrapped("Enter the new Syncshell password for Syncshell " + name + " here.");
+            UiSharedService.TextWrapped("This action is irreversible");
+            ImGui.SetNextItemWidth(-1);
+            ImGui.InputTextWithHint("##changepw", "New password for " + name, ref _newSyncShellPassword, 255);
+            if (ImGui.Button("Change password"))
+            {
+                var pw = _newSyncShellPassword;
+                _isPasswordValid = ApiController.GroupChangePassword(new(groupDto.Group, pw)).Result;
+                _newSyncShellPassword = string.Empty;
+                if (_isPasswordValid) _showModalChangePassword = false;
+            }
+
+            if (!_isPasswordValid)
+            {
+                UiSharedService.ColorTextWrapped("The selected password is too short. It must be at least 10 characters.", new Vector4(1, 0, 0, 1));
+            }
+
+            UiSharedService.SetScaledWindowSize(290);
+            ImGui.EndPopup();
+        }
+
+        if (_showModalBulkOneTimeInvites && !_modalBulkOneTimeInvitesOpened)
+        {
+            _modalBulkOneTimeInvitesOpened = true;
+            ImGui.OpenPopup("Create Bulk One-Time Invites");
+        }
+
+        if (!_showModalBulkOneTimeInvites) _modalBulkOneTimeInvitesOpened = false;
+
+        if (ImGui.BeginPopupModal("Create Bulk One-Time Invites", ref _showModalBulkOneTimeInvites, UiSharedService.PopupWindowFlags))
+        {
+            UiSharedService.TextWrapped("This allows you to create up to 100 one-time invites at once for the Syncshell " + name + "." + Environment.NewLine
+                + "The invites are valid for 24h after creation and will automatically expire.");
+            ImGui.Separator();
+            if (_bulkOneTimeInvites.Count == 0)
+            {
+                ImGui.SetNextItemWidth(-1);
+                ImGui.SliderInt("Amount##bulkinvites", ref _bulkInviteCount, 1, 100);
+                if (_uiShared.IconTextButton(FontAwesomeIcon.MailBulk, "Create invites"))
+                {
+                    _bulkOneTimeInvites = ApiController.GroupCreateTempInvite(groupDto, _bulkInviteCount).Result;
+                }
+            }
+            else
+            {
+                UiSharedService.TextWrapped("A total of " + _bulkOneTimeInvites.Count + " invites have been created.");
+                if (_uiShared.IconTextButton(FontAwesomeIcon.Copy, "Copy invites to clipboard"))
+                {
+                    ImGui.SetClipboardText(string.Join(Environment.NewLine, _bulkOneTimeInvites));
+                }
+            }
+
+            UiSharedService.SetScaledWindowSize(290);
+            ImGui.EndPopup();
+        }
+
+        bool hideOfflineUsers = pairsInGroup.Count > 1000;
+
+        ImGui.Indent(20);
+        if (_expandedGroupState[groupDto.GID])
+        {
+            var sortedPairs = pairsInGroup
+                .OrderByDescending(u => string.Equals(u.UserData.UID, groupDto.OwnerUID, StringComparison.Ordinal))
+                .ThenByDescending(u => u.GroupPair[groupDto].GroupPairStatusInfo.IsModerator())
+                .ThenByDescending(u => u.GroupPair[groupDto].GroupPairStatusInfo.IsPinned())
+                .ThenBy(u => u.GetPairSortKey(), StringComparer.OrdinalIgnoreCase);
+
+            var visibleUsers = new List<DrawGroupPair>();
+            var onlineUsers = new List<DrawGroupPair>();
+            var offlineUsers = new List<DrawGroupPair>();
+
+            foreach (var pair in sortedPairs)
+            {
+                var drawPair = new DrawGroupPair(
+                    groupDto.GID + pair.UserData.UID, pair,
+                    ApiController, _mainUi.Mediator, groupDto,
+                    pair.GroupPair.Single(
+                        g => GroupDataComparer.Instance.Equals(g.Key.Group, groupDto.Group)
+                    ).Value,
+                    _uidDisplayHandler,
+                    _uiShared,
+                    _charaDataManager);
+
+                if (pair.IsVisible)
+                    visibleUsers.Add(drawPair);
+                else if (pair.IsOnline)
+                    onlineUsers.Add(drawPair);
+                else
+                    offlineUsers.Add(drawPair);
+            }
+
+            if (visibleUsers.Count > 0)
+            {
+                ImGui.TextUnformatted("Visible");
+                ImGui.Separator();
+                _uidDisplayHandler.RenderPairList(visibleUsers);
+            }
+
+            if (onlineUsers.Count > 0)
+            {
+                ImGui.TextUnformatted("Online");
+                ImGui.Separator();
+                _uidDisplayHandler.RenderPairList(onlineUsers);
+            }
+
+            if (offlineUsers.Count > 0)
+            {
+                ImGui.TextUnformatted("Offline/Unknown");
+                ImGui.Separator();
+                if (hideOfflineUsers)
+                {
+                    UiSharedService.ColorText($"    {offlineUsers.Count} offline users omitted from display.", ImGuiColors.DalamudGrey);
+                }
+                else
+                {
+                    _uidDisplayHandler.RenderPairList(offlineUsers);
+                }
+            }
+
+            ImGui.Separator();
+        }
+        ImGui.Unindent(20);
+    }
+
+    private void DrawSyncShellButtons(GroupFullInfoDto groupDto, List<Pair> groupPairs)
+    {
+        var infoIcon = FontAwesomeIcon.InfoCircle;
+
+        bool invitesEnabled = !groupDto.GroupPermissions.IsDisableInvites();
+        var soundsDisabled = groupDto.GroupPermissions.IsDisableSounds();
+        var animDisabled = groupDto.GroupPermissions.IsDisableAnimations();
+        var vfxDisabled = groupDto.GroupPermissions.IsDisableVFX();
+
+        var userSoundsDisabled = groupDto.GroupUserPermissions.IsDisableSounds();
+        var userAnimDisabled = groupDto.GroupUserPermissions.IsDisableAnimations();
+        var userVFXDisabled = groupDto.GroupUserPermissions.IsDisableVFX();
+
+        bool showInfoIcon = !invitesEnabled || soundsDisabled || animDisabled || vfxDisabled || userSoundsDisabled || userAnimDisabled || userVFXDisabled;
+
+        var lockedIcon = invitesEnabled ? FontAwesomeIcon.LockOpen : FontAwesomeIcon.Lock;
+        var animIcon = animDisabled ? FontAwesomeIcon.Stop : FontAwesomeIcon.Running;
+        var soundsIcon = soundsDisabled ? FontAwesomeIcon.VolumeOff : FontAwesomeIcon.VolumeUp;
+        var vfxIcon = vfxDisabled ? FontAwesomeIcon.Circle : FontAwesomeIcon.Sun;
+        var userAnimIcon = userAnimDisabled ? FontAwesomeIcon.Stop : FontAwesomeIcon.Running;
+        var userSoundsIcon = userSoundsDisabled ? FontAwesomeIcon.VolumeOff : FontAwesomeIcon.VolumeUp;
+        var userVFXIcon = userVFXDisabled ? FontAwesomeIcon.Circle : FontAwesomeIcon.Sun;
+
+        var iconSize = UiSharedService.GetIconSize(infoIcon);
+        var barbuttonSize = _uiShared.GetIconButtonSize(FontAwesomeIcon.Bars);
+        var isOwner = string.Equals(groupDto.OwnerUID, ApiController.UID, StringComparison.Ordinal);
+
+        var spacingX = ImGui.GetStyle().ItemSpacing.X;
+        var windowEndX = ImGui.GetWindowContentRegionMin().X + UiSharedService.GetWindowContentRegionWidth();
+        var pauseIcon = groupDto.GroupUserPermissions.IsPaused() ? FontAwesomeIcon.Play : FontAwesomeIcon.Pause;
+        var pauseIconSize = _uiShared.GetIconButtonSize(pauseIcon);
+
+        ImGui.SameLine(windowEndX - barbuttonSize.X - (showInfoIcon ? iconSize.X : 0) - (showInfoIcon ? spacingX : 0) - pauseIconSize.X - spacingX);
+
+        if (showInfoIcon)
+        {
+            _uiShared.IconText(infoIcon);
+            if (ImGui.IsItemHovered())
+            {
+                ImGui.BeginTooltip();
+                if (!invitesEnabled || soundsDisabled || animDisabled || vfxDisabled)
+                {
+                    ImGui.TextUnformatted("Syncshell permissions");
+
+                    if (!invitesEnabled)
+                    {
+                        var lockedText = "Syncshell is closed for joining";
+                        _uiShared.IconText(lockedIcon);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(lockedText);
+                    }
+
+                    if (soundsDisabled)
+                    {
+                        var soundsText = "Sound sync disabled through owner";
+                        _uiShared.IconText(soundsIcon);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(soundsText);
+                    }
+
+                    if (animDisabled)
+                    {
+                        var animText = "Animation sync disabled through owner";
+                        _uiShared.IconText(animIcon);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(animText);
+                    }
+
+                    if (vfxDisabled)
+                    {
+                        var vfxText = "VFX sync disabled through owner";
+                        _uiShared.IconText(vfxIcon);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(vfxText);
+                    }
+                }
+
+                if (userSoundsDisabled || userAnimDisabled || userVFXDisabled)
+                {
+                    if (!invitesEnabled || soundsDisabled || animDisabled || vfxDisabled)
+                        ImGui.Separator();
+
+                    ImGui.TextUnformatted("Your permissions");
+
+                    if (userSoundsDisabled)
+                    {
+                        var userSoundsText = "Sound sync disabled through you";
+                        _uiShared.IconText(userSoundsIcon);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(userSoundsText);
+                    }
+
+                    if (userAnimDisabled)
+                    {
+                        var userAnimText = "Animation sync disabled through you";
+                        _uiShared.IconText(userAnimIcon);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(userAnimText);
+                    }
+
+                    if (userVFXDisabled)
+                    {
+                        var userVFXText = "VFX sync disabled through you";
+                        _uiShared.IconText(userVFXIcon);
+                        ImGui.SameLine(40 * ImGuiHelpers.GlobalScale);
+                        ImGui.TextUnformatted(userVFXText);
+                    }
+
+                    if (!invitesEnabled || soundsDisabled || animDisabled || vfxDisabled)
+                        UiSharedService.TextWrapped("Note that syncshell permissions for disabling take precedence over your own set permissions");
+                }
+                ImGui.EndTooltip();
+            }
+            ImGui.SameLine();
+        }
+
+        if (_uiShared.IconButton(pauseIcon))
+        {
+            var userPerm = groupDto.GroupUserPermissions ^ GroupUserPermissions.Paused;
+            _ = ApiController.GroupChangeIndividualPermissionState(new GroupPairUserPermissionDto(groupDto.Group, new UserData(ApiController.UID), userPerm));
+        }
+        UiSharedService.AttachToolTip((groupDto.GroupUserPermissions.IsPaused() ? "Resume" : "Pause") + " pairing with all users in this Syncshell");
+        ImGui.SameLine();
+
+        if (_uiShared.IconButton(FontAwesomeIcon.Bars))
+        {
+            ImGui.OpenPopup("ShellPopup");
+        }
+
+        if (ImGui.BeginPopup("ShellPopup"))
+        {
+            if (_uiShared.IconTextButton(FontAwesomeIcon.ArrowCircleLeft, "Leave Syncshell") && UiSharedService.CtrlPressed())
+            {
+                _ = ApiController.GroupLeave(groupDto);
+            }
+            UiSharedService.AttachToolTip("Hold CTRL and click to leave this Syncshell" + (!string.Equals(groupDto.OwnerUID, ApiController.UID, StringComparison.Ordinal) ? string.Empty : Environment.NewLine
+                + "WARNING: This action is irreversible" + Environment.NewLine + "Leaving an owned Syncshell will transfer the ownership to a random person in the Syncshell."));
+
+            if (_uiShared.IconTextButton(FontAwesomeIcon.Copy, "Copy ID"))
+            {
+                ImGui.CloseCurrentPopup();
+                ImGui.SetClipboardText(groupDto.GroupAliasOrGID);
+            }
+            UiSharedService.AttachToolTip("Copy Syncshell ID to Clipboard");
+
+            if (_uiShared.IconTextButton(FontAwesomeIcon.StickyNote, "Copy Notes"))
+            {
+                ImGui.CloseCurrentPopup();
+                ImGui.SetClipboardText(UiSharedService.GetNotes(groupPairs));
+            }
+            UiSharedService.AttachToolTip("Copies all your notes for all users in this Syncshell to the clipboard." + Environment.NewLine + "They can be imported via Settings -> General -> Notes -> Import notes from clipboard");
+
+            var soundsText = userSoundsDisabled ? "Enable sound sync" : "Disable sound sync";
+            if (_uiShared.IconTextButton(userSoundsIcon, soundsText))
+            {
+                ImGui.CloseCurrentPopup();
+                var perm = groupDto.GroupUserPermissions;
+                perm.SetDisableSounds(!perm.IsDisableSounds());
+                _ = ApiController.GroupChangeIndividualPermissionState(new(groupDto.Group, new UserData(ApiController.UID), perm));
+            }
+            UiSharedService.AttachToolTip("Sets your allowance for sound synchronization for users of this syncshell."
+                + Environment.NewLine + "Disabling the synchronization will stop applying sound modifications for users of this syncshell."
+                + Environment.NewLine + "Note: this setting can be forcefully overridden to 'disabled' through the syncshell owner."
+                + Environment.NewLine + "Note: this setting does not apply to individual pairs that are also in the syncshell.");
+
+            var animText = userAnimDisabled ? "Enable animations sync" : "Disable animations sync";
+            if (_uiShared.IconTextButton(userAnimIcon, animText))
+            {
+                ImGui.CloseCurrentPopup();
+                var perm = groupDto.GroupUserPermissions;
+                perm.SetDisableAnimations(!perm.IsDisableAnimations());
+                _ = ApiController.GroupChangeIndividualPermissionState(new(groupDto.Group, new UserData(ApiController.UID), perm));
+            }
+            UiSharedService.AttachToolTip("Sets your allowance for animations synchronization for users of this syncshell."
+                + Environment.NewLine + "Disabling the synchronization will stop applying animations modifications for users of this syncshell."
+                + Environment.NewLine + "Note: this setting might also affect sound synchronization"
+                + Environment.NewLine + "Note: this setting can be forcefully overridden to 'disabled' through the syncshell owner."
+                + Environment.NewLine + "Note: this setting does not apply to individual pairs that are also in the syncshell.");
+
+            var vfxText = userVFXDisabled ? "Enable VFX sync" : "Disable VFX sync";
+            if (_uiShared.IconTextButton(userVFXIcon, vfxText))
+            {
+                ImGui.CloseCurrentPopup();
+                var perm = groupDto.GroupUserPermissions;
+                perm.SetDisableVFX(!perm.IsDisableVFX());
+                _ = ApiController.GroupChangeIndividualPermissionState(new(groupDto.Group, new UserData(ApiController.UID), perm));
+            }
+            UiSharedService.AttachToolTip("Sets your allowance for VFX synchronization for users of this syncshell."
+                                          + Environment.NewLine + "Disabling the synchronization will stop applying VFX modifications for users of this syncshell."
+                                          + Environment.NewLine + "Note: this setting might also affect animation synchronization to some degree"
+                                          + Environment.NewLine + "Note: this setting can be forcefully overridden to 'disabled' through the syncshell owner."
+                                          + Environment.NewLine + "Note: this setting does not apply to individual pairs that are also in the syncshell.");
+
+            if (isOwner || groupDto.GroupUserInfo.IsModerator())
+            {
+                ImGui.Separator();
+                if (_uiShared.IconTextButton(FontAwesomeIcon.Cog, "Open Admin Panel"))
+                {
+                    ImGui.CloseCurrentPopup();
+                    _mainUi.Mediator.Publish(new OpenSyncshellAdminPanel(groupDto));
+                }
+            }
+
+            ImGui.EndPopup();
+        }
+    }
+
+    private void DrawSyncshellList()
+    {
+        var ySize = _mainUi.TransferPartHeight == 0
+            ? 1
+            : (ImGui.GetWindowContentRegionMax().Y - ImGui.GetWindowContentRegionMin().Y) - _mainUi.TransferPartHeight - ImGui.GetCursorPosY();
+        ImGui.BeginChild("list", new Vector2(_mainUi.WindowContentWidth, ySize), border: false);
+        foreach (var entry in _pairManager.GroupPairs.OrderBy(g => g.Key.Group.AliasOrGID, StringComparer.OrdinalIgnoreCase).ToList())
+        {
+            using (ImRaii.PushId(entry.Key.Group.GID)) DrawSyncshell(entry.Key, entry.Value);
+        }
+        ImGui.EndChild();
+    }
+}

MareSynchronos/UI/Components/PairGroupsUi.cs

@@ -0,0 +1,258 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.UI.Handlers;
+using MareSynchronos.WebAPI;
+
+namespace MareSynchronos.UI.Components;
+
+public class PairGroupsUi
+{
+    private readonly ApiController _apiController;
+    private readonly MareConfigService _mareConfig;
+    private readonly SelectPairForGroupUi _selectGroupForPairUi;
+    private readonly TagHandler _tagHandler;
+    private readonly UidDisplayHandler _uidDisplayHandler;
+    private readonly UiSharedService _uiSharedService;
+
+    public PairGroupsUi(MareConfigService mareConfig, TagHandler tagHandler, UidDisplayHandler uidDisplayHandler, ApiController apiController,
+        SelectPairForGroupUi selectGroupForPairUi, UiSharedService uiSharedService)
+    {
+        _mareConfig = mareConfig;
+        _tagHandler = tagHandler;
+        _uidDisplayHandler = uidDisplayHandler;
+        _apiController = apiController;
+        _selectGroupForPairUi = selectGroupForPairUi;
+        _uiSharedService = uiSharedService;
+    }
+
+    public void Draw<T>(List<T> visibleUsers, List<T> onlineUsers, List<T> offlineUsers) where T : DrawPairBase
+    {
+        // Only render those tags that actually have pairs in them, otherwise
+        // we can end up with a bunch of useless pair groups
+        var tagsWithPairsInThem = _tagHandler.GetAllTagsSorted();
+        var allUsers = onlineUsers.Concat(offlineUsers).ToList();
+        if (typeof(T) == typeof(DrawUserPair))
+        {
+            DrawUserPairs(tagsWithPairsInThem, allUsers.Cast<DrawUserPair>().ToList(), visibleUsers.Cast<DrawUserPair>(), onlineUsers.Cast<DrawUserPair>(), offlineUsers.Cast<DrawUserPair>());
+        }
+    }
+
+    private void DrawButtons(string tag, List<DrawUserPair> availablePairsInThisTag)
+    {
+        var allArePaused = availablePairsInThisTag.All(pair => pair.UserPair!.OwnPermissions.IsPaused());
+        var pauseButton = allArePaused ? FontAwesomeIcon.Play : FontAwesomeIcon.Pause;
+        var flyoutMenuX = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Bars).X;
+        var pauseButtonX = _uiSharedService.GetIconButtonSize(pauseButton).X;
+        var windowX = ImGui.GetWindowContentRegionMin().X;
+        var windowWidth = UiSharedService.GetWindowContentRegionWidth();
+        var spacingX = ImGui.GetStyle().ItemSpacing.X;
+
+        var buttonPauseOffset = windowX + windowWidth - flyoutMenuX - spacingX - pauseButtonX;
+        ImGui.SameLine(buttonPauseOffset);
+        if (_uiSharedService.IconButton(pauseButton))
+        {
+            // If all of the currently visible pairs (after applying filters to the pairs)
+            // are paused we display a resume button to resume all currently visible (after filters)
+            // pairs. Otherwise, we just pause all the remaining pairs.
+            if (allArePaused)
+            {
+                // If all are paused => resume all
+                ResumeAllPairs(availablePairsInThisTag);
+            }
+            else
+            {
+                // otherwise pause all remaining
+                PauseRemainingPairs(availablePairsInThisTag);
+            }
+        }
+        if (allArePaused)
+        {
+            UiSharedService.AttachToolTip($"Resume pairing with all pairs in {tag}");
+        }
+        else
+        {
+            UiSharedService.AttachToolTip($"Pause pairing with all pairs in {tag}");
+        }
+
+        var buttonDeleteOffset = windowX + windowWidth - flyoutMenuX;
+        ImGui.SameLine(buttonDeleteOffset);
+        if (_uiSharedService.IconButton(FontAwesomeIcon.Bars))
+        {
+            ImGui.OpenPopup("Group Flyout Menu");
+        }
+
+        if (ImGui.BeginPopup("Group Flyout Menu"))
+        {
+            using (ImRaii.PushId($"buttons-{tag}")) DrawGroupMenu(tag);
+            ImGui.EndPopup();
+        }
+    }
+
+    private void DrawCategory(string tag, IEnumerable<DrawPairBase> onlineUsers, IEnumerable<DrawPairBase> allUsers, IEnumerable<DrawPairBase>? visibleUsers = null)
+    {
+        IEnumerable<DrawPairBase> usersInThisTag;
+        HashSet<string>? otherUidsTaggedWithTag = null;
+        bool isSpecialTag = false;
+        int visibleInThisTag = 0;
+        if (tag is TagHandler.CustomOfflineTag or TagHandler.CustomOnlineTag or TagHandler.CustomVisibleTag or TagHandler.CustomUnpairedTag)
+        {
+            usersInThisTag = onlineUsers;
+            isSpecialTag = true;
+        }
+        else
+        {
+            otherUidsTaggedWithTag = _tagHandler.GetOtherUidsForTag(tag);
+            usersInThisTag = onlineUsers
+                .Where(pair => otherUidsTaggedWithTag.Contains(pair.UID))
+                .ToList();
+            visibleInThisTag = visibleUsers?.Count(p => otherUidsTaggedWithTag.Contains(p.UID)) ?? 0;
+        }
+
+        if (isSpecialTag && !usersInThisTag.Any()) return;
+
+        DrawName(tag, isSpecialTag, visibleInThisTag, usersInThisTag.Count(), otherUidsTaggedWithTag?.Count);
+        if (!isSpecialTag)
+        {
+            using (ImRaii.PushId($"group-{tag}-buttons")) DrawButtons(tag, allUsers.Cast<DrawUserPair>().Where(p => otherUidsTaggedWithTag!.Contains(p.UID)).ToList());
+        }
+        else
+        {
+            // Avoid uncomfortably close group names
+            if (!_tagHandler.IsTagOpen(tag))
+            {
+                var size = ImGui.CalcTextSize("").Y + ImGui.GetStyle().FramePadding.Y * 2f;
+                ImGui.SameLine();
+                ImGui.Dummy(new(size, size));
+            }
+        }
+
+        if (!_tagHandler.IsTagOpen(tag)) return;
+
+        ImGui.Indent(20);
+        DrawPairs(tag, usersInThisTag);
+        ImGui.Unindent(20);
+    }
+
+    private void DrawGroupMenu(string tag)
+    {
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Users, "Add people to " + tag))
+        {
+            _selectGroupForPairUi.Open(tag);
+        }
+        UiSharedService.AttachToolTip($"Add more users to Group {tag}");
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Delete " + tag) && UiSharedService.CtrlPressed())
+        {
+            _tagHandler.RemoveTag(tag);
+        }
+        UiSharedService.AttachToolTip($"Delete Group {tag} (Will not delete the pairs)" + Environment.NewLine + "Hold CTRL to delete");
+    }
+
+    private void DrawName(string tag, bool isSpecialTag, int visible, int online, int? total)
+    {
+        string displayedName = tag switch
+        {
+            TagHandler.CustomUnpairedTag => "Unpaired",
+            TagHandler.CustomOfflineTag => "Offline",
+            TagHandler.CustomOnlineTag => _mareConfig.Current.ShowOfflineUsersSeparately ? "Online/Paused" : "Contacts",
+            TagHandler.CustomVisibleTag => "Visible",
+            _ => tag
+        };
+
+        string resultFolderName = !isSpecialTag ? $"{displayedName} ({visible}/{online}/{total} Pairs)" : $"{displayedName} ({online} Pairs)";
+
+        //  FontAwesomeIcon.CaretSquareDown : FontAwesomeIcon.CaretSquareRight
+        var icon = _tagHandler.IsTagOpen(tag) ? FontAwesomeIcon.CaretSquareDown : FontAwesomeIcon.CaretSquareRight;
+        _uiSharedService.IconText(icon);
+        if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+        {
+            ToggleTagOpen(tag);
+        }
+        ImGui.SameLine();
+        ImGui.TextUnformatted(resultFolderName);
+        if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+        {
+            ToggleTagOpen(tag);
+        }
+
+        if (!isSpecialTag && ImGui.IsItemHovered())
+        {
+            ImGui.BeginTooltip();
+            ImGui.TextUnformatted($"Group {tag}");
+            ImGui.Separator();
+            ImGui.TextUnformatted($"{visible} Pairs visible");
+            ImGui.TextUnformatted($"{online} Pairs online/paused");
+            ImGui.TextUnformatted($"{total} Pairs total");
+            ImGui.EndTooltip();
+        }
+    }
+
+    private void DrawPairs(string tag, IEnumerable<DrawPairBase> availablePairsInThisCategory)
+    {
+        // These are all the OtherUIDs that are tagged with this tag
+        _uidDisplayHandler.RenderPairList(availablePairsInThisCategory);
+        ImGui.Separator();
+    }
+
+    private void DrawUserPairs(List<string> tagsWithPairsInThem, List<DrawUserPair> allUsers, IEnumerable<DrawUserPair> visibleUsers, IEnumerable<DrawUserPair> onlineUsers, IEnumerable<DrawUserPair> offlineUsers)
+    {
+        if (_mareConfig.Current.ShowVisibleUsersSeparately)
+        {
+            using (ImRaii.PushId("$group-VisibleCustomTag")) DrawCategory(TagHandler.CustomVisibleTag, visibleUsers, allUsers);
+        }
+        foreach (var tag in tagsWithPairsInThem)
+        {
+            if (_mareConfig.Current.ShowOfflineUsersSeparately)
+            {
+                using (ImRaii.PushId($"group-{tag}")) DrawCategory(tag, onlineUsers, allUsers, visibleUsers);
+            }
+            else
+            {
+                using (ImRaii.PushId($"group-{tag}")) DrawCategory(tag, allUsers, allUsers, visibleUsers);
+            }
+        }
+        if (_mareConfig.Current.ShowOfflineUsersSeparately)
+        {
+            using (ImRaii.PushId($"group-OnlineCustomTag")) DrawCategory(TagHandler.CustomOnlineTag,
+                onlineUsers.Where(u => !_tagHandler.HasAnyTag(u.UID)).ToList(), allUsers);
+            using (ImRaii.PushId($"group-OfflineCustomTag")) DrawCategory(TagHandler.CustomOfflineTag,
+                offlineUsers.Where(u => u.UserPair!.OtherPermissions.IsPaired()).ToList(), allUsers);
+        }
+        else
+        {
+            using (ImRaii.PushId($"group-OnlineCustomTag")) DrawCategory(TagHandler.CustomOnlineTag,
+                onlineUsers.Concat(offlineUsers.Where(u => u.UserPair!.OtherPermissions.IsPaired())).Where(u => !_tagHandler.HasAnyTag(u.UID)).ToList(), allUsers);
+        }
+        using (ImRaii.PushId($"group-UnpairedCustomTag")) DrawCategory(TagHandler.CustomUnpairedTag,
+            offlineUsers.Where(u => !u.UserPair!.OtherPermissions.IsPaired()).ToList(), allUsers);
+    }
+
+    private void PauseRemainingPairs(List<DrawUserPair> availablePairs)
+    {
+        foreach (var pairToPause in availablePairs.Where(pair => !pair.UserPair!.OwnPermissions.IsPaused()))
+        {
+            var perm = pairToPause.UserPair!.OwnPermissions;
+            perm.SetPaused(paused: true);
+            _ = _apiController.UserSetPairPermissions(new(new(pairToPause.UID), perm));
+        }
+    }
+
+    private void ResumeAllPairs(List<DrawUserPair> availablePairs)
+    {
+        foreach (var pairToPause in availablePairs)
+        {
+            var perm = pairToPause.UserPair!.OwnPermissions;
+            perm.SetPaused(paused: false);
+            _ = _apiController.UserSetPairPermissions(new(new(pairToPause.UID), perm));
+        }
+    }
+
+    private void ToggleTagOpen(string tag)
+    {
+        bool open = !_tagHandler.IsTagOpen(tag);
+        _tagHandler.SetTagOpen(tag, open);
+    }
+}

MareSynchronos/UI/Components/Popup/BanUserPopupHandler.cs

@@ -0,0 +1,50 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using MareSynchronos.API.Dto.Group;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.WebAPI;
+using System.Numerics;
+
+namespace MareSynchronos.UI.Components.Popup;
+
+public class BanUserPopupHandler : IPopupHandler
+{
+    private readonly ApiController _apiController;
+    private readonly UiSharedService _uiSharedService;
+    private string _banReason = string.Empty;
+    private GroupFullInfoDto _group = null!;
+    private Pair _reportedPair = null!;
+
+    public BanUserPopupHandler(ApiController apiController, UiSharedService uiSharedService)
+    {
+        _apiController = apiController;
+        _uiSharedService = uiSharedService;
+    }
+
+    public Vector2 PopupSize => new(500, 250);
+
+    public bool ShowClose => true;
+
+    public void DrawContent()
+    {
+        UiSharedService.TextWrapped("User " + (_reportedPair.UserData.AliasOrUID) + " will be banned and removed from this Syncshell.");
+        ImGui.InputTextWithHint("##banreason", "Ban Reason", ref _banReason, 255);
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.UserSlash, "Ban User"))
+        {
+            ImGui.CloseCurrentPopup();
+            var reason = _banReason;
+            _ = _apiController.GroupBanUser(new GroupPairDto(_group.Group, _reportedPair.UserData), reason);
+            _banReason = string.Empty;
+        }
+        UiSharedService.TextWrapped("The reason will be displayed in the banlist. The current server-side alias if present (Vanity ID) will automatically be attached to the reason.");
+    }
+
+    public void Open(OpenBanUserPopupMessage message)
+    {
+        _reportedPair = message.PairToBan;
+        _group = message.GroupFullInfoDto;
+        _banReason = string.Empty;
+    }
+}

MareSynchronos/UI/Components/Popup/IPopupHandler.cs

@@ -0,0 +1,11 @@
+using System.Numerics;
+
+namespace MareSynchronos.UI.Components.Popup;
+
+public interface IPopupHandler
+{
+    Vector2 PopupSize { get; }
+    bool ShowClose { get; }
+
+    void DrawContent();
+}

MareSynchronos/UI/Components/Popup/PopupHandler.cs

@@ -0,0 +1,81 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+
+namespace MareSynchronos.UI.Components.Popup;
+
+public class PopupHandler : WindowMediatorSubscriberBase
+{
+    protected bool _openPopup = false;
+    private readonly HashSet<IPopupHandler> _handlers;
+    private readonly UiSharedService _uiSharedService;
+    private IPopupHandler? _currentHandler = null;
+
+    public PopupHandler(ILogger<PopupHandler> logger, MareMediator mediator, IEnumerable<IPopupHandler> popupHandlers,
+        PerformanceCollectorService performanceCollectorService, UiSharedService uiSharedService)
+        : base(logger, mediator, "MarePopupHandler", performanceCollectorService)
+    {
+        Flags = ImGuiWindowFlags.NoBringToFrontOnFocus
+          | ImGuiWindowFlags.NoDecoration
+          | ImGuiWindowFlags.NoInputs
+          | ImGuiWindowFlags.NoSavedSettings
+          | ImGuiWindowFlags.NoBackground
+          | ImGuiWindowFlags.NoMove
+          | ImGuiWindowFlags.NoNav
+          | ImGuiWindowFlags.NoTitleBar
+          | ImGuiWindowFlags.NoFocusOnAppearing;
+
+        IsOpen = true;
+
+        _handlers = popupHandlers.ToHashSet();
+
+        Mediator.Subscribe<OpenReportPopupMessage>(this, (msg) =>
+        {
+            _openPopup = true;
+            _currentHandler = _handlers.OfType<ReportPopupHandler>().Single();
+            ((ReportPopupHandler)_currentHandler).Open(msg);
+            IsOpen = true;
+        });
+
+        Mediator.Subscribe<OpenBanUserPopupMessage>(this, (msg) =>
+        {
+            _openPopup = true;
+            _currentHandler = _handlers.OfType<BanUserPopupHandler>().Single();
+            ((BanUserPopupHandler)_currentHandler).Open(msg);
+            IsOpen = true;
+        });
+        _uiSharedService = uiSharedService;
+        DisableWindowSounds = true;
+    }
+
+    protected override void DrawInternal()
+    {
+        if (_currentHandler == null) return;
+
+        if (_openPopup)
+        {
+            ImGui.OpenPopup(WindowName);
+            _openPopup = false;
+        }
+
+        var viewportSize = ImGui.GetWindowViewport().Size;
+        ImGui.SetNextWindowSize(_currentHandler!.PopupSize * ImGuiHelpers.GlobalScale);
+        ImGui.SetNextWindowPos(viewportSize / 2, ImGuiCond.Always, new Vector2(0.5f));
+        using var popup = ImRaii.Popup(WindowName, ImGuiWindowFlags.Modal);
+        if (!popup) return;
+        _currentHandler.DrawContent();
+        if (_currentHandler.ShowClose)
+        {
+            ImGui.Separator();
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Times, "Close"))
+            {
+                ImGui.CloseCurrentPopup();
+            }
+        }
+    }
+}

MareSynchronos/UI/Components/Popup/ReportPopupHandler.cs

@@ -0,0 +1,58 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.WebAPI;
+using System.Numerics;
+
+namespace MareSynchronos.UI.Components.Popup;
+
+internal class ReportPopupHandler : IPopupHandler
+{
+    private readonly ApiController _apiController;
+    private readonly UiSharedService _uiSharedService;
+    private Pair? _reportedPair;
+    private string _reportReason = string.Empty;
+
+    public ReportPopupHandler(ApiController apiController, UiSharedService uiSharedService)
+    {
+        _apiController = apiController;
+        _uiSharedService = uiSharedService;
+    }
+
+    public Vector2 PopupSize => new(500, 500);
+
+    public bool ShowClose => true;
+
+    public void DrawContent()
+    {
+        using (_uiSharedService.UidFont.Push())
+            UiSharedService.TextWrapped("Report " + _reportedPair!.UserData.AliasOrUID + " Profile");
+
+        ImGui.InputTextMultiline("##reportReason", ref _reportReason, 500, new Vector2(500 - ImGui.GetStyle().ItemSpacing.X * 2, 200));
+        UiSharedService.TextWrapped($"Note: Sending a report will disable the offending profile globally.{Environment.NewLine}" +
+            $"The report will be sent to the team of your currently connected server.{Environment.NewLine}" +
+            $"Depending on the severity of the offense the users profile or account can be permanently disabled or banned.");
+        UiSharedService.ColorTextWrapped("Report spam and wrong reports will not be tolerated and can lead to permanent account suspension.", ImGuiColors.DalamudRed);
+        UiSharedService.ColorTextWrapped("This is not for reporting misbehavior but solely for the actual profile. " +
+            "Reports that are not solely for the profile will be ignored.", ImGuiColors.DalamudYellow);
+
+        using (ImRaii.Disabled(string.IsNullOrEmpty(_reportReason)))
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.ExclamationTriangle, "Send Report"))
+            {
+                ImGui.CloseCurrentPopup();
+                var reason = _reportReason;
+                _ = _apiController.UserReportProfile(new(_reportedPair.UserData, reason));
+            }
+        }
+    }
+
+    public void Open(OpenReportPopupMessage msg)
+    {
+        _reportedPair = msg.PairToReport;
+        _reportReason = string.Empty;
+    }
+}

MareSynchronos/UI/Components/SelectGroupForPairUi.cs

@@ -0,0 +1,139 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using Dalamud.Utility;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.UI.Handlers;
+using System.Numerics;
+
+namespace MareSynchronos.UI.Components;
+
+public class SelectGroupForPairUi
+{
+    private readonly TagHandler _tagHandler;
+    private readonly UidDisplayHandler _uidDisplayHandler;
+    private readonly UiSharedService _uiSharedService;
+
+    /// <summary>
+    /// The group UI is always open for a specific pair. This defines which pair the UI is open for.
+    /// </summary>
+    /// <returns></returns>
+    private Pair? _pair;
+
+    /// <summary>
+    /// Should the panel show, yes/no
+    /// </summary>
+    private bool _show;
+
+    /// <summary>
+    /// For the add category option, this stores the currently typed in tag name
+    /// </summary>
+    private string _tagNameToAdd = "";
+
+    public SelectGroupForPairUi(TagHandler tagHandler, UidDisplayHandler uidDisplayHandler, UiSharedService uiSharedService)
+    {
+        _show = false;
+        _pair = null;
+        _tagHandler = tagHandler;
+        _uidDisplayHandler = uidDisplayHandler;
+        _uiSharedService = uiSharedService;
+    }
+
+    public void Draw()
+    {
+        if (_pair == null)
+        {
+            return;
+        }
+
+        var name = PairName(_pair);
+        var popupName = $"Choose Groups for {name}";
+        // Is the popup supposed to show but did not open yet? Open it
+        if (_show)
+        {
+            ImGui.OpenPopup(popupName);
+            _show = false;
+        }
+
+        if (ImGui.BeginPopup(popupName))
+        {
+            var tags = _tagHandler.GetAllTagsSorted();
+            var childHeight = tags.Count != 0 ? tags.Count * 25 : 1;
+            var childSize = new Vector2(0, childHeight > 100 ? 100 : childHeight) * ImGuiHelpers.GlobalScale;
+
+            ImGui.TextUnformatted($"Select the groups you want {name} to be in.");
+            if (ImGui.BeginChild(name + "##listGroups", childSize))
+            {
+                foreach (var tag in tags)
+                {
+                    using (ImRaii.PushId($"groups-pair-{_pair.UserData.UID}-{tag}")) DrawGroupName(_pair, tag);
+                }
+                ImGui.EndChild();
+            }
+
+            ImGui.Separator();
+            ImGui.TextUnformatted($"Create a new group for {name}.");
+            if (_uiSharedService.IconButton(FontAwesomeIcon.Plus))
+            {
+                HandleAddTag();
+            }
+            ImGui.SameLine();
+            ImGui.InputTextWithHint("##category_name", "New Group", ref _tagNameToAdd, 40);
+            if (ImGui.IsKeyDown(ImGuiKey.Enter))
+            {
+                HandleAddTag();
+            }
+            ImGui.EndPopup();
+        }
+    }
+
+    public void Open(Pair pair)
+    {
+        _pair = pair;
+        // Using "_show" here to de-couple the opening of the popup
+        // The popup name is derived from the name the user currently sees, which is
+        // based on the showUidForEntry dictionary.
+        // We'd have to derive the name here to open it popup modal here, when the Open() is called
+        _show = true;
+    }
+
+    private void DrawGroupName(Pair pair, string name)
+    {
+        var hasTagBefore = _tagHandler.HasTag(pair.UserData.UID, name);
+        var hasTag = hasTagBefore;
+        if (ImGui.Checkbox(name, ref hasTag))
+        {
+            if (hasTag)
+            {
+                _tagHandler.AddTagToPairedUid(pair.UserData.UID, name);
+            }
+            else
+            {
+                _tagHandler.RemoveTagFromPairedUid(pair.UserData.UID, name);
+            }
+        }
+    }
+
+    private void HandleAddTag()
+    {
+        if (!_tagNameToAdd.IsNullOrWhitespace() && _tagNameToAdd is not (TagHandler.CustomOfflineTag or TagHandler.CustomOnlineTag or TagHandler.CustomVisibleTag))
+        {
+            _tagHandler.AddTag(_tagNameToAdd);
+            if (_pair != null)
+            {
+                _tagHandler.AddTagToPairedUid(_pair.UserData.UID, _tagNameToAdd);
+            }
+            _tagNameToAdd = string.Empty;
+        }
+        else
+        {
+            _tagNameToAdd = string.Empty;
+        }
+    }
+
+    private string PairName(Pair pair)
+    {
+        return _uidDisplayHandler.GetPlayerText(pair).text;
+    }
+}

MareSynchronos/UI/Components/SelectPairForGroupUi.cs

@@ -0,0 +1,92 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface.Utility;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.UI.Handlers;
+using System.Numerics;
+
+namespace MareSynchronos.UI.Components;
+
+public class SelectPairForGroupUi
+{
+    private readonly TagHandler _tagHandler;
+    private readonly UidDisplayHandler _uidDisplayHandler;
+    private string _filter = string.Empty;
+    private bool _opened = false;
+    private HashSet<string> _peopleInGroup = new(StringComparer.Ordinal);
+    private bool _show = false;
+    private string _tag = string.Empty;
+
+    public SelectPairForGroupUi(TagHandler tagHandler, UidDisplayHandler uidDisplayHandler)
+    {
+        _tagHandler = tagHandler;
+        _uidDisplayHandler = uidDisplayHandler;
+    }
+
+    public void Draw(List<Pair> pairs)
+    {
+        var workHeight = ImGui.GetMainViewport().WorkSize.Y / ImGuiHelpers.GlobalScale;
+        var minSize = new Vector2(300, workHeight < 400 ? workHeight : 400) * ImGuiHelpers.GlobalScale;
+        var maxSize = new Vector2(300, 1000) * ImGuiHelpers.GlobalScale;
+
+        var popupName = $"Choose Users for Group {_tag}";
+
+        if (!_show)
+        {
+            _opened = false;
+        }
+
+        if (_show && !_opened)
+        {
+            ImGui.SetNextWindowSize(minSize);
+            UiSharedService.CenterNextWindow(minSize.X, minSize.Y, ImGuiCond.Always);
+            ImGui.OpenPopup(popupName);
+            _opened = true;
+        }
+
+        ImGui.SetNextWindowSizeConstraints(minSize, maxSize);
+        if (ImGui.BeginPopupModal(popupName, ref _show, ImGuiWindowFlags.Popup | ImGuiWindowFlags.Modal))
+        {
+            ImGui.TextUnformatted($"Select users for group {_tag}");
+
+            ImGui.InputTextWithHint("##filter", "Filter", ref _filter, 255, ImGuiInputTextFlags.None);
+            foreach (var item in pairs
+                .Where(p => string.IsNullOrEmpty(_filter) || PairName(p).Contains(_filter, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(p => PairName(p), StringComparer.OrdinalIgnoreCase)
+                .ToList())
+            {
+                var isInGroup = _peopleInGroup.Contains(item.UserData.UID);
+                if (ImGui.Checkbox(PairName(item), ref isInGroup))
+                {
+                    if (isInGroup)
+                    {
+                        _tagHandler.AddTagToPairedUid(item.UserData.UID, _tag);
+                        _peopleInGroup.Add(item.UserData.UID);
+                    }
+                    else
+                    {
+                        _tagHandler.RemoveTagFromPairedUid(item.UserData.UID, _tag);
+                        _peopleInGroup.Remove(item.UserData.UID);
+                    }
+                }
+            }
+            ImGui.EndPopup();
+        }
+        else
+        {
+            _filter = string.Empty;
+            _show = false;
+        }
+    }
+
+    public void Open(string tag)
+    {
+        _peopleInGroup = _tagHandler.GetOtherUidsForTag(tag);
+        _tag = tag;
+        _show = true;
+    }
+
+    private string PairName(Pair pair)
+    {
+        return _uidDisplayHandler.GetPlayerText(pair).text;
+    }
+}

MareSynchronos/UI/DataAnalysisUi.cs

@@ -0,0 +1,492 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+public class DataAnalysisUi : WindowMediatorSubscriberBase
+{
+    private readonly CharacterAnalyzer _characterAnalyzer;
+    private readonly Progress<(string, int)> _conversionProgress = new();
+    private readonly IpcManager _ipcManager;
+    private readonly UiSharedService _uiSharedService;
+    private readonly Dictionary<string, string[]> _texturesToConvert = new(StringComparer.Ordinal);
+    private Dictionary<ObjectKind, Dictionary<string, CharacterAnalyzer.FileDataEntry>>? _cachedAnalysis;
+    private CancellationTokenSource _conversionCancellationTokenSource = new();
+    private string _conversionCurrentFileName = string.Empty;
+    private int _conversionCurrentFileProgress = 0;
+    private Task? _conversionTask;
+    private bool _enableBc7ConversionMode = false;
+    private bool _hasUpdate = false;
+    private bool _sortDirty = true;
+    private bool _modalOpen = false;
+    private string _selectedFileTypeTab = string.Empty;
+    private string _selectedHash = string.Empty;
+    private ObjectKind _selectedObjectTab;
+    private bool _showModal = false;
+
+    public DataAnalysisUi(ILogger<DataAnalysisUi> logger, MareMediator mediator,
+        CharacterAnalyzer characterAnalyzer, IpcManager ipcManager,
+        PerformanceCollectorService performanceCollectorService,
+        UiSharedService uiSharedService)
+        : base(logger, mediator, "Character Data Analysis", performanceCollectorService)
+    {
+        _characterAnalyzer = characterAnalyzer;
+        _ipcManager = ipcManager;
+        _uiSharedService = uiSharedService;
+        Mediator.Subscribe<CharacterDataAnalyzedMessage>(this, (_) =>
+        {
+            _hasUpdate = true;
+        });
+        SizeConstraints = new()
+        {
+            MinimumSize = new()
+            {
+                X = 800,
+                Y = 600
+            },
+            MaximumSize = new()
+            {
+                X = 3840,
+                Y = 2160
+            }
+        };
+
+        _conversionProgress.ProgressChanged += ConversionProgress_ProgressChanged;
+    }
+
+    protected override void DrawInternal()
+    {
+        if (_conversionTask != null && !_conversionTask.IsCompleted)
+        {
+            _showModal = true;
+            if (ImGui.BeginPopupModal("BC7 Conversion in Progress"))
+            {
+                ImGui.TextUnformatted("BC7 Conversion in progress: " + _conversionCurrentFileProgress + "/" + _texturesToConvert.Count);
+                UiSharedService.TextWrapped("Current file: " + _conversionCurrentFileName);
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.StopCircle, "Cancel conversion"))
+                {
+                    _conversionCancellationTokenSource.Cancel();
+                }
+                UiSharedService.SetScaledWindowSize(500);
+                ImGui.EndPopup();
+            }
+            else
+            {
+                _modalOpen = false;
+            }
+        }
+        else if (_conversionTask != null && _conversionTask.IsCompleted && _texturesToConvert.Count > 0)
+        {
+            _conversionTask = null;
+            _texturesToConvert.Clear();
+            _showModal = false;
+            _modalOpen = false;
+            _enableBc7ConversionMode = false;
+        }
+
+        if (_showModal && !_modalOpen)
+        {
+            ImGui.OpenPopup("BC7 Conversion in Progress");
+            _modalOpen = true;
+        }
+
+        if (_hasUpdate)
+        {
+            _cachedAnalysis = _characterAnalyzer.LastAnalysis.DeepClone();
+            _hasUpdate = false;
+            _sortDirty = true;
+        }
+
+        UiSharedService.TextWrapped("This window shows you all files and their sizes that are currently in use through your character and associated entities");
+
+        if (_cachedAnalysis == null || _cachedAnalysis.Count == 0) return;
+
+        bool isAnalyzing = _characterAnalyzer.IsAnalysisRunning;
+        bool needAnalysis = _cachedAnalysis!.Any(c => c.Value.Any(f => !f.Value.IsComputed));
+        if (isAnalyzing)
+        {
+            UiSharedService.ColorTextWrapped($"Analyzing {_characterAnalyzer.CurrentFile}/{_characterAnalyzer.TotalFiles}",
+                ImGuiColors.DalamudYellow);
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.StopCircle, "Cancel analysis"))
+            {
+                _characterAnalyzer.CancelAnalyze();
+            }
+        }
+        else
+        {
+            if (needAnalysis)
+            {
+                UiSharedService.ColorTextWrapped("Some entries in the analysis have file size not determined yet, press the button below to analyze your current data",
+                    ImGuiColors.DalamudYellow);
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.PlayCircle, "Start analysis (missing entries)"))
+                {
+                    _ = _characterAnalyzer.ComputeAnalysis(print: false);
+                }
+            }
+            else
+            {
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.PlayCircle, "Start analysis (recalculate all entries)"))
+                {
+                    _ = _characterAnalyzer.ComputeAnalysis(print: false, recalculate: true);
+                }
+            }
+        }
+
+        ImGui.Separator();
+
+        ImGui.TextUnformatted("Total files:");
+        ImGui.SameLine();
+        ImGui.TextUnformatted(_cachedAnalysis!.Values.Sum(c => c.Values.Count).ToString());
+        ImGui.SameLine();
+        using (var font = ImRaii.PushFont(UiBuilder.IconFont))
+        {
+            ImGui.TextUnformatted(FontAwesomeIcon.InfoCircle.ToIconString());
+        }
+        if (ImGui.IsItemHovered())
+        {
+            string text = "";
+            var groupedfiles = _cachedAnalysis.Values.SelectMany(f => f.Values).GroupBy(f => f.FileType, StringComparer.Ordinal);
+            text = string.Join(Environment.NewLine, groupedfiles.OrderBy(f => f.Key, StringComparer.Ordinal)
+                .Select(f => f.Key + ": " + f.Count() + " files, size: " + UiSharedService.ByteToString(f.Sum(v => v.OriginalSize))
+                + ", compressed: " + UiSharedService.ByteToString(f.Sum(v => v.CompressedSize))));
+            ImGui.SetTooltip(text);
+        }
+        ImGui.TextUnformatted("Total size (actual):");
+        ImGui.SameLine();
+        ImGui.TextUnformatted(UiSharedService.ByteToString(_cachedAnalysis!.Sum(c => c.Value.Sum(c => c.Value.OriginalSize))));
+        ImGui.TextUnformatted("Total size (download size):");
+        ImGui.SameLine();
+        using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, needAnalysis))
+        {
+            ImGui.TextUnformatted(UiSharedService.ByteToString(_cachedAnalysis!.Sum(c => c.Value.Sum(c => c.Value.CompressedSize))));
+            if (needAnalysis && !isAnalyzing)
+            {
+                ImGui.SameLine();
+                using (ImRaii.PushFont(UiBuilder.IconFont))
+                    ImGui.TextUnformatted(FontAwesomeIcon.ExclamationCircle.ToIconString());
+                UiSharedService.AttachToolTip("Click \"Start analysis\" to calculate download size");
+            }
+        }
+        ImGui.TextUnformatted($"Total modded model triangles: {UiSharedService.TrisToString(_cachedAnalysis.Sum(c => c.Value.Sum(f => f.Value.Triangles)))}");
+        ImGui.Separator();
+
+        using var tabbar = ImRaii.TabBar("objectSelection");
+        foreach (var kvp in _cachedAnalysis)
+        {
+            using var id = ImRaii.PushId(kvp.Key.ToString());
+            string tabText = kvp.Key.ToString();
+            using var tab = ImRaii.TabItem(tabText + "###" + kvp.Key.ToString());
+            if (tab.Success)
+            {
+                var groupedfiles = kvp.Value.Select(v => v.Value).GroupBy(f => f.FileType, StringComparer.Ordinal)
+                    .OrderBy(k => k.Key, StringComparer.Ordinal).ToList();
+
+                ImGui.TextUnformatted("Files for " + kvp.Key);
+                ImGui.SameLine();
+                ImGui.TextUnformatted(kvp.Value.Count.ToString());
+                ImGui.SameLine();
+
+                using (var font = ImRaii.PushFont(UiBuilder.IconFont))
+                {
+                    ImGui.TextUnformatted(FontAwesomeIcon.InfoCircle.ToIconString());
+                }
+                if (ImGui.IsItemHovered())
+                {
+                    string text = "";
+                    text = string.Join(Environment.NewLine, groupedfiles
+                        .Select(f => f.Key + ": " + f.Count() + " files, size: " + UiSharedService.ByteToString(f.Sum(v => v.OriginalSize))
+                        + ", compressed: " + UiSharedService.ByteToString(f.Sum(v => v.CompressedSize))));
+                    ImGui.SetTooltip(text);
+                }
+                ImGui.TextUnformatted($"{kvp.Key} size (actual):");
+                ImGui.SameLine();
+                ImGui.TextUnformatted(UiSharedService.ByteToString(kvp.Value.Sum(c => c.Value.OriginalSize)));
+                ImGui.TextUnformatted($"{kvp.Key} size (download size):");
+                ImGui.SameLine();
+                using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, needAnalysis))
+                {
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(kvp.Value.Sum(c => c.Value.CompressedSize)));
+                    if (needAnalysis && !isAnalyzing)
+                    {
+                        ImGui.SameLine();
+                        using (ImRaii.PushFont(UiBuilder.IconFont))
+                            ImGui.TextUnformatted(FontAwesomeIcon.ExclamationCircle.ToIconString());
+                        UiSharedService.AttachToolTip("Click \"Start analysis\" to calculate download size");
+                    }
+                }
+                ImGui.TextUnformatted($"{kvp.Key} VRAM usage:");
+                ImGui.SameLine();
+                var vramUsage = groupedfiles.SingleOrDefault(v => string.Equals(v.Key, "tex", StringComparison.Ordinal));
+                if (vramUsage != null)
+                {
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(vramUsage.Sum(f => f.OriginalSize)));
+                }
+                ImGui.TextUnformatted($"{kvp.Key} modded model triangles: {UiSharedService.TrisToString(kvp.Value.Sum(f => f.Value.Triangles))}");
+
+                ImGui.Separator();
+                if (_selectedObjectTab != kvp.Key)
+                {
+                    _selectedHash = string.Empty;
+                    _selectedObjectTab = kvp.Key;
+                    _selectedFileTypeTab = string.Empty;
+                    _enableBc7ConversionMode = false;
+                    _texturesToConvert.Clear();
+                }
+
+                using var fileTabBar = ImRaii.TabBar("fileTabs");
+
+                foreach (IGrouping<string, CharacterAnalyzer.FileDataEntry>? fileGroup in groupedfiles)
+                {
+                    string fileGroupText = fileGroup.Key + " [" + fileGroup.Count() + "]";
+                    var requiresCompute = fileGroup.Any(k => !k.IsComputed);
+                    using var tabcol = ImRaii.PushColor(ImGuiCol.Tab, UiSharedService.Color(ImGuiColors.DalamudYellow), requiresCompute);
+                    ImRaii.IEndObject fileTab;
+                    using (var textcol = ImRaii.PushColor(ImGuiCol.Text, UiSharedService.Color(new(0, 0, 0, 1)),
+                        requiresCompute && !string.Equals(_selectedFileTypeTab, fileGroup.Key, StringComparison.Ordinal)))
+                    {
+                        fileTab = ImRaii.TabItem(fileGroupText + "###" + fileGroup.Key);
+                    }
+
+                    if (!fileTab) { fileTab.Dispose(); continue; }
+
+                    if (!string.Equals(fileGroup.Key, _selectedFileTypeTab, StringComparison.Ordinal))
+                    {
+                        _selectedFileTypeTab = fileGroup.Key;
+                        _selectedHash = string.Empty;
+                        _enableBc7ConversionMode = false;
+                        _texturesToConvert.Clear();
+                    }
+
+                    ImGui.TextUnformatted($"{fileGroup.Key} files");
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted(fileGroup.Count().ToString());
+
+                    ImGui.TextUnformatted($"{fileGroup.Key} files size (actual):");
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(fileGroup.Sum(c => c.OriginalSize)));
+
+                    ImGui.TextUnformatted($"{fileGroup.Key} files size (download size):");
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(fileGroup.Sum(c => c.CompressedSize)));
+
+                    if (string.Equals(_selectedFileTypeTab, "tex", StringComparison.Ordinal))
+                    {
+                        ImGui.Checkbox("Enable BC7 Conversion Mode", ref _enableBc7ConversionMode);
+                        if (_enableBc7ConversionMode)
+                        {
+                            UiSharedService.ColorText("WARNING BC7 CONVERSION:", ImGuiColors.DalamudYellow);
+                            ImGui.SameLine();
+                            UiSharedService.ColorText("Converting textures to BC7 is irreversible!", ImGuiColors.DalamudRed);
+                            UiSharedService.ColorTextWrapped("- Converting textures to BC7 will reduce their size (compressed and uncompressed) drastically. It is recommended to be used for large (4k+) textures." +
+                            Environment.NewLine + "- Some textures, especially ones utilizing colorsets, might not be suited for BC7 conversion and might produce visual artifacts." +
+                            Environment.NewLine + "- Before converting textures, make sure to have the original files of the mod you are converting so you can reimport it in case of issues." +
+                            Environment.NewLine + "- Conversion will convert all found texture duplicates (entries with more than 1 file path) automatically." +
+                            Environment.NewLine + "- Converting textures to BC7 is a very expensive operation and, depending on the amount of textures to convert, will take a while to complete."
+                                , ImGuiColors.DalamudYellow);
+                            if (_texturesToConvert.Count > 0 && _uiSharedService.IconTextButton(FontAwesomeIcon.PlayCircle, "Start conversion of " + _texturesToConvert.Count + " texture(s)"))
+                            {
+                                _conversionCancellationTokenSource = _conversionCancellationTokenSource.CancelRecreate();
+                                _conversionTask = _ipcManager.Penumbra.ConvertTextureFiles(_logger, _texturesToConvert, _conversionProgress, _conversionCancellationTokenSource.Token);
+                            }
+                        }
+                    }
+
+                    ImGui.Separator();
+                    DrawTable(fileGroup);
+
+                    fileTab.Dispose();
+                }
+            }
+        }
+
+        ImGui.Separator();
+
+        ImGui.TextUnformatted("Selected file:");
+        ImGui.SameLine();
+        UiSharedService.ColorText(_selectedHash, ImGuiColors.DalamudYellow);
+
+        if (_cachedAnalysis[_selectedObjectTab].TryGetValue(_selectedHash, out CharacterAnalyzer.FileDataEntry? item))
+        {
+            var filePaths = item.FilePaths;
+            ImGui.TextUnformatted("Local file path:");
+            ImGui.SameLine();
+            UiSharedService.TextWrapped(filePaths[0]);
+            if (filePaths.Count > 1)
+            {
+                ImGui.SameLine();
+                ImGui.TextUnformatted($"(and {filePaths.Count - 1} more)");
+                ImGui.SameLine();
+                _uiSharedService.IconText(FontAwesomeIcon.InfoCircle);
+                UiSharedService.AttachToolTip(string.Join(Environment.NewLine, filePaths.Skip(1)));
+            }
+
+            var gamepaths = item.GamePaths;
+            ImGui.TextUnformatted("Used by game path:");
+            ImGui.SameLine();
+            UiSharedService.TextWrapped(gamepaths[0]);
+            if (gamepaths.Count > 1)
+            {
+                ImGui.SameLine();
+                ImGui.TextUnformatted($"(and {gamepaths.Count - 1} more)");
+                ImGui.SameLine();
+                _uiSharedService.IconText(FontAwesomeIcon.InfoCircle);
+                UiSharedService.AttachToolTip(string.Join(Environment.NewLine, gamepaths.Skip(1)));
+            }
+        }
+    }
+
+    public override void OnOpen()
+    {
+        _hasUpdate = true;
+        _selectedHash = string.Empty;
+        _enableBc7ConversionMode = false;
+        _texturesToConvert.Clear();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        _conversionProgress.ProgressChanged -= ConversionProgress_ProgressChanged;
+    }
+
+    private void ConversionProgress_ProgressChanged(object? sender, (string, int) e)
+    {
+        _conversionCurrentFileName = e.Item1;
+        _conversionCurrentFileProgress = e.Item2;
+    }
+
+    private void DrawTable(IGrouping<string, CharacterAnalyzer.FileDataEntry> fileGroup)
+    {
+        var tableColumns = string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal)
+            ? (_enableBc7ConversionMode ? 7 : 6)
+            : (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal) ? 6 : 5);
+        using var table = ImRaii.Table("Analysis", tableColumns, ImGuiTableFlags.Sortable | ImGuiTableFlags.RowBg | ImGuiTableFlags.ScrollY | ImGuiTableFlags.SizingFixedFit,
+            new Vector2(0, 300));
+        if (!table.Success) return;
+        ImGui.TableSetupColumn("Hash");
+        ImGui.TableSetupColumn("Filepaths", ImGuiTableColumnFlags.PreferSortDescending);
+        ImGui.TableSetupColumn("Gamepaths", ImGuiTableColumnFlags.PreferSortDescending);
+        ImGui.TableSetupColumn("File Size", ImGuiTableColumnFlags.DefaultSort | ImGuiTableColumnFlags.PreferSortDescending);
+        ImGui.TableSetupColumn("Download Size", ImGuiTableColumnFlags.PreferSortDescending);
+        if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal))
+        {
+            ImGui.TableSetupColumn("Format");
+            if (_enableBc7ConversionMode) ImGui.TableSetupColumn("Convert to BC7");
+        }
+        if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal))
+        {
+            ImGui.TableSetupColumn("Triangles", ImGuiTableColumnFlags.PreferSortDescending);
+        }
+        ImGui.TableSetupScrollFreeze(0, 1);
+        ImGui.TableHeadersRow();
+
+        var sortSpecs = ImGui.TableGetSortSpecs();
+        if (sortSpecs.SpecsDirty || _sortDirty)
+        {
+            var idx = sortSpecs.Specs.ColumnIndex;
+
+            if (idx == 0 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Key, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 0 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Key, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 1 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.FilePaths.Count).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 1 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.FilePaths.Count).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 2 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.GamePaths.Count).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 2 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.GamePaths.Count).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 3 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.OriginalSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 3 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.OriginalSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 4 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.CompressedSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 4 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.CompressedSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal) && idx == 5 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.Triangles).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal) && idx == 5 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.Triangles).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal) && idx == 5 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.Format.Value, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal) && idx == 5 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.Format.Value, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+
+            sortSpecs.SpecsDirty = false;
+            _sortDirty = false;
+        }
+
+        foreach (var item in fileGroup)
+        {
+            using var text = ImRaii.PushColor(ImGuiCol.Text, new Vector4(0, 0, 0, 1), string.Equals(item.Hash, _selectedHash, StringComparison.Ordinal));
+            using var text2 = ImRaii.PushColor(ImGuiCol.Text, new Vector4(1, 1, 1, 1), !item.IsComputed);
+            ImGui.TableNextColumn();
+            if (string.Equals(_selectedHash, item.Hash, StringComparison.Ordinal))
+            {
+                ImGui.TableSetBgColor(ImGuiTableBgTarget.RowBg1, UiSharedService.Color(ImGuiColors.DalamudYellow));
+                ImGui.TableSetBgColor(ImGuiTableBgTarget.RowBg0, UiSharedService.Color(ImGuiColors.DalamudYellow));
+            }
+            ImGui.TextUnformatted(item.Hash);
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            ImGui.TableNextColumn();
+            ImGui.TextUnformatted(item.FilePaths.Count.ToString());
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            ImGui.TableNextColumn();
+            ImGui.TextUnformatted(item.GamePaths.Count.ToString());
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            ImGui.TableNextColumn();
+            ImGui.TextUnformatted(UiSharedService.ByteToString(item.OriginalSize));
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            ImGui.TableNextColumn();
+            using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, !item.IsComputed))
+                ImGui.TextUnformatted(UiSharedService.ByteToString(item.CompressedSize));
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal))
+            {
+                ImGui.TableNextColumn();
+                ImGui.TextUnformatted(item.Format.Value);
+                if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+                if (_enableBc7ConversionMode)
+                {
+                    ImGui.TableNextColumn();
+                    if (item.Format.Value.StartsWith("BC", StringComparison.Ordinal) || item.Format.Value.StartsWith("DXT", StringComparison.Ordinal)
+                        || item.Format.Value.StartsWith("24864", StringComparison.Ordinal)) // BC4
+                    {
+                        ImGui.TextUnformatted("");
+                        continue;
+                    }
+                    var filePath = item.FilePaths[0];
+                    bool toConvert = _texturesToConvert.ContainsKey(filePath);
+                    if (ImGui.Checkbox("###convert" + item.Hash, ref toConvert))
+                    {
+                        if (toConvert && !_texturesToConvert.ContainsKey(filePath))
+                        {
+                            _texturesToConvert[filePath] = item.FilePaths.Skip(1).ToArray();
+                        }
+                        else if (!toConvert && _texturesToConvert.ContainsKey(filePath))
+                        {
+                            _texturesToConvert.Remove(filePath);
+                        }
+                    }
+                }
+            }
+            if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal))
+            {
+                ImGui.TableNextColumn();
+                ImGui.TextUnformatted(UiSharedService.TrisToString(item.Triangles));
+                if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            }
+        }
+    }
+}

MareSynchronos/UI/DownloadUi.cs

@@ -0,0 +1,248 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface.Colors;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.WebAPI.Files;
+using MareSynchronos.WebAPI.Files.Models;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+public class DownloadUi : WindowMediatorSubscriberBase
+{
+    private readonly MareConfigService _configService;
+    private readonly ConcurrentDictionary<GameObjectHandler, Dictionary<string, FileDownloadStatus>> _currentDownloads = new();
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly FileUploadManager _fileTransferManager;
+    private readonly UiSharedService _uiShared;
+    private readonly ConcurrentDictionary<GameObjectHandler, bool> _uploadingPlayers = new();
+
+    public DownloadUi(ILogger<DownloadUi> logger, DalamudUtilService dalamudUtilService, MareConfigService configService,
+        FileUploadManager fileTransferManager, MareMediator mediator, UiSharedService uiShared, PerformanceCollectorService performanceCollectorService)
+        : base(logger, mediator, "Elezen Downloads", performanceCollectorService)
+    {
+        _dalamudUtilService = dalamudUtilService;
+        _configService = configService;
+        _fileTransferManager = fileTransferManager;
+        _uiShared = uiShared;
+
+        SizeConstraints = new WindowSizeConstraints()
+        {
+            MaximumSize = new Vector2(500, 90),
+            MinimumSize = new Vector2(500, 90),
+        };
+
+        Flags |= ImGuiWindowFlags.NoMove;
+        Flags |= ImGuiWindowFlags.NoBackground;
+        Flags |= ImGuiWindowFlags.NoInputs;
+        Flags |= ImGuiWindowFlags.NoNavFocus;
+        Flags |= ImGuiWindowFlags.NoResize;
+        Flags |= ImGuiWindowFlags.NoScrollbar;
+        Flags |= ImGuiWindowFlags.NoTitleBar;
+        Flags |= ImGuiWindowFlags.NoDecoration;
+        Flags |= ImGuiWindowFlags.NoFocusOnAppearing;
+
+        DisableWindowSounds = true;
+
+        ForceMainWindow = true;
+
+        IsOpen = true;
+
+        Mediator.Subscribe<DownloadStartedMessage>(this, (msg) => _currentDownloads[msg.DownloadId] = msg.DownloadStatus);
+        Mediator.Subscribe<DownloadFinishedMessage>(this, (msg) => _currentDownloads.TryRemove(msg.DownloadId, out _));
+        Mediator.Subscribe<GposeStartMessage>(this, (_) => IsOpen = false);
+        Mediator.Subscribe<GposeEndMessage>(this, (_) => IsOpen = true);
+        Mediator.Subscribe<PlayerUploadingMessage>(this, (msg) =>
+        {
+            if (msg.IsUploading)
+            {
+                _uploadingPlayers[msg.Handler] = true;
+            }
+            else
+            {
+                _uploadingPlayers.TryRemove(msg.Handler, out _);
+            }
+        });
+    }
+
+    protected override void DrawInternal()
+    {
+        if (_configService.Current.ShowTransferWindow)
+        {
+            try
+            {
+                if (_fileTransferManager.CurrentUploads.Any())
+                {
+                    var currentUploads = _fileTransferManager.CurrentUploads.ToList();
+                    var totalUploads = currentUploads.Count;
+
+                    var doneUploads = currentUploads.Count(c => c.IsTransferred);
+                    var totalUploaded = currentUploads.Sum(c => c.Transferred);
+                    var totalToUpload = currentUploads.Sum(c => c.Total);
+
+                    UiSharedService.DrawOutlinedFont($"▲", ImGuiColors.DalamudWhite, new Vector4(0, 0, 0, 255), 1);
+                    ImGui.SameLine();
+                    var xDistance = ImGui.GetCursorPosX();
+                    UiSharedService.DrawOutlinedFont($"Compressing+Uploading {doneUploads}/{totalUploads}",
+                        ImGuiColors.DalamudWhite, new Vector4(0, 0, 0, 255), 1);
+                    ImGui.NewLine();
+                    ImGui.SameLine(xDistance);
+                    UiSharedService.DrawOutlinedFont(
+                        $"{UiSharedService.ByteToString(totalUploaded, addSuffix: false)}/{UiSharedService.ByteToString(totalToUpload)}",
+                        ImGuiColors.DalamudWhite, new Vector4(0, 0, 0, 255), 1);
+
+                    if (_currentDownloads.Any()) ImGui.Separator();
+                }
+            }
+            catch
+            {
+                // ignore errors thrown from UI
+            }
+
+            try
+            {
+                foreach (var item in _currentDownloads.ToList())
+                {
+                    var dlSlot = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.WaitingForSlot);
+                    var dlQueue = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.WaitingForQueue);
+                    var dlProg = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.Downloading);
+                    var dlDecomp = item.Value.Count(c => c.Value.DownloadStatus == DownloadStatus.Decompressing);
+                    var totalFiles = item.Value.Sum(c => c.Value.TotalFiles);
+                    var transferredFiles = item.Value.Sum(c => c.Value.TransferredFiles);
+                    var totalBytes = item.Value.Sum(c => c.Value.TotalBytes);
+                    var transferredBytes = item.Value.Sum(c => c.Value.TransferredBytes);
+
+                    UiSharedService.DrawOutlinedFont($"▼", ImGuiColors.DalamudWhite, new Vector4(0, 0, 0, 255), 1);
+                    ImGui.SameLine();
+                    var xDistance = ImGui.GetCursorPosX();
+                    UiSharedService.DrawOutlinedFont(
+                        $"{item.Key.Name} [W:{dlSlot}/Q:{dlQueue}/P:{dlProg}/D:{dlDecomp}]",
+                        ImGuiColors.DalamudWhite, new Vector4(0, 0, 0, 255), 1);
+                    ImGui.NewLine();
+                    ImGui.SameLine(xDistance);
+                    UiSharedService.DrawOutlinedFont(
+                        $"{transferredFiles}/{totalFiles} ({UiSharedService.ByteToString(transferredBytes, addSuffix: false)}/{UiSharedService.ByteToString(totalBytes)})",
+                        ImGuiColors.DalamudWhite, new Vector4(0, 0, 0, 255), 1);
+                }
+            }
+            catch
+            {
+                // ignore errors thrown from UI
+            }
+        }
+
+        if (_configService.Current.ShowTransferBars)
+        {
+            const int transparency = 100;
+            const int dlBarBorder = 3;
+
+            foreach (var transfer in _currentDownloads.ToList())
+            {
+                var screenPos = _dalamudUtilService.WorldToScreen(transfer.Key.GetGameObject());
+                if (screenPos == Vector2.Zero) continue;
+
+                var totalBytes = transfer.Value.Sum(c => c.Value.TotalBytes);
+                var transferredBytes = transfer.Value.Sum(c => c.Value.TransferredBytes);
+
+                var maxDlText = $"{UiSharedService.ByteToString(totalBytes, addSuffix: false)}/{UiSharedService.ByteToString(totalBytes)}";
+                var textSize = _configService.Current.TransferBarsShowText ? ImGui.CalcTextSize(maxDlText) : new Vector2(10, 10);
+
+                int dlBarHeight = _configService.Current.TransferBarsHeight > ((int)textSize.Y + 5) ? _configService.Current.TransferBarsHeight : (int)textSize.Y + 5;
+                int dlBarWidth = _configService.Current.TransferBarsWidth > ((int)textSize.X + 10) ? _configService.Current.TransferBarsWidth : (int)textSize.X + 10;
+
+                var dlBarStart = new Vector2(screenPos.X - dlBarWidth / 2f, screenPos.Y - dlBarHeight / 2f);
+                var dlBarEnd = new Vector2(screenPos.X + dlBarWidth / 2f, screenPos.Y + dlBarHeight / 2f);
+                var drawList = ImGui.GetBackgroundDrawList();
+                drawList.AddRectFilled(
+                    dlBarStart with { X = dlBarStart.X - dlBarBorder - 1, Y = dlBarStart.Y - dlBarBorder - 1 },
+                    dlBarEnd with { X = dlBarEnd.X + dlBarBorder + 1, Y = dlBarEnd.Y + dlBarBorder + 1 },
+                    UiSharedService.Color(0, 0, 0, transparency), 1);
+                drawList.AddRectFilled(dlBarStart with { X = dlBarStart.X - dlBarBorder, Y = dlBarStart.Y - dlBarBorder },
+                    dlBarEnd with { X = dlBarEnd.X + dlBarBorder, Y = dlBarEnd.Y + dlBarBorder },
+                    UiSharedService.Color(220, 220, 220, transparency), 1);
+                drawList.AddRectFilled(dlBarStart, dlBarEnd,
+                    UiSharedService.Color(0, 0, 0, transparency), 1);
+                var dlProgressPercent = transferredBytes / (double)totalBytes;
+                drawList.AddRectFilled(dlBarStart,
+                    dlBarEnd with { X = dlBarStart.X + (float)(dlProgressPercent * dlBarWidth) },
+                    UiSharedService.Color(50, 205, 50, transparency), 1);
+
+                if (_configService.Current.TransferBarsShowText)
+                {
+                    var downloadText = $"{UiSharedService.ByteToString(transferredBytes, addSuffix: false)}/{UiSharedService.ByteToString(totalBytes)}";
+                    UiSharedService.DrawOutlinedFont(drawList, downloadText,
+                        screenPos with { X = screenPos.X - textSize.X / 2f - 1, Y = screenPos.Y - textSize.Y / 2f - 1 },
+                        UiSharedService.Color(255, 255, 255, transparency),
+                        UiSharedService.Color(0, 0, 0, transparency), 1);
+                }
+            }
+
+            if (_configService.Current.ShowUploading)
+            {
+                foreach (var player in _uploadingPlayers.Select(p => p.Key).ToList())
+                {
+                    var screenPos = _dalamudUtilService.WorldToScreen(player.GetGameObject());
+                    if (screenPos == Vector2.Zero) continue;
+
+                    try
+                    {
+                        using var _ = _uiShared.UidFont.Push();
+                        var uploadText = "Uploading";
+
+                        var textSize = ImGui.CalcTextSize(uploadText);
+
+                        var drawList = ImGui.GetBackgroundDrawList();
+                        UiSharedService.DrawOutlinedFont(drawList, uploadText,
+                            screenPos with { X = screenPos.X - textSize.X / 2f - 1, Y = screenPos.Y - textSize.Y / 2f - 1 },
+                            UiSharedService.Color(255, 255, 0, transparency),
+                            UiSharedService.Color(0, 0, 0, transparency), 2);
+                    }
+                    catch
+                    {
+                        // ignore errors thrown on UI
+                    }
+                }
+            }
+        }
+    }
+
+    public override bool DrawConditions()
+    {
+        if (_uiShared.EditTrackerPosition) return true;
+        if (!_configService.Current.ShowTransferWindow && !_configService.Current.ShowTransferBars) return false;
+        if (!_currentDownloads.Any() && !_fileTransferManager.CurrentUploads.Any() && !_uploadingPlayers.Any()) return false;
+        if (!IsOpen) return false;
+        return true;
+    }
+
+    public override void PreDraw()
+    {
+        base.PreDraw();
+
+        if (_uiShared.EditTrackerPosition)
+        {
+            Flags &= ~ImGuiWindowFlags.NoMove;
+            Flags &= ~ImGuiWindowFlags.NoBackground;
+            Flags &= ~ImGuiWindowFlags.NoInputs;
+            Flags &= ~ImGuiWindowFlags.NoResize;
+        }
+        else
+        {
+            Flags |= ImGuiWindowFlags.NoMove;
+            Flags |= ImGuiWindowFlags.NoBackground;
+            Flags |= ImGuiWindowFlags.NoInputs;
+            Flags |= ImGuiWindowFlags.NoResize;
+        }
+
+        var maxHeight = ImGui.GetTextLineHeight() * (_configService.Current.ParallelDownloads + 3);
+        SizeConstraints = new()
+        {
+            MinimumSize = new Vector2(300, maxHeight),
+            MaximumSize = new Vector2(300, maxHeight),
+        };
+    }
+}

MareSynchronos/UI/DtrEntry.cs

@@ -0,0 +1,241 @@
+using Dalamud.Game.Gui.Dtr;
+using Dalamud.Game.Text.SeStringHandling;
+using Dalamud.Game.Text.SeStringHandling.Payloads;
+using Dalamud.Plugin.Services;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Configurations;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.WebAPI;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System.Runtime.InteropServices;
+
+namespace MareSynchronos.UI;
+
+public sealed class DtrEntry : IDisposable, IHostedService
+{
+    private enum DtrStyle
+    {
+        Default,
+        Style1,
+        Style2,
+        Style3,
+        Style4,
+        Style5,
+        Style6,
+        Style7,
+        Style8,
+        Style9
+    }
+
+    public const int NumStyles = 10;
+
+    private readonly ApiController _apiController;
+    private readonly CancellationTokenSource _cancellationTokenSource = new();
+    private readonly MareConfigService _configService;
+    private readonly IDtrBar _dtrBar;
+    private readonly Lazy<IDtrBarEntry> _entry;
+    private readonly ILogger<DtrEntry> _logger;
+    private readonly MareMediator _mareMediator;
+    private readonly PairManager _pairManager;
+    private Task? _runTask;
+    private string? _text;
+    private string? _tooltip;
+    private Colors _colors;
+
+    public DtrEntry(ILogger<DtrEntry> logger, IDtrBar dtrBar, MareConfigService configService, MareMediator mareMediator, PairManager pairManager, ApiController apiController)
+    {
+        _logger = logger;
+        _dtrBar = dtrBar;
+        _entry = new(CreateEntry);
+        _configService = configService;
+        _mareMediator = mareMediator;
+        _pairManager = pairManager;
+        _apiController = apiController;
+    }
+
+    public void Dispose()
+    {
+        if (_entry.IsValueCreated)
+        {
+            _logger.LogDebug("Disposing DtrEntry");
+            Clear();
+            _entry.Value.Remove();
+        }
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting DtrEntry");
+        _runTask = Task.Run(RunAsync, _cancellationTokenSource.Token);
+        _logger.LogInformation("Started DtrEntry");
+        return Task.CompletedTask;
+    }
+
+    public async Task StopAsync(CancellationToken cancellationToken)
+    {
+        _cancellationTokenSource.Cancel();
+        try
+        {
+            await _runTask!.ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            // ignore cancelled
+        }
+        finally
+        {
+            _cancellationTokenSource.Dispose();
+        }
+    }
+
+    private void Clear()
+    {
+        if (!_entry.IsValueCreated) return;
+        _logger.LogInformation("Clearing entry");
+        _text = null;
+        _tooltip = null;
+        _colors = default;
+
+        _entry.Value.Shown = false;
+    }
+
+    private IDtrBarEntry CreateEntry()
+    {
+        _logger.LogTrace("Creating new DtrBar entry");
+        var entry = _dtrBar.Get("Elezen");
+        entry.OnClick = _ => _mareMediator.Publish(new UiToggleMessage(typeof(CompactUi)));
+
+        return entry;
+    }
+
+    private async Task RunAsync()
+    {
+        while (!_cancellationTokenSource.IsCancellationRequested)
+        {
+            await Task.Delay(1000, _cancellationTokenSource.Token).ConfigureAwait(false);
+
+            Update();
+        }
+    }
+
+    private void Update()
+    {
+        if (!_configService.Current.EnableDtrEntry || !_configService.Current.HasValidSetup())
+        {
+            if (_entry.IsValueCreated && _entry.Value.Shown)
+            {
+                _logger.LogInformation("Disabling entry");
+
+                Clear();
+            }
+            return;
+        }
+
+        if (!_entry.Value.Shown)
+        {
+            _logger.LogInformation("Showing entry");
+            _entry.Value.Shown = true;
+        }
+
+        string text;
+        string tooltip;
+        Colors colors;
+        if (_apiController.IsConnected)
+        {
+            var pairCount = _pairManager.GetVisibleUserCount();
+
+            text = RenderDtrStyle(_configService.Current.DtrStyle, pairCount.ToString());
+            if (pairCount > 0)
+            {
+                IEnumerable<string> visiblePairs;
+                if (_configService.Current.ShowUidInDtrTooltip)
+                {
+                    visiblePairs = _pairManager.GetOnlineUserPairs()
+                        .Where(x => x.IsVisible)
+                        .Select(x => string.Format("{0} ({1})", _configService.Current.PreferNoteInDtrTooltip ? x.GetNoteOrName() : x.PlayerName, x.UserData.AliasOrUID));
+                }
+                else
+                {
+                    visiblePairs = _pairManager.GetOnlineUserPairs()
+                        .Where(x => x.IsVisible)
+                        .Select(x => string.Format("{0}", _configService.Current.PreferNoteInDtrTooltip ? x.GetNoteOrName() : x.PlayerName));
+                }
+
+                tooltip = $"Elezen: Connected{Environment.NewLine}----------{Environment.NewLine}{string.Join(Environment.NewLine, visiblePairs)}";
+                colors = _configService.Current.DtrColorsPairsInRange;
+            }
+            else
+            {
+                tooltip = "Elezen: Connected";
+                colors = _configService.Current.DtrColorsDefault;
+            }
+        }
+        else
+        {
+            text = RenderDtrStyle(_configService.Current.DtrStyle, "\uE04C");
+            tooltip = "Elezen: Not Connected";
+            colors = _configService.Current.DtrColorsNotConnected;
+        }
+
+        if (!_configService.Current.UseColorsInDtr)
+            colors = default;
+
+        if (!string.Equals(text, _text, StringComparison.Ordinal) || !string.Equals(tooltip, _tooltip, StringComparison.Ordinal) || colors != _colors)
+        {
+            _text = text;
+            _tooltip = tooltip;
+            _colors = colors;
+            _entry.Value.Text = BuildColoredSeString(text, colors);
+            _entry.Value.Tooltip = tooltip;
+        }
+    }
+
+    public static string RenderDtrStyle(int styleNum, string text)
+    {
+        var style = (DtrStyle)styleNum;
+
+        return style switch {
+            DtrStyle.Style1 => $"\xE039 {text}",
+            DtrStyle.Style2 => $"\xE0BC {text}",
+            DtrStyle.Style3 => $"\xE0BD {text}",
+            DtrStyle.Style4 => $"\xE03A {text}",
+            DtrStyle.Style5 => $"\xE033 {text}",
+            DtrStyle.Style6 => $"\xE038 {text}",
+            DtrStyle.Style7 => $"\xE05D {text}",
+            DtrStyle.Style8 => $"\xE03C{text}",
+            DtrStyle.Style9 => $"\xE040 {text} \xE041",
+            _ => $"\uE044 {text}"
+        };
+    }
+
+    #region Colored SeString
+    private const byte _colorTypeForeground = 0x13;
+    private const byte _colorTypeGlow = 0x14;
+
+    private static SeString BuildColoredSeString(string text, Colors colors)
+    {
+        var ssb = new SeStringBuilder();
+        if (colors.Foreground != default)
+            ssb.Add(BuildColorStartPayload(_colorTypeForeground, colors.Foreground));
+        if (colors.Glow != default)
+            ssb.Add(BuildColorStartPayload(_colorTypeGlow, colors.Glow));
+        ssb.AddText(text);
+        if (colors.Glow != default)
+            ssb.Add(BuildColorEndPayload(_colorTypeGlow));
+        if (colors.Foreground != default)
+            ssb.Add(BuildColorEndPayload(_colorTypeForeground));
+        return ssb.Build();
+    }
+
+    private static RawPayload BuildColorStartPayload(byte colorType, uint color)
+        => new(unchecked([0x02, colorType, 0x05, 0xF6, byte.Max((byte)color, 0x01), byte.Max((byte)(color >> 8), 0x01), byte.Max((byte)(color >> 16), 0x01), 0x03]));
+
+    private static RawPayload BuildColorEndPayload(byte colorType)
+        => new([0x02, colorType, 0x02, 0xEC, 0x03]);
+
+    [StructLayout(LayoutKind.Sequential)]
+    public readonly record struct Colors(uint Foreground = default, uint Glow = default);
+    #endregion
+}

MareSynchronos/UI/EditProfileUi.cs

@@ -0,0 +1,220 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.ImGuiFileDialog;
+using Dalamud.Interface.Textures.TextureWraps;
+using Dalamud.Interface.Utility;
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Dto.User;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.Utils;
+using MareSynchronos.WebAPI;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.UI;
+
+public class EditProfileUi : WindowMediatorSubscriberBase
+{
+    private readonly ApiController _apiController;
+    private readonly FileDialogManager _fileDialogManager;
+    private readonly MareProfileManager _mareProfileManager;
+    private readonly UiSharedService _uiSharedService;
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+    private bool _adjustedForScollBarsLocalProfile = false;
+    private bool _adjustedForScollBarsOnlineProfile = false;
+    private string _descriptionText = string.Empty;
+    private IDalamudTextureWrap? _pfpTextureWrap;
+    private string _profileDescription = string.Empty;
+    private byte[] _profileImage = [];
+    private bool _showFileDialogError = false;
+    private bool _wasOpen;
+
+    public EditProfileUi(ILogger<EditProfileUi> logger, MareMediator mediator,
+        ApiController apiController, UiSharedService uiSharedService, FileDialogManager fileDialogManager,
+        ServerConfigurationManager serverConfigurationManager,
+        MareProfileManager mareProfileManager, PerformanceCollectorService performanceCollectorService)
+        : base(logger, mediator, "Elezen Edit Profile###ElezenSyncEditProfileUI", performanceCollectorService)
+    {
+        IsOpen = false;
+        this.SizeConstraints = new()
+        {
+            MinimumSize = new(768, 512),
+            MaximumSize = new(768, 2000)
+        };
+        _apiController = apiController;
+        _uiSharedService = uiSharedService;
+        _fileDialogManager = fileDialogManager;
+        _serverConfigurationManager = serverConfigurationManager;
+        _mareProfileManager = mareProfileManager;
+
+        Mediator.Subscribe<GposeStartMessage>(this, (_) => { _wasOpen = IsOpen; IsOpen = false; });
+        Mediator.Subscribe<GposeEndMessage>(this, (_) => IsOpen = _wasOpen);
+        Mediator.Subscribe<DisconnectedMessage>(this, (_) => IsOpen = false);
+        Mediator.Subscribe<ClearProfileDataMessage>(this, (msg) =>
+        {
+            if (msg.UserData == null || string.Equals(msg.UserData.UID, _apiController.UID, StringComparison.Ordinal))
+            {
+                _pfpTextureWrap?.Dispose();
+                _pfpTextureWrap = null;
+            }
+        });
+    }
+
+    protected override void DrawInternal()
+    {
+        _uiSharedService.BigText("Current Profile (as saved on server)");
+
+        var profile = _mareProfileManager.GetMareProfile(new UserData(_apiController.UID));
+
+        if (profile.IsFlagged)
+        {
+            UiSharedService.ColorTextWrapped(profile.Description, ImGuiColors.DalamudRed);
+            return;
+        }
+
+        if (!_profileImage.SequenceEqual(profile.ImageData.Value))
+        {
+            _profileImage = profile.ImageData.Value;
+            _pfpTextureWrap?.Dispose();
+            _pfpTextureWrap = _uiSharedService.LoadImage(_profileImage);
+        }
+
+        if (!string.Equals(_profileDescription, profile.Description, StringComparison.OrdinalIgnoreCase))
+        {
+            _profileDescription = profile.Description;
+            _descriptionText = _profileDescription;
+        }
+
+        if (_pfpTextureWrap != null)
+        {
+            ImGui.Image(_pfpTextureWrap.Handle, ImGuiHelpers.ScaledVector2(_pfpTextureWrap.Width, _pfpTextureWrap.Height));
+        }
+
+        var spacing = ImGui.GetStyle().ItemSpacing.X;
+        ImGuiHelpers.ScaledRelativeSameLine(256, spacing);
+        using (_uiSharedService.GameFont.Push())
+        {
+            var descriptionTextSize = ImGui.CalcTextSize(profile.Description, hideTextAfterDoubleHash: false, 256f);
+            var childFrame = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 256);
+            if (descriptionTextSize.Y > childFrame.Y)
+            {
+                _adjustedForScollBarsOnlineProfile = true;
+            }
+            else
+            {
+                _adjustedForScollBarsOnlineProfile = false;
+            }
+            childFrame = childFrame with
+            {
+                X = childFrame.X + (_adjustedForScollBarsOnlineProfile ? ImGui.GetStyle().ScrollbarSize : 0),
+            };
+            if (ImGui.BeginChildFrame(101, childFrame))
+            {
+                UiSharedService.TextWrapped(profile.Description);
+            }
+            ImGui.EndChildFrame();
+        }
+
+        var nsfw = profile.IsNSFW;
+        ImGui.BeginDisabled();
+        ImGui.Checkbox("Is NSFW", ref nsfw);
+        ImGui.EndDisabled();
+
+        ImGui.Separator();
+        _uiSharedService.BigText("Profile Settings");
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.FileUpload, "Upload new profile picture"))
+        {
+            _fileDialogManager.OpenFileDialog("Select new Profile picture", ".png", (success, file) =>
+            {
+                if (!success) return;
+                _ = Task.Run(async () =>
+                {
+                    var fileContent = File.ReadAllBytes(file);
+                    using MemoryStream ms = new(fileContent);
+                    var format = PngHdr.TryExtractDimensions(ms);
+
+                    if (format.Width > 256 || format.Height > 256 || (fileContent.Length > 250 * 1024))
+                    {
+                        _showFileDialogError = true;
+                        return;
+                    }
+
+                    _showFileDialogError = false;
+                    await _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, Convert.ToBase64String(fileContent), Description: null))
+                        .ConfigureAwait(false);
+                });
+            });
+        }
+        UiSharedService.AttachToolTip("Select and upload a new profile picture");
+        ImGui.SameLine();
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear uploaded profile picture"))
+        {
+            _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, "", Description: null));
+        }
+        UiSharedService.AttachToolTip("Clear your currently uploaded profile picture");
+        if (_showFileDialogError)
+        {
+            UiSharedService.ColorTextWrapped("The profile picture must be a PNG file with a maximum height and width of 256px and 250KiB size", ImGuiColors.DalamudRed);
+        }
+        var isNsfw = profile.IsNSFW;
+        if (ImGui.Checkbox("Profile is NSFW", ref isNsfw))
+        {
+            _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, isNsfw, ProfilePictureBase64: null, Description: null));
+        }
+        _uiSharedService.DrawHelpText("If your profile description or image can be considered NSFW, toggle this to ON");
+        var widthTextBox = 400;
+        var posX = ImGui.GetCursorPosX();
+        ImGui.TextUnformatted($"Description {_descriptionText.Length}/1500");
+        ImGui.SetCursorPosX(posX);
+        ImGuiHelpers.ScaledRelativeSameLine(widthTextBox, ImGui.GetStyle().ItemSpacing.X);
+        ImGui.TextUnformatted("Preview (approximate)");
+        using (_uiSharedService.GameFont.Push())
+            ImGui.InputTextMultiline("##description", ref _descriptionText, 1500, ImGuiHelpers.ScaledVector2(widthTextBox, 200));
+
+        ImGui.SameLine();
+
+        using (_uiSharedService.GameFont.Push())
+        {
+            var descriptionTextSizeLocal = ImGui.CalcTextSize(_descriptionText, hideTextAfterDoubleHash: false, 256f);
+            var childFrameLocal = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 200);
+            if (descriptionTextSizeLocal.Y > childFrameLocal.Y)
+            {
+                _adjustedForScollBarsLocalProfile = true;
+            }
+            else
+            {
+                _adjustedForScollBarsLocalProfile = false;
+            }
+            childFrameLocal = childFrameLocal with
+            {
+                X = childFrameLocal.X + (_adjustedForScollBarsLocalProfile ? ImGui.GetStyle().ScrollbarSize : 0),
+            };
+            if (ImGui.BeginChildFrame(102, childFrameLocal))
+            {
+                UiSharedService.TextWrapped(_descriptionText);
+            }
+            ImGui.EndChildFrame();
+        }
+
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Save, "Save Description"))
+        {
+            _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, _descriptionText));
+        }
+        UiSharedService.AttachToolTip("Sets your profile description text");
+        ImGui.SameLine();
+        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Clear Description"))
+        {
+            _ = _apiController.UserSetProfile(new UserProfileDto(new UserData(_apiController.UID), Disabled: false, IsNSFW: null, ProfilePictureBase64: null, ""));
+        }
+        UiSharedService.AttachToolTip("Clears your profile description text");
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        _pfpTextureWrap?.Dispose();
+    }
+}

MareSynchronos/UI/EventViewerUI.cs

@@ -0,0 +1,238 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility.Raii;
+using Dalamud.Utility;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Events;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+using System.Globalization;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+internal class EventViewerUI : WindowMediatorSubscriberBase
+{
+    private readonly EventAggregator _eventAggregator;
+    private readonly UiSharedService _uiSharedService;
+    private readonly MareConfigService _configService;
+    private List<Event> _currentEvents = new();
+    private Lazy<List<Event>> _filteredEvents;
+    private string _filterFreeText = string.Empty;
+    private bool _isPaused = false;
+
+    private List<Event> CurrentEvents
+    {
+        get
+        {
+            return _currentEvents;
+        }
+        set
+        {
+            _currentEvents = value;
+            _filteredEvents = RecreateFilter();
+        }
+    }
+
+    public EventViewerUI(ILogger<EventViewerUI> logger, MareMediator mediator,
+        EventAggregator eventAggregator, UiSharedService uiSharedService, MareConfigService configService,
+        PerformanceCollectorService performanceCollectorService)
+        : base(logger, mediator, "Event Viewer", performanceCollectorService)
+    {
+        _eventAggregator = eventAggregator;
+        _uiSharedService = uiSharedService;
+        _configService = configService;
+        SizeConstraints = new()
+        {
+            MinimumSize = new(700, 400)
+        };
+        _filteredEvents = RecreateFilter();
+    }
+
+    private Lazy<List<Event>> RecreateFilter()
+    {
+        return new(() =>
+            CurrentEvents.Where(f =>
+                string.IsNullOrEmpty(_filterFreeText)
+                || (f.EventSource.Contains(_filterFreeText, StringComparison.OrdinalIgnoreCase)
+                    || f.Character.Contains(_filterFreeText, StringComparison.OrdinalIgnoreCase)
+                    || f.UID.Contains(_filterFreeText, StringComparison.OrdinalIgnoreCase)
+                    || f.Message.Contains(_filterFreeText, StringComparison.OrdinalIgnoreCase)
+                )
+             ).ToList());
+    }
+
+    private void ClearFilters()
+    {
+        _filterFreeText = string.Empty;
+        _filteredEvents = RecreateFilter();
+    }
+
+    public override void OnOpen()
+    {
+        CurrentEvents = _eventAggregator.EventList.Value.OrderByDescending(f => f.EventTime).ToList();
+        ClearFilters();
+    }
+
+    protected override void DrawInternal()
+    {
+        var newEventsAvailable = _eventAggregator.NewEventsAvailable;
+
+        var freezeSize = _uiSharedService.GetIconTextButtonSize(FontAwesomeIcon.PlayCircle, "Unfreeze View");
+        if (_isPaused)
+        {
+            using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, newEventsAvailable))
+            {
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.PlayCircle, "Unfreeze View"))
+                    _isPaused = false;
+                if (newEventsAvailable)
+                    UiSharedService.AttachToolTip("New events are available. Click to resume updating.");
+            }
+        }
+        else
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.PauseCircle, "Freeze View"))
+                _isPaused = true;
+        }
+
+        if (newEventsAvailable && !_isPaused)
+            CurrentEvents = _eventAggregator.EventList.Value.OrderByDescending(f => f.EventTime).ToList();
+
+        ImGui.SameLine(freezeSize + ImGui.GetStyle().ItemSpacing.X * 2);
+
+        bool changedFilter = false;
+        ImGui.SetNextItemWidth(200);
+        changedFilter |= ImGui.InputText("Filter lines", ref _filterFreeText, 50);
+        if (changedFilter) _filteredEvents = RecreateFilter();
+
+        using (ImRaii.Disabled(_filterFreeText.IsNullOrEmpty()))
+        {
+            ImGui.SameLine();
+            if (_uiSharedService.IconButton(FontAwesomeIcon.Ban))
+            {
+                _filterFreeText = string.Empty;
+                _filteredEvents = RecreateFilter();
+            }
+        }
+
+        if (_configService.Current.LogEvents)
+        {
+            var buttonSize = _uiSharedService.GetIconTextButtonSize(FontAwesomeIcon.FolderOpen, "Open EventLog Folder");
+            var dist = ImGui.GetWindowContentRegionMax().X - buttonSize;
+            ImGui.SameLine(dist);
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.FolderOpen, "Open EventLog folder"))
+            {
+                ProcessStartInfo ps = new()
+                {
+                    FileName = _eventAggregator.EventLogFolder,
+                    UseShellExecute = true,
+                    WindowStyle = ProcessWindowStyle.Normal
+                };
+                Process.Start(ps);
+            }
+        }
+
+        var cursorPos = ImGui.GetCursorPosY();
+        var max = ImGui.GetWindowContentRegionMax();
+        var min = ImGui.GetWindowContentRegionMin();
+        var width = max.X - min.X;
+        var height = max.Y - cursorPos;
+        using var table = ImRaii.Table("eventTable", 6, ImGuiTableFlags.SizingFixedFit | ImGuiTableFlags.ScrollY | ImGuiTableFlags.RowBg,
+            new Vector2(width, height));
+
+        float timeColWidth = ImGui.CalcTextSize("88:88:88 PM").X;
+        float sourceColWidth = ImGui.CalcTextSize("PairManager").X;
+        float uidColWidth = ImGui.CalcTextSize("WWWWWWW").X;
+        float characterColWidth = ImGui.CalcTextSize("Wwwwww Wwwwww").X;
+
+        if (table)
+        {
+            ImGui.TableSetupScrollFreeze(0, 1);
+            ImGui.TableSetupColumn(string.Empty, ImGuiTableColumnFlags.NoSort);
+            ImGui.TableSetupColumn("Time", ImGuiTableColumnFlags.None, timeColWidth);
+            ImGui.TableSetupColumn("Source", ImGuiTableColumnFlags.None, sourceColWidth);
+            ImGui.TableSetupColumn("UID", ImGuiTableColumnFlags.None, uidColWidth);
+            ImGui.TableSetupColumn("Character", ImGuiTableColumnFlags.None, characterColWidth);
+            ImGui.TableSetupColumn("Event", ImGuiTableColumnFlags.None);
+            ImGui.TableHeadersRow();
+            int i = 0;
+            foreach (var ev in _filteredEvents.Value)
+            {
+                ++i;
+
+                var icon = ev.EventSeverity switch
+                {
+                    EventSeverity.Informational => FontAwesomeIcon.InfoCircle,
+                    EventSeverity.Warning => FontAwesomeIcon.ExclamationTriangle,
+                    EventSeverity.Error => FontAwesomeIcon.Cross,
+                    _ => FontAwesomeIcon.QuestionCircle
+                };
+
+                var iconColor = ev.EventSeverity switch
+                {
+                    EventSeverity.Informational => new Vector4(),
+                    EventSeverity.Warning => ImGuiColors.DalamudYellow,
+                    EventSeverity.Error => ImGuiColors.DalamudRed,
+                    _ => new Vector4()
+                };
+
+                ImGui.TableNextColumn();
+                _uiSharedService.IconText(icon, iconColor == new Vector4() ? null : iconColor);
+                UiSharedService.AttachToolTip(ev.EventSeverity.ToString());
+                ImGui.TableNextColumn();
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextUnformatted(ev.EventTime.ToString("T", CultureInfo.CurrentCulture));
+                ImGui.TableNextColumn();
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextUnformatted(ev.EventSource);
+                ImGui.TableNextColumn();
+                ImGui.AlignTextToFramePadding();
+                if (!string.IsNullOrEmpty(ev.UID))
+                {
+                    if (ImGui.Selectable(ev.UID + $"##{i}"))
+                    {
+                        _filterFreeText = ev.UID;
+                        _filteredEvents = RecreateFilter();
+                    }
+                }
+                else
+                {
+                    ImGui.TextUnformatted("--");
+                }
+                ImGui.TableNextColumn();
+                ImGui.AlignTextToFramePadding();
+                if (!string.IsNullOrEmpty(ev.Character))
+                {
+                    if (ImGui.Selectable(ev.Character + $"##{i}"))
+                    {
+                        _filterFreeText = ev.Character;
+                        _filteredEvents = RecreateFilter();
+                    }
+                }
+                else
+                {
+                    ImGui.TextUnformatted("--");
+                }
+                ImGui.TableNextColumn();
+                ImGui.AlignTextToFramePadding();
+                var posX = ImGui.GetCursorPosX();
+                var maxTextLength = ImGui.GetWindowContentRegionMax().X - posX;
+                var textSize = ImGui.CalcTextSize(ev.Message).X;
+                var msg = ev.Message;
+                while (textSize > maxTextLength)
+                {
+                    msg = msg[..^5] + "...";
+                    textSize = ImGui.CalcTextSize(msg).X;
+                }
+                ImGui.TextUnformatted(msg);
+                if (!string.Equals(msg, ev.Message, StringComparison.Ordinal))
+                {
+                    UiSharedService.AttachToolTip(ev.Message);
+                }
+            }
+        }
+    }
+}

MareSynchronos/UI/Handlers/TagHandler.cs

@@ -0,0 +1,85 @@
+using MareSynchronos.Services.ServerConfiguration;
+
+namespace MareSynchronos.UI.Handlers;
+
+public class TagHandler
+{
+    public const string CustomOfflineTag = "Mare_Offline";
+    public const string CustomOfflineSyncshellTag = "Mare_OfflineSyncshell";
+    public const string CustomOnlineTag = "Mare_Online";
+    public const string CustomUnpairedTag = "Mare_Unpaired";
+    public const string CustomVisibleTag = "Mare_Visible";
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+
+    public TagHandler(ServerConfigurationManager serverConfigurationManager)
+    {
+        _serverConfigurationManager = serverConfigurationManager;
+    }
+
+    public void AddTag(string tag)
+    {
+        _serverConfigurationManager.AddTag(tag);
+    }
+
+    public void AddTagToPairedUid(string uid, string tagName)
+    {
+        _serverConfigurationManager.AddTagForUid(uid, tagName);
+    }
+
+    public List<string> GetAllTagsSorted()
+    {
+        return
+        [
+            .. _serverConfigurationManager.GetServerAvailablePairTags()
+                        .OrderBy(s => s, StringComparer.OrdinalIgnoreCase)
+,
+        ];
+    }
+
+    public HashSet<string> GetOtherUidsForTag(string tag)
+    {
+        return _serverConfigurationManager.GetUidsForTag(tag);
+    }
+
+    public bool HasAnyTag(string uid)
+    {
+        return _serverConfigurationManager.HasTags(uid);
+    }
+
+    public bool HasTag(string uid, string tagName)
+    {
+        return _serverConfigurationManager.ContainsTag(uid, tagName);
+    }
+
+    /// <summary>
+    /// Is this tag opened in the paired clients UI?
+    /// </summary>
+    /// <param name="tag">the tag</param>
+    /// <returns>open true/false</returns>
+    public bool IsTagOpen(string tag)
+    {
+        return _serverConfigurationManager.ContainsOpenPairTag(tag);
+    }
+
+    public void RemoveTag(string tag)
+    {
+        _serverConfigurationManager.RemoveTag(tag);
+    }
+
+    public void RemoveTagFromPairedUid(string uid, string tagName)
+    {
+        _serverConfigurationManager.RemoveTagForUid(uid, tagName);
+    }
+
+    public void SetTagOpen(string tag, bool open)
+    {
+        if (open)
+        {
+            _serverConfigurationManager.AddOpenPairTag(tag);
+        }
+        else
+        {
+            _serverConfigurationManager.RemoveOpenPairTag(tag);
+        }
+    }
+}

MareSynchronos/UI/Handlers/UidDisplayHandler.cs

@@ -0,0 +1,204 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.UI.Components;
+
+namespace MareSynchronos.UI.Handlers;
+
+public class UidDisplayHandler
+{
+    private readonly MareConfigService _mareConfigService;
+    private readonly MareMediator _mediator;
+    private readonly PairManager _pairManager;
+    private readonly ServerConfigurationManager _serverManager;
+    private readonly Dictionary<string, bool> _showUidForEntry = new(StringComparer.Ordinal);
+    private string _editNickEntry = string.Empty;
+    private string _editUserComment = string.Empty;
+    private string _lastMouseOverUid = string.Empty;
+    private bool _popupShown = false;
+    private DateTime? _popupTime;
+
+    public UidDisplayHandler(MareMediator mediator, PairManager pairManager,
+        ServerConfigurationManager serverManager, MareConfigService mareConfigService)
+    {
+        _mediator = mediator;
+        _pairManager = pairManager;
+        _serverManager = serverManager;
+        _mareConfigService = mareConfigService;
+    }
+
+    public void RenderPairList(IEnumerable<DrawPairBase> pairs)
+    {
+        var textHeight = ImGui.GetFontSize();
+        var style = ImGui.GetStyle();
+        var framePadding = style.FramePadding;
+        var spacing = style.ItemSpacing;
+        var lineHeight = textHeight + framePadding.Y * 2 + spacing.Y;
+        var startY = ImGui.GetCursorStartPos().Y;
+        var cursorY = ImGui.GetCursorPosY();
+        var contentHeight = UiSharedService.GetWindowContentRegionHeight();
+
+        foreach (var entry in pairs)
+        {
+            if ((startY + cursorY) < -lineHeight || (startY + cursorY) > contentHeight)
+            {
+                cursorY += lineHeight;
+                ImGui.SetCursorPosY(cursorY);
+                continue;
+            }
+
+            using (ImRaii.PushId(entry.ImGuiID)) entry.DrawPairedClient();
+            cursorY += lineHeight;
+        }
+    }
+
+    public void DrawPairText(string id, Pair pair, float textPosX, float originalY, Func<float> editBoxWidth)
+    {
+        ImGui.SameLine(textPosX);
+        (bool textIsUid, string playerText) = GetPlayerText(pair);
+        if (!string.Equals(_editNickEntry, pair.UserData.UID, StringComparison.Ordinal))
+        {
+            ImGui.SetCursorPosY(originalY);
+
+            using (ImRaii.PushFont(UiBuilder.MonoFont, textIsUid)) ImGui.TextUnformatted(playerText);
+
+            if (ImGui.IsItemHovered())
+            {
+                if (!string.Equals(_lastMouseOverUid, id))
+                {
+                    _popupTime = DateTime.UtcNow.AddSeconds(_mareConfigService.Current.ProfileDelay);
+                }
+
+                _lastMouseOverUid = id;
+
+                if (_popupTime > DateTime.UtcNow || !_mareConfigService.Current.ProfilesShow)
+                {
+                    ImGui.SetTooltip("Left click to switch between UID display and nick" + Environment.NewLine
+                        + "Right click to change nick for " + pair.UserData.AliasOrUID + Environment.NewLine
+                        + "Middle Mouse Button to open their profile in a separate window");
+                }
+                else if (_popupTime < DateTime.UtcNow && !_popupShown)
+                {
+                    _popupShown = true;
+                    _mediator.Publish(new ProfilePopoutToggle(pair));
+                }
+            }
+            else
+            {
+                if (string.Equals(_lastMouseOverUid, id))
+                {
+                    _mediator.Publish(new ProfilePopoutToggle(null));
+                    _lastMouseOverUid = string.Empty;
+                    _popupShown = false;
+                }
+            }
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Left))
+            {
+                var prevState = textIsUid;
+                if (_showUidForEntry.ContainsKey(pair.UserData.UID))
+                {
+                    prevState = _showUidForEntry[pair.UserData.UID];
+                }
+                _showUidForEntry[pair.UserData.UID] = !prevState;
+            }
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Right))
+            {
+                var nickEntryPair = _pairManager.DirectPairs.Find(p => string.Equals(p.UserData.UID, _editNickEntry, StringComparison.Ordinal));
+                nickEntryPair?.SetNote(_editUserComment);
+                _editUserComment = pair.GetNote() ?? string.Empty;
+                _editNickEntry = pair.UserData.UID;
+            }
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Middle))
+            {
+                _mediator.Publish(new ProfileOpenStandaloneMessage(pair));
+            }
+        }
+        else
+        {
+            ImGui.SetCursorPosY(originalY);
+
+            ImGui.SetNextItemWidth(editBoxWidth.Invoke());
+            if (ImGui.InputTextWithHint("##" + pair.UserData.UID, "Nick/Notes", ref _editUserComment, 255, ImGuiInputTextFlags.EnterReturnsTrue))
+            {
+                _serverManager.SetNoteForUid(pair.UserData.UID, _editUserComment);
+                _serverManager.SaveNotes();
+                _editNickEntry = string.Empty;
+            }
+
+            if (ImGui.IsItemClicked(ImGuiMouseButton.Right))
+            {
+                _editNickEntry = string.Empty;
+            }
+            UiSharedService.AttachToolTip("Hit ENTER to save\nRight click to cancel");
+        }
+    }
+
+    public (bool isUid, string text) GetPlayerText(Pair pair)
+    {
+        var textIsUid = true;
+        bool showUidInsteadOfName = ShowUidInsteadOfName(pair);
+        string? playerText = _serverManager.GetNoteForUid(pair.UserData.UID);
+        if (!showUidInsteadOfName && playerText != null)
+        {
+            if (string.IsNullOrEmpty(playerText))
+            {
+                playerText = pair.UserData.AliasOrUID;
+            }
+            else
+            {
+                textIsUid = false;
+            }
+        }
+        else
+        {
+            playerText = pair.UserData.AliasOrUID;
+        }
+
+        if (_mareConfigService.Current.ShowCharacterNames && textIsUid && !showUidInsteadOfName)
+        {
+            var name = pair.PlayerName;
+            if (name != null)
+            {
+                playerText = name;
+                textIsUid = false;
+                var note = pair.GetNote();
+                if (note != null)
+                {
+                    playerText = note;
+                }
+            }
+        }
+
+        return (textIsUid, playerText!);
+    }
+
+    internal void Clear()
+    {
+        _editNickEntry = string.Empty;
+        _editUserComment = string.Empty;
+    }
+
+    internal void OpenProfile(Pair entry)
+    {
+        _mediator.Publish(new ProfileOpenStandaloneMessage(entry));
+    }
+
+    internal void OpenAnalysis(Pair entry)
+    {
+        _mediator.Publish(new OpenPairAnalysisWindow(entry));
+    }
+
+    private bool ShowUidInsteadOfName(Pair pair)
+    {
+        _showUidForEntry.TryGetValue(pair.UserData.UID, out var showUidInsteadOfName);
+
+        return showUidInsteadOfName;
+    }
+}

MareSynchronos/UI/IntroUI.cs

@@ -0,0 +1,369 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility.Raii;
+using Dalamud.Utility;
+using MareSynchronos.API.Dto.Account;
+using MareSynchronos.FileCache;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.WebAPI;
+using MareSynchronos.WebAPI.SignalR.Utils;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+using System.Text.RegularExpressions;
+
+namespace MareSynchronos.UI;
+
+public partial class IntroUi : WindowMediatorSubscriberBase
+{
+    private readonly MareConfigService _configService;
+    private readonly CacheMonitor _cacheMonitor;
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly AccountRegistrationService _registerService;
+    private readonly UiSharedService _uiShared;
+    private bool _readFirstPage;
+
+    private string _secretKey = string.Empty;
+    private string _timeoutLabel = string.Empty;
+    private Task? _timeoutTask;
+    private bool _registrationInProgress = false;
+    private bool _registrationSuccess = false;
+    private string? _registrationMessage;
+    private RegisterReplyDto? _registrationReply;
+
+    public IntroUi(ILogger<IntroUi> logger, UiSharedService uiShared, MareConfigService configService,
+        CacheMonitor fileCacheManager, ServerConfigurationManager serverConfigurationManager, MareMediator mareMediator,
+        PerformanceCollectorService performanceCollectorService, DalamudUtilService dalamudUtilService, AccountRegistrationService registerService) : base(logger, mareMediator, "Elezen Setup", performanceCollectorService)
+    {
+        _uiShared = uiShared;
+        _configService = configService;
+        _cacheMonitor = fileCacheManager;
+        _serverConfigurationManager = serverConfigurationManager;
+        _dalamudUtilService = dalamudUtilService;
+        _registerService = registerService;
+        IsOpen = false;
+        ShowCloseButton = false;
+        RespectCloseHotkey = false;
+
+        SizeConstraints = new WindowSizeConstraints()
+        {
+            MinimumSize = new Vector2(650, 500),
+            MaximumSize = new Vector2(650, 2000),
+        };
+
+        Mediator.Subscribe<SwitchToMainUiMessage>(this, (_) => IsOpen = false);
+        Mediator.Subscribe<SwitchToIntroUiMessage>(this, (_) =>
+        {
+            _configService.Current.UseCompactor = !dalamudUtilService.IsWine;
+            IsOpen = true;
+        });
+    }
+
+    private Vector4 GetConnectionColor()
+    {
+        return _uiShared.ApiController.ServerState switch
+        {
+            ServerState.Connecting => ImGuiColors.DalamudYellow,
+            ServerState.Reconnecting => ImGuiColors.DalamudRed,
+            ServerState.Connected => ImGuiColors.HealerGreen,
+            ServerState.Disconnected => ImGuiColors.DalamudYellow,
+            ServerState.Disconnecting => ImGuiColors.DalamudYellow,
+            ServerState.Unauthorized => ImGuiColors.DalamudRed,
+            ServerState.VersionMisMatch => ImGuiColors.DalamudRed,
+            ServerState.Offline => ImGuiColors.DalamudRed,
+            ServerState.RateLimited => ImGuiColors.DalamudYellow,
+            ServerState.NoSecretKey => ImGuiColors.DalamudYellow,
+            ServerState.MultiChara => ImGuiColors.DalamudYellow,
+            _ => ImGuiColors.DalamudRed
+        };
+    }
+
+    private string GetConnectionStatus()
+    {
+        return _uiShared.ApiController.ServerState switch
+        {
+            ServerState.Reconnecting => "Reconnecting",
+            ServerState.Connecting => "Connecting",
+            ServerState.Disconnected => "Disconnected",
+            ServerState.Disconnecting => "Disconnecting",
+            ServerState.Unauthorized => "Unauthorized",
+            ServerState.VersionMisMatch => "Version mismatch",
+            ServerState.Offline => "Unavailable",
+            ServerState.RateLimited => "Rate Limited",
+            ServerState.NoSecretKey => "No Secret Key",
+            ServerState.MultiChara => "Duplicate Characters",
+            ServerState.Connected => "Connected",
+            _ => string.Empty
+        };
+    }
+
+    protected override void DrawInternal()
+    {
+        if (_uiShared.IsInGpose) return;
+
+        if (!_configService.Current.AcceptedAgreement && !_readFirstPage)
+        {
+            _uiShared.BigText("Welcome to Elezen");
+            ImGui.Separator();
+            UiSharedService.TextWrapped("Elezen is a plugin that will replicate your full current character state including all Penumbra mods to other paired users. " +
+                              "Note that you will have to have Penumbra as well as Glamourer installed to use this plugin.");
+            UiSharedService.TextWrapped("We will have to setup a few things first before you can start using this plugin. Click on next to continue.");
+
+            UiSharedService.ColorTextWrapped("Note: Any modifications you have applied through anything but Penumbra cannot be shared and your character state on other clients " +
+                                 "might look broken because of this or others players mods might not apply on your end altogether. " +
+                                 "If you want to use this plugin you will have to move your mods to Penumbra.", ImGuiColors.DalamudYellow);
+            if (!_uiShared.DrawOtherPluginState(intro: true)) return;
+            ImGui.Separator();
+            if (ImGui.Button("Next##toAgreement"))
+            {
+                _readFirstPage = true;
+#if !DEBUG
+                _timeoutTask = Task.Run(async () =>
+                {
+                    for (int i = 10; i > 0; i--)
+                    {
+                        _timeoutLabel = $"'I agree' button will be available in {i}s";
+                        await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
+                    }
+                });
+#else
+                _timeoutTask = Task.CompletedTask;
+#endif
+            }
+        }
+        else if (!_configService.Current.AcceptedAgreement && _readFirstPage)
+        {
+            using (_uiShared.UidFont.Push())
+            {
+                ImGui.TextUnformatted("Agreement of Usage of Service");
+            }
+
+            ImGui.Separator();
+            ImGui.SetWindowFontScale(1.5f);
+            string readThis = "READ THIS CAREFULLY";
+            Vector2 textSize = ImGui.CalcTextSize(readThis);
+            ImGui.SetCursorPosX(ImGui.GetWindowSize().X / 2 - textSize.X / 2);
+            UiSharedService.ColorText(readThis, ImGuiColors.DalamudRed);
+            ImGui.SetWindowFontScale(1.0f);
+            ImGui.Separator();
+
+            UiSharedService.TextWrapped("""
+All of the mod files currently active on your character as well as your current character state will be uploaded to the service you registered yourself at automatically. The plugin will exclusively upload the necessary mod files and not the whole mod.
+""");
+            UiSharedService.TextWrapped("""
+If you are on a data capped internet connection, higher fees due to data usage depending on the amount of downloaded and uploaded mod files might occur. Mod files will be compressed on up- and download to save on bandwidth usage. Due to varying up- and download speeds, changes in characters might not be visible immediately. Files present on the service that already represent your active mod files will not be uploaded again.
+""");
+            UiSharedService.TextWrapped("""
+The mod files you are uploading are confidential and will not be distributed to parties other than the ones who are requesting the exact same mod files. Please think about who you are going to pair since it is unavoidable that they will receive and locally cache the necessary mod files that you have currently in use. Locally cached mod files will have arbitrary file names to discourage attempts at replicating the original mod.
+""");
+            UiSharedService.TextWrapped("""
+The plugin creator tried their best to keep you secure. However, there is no guarantee for 100% security. Do not blindly pair your client with everyone.
+""");
+            UiSharedService.TextWrapped("""
+Mod files that are saved on the service will remain on the service as long as there are requests for the files from clients. After a period of not being used, the mod files will be automatically deleted.
+""");
+            UiSharedService.TextWrapped("""
+This service is provided as-is.
+""");
+
+            ImGui.Separator();
+            if (_timeoutTask?.IsCompleted ?? true)
+            {
+                if (ImGui.Button("I agree##toSetup"))
+                {
+                    _configService.Current.AcceptedAgreement = true;
+                    _configService.Save();
+                }
+            }
+            else
+            {
+                UiSharedService.TextWrapped(_timeoutLabel);
+            }
+        }
+        else if (_configService.Current.AcceptedAgreement
+                 && (string.IsNullOrEmpty(_configService.Current.CacheFolder)
+                     || !_configService.Current.InitialScanComplete
+                     || !Directory.Exists(_configService.Current.CacheFolder)))
+        {
+            using (_uiShared.UidFont.Push())
+                ImGui.TextUnformatted("File Storage Setup");
+
+            ImGui.Separator();
+
+            if (!_uiShared.HasValidPenumbraModPath)
+            {
+                UiSharedService.ColorTextWrapped("You do not have a valid Penumbra path set. Open Penumbra and set up a valid path for the mod directory.", ImGuiColors.DalamudRed);
+            }
+            else
+            {
+                UiSharedService.TextWrapped("To not unnecessary download files already present on your computer, Elezen will have to scan your Penumbra mod directory. " +
+                                     "Additionally, a local storage folder must be set where Elezen will download other character files to. " +
+                                     "Once the storage folder is set and the scan complete, this page will automatically forward to registration at a service.");
+                UiSharedService.TextWrapped("Note: The initial scan, depending on the amount of mods you have, might take a while. Please wait until it is completed.");
+                UiSharedService.ColorTextWrapped("Warning: once past this step you should not delete the FileCache.csv of Elezen in the Plugin Configurations folder of Dalamud. " +
+                                          "Otherwise on the next launch a full re-scan of the file cache database will be initiated.", ImGuiColors.DalamudYellow);
+                UiSharedService.ColorTextWrapped("Warning: if the scan is hanging and does nothing for a long time, chances are high your Penumbra folder is not set up properly.", ImGuiColors.DalamudYellow);
+                _uiShared.DrawCacheDirectorySetting();
+            }
+
+            if (!_cacheMonitor.IsScanRunning && !string.IsNullOrEmpty(_configService.Current.CacheFolder) && _uiShared.HasValidPenumbraModPath && Directory.Exists(_configService.Current.CacheFolder))
+            {
+                if (ImGui.Button("Start Scan##startScan"))
+                {
+                    _cacheMonitor.InvokeScan();
+                }
+            }
+            else
+            {
+                _uiShared.DrawFileScanState();
+            }
+            if (!_dalamudUtilService.IsWine)
+            {
+                var useFileCompactor = _configService.Current.UseCompactor;
+                if (ImGui.Checkbox("Use File Compactor", ref useFileCompactor))
+                {
+                    _configService.Current.UseCompactor = useFileCompactor;
+                    _configService.Save();
+                }
+                UiSharedService.ColorTextWrapped("The File Compactor can save a tremendeous amount of space on the hard disk for downloads through Elezen. It will incur a minor CPU penalty on download but can speed up " +
+                    "loading of other characters. It is recommended to keep it enabled. You can change this setting later anytime in the Elezen settings.", ImGuiColors.DalamudYellow);
+            }
+        }
+        else if (!_uiShared.ApiController.IsConnected)
+        {
+            using (_uiShared.UidFont.Push())
+                ImGui.TextUnformatted("Service Registration");
+            ImGui.Separator();
+            UiSharedService.TextWrapped("To be able to use Elezen you will have to register an account.");
+            UiSharedService.TextWrapped("Refer to the instructions at the location you obtained this plugin for more information or support.");
+
+            ImGui.Separator();
+
+            ImGui.BeginDisabled(_registrationInProgress || _uiShared.ApiController.ServerState == ServerState.Connecting || _uiShared.ApiController.ServerState == ServerState.Reconnecting);
+            _ = _uiShared.DrawServiceSelection(selectOnChange: true, intro: true);
+
+            if (true) // Enable registration button for all servers
+            {
+                ImGui.BeginDisabled(_registrationInProgress || _registrationSuccess || _secretKey.Length > 0);
+                ImGui.Separator();
+                ImGui.TextUnformatted("If you have not used Elezen before, click below to register a new account.");
+                if (_uiShared.IconTextButton(FontAwesomeIcon.Plus, "Register a new Elezen account"))
+                {
+                    _registrationInProgress = true;
+                    _ = Task.Run(async () => {
+                        try
+                        {
+                            var reply = await _registerService.RegisterAccount(CancellationToken.None).ConfigureAwait(false);
+                            if (!reply.Success)
+                            {
+                                _logger.LogWarning("Registration failed: {err}", reply.ErrorMessage);
+                                _registrationMessage = reply.ErrorMessage;
+                                if (_registrationMessage.IsNullOrEmpty())
+                                    _registrationMessage = "An unknown error occured. Please try again later.";
+                                return;
+                            }
+                            _registrationMessage = "New account registered.\nPlease keep a copy of your secret key in case you need to reset your plugins, or to use it on another PC.";
+                            _secretKey = reply.SecretKey ?? "";
+                            _registrationReply = reply;
+                            _registrationSuccess = true;
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.LogWarning(ex, "Registration failed");
+                            _registrationSuccess = false;
+                            _registrationMessage = "An unknown error occured. Please try again later.";
+                        }
+                        finally
+                        {
+                            _registrationInProgress = false;
+                        }
+                    });
+                }
+                ImGui.EndDisabled(); // _registrationInProgress || _registrationSuccess
+                if (_registrationInProgress)
+                {
+                    ImGui.TextUnformatted("Sending request...");
+                }
+                else if (!_registrationMessage.IsNullOrEmpty())
+                {
+                    if (!_registrationSuccess)
+                        ImGui.TextColored(ImGuiColors.DalamudYellow, _registrationMessage);
+                    else
+                        ImGui.TextWrapped(_registrationMessage);
+                }
+            }
+
+            ImGui.Separator();
+
+            var text = "Enter Secret Key";
+
+            if (_registrationSuccess)
+            {
+                text = "Secret Key";
+            }
+            else
+            {
+                ImGui.TextUnformatted("If you already have a registered account, you can enter its secret key below to use it instead.");
+            }
+
+            var textSize = ImGui.CalcTextSize(text);
+            ImGui.AlignTextToFramePadding();
+            ImGui.TextUnformatted(text);
+            ImGui.SameLine();
+            ImGui.SetNextItemWidth(UiSharedService.GetWindowContentRegionWidth() - ImGui.GetWindowContentRegionMin().X - textSize.X);
+            ImGui.InputText("", ref _secretKey, 64);
+            if (_secretKey.Length > 0 && _secretKey.Length != 64)
+            {
+                UiSharedService.ColorTextWrapped("Your secret key must be exactly 64 characters long.", ImGuiColors.DalamudRed);
+            }
+            else if (_secretKey.Length == 64 && !HexRegex().IsMatch(_secretKey))
+            {
+                UiSharedService.ColorTextWrapped("Your secret key can only contain ABCDEF and the numbers 0-9.", ImGuiColors.DalamudRed);
+            }
+            else if (_secretKey.Length == 64)
+            {
+                using var saveDisabled = ImRaii.Disabled(_uiShared.ApiController.ServerState == ServerState.Connecting || _uiShared.ApiController.ServerState == ServerState.Reconnecting);
+                if (ImGui.Button("Save and Connect"))
+                {
+                    string keyName;
+                    if (_serverConfigurationManager.CurrentServer == null) _serverConfigurationManager.SelectServer(0);
+                    if (_registrationReply != null && _secretKey.Equals(_registrationReply.SecretKey, StringComparison.Ordinal))
+                        keyName = _registrationReply.UID + $" (registered {DateTime.Now:yyyy-MM-dd})";
+                    else
+                        keyName = $"Secret Key added on Setup ({DateTime.Now:yyyy-MM-dd})";
+                    _serverConfigurationManager.CurrentServer!.SecretKeys.Add(_serverConfigurationManager.CurrentServer.SecretKeys.Select(k => k.Key).LastOrDefault() + 1, new SecretKey()
+                    {
+                        FriendlyName = keyName,
+                        Key = _secretKey,
+                    });
+                    _serverConfigurationManager.AddCurrentCharacterToServer(save: false);
+                    _ = Task.Run(() => _uiShared.ApiController.CreateConnections());
+                }
+            }
+
+            if (_uiShared.ApiController.ServerState != ServerState.NoSecretKey)
+            {
+                UiSharedService.ColorText(GetConnectionStatus(), GetConnectionColor());
+            }
+
+            ImGui.EndDisabled(); // _registrationInProgress
+        }
+        else
+        {
+            _secretKey = string.Empty;
+            _serverConfigurationManager.Save();
+            Mediator.Publish(new SwitchToMainUiMessage());
+            IsOpen = false;
+        }
+    }
+
+#pragma warning disable MA0009
+    [GeneratedRegex("^([A-F0-9]{2})+")]
+    private static partial Regex HexRegex();
+#pragma warning restore MA0009
+}

MareSynchronos/UI/PermissionWindowUI.cs

@@ -0,0 +1,167 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using MareSynchronos.WebAPI;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.UI;
+
+public class PermissionWindowUI : WindowMediatorSubscriberBase
+{
+    public Pair Pair { get; init; }
+
+    private readonly UiSharedService _uiSharedService;
+    private readonly ApiController _apiController;
+    private UserPermissions _ownPermissions;
+
+    public PermissionWindowUI(ILogger<PermissionWindowUI> logger, Pair pair, MareMediator mediator, UiSharedService uiSharedService,
+        ApiController apiController, PerformanceCollectorService performanceCollectorService)
+        : base(logger, mediator, "Permissions for " + pair.UserData.AliasOrUID + "###ElezenSyncPermissions" + pair.UserData.UID, performanceCollectorService)
+    {
+        Pair = pair;
+        _uiSharedService = uiSharedService;
+        _apiController = apiController;
+        _ownPermissions = pair.UserPair?.OwnPermissions.DeepClone() ?? default;
+        Flags = ImGuiWindowFlags.NoScrollbar | ImGuiWindowFlags.NoResize;
+        SizeConstraints = new()
+        {
+            MinimumSize = new(450, 100),
+            MaximumSize = new(450, 500)
+        };
+        IsOpen = true;
+    }
+
+    protected override void DrawInternal()
+    {
+        var paused = _ownPermissions.IsPaused();
+        var disableSounds = _ownPermissions.IsDisableSounds();
+        var disableAnimations = _ownPermissions.IsDisableAnimations();
+        var disableVfx = _ownPermissions.IsDisableVFX();
+        var style = ImGui.GetStyle();
+        var indentSize = ImGui.GetFrameHeight() + style.ItemSpacing.X;
+
+        _uiSharedService.BigText("Permissions for " + Pair.UserData.AliasOrUID);
+        ImGuiHelpers.ScaledDummy(1f);
+
+        if (Pair.UserPair == null)
+            return;
+
+        if (ImGui.Checkbox("Pause Sync", ref paused))
+        {
+            _ownPermissions.SetPaused(paused);
+        }
+        _uiSharedService.DrawHelpText("Pausing will completely cease any sync with this user." + UiSharedService.TooltipSeparator
+            + "Note: this is bidirectional, either user pausing will cease sync completely.");
+        var otherPerms = Pair.UserPair.OtherPermissions;
+
+        var otherIsPaused = otherPerms.IsPaused();
+        var otherDisableSounds = otherPerms.IsDisableSounds();
+        var otherDisableAnimations = otherPerms.IsDisableAnimations();
+        var otherDisableVFX = otherPerms.IsDisableVFX();
+
+        using (ImRaii.PushIndent(indentSize, false))
+        {
+            _uiSharedService.BooleanToColoredIcon(!otherIsPaused, false);
+            ImGui.SameLine();
+            ImGui.AlignTextToFramePadding();
+            ImGui.TextUnformatted(Pair.UserData.AliasOrUID + " has " + (!otherIsPaused ? "not " : string.Empty) + "paused you");
+        }
+
+        ImGuiHelpers.ScaledDummy(0.5f);
+        ImGui.Separator();
+        ImGuiHelpers.ScaledDummy(0.5f);
+
+        if (ImGui.Checkbox("Disable Sounds", ref disableSounds))
+        {
+            _ownPermissions.SetDisableSounds(disableSounds);
+        }
+        _uiSharedService.DrawHelpText("Disabling sounds will remove all sounds synced with this user on both sides." + UiSharedService.TooltipSeparator
+            + "Note: this is bidirectional, either user disabling sound sync will stop sound sync on both sides.");
+        using (ImRaii.PushIndent(indentSize, false))
+        {
+            _uiSharedService.BooleanToColoredIcon(!otherDisableSounds, false);
+            ImGui.SameLine();
+            ImGui.AlignTextToFramePadding();
+            ImGui.TextUnformatted(Pair.UserData.AliasOrUID + " has " + (!otherDisableSounds ? "not " : string.Empty) + "disabled sound sync with you");
+        }
+
+        if (ImGui.Checkbox("Disable Animations", ref disableAnimations))
+        {
+            _ownPermissions.SetDisableAnimations(disableAnimations);
+        }
+        _uiSharedService.DrawHelpText("Disabling sounds will remove all animations synced with this user on both sides." + UiSharedService.TooltipSeparator
+            + "Note: this is bidirectional, either user disabling animation sync will stop animation sync on both sides.");
+        using (ImRaii.PushIndent(indentSize, false))
+        {
+            _uiSharedService.BooleanToColoredIcon(!otherDisableAnimations, false);
+            ImGui.SameLine();
+            ImGui.AlignTextToFramePadding();
+            ImGui.TextUnformatted(Pair.UserData.AliasOrUID + " has " + (!otherDisableAnimations ? "not " : string.Empty) + "disabled animation sync with you");
+        }
+
+        if (ImGui.Checkbox("Disable VFX", ref disableVfx))
+        {
+            _ownPermissions.SetDisableVFX(disableVfx);
+        }
+        _uiSharedService.DrawHelpText("Disabling sounds will remove all VFX synced with this user on both sides." + UiSharedService.TooltipSeparator
+            + "Note: this is bidirectional, either user disabling VFX sync will stop VFX sync on both sides.");
+        using (ImRaii.PushIndent(indentSize, false))
+        {
+            _uiSharedService.BooleanToColoredIcon(!otherDisableVFX, false);
+            ImGui.SameLine();
+            ImGui.AlignTextToFramePadding();
+            ImGui.TextUnformatted(Pair.UserData.AliasOrUID + " has " + (!otherDisableVFX ? "not " : string.Empty) + "disabled VFX sync with you");
+        }
+
+        ImGuiHelpers.ScaledDummy(0.5f);
+        ImGui.Separator();
+        ImGuiHelpers.ScaledDummy(0.5f);
+
+        bool hasChanges = _ownPermissions != Pair.UserPair.OwnPermissions;
+
+        using (ImRaii.Disabled(!hasChanges))
+            if (_uiSharedService.IconTextButton(Dalamud.Interface.FontAwesomeIcon.Save, "Save"))
+            {
+                _ = _apiController.UserSetPairPermissions(new(Pair.UserData, _ownPermissions));
+            }
+        UiSharedService.AttachToolTip("Save and apply all changes");
+
+        var rightSideButtons = _uiSharedService.GetIconTextButtonSize(Dalamud.Interface.FontAwesomeIcon.Undo, "Revert") +
+            _uiSharedService.GetIconTextButtonSize(Dalamud.Interface.FontAwesomeIcon.ArrowsSpin, "Reset to Default");
+        var availableWidth = ImGui.GetWindowContentRegionMax().X - ImGui.GetWindowContentRegionMin().X;
+
+        ImGui.SameLine(availableWidth - rightSideButtons);
+
+        using (ImRaii.Disabled(!hasChanges))
+            if (_uiSharedService.IconTextButton(Dalamud.Interface.FontAwesomeIcon.Undo, "Revert"))
+            {
+                _ownPermissions = Pair.UserPair.OwnPermissions.DeepClone();
+            }
+        UiSharedService.AttachToolTip("Revert all changes");
+
+        ImGui.SameLine();
+        if (_uiSharedService.IconTextButton(Dalamud.Interface.FontAwesomeIcon.ArrowsSpin, "Reset to Default"))
+        {
+            _ownPermissions.SetPaused(false);
+            _ownPermissions.SetDisableVFX(false);
+            _ownPermissions.SetDisableSounds(false);
+            _ownPermissions.SetDisableAnimations(false);
+            _ = _apiController.UserSetPairPermissions(new(Pair.UserData, _ownPermissions));
+        }
+        UiSharedService.AttachToolTip("This will set all permissions to their default setting");
+
+        var ySize = ImGui.GetCursorPosY() + style.FramePadding.Y * ImGuiHelpers.GlobalScale + style.FrameBorderSize;
+        ImGui.SetWindowSize(new(400, ySize));
+    }
+
+    public override void OnClose()
+    {
+        Mediator.Publish(new RemoveWindowMessage(this));
+    }
+}

MareSynchronos/UI/PlayerAnalysisUI.cs

@@ -0,0 +1,366 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+public class PlayerAnalysisUI : WindowMediatorSubscriberBase
+{
+    private readonly UiSharedService _uiSharedService;
+    private Dictionary<ObjectKind, Dictionary<string, CharacterAnalyzer.FileDataEntry>>? _cachedAnalysis;
+    private bool _hasUpdate = true;
+    private bool _sortDirty = true;
+    private string _selectedFileTypeTab = string.Empty;
+    private string _selectedHash = string.Empty;
+    private ObjectKind _selectedObjectTab;
+
+    public PlayerAnalysisUI(ILogger<PlayerAnalysisUI> logger, Pair pair, MareMediator mediator, UiSharedService uiSharedService,
+        PerformanceCollectorService performanceCollectorService)
+        : base(logger, mediator, "Character Data Analysis for " + pair.UserData.AliasOrUID + "###ElezenPairAnalysis" + pair.UserData.UID, performanceCollectorService)
+    {
+        Pair = pair;
+        _uiSharedService = uiSharedService;
+        Mediator.SubscribeKeyed<PairDataAnalyzedMessage>(this, Pair.UserData.UID, (_) =>
+        {
+            _logger.LogInformation("PairDataAnalyzedMessage received for {uid}", Pair.UserData.UID);
+            _hasUpdate = true;
+        });
+        SizeConstraints = new()
+        {
+            MinimumSize = new()
+            {
+                X = 800,
+                Y = 600
+            },
+            MaximumSize = new()
+            {
+                X = 3840,
+                Y = 2160
+            }
+        };
+        IsOpen = true;
+    }
+
+    public Pair Pair { get; private init; }
+    public PairAnalyzer? PairAnalyzer => Pair.PairAnalyzer;
+
+    public override void OnClose()
+    {
+        Mediator.Publish(new RemoveWindowMessage(this));
+    }
+
+    protected override void DrawInternal()
+    {
+        if (PairAnalyzer == null) return;
+        PairAnalyzer analyzer = PairAnalyzer!;
+
+        if (_hasUpdate)
+        {
+            _cachedAnalysis = analyzer.LastAnalysis.DeepClone();
+            _hasUpdate = false;
+            _sortDirty = true;
+        }
+
+        UiSharedService.TextWrapped($"This window shows you all files and their sizes that are currently in use by {Pair.UserData.AliasOrUID} and associated entities");
+
+        if (_cachedAnalysis == null || _cachedAnalysis.Count == 0) return;
+
+        bool isAnalyzing = analyzer.IsAnalysisRunning;
+        bool needAnalysis = _cachedAnalysis!.Any(c => c.Value.Any(f => !f.Value.IsComputed));
+        if (isAnalyzing)
+        {
+            UiSharedService.ColorTextWrapped($"Analyzing {analyzer.CurrentFile}/{analyzer.TotalFiles}",
+                ImGuiColors.DalamudYellow);
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.StopCircle, "Cancel analysis"))
+            {
+                analyzer.CancelAnalyze();
+            }
+        }
+        else
+        {
+            if (needAnalysis)
+            {
+                UiSharedService.ColorTextWrapped("Some entries in the analysis have file size not determined yet, press the button below to compute missing data",
+                    ImGuiColors.DalamudYellow);
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.PlayCircle, "Start analysis (missing entries)"))
+                {
+                    _ = analyzer.ComputeAnalysis(print: false);
+                }
+            }
+        }
+
+        ImGui.Separator();
+
+        ImGui.TextUnformatted("Total files:");
+        ImGui.SameLine();
+        ImGui.TextUnformatted(_cachedAnalysis!.Values.Sum(c => c.Values.Count).ToString());
+        ImGui.SameLine();
+        using (var font = ImRaii.PushFont(UiBuilder.IconFont))
+        {
+            ImGui.TextUnformatted(FontAwesomeIcon.InfoCircle.ToIconString());
+        }
+        if (ImGui.IsItemHovered())
+        {
+            string text = "";
+            var groupedfiles = _cachedAnalysis.Values.SelectMany(f => f.Values).GroupBy(f => f.FileType, StringComparer.Ordinal);
+            text = string.Join(Environment.NewLine, groupedfiles.OrderBy(f => f.Key, StringComparer.Ordinal)
+                .Select(f => f.Key + ": " + f.Count() + " files, size: " + UiSharedService.ByteToString(f.Sum(v => v.OriginalSize))
+                + ", compressed: " + UiSharedService.ByteToString(f.Sum(v => v.CompressedSize))));
+            ImGui.SetTooltip(text);
+        }
+        ImGui.TextUnformatted("Total size (actual):");
+        ImGui.SameLine();
+        ImGui.TextUnformatted(UiSharedService.ByteToString(_cachedAnalysis!.Sum(c => c.Value.Sum(c => c.Value.OriginalSize))));
+        ImGui.TextUnformatted("Total size (compressed for up/download only):");
+        ImGui.SameLine();
+        using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, needAnalysis))
+        {
+            ImGui.TextUnformatted(UiSharedService.ByteToString(_cachedAnalysis!.Sum(c => c.Value.Sum(c => c.Value.CompressedSize))));
+            if (needAnalysis && !isAnalyzing)
+            {
+                ImGui.SameLine();
+                using (ImRaii.PushFont(UiBuilder.IconFont))
+                    ImGui.TextUnformatted(FontAwesomeIcon.ExclamationCircle.ToIconString());
+                UiSharedService.AttachToolTip("Click \"Start analysis\" to calculate download size");
+            }
+        }
+        ImGui.TextUnformatted($"Total modded model triangles: {UiSharedService.TrisToString(_cachedAnalysis.Sum(c => c.Value.Sum(f => f.Value.Triangles)))}");
+        ImGui.Separator();
+
+        var playerName = analyzer.LastPlayerName;
+
+        if (playerName.Length == 0)
+        {
+            playerName = Pair.PlayerName ?? string.Empty;
+            analyzer.LastPlayerName = playerName;
+        }
+
+        using var tabbar = ImRaii.TabBar("objectSelection");
+        foreach (var kvp in _cachedAnalysis)
+        {
+            using var id = ImRaii.PushId(kvp.Key.ToString());
+            string tabText = kvp.Key == ObjectKind.Player ? playerName : $"{playerName}'s {kvp.Key}";
+            using var tab = ImRaii.TabItem(tabText + "###" + kvp.Key.ToString());
+            if (tab.Success)
+            {
+                var groupedfiles = kvp.Value.Select(v => v.Value).GroupBy(f => f.FileType, StringComparer.Ordinal)
+                    .OrderBy(k => k.Key, StringComparer.Ordinal).ToList();
+
+                ImGui.TextUnformatted($"Files for {tabText}");
+
+                ImGui.SameLine();
+                ImGui.TextUnformatted(kvp.Value.Count.ToString());
+                ImGui.SameLine();
+
+                using (var font = ImRaii.PushFont(UiBuilder.IconFont))
+                {
+                    ImGui.TextUnformatted(FontAwesomeIcon.InfoCircle.ToIconString());
+                }
+                if (ImGui.IsItemHovered())
+                {
+                    string text = "";
+                    text = string.Join(Environment.NewLine, groupedfiles
+                        .Select(f => f.Key + ": " + f.Count() + " files, size: " + UiSharedService.ByteToString(f.Sum(v => v.OriginalSize))
+                        + ", compressed: " + UiSharedService.ByteToString(f.Sum(v => v.CompressedSize))));
+                    ImGui.SetTooltip(text);
+                }
+                ImGui.TextUnformatted($"{kvp.Key} size (actual):");
+                ImGui.SameLine();
+                ImGui.TextUnformatted(UiSharedService.ByteToString(kvp.Value.Sum(c => c.Value.OriginalSize)));
+                ImGui.TextUnformatted($"{kvp.Key} size (download size):");
+                ImGui.SameLine();
+                using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, needAnalysis))
+                {
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(kvp.Value.Sum(c => c.Value.CompressedSize)));
+                    if (needAnalysis && !isAnalyzing)
+                    {
+                        ImGui.SameLine();
+                        using (ImRaii.PushFont(UiBuilder.IconFont))
+                            ImGui.TextUnformatted(FontAwesomeIcon.ExclamationCircle.ToIconString());
+                        UiSharedService.AttachToolTip("Click \"Start analysis\" to calculate download size");
+                    }
+                }
+                ImGui.TextUnformatted($"{kvp.Key} VRAM usage:");
+                ImGui.SameLine();
+                var vramUsage = groupedfiles.SingleOrDefault(v => string.Equals(v.Key, "tex", StringComparison.Ordinal));
+                if (vramUsage != null)
+                {
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(vramUsage.Sum(f => f.OriginalSize)));
+                }
+                ImGui.TextUnformatted($"{kvp.Key} modded model triangles: {UiSharedService.TrisToString(kvp.Value.Sum(f => f.Value.Triangles))}");
+
+                ImGui.Separator();
+                if (_selectedObjectTab != kvp.Key)
+                {
+                    _selectedHash = string.Empty;
+                    _selectedObjectTab = kvp.Key;
+                    _selectedFileTypeTab = string.Empty;
+                }
+
+                using var fileTabBar = ImRaii.TabBar("fileTabs");
+
+                foreach (IGrouping<string, CharacterAnalyzer.FileDataEntry>? fileGroup in groupedfiles)
+                {
+                    string fileGroupText = fileGroup.Key + " [" + fileGroup.Count() + "]";
+                    var requiresCompute = fileGroup.Any(k => !k.IsComputed);
+                    using var tabcol = ImRaii.PushColor(ImGuiCol.Tab, UiSharedService.Color(ImGuiColors.DalamudYellow), requiresCompute);
+                    ImRaii.IEndObject fileTab;
+                    using (var textcol = ImRaii.PushColor(ImGuiCol.Text, UiSharedService.Color(new(0, 0, 0, 1)),
+                        requiresCompute && !string.Equals(_selectedFileTypeTab, fileGroup.Key, StringComparison.Ordinal)))
+                    {
+                        fileTab = ImRaii.TabItem(fileGroupText + "###" + fileGroup.Key);
+                    }
+
+                    if (!fileTab) { fileTab.Dispose(); continue; }
+
+                    if (!string.Equals(fileGroup.Key, _selectedFileTypeTab, StringComparison.Ordinal))
+                    {
+                        _selectedFileTypeTab = fileGroup.Key;
+                        _selectedHash = string.Empty;
+                    }
+
+                    ImGui.TextUnformatted($"{fileGroup.Key} files");
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted(fileGroup.Count().ToString());
+
+                    ImGui.TextUnformatted($"{fileGroup.Key} files size (actual):");
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(fileGroup.Sum(c => c.OriginalSize)));
+
+                    ImGui.TextUnformatted($"{fileGroup.Key} files size (download size):");
+                    ImGui.SameLine();
+                    ImGui.TextUnformatted(UiSharedService.ByteToString(fileGroup.Sum(c => c.CompressedSize)));
+
+                    ImGui.Separator();
+                    DrawTable(fileGroup);
+
+                    fileTab.Dispose();
+                }
+            }
+        }
+
+        ImGui.Separator();
+
+        ImGui.TextUnformatted("Selected file:");
+        ImGui.SameLine();
+        UiSharedService.ColorText(_selectedHash, ImGuiColors.DalamudYellow);
+
+        if (_cachedAnalysis[_selectedObjectTab].TryGetValue(_selectedHash, out CharacterAnalyzer.FileDataEntry? item))
+        {
+            var gamepaths = item.GamePaths;
+            ImGui.TextUnformatted("Used by game path:");
+            ImGui.SameLine();
+            UiSharedService.TextWrapped(gamepaths[0]);
+            if (gamepaths.Count > 1)
+            {
+                ImGui.SameLine();
+                ImGui.TextUnformatted($"(and {gamepaths.Count - 1} more)");
+                ImGui.SameLine();
+                _uiSharedService.IconText(FontAwesomeIcon.InfoCircle);
+                UiSharedService.AttachToolTip(string.Join(Environment.NewLine, gamepaths.Skip(1)));
+            }
+        }
+    }
+
+    private void DrawTable(IGrouping<string, CharacterAnalyzer.FileDataEntry> fileGroup)
+    {
+        var tableColumns = string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal)
+            ? 5
+            : (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal) ? 5 : 4);
+        using var table = ImRaii.Table("Analysis", tableColumns, ImGuiTableFlags.Sortable | ImGuiTableFlags.RowBg | ImGuiTableFlags.ScrollY | ImGuiTableFlags.SizingFixedFit,
+            new Vector2(0, 300));
+        if (!table.Success) return;
+        ImGui.TableSetupColumn("Hash");
+        ImGui.TableSetupColumn("Gamepaths", ImGuiTableColumnFlags.PreferSortDescending);
+        ImGui.TableSetupColumn("File Size", ImGuiTableColumnFlags.DefaultSort | ImGuiTableColumnFlags.PreferSortDescending);
+        ImGui.TableSetupColumn("Download Size", ImGuiTableColumnFlags.PreferSortDescending);
+        if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal))
+        {
+            ImGui.TableSetupColumn("Format");
+        }
+        if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal))
+        {
+            ImGui.TableSetupColumn("Triangles", ImGuiTableColumnFlags.PreferSortDescending);
+        }
+        ImGui.TableSetupScrollFreeze(0, 1);
+        ImGui.TableHeadersRow();
+
+        var sortSpecs = ImGui.TableGetSortSpecs();
+        if (sortSpecs.SpecsDirty || _sortDirty)
+        {
+            var idx = sortSpecs.Specs.ColumnIndex;
+
+            if (idx == 0 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Key, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 0 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Key, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 1 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.GamePaths.Count).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 1 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.GamePaths.Count).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 2 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.OriginalSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 2 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.OriginalSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 3 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.CompressedSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (idx == 3 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.CompressedSize).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal) && idx == 4 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.Triangles).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal) && idx == 4 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.Triangles).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal) && idx == 4 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Ascending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderBy(k => k.Value.Format.Value, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+            if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal) && idx == 4 && sortSpecs.Specs.SortDirection == ImGuiSortDirection.Descending)
+                _cachedAnalysis![_selectedObjectTab] = _cachedAnalysis[_selectedObjectTab].OrderByDescending(k => k.Value.Format.Value, StringComparer.Ordinal).ToDictionary(d => d.Key, d => d.Value, StringComparer.Ordinal);
+
+            sortSpecs.SpecsDirty = false;
+            _sortDirty = false;
+        }
+
+        foreach (var item in fileGroup)
+        {
+            using var text = ImRaii.PushColor(ImGuiCol.Text, new Vector4(0, 0, 0, 1), string.Equals(item.Hash, _selectedHash, StringComparison.Ordinal));
+            using var text2 = ImRaii.PushColor(ImGuiCol.Text, new Vector4(1, 1, 1, 1), !item.IsComputed);
+            ImGui.TableNextColumn();
+            if (string.Equals(_selectedHash, item.Hash, StringComparison.Ordinal))
+            {
+                ImGui.TableSetBgColor(ImGuiTableBgTarget.RowBg1, UiSharedService.Color(ImGuiColors.DalamudYellow));
+                ImGui.TableSetBgColor(ImGuiTableBgTarget.RowBg0, UiSharedService.Color(ImGuiColors.DalamudYellow));
+            }
+            ImGui.TextUnformatted(item.Hash);
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            ImGui.TableNextColumn();
+            ImGui.TextUnformatted(item.GamePaths.Count.ToString());
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            ImGui.TableNextColumn();
+            ImGui.TextUnformatted(UiSharedService.ByteToString(item.OriginalSize));
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            ImGui.TableNextColumn();
+            using (ImRaii.PushColor(ImGuiCol.Text, ImGuiColors.DalamudYellow, !item.IsComputed))
+                ImGui.TextUnformatted(UiSharedService.ByteToString(item.CompressedSize));
+            if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            if (string.Equals(fileGroup.Key, "tex", StringComparison.Ordinal))
+            {
+                ImGui.TableNextColumn();
+                ImGui.TextUnformatted(item.Format.Value);
+                if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            }
+            if (string.Equals(fileGroup.Key, "mdl", StringComparison.Ordinal))
+            {
+                ImGui.TableNextColumn();
+                ImGui.TextUnformatted(UiSharedService.TrisToString(item.Triangles));
+                if (ImGui.IsItemClicked()) _selectedHash = item.Hash;
+            }
+        }
+    }
+}

MareSynchronos/UI/PopoutProfileUi.cs

@@ -0,0 +1,185 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Textures.TextureWraps;
+using Dalamud.Interface.Utility;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+public class PopoutProfileUi : WindowMediatorSubscriberBase
+{
+    private readonly MareProfileManager _mareProfileManager;
+    private readonly PairManager _pairManager;
+    private readonly ServerConfigurationManager _serverManager;
+    private readonly UiSharedService _uiSharedService;
+    private Vector2 _lastMainPos = Vector2.Zero;
+    private Vector2 _lastMainSize = Vector2.Zero;
+    private byte[] _lastProfilePicture = [];
+    private byte[] _lastSupporterPicture = [];
+    private Pair? _pair;
+    private IDalamudTextureWrap? _supporterTextureWrap;
+    private IDalamudTextureWrap? _textureWrap;
+
+    public PopoutProfileUi(ILogger<PopoutProfileUi> logger, MareMediator mediator, UiSharedService uiSharedService,
+        ServerConfigurationManager serverManager, MareConfigService mareConfigService,
+        MareProfileManager mareProfileManager, PairManager pairManager, PerformanceCollectorService performanceCollectorService) : base(logger, mediator, "###ElezenSyncPopoutProfileUI", performanceCollectorService)
+    {
+        _uiSharedService = uiSharedService;
+        _serverManager = serverManager;
+        _mareProfileManager = mareProfileManager;
+        _pairManager = pairManager;
+        Flags = ImGuiWindowFlags.NoDecoration;
+
+        Mediator.Subscribe<ProfilePopoutToggle>(this, (msg) =>
+        {
+            IsOpen = msg.Pair != null;
+            _pair = msg.Pair;
+            _lastProfilePicture = [];
+            _lastSupporterPicture = [];
+            _textureWrap?.Dispose();
+            _textureWrap = null;
+            _supporterTextureWrap?.Dispose();
+            _supporterTextureWrap = null;
+        });
+
+        Mediator.Subscribe<CompactUiChange>(this, (msg) =>
+        {
+            if (msg.Size != Vector2.Zero)
+            {
+                var border = ImGui.GetStyle().WindowBorderSize;
+                var padding = ImGui.GetStyle().WindowPadding;
+                Size = new(256 + (padding.X * 2) + border, msg.Size.Y / ImGuiHelpers.GlobalScale);
+                _lastMainSize = msg.Size;
+            }
+            var mainPos = msg.Position == Vector2.Zero ? _lastMainPos : msg.Position;
+            if (mareConfigService.Current.ProfilePopoutRight)
+            {
+                Position = new(mainPos.X + _lastMainSize.X * ImGuiHelpers.GlobalScale, mainPos.Y);
+            }
+            else
+            {
+                Position = new(mainPos.X - Size!.Value.X * ImGuiHelpers.GlobalScale, mainPos.Y);
+            }
+
+            if (msg.Position != Vector2.Zero)
+            {
+                _lastMainPos = msg.Position;
+            }
+        });
+
+        IsOpen = false;
+    }
+
+    protected override void DrawInternal()
+    {
+        if (_pair == null) return;
+
+        try
+        {
+            var spacing = ImGui.GetStyle().ItemSpacing;
+
+            var mareProfile = _mareProfileManager.GetMareProfile(_pair.UserData);
+
+            if (_textureWrap == null || !mareProfile.ImageData.Value.SequenceEqual(_lastProfilePicture))
+            {
+                _textureWrap?.Dispose();
+                _lastProfilePicture = mareProfile.ImageData.Value;
+
+                _textureWrap = _uiSharedService.LoadImage(_lastProfilePicture);
+            }
+
+            var drawList = ImGui.GetWindowDrawList();
+            var rectMin = drawList.GetClipRectMin();
+            var rectMax = drawList.GetClipRectMax();
+
+            using (_uiSharedService.UidFont.Push())
+                UiSharedService.ColorText(_pair.UserData.AliasOrUID, UiSharedService.AccentColor);
+
+            ImGuiHelpers.ScaledDummy(spacing.Y, spacing.Y);
+            var textPos = ImGui.GetCursorPosY();
+            ImGui.Separator();
+            var imagePos = ImGui.GetCursorPos();
+            ImGuiHelpers.ScaledDummy(256, 256 * ImGuiHelpers.GlobalScale + spacing.Y);
+            var note = _serverManager.GetNoteForUid(_pair.UserData.UID);
+            if (!string.IsNullOrEmpty(note))
+            {
+                UiSharedService.ColorText(note, ImGuiColors.DalamudGrey);
+            }
+            string status = _pair.IsVisible ? "Visible" : (_pair.IsOnline ? "Online" : "Offline");
+            UiSharedService.ColorText(status, (_pair.IsVisible || _pair.IsOnline) ? ImGuiColors.HealerGreen : ImGuiColors.DalamudRed);
+            if (_pair.IsVisible)
+            {
+                ImGui.SameLine();
+                ImGui.TextUnformatted($"({_pair.PlayerName})");
+            }
+            if (_pair.UserPair != null)
+            {
+                ImGui.TextUnformatted("Directly paired");
+                if (_pair.UserPair.OwnPermissions.IsPaused())
+                {
+                    ImGui.SameLine();
+                    UiSharedService.ColorText("You: paused", ImGuiColors.DalamudYellow);
+                }
+                if (_pair.UserPair.OtherPermissions.IsPaused())
+                {
+                    ImGui.SameLine();
+                    UiSharedService.ColorText("They: paused", ImGuiColors.DalamudYellow);
+                }
+            }
+            if (_pair.GroupPair.Any())
+            {
+                ImGui.TextUnformatted("Paired through Syncshells:");
+                foreach (var groupPair in _pair.GroupPair.Select(k => k.Key))
+                {
+                    var groupNote = _serverManager.GetNoteForGid(groupPair.GID);
+                    var groupName = groupPair.GroupAliasOrGID;
+                    var groupString = string.IsNullOrEmpty(groupNote) ? groupName : $"{groupNote} ({groupName})";
+                    ImGui.TextUnformatted("- " + groupString);
+                }
+            }
+
+            ImGui.Separator();
+            _uiSharedService.GameFont.Push();
+            var remaining = ImGui.GetWindowContentRegionMax().Y - ImGui.GetCursorPosY();
+            var descText = mareProfile.Description;
+            var textSize = ImGui.CalcTextSize(descText, hideTextAfterDoubleHash: false, 256f * ImGuiHelpers.GlobalScale);
+            bool trimmed = textSize.Y > remaining;
+            while (textSize.Y > remaining && descText.Contains(' '))
+            {
+                descText = descText[..descText.LastIndexOf(' ')].TrimEnd();
+                textSize = ImGui.CalcTextSize(descText + $"...{Environment.NewLine}[Open Full Profile for complete description]", hideTextAfterDoubleHash: false, 256f * ImGuiHelpers.GlobalScale);
+            }
+            UiSharedService.TextWrapped(trimmed ? descText + $"...{Environment.NewLine}[Open Full Profile for complete description]" : mareProfile.Description);
+
+            _uiSharedService.GameFont.Pop();
+
+            var padding = ImGui.GetStyle().WindowPadding.X / 2;
+            bool tallerThanWide = _textureWrap.Height >= _textureWrap.Width;
+            var stretchFactor = tallerThanWide ? 256f * ImGuiHelpers.GlobalScale / _textureWrap.Height : 256f * ImGuiHelpers.GlobalScale / _textureWrap.Width;
+            var newWidth = _textureWrap.Width * stretchFactor;
+            var newHeight = _textureWrap.Height * stretchFactor;
+            var remainingWidth = (256f * ImGuiHelpers.GlobalScale - newWidth) / 2f;
+            var remainingHeight = (256f * ImGuiHelpers.GlobalScale - newHeight) / 2f;
+            drawList.AddImage(_textureWrap.Handle, new Vector2(rectMin.X + padding + remainingWidth, rectMin.Y + spacing.Y + imagePos.Y + remainingHeight),
+                new Vector2(rectMin.X + padding + remainingWidth + newWidth, rectMin.Y + spacing.Y + imagePos.Y + remainingHeight + newHeight));
+            if (_supporterTextureWrap != null)
+            {
+                const float iconSize = 38;
+                drawList.AddImage(_supporterTextureWrap.Handle,
+                    new Vector2(rectMax.X - iconSize - spacing.X, rectMin.Y + (textPos / 2) - (iconSize / 2)),
+                    new Vector2(rectMax.X - spacing.X, rectMin.Y + iconSize + (textPos / 2) - (iconSize / 2)));
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error during draw tooltip");
+        }
+    }
+}

MareSynchronos/UI/StandaloneProfileUi.cs

@@ -0,0 +1,167 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Textures.TextureWraps;
+using Dalamud.Interface.Utility;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+
+namespace MareSynchronos.UI;
+
+public class StandaloneProfileUi : WindowMediatorSubscriberBase
+{
+    private readonly MareProfileManager _mareProfileManager;
+    private readonly PairManager _pairManager;
+    private readonly ServerConfigurationManager _serverManager;
+    private readonly UiSharedService _uiSharedService;
+    private bool _adjustedForScrollBars = false;
+    private byte[] _lastProfilePicture = [];
+    private IDalamudTextureWrap? _textureWrap;
+
+    public StandaloneProfileUi(ILogger<StandaloneProfileUi> logger, MareMediator mediator, UiSharedService uiBuilder,
+        ServerConfigurationManager serverManager, MareProfileManager mareProfileManager, PairManager pairManager, Pair pair,
+        PerformanceCollectorService performanceCollector)
+        : base(logger, mediator, "Profile of " + pair.UserData.AliasOrUID + "##ElezenSyncStandaloneProfileUI" + pair.UserData.AliasOrUID, performanceCollector)
+    {
+        _uiSharedService = uiBuilder;
+        _serverManager = serverManager;
+        _mareProfileManager = mareProfileManager;
+        Pair = pair;
+        _pairManager = pairManager;
+        Flags = ImGuiWindowFlags.NoResize | ImGuiWindowFlags.AlwaysAutoResize;
+
+        var spacing = ImGui.GetStyle().ItemSpacing;
+
+        Size = new(512 + spacing.X * 3 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, 512);
+
+        IsOpen = true;
+    }
+
+    public Pair Pair { get; init; }
+
+    protected override void DrawInternal()
+    {
+        try
+        {
+            var spacing = ImGui.GetStyle().ItemSpacing;
+
+            var mareProfile = _mareProfileManager.GetMareProfile(Pair.UserData);
+
+            if (_textureWrap == null || !mareProfile.ImageData.Value.SequenceEqual(_lastProfilePicture))
+            {
+                _textureWrap?.Dispose();
+                _lastProfilePicture = mareProfile.ImageData.Value;
+                _textureWrap = _uiSharedService.LoadImage(_lastProfilePicture);
+            }
+
+            var drawList = ImGui.GetWindowDrawList();
+            var rectMin = drawList.GetClipRectMin();
+            var rectMax = drawList.GetClipRectMax();
+            var headerSize = ImGui.GetCursorPosY() - ImGui.GetStyle().WindowPadding.Y;
+
+            using (_uiSharedService.UidFont.Push())
+                UiSharedService.ColorText(Pair.UserData.AliasOrUID, UiSharedService.AccentColor);
+
+            var reportButtonSize = _uiSharedService.GetIconTextButtonSize(FontAwesomeIcon.ExclamationTriangle, "Report Profile");
+            ImGui.SameLine(ImGui.GetWindowContentRegionMax().X - reportButtonSize);
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.ExclamationTriangle, "Report Profile"))
+                Mediator.Publish(new OpenReportPopupMessage(Pair));
+
+            ImGuiHelpers.ScaledDummy(new Vector2(spacing.Y, spacing.Y));
+            var textPos = ImGui.GetCursorPosY() - headerSize;
+            ImGui.Separator();
+            var pos = ImGui.GetCursorPos() with { Y = ImGui.GetCursorPosY() - headerSize };
+            ImGuiHelpers.ScaledDummy(new Vector2(256, 256 + spacing.Y));
+            var postDummy = ImGui.GetCursorPosY();
+            ImGui.SameLine();
+            var descriptionTextSize = ImGui.CalcTextSize(mareProfile.Description, hideTextAfterDoubleHash: false, 256f);
+            var descriptionChildHeight = rectMax.Y - pos.Y - rectMin.Y - spacing.Y * 2;
+            if (descriptionTextSize.Y > descriptionChildHeight && !_adjustedForScrollBars)
+            {
+                Size = Size!.Value with { X = Size.Value.X + ImGui.GetStyle().ScrollbarSize };
+                _adjustedForScrollBars = true;
+            }
+            else if (descriptionTextSize.Y < descriptionChildHeight && _adjustedForScrollBars)
+            {
+                Size = Size!.Value with { X = Size.Value.X - ImGui.GetStyle().ScrollbarSize };
+                _adjustedForScrollBars = false;
+            }
+            var childFrame = ImGuiHelpers.ScaledVector2(256 + ImGui.GetStyle().WindowPadding.X + ImGui.GetStyle().WindowBorderSize, descriptionChildHeight);
+            childFrame = childFrame with
+            {
+                X = childFrame.X + (_adjustedForScrollBars ? ImGui.GetStyle().ScrollbarSize : 0),
+                Y = childFrame.Y / ImGuiHelpers.GlobalScale
+            };
+            if (ImGui.BeginChildFrame(1000, childFrame))
+            {
+                using var _ = _uiSharedService.GameFont.Push();
+                ImGui.TextWrapped(mareProfile.Description);
+            }
+            ImGui.EndChildFrame();
+
+            ImGui.SetCursorPosY(postDummy);
+            var note = _serverManager.GetNoteForUid(Pair.UserData.UID);
+            if (!string.IsNullOrEmpty(note))
+            {
+                UiSharedService.ColorText(note, ImGuiColors.DalamudGrey);
+            }
+            string status = Pair.IsVisible ? "Visible" : (Pair.IsOnline ? "Online" : "Offline");
+            UiSharedService.ColorText(status, (Pair.IsVisible || Pair.IsOnline) ? ImGuiColors.HealerGreen : ImGuiColors.DalamudRed);
+            if (Pair.IsVisible)
+            {
+                ImGui.SameLine();
+                ImGui.TextUnformatted($"({Pair.PlayerName})");
+            }
+            if (Pair.UserPair != null)
+            {
+                ImGui.TextUnformatted("Directly paired");
+                if (Pair.UserPair.OwnPermissions.IsPaused())
+                {
+                    ImGui.SameLine();
+                    UiSharedService.ColorText("You: paused", ImGuiColors.DalamudYellow);
+                }
+                if (Pair.UserPair.OtherPermissions.IsPaused())
+                {
+                    ImGui.SameLine();
+                    UiSharedService.ColorText("They: paused", ImGuiColors.DalamudYellow);
+                }
+            }
+
+            if (Pair.GroupPair.Any())
+            {
+                ImGui.TextUnformatted("Paired through Syncshells:");
+                foreach (var groupPair in Pair.GroupPair.Select(k => k.Key))
+                {
+                    var groupNote = _serverManager.GetNoteForGid(groupPair.GID);
+                    var groupName = groupPair.GroupAliasOrGID;
+                    var groupString = string.IsNullOrEmpty(groupNote) ? groupName : $"{groupNote} ({groupName})";
+                    ImGui.TextUnformatted("- " + groupString);
+                }
+            }
+
+            var padding = ImGui.GetStyle().WindowPadding.X / 2;
+            bool tallerThanWide = _textureWrap.Height >= _textureWrap.Width;
+            var stretchFactor = tallerThanWide ? 256f * ImGuiHelpers.GlobalScale / _textureWrap.Height : 256f * ImGuiHelpers.GlobalScale / _textureWrap.Width;
+            var newWidth = _textureWrap.Width * stretchFactor;
+            var newHeight = _textureWrap.Height * stretchFactor;
+            var remainingWidth = (256f * ImGuiHelpers.GlobalScale - newWidth) / 2f;
+            var remainingHeight = (256f * ImGuiHelpers.GlobalScale - newHeight) / 2f;
+            drawList.AddImage(_textureWrap.Handle, new Vector2(rectMin.X + padding + remainingWidth, rectMin.Y + spacing.Y + pos.Y + remainingHeight),
+                new Vector2(rectMin.X + padding + remainingWidth + newWidth, rectMin.Y + spacing.Y + pos.Y + remainingHeight + newHeight));
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error during draw tooltip");
+        }
+    }
+
+    public override void OnClose()
+    {
+        Mediator.Publish(new RemoveWindowMessage(this));
+    }
+}

MareSynchronos/UI/SyncshellAdminUI.cs

@@ -0,0 +1,455 @@
+using Dalamud.Bindings.ImGui;
+using Dalamud.Interface;
+using Dalamud.Interface.Colors;
+using Dalamud.Interface.Utility;
+using Dalamud.Interface.Utility.Raii;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.API.Dto.Group;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.WebAPI;
+using Microsoft.Extensions.Logging;
+using System.Globalization;
+
+namespace MareSynchronos.UI.Components.Popup;
+
+public class SyncshellAdminUI : WindowMediatorSubscriberBase
+{
+    private readonly ApiController _apiController;
+    private readonly bool _isModerator = false;
+    private readonly bool _isOwner = false;
+    private readonly List<string> _oneTimeInvites = [];
+    private readonly PairManager _pairManager;
+    private readonly UiSharedService _uiSharedService;
+    private List<BannedGroupUserDto> _bannedUsers = [];
+    private int _multiInvites;
+    private string _newPassword;
+    private bool _pwChangeSuccess;
+    private Task<int>? _pruneTestTask;
+    private Task<int>? _pruneTask;
+    private int _pruneDays = 14;
+
+    public SyncshellAdminUI(ILogger<SyncshellAdminUI> logger, MareMediator mediator, ApiController apiController,
+        UiSharedService uiSharedService, PairManager pairManager, GroupFullInfoDto groupFullInfo, PerformanceCollectorService performanceCollectorService)
+        : base(logger, mediator, "Syncshell Admin Panel (" + groupFullInfo.GroupAliasOrGID + ")", performanceCollectorService)
+    {
+        GroupFullInfo = groupFullInfo;
+        _apiController = apiController;
+        _uiSharedService = uiSharedService;
+        _pairManager = pairManager;
+        _isOwner = string.Equals(GroupFullInfo.OwnerUID, _apiController.UID, StringComparison.Ordinal);
+        _isModerator = GroupFullInfo.GroupUserInfo.IsModerator();
+        _newPassword = string.Empty;
+        _multiInvites = 30;
+        _pwChangeSuccess = true;
+        IsOpen = true;
+        SizeConstraints = new WindowSizeConstraints()
+        {
+            MinimumSize = new(700, 500),
+            MaximumSize = new(700, 2000),
+        };
+    }
+
+    public GroupFullInfoDto GroupFullInfo { get; private set; }
+
+    protected override void DrawInternal()
+    {
+        if (!_isModerator && !_isOwner) return;
+
+        GroupFullInfo = _pairManager.Groups[GroupFullInfo.Group];
+
+        using var id = ImRaii.PushId("syncshell_admin_" + GroupFullInfo.GID);
+
+        using (_uiSharedService.UidFont.Push())
+            ImGui.TextUnformatted(GroupFullInfo.GroupAliasOrGID + " Administrative Panel");
+
+        ImGui.Separator();
+        var perm = GroupFullInfo.GroupPermissions;
+
+        using var tabbar = ImRaii.TabBar("syncshell_tab_" + GroupFullInfo.GID);
+
+        if (tabbar)
+        {
+            var inviteTab = ImRaii.TabItem("Invites");
+            if (inviteTab)
+            {
+                bool isInvitesDisabled = perm.IsDisableInvites();
+
+                if (_uiSharedService.IconTextButton(isInvitesDisabled ? FontAwesomeIcon.Unlock : FontAwesomeIcon.Lock,
+                    isInvitesDisabled ? "Unlock Syncshell" : "Lock Syncshell"))
+                {
+                    perm.SetDisableInvites(!isInvitesDisabled);
+                    _ = _apiController.GroupChangeGroupPermissionState(new(GroupFullInfo.Group, perm));
+                }
+
+                ImGuiHelpers.ScaledDummy(2f);
+
+                UiSharedService.TextWrapped("One-time invites work as single-use passwords. Use those if you do not want to distribute your Syncshell password.");
+                if (_uiSharedService.IconTextButton(FontAwesomeIcon.Envelope, "Single one-time invite"))
+                {
+                    ImGui.SetClipboardText(_apiController.GroupCreateTempInvite(new(GroupFullInfo.Group), 1).Result.FirstOrDefault() ?? string.Empty);
+                }
+                UiSharedService.AttachToolTip("Creates a single-use password for joining the syncshell which is valid for 24h and copies it to the clipboard.");
+                ImGui.InputInt("##amountofinvites", ref _multiInvites);
+                ImGui.SameLine();
+                using (ImRaii.Disabled(_multiInvites <= 1 || _multiInvites > 100))
+                {
+                    if (_uiSharedService.IconTextButton(FontAwesomeIcon.Envelope, "Generate " + _multiInvites + " one-time invites"))
+                    {
+                        _oneTimeInvites.AddRange(_apiController.GroupCreateTempInvite(new(GroupFullInfo.Group), _multiInvites).Result);
+                    }
+                }
+
+                if (_oneTimeInvites.Any())
+                {
+                    var invites = string.Join(Environment.NewLine, _oneTimeInvites);
+                    ImGui.InputTextMultiline("Generated Multi Invites", ref invites, 5000, new(0, 0), ImGuiInputTextFlags.ReadOnly);
+                    if (_uiSharedService.IconTextButton(FontAwesomeIcon.Copy, "Copy Invites to clipboard"))
+                    {
+                        ImGui.SetClipboardText(invites);
+                    }
+                }
+            }
+            inviteTab.Dispose();
+
+            var mgmtTab = ImRaii.TabItem("User Management");
+            if (mgmtTab)
+            {
+                var userNode = ImRaii.TreeNode("User List & Administration");
+                if (userNode)
+                {
+                    if (!_pairManager.GroupPairs.TryGetValue(GroupFullInfo, out var pairs))
+                    {
+                        UiSharedService.ColorTextWrapped("No users found in this Syncshell", ImGuiColors.DalamudYellow);
+                    }
+                    else
+                    {
+                        using var table = ImRaii.Table("userList#" + GroupFullInfo.Group.GID, 4, ImGuiTableFlags.RowBg | ImGuiTableFlags.SizingStretchProp | ImGuiTableFlags.ScrollY);
+                        if (table)
+                        {
+                            ImGui.TableSetupColumn("Alias/UID/Note", ImGuiTableColumnFlags.None, 3);
+                            ImGui.TableSetupColumn("Online/Name", ImGuiTableColumnFlags.None, 2);
+                            ImGui.TableSetupColumn("Flags", ImGuiTableColumnFlags.None, 1);
+                            ImGui.TableSetupColumn("Actions", ImGuiTableColumnFlags.None, 2);
+                            ImGui.TableHeadersRow();
+
+                            var groupedPairs = new Dictionary<Pair, GroupUserInfo?>(pairs.Select(p => new KeyValuePair<Pair, GroupUserInfo?>(p,
+                                p.GroupPair.TryGetValue(GroupFullInfo, out GroupPairFullInfoDto? value) ? value.GroupPairStatusInfo : null)));
+
+                            foreach (var pair in groupedPairs.OrderBy(p =>
+                            {
+                                if (p.Value == null) return 10;
+                                if (p.Value.Value.IsModerator()) return 0;
+                                if (p.Value.Value.IsPinned()) return 1;
+                                return 10;
+                            }).ThenBy(p => p.Key.GetNote() ?? p.Key.UserData.AliasOrUID, StringComparer.OrdinalIgnoreCase))
+                            {
+                                using var tableId = ImRaii.PushId("userTable_" + pair.Key.UserData.UID);
+
+                                ImGui.TableNextColumn(); // alias/uid/note
+                                var note = pair.Key.GetNote();
+                                var text = note == null ? pair.Key.UserData.AliasOrUID : note + " (" + pair.Key.UserData.AliasOrUID + ")";
+                                ImGui.AlignTextToFramePadding();
+                                ImGui.TextUnformatted(text);
+
+                                ImGui.TableNextColumn(); // online/name
+                                string onlineText = pair.Key.IsOnline ? "Online" : "Offline";
+                                string? name = pair.Key.GetNoteOrName();
+                                if (!string.IsNullOrEmpty(name))
+                                {
+                                    onlineText += " (" + name + ")";
+                                }
+                                var boolcolor = UiSharedService.GetBoolColor(pair.Key.IsOnline);
+                                ImGui.AlignTextToFramePadding();
+                                UiSharedService.ColorText(onlineText, boolcolor);
+
+                                ImGui.TableNextColumn(); // special flags
+                                if (pair.Value != null && (pair.Value.Value.IsModerator() || pair.Value.Value.IsPinned()))
+                                {
+                                    if (pair.Value.Value.IsModerator())
+                                    {
+                                        _uiSharedService.IconText(FontAwesomeIcon.UserShield);
+                                        UiSharedService.AttachToolTip("Moderator");
+                                    }
+                                    if (pair.Value.Value.IsPinned())
+                                    {
+                                        _uiSharedService.IconText(FontAwesomeIcon.Thumbtack);
+                                        UiSharedService.AttachToolTip("Pinned");
+                                    }
+                                }
+                                else
+                                {
+                                    _uiSharedService.IconText(FontAwesomeIcon.None);
+                                }
+
+                                ImGui.TableNextColumn(); // actions
+                                if (_isOwner)
+                                {
+                                    if (_uiSharedService.IconButton(FontAwesomeIcon.UserShield))
+                                    {
+                                        GroupUserInfo userInfo = pair.Value ?? GroupUserInfo.None;
+
+                                        userInfo.SetModerator(!userInfo.IsModerator());
+
+                                        _ = _apiController.GroupSetUserInfo(new GroupPairUserInfoDto(GroupFullInfo.Group, pair.Key.UserData, userInfo));
+                                    }
+                                    UiSharedService.AttachToolTip(pair.Value != null && pair.Value.Value.IsModerator() ? "Demod user" : "Mod user");
+                                    ImGui.SameLine();
+                                }
+
+                                if (_isOwner || (pair.Value == null || (pair.Value != null && !pair.Value.Value.IsModerator())))
+                                {
+                                    if (_uiSharedService.IconButton(FontAwesomeIcon.Thumbtack))
+                                    {
+                                        GroupUserInfo userInfo = pair.Value ?? GroupUserInfo.None;
+
+                                        userInfo.SetPinned(!userInfo.IsPinned());
+
+                                        _ = _apiController.GroupSetUserInfo(new GroupPairUserInfoDto(GroupFullInfo.Group, pair.Key.UserData, userInfo));
+                                    }
+                                    UiSharedService.AttachToolTip(pair.Value != null && pair.Value.Value.IsPinned() ? "Unpin user" : "Pin user");
+                                    ImGui.SameLine();
+
+                                    using (ImRaii.Disabled(!UiSharedService.CtrlPressed()))
+                                    {
+                                        if (_uiSharedService.IconButton(FontAwesomeIcon.Trash))
+                                        {
+                                            _ = _apiController.GroupRemoveUser(new GroupPairDto(GroupFullInfo.Group, pair.Key.UserData));
+                                        }
+                                    }
+                                    UiSharedService.AttachToolTip("Remove user from Syncshell"
+                                        + UiSharedService.TooltipSeparator + "Hold CTRL to enable this button");
+
+                                    ImGui.SameLine();
+                                    using (ImRaii.Disabled(!UiSharedService.CtrlPressed()))
+                                    {
+                                        if (_uiSharedService.IconButton(FontAwesomeIcon.Ban))
+                                        {
+                                            Mediator.Publish(new OpenBanUserPopupMessage(pair.Key, GroupFullInfo));
+                                        }
+                                    }
+                                    UiSharedService.AttachToolTip("Ban user from Syncshell"
+                                        + UiSharedService.TooltipSeparator + "Hold CTRL to enable this button");
+                                }
+                            }
+                        }
+                    }
+                }
+                userNode.Dispose();
+                var clearNode = ImRaii.TreeNode("Mass Cleanup");
+                if (clearNode)
+                {
+                    using (ImRaii.Disabled(!UiSharedService.CtrlPressed()))
+                    {
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Broom, "Clear Syncshell"))
+                        {
+                            _ = _apiController.GroupClear(new(GroupFullInfo.Group));
+                        }
+                    }
+                    UiSharedService.AttachToolTip("This will remove all non-pinned, non-moderator users from the Syncshell."
+                        + UiSharedService.TooltipSeparator + "Hold CTRL to enable this button");
+
+                    ImGuiHelpers.ScaledDummy(2f);
+                    ImGui.Separator();
+                    ImGuiHelpers.ScaledDummy(2f);
+
+                    if (_uiSharedService.IconTextButton(FontAwesomeIcon.Unlink, "Check for Inactive Users"))
+                    {
+                        _pruneTestTask = _apiController.GroupPrune(new(GroupFullInfo.Group), _pruneDays, execute: false);
+                        _pruneTask = null;
+                    }
+                    UiSharedService.AttachToolTip($"This will start the prune process for this Syncshell of inactive users that have not logged in the past {_pruneDays} days."
+                        + Environment.NewLine + "You will be able to review the amount of inactive users before executing the prune."
+                        + UiSharedService.TooltipSeparator + "Note: pruning excludes pinned users and moderators of this Syncshell.");
+                    ImGui.SameLine();
+                    ImGui.SetNextItemWidth(150);
+                    _uiSharedService.DrawCombo("Days of inactivity", [7, 14, 30, 90], (count) =>
+                    {
+                        return count + " days";
+                    },
+                    (selected) =>
+                    {
+                        _pruneDays = selected;
+                        _pruneTestTask = null;
+                        _pruneTask = null;
+                    },
+                    _pruneDays);
+
+                    if (_pruneTestTask != null)
+                    {
+                        if (!_pruneTestTask.IsCompleted)
+                        {
+                            UiSharedService.ColorTextWrapped("Calculating inactive users...", ImGuiColors.DalamudYellow);
+                        }
+                        else
+                        {
+                            ImGui.AlignTextToFramePadding();
+                            UiSharedService.TextWrapped($"Found {_pruneTestTask.Result} user(s) that have not logged in the past {_pruneDays} days.");
+                            if (_pruneTestTask.Result > 0)
+                            {
+                                using (ImRaii.Disabled(!UiSharedService.CtrlPressed()))
+                                {
+                                    if (_uiSharedService.IconTextButton(FontAwesomeIcon.Broom, "Prune Inactive Users"))
+                                    {
+                                        _pruneTask = _apiController.GroupPrune(new(GroupFullInfo.Group), _pruneDays, execute: true);
+                                        _pruneTestTask = null;
+                                    }
+                                }
+                                UiSharedService.AttachToolTip($"Pruning will remove {_pruneTestTask?.Result ?? 0} inactive user(s)."
+                                    + UiSharedService.TooltipSeparator + "Hold CTRL to enable this button");
+                            }
+                        }
+                    }
+                    if (_pruneTask != null)
+                    {
+                        if (!_pruneTask.IsCompleted)
+                        {
+                            UiSharedService.ColorTextWrapped("Pruning Syncshell...", ImGuiColors.DalamudYellow);
+                        }
+                        else
+                        {
+                            UiSharedService.TextWrapped($"Syncshell was pruned and {_pruneTask.Result} inactive user(s) have been removed.");
+                        }
+                    }
+                }
+                clearNode.Dispose();
+
+                var banNode = ImRaii.TreeNode("User Bans");
+                if (banNode)
+                {
+                    if (_uiSharedService.IconTextButton(FontAwesomeIcon.Retweet, "Refresh Banlist from Server"))
+                    {
+                        _bannedUsers = _apiController.GroupGetBannedUsers(new GroupDto(GroupFullInfo.Group)).Result;
+                    }
+
+                    if (ImGui.BeginTable("bannedusertable" + GroupFullInfo.GID, 6, ImGuiTableFlags.RowBg | ImGuiTableFlags.SizingStretchProp | ImGuiTableFlags.ScrollY))
+                    {
+                        ImGui.TableSetupColumn("UID", ImGuiTableColumnFlags.None, 1);
+                        ImGui.TableSetupColumn("Alias", ImGuiTableColumnFlags.None, 1);
+                        ImGui.TableSetupColumn("By", ImGuiTableColumnFlags.None, 1);
+                        ImGui.TableSetupColumn("Date", ImGuiTableColumnFlags.None, 2);
+                        ImGui.TableSetupColumn("Reason", ImGuiTableColumnFlags.None, 3);
+                        ImGui.TableSetupColumn("Actions", ImGuiTableColumnFlags.None, 1);
+
+                        ImGui.TableHeadersRow();
+
+                        foreach (var bannedUser in _bannedUsers.ToList())
+                        {
+                            ImGui.TableNextColumn();
+                            ImGui.TextUnformatted(bannedUser.UID);
+                            ImGui.TableNextColumn();
+                            ImGui.TextUnformatted(bannedUser.UserAlias ?? string.Empty);
+                            ImGui.TableNextColumn();
+                            ImGui.TextUnformatted(bannedUser.BannedBy);
+                            ImGui.TableNextColumn();
+                            ImGui.TextUnformatted(bannedUser.BannedOn.ToLocalTime().ToString(CultureInfo.CurrentCulture));
+                            ImGui.TableNextColumn();
+                            UiSharedService.TextWrapped(bannedUser.Reason);
+                            ImGui.TableNextColumn();
+                            using var pushId = ImRaii.PushId(bannedUser.UID);
+                            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Check, "Unban"))
+                            {
+                                _ = Task.Run(async () => await _apiController.GroupUnbanUser(bannedUser).ConfigureAwait(false));
+                                _bannedUsers.RemoveAll(b => string.Equals(b.UID, bannedUser.UID, StringComparison.Ordinal));
+                            }
+                        }
+
+                        ImGui.EndTable();
+                    }
+                }
+                banNode.Dispose();
+            }
+            mgmtTab.Dispose();
+
+            var permissionTab = ImRaii.TabItem("Permissions");
+            if (permissionTab)
+            {
+                bool isDisableAnimations = perm.IsDisableAnimations();
+                bool isDisableSounds = perm.IsDisableSounds();
+                bool isDisableVfx = perm.IsDisableVFX();
+
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextUnformatted("Sound Sync");
+                _uiSharedService.BooleanToColoredIcon(!isDisableSounds);
+                ImGui.SameLine(230);
+                if (_uiSharedService.IconTextButton(isDisableSounds ? FontAwesomeIcon.VolumeUp : FontAwesomeIcon.VolumeMute,
+                    isDisableSounds ? "Enable sound sync" : "Disable sound sync"))
+                {
+                    perm.SetDisableSounds(!perm.IsDisableSounds());
+                    _ = _apiController.GroupChangeGroupPermissionState(new(GroupFullInfo.Group, perm));
+                }
+
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextUnformatted("Animation Sync");
+                _uiSharedService.BooleanToColoredIcon(!isDisableAnimations);
+                ImGui.SameLine(230);
+                if (_uiSharedService.IconTextButton(isDisableAnimations ? FontAwesomeIcon.Running : FontAwesomeIcon.Stop,
+                    isDisableAnimations ? "Enable animation sync" : "Disable animation sync"))
+                {
+                    perm.SetDisableAnimations(!perm.IsDisableAnimations());
+                    _ = _apiController.GroupChangeGroupPermissionState(new(GroupFullInfo.Group, perm));
+                }
+
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextUnformatted("VFX Sync");
+                _uiSharedService.BooleanToColoredIcon(!isDisableVfx);
+                ImGui.SameLine(230);
+                if (_uiSharedService.IconTextButton(isDisableVfx ? FontAwesomeIcon.Sun : FontAwesomeIcon.Circle,
+                    isDisableVfx ? "Enable VFX sync" : "Disable VFX sync"))
+                {
+                    perm.SetDisableVFX(!perm.IsDisableVFX());
+                    _ = _apiController.GroupChangeGroupPermissionState(new(GroupFullInfo.Group, perm));
+                }
+            }
+            permissionTab.Dispose();
+
+            if (_isOwner)
+            {
+                var ownerTab = ImRaii.TabItem("Owner Settings");
+                if (ownerTab)
+                {
+                    ImGui.AlignTextToFramePadding();
+                    ImGui.TextUnformatted("New Password");
+                    var availableWidth = ImGui.GetWindowContentRegionMax().X - ImGui.GetWindowContentRegionMin().X;
+                    var buttonSize = _uiSharedService.GetIconTextButtonSize(FontAwesomeIcon.Passport, "Change Password");
+                    var textSize = ImGui.CalcTextSize("New Password").X;
+                    var spacing = ImGui.GetStyle().ItemSpacing.X;
+
+                    ImGui.SameLine();
+                    ImGui.SetNextItemWidth(availableWidth - buttonSize - textSize - spacing * 2);
+                    ImGui.InputTextWithHint("##changepw", "Min 10 characters", ref _newPassword, 50);
+                    ImGui.SameLine();
+                    using (ImRaii.Disabled(_newPassword.Length < 10))
+                    {
+                        if (_uiSharedService.IconTextButton(FontAwesomeIcon.Passport, "Change Password"))
+                        {
+                            _pwChangeSuccess = _apiController.GroupChangePassword(new GroupPasswordDto(GroupFullInfo.Group, _newPassword)).Result;
+                            _newPassword = string.Empty;
+                        }
+                    }
+                    UiSharedService.AttachToolTip("Password requires to be at least 10 characters long. This action is irreversible.");
+
+                    if (!_pwChangeSuccess)
+                    {
+                        UiSharedService.ColorTextWrapped("Failed to change the password. Password requires to be at least 10 characters long.", ImGuiColors.DalamudYellow);
+                    }
+
+                    if (_uiSharedService.IconTextButton(FontAwesomeIcon.Trash, "Delete Syncshell") && UiSharedService.CtrlPressed() && UiSharedService.ShiftPressed())
+                    {
+                        IsOpen = false;
+                        _ = _apiController.GroupDelete(new(GroupFullInfo.Group));
+                    }
+                    UiSharedService.AttachToolTip("Hold CTRL and Shift and click to delete this Syncshell." + Environment.NewLine + "WARNING: this action is irreversible.");
+                }
+                ownerTab.Dispose();
+            }
+        }
+    }
+
+    public override void OnClose()
+    {
+        Mediator.Publish(new RemoveWindowMessage(this));
+    }
+}