Add Linux window management implementation

Author: lijy91

src/menu.cpp

@@ -0,0 +1,36 @@
+#include "menu.h"
+#include <sstream>
+
+namespace nativeapi {
+
+std::string KeyboardAccelerator::ToString() const {
+    std::ostringstream oss;
+    bool first = true;
+    if (modifiers & Ctrl) {
+        oss << "Ctrl";
+        first = false;
+    }
+    if (modifiers & Alt) {
+        if (!first) oss << "+";
+        oss << "Alt";
+        first = false;
+    }
+    if (modifiers & Shift) {
+        if (!first) oss << "+";
+        oss << "Shift";
+        first = false;
+    }
+    if (modifiers & Meta) {
+        if (!first) oss << "+";
+        oss << "Meta";
+        first = false;
+    }
+    if (!key.empty()) {
+        if (!first) oss << "+";
+        oss << key;
+    }
+    return oss.str();
+}
+
+} // namespace nativeapi
+

src/platform/linux/app_runner_linux.cpp

@@ -0,0 +1,76 @@
+#include <iostream>
+
+#include "../../app_runner.h"
+#include "../../window.h"
+
+// Import GTK headers
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+
+namespace nativeapi {
+
+// Private implementation for Linux using GTK
+class AppRunner::Impl {
+public:
+  Impl() {
+    // GTK initialization is handled by WindowManager
+    // No need to initialize again here
+  }
+
+  ~Impl() {
+    // GTK cleanup is handled automatically
+  }
+
+  int Run(std::shared_ptr<Window> window) {
+    if (!window) {
+      std::cerr << "Cannot run application with null window" << std::endl;
+      return -1;
+    }
+
+    // Check if GTK is available
+    GdkDisplay* display = gdk_display_get_default();
+    if (!display) {
+      std::cerr << "No display available - cannot run application" << std::endl;
+      return -1;
+    }
+
+    std::cout << "Starting application with window ID: " << window->id << std::endl;
+
+    // Connect to the window destroy signal to quit the main loop
+    // when the window is closed
+    if (window->id != 0) {
+      // Find the GTK window corresponding to our Window object
+      GList* toplevels = gtk_window_list_toplevels();
+      for (GList* l = toplevels; l != nullptr; l = l->next) {
+        GtkWindow* gtk_window = GTK_WINDOW(l->data);
+        GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(gtk_window));
+
+        if (gdk_window && (WindowID)gdk_window == window->id) {
+          // Connect destroy signal to quit the main loop
+          g_signal_connect(gtk_window, "destroy", G_CALLBACK(gtk_main_quit), nullptr);
+          break;
+        }
+      }
+      g_list_free(toplevels);
+    }
+
+    // Run the GTK main loop
+    std::cout << "Starting GTK main loop..." << std::endl;
+    gtk_main();
+
+    std::cout << "Application finished" << std::endl;
+    return 0;
+  }
+};
+
+// AppRunner implementation
+AppRunner::AppRunner() : pimpl_(std::make_unique<Impl>()) {
+}
+
+AppRunner::~AppRunner() = default;
+
+int AppRunner::Run(std::shared_ptr<Window> window) {
+  return pimpl_->Run(window);
+}
+
+}  // namespace nativeapi

src/platform/linux/window_linux.cpp

@@ -182,7 +182,7 @@ void Window::SetMinimumSize(Size size) {
   // For now, we'll provide a basic implementation that doesn't enforce constraints
 }
 
