Replace modal dialogs with in-window pages and make binding async

UI navigation
- MainWindow hosts a QStackedWidget with Dashboard, Connections, and
  Pairing pages instead of stacking modal QDialogs. Each non-dashboard
  page has a Back button and tracks its return target so pairing
  returns to the page that launched it.
- New ErrorBanner widget styled with Theme::error (matches dish-mac and
  dish-android colorError #E74C3C) replaces QMessageBox; sits below the
  stack so it appears at the bottom of every page.
- Connections page disables Connect/Forget until something is selected,
  and shows an indeterminate progress bar while scanning.
- Pairing page accepts a 4-digit PIN (matching dialog_pairing.xml),
  disables Pair until the input is complete, and shows a spinner during
  the async pair attempt with errors surfaced inline.
- Spinners use setRetainSizeWhenHidden so showing/hiding them doesn't
  shift the rest of the layout.

Async controller registration
- WifiConnection::registerController no longer blocks the main thread
  with QThread::msleep. A QTimer polls lastControllerAck_ for up to 2 s
  and decodes the result byte from MSG_CONTROLLER_ACK.
- New errorOccurred and registrationFailed signals surface ack codes
  (BACKEND_UNAVAIL, NO_SLOTS, ALREADY_EXISTS, PLUGIN_FAIL, timeout) as
  human-readable messages via the error banner.
- ConnectionHub auto-unbinds when registrationFailed fires, so the
  local UI rolls back when the server rejects a controller add.
- AppModel exposes a busy flag aggregated from all WifiConnections; the
  dashboard shows an indeterminate spinner while any registration is in
  flight.

Theme + icon
- QPushButton#primary:disabled now uses Theme::surfaceDim + muted text
  so disabled primary buttons read as inactive instead of identical to
  active ones.
- QProgressBar + ::chunk styled with Theme::primary so indeterminate
  bars actually animate under the custom stylesheet.
- Icon SVG bundled in the binary via resources/icons.qrc; main.cpp
  calls QGuiApplication::setWindowIcon for the in-binary case.

Cleanup
- Removed the unused virtual-controller slot, SlotInputType enum, and
  kVirtualSlotId constant.
- Removed the telemetry footer plus TelemetrySnapshot / drainTelemetry
  / counter fields on GamepadInputProcessor; the test that exercised
  them is gone too.
- SlotCard's Unbind button is enabled when bound (was incorrectly tied
  to "available" connections being non-empty).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 2 people

CMakeLists.txt

@@ -120,12 +120,15 @@ set(DISH_UI_SOURCES
     src/UI/Theme.cpp
     src/UI/SlotCard.h
     src/UI/SlotCard.cpp
-    src/UI/PairingDialog.h
-    src/UI/PairingDialog.cpp
-    src/UI/ConnectionsDialog.h
-    src/UI/ConnectionsDialog.cpp
+    src/UI/PairingPage.h
+    src/UI/PairingPage.cpp
+    src/UI/ConnectionsPage.h
+    src/UI/ConnectionsPage.cpp
+    src/UI/ErrorBanner.h
+    src/UI/ErrorBanner.cpp
     src/UI/MainWindow.h
     src/UI/MainWindow.cpp
+    resources/icons.qrc
     src/main.cpp)
 
 add_executable(Dish ${DISH_UI_SOURCES})

resources/icons.qrc

@@ -0,0 +1,5 @@
+<RCC>
+  <qresource prefix="/icons">
+    <file alias="dish.svg">../packaging/dish.svg</file>
+  </qresource>
+</RCC>

src/AppModel.cpp

