rm key replay. also noticed some type of race condition with wofi

collinalexbell · collinalexbell · commit cea9ba4b277c · 2026-03-01T17:52:17.000-05:00
diff --git a/include/WindowManager/WindowManager.h b/include/WindowManager/WindowManager.h
@@ -68,9 +68,6 @@ class WindowManagerInterface
   virtual void registerControls(Controls* controls) = 0;
   virtual void tick() = 0;
   virtual void handleHotkeySym(xkb_keysym_t sym, bool modifierHeld, bool shiftHeld) = 0;
-  virtual void keyReplay(const std::vector<std::pair<std::string, uint32_t>>& entries) = 0;
-  virtual std::vector<ReplayEvent> consumeReadyReplaySyms(uint64_t now_ms) = 0;
-  virtual bool hasPendingReplay() const = 0;
   virtual bool consumeScreenshotRequest() = 0;
   virtual void requestScreenshot() = 0;
   virtual bool consumeMenuSpawnPending() = 0;
@@ -192,9 +189,6 @@ class WindowManager : public WindowManagerInterface
   void registerControls(Controls* controls) override;
   void tick() override;
   void handleHotkeySym(xkb_keysym_t sym, bool superHeld, bool shiftHeld) override;
-  void keyReplay(const std::vector<std::pair<std::string, uint32_t>>& entries) override;
-  std::vector<ReplayEvent> consumeReadyReplaySyms(uint64_t now_ms) override;
-  bool hasPendingReplay() const override { return replayActive; }
   bool consumeScreenshotRequest() override;
   void requestScreenshot() override;
   bool consumeMenuSpawnPending() override { return menuSpawnPending.exchange(false); }
diff --git a/src/WindowManager/WindowManager.cpp b/src/WindowManager/WindowManager.cpp
@@ -1109,63 +1109,6 @@ WindowManager::setCursorVisible(bool visible)
   cursorVisible = visible;
 }
 
-void
-WindowManager::keyReplay(const std::vector<std::pair<std::string, uint32_t>>& entries)
-{
-  replayQueue.clear();
-  replayIndex = 0;
-  replayActive = false;
-  replayStart = std::chrono::steady_clock::now();
-  uint64_t cumulative = 0;
-  for (const auto& e : entries) {
-    if (e.first.empty()) {
-      continue;
-    }
-    xkb_keysym_t sym =
-      xkb_keysym_from_name(e.first.c_str(), XKB_KEYSYM_NO_FLAGS);
-    if (sym == XKB_KEY_NoSymbol) {
-      continue;
-    }
-    cumulative += e.second;
-    char name[64] = {0};
-    xkb_keysym_get_name(sym, name, sizeof(name));
-    // Detailed replay log to debug dropped/garbled input; keep to avoid
-    // reintroducing silent failures in future refactors.
-    WL_WM_LOG("WM: keyReplay add sym=%s(%u) delay=%u cumulative=%llu\n",
-              name,
-              sym,
-              e.second,
-              (unsigned long long)cumulative);
-    replayQueue.push_back(ReplayEvent{ sym, cumulative });
-  }
-  WL_WM_LOG("WM: keyReplay queued count=%zu cumulative=%llu\n",
-            replayQueue.size(),
-            (unsigned long long)cumulative);
-  replayActive = !replayQueue.empty();
-}
-
-std::vector<ReplayEvent>
-WindowManager::consumeReadyReplaySyms(uint64_t now_ms)
-{
-  std::vector<ReplayEvent> ready;
-  if (!replayActive) {
-    return ready;
-  }
-  uint64_t start_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-                        replayStart.time_since_epoch())
-                        .count();
-  uint64_t elapsed = now_ms > start_ms ? now_ms - start_ms : 0;
-  while (replayIndex < replayQueue.size() &&
-         elapsed >= replayQueue[replayIndex].ready_ms) {
-    ready.push_back(replayQueue[replayIndex]);
-    ++replayIndex;
-  }
-  if (replayIndex >= replayQueue.size()) {
-    replayActive = false;
-  }
-  return ready;
-}
-
 void
 WindowManager::requestScreenshot()
 {
diff --git a/src/api.cpp b/src/api.cpp
@@ -421,18 +421,6 @@ Api::processBatchedRequest(BatchedRequest batchedRequest)
       }
       break;
     }