-Size Window::GetMinimumSize() {
+Size Window::GetMinimumSize() const {
   return Size{0, 0};
 }
 
@@ -191,7 +191,7 @@ void Window::SetMaximumSize(Size size) {
   // For now, we'll provide a basic implementation that doesn't enforce constraints
 }
 
-Size Window::GetMaximumSize() {
+Size Window::GetMaximumSize() const {
   return Size{-1, -1}; // -1 indicates no maximum
 }
 
@@ -254,7 +254,7 @@ void Window::SetAlwaysOnTop(bool is_always_on_top) {
   }
 }
 
-bool Window::IsAlwaysOnTop() {
+bool Window::IsAlwaysOnTop() const {
   if (!pimpl_->gdk_window_) return false;
   GdkWindowState state = gdk_window_get_state(pimpl_->gdk_window_);
   return state & GDK_WINDOW_STATE_ABOVE;
@@ -266,7 +266,7 @@ void Window::SetPosition(Point point) {
   }
 }
 
-Point Window::GetPosition() {
+Point Window::GetPosition() const {
   Point point = {0, 0};
   if (pimpl_->gdk_window_) {
     gint x, y;
@@ -282,7 +282,7 @@ void Window::SetTitle(std::string title) {
   // For now, provide stub implementation
 }
 
-std::string Window::GetTitle() {
+std::string Window::GetTitle() const {
   // GDK windows don't have titles directly - this would come from the GTK widget
   return std::string();
 }

src/platform/linux/window_manager_linux.cpp

@@ -166,9 +166,80 @@ std::shared_ptr<Window> WindowManager::GetCurrent() {
 }
 
 std::shared_ptr<Window> WindowManager::Create(const WindowOptions& options) {
-  // TODO: Implement Linux window creation using GTK
-  // For now, return nullptr as this is a stub implementation
-  return nullptr;
+  // Check if GTK is available
+  GdkDisplay* display = gdk_display_get_default();
+  if (!display) {
+    std::cerr << "No display available for window creation" << std::endl;
+    return nullptr;
+  }
+
+  // Create a new GTK window
+  GtkWidget* gtk_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  if (!gtk_window) {
+    std::cerr << "Failed to create GTK window" << std::endl;
+    return nullptr;
+  }
+
+  // Set window properties from options
+  if (!options.title.empty()) {
+    gtk_window_set_title(GTK_WINDOW(gtk_window), options.title.c_str());
+  }
+
+  // Set window size
+  if (options.size.width > 0 && options.size.height > 0) {
+    gtk_window_set_default_size(GTK_WINDOW(gtk_window),
+                                options.size.width,
+                                options.size.height);
+  }
+
+  // Set minimum size if specified
+  if (options.minimum_size.width > 0 && options.minimum_size.height > 0) {
+    GdkGeometry geometry;
+    geometry.min_width = options.minimum_size.width;
+    geometry.min_height = options.minimum_size.height;
+    gtk_window_set_geometry_hints(GTK_WINDOW(gtk_window), nullptr, &geometry, GDK_HINT_MIN_SIZE);
+  }
+
+  // Set maximum size if specified
+  if (options.maximum_size.width > 0 && options.maximum_size.height > 0) {
+    GdkGeometry geometry;
+    geometry.max_width = options.maximum_size.width;
+    geometry.max_height = options.maximum_size.height;
+    gtk_window_set_geometry_hints(GTK_WINDOW(gtk_window), nullptr, &geometry, GDK_HINT_MAX_SIZE);
+  }
+
+  // Center the window if requested
+  if (options.centered) {
+    gtk_window_set_position(GTK_WINDOW(gtk_window), GTK_WIN_POS_CENTER);
+  }
+
+  // Show the window
+  gtk_widget_show(gtk_window);
+
+  // Get the GdkWindow after the widget is realized
+  GdkWindow* gdk_window = gtk_widget_get_window(gtk_window);
+  if (!gdk_window) {
+    // If window is not yet realized, realize it first
+    gtk_widget_realize(gtk_window);
+    gdk_window = gtk_widget_get_window(gtk_window);
+  }
+
+  if (!gdk_window) {
+    std::cerr << "Failed to get GdkWindow from GTK widget" << std::endl;
+    gtk_widget_destroy(gtk_window);
+    return nullptr;
+  }
+
+  // Create our Window wrapper
+  auto window = std::make_shared<Window>((void*)gdk_window);
+  WindowID window_id = (WindowID)gdk_window;
+
+  // Store in our cache
+  windows_[window_id] = window;
+
+  std::cout << "Created window with ID: " << window_id << std::endl;
+
+  return window;
 }
 
 bool WindowManager::Destroy(WindowID id) {