Remove the stale legacy-cpp implementation

The Rust rewrite (crates/) has fully superseded it - keeping both around
was actively misleading (main looked like it still shipped a C++ build),
and nothing here still depends on it.

1 files changed, 0 insertions, 673 deletions

diff --git a/legacy-cpp/src/core/window_manager.cc b/legacy-cpp/src/core/window_manager.cc
deleted file mode 100644
index 08033fe..0000000
--- a/legacy-cpp/src/core/window_manager.cc
+++ /dev/null
@@ -1,673 +0,0 @@
-#include "window_manager.h"
-#include "window.h"
-#include "../input/input_handler.h"
-#include "../layouts/layout_engine.h"
-#include "../platform/platform.h"
-#include "../config/lua_manager.h"
-#include <iostream>
-#include <chrono>
-#include <thread>
-
-SRDWindowManager::SRDWindowManager() {
-    std::cout << "SRDWindowManager: Initializing..." << std::endl;
-}
-
-SRDWindowManager::~SRDWindowManager() {
-    std::cout << "SRDWindowManager: Shutting down..." << std::endl;
-}
-
-void SRDWindowManager::run() {
-    // Main event loop
-    std::cout << "SRDWindowManager: Starting main loop" << std::endl;
-    
-    if (!platform_) {
-        std::cerr << "SRDWindowManager: No platform available, cannot run" << std::endl;
-        return;
-    }
-    
-    std::cout << "SRDWindowManager: Entering main event loop..." << std::endl;
-    
-    bool running = true;
-    while (running) {
-        // Poll for platform events
-        std::vector<Event> events;
-        if (platform_->poll_events(events)) {
-            // Process all events
-            for (const auto& event : events) {
-                handle_event(event);
-                
-                // Check for exit condition
-                if (event.type == EventType::KeyPress) {
-                    // TODO: Check for exit key combination
-                    // For now, just continue
-                }
-            }
-        }
-        
-        // Manage windows
-        manage_windows();
-        
-        // Arrange windows if needed
-        if (layout_engine_) {
-            layout_engine_->arrange_all_monitors();
-        }
-        
-        // Small delay to prevent busy waiting
-        // TODO: Use proper event-driven approach instead of polling
-        std::this_thread::sleep_for(std::chrono::milliseconds(16)); // ~60 FPS
-    }
-    
-    std::cout << "SRDWindowManager: Main loop ended" << std::endl;
-}
-
-// SRDWindow management
-void SRDWindowManager::add_window(std::unique_ptr<SRDWindow> window) {
-    if (window) {
-        windows_.push_back(window.get());
-        window.release(); // Transfer ownership
-        
-        // Add to layout engine if available
-        if (layout_engine_) {
-            layout_engine_->add_window(window.get());
-        }
-        
-        std::cout << "SRDWindowManager: Added window " << window->getId() << std::endl;
-    }
-}
-
-void SRDWindowManager::remove_window(SRDWindow* window) {
-    auto it = std::find(windows_.begin(), windows_.end(), window);
-    if (it != windows_.end()) {
-        windows_.erase(it);
-        
-        // Remove from layout engine if available
-        if (layout_engine_) {
-            layout_engine_->remove_window(window);
-        }
-        
-        std::cout << "SRDWindowManager: Removed window " << window->getId() << std::endl;
-    }
-}
-
-void SRDWindowManager::focus_window(SRDWindow* window) {
-    focused_window_ = window;
-    std::cout << "SRDWindowManager: Focused window " << (window ? window->getId() : -1) << std::endl;
-}
-
-SRDWindow* SRDWindowManager::get_focused_window() const {
-    return focused_window_;
-}
-
-std::vector<SRDWindow*> SRDWindowManager::get_windows() const {
-    return windows_;
-}
-
-void SRDWindowManager::focus_next_window() {
-    if (windows_.empty()) return;
-    
-    if (!focused_window_) {
-        // No window focused, focus the first one
-        focus_window(windows_[0]);
-        return;
-    }
-    
-    // Find current focused window index
-    auto it = std::find(windows_.begin(), windows_.end(), focused_window_);
-    if (it == windows_.end()) {
-        focus_window(windows_[0]);
-        return;
-    }
-    
-    // Move to next window (wrap around)
-    ++it;
-    if (it == windows_.end()) {
-        it = windows_.begin();
-    }
-    
-    focus_window(*it);
-    std::cout << "SRDWindowManager: Focused next window " << (*it)->getId() << std::endl;
-}
-
-void SRDWindowManager::focus_previous_window() {
-    if (windows_.empty()) return;
-    
-    if (!focused_window_) {
-        // No window focused, focus the last one
-        focus_window(windows_.back());
-        return;
-    }
-    
-    // Find current focused window index
-    auto it = std::find(windows_.begin(), windows_.end(), focused_window_);
-    if (it == windows_.end()) {
-        focus_window(windows_.back());
-        return;
-    }
-    
-    // Move to previous window (wrap around)
-    if (it == windows_.begin()) {
-        it = windows_.end() - 1;
-    } else {
-        --it;
-    }
-    
-    focus_window(*it);
-    std::cout << "SRDWindowManager: Focused previous window " << (*it)->getId() << std::endl;
-}
-
-void SRDWindowManager::manage_windows() {
-    // Manage window states
-    std::cout << "SRDWindowManager: Managing " << windows_.size() << " windows" << std::endl;
-}
-
-// SRDWindow operations
-void SRDWindowManager::close_window(SRDWindow* window) {
-    if (window) {
-        std::cout << "SRDWindowManager: Closing window " << window->getId() << std::endl;
-        // TODO: Implement actual window closing
-    }
-}
-
-void SRDWindowManager::minimize_window(SRDWindow* window) {
-    if (window) {
-        std::cout << "SRDWindowManager: Minimizing window " << window->getId() << std::endl;
-        // TODO: Implement actual window minimizing
-    }
-}
-
-void SRDWindowManager::maximize_window(SRDWindow* window) {
-    if (window) {
-        std::cout << "SRDWindowManager: Maximizing window " << window->getId() << std::endl;
-        // TODO: Implement actual window maximizing
-    }
-}
-
-void SRDWindowManager::move_window(SRDWindow* window, int x, int y) {
-    if (window) {
-        window->setPosition(x, y);
-        update_layout_for_window(window);
-        std::cout << "SRDWindowManager: Moved window " << window->getId() << " to (" << x << ", " << y << ")" << std::endl;
-    }
-}
-
-void SRDWindowManager::resize_window(SRDWindow* window, int width, int height) {
-    if (window) {
-        window->setSize(width, height);
-        update_layout_for_window(window);
-        std::cout << "SRDWindowManager: Resized window " << window->getId() << " to " << width << "x" << height << std::endl;
-    }
-}
-
-void SRDWindowManager::toggle_window_floating(SRDWindow* window) {
-    if (!window) return;
-    
-    auto it = floating_windows_.find(window);
-    if (it != floating_windows_.end()) {
-        // Window is floating, make it tiled
-        floating_windows_.erase(it);
-        std::cout << "SRDWindowManager: Window " << window->getId() << " is now tiled" << std::endl;
-    } else {
-        // Window is tiled, make it floating
-        floating_windows_.insert(window);
-        std::cout << "SRDWindowManager: Window " << window->getId() << " is now floating" << std::endl;
-    }
-    
-    // Re-arrange windows to reflect the change
-    arrange_windows();
-}
-
-bool SRDWindowManager::is_window_floating(SRDWindow* window) const {
-    if (!window) return false;
-    return floating_windows_.find(window) != floating_windows_.end();
-}
-
-// Window dragging and resizing implementation
-void SRDWindowManager::start_window_drag(SRDWindow* window, int start_x, int start_y) {
-    if (!window || dragging_window_) return;
-    
-    dragging_window_ = window;
-    drag_start_x_ = start_x;
-    drag_start_y_ = start_y;
-    drag_start_window_x_ = window->getX();
-    drag_start_window_y_ = window->getY();
-    
-    std::cout << "SRDWindowManager: Started dragging window " << window->getId() << std::endl;
-}
-
-void SRDWindowManager::start_window_resize(SRDWindow* window, int start_x, int start_y, int edge) {
-    if (!window || resizing_window_) return;
-    
-    resizing_window_ = window;
-    resize_start_x_ = start_x;
-    resize_start_y_ = start_y;
-    resize_start_width_ = window->getWidth();
-    resize_start_height_ = window->getHeight();
-    resize_edge_ = edge;
-    
-    std::cout << "SRDWindowManager: Started resizing window " << window->getId() << " edge: " << edge << std::endl;
-}
-
-void SRDWindowManager::update_window_drag(int x, int y) {
-    if (!dragging_window_) return;
-    
-    int delta_x = x - drag_start_x_;
-    int delta_y = y - drag_start_y_;
-    
-    int new_x = drag_start_window_x_ + delta_x;
-    int new_y = drag_start_window_y_ + delta_y;
-    
-    // Ensure window stays within monitor bounds
-    // TODO: Get actual monitor bounds
-    new_x = std::max(0, std::min(new_x, 1920 - dragging_window_->getWidth()));
-    new_y = std::max(0, std::min(new_y, 1080 - dragging_window_->getHeight()));
-    
-    dragging_window_->setPosition(new_x, new_y);
-    update_layout_for_window(dragging_window_);
-}
-
-void SRDWindowManager::update_window_resize(int x, int y) {
-    if (!resizing_window_) return;
-    
-    int delta_x = x - resize_start_x_;
-    int delta_y = y - resize_start_y_;
-    
-    int new_width = resize_start_width_;
-    int new_height = resize_start_height_;
-    int new_x = resizing_window_->getX();
-    int new_y = resizing_window_->getY();
-    
-    // Handle different resize edges
-    switch (resize_edge_) {
-        case 1: // Left edge
-            new_width = std::max(100, resize_start_width_ - delta_x);
-            new_x = resize_start_x_ + resize_start_width_ - new_width;
-            break;
-        case 2: // Right edge
-            new_width = std::max(100, resize_start_width_ + delta_x);
-            break;
-        case 3: // Top edge
-            new_height = std::max(100, resize_start_height_ - delta_y);
-            new_y = resize_start_y_ + resize_start_height_ - new_height;
-            break;
-        case 4: // Bottom edge
-            new_height = std::max(100, resize_start_height_ + delta_y);
-            break;
-        case 5: // Corner (both width and height)
-            new_width = std::max(100, resize_start_width_ + delta_x);
-            new_height = std::max(100, resize_start_height_ + delta_y);
-            break;
-    }
-    
-    // Ensure minimum size and bounds
-    new_width = std::max(100, std::min(new_width, 1920 - new_x));
-    new_height = std::max(100, std::min(new_height, 1080 - new_y));
-    
-    resizing_window_->setPosition(new_x, new_y);
-    resizing_window_->setSize(new_width, new_height);
-    update_layout_for_window(resizing_window_);
-}
-
-void SRDWindowManager::end_window_drag() {
-    if (dragging_window_) {
-        std::cout << "SRDWindowManager: Ended dragging window " << dragging_window_->getId() << std::endl;
-        dragging_window_ = nullptr;
-    }
-}
-
-void SRDWindowManager::end_window_resize() {
-    if (resizing_window_) {
-        std::cout << "SRDWindowManager: Ended resizing window " << resizing_window_->getId() << std::endl;
-        resizing_window_ = nullptr;
-    }
-}
-
-// Layout management
-void SRDWindowManager::set_layout(int monitor_id, const std::string& layout_name) {
-    if (layout_engine_) {
-        layout_engine_->set_layout(monitor_id, layout_name);
-        std::cout << "SRDWindowManager: Set layout '" << layout_name << "' for monitor " << monitor_id << std::endl;
-    }
-}
-
-std::string SRDWindowManager::get_layout(int monitor_id) const {
-    if (layout_engine_) {
-        return layout_engine_->get_layout_name(monitor_id);
-    }
-    return "dynamic";
-}
-
-void SRDWindowManager::arrange_windows() {
-    if (layout_engine_) {
-        layout_engine_->arrange_all_monitors();
-        std::cout << "SRDWindowManager: Arranged all windows" << std::endl;
-    }
-}
-
-void SRDWindowManager::tile_windows() {
-    set_layout(0, "tiling");
-    arrange_windows();
-}
-
-void SRDWindowManager::arrange_windows_dynamic() {
-    set_layout(0, "dynamic");
-    arrange_windows();
-}
-
-// Key binding system
-void SRDWindowManager::bind_key(const std::string& key_combination, std::function<void()> action) {
-    key_bindings_[key_combination] = action;
-    std::cout << "SRDWindowManager: Bound key '" << key_combination << "'" << std::endl;
-}
-
-void SRDWindowManager::unbind_key(const std::string& key_combination) {
-    auto it = key_bindings_.find(key_combination);
-    if (it != key_bindings_.end()) {
-        key_bindings_.erase(it);
-        std::cout << "SRDWindowManager: Unbound key '" << key_combination << "'" << std::endl;
-    }
-}
-
-void SRDWindowManager::handle_key_press(int key_code, int modifiers) {
-    std::string key_string = key_code_to_string(key_code, modifiers);
-    pressed_keys_[key_code] = modifiers;
-    
-    std::cout << "SRDWindowManager: Key press " << key_code << " (modifiers: " << modifiers << ") -> '" << key_string << "'" << std::endl;
-    
-    // Check for key bindings
-    auto it = key_bindings_.find(key_string);
-    if (it != key_bindings_.end()) {
-        std::cout << "SRDWindowManager: Executing key binding for '" << key_string << "'" << std::endl;
-        it->second();
-    }
-}
-
-void SRDWindowManager::handle_key_release(int key_code, int modifiers) {
-    pressed_keys_.erase(key_code);
-    std::cout << "SRDWindowManager: Key release " << key_code << std::endl;
-}
-
-// Integration
-void SRDWindowManager::set_layout_engine(LayoutEngine* engine) {
-    layout_engine_ = engine;
-    std::cout << "SRDWindowManager: Layout engine connected" << std::endl;
-}
-
-void SRDWindowManager::set_lua_manager(LuaManager* manager) {
-    lua_manager_ = manager;
-    std::cout << "SRDWindowManager: Lua manager connected" << std::endl;
-}
-
-void SRDWindowManager::set_platform(Platform* platform) {
-    platform_ = platform;
-    std::cout << "SRDWindowManager: Platform connected" << std::endl;
-}
-
-// Legacy input handling (for compatibility)
-void SRDWindowManager::handle_key_press(int key_code) {
-    handle_key_press(key_code, 0);
-}
-
-void SRDWindowManager::handle_key_release(int key_code) {
-    handle_key_release(key_code, 0);
-}
-
-void SRDWindowManager::handle_mouse_button_press(int button, int x, int y) {
-    std::cout << "SRDWindowManager: Mouse button press " << button << " at (" << x << ", " << y << ")" << std::endl;
-    
-    // Find window under cursor
-    SRDWindow* window_under_cursor = find_window_at_position(x, y);
-    
-    if (window_under_cursor) {
-        // Focus the window
-        focus_window(window_under_cursor);
-        
-        // Handle different mouse buttons
-        if (button == 1) { // Left button - start drag or resize
-            if (is_in_titlebar_area(window_under_cursor, x, y)) {
-                // Start dragging from titlebar
-                start_window_drag(window_under_cursor, x, y);
-            } else if (is_in_resize_area(window_under_cursor, x, y)) {
-                // Start resizing
-                int edge = get_resize_edge(window_under_cursor, x, y);
-                start_window_resize(window_under_cursor, x, y, edge);
-            }
-        }
-    }
-}
-
-void SRDWindowManager::handle_mouse_button_release(int button, int x, int y) {
-    std::cout << "SRDWindowManager: Mouse button release " << button << " at (" << x << ", " << y << ")" << std::endl;
-    
-    if (button == 1) { // Left button
-        if (is_dragging()) {
-            end_window_drag();
-        } else if (is_resizing()) {
-            end_window_resize();
-        }
-    }
-}
-
-void SRDWindowManager::handle_mouse_motion(int x, int y) {
-    // Only log if we're not dragging or resizing to avoid spam
-    if (!is_dragging() && !is_resizing()) {
-        std::cout << "SRDWindowManager: Mouse motion to (" << x << ", " << y << ")" << std::endl;
-    }
-    
-    // Update drag or resize if active
-    if (is_dragging()) {
-        update_window_drag(x, y);
-    } else if (is_resizing()) {
-        update_window_resize(x, y);
-    }
-}
-
-void SRDWindowManager::handle_event(const Event& event) {
-    std::cout << "SRDWindowManager: Handling event type " << static_cast<int>(event.type) << std::endl;
-}
-
-// Workspace management
-void SRDWindowManager::add_workspace(const std::string& name) {
-    Workspace workspace(next_workspace_id_++, name);
-    workspaces_.push_back(workspace);
-    
-    // If this is the first workspace, make it current
-    if (workspaces_.size() == 1) {
-        current_workspace_ = workspace.id;
-        workspace.visible = true;
-    }
-    
-    std::cout << "SRDWindowManager: Added workspace " << workspace.id << " (" << name << ")" << std::endl;
-}
-
-void SRDWindowManager::remove_workspace(int workspace_id) {
-    auto it = std::find_if(workspaces_.begin(), workspaces_.end(),
-                           [workspace_id](const Workspace& w) { return w.id == workspace_id; });
-    
-    if (it != workspaces_.end()) {
-        // Move windows to current workspace if removing current
-        if (workspace_id == current_workspace_) {
-            for (auto* window : it->windows) {
-                move_window_to_workspace(window, current_workspace_);
-            }
-        }
-        
-        workspaces_.erase(it);
-        std::cout << "SRDWindowManager: Removed workspace " << workspace_id << std::endl;
-    }
-}
-
-void SRDWindowManager::switch_to_workspace(int workspace_id) {
-    auto* workspace = get_workspace(workspace_id);
-    if (workspace) {
-        // Hide current workspace
-        auto* current = get_workspace(current_workspace_);
-        if (current) {
-            current->visible = false;
-        }
-        
-        // Show new workspace
-        current_workspace_ = workspace_id;
-        workspace->visible = true;
-        
-        // Arrange windows on the new workspace
-        arrange_workspace_windows(workspace_id);
-        
-        std::cout << "SRDWindowManager: Switched to workspace " << workspace_id << std::endl;
-    }
-}
-
-void SRDWindowManager::move_window_to_workspace(SRDWindow* window, int workspace_id) {
-    if (!window) return;
-    
-    auto* target_workspace = get_workspace(workspace_id);
-    if (!target_workspace) return;
-    
-    // Remove from current workspace
-    for (auto& workspace : workspaces_) {
-        auto it = std::find(workspace.windows.begin(), workspace.windows.end(), window);
-        if (it != workspace.windows.end()) {
-            workspace.windows.erase(it);
-            break;
-        }
-    }
-    
-    // Add to target workspace
-    target_workspace->windows.push_back(window);
-    
-    std::cout << "SRDWindowManager: Moved window " << window->getId() 
-              << " to workspace " << workspace_id << std::endl;
-}
-
-int SRDWindowManager::get_current_workspace() const {
-    return current_workspace_;
-}
-
-std::vector<Workspace> SRDWindowManager::get_workspaces() const {
-    return workspaces_;
-}
-
-Workspace* SRDWindowManager::get_workspace(int workspace_id) {
-    auto it = std::find_if(workspaces_.begin(), workspaces_.end(),
-                           [workspace_id](const Workspace& w) { return w.id == workspace_id; });
-    return it != workspaces_.end() ? &(*it) : nullptr;
-}
-
-// Helper methods
-std::string SRDWindowManager::key_code_to_string(int key_code, int modifiers) const {
-    std::string result;
-    
-    // Add modifiers
-    if (modifiers & 0x01) result += "Ctrl+";  // Control
-    if (modifiers & 0x02) result += "Shift+"; // Shift
-    if (modifiers & 0x04) result += "Alt+";   // Alt
-    if (modifiers & 0x08) result += "Mod4+";  // Super/SRDWindows
-    
-    // Add key
-    if (key_code >= 'A' && key_code <= 'Z') {
-        result += static_cast<char>(key_code);
-    } else if (key_code >= '0' && key_code <= '9') {
-        result += static_cast<char>(key_code);
-    } else {
-        result += "Key" + std::to_string(key_code);
-    }
-    
-    return result;
-}
-
-void SRDWindowManager::execute_key_binding(const std::string& key_combination) {
-    auto it = key_bindings_.find(key_combination);
-    if (it != key_bindings_.end()) {
-        it->second();
-    }
-}
-
-void SRDWindowManager::update_layout_for_window(SRDWindow* window) {
-    if (layout_engine_) {
-        layout_engine_->update_window(window);
-    }
-}
-
-void SRDWindowManager::arrange_workspace_windows(int workspace_id) {
-    auto* workspace = get_workspace(workspace_id);
-    if (!workspace || !layout_engine_) return;
-    
-    // Get monitor for current workspace (simplified - assuming single monitor for now)
-    if (!workspace->windows.empty() && !monitors_.empty()) {
-        // Arrange windows using the layout engine
-        // TODO: Get the actual monitor for this workspace
-        layout_engine_->arrange_on_monitor(monitors_[0]);
-    }
-}
-
-void SRDWindowManager::update_workspace_visibility() {
-    for (auto& workspace : workspaces_) {
-        workspace.visible = (workspace.id == current_workspace_);
-    }
-}
-
-// Window interaction helper methods
-SRDWindow* SRDWindowManager::find_window_at_position(int x, int y) const {
-    // Find the topmost window at the given position
-    // For now, just check if point is within any window bounds
-    // TODO: Implement proper z-order checking
-    for (auto* window : windows_) {
-        if (x >= window->getX() && x < window->getX() + window->getWidth() &&
-            y >= window->getY() && y < window->getY() + window->getHeight()) {
-            return window;
-        }
-    }
-    return nullptr;
-}
-
-bool SRDWindowManager::is_in_titlebar_area(SRDWindow* window, int x, int y) const {
-    if (!window) return false;
-    
-    // Check if point is in the top area of the window (titlebar region)
-    // Titlebar is typically the top 20-30 pixels of the window
-    int titlebar_height = 30;
-    
-    return (x >= window->getX() && x < window->getX() + window->getWidth() &&
-            y >= window->getY() && y < window->getY() + titlebar_height);
-}
-
-bool SRDWindowManager::is_in_resize_area(SRDWindow* window, int x, int y) const {
-    if (!window) return false;
-    
-    // Check if point is near the edges of the window (resize handles)
-    int resize_margin = 5;
-    
-    int left = window->getX();
-    int right = left + window->getWidth();
-    int top = window->getY();
-    int bottom = top + window->getHeight();
-    
-    return (x <= left + resize_margin || x >= right - resize_margin ||
-            y <= top + resize_margin || y >= bottom - resize_margin);
-}
-
-int SRDWindowManager::get_resize_edge(SRDWindow* window, int x, int y) const {
-    if (!window) return 0;
-    
-    int resize_margin = 5;
-    int left = window->getX();
-    int right = left + window->getWidth();
-    int top = window->getY();
-    int bottom = top + window->getHeight();
-    
-    bool near_left = (x <= left + resize_margin);
-    bool near_right = (x >= right - resize_margin);
-    bool near_top = (y <= top + resize_margin);
-    bool near_bottom = (y >= bottom - resize_margin);
-    
-    // Determine which edge or corner
-    if (near_left && near_top) return 5;      // Top-left corner
-    if (near_right && near_top) return 5;     // Top-right corner
-    if (near_left && near_bottom) return 5;   // Bottom-left corner
-    if (near_right && near_bottom) return 5;  // Bottom-right corner
-    if (near_left) return 1;                  // Left edge
-    if (near_right) return 2;                 // Right edge
-    if (near_top) return 3;                   // Top edge
-    if (near_bottom) return 4;                // Bottom edge
-    
-    return 0; // No resize edge
-}