Merge #7210: feat: modernize launch splash

3d45e61 qt: cache translated splash phase labels (UdjinM6)
80fa525 qt: simplify splash fallback progress state (UdjinM6)
b0013af qt: show real wallet rescan progress on startup (UdjinM6)
6a056f4 feat(qt): add phase-based progress bar to splash screen (pasta)
d8f33d2 feat(qt): modernize splash screen with rounded corners and refined layout (pasta)

Pull request description:

  ## Issue being fixed or feature implemented
  - Modernize the splash screen visual design and add a progress bar so users have feedback on initialization progress instead of only a static status message.

  ### Old
  <img width="426" height="506" alt="Screenshot 2026-03-11 at 23 24 23" src="https://github.com/user-attachments/assets/d028ad86-499c-445f-9a50-031cae2b54cb" />

  ### New

  https://github.com/user-attachments/assets/aebe03dd-5484-445b-b4e4-0ffb7e57c26e

  ## What was done?

  **Commit 1: Visual modernization**
  - Replaced the flat rectangular splash with a modern card-style design featuring rounded corners and a translucent background
  - Redesigned layout: smaller centered logo, refined typography (28pt title, 12pt version), subtle text opacity
  - Replaced the rectangular network badge with a pill-shaped rounded badge
  - Added canvas padding around the card for compositor-based visual separation
  - Scoped `QPainter` lifetime to release the pixmap before timer/signal setup

  **Commit 2: Phase-based progress bar**
  - Added a thin progress bar at the bottom of the splash card that tracks init phases
  - Built a phase weight table mapping init messages to progress ranges (e.g., "Loading block index…" = 3–75%)
  - Phases with `ShowProgress` callbacks (block verification, replaying, rescanning) interpolate linearly within their range
  - Phases without sub-progress use exponential time-based fill (slow curve for long phases like rescan)
  - "Verifying wallet(s)…" and "Loading wallet…" are batched as a single bar (verify = 0–20%, load = 20–100%)
  - "Rescanning…" resets the bar and uses a very slow exponential curve (tau=120s) appropriate for operations that can take hours
  - Snaps to 100% on "Done loading" since the splash is destroyed immediately after
  - Phase lookup translates keys via `_()` at runtime so matching works in all locales
  - `messageColor` is `const` and captured by value in signal lambdas for thread-safe cross-thread callbacks
  - Animation timer deferred until first message arrives to avoid idle repaints

  ## How Has This Been Tested?
  - Manual testing on macOS: verified splash screen appearance, progress bar animation through full startup sequence including wallet verification and loading
  - Verified progress bar behavior with `--rescan` flag (bar resets and uses slow curve)
  - Confirmed "Done loading" snaps bar to 100% before splash dismissal
  - Verified no regressions in testnet/devnet badge rendering

  ## Breaking Changes
  None. Visual-only changes to the splash screen with no impact on consensus, RPC, or wallet behavior.

  ## Checklist:
  - [x] I have performed a self-review of my own code
  - [x] I have commented my code, particularly in hard-to-understand areas
  - [ ] I have added or updated relevant unit/integration/functional/e2e tests
  - [ ] I have made corresponding changes to the documentation
  - [ ] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_

Top commit has no ACKs.

Tree-SHA512: d29656d57435f1ba166b0db458097d594a687775b47520abfa0bd221850feed3dc32cfcdb13941038c30e4b4a71cd4d2954fcc8f00814d749b7ffa4a9cd8a6b7

Author: PastaPastaPasta

src/interfaces/wallet.h

@@ -407,6 +407,11 @@ class WalletLoader : public ChainClient
     using LoadWalletFn = std::function<void(std::unique_ptr<Wallet> wallet)>;
     virtual std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) = 0;
 
+    //! Register handler for wallet-loading messages. This callback is triggered
+    //! after a wallet object exists and can emit progress, but before startup
+    //! load work like AttachChain()/rescan necessarily completes.
+    virtual std::unique_ptr<Handler> handleLoadWalletLoading(LoadWalletFn fn) = 0;
+
     //! Return pointer to internal context, useful for testing.
     virtual wallet::WalletContext* context() { return nullptr; }
 };

src/qt/splashscreen.cpp

@@ -5,6 +5,8 @@
 #ifndef BITCOIN_QT_SPLASHSCREEN_H
 #define BITCOIN_QT_SPLASHSCREEN_H
 
+#include <QElapsedTimer>
+#include <QTimer>
 #include <QWidget>
 
 #include <memory>
@@ -40,8 +42,11 @@ public Q_SLOTS:
     /** Show message and progress */
     void showMessage(const QString &message, int alignment, const QColor &color);
 
-    /** Handle wallet load notifications. */
-    void handleLoadWallet();
+    /** Set progress bar value (-1 = no sub-progress, 0-100 = phase sub-progress) */
+    void setProgress(int value);
+
+    /** Handle early wallet-loading notifications so startup progress can be observed. */
+    void handleLoadingWallet();
 
 protected:
     bool eventFilter(QObject * obj, QEvent * ev) override;
@@ -53,18 +58,33 @@ public Q_SLOTS:
     void unsubscribeFromCoreSignals();
     /** Initiate shutdown */
     void shutdown();
+    /** Calculate overall progress (0.0-1.0) based on current phase and sub-progress */
+    qreal calcOverallProgress() const;
 
     QPixmap pixmap;