@@ -80,15 +80,9 @@ void AppModel::onWifiEvent(const net::ConnectionEvent& evt) {
 
 void AppModel::rebuild() {
     QList<models::ControllerSlot> next;
-    models::ControllerSlot virt;
-    virt.id = QString::fromLatin1(models::kVirtualSlotId);
-    virt.inputType = models::SlotInputType::Virtual;
-    virt.name = QStringLiteral("Virtual Controller");
-    next.append(virt);
     for (const auto& d : bridge_->devices()) {
         models::ControllerSlot s;
         s.id = d.id;
-        s.inputType = models::SlotInputType::Physical;
         s.name = d.name;
         s.physicalDeviceId = d.id;
         next.append(s);
@@ -105,6 +99,15 @@ void AppModel::rebuild() {
     }
     state_.slotList = std::move(next);
 
+    bool busy = false;
+    for (auto* conn : wifi_->connections()) {
+        if (conn->isRegisteringController()) {
+            busy = true;
+            break;
+        }
+    }
+    state_.busy = busy;
+
     // Update the routing table to mirror the new slot/binding shape.
     QHash<QString, net::ConnectionHub::ReportSender> nextRouting;
     for (const auto& slot : state_.slotList) {

src/AppModel.h

@@ -33,6 +33,9 @@ struct MainUiState {
     QList<models::ControllerSlot> slotList;
     QList<models::ConnectionSummary> connections;
     std::optional<models::DiscoveredServer> pairingTarget;
+    // True while any WiFi connection is registering a controller. Drives the
+    // dashboard's indeterminate spinner.
+    bool busy = false;
 };
 
 // Top-level application state. Owns the network + input layers and stitches

src/Input/GamepadInputProcessor.cpp

@@ -27,9 +27,6 @@ void GamepadInputProcessor::publish(const DeviceId& id, const DeviceState& state
         if (auto it = deadzones_.find(id); it != deadzones_.end()) { dz = it->second; }
         filtered = applyDeadzones(state, dz);
         states_[id] = filtered;
-        ++telEvents_;
-        ++telSends_;
-        ++telTotalSent_;
         snapshot = sender_;
     }
     if (snapshot) {
@@ -60,14 +57,6 @@ void GamepadInputProcessor::remove(const DeviceId& id) {
     deadzones_.erase(id);
 }
 
-GamepadInputProcessor::TelemetrySnapshot GamepadInputProcessor::drainTelemetry() {
-    std::lock_guard<std::mutex> lock(mtx_);
-    TelemetrySnapshot snap{telEvents_, telSends_, telTotalSent_};
-    telEvents_ = 0;
-    telSends_ = 0;
-    return snap;
-}
-
 std::int16_t scaleAxis(float v, float maxMagnitude) {
     const auto clamped = std::clamp(v, -1.0f, 1.0f);
     const auto scaled = static_cast<int>(clamped * maxMagnitude);

src/Input/GamepadInputProcessor.h

@@ -72,27 +72,17 @@ class GamepadInputProcessor {
         }
     };
 
-    struct TelemetrySnapshot {
-        int events = 0;
-        int sends = 0;
-        std::uint64_t totalSent = 0;
-    };
-
     void setReportSender(ReportSender sender);
     void setDeadzones(const DeviceId& id, const Deadzones& dz);
     void publish(const DeviceId& id, const DeviceState& state);
     void zeroAndSendAll();
     void remove(const DeviceId& id);
-    TelemetrySnapshot drainTelemetry();
 
   private:
     std::mutex mtx_;
     std::unordered_map<DeviceId, DeviceState> states_;
     std::unordered_map<DeviceId, Deadzones> deadzones_;
     ReportSender sender_;
-    int telEvents_ = 0;
-    int telSends_ = 0;
-    std::uint64_t telTotalSent_ = 0;
 };
 
 // Pure helpers — easily testable.

src/Models/Models.h

@@ -69,19 +69,14 @@ struct ConnectionSummary {
     std::optional<QString> boundSlotId;
 };
 
-enum class SlotInputType { Virtual, Physical };
-
 struct ControllerSlot {
     QString id;
-    SlotInputType inputType = SlotInputType::Virtual;
     QString name;
     QString physicalDeviceId;
     std::optional<QString> boundConnectionId;
     std::optional<ConnectionSummary> boundStatus;
 };
 
-inline constexpr const char* kVirtualSlotId = "virtual";
-
 struct RememberedWifi {
     QString id;
     QString name;

src/Network/ConnectionHub.cpp

@@ -12,6 +12,8 @@ namespace dish::net {
 ConnectionHub::ConnectionHub(WifiConnectionManager* wifi, ConnectionStore* store, QObject* parent)
     : QObject(parent), wifi_(wifi), store_(store) {
     QObject::connect(wifi_, &WifiConnectionManager::poolChanged, this, &ConnectionHub::rebuild);
+    QObject::connect(wifi_, &WifiConnectionManager::slotRegistrationFailed, this,
+                     &ConnectionHub::unbind);
     rebuild();
 }
 

src/Network/WifiConnection.cpp

@@ -3,10 +3,31 @@
 
 #include "WifiConnection.h"
 
-#include <QThread>
-
 namespace dish::net {
 
+namespace {
+
+QString controllerAckErrorMessage(std::uint8_t result) {
+    // Matches the satellite/src/core/types.h codes verbatim.
+    switch (result) {
+    case 0x01:
+        return QStringLiteral(
+            "Server has no virtual gamepad backend — controller cannot be created");
+    case 0x02:
+        return QStringLiteral("Server has no free controller slots");
+    case 0x03:
+        return QStringLiteral("Controller already added on the server");
+    case 0x04:
+        return QStringLiteral("Controller not found on the server");
+    case 0x05:
+        return QStringLiteral("Server failed to plug in the virtual controller");
+    default:
+        return QStringLiteral("Server rejected controller add (code %1)").arg(result);
+    }
+}
+
+} // namespace
+
 WifiConnection::WifiConnection(QString id, models::DiscoveredServer server, QObject* parent)
     : QObject(parent), id_(std::move(id)), server_(std::move(server)) {}
 
@@ -64,6 +85,8 @@ void WifiConnection::markDisconnected() {
         aliveTimer_->deleteLater();
         aliveTimer_ = nullptr;
     }
+    if (ackPollTimer_ != nullptr) { ackPollTimer_->stop(); }
+    controllerRegistering_ = false;
     if (existing) {
         existing->stopHeartbeat();
         existing->stopReceiveLoop();
@@ -96,20 +119,59 @@ void WifiConnection::detachSlot() {
 void WifiConnection::registerController(int type) {
     auto c = clientRef_.get();
     if (!c) { return; }
+    pendingControllerType_ = type;
     c->resetControllerAck();
     c->controllerAdd(kDefaultCtrlIndex, kDefaultCaps);
-    // Spin briefly waiting for the server's controller ACK; same shape as the
-    // Mac client. This blocks the calling (main) thread for up to ~2s in the
-    // worst case, but the satellite normally responds within a few ms.
-    for (int i = 0; i < kAckWaitAttempts && c->lastControllerAck() == -1; ++i) {
-        QThread::msleep(kAckWaitIntervalMs);
+    ackPollCount_ = 0;
+    controllerRegistering_ = true;
+    if (ackPollTimer_ == nullptr) {
+        ackPollTimer_ = new QTimer(this);
+        ackPollTimer_->setInterval(kAckWaitIntervalMs);
+        QObject::connect(ackPollTimer_, &QTimer::timeout, this, &WifiConnection::pollControllerAck);
     }
-    if (c->lastControllerAck() != -1) {
-        c->sendControllerType(kDefaultCtrlIndex, type);
+    ackPollTimer_->start();
+    emit changed();
+}
+
+void WifiConnection::pollControllerAck() {
+    auto c = clientRef_.get();
+    if (!c) {
+        const auto slotId = boundSlotId_.value_or(QString());
+        finishRegistration();
+        emit errorOccurred(QStringLiteral("Connection dropped before controller acknowledgement"));
+        if (!slotId.isEmpty()) { emit registrationFailed(slotId); }
+        return;
+    }
+    const auto ack = c->lastControllerAck();
+    if (ack == -1) {
+        if (++ackPollCount_ >= kAckWaitAttempts) {
+            const auto slotId = boundSlotId_.value_or(QString());
+            finishRegistration();
+            emit errorOccurred(
+                QStringLiteral("Server did not acknowledge controller add (timeout)"));
+            if (!slotId.isEmpty()) { emit registrationFailed(slotId); }
+        }
+        return;
+    }
+    const std::uint8_t result = static_cast<std::uint8_t>(ack & 0xFF);
+    if (result == 0x00 /* ACK_OK */) {
+        c->sendControllerType(kDefaultCtrlIndex, pendingControllerType_);
         controllerAdded_ = true;
+        finishRegistration();
+    } else {
+        const auto slotId = boundSlotId_.value_or(QString());
+        finishRegistration();
+        emit errorOccurred(controllerAckErrorMessage(result));
+        if (!slotId.isEmpty()) { emit registrationFailed(slotId); }
     }
 }
 
+void WifiConnection::finishRegistration() {
+    if (ackPollTimer_ != nullptr) { ackPollTimer_->stop(); }
+    controllerRegistering_ = false;
+    emit changed();
+}
+
 void WifiConnection::sendReport(std::uint16_t buttons, std::uint8_t lt, std::uint8_t rt,
                                 std::int16_t lx, std::int16_t ly, std::int16_t rx,
                                 std::int16_t ry) {

src/Network/WifiConnection.h

@@ -64,12 +64,19 @@ class WifiConnection : public QObject {
     void attachSlot(const QString& slotId, int controllerType);
     void detachSlot();
 
+    bool isRegisteringController() const { return controllerRegistering_; }
+
     // Hot path: called directly from the SDL gamepad thread.
     void sendReport(std::uint16_t buttons, std::uint8_t lt, std::uint8_t rt, std::int16_t lx,
                     std::int16_t ly, std::int16_t rx, std::int16_t ry);
 
   signals:
     void changed();
+    void errorOccurred(const QString& message);
+    // Emitted when the in-flight controller registration for `slotId` was
+    // rejected or timed out. Listened to by ConnectionHub to roll back the
+    // local binding so the UI reflects reality.
+    void registrationFailed(const QString& slotId);
 
   private:
     static constexpr int kDefaultCtrlIndex = 0;
@@ -78,6 +85,8 @@ class WifiConnection : public QObject {
     static constexpr int kAckWaitIntervalMs = 100;
 
     void registerController(int type);
+    void pollControllerAck();
+    void finishRegistration();
 
     QString id_;
     models::DiscoveredServer server_;
@@ -87,6 +96,9 @@ class WifiConnection : public QObject {
 
     ClientRef clientRef_;
     QTimer* aliveTimer_ = nullptr;
+    QTimer* ackPollTimer_ = nullptr;
+    int ackPollCount_ = 0;
+    bool controllerRegistering_ = false;
     std::function<void()> onDead_;
     bool controllerAdded_ = false;
     int pendingControllerType_ = 0;