1 files changed, 188 insertions, 0 deletions
diff --git a/src/layouts/layout_engine.cc b/src/layouts/layout_engine.cc
new file mode 100644
index 0000000..f6bc20f
--- /dev/null
+++ b/src/layouts/layout_engine.cc
@@ -0,0 +1,188 @@
+#include "layout_engine.h"
+#include <iostream>
+#include <algorithm>
+
+LayoutEngine::LayoutEngine() {
+    std::cout << "LayoutEngine: Initializing..." << std::endl;
+}
+
+LayoutEngine::~LayoutEngine() {
+    std::cout << "LayoutEngine: Shutting down..." << std::endl;
+}
+
+// Layout management
+bool LayoutEngine::set_layout(int monitor_id, LayoutType layout_type) {
+    active_layouts_[monitor_id] = layout_type;
+    std::cout << "LayoutEngine: Set layout " << layout_type_to_string(layout_type) 
+              << " for monitor " << monitor_id << std::endl;
+    return true;
+}
+
+bool LayoutEngine::set_layout(int monitor_id, const std::string& layout_name) {
+    LayoutType layout_type = string_to_layout_type(layout_name);
+    if (layout_type != LayoutType::TILING && layout_type != LayoutType::DYNAMIC && layout_type != LayoutType::FLOATING) {
+        std::cerr << "LayoutEngine: Unknown layout type: " << layout_name << std::endl;
+        return false;
+    }
+    return set_layout(monitor_id, layout_type);
+}
+
+LayoutType LayoutEngine::get_layout(int monitor_id) const {
+    auto it = active_layouts_.find(monitor_id);
+    if (it != active_layouts_.end()) {
+        return it->second;
+    }
+    return LayoutType::DYNAMIC; // Default layout
+}
+
+std::string LayoutEngine::get_layout_name(int monitor_id) const {
+    return layout_type_to_string(get_layout(monitor_id));
+}
+
+// Layout configuration
+bool LayoutEngine::configure_layout(const std::string& layout_name, const std::map<std::string, std::string>& config) {
+    layout_configs_[layout_name] = config;
+    std::cout << "LayoutEngine: Configured layout '" << layout_name << "' with " 
+              << config.size() << " parameters" << std::endl;
+    return true;
+}
+
+bool LayoutEngine::register_custom_layout(const std::string& name, std::function<void(const std::vector<SRDWindow*>&, const Monitor&)> layout_func) {
+    custom_layouts_[name] = layout_func;
+    std::cout << "LayoutEngine: Registered custom layout '" << name << "'" << std::endl;
+    return true;
+}
+
+// SRDWindow management
+void LayoutEngine::add_window(SRDWindow* window) {
+    if (window && std::find(windows_.begin(), windows_.end(), window) == windows_.end()) {
+        windows_.push_back(window);
+        std::cout << "LayoutEngine: Added window " << window->getId() << std::endl;
+    }
+}
+
+void LayoutEngine::remove_window(SRDWindow* window) {
+    auto it = std::find(windows_.begin(), windows_.end(), window);
+    if (it != windows_.end()) {
+        windows_.erase(it);
+        std::cout << "LayoutEngine: Removed window " << window->getId() << std::endl;
+    }
+}
+
+void LayoutEngine::update_window(SRDWindow* window) {
+    // Trigger rearrangement for the monitor this window is on
+    // For now, just log the update
+    std::cout << "LayoutEngine: Updated window " << window->getId() << std::endl;
+}
+
+// Monitor management
+void LayoutEngine::add_monitor(const Monitor& monitor) {
+    // Check if monitor already exists
+    auto it = std::find_if(monitors_.begin(), monitors_.end(), 
+                          [&](const Monitor& m) { return m.id == monitor.id; });
+    if (it == monitors_.end()) {
+        monitors_.push_back(monitor);
+        // Set default layout for new monitor
+        active_layouts_[monitor.id] = LayoutType::DYNAMIC;
+        std::cout << "LayoutEngine: Added monitor " << monitor.id << std::endl;
+    }
+}
+
+void LayoutEngine::remove_monitor(int monitor_id) {
+    auto it = std::find_if(monitors_.begin(), monitors_.end(), 
+                          [monitor_id](const Monitor& m) { return m.id == monitor_id; });
+    if (it != monitors_.end()) {
+        monitors_.erase(it);
+        active_layouts_.erase(monitor_id);
+        std::cout << "LayoutEngine: Removed monitor " << monitor_id << std::endl;
+    }
+}
+
+void LayoutEngine::update_monitor(const Monitor& monitor) {
+    auto it = std::find_if(monitors_.begin(), monitors_.end(), 
+                          [&](const Monitor& m) { return m.id == monitor.id; });
+    if (it != monitors_.end()) {
+        *it = monitor;
+        std::cout << "LayoutEngine: Updated monitor " << monitor.id << std::endl;
+    }
+}
+
+// Arrangement
+void LayoutEngine::arrange_on_monitor(const Monitor& monitor) {
+    if (active_layouts_.count(monitor.id)) {
+        LayoutType current_layout_type = active_layouts_[monitor.id];
+        std::vector<SRDWindow*> windows_on_monitor = get_windows_on_monitor(monitor.id);
+        
+        std::cout << "LayoutEngine: Arranging " << windows_on_monitor.size() 
+                  << " windows on monitor " << monitor.id 
+                  << " with layout " << layout_type_to_string(current_layout_type) << std::endl;
+
+        if (current_layout_type == LayoutType::TILING) {
+            tiling_layout_.arrange_windows(windows_on_monitor, monitor);
+        } else if (current_layout_type == LayoutType::DYNAMIC) {
+            dynamic_layout_.arrange_windows(windows_on_monitor, monitor);
+        } else if (current_layout_type == LayoutType::FLOATING) {
+            // Floating layout - windows keep their current positions
+            std::cout << "LayoutEngine: Floating layout - no arrangement needed" << std::endl;
+        }
+    }
+}
+
+void LayoutEngine::arrange_all_monitors() {
+    for (const auto& monitor : monitors_) {
+        arrange_on_monitor(monitor);
+    }
+}
+
+// Utility
+std::vector<std::string> LayoutEngine::get_available_layouts() const {
+    return {"tiling", "dynamic", "floating"};
+}
+
+std::vector<SRDWindow*> LayoutEngine::get_windows_on_monitor(int monitor_id) const {
+    std::vector<SRDWindow*> windows_on_monitor;
+    
+    // Find the monitor
+    auto monitor_it = std::find_if(monitors_.begin(), monitors_.end(), 
+                                  [monitor_id](const Monitor& m) { return m.id == monitor_id; });
+    if (monitor_it == monitors_.end()) {
+        return windows_on_monitor;
+    }
+    
+    // Get windows that are on this monitor
+    for (SRDWindow* window : windows_) {
+        if (is_window_on_monitor(window, *monitor_it)) {
+            windows_on_monitor.push_back(window);
+        }
+    }
+    
+    return windows_on_monitor;
+}
+
+// Helper methods
+LayoutType LayoutEngine::string_to_layout_type(const std::string& name) const {
+    if (name == "tiling") return LayoutType::TILING;
+    if (name == "dynamic") return LayoutType::DYNAMIC;
+    if (name == "floating") return LayoutType::FLOATING;
+    return LayoutType::DYNAMIC; // Default
+}
+
+std::string LayoutEngine::layout_type_to_string(LayoutType type) const {
+    switch (type) {
+        case LayoutType::TILING: return "tiling";
+        case LayoutType::DYNAMIC: return "dynamic";
+        case LayoutType::FLOATING: return "floating";
+        default: return "dynamic";
+    }
+}
+
+bool LayoutEngine::is_window_on_monitor(const SRDWindow* window, const Monitor& monitor) const {
+    if (!window) return false;
+    
+    // Simple check: window center is within monitor bounds
+    int window_center_x = window->getX() + window->getWidth() / 2;
+    int window_center_y = window->getY() + window->getHeight() / 2;
+    
+    return window_center_x >= monitor.x && window_center_x < monitor.x + monitor.width &&
+           window_center_y >= monitor.y && window_center_y < monitor.y + monitor.height;
+}