You can now do all of the control things you'd do in the control window via the bezos_cli/ctl command line tool.

src/bezos_ctl.cpp

@@ -11,31 +11,48 @@ const int DEFAULT_PORT=9898;
 
 struct Options {
   bool help{false};
-  bool focus{false};
+  CtrlCommand cmd{CtrlCommand::NONE};
   bool error{false};
   unsigned short port=DEFAULT_PORT;
 };
 
-void request_focus(Options& options) {
+void send_request(Options& options) {
-  fmt::println("Moving control window front: port={}", options.port);
   sf::UdpSocket sock;
-  uint32_t cmd = uint32_t(CtrlCommand::FOCUS);
+  uint32_t cmd = uint32_t(options.cmd);
   auto localhost = sf::IpAddress::getLocalAddress();
+  dbc::check(localhost != std::nullopt, "Failed to get local addres?!");
+
   auto result = sock.send(&cmd, sizeof cmd, *localhost, options.port);
 }
 
 void print_usage() {
-  fmt::println("USAGE: bezos [-p {}] [-hf] -d deck.md", DEFAULT_PORT);
+  fmt::println("USAGE: bezos [-p {}] [-h] [-fLRNPq]", DEFAULT_PORT);
 }
 
 Options parse_options(int argc, char* argv[]) {
   int opt = 0;
   Options result;
 
-  while((opt = getopt(argc, argv, "fhp:")) != -1) {
+  while((opt = getopt(argc, argv, "fLRNPqhp:")) != -1) {
+    using enum CtrlCommand;
     switch(opt) {
+      case 'L':
+        result.cmd = MOVE_LEFT;
+        break;
+      case 'R':
+        result.cmd = MOVE_RIGHT;
+        break;
+      case 'N':
+        result.cmd = NEXT_SLIDE;
+        break;
+      case 'P':
+        result.cmd = PREV_SLIDE;
+        break;
+      case 'q':
+        result.cmd = QUIT;
+        break;
       case 'f':
-        result.focus=true;
+        result.cmd = FOCUS;
         break;
       case 'h':
         print_usage();
@@ -50,23 +67,22 @@ Options parse_options(int argc, char* argv[]) {
     }
   }
 
-  if(!result.focus) {
+  if(result.cmd == CtrlCommand::NONE) {
     print_usage();
   }
 
   return result;
 }
 
-
 int main(int argc, char *argv[]) {
   auto options = parse_options(argc, argv);
 
-  if(options.focus) {
+  if(options.help) {
-    request_focus(options);
-    return 0;
-  } else if(options.help) {
     return 0;
   } else if(options.error) {
     return 1;
+  } else {
+    send_request(options);
+    return 0;
   }
 }

src/control_ui.cpp

@@ -11,11 +11,13 @@
 #include <iostream>
 #include "constants.hpp"
 #include "control_ui.hpp"
+#include <optional>
 
-ControlUI::ControlUI(sf::RenderWindow& presenter, sf::RenderWindow& controller) :
+ControlUI::ControlUI(sf::RenderWindow& presenter, sf::RenderWindow& controller, unsigned short port) :
-    $presenter(presenter),
+    $presenter{presenter},
-    $controller(controller),
+    $controller{controller},
-    $window_size($presenter.getSize())
+    $window_size{$presenter.getSize()},
+    $ctrl_sock{port}
 {
   $gui.position(0, 0, CONTROL_WIDTH, CONTROL_HEIGHT);
   $gui.layout(
@@ -31,6 +33,8 @@ ControlUI::ControlUI(sf::RenderWindow& presenter, sf::RenderWindow& controller)
 }
 
 void ControlUI::init() {
+  $ctrl_sock.listen();
+
   auto status_id = $gui.entity("status");
   $gui.set<guecs::Text>(status_id, {L""});
 
@@ -98,35 +102,72 @@ void ControlUI::full_screen(bool do_it) {
   $full_screen = do_it;
 }
 
-void ControlUI::handle_events(std::shared_ptr<SlidesUI> slides, const sf::Event& event) {
+void ControlUI::process_commands(std::shared_ptr<SlidesUI> slides) {
+  using enum CtrlCommand;
+
+  switch($ctrl_sock.receive()) {
+    case FOCUS:
+      sf::Mouse::setPosition({WINDOW_WIDTH - 100, WINDOW_HEIGHT - 100}, $presenter);
+      break;
+    case FULL_SCREEN:
+      full_screen(!$full_screen);
+      break;
+    case MOVE_LEFT:
+      move(1);
+      break;
+    case MOVE_RIGHT:
+      move(-1);
+      break;
+    case NEXT_SLIDE:
+      slides->next_slide();
+      break;
+    case PREV_SLIDE:
+      slides->prev_slide();
+      break;
+    case QUIT:
+      $controller.close();
+      break;
+    default:
+      break;
+  }
+}
+
+void ControlUI::move(int dir) {
+  auto pos = $presenter.getPosition();
+  pos.x += dir * $window_size.x;
+  $presenter.setPosition(pos);
+}
+
+void ControlUI::update(std::shared_ptr<SlidesUI> slides) {
   dbc::check($status != nullptr, "handle_events called before init?!");
 
-  if(event.is<sf::Event::Closed>()) {
+  process_commands(slides);
-    $controller.close();
+
-    return;
+  while (const auto event = $controller.pollEvent()) {
-  }
+    if(event->is<sf::Event::Closed>()) {
+      $controller.close();
+      return;
+    }
 
-  if(const auto* key = event.getIf<sf::Event::KeyPressed>()) {
+    if(const auto* key = event->getIf<sf::Event::KeyPressed>()) {
-    auto pos = $presenter.getPosition();
+
-
+      using KEY = sf::Keyboard::Scan;
-    using KEY = sf::Keyboard::Scan;
+      switch(key->scancode) {
-    switch(key->scancode) {
+        case KEY::A:
-      case KEY::A: {
+          move(1);
-          pos.x -= $window_size.x;
+          break;
-          $presenter.setPosition(pos);
+        case KEY::D:
-        } break;
+          move(-1);
-      case KEY::D: {
+          break;
-        pos.x += int($window_size.x);
+        case KEY::Q:
-        $presenter.setPosition(pos);
+          $controller.close();
-       } break;
+          break;
-      case KEY::Q:
+        case KEY::F:
-        $controller.close();
+          full_screen(!$full_screen);
-        break;
+          break;
-      case KEY::F:
+        default:
-        full_screen(!$full_screen);
+          slides->handle_events($controller, *event);
-        break;
+      }
-      default:
-        slides->handle_events($controller, event);
     }
   }
 }

src/control_ui.hpp

@@ -3,6 +3,7 @@
 #include "guecs/sfml/components.hpp"
 #include "guecs/ui.hpp"
 #include "slides_ui.hpp"
+#include "control.hpp"
 
 struct ControlUI {
   bool $full_screen = true;
@@ -11,11 +12,15 @@ struct ControlUI {
   sf::RenderWindow& $presenter;
   sf::RenderWindow& $controller;
   sf::Vector2u $window_size;
+  CtrlSocket $ctrl_sock;
+
+  ControlUI(sf::RenderWindow& presenter, sf::RenderWindow& controller, unsigned short port);
 
-  ControlUI(sf::RenderWindow& presenter, sf::RenderWindow& controller);
   void init();
   void render(sf::RenderWindow& window, SlideDeck& deck);
-  void handle_events(std::shared_ptr<SlidesUI> slides, const sf::Event& event);
+  void update(std::shared_ptr<SlidesUI> slides);
   void render_slide(const std::string& name, Slide& slide);
   void full_screen(bool do_it);
+  void process_commands(std::shared_ptr<SlidesUI> slides);
+  void move(int dir);
 };

src/main.cpp

@@ -11,7 +11,6 @@
 #include <SFML/System/Clock.hpp>
 #include <memory>
 #include <unistd.h>
-#include "control.hpp"
 
 using namespace std::chrono_literals;
 
@@ -70,7 +69,7 @@ struct ChangeDetector {
 };
 
 void print_usage() {
-  fmt::println("USAGE: bezos [-p PORT] [-hf] -d deck.md");
+  fmt::println("USAGE: bezos [-p PORT] [-h] -d deck.md");
 }
 
 Options parse_options(int argc, char* argv[]) {
@@ -137,30 +136,20 @@ int main(int argc, char *argv[]) {
     return 1;
   }
 
-  ControlUI control_ui(presenter, controller);
+  ControlUI control_ui{presenter, controller, options.port};
   control_ui.init();
   control_ui.full_screen(false);
 
-  CtrlSocket ctrl_sock{options.port};
-  ctrl_sock.listen();
-
   ChangeDetector slides_reloader{options.deck_file};
   ChangeDetector layout_reloader{slides->$deck->config["layouts"]};
 
   while(controller.isOpen()) {
-    auto command = ctrl_sock.receive();
-
-    if(command == CtrlCommand::FOCUS) {
-      sf::Mouse::setPosition({WINDOW_WIDTH - 100, WINDOW_HEIGHT - 100}, presenter);
-    }
 
     while(const auto event = presenter.pollEvent()) {
       if(event) slides->handle_events(presenter, *event);
     }
 
-    while (const auto event = controller.pollEvent()) {
+    control_ui.update(slides);
-      if(event) control_ui.handle_events(slides, *event);
-    }
 
     slides->render(presenter);
     control_ui.render(controller, *slides->$deck);