Add observer pattern to selection window

stevenewald · stevenewald · commit 75930cd1c9ec · 2024-11-24T13:21:00.000-06:00
diff --git a/source/graphics/basic_display.cpp b/source/graphics/basic_display.cpp
@@ -1,90 +1,65 @@
 #include "basic_display.hpp"
 
-#include "coordinates.hpp"
-#include "ends.hpp"
-
 #include <fmt/format.h>
 
 #include <cmath>
 
 namespace fractal {
 
-void BasicDisplay::display_window()
+void BasicDisplay::handle_event_(const sf::Event& event)
 {
-    bool left_mouse_down{};
-    float selection_start_x{};
-    float selection_start_y{};
-    float mouse_x{};
-    float mouse_y{};
-
-    while (window_.isOpen()) {
-        sf::Event event{};
-        while (window_.pollEvent(event)) {
-            switch (event.type) {
-                case sf::Event::Closed:
-                    window_.close();
-                    break;
-                case sf::Event::MouseMoved:
-                    mouse_x = static_cast<float>(event.mouseMove.x);
-                    mouse_y = static_cast<float>(event.mouseMove.y);
-                    break;
-
-                case sf::Event::MouseButtonPressed:
-                    if (event.mouseButton.button != sf::Mouse::Left) {
-                        break;
-                    }
-                    left_mouse_down = true;
-                    selection_start_x = static_cast<float>(event.mouseButton.x);
-                    selection_start_y = static_cast<float>(event.mouseButton.y);
-                    std::for_each(
-                        observers_.begin(), observers_.end(),
-                        [&](const auto& observer) {
-                            observer->on_mouse_button_pressed(event.mouseButton);
-                        }
-                    );
-                    break;
-                default:
-                    break;
-
-                case sf::Event::MouseButtonReleased:
-                    if (event.mouseButton.button != sf::Mouse::Left) {
-                        break;
-                    }
-                    std::for_each(
-                        observers_.begin(), observers_.end(),
-                        [&](const auto& observer) {
-                            observer->on_mouse_button_released(event.mouseButton);
-                        }
-                    );
-                    left_mouse_down = false;
-                    break;
+    switch (event.type) {
+        case sf::Event::MouseMoved:
+            for (const auto& observer : observers_) {
+                observer->on_mouse_moved(event.mouseMove);
             }
-        }
+            return;
+        case sf::Event::MouseButtonPressed:
+            std::for_each(
+                observers_.begin(), observers_.end(),
+                [&](const auto& observer) {
+                    observer->on_mouse_button_pressed(event.mouseButton);
+                }
+            );
+            return;
+        case sf::Event::MouseButtonReleased:
+            std::for_each(
+                observers_.begin(), observers_.end(),
+                [&](const auto& observer) {
+                    observer->on_mouse_button_released(event.mouseButton);
+                }
+            );
+            return;
+        default:
+            break;
+    }
+}
 
-        window_.clear(sf::Color::Black);
+void BasicDisplay::add_observer(std::unique_ptr<DisplayEventObserver> observer)
+{
+    observers_.push_back(std::move(observer));
+}
 
-        for (const auto& observer : observers_) {
-            auto opt = observer->get_drawable();
-            if (opt) {
-                window_.draw(opt.value());
-            }
-        }
+void BasicDisplay::poll_window_events()
+{
+    sf::Event event{};
+    while (window_.pollEvent(event)) {
+        handle_event_(event);
+    }
+}
 
-        if (left_mouse_down) {
-            display_coordinate end_point = calculate_end_points(
-                {selection_start_x, selection_start_y}, {mouse_x, mouse_y}
-            );
+void BasicDisplay::display_window()
+{
+    window_.clear(sf::Color::Black);
 
-            sf::RectangleShape selection_rectangle(
-                {end_point.first - selection_start_x,
-                 end_point.second - selection_start_y}
-            );
-            selection_rectangle.setPosition(selection_start_x, selection_start_y);
-            selection_rectangle.setFillColor(sf::Color(255, 0, 0, 127));
-            window_.draw(selection_rectangle);
+    auto draw_from_observer = [this](const auto& observer) {
+        if (auto opt = observer->get_drawable(); opt) {
+            window_.draw(*(opt.value()));
         }
+    };
 
-        window_.display();
-    }
+    std::for_each(observers_.begin(), observers_.end(), draw_from_observer);
+
+    window_.display();
 }
 } // namespace fractal
diff --git a/source/graphics/basic_display.hpp b/source/graphics/basic_display.hpp
@@ -14,16 +14,16 @@
 namespace fractal {
 class BasicDisplay {
     sf::RenderWindow window_{sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "SFML Window"};
-    std::vector<std::shared_ptr<DisplayEventObserver>> observers_;
+    std::vector<std::unique_ptr<DisplayEventObserver>> observers_;
+
+    void handle_event_(const sf::Event& event);
 
 public:
     explicit BasicDisplay() { window_.setFramerateLimit(FRAME_RATE); }
 
-    void add_observer(std::shared_ptr<DisplayEventObserver> observer)
-    {
-        observers_.push_back(std::move(observer));
-    }
+    void add_observer(std::unique_ptr<DisplayEventObserver> observer);
 
+    void poll_window_events();
     void display_window();
 };
 } // namespace fractal
diff --git a/source/graphics/display_event_observer.hpp b/source/graphics/display_event_observer.hpp
@@ -15,7 +15,7 @@ class DisplayEventObserver {
 
     virtual void on_mouse_button_released(const sf::Event::MouseButtonEvent&) {}
 
-    virtual std::optional<std::reference_wrapper<sf::Drawable>> get_drawable() = 0;
+    virtual std::optional<std::unique_ptr<sf::Drawable>> get_drawable() = 0;
 
     DisplayEventObserver() = default;
     DisplayEventObserver(DisplayEventObserver&&) = default;
diff --git a/source/graphics/selection.hpp b/source/graphics/selection.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+#include "coordinates.hpp"
+#include "graphics/display_event_observer.hpp"
+#include "graphics/ends.hpp"
+
+#include <SFML/Graphics/Drawable.hpp>
+#include <SFML/Graphics/RectangleShape.hpp>
+#include <SFML/System/Vector2.hpp>
+
+namespace fractal {
+class SelectionWindow : public DisplayEventObserver {
+    float selection_start_x_{};
+    float selection_start_y_{};
+    float current_mouse_x_{};
+    float current_mouse_y_{};
+    bool left_mouse_down_ = false;
+
+    void on_mouse_moved(const sf::Event::MouseMoveEvent& event) override
+    {
+        current_mouse_x_ = static_cast<float>(event.x);
+        current_mouse_y_ = static_cast<float>(event.y);
+    }
+
+    void on_mouse_button_pressed(const sf::Event::MouseButtonEvent& event) override
+    {
+        if (event.button != sf::Mouse::Left) {
+            return;
+        }
+        selection_start_x_ = static_cast<float>(event.x);
+        selection_start_y_ = static_cast<float>(event.y);
+        left_mouse_down_ = true;
+    }
+
+    void on_mouse_button_released(const sf::Event::MouseButtonEvent& event) override
+    {
+        if (event.button != sf::Mouse::Left) {
+            return;
+        }
+        left_mouse_down_ = false;
+    }
+
+    std::optional<std::unique_ptr<sf::Drawable>> get_drawable() override
+    {
+        if (!left_mouse_down_)
+            return std::nullopt;
+        display_coordinate end_point = calculate_end_points(
+            {selection_start_x_, selection_start_y_},
+            {current_mouse_x_, current_mouse_y_}
+        );
+
+        auto rectangle = std::make_unique<sf::RectangleShape>(sf::Vector2f{
+            static_cast<float>(end_point.first) - selection_start_x_,
+            static_cast<float>(end_point.second) - selection_start_y_
+        });
+        rectangle->setPosition(selection_start_x_, selection_start_y_);
+        rectangle->setFillColor(sf::Color(255, 0, 0, 127));
+        return rectangle;
+    }
+};
+} // namespace fractal
diff --git a/source/main.cpp b/source/main.cpp
@@ -1,4 +1,5 @@
 #include "graphics/basic_display.hpp"
+#include "graphics/selection.hpp"
 #include "mandelbrot.hpp"
 
 #include <argparse/argparse.hpp>
@@ -7,11 +8,13 @@ namespace fractal {
 
 void display_mandelbrot()
 {
-    auto t = std::make_shared<Mandelbrot>();
     BasicDisplay display;
-    display.add_observer(t);
+
+    display.add_observer(std::make_unique<Mandelbrot>());
+    display.add_observer(std::make_unique<SelectionWindow>());
 
     while (true) {
+        display.poll_window_events();
         display.display_window();
     }
 }
diff --git a/source/mandelbrot.hpp b/source/mandelbrot.hpp
@@ -47,7 +47,6 @@ class Mandelbrot : public DisplayEventObserver {
     complex_domain domain_ = START_COMPLEX_DOMAIN;
     sf::Image image_;
     sf::Texture texture_;
-    sf::Sprite sprite_{texture_};
     int start_x{};
     int start_y{};
 
@@ -105,15 +104,12 @@ class Mandelbrot : public DisplayEventObserver {
         flush_buffer();
     }
 
-    void flush_buffer()
-    {
-        texture_.loadFromImage(image_);
-        sprite_ = sf::Sprite{texture_};
-    }
+    void flush_buffer() {}
 
-    std::optional<std::reference_wrapper<sf::Drawable>> get_drawable() override
+    std::optional<std::unique_ptr<sf::Drawable>> get_drawable() override
     {
-        return sprite_;
+        texture_.loadFromImage(image_);
+        return std::make_unique<sf::Sprite>(texture_);
     }
 };
 } // namespace fractal

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#include "graphics/basic_display.hpp"`
	`2`	`+#include "graphics/selection.hpp"`
`2`	`3`	`#include "mandelbrot.hpp"`
`3`	`4`
`4`	`5`	`#include <argparse/argparse.hpp>`
`@@ -7,11 +8,13 @@ namespace fractal {`
`7`	`8`
`8`	`9`	`void display_mandelbrot()`
`9`	`10`	`{`
`10`		`- auto t = std::make_shared<Mandelbrot>();`
`11`	`11`	`BasicDisplay display;`
`12`		`- display.add_observer(t);`
	`12`	`+`
	`13`	`+ display.add_observer(std::make_unique<Mandelbrot>());`
	`14`	`+ display.add_observer(std::make_unique<SelectionWindow>());`
`13`	`15`
`14`	`16`	`while (true) {`
	`17`	`+ display.poll_window_events();`
`15`	`18`	`display.display_window();`
`16`	`19`	`}`
`17`	`20`	`}`