598 lines
22 KiB
C#
598 lines
22 KiB
C#
using Dalamud.Interface;
|
|
using Dalamud.Interface.Colors;
|
|
using Dalamud.Interface.Utility;
|
|
using Dalamud.Interface.Utility.Raii;
|
|
using Dalamud.Interface.Windowing;
|
|
using LightlessSync.LightlessConfiguration;
|
|
using LightlessSync.LightlessConfiguration.Models;
|
|
using LightlessSync.Services;
|
|
using LightlessSync.Services.Mediator;
|
|
using LightlessSync.UI.Models;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
using System.Numerics;
|
|
using Dalamud.Bindings.ImGui;
|
|
|
|
namespace LightlessSync.UI;
|
|
|
|
public class LightlessNotificationUI : WindowMediatorSubscriberBase
|
|
{
|
|
private const float NotificationMinHeight = 60f;
|
|
private const float NotificationMaxHeight = 250f;
|
|
private const float WindowPaddingOffset = 6f;
|
|
private const float SlideAnimationDistance = 100f;
|
|
private const float OutAnimationSpeedMultiplier = 0.7f;
|
|
|
|
private readonly List<LightlessNotification> _notifications = new();
|
|
private readonly object _notificationLock = new();
|
|
private readonly LightlessConfigService _configService;
|
|
|
|
public LightlessNotificationUI(ILogger<LightlessNotificationUI> logger, LightlessMediator mediator, PerformanceCollectorService performanceCollector, LightlessConfigService configService)
|
|
: base(logger, mediator, "Lightless Notifications##LightlessNotifications", performanceCollector)
|
|
{
|
|
_configService = configService;
|
|
Flags = ImGuiWindowFlags.NoDecoration |
|
|
ImGuiWindowFlags.NoMove |
|
|
ImGuiWindowFlags.NoResize |
|
|
ImGuiWindowFlags.NoSavedSettings |
|
|
ImGuiWindowFlags.NoFocusOnAppearing |
|
|
ImGuiWindowFlags.NoNav |
|
|
ImGuiWindowFlags.NoBackground |
|
|
ImGuiWindowFlags.NoCollapse |
|
|
ImGuiWindowFlags.AlwaysAutoResize;
|
|
|
|
PositionCondition = ImGuiCond.Always;
|
|
|
|
Size = new Vector2(_configService.Current.NotificationWidth, 100);
|
|
SizeCondition = ImGuiCond.FirstUseEver;
|
|
IsOpen = false;
|
|
RespectCloseHotkey = false;
|
|
DisableWindowSounds = true;
|
|
|
|
Mediator.Subscribe<LightlessNotificationMessage>(this, HandleNotificationMessage);
|
|
Mediator.Subscribe<LightlessNotificationDismissMessage>(this, HandleNotificationDismissMessage);
|
|
}
|
|
private void HandleNotificationMessage(LightlessNotificationMessage message) =>
|
|
AddNotification(message.Notification);
|
|
|
|
private void HandleNotificationDismissMessage(LightlessNotificationDismissMessage message) =>
|
|
RemoveNotification(message.NotificationId);
|
|
|
|
public void AddNotification(LightlessNotification notification)
|
|
{
|
|
lock (_notificationLock)
|
|
{
|
|
var existingNotification = _notifications.FirstOrDefault(n => n.Id == notification.Id);
|
|
if (existingNotification != null)
|
|
{
|
|
UpdateExistingNotification(existingNotification, notification);
|
|
}
|
|
else
|
|
{
|
|
_notifications.Add(notification);
|
|
_logger.LogDebug("Added new notification: {Title}", notification.Title);
|
|
}
|
|
|
|
if (!IsOpen) IsOpen = true;
|
|
}
|
|
}
|
|
|
|
private void UpdateExistingNotification(LightlessNotification existing, LightlessNotification updated)
|
|
{
|
|
existing.Message = updated.Message;
|
|
existing.Progress = updated.Progress;
|
|
existing.ShowProgress = updated.ShowProgress;
|
|
existing.Title = updated.Title;
|
|
_logger.LogDebug("Updated existing notification: {Title}", updated.Title);
|
|
}
|
|
|
|
public void RemoveNotification(string id)
|
|
{
|
|
lock (_notificationLock)
|
|
{
|
|
var notification = _notifications.FirstOrDefault(n => n.Id == id);
|
|
if (notification != null)
|
|
{
|
|
StartOutAnimation(notification);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void StartOutAnimation(LightlessNotification notification)
|
|
{
|
|
notification.IsAnimatingOut = true;
|
|
notification.IsAnimatingIn = false;
|
|
}
|
|
|
|
protected override void DrawInternal()
|
|
{
|
|
ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, Vector2.Zero);
|
|
|
|
lock (_notificationLock)
|
|
{
|
|
UpdateNotifications();
|
|
|
|
if (_notifications.Count == 0)
|
|
{
|
|
ImGui.PopStyleVar();
|
|
IsOpen = false;
|
|
return;
|
|
}
|
|
|
|
var viewport = ImGui.GetMainViewport();
|
|
Position = CalculateWindowPosition(viewport);
|
|
DrawAllNotifications();
|
|
}
|
|
|
|
ImGui.PopStyleVar();
|
|
}
|
|
|
|
private Vector2 CalculateWindowPosition(ImGuiViewportPtr viewport)
|
|
{
|
|
var x = viewport.WorkPos.X + viewport.WorkSize.X -
|
|
_configService.Current.NotificationWidth -
|
|
_configService.Current.NotificationOffsetX -
|
|
WindowPaddingOffset;
|
|
var y = viewport.WorkPos.Y + _configService.Current.NotificationOffsetY;
|
|
return new Vector2(x, y);
|
|
}
|
|
|
|
private void DrawAllNotifications()
|
|
{
|
|
for (int i = 0; i < _notifications.Count; i++)
|
|
{
|
|
DrawNotification(_notifications[i], i);
|
|
|
|
if (i < _notifications.Count - 1)
|
|
{
|
|
ImGui.Dummy(new Vector2(0, _configService.Current.NotificationSpacing));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateNotifications()
|
|
{
|
|
var deltaTime = ImGui.GetIO().DeltaTime;
|
|
EnforceMaxNotificationLimit();
|
|
UpdateAnimationsAndRemoveExpired(deltaTime);
|
|
}
|
|
|
|
private void EnforceMaxNotificationLimit()
|
|
{
|
|
var maxNotifications = _configService.Current.MaxSimultaneousNotifications;
|
|
while (_notifications.Count(n => !n.IsAnimatingOut) > maxNotifications)
|
|
{
|
|
var oldestNotification = _notifications
|
|
.Where(n => !n.IsAnimatingOut)
|
|
.OrderBy(n => n.CreatedAt)
|
|
.FirstOrDefault();
|
|
|
|
if (oldestNotification != null)
|
|
{
|
|
StartOutAnimation(oldestNotification);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateAnimationsAndRemoveExpired(float deltaTime)
|
|
{
|
|
for (int i = _notifications.Count - 1; i >= 0; i--)
|
|
{
|
|
var notification = _notifications[i];
|
|
UpdateNotificationAnimation(notification, deltaTime);
|
|
|
|
if (ShouldRemoveNotification(notification))
|
|
{
|
|
_notifications.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateNotificationAnimation(LightlessNotification notification, float deltaTime)
|
|
{
|
|
if (notification.IsAnimatingIn && notification.AnimationProgress < 1f)
|
|
{
|
|
notification.AnimationProgress = Math.Min(1f,
|
|
notification.AnimationProgress + deltaTime * _configService.Current.NotificationAnimationSpeed);
|
|
}
|
|
else if (notification.IsAnimatingOut && notification.AnimationProgress > 0f)
|
|
{
|
|
notification.AnimationProgress = Math.Max(0f,
|
|
notification.AnimationProgress - deltaTime * _configService.Current.NotificationAnimationSpeed * OutAnimationSpeedMultiplier);
|
|
}
|
|
else if (!notification.IsAnimatingOut && !notification.IsDismissed)
|
|
{
|
|
notification.IsAnimatingIn = false;
|
|
|
|
if (notification.IsExpired)
|
|
{
|
|
StartOutAnimation(notification);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool ShouldRemoveNotification(LightlessNotification notification) =>
|
|
notification.IsAnimatingOut && notification.AnimationProgress <= 0.01f;
|
|
|
|
private void DrawNotification(LightlessNotification notification, int index)
|
|
{
|
|
var alpha = notification.AnimationProgress;
|
|
if (alpha <= 0f) return;
|
|
|
|
var slideOffset = (1f - alpha) * SlideAnimationDistance;
|
|
var originalCursorPos = ImGui.GetCursorPos();
|
|
ImGui.SetCursorPosX(originalCursorPos.X + slideOffset);
|
|
|
|
var notificationHeight = CalculateNotificationHeight(notification);
|
|
var notificationWidth = _configService.Current.NotificationWidth - slideOffset;
|
|
|
|
ImGui.PushStyleVar(ImGuiStyleVar.WindowPadding, Vector2.Zero);
|
|
|
|
using var child = ImRaii.Child($"notification_{notification.Id}",
|
|
new Vector2(notificationWidth, notificationHeight),
|
|
false, ImGuiWindowFlags.NoScrollbar);
|
|
|
|
if (child.Success)
|
|
{
|
|
DrawNotificationContent(notification, alpha);
|
|
}
|
|
|
|
ImGui.PopStyleVar();
|
|
}
|
|
|
|
private void DrawNotificationContent(LightlessNotification notification, float alpha)
|
|
{
|
|
var drawList = ImGui.GetWindowDrawList();
|
|
var windowPos = ImGui.GetWindowPos();
|
|
var windowSize = ImGui.GetWindowSize();
|
|
|
|
var bgColor = CalculateBackgroundColor(alpha, ImGui.IsWindowHovered());
|
|
var accentColor = GetNotificationAccentColor(notification.Type);
|
|
accentColor.W *= alpha;
|
|
|
|
DrawShadow(drawList, windowPos, windowSize, alpha);
|
|
HandleClickToDismiss(notification);
|
|
DrawBackground(drawList, windowPos, windowSize, bgColor);
|
|
DrawAccentBar(drawList, windowPos, windowSize, accentColor);
|
|
DrawDurationProgressBar(notification, alpha, windowPos, windowSize, drawList);
|
|
DrawNotificationText(notification, alpha);
|
|
}
|
|
|
|
private Vector4 CalculateBackgroundColor(float alpha, bool isHovered)
|
|
{
|
|
var baseOpacity = _configService.Current.NotificationOpacity;
|
|
var finalOpacity = baseOpacity * alpha;
|
|
var bgColor = new Vector4(30f/255f, 30f/255f, 30f/255f, finalOpacity);
|
|
|
|
if (isHovered)
|
|
{
|
|
bgColor *= 1.1f;
|
|
bgColor.W = Math.Min(bgColor.W, 0.98f);
|
|
}
|
|
|
|
return bgColor;
|
|
}
|
|
|
|
private void DrawShadow(ImDrawListPtr drawList, Vector2 windowPos, Vector2 windowSize, float alpha)
|
|
{
|
|
var shadowOffset = new Vector2(1f, 1f);
|
|
var shadowColor = new Vector4(0f, 0f, 0f, 0.4f * alpha);
|
|
drawList.AddRectFilled(
|
|
windowPos + shadowOffset,
|
|
windowPos + windowSize + shadowOffset,
|
|
ImGui.ColorConvertFloat4ToU32(shadowColor),
|
|
3f
|
|
);
|
|
}
|
|
|
|
private void HandleClickToDismiss(LightlessNotification notification)
|
|
{
|
|
if (ImGui.IsWindowHovered() &&
|
|
_configService.Current.DismissNotificationOnClick &&
|
|
!notification.Actions.Any() &&
|
|
ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
notification.IsDismissed = true;
|
|
StartOutAnimation(notification);
|
|
}
|
|
}
|
|
|
|
private void DrawBackground(ImDrawListPtr drawList, Vector2 windowPos, Vector2 windowSize, Vector4 bgColor)
|
|
{
|
|
drawList.AddRectFilled(
|
|
windowPos,
|
|
windowPos + windowSize,
|
|
ImGui.ColorConvertFloat4ToU32(bgColor),
|
|
3f
|
|
);
|
|
}
|
|
|
|
private void DrawAccentBar(ImDrawListPtr drawList, Vector2 windowPos, Vector2 windowSize, Vector4 accentColor)
|
|
{
|
|
var accentWidth = _configService.Current.NotificationAccentBarWidth;
|
|
if (accentWidth > 0f)
|
|
{
|
|
drawList.AddRectFilled(
|
|
windowPos,
|
|
windowPos + new Vector2(accentWidth, windowSize.Y),
|
|
ImGui.ColorConvertFloat4ToU32(accentColor),
|
|
3f
|
|
);
|
|
}
|
|
}
|
|
|
|
private void DrawDurationProgressBar(LightlessNotification notification, float alpha, Vector2 windowPos, Vector2 windowSize, ImDrawListPtr drawList)
|
|
{
|
|
var progress = CalculateProgress(notification);
|
|
var progressBarColor = UIColors.Get("LightlessBlue");
|
|
var progressHeight = 2f;
|
|
var progressY = windowPos.Y + windowSize.Y - progressHeight;
|
|
var progressWidth = windowSize.X * progress;
|
|
|
|
DrawProgressBackground(drawList, windowPos, windowSize, progressY, progressHeight, progressBarColor, alpha);
|
|
|
|
if (progress > 0)
|
|
{
|
|
DrawProgressForeground(drawList, windowPos, progressY, progressHeight, progressWidth, progressBarColor, alpha);
|
|
}
|
|
}
|
|
|
|
private float CalculateProgress(LightlessNotification notification)
|
|
{
|
|
if (notification.Type == NotificationType.Download && notification.ShowProgress)
|
|
{
|
|
return Math.Clamp(notification.Progress, 0f, 1f);
|
|
}
|
|
|
|
var elapsed = DateTime.UtcNow - notification.CreatedAt;
|
|
return Math.Min(1.0f, (float)(elapsed.TotalSeconds / notification.Duration.TotalSeconds));
|
|
}
|
|
|
|
private void DrawProgressBackground(ImDrawListPtr drawList, Vector2 windowPos, Vector2 windowSize, float progressY, float progressHeight, Vector4 progressBarColor, float alpha)
|
|
{
|
|
var bgProgressColor = new Vector4(progressBarColor.X * 0.3f, progressBarColor.Y * 0.3f, progressBarColor.Z * 0.3f, 0.5f * alpha);
|
|
drawList.AddRectFilled(
|
|
new Vector2(windowPos.X, progressY),
|
|
new Vector2(windowPos.X + windowSize.X, progressY + progressHeight),
|
|
ImGui.ColorConvertFloat4ToU32(bgProgressColor),
|
|
0f
|
|
);
|
|
}
|
|
|
|
private void DrawProgressForeground(ImDrawListPtr drawList, Vector2 windowPos, float progressY, float progressHeight, float progressWidth, Vector4 progressBarColor, float alpha)
|
|
{
|
|
var progressColor = progressBarColor;
|
|
progressColor.W *= alpha;
|
|
drawList.AddRectFilled(
|
|
new Vector2(windowPos.X, progressY),
|
|
new Vector2(windowPos.X + progressWidth, progressY + progressHeight),
|
|
ImGui.ColorConvertFloat4ToU32(progressColor),
|
|
0f
|
|
);
|
|
}
|
|
|
|
private void DrawNotificationText(LightlessNotification notification, float alpha)
|
|
{
|
|
var padding = new Vector2(10f, 6f);
|
|
var contentPos = new Vector2(padding.X, padding.Y);
|
|
var windowSize = ImGui.GetWindowSize();
|
|
var contentSize = new Vector2(windowSize.X - padding.X, windowSize.Y - padding.Y * 2);
|
|
|
|
ImGui.SetCursorPos(contentPos);
|
|
|
|
var titleHeight = DrawTitle(notification, contentSize.X, alpha);
|
|
DrawMessage(notification, contentPos, contentSize.X, titleHeight, alpha);
|
|
|
|
if (notification.Actions.Count > 0)
|
|
{
|
|
ImGui.SetCursorPosY(ImGui.GetCursorPosY() + ImGui.GetStyle().ItemSpacing.Y);
|
|
ImGui.SetCursorPosX(contentPos.X);
|
|
DrawNotificationActions(notification, contentSize.X, alpha);
|
|
}
|
|
}
|
|
|
|
private float DrawTitle(LightlessNotification notification, float contentWidth, float alpha)
|
|
{
|
|
using (ImRaii.PushColor(ImGuiCol.Text, new Vector4(1f, 1f, 1f, alpha)))
|
|
{
|
|
ImGui.PushTextWrapPos(ImGui.GetCursorPosX() + contentWidth);
|
|
var titleStartY = ImGui.GetCursorPosY();
|
|
|
|
var titleText = _configService.Current.ShowNotificationTimestamp
|
|
? $"[{notification.CreatedAt.ToLocalTime():HH:mm:ss}] {notification.Title}"
|
|
: notification.Title;
|
|
|
|
ImGui.TextWrapped(titleText);
|
|
var titleHeight = ImGui.GetCursorPosY() - titleStartY;
|
|
ImGui.PopTextWrapPos();
|
|
return titleHeight;
|
|
}
|
|
}
|
|
|
|
private void DrawMessage(LightlessNotification notification, Vector2 contentPos, float contentWidth, float titleHeight, float alpha)
|
|
{
|
|
if (string.IsNullOrEmpty(notification.Message)) return;
|
|
|
|
ImGui.SetCursorPos(contentPos + new Vector2(0f, titleHeight + 4f));
|
|
ImGui.PushTextWrapPos(ImGui.GetCursorPosX() + contentWidth);
|
|
using (ImRaii.PushColor(ImGuiCol.Text, new Vector4(0.9f, 0.9f, 0.9f, alpha)))
|
|
{
|
|
ImGui.TextWrapped(notification.Message);
|
|
}
|
|
ImGui.PopTextWrapPos();
|
|
}
|
|
|
|
private void DrawNotificationActions(LightlessNotification notification, float availableWidth, float alpha)
|
|
{
|
|
var buttonSpacing = 8f;
|
|
var rightPadding = 10f;
|
|
var usableWidth = availableWidth - rightPadding;
|
|
var totalSpacing = (notification.Actions.Count - 1) * buttonSpacing;
|
|
var buttonWidth = (usableWidth - totalSpacing) / notification.Actions.Count;
|
|
|
|
_logger.LogDebug("Drawing {ActionCount} notification actions, buttonWidth: {ButtonWidth}, availableWidth: {AvailableWidth}",
|
|
notification.Actions.Count, buttonWidth, availableWidth);
|
|
|
|
var startCursorPos = ImGui.GetCursorPos();
|
|
|
|
for (int i = 0; i < notification.Actions.Count; i++)
|
|
{
|
|
var action = notification.Actions[i];
|
|
|
|
if (i > 0)
|
|
{
|
|
ImGui.SameLine();
|
|
var currentX = startCursorPos.X + i * (buttonWidth + buttonSpacing);
|
|
ImGui.SetCursorPosX(currentX);
|
|
}
|
|
DrawActionButton(action, notification, alpha, buttonWidth);
|
|
}
|
|
}
|
|
|
|
private void DrawActionButton(LightlessNotificationAction action, LightlessNotification notification, float alpha, float buttonWidth)
|
|
{
|
|
_logger.LogDebug("Drawing action button: {ActionId} - {ActionLabel}, width: {ButtonWidth}", action.Id, action.Label, buttonWidth);
|
|
|
|
var buttonColor = action.Color;
|
|
buttonColor.W *= alpha;
|
|
|
|
var hoveredColor = buttonColor * 1.1f;
|
|
hoveredColor.W = buttonColor.W;
|
|
|
|
var activeColor = buttonColor * 0.9f;
|
|
activeColor.W = buttonColor.W;
|
|
|
|
using (ImRaii.PushColor(ImGuiCol.Button, buttonColor))
|
|
using (ImRaii.PushColor(ImGuiCol.ButtonHovered, hoveredColor))
|
|
using (ImRaii.PushColor(ImGuiCol.ButtonActive, activeColor))
|
|
using (ImRaii.PushColor(ImGuiCol.Text, new Vector4(1f, 1f, 1f, alpha)))
|
|
{
|
|
var buttonPressed = false;
|
|
|
|
if (action.Icon != FontAwesomeIcon.None)
|
|
{
|
|
buttonPressed = DrawIconTextButton(action.Icon, action.Label, buttonWidth, alpha);
|
|
}
|
|
else
|
|
{
|
|
buttonPressed = ImGui.Button(action.Label, new Vector2(buttonWidth, 0));
|
|
}
|
|
|
|
_logger.LogDebug("Button {ActionId} pressed: {ButtonPressed}", action.Id, buttonPressed);
|
|
|
|
if (buttonPressed)
|
|
{
|
|
try
|
|
{
|
|
_logger.LogDebug("Executing action: {ActionId}", action.Id);
|
|
action.OnClick(notification);
|
|
_logger.LogDebug("Action executed successfully: {ActionId}", action.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error executing notification action: {ActionId}", action.Id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool DrawIconTextButton(FontAwesomeIcon icon, string text, float width, float alpha)
|
|
{
|
|
var drawList = ImGui.GetWindowDrawList();
|
|
var cursorPos = ImGui.GetCursorScreenPos();
|
|
var frameHeight = ImGui.GetFrameHeight();
|
|
|
|
Vector2 iconSize;
|
|
using (ImRaii.PushFont(UiBuilder.IconFont))
|
|
{
|
|
iconSize = ImGui.CalcTextSize(icon.ToIconString());
|
|
}
|
|
|
|
var textSize = ImGui.CalcTextSize(text);
|
|
var spacing = 3f * ImGuiHelpers.GlobalScale;
|
|
var totalTextWidth = iconSize.X + spacing + textSize.X;
|
|
|
|
var buttonPressed = ImGui.InvisibleButton($"btn_{icon}_{text}", new Vector2(width, frameHeight));
|
|
|
|
var buttonMin = ImGui.GetItemRectMin();
|
|
var buttonMax = ImGui.GetItemRectMax();
|
|
var buttonSize = buttonMax - buttonMin;
|
|
|
|
var buttonColor = ImGui.GetColorU32(ImGuiCol.Button);
|
|
if (ImGui.IsItemHovered())
|
|
buttonColor = ImGui.GetColorU32(ImGuiCol.ButtonHovered);
|
|
if (ImGui.IsItemActive())
|
|
buttonColor = ImGui.GetColorU32(ImGuiCol.ButtonActive);
|
|
|
|
drawList.AddRectFilled(buttonMin, buttonMax, buttonColor, 3f);
|
|
|
|
var iconPos = buttonMin + new Vector2((buttonSize.X - totalTextWidth) / 2f, (buttonSize.Y - iconSize.Y) / 2f);
|
|
var textPos = iconPos + new Vector2(iconSize.X + spacing, (iconSize.Y - textSize.Y) / 2f);
|
|
|
|
var textColor = ImGui.GetColorU32(ImGuiCol.Text);
|
|
|
|
// Draw icon
|
|
using (ImRaii.PushFont(UiBuilder.IconFont))
|
|
{
|
|
drawList.AddText(iconPos, textColor, icon.ToIconString());
|
|
}
|
|
|
|
// Draw text
|
|
drawList.AddText(textPos, textColor, text);
|
|
|
|
return buttonPressed;
|
|
}
|
|
|
|
private float CalculateNotificationHeight(LightlessNotification notification)
|
|
{
|
|
var contentWidth = _configService.Current.NotificationWidth - 35f;
|
|
var height = 12f;
|
|
|
|
height += CalculateTitleHeight(notification, contentWidth);
|
|
height += CalculateMessageHeight(notification, contentWidth);
|
|
|
|
if (notification.ShowProgress)
|
|
{
|
|
height += 12f;
|
|
}
|
|
|
|
if (notification.Actions.Count > 0)
|
|
{
|
|
height += ImGui.GetStyle().ItemSpacing.Y;
|
|
height += ImGui.GetFrameHeight();
|
|
height += 12f;
|
|
}
|
|
|
|
return Math.Clamp(height, NotificationMinHeight, NotificationMaxHeight);
|
|
}
|
|
|
|
private float CalculateTitleHeight(LightlessNotification notification, float contentWidth)
|
|
{
|
|
var titleText = _configService.Current.ShowNotificationTimestamp
|
|
? $"[{notification.CreatedAt.ToLocalTime():HH:mm:ss}] {notification.Title}"
|
|
: notification.Title;
|
|
|
|
return ImGui.CalcTextSize(titleText, true, contentWidth).Y;
|
|
}
|
|
|
|
private float CalculateMessageHeight(LightlessNotification notification, float contentWidth)
|
|
{
|
|
if (string.IsNullOrEmpty(notification.Message)) return 0f;
|
|
|
|
var messageHeight = ImGui.CalcTextSize(notification.Message, true, contentWidth).Y;
|
|
return 4f + messageHeight;
|
|
}
|
|
|
|
private Vector4 GetNotificationAccentColor(NotificationType type)
|
|
{
|
|
return type switch
|
|
{
|
|
NotificationType.Info => UIColors.Get("LightlessPurple"),
|
|
NotificationType.Warning => UIColors.Get("LightlessYellow"),
|
|
NotificationType.Error => UIColors.Get("DimRed"),
|
|
NotificationType.PairRequest => UIColors.Get("LightlessBlue"),
|
|
NotificationType.Download => UIColors.Get("LightlessGreen"),
|
|
_ => UIColors.Get("LightlessPurple")
|
|
};
|
|
}
|
|
} |