+    /** Cached on GUI thread at construction for thread-safe use in cross-thread callbacks.
+     *  Const after construction — no synchronization needed. */
+    const QColor messageColor;
     QString curMessage;
     QColor curColor;
     int curAlignment{0};
+    int curProgress{-1};
+
+    // Phase-based progress tracking
+    qreal phaseStart{0.0};      // Overall progress at start of current phase
+    qreal phaseEnd{0.0};        // Overall progress at end of current phase
+    QElapsedTimer phaseTimer;    // Time since current phase started
+    const struct PhaseInfo* m_current_phase{nullptr}; // Current phase (defined in splashscreen.cpp)
+    QString m_current_phase_message;                   // Message that triggered current phase
+    qreal displayProgress{0.0}; // Smoothly animated display value (0.0-1.0)
+    QTimer animTimer;
 
     interfaces::Node* m_node = nullptr;
     bool m_shutdown = false;
     std::unique_ptr<interfaces::Handler> m_handler_init_message;
     std::unique_ptr<interfaces::Handler> m_handler_show_progress;
     std::unique_ptr<interfaces::Handler> m_handler_init_wallet;
-    std::unique_ptr<interfaces::Handler> m_handler_load_wallet;
+    std::unique_ptr<interfaces::Handler> m_handler_loading_wallet;
     std::list<std::unique_ptr<interfaces::Wallet>> m_connected_wallets;
     std::list<std::unique_ptr<interfaces::Handler>> m_connected_wallet_handlers;
 };

src/qt/splashscreen.h

@@ -46,6 +46,7 @@ struct WalletContext {
     // this could introduce inconsistent lock ordering and cause deadlocks.
     Mutex wallets_mutex;
     std::vector<std::shared_ptr<CWallet>> wallets GUARDED_BY(wallets_mutex);
+    std::list<LoadWalletFn> wallet_loading_fns GUARDED_BY(wallets_mutex);
     std::list<LoadWalletFn> wallet_load_fns GUARDED_BY(wallets_mutex);
     interfaces::CoinJoin::Loader* coinjoin_loader{nullptr};
     // Some Dash RPCs rely on WalletContext yet access NodeContext members

src/wallet/context.h

@@ -810,6 +810,10 @@ class WalletLoaderImpl : public WalletLoader
     {
         return HandleLoadWallet(m_context, std::move(fn));
     }
+    std::unique_ptr<Handler> handleLoadWalletLoading(LoadWalletFn fn) override
+    {
+        return HandleLoadWalletLoading(m_context, std::move(fn));
+    }
     WalletContext* context() override  { return &m_context; }
 
     WalletContext m_context;

src/wallet/interfaces.cpp

@@ -193,6 +193,21 @@ std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, Lo
     return interfaces::MakeHandler([&context, it] { LOCK(context.wallets_mutex); context.wallet_load_fns.erase(it); });
 }
 
+std::unique_ptr<interfaces::Handler> HandleLoadWalletLoading(WalletContext& context, LoadWalletFn load_wallet)
+{
+    LOCK(context.wallets_mutex);
+    auto it = context.wallet_loading_fns.emplace(context.wallet_loading_fns.end(), std::move(load_wallet));
+    return interfaces::MakeHandler([&context, it] { LOCK(context.wallets_mutex); context.wallet_loading_fns.erase(it); });
+}
+
+void NotifyWalletLoading(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
+{
+    LOCK(context.wallets_mutex);
+    for (auto& load_wallet : context.wallet_loading_fns) {
+        load_wallet(interfaces::MakeWallet(context, wallet));
+    }
+}
+
 void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet)
 {
     LOCK(context.wallets_mutex);
@@ -3282,6 +3297,8 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
     // Try to top up keypool. No-op if the wallet is locked.
     walletInstance->TopUpKeyPool();
 
+    NotifyWalletLoading(context, walletInstance);
+
     if (chain && !AttachChain(walletInstance, *chain, error, warnings)) {
         walletInstance->m_chain_notifications_handler.reset(); // Reset this pointer so that the wallet will actually be unloaded
         return nullptr;

src/wallet/wallet.cpp

@@ -76,7 +76,9 @@ std::shared_ptr<CWallet> GetWallet(WalletContext& context, const std::string& na
 std::shared_ptr<CWallet> LoadWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
 std::shared_ptr<CWallet> CreateWallet(WalletContext& context, const std::string& name, std::optional<bool> load_on_start, DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
 std::shared_ptr<CWallet> RestoreWallet(WalletContext& context, const fs::path& backup_file, const std::string& wallet_name, std::optional<bool> load_on_start, DatabaseStatus& status, bilingual_str& error, std::vector<bilingual_str>& warnings);
+std::unique_ptr<interfaces::Handler> HandleLoadWalletLoading(WalletContext& context, LoadWalletFn load_wallet);
 std::unique_ptr<interfaces::Handler> HandleLoadWallet(WalletContext& context, LoadWalletFn load_wallet);
+void NotifyWalletLoading(WalletContext& context, const std::shared_ptr<CWallet>& wallet);
 void NotifyWalletLoaded(WalletContext& context, const std::shared_ptr<CWallet>& wallet);
 std::unique_ptr<WalletDatabase> MakeWalletDatabase(const std::string& name, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error);