feat: Update assets for new Millennium version, and fix some UX issues

Author: shdwmtr

src/animate.cc

@@ -37,6 +37,7 @@
 #include <imgui.h>
 #include <memory>
 #include <dpi.h>
+#include <mutex>
 
 /** Based on https://stackoverflow.com/questions/13462001/ease-in-and-ease-out-animation-formula */
 float EaseInOut(float t)
@@ -46,7 +47,7 @@ float EaseInOut(float t)
 
 float EaseInOutFloat(const std::string& id, float lowerBound, float upperBound, bool currentState, float duration)
 {
-    struct AnimationState
+    struct FloatAnimationState
     {
         bool wasHovered = false;
         bool isAnimating = false;
@@ -59,23 +60,26 @@ float EaseInOutFloat(const std::string& id, float lowerBound, float upperBound,
 
         float lastXDPI = XDPI, lastYDPI = YDPI;
 
-        AnimationState() = default;
-        AnimationState(float lower, float upper)
+        FloatAnimationState() = default;
+        FloatAnimationState(float lower, float upper)
             : wasHovered(false), isAnimating(false), isReversing(false), elapsedTime(0.0f), currentValue(lower), minValue(lower), maxValue(upper)
         {
         }
     };
 
-    static std::unordered_map<std::string, AnimationState> animations;
+    static std::unordered_map<std::string, FloatAnimationState> animations;
+    static std::mutex animationsMutex;
+
+    std::lock_guard<std::mutex> lock(animationsMutex);
 
     auto it = animations.find(id);
     if (it == animations.end()) {
-        animations[id] = AnimationState(lowerBound, upperBound);
+        animations[id] = FloatAnimationState(lowerBound, upperBound);
         animations[id].currentValue = currentState ? upperBound : lowerBound;
         animations[id].wasHovered = currentState;
     }
 
-    AnimationState& state = animations[id];
+    FloatAnimationState& state = animations[id];
 
     float deltaTime = ImGui::GetIO().DeltaTime;
 
@@ -119,6 +123,9 @@ float EaseInOutFloat(const std::string& id, float lowerBound, float upperBound,
 float SmoothFloat(const std::string& id, float targetOffset, bool currentState, float displacement, float duration, std::tuple<float, float> colorTransition)
 {
     static std::unordered_map<std::string, AnimationState> animations;
+    static std::mutex animationsMutex;
+
+    std::lock_guard<std::mutex> lock(animationsMutex);
 
     const auto [lowerBound, upperBound] = colorTransition;
     AnimationState& state = animations[id];

src/components/message.cc

@@ -63,7 +63,10 @@ void ShowMessageBox(std::string title, std::string body, MessageLevel level)
  */
 void RenderMessageBoxes()
 {
+    static bool isClosing = false;
+
     if (messageBoxQueue.size() <= 0) {
+        isClosing = false;
         return;
     }
 
@@ -81,15 +84,25 @@ void RenderMessageBoxes()
     static const float scrollFriction = 0.95f;
     static const float minVelocityThreshold = 0.01f;
 
-    float opacityAnimation = EaseInOutFloat("MessageAlertPopupAnimation", 0.f, 1.f, true, 0.3f);
+    float opacityAnimation = EaseInOutFloat("MessageAlertPopupAnimation", 0.f, 1.f, !isClosing, 0.3f);
+
+    // When fade-out animation completes, actually close the popup
+    if (isClosing && opacityAnimation <= 0.01f) {
+        CloseCurrentPopup();
+        messageBoxQueue.pop();
+        isClosing = false;
+        hasSkippedFirstFrame = false;
+        scrollPosition = 0.0f;
+        scrollVelocity = 0.0f;
+    }
 
-    PushStyleColor(ImGuiCol_PopupBg, ImVec4(0.098f, 0.102f, 0.11f, 1.0f));
-    PushStyleColor(ImGuiCol_Border, ImVec4(0.48f, 0.484f, 0.492f, 0.5f));
+    PushStyleColor(ImGuiCol_PopupBg, ImVec4(0.067f, 0.071f, 0.078f, 1.0f));
+    PushStyleColor(ImGuiCol_Border, ImVec4(0.48f, 0.484f, 0.492f, 0.3f));
     PushStyleVar(ImGuiStyleVar_Alpha, opacityAnimation);
     PushStyleVar(ImGuiStyleVar_WindowRounding, ScaleX(10.0f));
     PushStyleVar(ImGuiStyleVar_WindowBorderSize, ScaleX(1.0f));
 
-    SetNextWindowSizeConstraints(ImVec2(ScaleX(500), 0), ImVec2(ScaleX(700), FLT_MAX));
+    SetNextWindowSizeConstraints(ImVec2(ScaleX(650), 0), ImVec2(ScaleX(900), FLT_MAX));
 
     if (BeginPopupModal("MessageAlertPopup", nullptr,
                         ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove |
@@ -120,9 +133,7 @@ void RenderMessageBoxes()
 
         TextWrapped(currentBox.title.c_str());
         PopFont();
-        SetCursorPosY(GetCursorPosY() + ScaleY(15));
-        Separator();
-        SetCursorPosY(GetCursorPosY() + ScaleY(20));
+        SetCursorPosY(GetCursorPosY() + ScaleY(25));
 
         TextWrapped(currentBox.body.c_str());
 
@@ -134,25 +145,28 @@ void RenderMessageBoxes()
 
         SetScrollY(scrollPosition);
         if (hasSkippedFirstFrame && !ImGui::IsWindowHovered() && ImGui::IsMouseClicked(0)) {
-            CloseCurrentPopup();
-            messageBoxQueue.pop();
+            isClosing = true;
         }
         hasSkippedFirstFrame = true;
 
         SetCursorPosY(GetCursorPosY() + ScaleY(40));
 
         PushStyleColor(ImGuiCol_Button, ImVec4(1.f, 1.f, 1.f, 1.f));
         PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.f, 1.f, 1.f, 1.f));
+        PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.9f, 0.9f, 0.9f, 1.f));
         PushStyleColor(ImGuiCol_Text, ImVec4(0.f, 0.f, 0.f, 1.f));
 
         SetCursorPosX(GetCursorPosX() + GetContentRegionAvail().x - ScaleX(140));
 
         if (Button("Continue", ImVec2(ScaleX(140), ScaleY(50)))) {
-            CloseCurrentPopup();
-            messageBoxQueue.pop();
+            isClosing = true;
+        }
+
+        if (IsItemHovered()) {
+            SetMouseCursor(ImGuiMouseCursor_Hand);
         }
 
-        PopStyleColor(3);
+        PopStyleColor(4);
         EndPopup();
     }
 

src/renderer.cc

@@ -69,10 +69,10 @@ void RenderImGui(GLFWwindow* window, std::shared_ptr<RouterNav> router)
         SameLine();
         currentPanel(router, xOffsetCurrent);
 
-        // if (IsKeyPressed(ImGuiKey_MouseX1)) {
-        //     if (router->canGoBack())
-        //         router->navigateBack();
-        // }
+        if (IsKeyPressed(ImGuiKey_MouseX1)) {
+            if (router->canGoBack())
+                router->navigateBack();
+        }
         // if (IsKeyPressed(ImGuiKey_MouseX2)) {
         //     if (router->canGoForward())
         //         router->navigateNext();

src/routes/installer.cc

@@ -282,6 +282,8 @@ const void RenderInstaller(std::shared_ptr<RouterNav> router, float xPos)
     static float currentY = startY;
     static bool shouldAnimate = false;
     static bool shouldRenderCompleteModal = false;
+    static bool isWaitingForProgressComplete = false;
+    static auto progressCompleteTime = std::chrono::steady_clock::now();
 
     static auto animationStartTime = std::chrono::steady_clock::now();
 
@@ -338,14 +340,33 @@ const void RenderInstaller(std::shared_ptr<RouterNav> router, float xPos)
     }
 
     if (hasTaskSchedulerFinished.load()) {
-        shouldAnimate = true;
-        shouldRenderCompleteModal = true;
-        animationStartTime = std::chrono::steady_clock::now();
-
-        /** Reset the flag so it doesn't restart the animation each frame */
+        isWaitingForProgressComplete = true;
+        /** Reset the flag so it doesn't restart each frame */
         hasTaskSchedulerFinished.store(false);
     }
 
+    /** Wait for progress bar animation to complete, then wait 0.5 seconds before showing the complete modal */
+    if (isWaitingForProgressComplete && !shouldRenderCompleteModal) {
+        if (easedProgress >= 0.99f) {
+            static bool timerStarted = false;
+            if (!timerStarted) {
+                progressCompleteTime = std::chrono::steady_clock::now();
+                timerStarted = true;
+            }
+            
+            auto now = std::chrono::steady_clock::now();
+            float elapsedTime = std::chrono::duration<float>(now - progressCompleteTime).count();
+            
+            if (elapsedTime >= 0.5f) {
+                shouldAnimate = true;
+                shouldRenderCompleteModal = true;
+                animationStartTime = std::chrono::steady_clock::now();
+                isWaitingForProgressComplete = false;
+                timerStarted = false;
+            }
+        }
+    }
+
     static const float ANIMATION_DURATION = 0.3f;
 
     if (shouldAnimate) {

src/routes/uninstall_select.cc

@@ -122,6 +122,8 @@ void InitializeUninstaller()
             steamPath / "version.dll", 
             steamPath / "ext" / "compat32" / "millennium_x86.dll", 
             steamPath / "ext" / "compat32" / "python311.dll", 
+            steamPath / "ext" / "compat64" / "millennium_x64.dll", 
+            steamPath / "ext" / "compat64" / "python311.dll", 
             steamPath / "millennium.hhx64.dll", 
             steamPath / "millennium.dll", 
             steamPath / "python311.dll" 
@@ -139,6 +141,9 @@ void InitializeUninstaller()
 
 void StartUninstall()
 {
+    /** Kill Steam before uninstalling */
+    KillSteamProcess();
+
     /** Render all selected components as uninstalling */
     std::for_each(uninstallComponents.begin(), uninstallComponents.end(), [](auto& pair)
     {
@@ -152,6 +157,12 @@ void StartUninstall()
         if (state.isSelected) {
             std::this_thread::sleep_for(std::chrono::milliseconds(300));
 
+            /** If the path list is empty, the component is already uninstalled */
+            if (props.pathList.empty()) {
+                state.uninstallState.state = ComponentState::UninstallState::Success;
+                continue;
+            }
+
             for (const auto& path : props.pathList) {
                 std::error_code ec;
                 std::filesystem::remove_all(path, ec); // Remove the path