Merge pull request #2770 from greenm01/triad-native-ipc-v5

Add Triad compositor backend

Author: ItsLemmy

meson.build

@@ -654,6 +654,10 @@ _noctalia_sources = files(
   'src/compositors/niri/niri_output_backend.cpp',
   'src/compositors/niri/niri_keyboard_backend.cpp',
   'src/compositors/niri/niri_workspace_backend.cpp',
+  'src/compositors/triad/triad_runtime.cpp',
+  'src/compositors/triad/triad_output_backend.cpp',
+  'src/compositors/triad/triad_keyboard_backend.cpp',
+  'src/compositors/triad/triad_workspace_backend.cpp',
   'src/compositors/sway/sway_runtime.cpp',
   'src/compositors/sway/sway_keyboard_backend.cpp',
   'src/compositors/sway/sway_output_backend.cpp',

src/compositors/compositor_detect.cpp

@@ -30,6 +30,12 @@ namespace compositors {
       if (const char* v = std::getenv("LABWC_PID"); v != nullptr && v[0] != '\0') {
         return CompositorKind::Labwc;
       }
+      if (const char* v = std::getenv("TRIAD_SOCKET"); v != nullptr && v[0] != '\0') {
+        return CompositorKind::Triad;
+      }
+      if (const char* v = std::getenv("RIVER_WM"); v != nullptr && StringUtils::containsInsensitive(v, "triad")) {
+        return CompositorKind::Triad;
+      }
       if (const char* v = std::getenv("NIRI_SOCKET"); v != nullptr && v[0] != '\0') {
         return CompositorKind::Niri;
       }
@@ -42,6 +48,9 @@ namespace compositors {
 
       // Fall back to the desktop env hint (covers dwl-style compositors that don't expose a socket var).
       const std::string hint = buildEnvHint();
+      if (StringUtils::containsInsensitive(hint, "triad")) {
+        return CompositorKind::Triad;
+      }
       if (StringUtils::containsInsensitive(hint, "niri")) {
         return CompositorKind::Niri;
       }
@@ -69,6 +78,8 @@ namespace compositors {
 
   std::string_view name(CompositorKind kind) {
     switch (kind) {
+    case CompositorKind::Triad:
+      return "Triad";
     case CompositorKind::Niri:
       return "Niri";
     case CompositorKind::Hyprland:

src/compositors/compositor_detect.h

@@ -12,6 +12,7 @@ namespace compositors {
     Sway = 3,
     Mango = 4, // dwl-derived (mango, dwl)
     Labwc = 5,
+    Triad = 6,
   };
 
   // Detected once per process from env vars. Cached after the first call.
@@ -28,5 +29,6 @@ namespace compositors {
   [[nodiscard]] inline bool isSway() { return detect() == CompositorKind::Sway; }
   [[nodiscard]] inline bool isMango() { return detect() == CompositorKind::Mango; }
   [[nodiscard]] inline bool isLabwc() { return detect() == CompositorKind::Labwc; }
+  [[nodiscard]] inline bool isTriad() { return detect() == CompositorKind::Triad; }
 
 } // namespace compositors

src/compositors/compositor_platform.cpp

@@ -15,6 +15,10 @@
 #include "compositors/niri/niri_workspace_backend.h"
 #include "compositors/sway/sway_keyboard_backend.h"
 #include "compositors/sway/sway_output_backend.h"
+#include "compositors/triad/triad_keyboard_backend.h"
+#include "compositors/triad/triad_output_backend.h"
+#include "compositors/triad/triad_runtime.h"
+#include "compositors/triad/triad_workspace_backend.h"
 #include "wayland/wayland_connection.h"
 #include "wayland/wayland_workspaces.h"
 
@@ -191,6 +195,11 @@ namespace {
             (void)wayland;
             return compositors::sway::setOutputPower(runtime, on);
           });
+    case compositors::CompositorKind::Triad:
+      return std::make_unique<LambdaOutputPowerBackend>(
+          [&runtime = runtimeRegistry.triad()](WaylandConnection& /*wayland*/, bool on) {
+            return compositors::triad::setOutputPower(runtime, on);
+          });
     case compositors::CompositorKind::Mango:
       return std::make_unique<LambdaOutputPowerBackend>(&setMangoOutputPower, true);
     case compositors::CompositorKind::Labwc:
@@ -209,6 +218,8 @@ namespace {
       return std::make_unique<FocusedOutputAdapter<NiriOutputBackend>>(runtimeRegistry.niri());
     case compositors::CompositorKind::Sway:
       return std::make_unique<FocusedOutputAdapter<SwayOutputBackend>>(runtimeRegistry.sway());
+    case compositors::CompositorKind::Triad:
+      return std::make_unique<FocusedOutputAdapter<TriadOutputBackend>>(runtimeRegistry.triad());
     case compositors::CompositorKind::Labwc:
     case compositors::CompositorKind::Mango:
     case compositors::CompositorKind::Unknown:
@@ -220,6 +231,8 @@ namespace {
   [[nodiscard]] std::unique_ptr<compositors::WorkspaceMetadataBackend>
   createWorkspaceMetadataBackend(compositors::CompositorRuntimeRegistry& runtimeRegistry) {
     switch (compositors::detect()) {
+    case compositors::CompositorKind::Triad:
+      return std::make_unique<TriadWorkspaceBackend>(runtimeRegistry.triad());
     case compositors::CompositorKind::Niri:
       return std::make_unique<NiriWorkspaceBackend>(runtimeRegistry.niri());
     case compositors::CompositorKind::Hyprland:
@@ -243,6 +256,8 @@ namespace {
       return std::make_unique<KeyboardLayoutBackendAdapter<MangoKeyboardBackend>>();
     case compositors::CompositorKind::Sway:
       return std::make_unique<KeyboardLayoutBackendAdapter<SwayKeyboardBackend>>(runtimeRegistry.sway());
+    case compositors::CompositorKind::Triad:
+      return std::make_unique<KeyboardLayoutBackendAdapter<TriadKeyboardBackend>>(runtimeRegistry.triad());
     case compositors::CompositorKind::Labwc:
     case compositors::CompositorKind::Unknown:
       break;

src/compositors/compositor_runtime.cpp

@@ -3,12 +3,13 @@
 #include "compositors/hyprland/hyprland_runtime.h"
 #include "compositors/niri/niri_runtime.h"
 #include "compositors/sway/sway_runtime.h"
+#include "compositors/triad/triad_runtime.h"
 
 namespace compositors {
 
   CompositorRuntimeRegistry::CompositorRuntimeRegistry()
       : m_hyprland(std::make_unique<hyprland::HyprlandRuntime>()), m_niri(std::make_unique<niri::NiriRuntime>()),
-        m_sway(std::make_unique<sway::SwayRuntime>()) {}
+        m_sway(std::make_unique<sway::SwayRuntime>()), m_triad(std::make_unique<triad::TriadRuntime>()) {}
 
   CompositorRuntimeRegistry::~CompositorRuntimeRegistry() = default;
 
@@ -24,4 +25,8 @@ namespace compositors {
 
   const sway::SwayRuntime& CompositorRuntimeRegistry::sway() const noexcept { return *m_sway; }
 
+  triad::TriadRuntime& CompositorRuntimeRegistry::triad() noexcept { return *m_triad; }
+
+  const triad::TriadRuntime& CompositorRuntimeRegistry::triad() const noexcept { return *m_triad; }
+
 } // namespace compositors

src/compositors/compositor_runtime.h

@@ -16,6 +16,10 @@ namespace compositors {
     class SwayRuntime;
   } // namespace sway
 
+  namespace triad {
+    class TriadRuntime;
+  } // namespace triad
+
   class CompositorRuntimeRegistry {
   public:
     CompositorRuntimeRegistry();
@@ -30,11 +34,14 @@ namespace compositors {
     [[nodiscard]] const niri::NiriRuntime& niri() const noexcept;
     [[nodiscard]] sway::SwayRuntime& sway() noexcept;
     [[nodiscard]] const sway::SwayRuntime& sway() const noexcept;
+    [[nodiscard]] triad::TriadRuntime& triad() noexcept;
+    [[nodiscard]] const triad::TriadRuntime& triad() const noexcept;
 
   private:
     std::unique_ptr<hyprland::HyprlandRuntime> m_hyprland;
     std::unique_ptr<niri::NiriRuntime> m_niri;
     std::unique_ptr<sway::SwayRuntime> m_sway;
+    std::unique_ptr<triad::TriadRuntime> m_triad;
   };
 
 } // namespace compositors

src/compositors/triad/triad_keyboard_backend.cpp

@@ -0,0 +1,74 @@
+#include "compositors/triad/triad_keyboard_backend.h"
+
+#include "compositors/triad/triad_runtime.h"
+
+#include <json.hpp>
+
+namespace {
+
+  [[nodiscard]] const nlohmann::json* triadState(const nlohmann::json& response) {
+    if (!response.is_object()) {
+      return nullptr;
+    }
+    const auto triadIt = response.find("triad");
+    if (triadIt == response.end() || !triadIt->is_object()) {
+      return nullptr;
+    }
+    const auto stateIt = triadIt->find("state");
+    return stateIt != triadIt->end() && stateIt->is_object() ? &(*stateIt) : nullptr;
+  }
+
+  [[nodiscard]] std::optional<KeyboardLayoutState> parseLayoutState(const nlohmann::json& response) {
+    const auto* stateJson = triadState(response);
+    if (stateJson == nullptr) {
+      return std::nullopt;
+    }
+
+    const auto namesIt = stateJson->find("keyboard_layouts");
+    const auto currentIt = stateJson->find("current_keyboard_layout_idx");
+    if (namesIt == stateJson->end() || !namesIt->is_array() || currentIt == stateJson->end() ||
+        !currentIt->is_number_integer()) {
+      return std::nullopt;
+    }
+
+    KeyboardLayoutState state;
+    state.currentIndex = currentIt->get<int>();
+    state.names.reserve(namesIt->size());
+    for (const auto& entry : *namesIt) {
+      if (!entry.is_string()) {
+        return std::nullopt;
+      }
+      state.names.push_back(entry.get<std::string>());
+    }
+
+    if (state.currentIndex < 0 || state.currentIndex >= static_cast<int>(state.names.size())) {
+      return std::nullopt;
+    }
+    return state;
+  }
+
+} // namespace
+
+TriadKeyboardBackend::TriadKeyboardBackend(compositors::triad::TriadRuntime& runtime) : m_runtime(runtime) {}
+
+bool TriadKeyboardBackend::isAvailable() const noexcept { return m_runtime.available(); }
+
+bool TriadKeyboardBackend::cycleLayout() const {
+  return isAvailable() && m_runtime.requestAction("switch-keyboard-layout", nlohmann::json{{"layout", "next"}});
+}
+
+std::optional<KeyboardLayoutState> TriadKeyboardBackend::layoutState() const {
+  if (!isAvailable()) {
+    return std::nullopt;
+  }
+  const auto response = m_runtime.requestJson("state");
+  return response.has_value() ? parseLayoutState(*response) : std::nullopt;
+}
+
+std::optional<std::string> TriadKeyboardBackend::currentLayoutName() const {
+  const auto state = layoutState();
+  if (!state.has_value() || state->currentIndex < 0 || state->currentIndex >= static_cast<int>(state->names.size())) {
+    return std::nullopt;
+  }
+  return state->names[static_cast<std::size_t>(state->currentIndex)];
+}

src/compositors/triad/triad_keyboard_backend.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "compositors/keyboard_backend.h"
+
+#include <optional>
+#include <string>
+
+namespace compositors::triad {
+  class TriadRuntime;
+} // namespace compositors::triad
+
+class TriadKeyboardBackend {
+public:
+  explicit TriadKeyboardBackend(compositors::triad::TriadRuntime& runtime);
+
+  [[nodiscard]] bool isAvailable() const noexcept;
+  [[nodiscard]] bool cycleLayout() const;
+  [[nodiscard]] std::optional<KeyboardLayoutState> layoutState() const;
+  [[nodiscard]] std::optional<std::string> currentLayoutName() const;
+
+private:
+  compositors::triad::TriadRuntime& m_runtime;
+};

src/compositors/triad/triad_output_backend.cpp

@@ -0,0 +1,95 @@
+#include "compositors/triad/triad_output_backend.h"
+
+#include "compositors/triad/triad_runtime.h"
+#include "core/log.h"
+
+#include <json.hpp>
+#include <optional>
+#include <string>
+
+namespace {
+
+  constexpr Logger kLog("triad_output");
+
+  [[nodiscard]] const nlohmann::json* triadState(const nlohmann::json& response) {
+    if (!response.is_object()) {
+      return nullptr;
+    }
+    const auto triadIt = response.find("triad");
+    if (triadIt == response.end() || !triadIt->is_object()) {
+      return nullptr;
+    }
+    const auto stateIt = triadIt->find("state");
+    return stateIt != triadIt->end() && stateIt->is_object() ? &(*stateIt) : nullptr;
+  }
+
+  [[nodiscard]] std::optional<std::uint64_t> jsonUnsigned(const nlohmann::json& json) {
+    if (json.is_number_unsigned()) {
+      return json.get<std::uint64_t>();
+    }
+    if (json.is_number_integer()) {
+      const auto value = json.get<std::int64_t>();
+      if (value >= 0) {
+        return static_cast<std::uint64_t>(value);
+      }
+    }
+    return std::nullopt;
+  }
+
+  [[nodiscard]] std::optional<std::string> activeOutputFromLayoutState(const nlohmann::json& state) {
+    const auto activeIt = state.find("active_workspace_idx");
+    const auto workspacesIt = state.find("workspaces");
+    if (activeIt == state.end() || workspacesIt == state.end() || !workspacesIt->is_array()) {
+      return std::nullopt;
+    }
+    const auto activeIdx = jsonUnsigned(*activeIt);
+    if (!activeIdx.has_value()) {
+      return std::nullopt;
+    }
+    for (const auto& workspace : *workspacesIt) {
+      if (!workspace.is_object()) {
+        continue;
+      }
+      const auto idxIt = workspace.find("workspace_idx");
+      const auto outputIt = workspace.find("output");
+      if (idxIt == workspace.end() || outputIt == workspace.end() || !outputIt->is_string()) {
+        continue;
+      }
+      const auto workspaceIdx = jsonUnsigned(*idxIt);
+      if (workspaceIdx.has_value() && *workspaceIdx == *activeIdx) {
+        return outputIt->get<std::string>();
+      }
+    }
+    return std::nullopt;
+  }
+
+} // namespace
+
+TriadOutputBackend::TriadOutputBackend(compositors::triad::TriadRuntime& runtime) : m_runtime(runtime) {}
+
+std::optional<std::string> TriadOutputBackend::focusedOutputName() const {
+  if (auto response = m_runtime.requestJson("state"); response.has_value()) {
+    if (const auto* state = triadState(*response); state != nullptr) {
+      if (auto output = activeOutputFromLayoutState(*state); output.has_value() && !output->empty()) {
+        return output;
+      }
+      const auto layoutIt = state->find("layout");
+      if (layoutIt != state->end() && layoutIt->is_object()) {
+        if (auto output = activeOutputFromLayoutState(*layoutIt); output.has_value() && !output->empty()) {
+          return output;
+        }
+      }
+    }
+  }
+
+  kLog.debug("failed to resolve focused output from triad IPC");
+  return std::nullopt;
+}
+
+namespace compositors::triad {
+
+  bool setOutputPower(TriadRuntime& runtime, bool on) {
+    return runtime.requestAction(on ? "power-on-monitors" : "power-off-monitors");
+  }
+
+} // namespace compositors::triad

src/compositors/triad/triad_output_backend.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <optional>
+#include <string>
+
+namespace compositors::triad {
+  class TriadRuntime;
+} // namespace compositors::triad
+
+class TriadOutputBackend {
+public:
+  explicit TriadOutputBackend(compositors::triad::TriadRuntime& runtime);
+
+  [[nodiscard]] std::optional<std::string> focusedOutputName() const;
+
+private:
+  compositors::triad::TriadRuntime& m_runtime;
+};
+
+namespace compositors::triad {
+
+  [[nodiscard]] bool setOutputPower(TriadRuntime& runtime, bool on);
+
+} // namespace compositors::triad