-    case KEY_REPLAY: {
-      if (wm) {
-        std::vector<std::pair<std::string, uint32_t>> entries;
-        const auto& replay = batchedRequest.request.keyreplay();
-        entries.reserve(replay.entries_size());
-        for (const auto& e : replay.entries()) {
-          entries.emplace_back(e.sym(), e.delay_ms());
-        }
-        wm->keyReplay(entries);
-      }
-      break;
-    }
     case POINTER_REPLAY: {
       if (controls) {
         const auto& replay = batchedRequest.request.pointerreplay();
diff --git a/src/wayland/wlr_compositor.cpp b/src/wayland/wlr_compositor.cpp
@@ -1072,31 +1072,6 @@ process_key_sym(WlrServer* server,
   }
 }
 
-static void
-flush_pending_replay_keyups(WlrServer* server,
-                            wlr_keyboard* keyboard,
-                            uint32_t now_msec)
-{
-  if (!server || server->pendingReplayKeyups.empty()) {
-    return;
-  }
-  auto it = server->pendingReplayKeyups.begin();
-  while (it != server->pendingReplayKeyups.end()) {
-    if (now_msec >= it->release_time_msec) {
-      process_key_sym(server,
-                      keyboard,
-                      it->sym,
-                      false,
-                      now_msec,
-                      it->keycode,
-                      it->update_mods);
-      it = server->pendingReplayKeyups.erase(it);
-    } else {
-      ++it;
-    }
-  }
-}
-
 void
 handle_keyboard_key(wl_listener* listener, void* data)
 {
@@ -1869,6 +1844,9 @@ handle_output_frame(wl_listener* listener, void* data)
   struct wlr_output_state output_state;
   wlr_output_state_init(&output_state);
 
+  // no-op if the swapchain has already been configured
+  // only errors if old swapchain isn't configured properly
+  // and a new one couldn't be created & configured
   if (!wlr_output_configure_primary_swapchain(
         handle->output, &output_state, &handle->swapchain)) {
     wlr_log(WLR_ERROR, "Failed to configure primary swapchain");
@@ -1922,125 +1900,6 @@ handle_output_frame(wl_listener* listener, void* data)
   // Ensure Wayland apps have textures attached once the renderer exists.
   ensure_wayland_apps_registered(server);
 
-  if (server->engine) {
-    auto wm = server->engine->getWindowManager();
-    if (wm) {
-      uint64_t now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-                          std::chrono::steady_clock::now().time_since_epoch())
-                          .count();
-      uint32_t now_msec = static_cast<uint32_t>(now_ms & 0xffffffff);
-      auto ready = wm->consumeReadyReplaySyms(now_ms);
-      wlr_keyboard* kbd = nullptr;
-      if (server->last_keyboard_device) {
-        kbd = wlr_keyboard_from_input_device(server->last_keyboard_device);
-      } else if (server->seat && server->seat->keyboard_state.keyboard) {
-        kbd = server->seat->keyboard_state.keyboard;
-      } else {
-        kbd = ensure_virtual_keyboard(server);
-      }
-      static bool logged_missing_keyboard = false;
-      if (!kbd && !logged_missing_keyboard) {
-        logged_missing_keyboard = true;
-      }
-      auto shift_lookup = keycode_for_keysym(kbd, XKB_KEY_Shift_L);
-      xkb_keysym_t modifier_sym_left =
-        server->hotkeyModifier == HotkeyModifier::Alt ? XKB_KEY_Alt_L : XKB_KEY_Super_L;
-      auto modifier_lookup = keycode_for_keysym(kbd, modifier_sym_left);
-      uint32_t base_msec = now_msec;
-      uint32_t step = 0;
-      constexpr uint32_t kReplayHoldMs = 16;
-      for (size_t i = 0; i < ready.size(); ++i) {
-        auto sym = ready[i].sym;
-      auto lookup = keycode_for_keysym(kbd, sym);
-      if (!lookup.has_value() || lookup->keycode == 0) {
-        continue;
-      }
-      uint32_t hw_keycode = lookup->keycode >= 8 ? lookup->keycode - 8 : lookup->keycode;
-      uint32_t time_msec = base_msec + step;
-      bool is_modifier_sym = is_hotkey_sym(server->hotkeyModifier, sym);
-      bool is_shift_sym = sym == XKB_KEY_Shift_L || sym == XKB_KEY_Shift_R;
-      bool is_last = (i + 1) == ready.size();
-      bool replay_has_future = wm->hasPendingReplay();
-      if (is_modifier_sym && server->pendingReplayModifier &&
-          server->pendingReplayModifierKeycode != 0) {
-        // Avoid overlapping modifier presses that clear modifiers out of order.
-          process_key_sym(server,
-                          kbd,
-                          server->pendingReplayModifierSym,
-                          false,
-                          time_msec,
-                          server->pendingReplayModifierKeycode,
-                          true);
-          server->pendingReplayModifier = false;
-          server->pendingReplayModifierKeycode = 0;
-          server->pendingReplayModifierSym = XKB_KEY_NoSymbol;
-        }
-      if ((is_modifier_sym || is_shift_sym) && (replay_has_future || !is_last)) {
-        // Hold modifiers (including shift) across the next keypress to mirror
-        // physical combos like Shift+0.
-        if (is_shift_sym && shift_lookup.has_value() && shift_lookup->keycode) {
-          server->pendingReplayShift = true;
-        }
-        server->pendingReplayModifier = true;
-        server->pendingReplayModifierKeycode = hw_keycode;
-        server->pendingReplayModifierSym = sym;
-        process_key_sym(server, kbd, sym, true, time_msec, hw_keycode, true);
-        // Do not release yet; move to next symbol.
-          step += 1;
-          continue;
-        }
-        if (lookup->needsShift && shift_lookup.has_value() && shift_lookup->keycode) {
-          uint32_t shift_hw = shift_lookup->keycode >= 8 ? shift_lookup->keycode - 8
-                                                         : shift_lookup->keycode;
-          process_key_sym(server,
-                          kbd,
-                          XKB_KEY_Shift_L,
-                          true,
-                          time_msec,
-                          shift_hw,
-                          true);
-          time_msec += 1;
-          step += 1;
-        }
-        process_key_sym(server, kbd, sym, true, time_msec, hw_keycode, true);
-        uint64_t hold_ms = kReplayHoldMs;
-        if (i + 1 < ready.size()) {
-          auto delta_ms = ready[i + 1].ready_ms - ready[i].ready_ms;
-          if (delta_ms > hold_ms) {
-            hold_ms = static_cast<uint32_t>(std::min<uint64_t>(delta_ms, 10000));
-          }
-        }
-        uint32_t release_time = time_msec + static_cast<uint32_t>(hold_ms);
-        server->pendingReplayKeyups.push_back(
-          ReplayKeyRelease{ sym, release_time, hw_keycode, true });
-        if (lookup->needsShift && shift_lookup.has_value() && shift_lookup->keycode) {
-          uint32_t shift_hw = shift_lookup->keycode >= 8 ? shift_lookup->keycode - 8
-                                                         : shift_lookup->keycode;
-          server->pendingReplayKeyups.push_back(
-            ReplayKeyRelease{ XKB_KEY_Shift_L, release_time + 1, shift_hw, true });
-          step += 1;
-        }
-        step += 2;
-        if (server->pendingReplayModifier && !is_modifier_sym && !is_shift_sym) {
-          // Release held modifier after the combo key with a realistic hold so the
-          // replay path mirrors physical key timing.
-          uint32_t modifier_release_time =
-            time_msec + static_cast<uint32_t>(std::max<uint64_t>(hold_ms, kReplayHoldMs));
-          server->pendingReplayKeyups.push_back(
-            ReplayKeyRelease{ server->pendingReplayModifierSym,
-                              modifier_release_time,
-                              server->pendingReplayModifierKeycode,
-                              true });
-          server->pendingReplayModifier = false;
-          server->pendingReplayModifierKeycode = 0;
-          server->pendingReplayModifierSym = XKB_KEY_NoSymbol;
-          step += 1;
-        }
-      }
-      flush_pending_replay_keyups(server, kbd, now_msec);
-    }
-  }
-
   if (server->engine) {
     Controls* controls = server->engine->getControls();
     Camera* camera = server->engine->getCamera();
@@ -2156,6 +2015,8 @@ handle_output_frame(wl_listener* listener, void* data)
   server->lastFrameTime = frameStart;
 }
 
+// This is called when wayland detects a new output such as a monitor
+// It sets up size, cursor info, and frame notify handler (which will render each frame)
 void
 handle_new_output(wl_listener* listener, void* data)
 {
