Add MessageDialog class and macOS implementation

Introduces a new MessageDialog class for displaying informational, warning, and custom dialogs, including modality support. Adds base Dialog class, updates nativeapi.h includes, and provides a macOS-specific implementation using NSAlert. Also adds a message_dialog_example demonstrating usage and integration in CMake.

Author: lijy91

CMakeLists.txt

@@ -14,6 +14,7 @@ add_subdirectory(examples/id_allocator_example)
 add_subdirectory(examples/keyboard_example)
 add_subdirectory(examples/menu_example)
 add_subdirectory(examples/menu_c_example)
+add_subdirectory(examples/message_dialog_example)
 add_subdirectory(examples/storage_example)
 add_subdirectory(examples/storage_c_example)
 add_subdirectory(examples/tray_icon_example)

examples/message_dialog_example/CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(message_dialog_example VERSION 0.0.1 LANGUAGES CXX)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Add example program
+add_executable(message_dialog_example
+  "main.cpp"
+)
+
+# Link main library
+target_link_libraries(message_dialog_example PRIVATE nativeapi)
+
+# Set example program properties
+set_target_properties(message_dialog_example PROPERTIES
+  OUTPUT_NAME "message_dialog_example"
+)
+
+# Set example program compile options (macOS only)
+if(APPLE)
+    set_source_files_properties("main.cpp"
+    PROPERTIES
+    COMPILE_FLAGS "-x objective-c++"
+  )
+endif()
+

examples/message_dialog_example/main.cpp

@@ -0,0 +1,113 @@
+#include <iostream>
+#include <memory>
+#include "nativeapi.h"
+
+using namespace nativeapi;
+
+int main() {
+  std::cout << "=== MessageDialog Example ===" << std::endl;
+
+  // Get the Application instance to initialize platform
+  Application& app = Application::GetInstance();
+
+  try {
+    std::cout << "\n1. Creating a simple informational dialog..." << std::endl;
+    
+    // Create a simple informational message dialog
+    auto info_dialog = std::make_shared<MessageDialog>(
+        "Information",
+        "This is an informational message dialog.\n\n"
+        "MessageDialog can be used to display various types of messages to users.");
+    
+    info_dialog->SetModality(DialogModality::Application);
+    
+    std::cout << "Dialog title: " << info_dialog->GetTitle() << std::endl;
+    std::cout << "Dialog message: " << info_dialog->GetMessage() << std::endl;
+    std::cout << "Opening dialog..." << std::endl;
+    
+    // Open the dialog (this will block until user dismisses it)
+    if (info_dialog->Open()) {
+      std::cout << "Dialog was opened successfully" << std::endl;
+    } else {
+      std::cout << "Failed to open dialog" << std::endl;
+    }
+    
+    std::cout << "\n2. Creating a warning dialog..." << std::endl;
+    
+    // Create a warning dialog
+    auto warning_dialog = std::make_shared<MessageDialog>(
+        "Warning",
+        "This is a warning message.\n\n"
+        "Warning dialogs are used to alert users about potential issues.");
+    
+    warning_dialog->SetModality(DialogModality::Application);
+    warning_dialog->Open();
+    
+    std::cout << "\n3. Creating a dialog with updated content..." << std::endl;
+    
+    // Create a dialog and update its content
+    auto dynamic_dialog = std::make_shared<MessageDialog>(
+        "Update Available",
+        "Initial message");
+    
+    // Update the title and message before opening
+    dynamic_dialog->SetTitle("System Update");
+    dynamic_dialog->SetMessage(
+        "A new version of the application is available.\n\n"
+        "Version 2.0 includes:\n"
+        "• Improved performance\n"
+        "• New features\n"
+        "• Bug fixes\n\n"
+        "Would you like to update now?");
+    
+    dynamic_dialog->SetModality(DialogModality::Application);
+    
+    std::cout << "Updated title: " << dynamic_dialog->GetTitle() << std::endl;
+    std::cout << "Opening updated dialog..." << std::endl;
+    dynamic_dialog->Open();
+    
+    std::cout << "\n4. Demonstrating different modality types..." << std::endl;
+    
+    // Non-modal dialog (default)
+    auto non_modal_dialog = std::make_shared<MessageDialog>(
+        "Non-Modal Dialog",
+        "This dialog does not block interaction.\n\n"
+        "The application continues running and users can interact with other windows.");
+    non_modal_dialog->SetModality(DialogModality::None);
+    std::cout << "Modality: None (non-modal)" << std::endl;
+    non_modal_dialog->Open();
+    
+    // Application modal dialog
+    auto app_modal_dialog = std::make_shared<MessageDialog>(
+        "Application Modal",
+        "This dialog blocks interaction with all windows in the current application.");
+    app_modal_dialog->SetModality(DialogModality::Application);
+    std::cout << "Modality: Application" << std::endl;
+    app_modal_dialog->Open();
+    
+    // Window modal dialog (behaves as Application on macOS)
+    auto window_modal_dialog = std::make_shared<MessageDialog>(
+        "Window Modal",
+        "This dialog blocks interaction with a specific parent window.\n\n"
+        "Note: On macOS, this behaves as Application.");
+    window_modal_dialog->SetModality(DialogModality::Window);
+    std::cout << "Modality: Window" << std::endl;
+    window_modal_dialog->Open();
+    
+    std::cout << "\n=== MessageDialog Example Complete ===" << std::endl;
+    std::cout << "This example demonstrated:" << std::endl;
+    std::cout << "1. Creating MessageDialog instances" << std::endl;
+    std::cout << "2. Setting title and message" << std::endl;
+    std::cout << "3. Updating dialog content programmatically" << std::endl;
+    std::cout << "4. Opening dialogs with different modality types (None, Application, Window)" << std::endl;
+    std::cout << "5. Modal vs non-modal dialog behavior" << std::endl;
+    
+    std::cout << "\nExiting MessageDialog Example..." << std::endl;
+    return 0;
+
+  } catch (const std::exception& e) {
+    std::cerr << "Error: " << e.what() << std::endl;
+    return 1;
+  }
+}
+

include/nativeapi.h

@@ -8,6 +8,7 @@
 #include "../src/display.h"
 #include "../src/display_event.h"
 #include "../src/display_manager.h"
+#include "../src/dialog.h"
 #include "../src/foundation/event.h"
 #include "../src/foundation/event_emitter.h"
 #include "../src/foundation/geometry.h"
@@ -16,6 +17,7 @@
 #include "../src/keyboard_event.h"
 #include "../src/keyboard_monitor.h"
 #include "../src/menu.h"
+#include "../src/message_dialog.h"
 #include "../src/preferences.h"
 #include "../src/secure_storage.h"
 #include "../src/storage.h"

src/dialog.cpp

@@ -0,0 +1,24 @@
+#include "dialog.h"
+
+namespace nativeapi {
+
+Dialog::~Dialog() = default;
+
+DialogModality Dialog::GetModality() const {
+  return modality_;
+}
+
+void Dialog::SetModality(DialogModality modality) {
+  modality_ = modality;
+}
+
+bool Dialog::Open() {
+  return false;  // Base class implementation - should be overridden
+}
+
+bool Dialog::Close() {
+  return false;  // Base class implementation - should be overridden
+}
+
+}  // namespace nativeapi
+

src/dialog.h

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <string>
+
+namespace nativeapi {
+
+/**
+ * @enum DialogModality
+ * @brief Dialog modality types.
+ *
+ * Defines how the dialog blocks user interaction.
+ */
+enum class DialogModality {
+  /**
+   * @brief None - Non-modal dialog.
+   *
+   * The dialog does not block user interaction. The application continues
+   * to run and users can interact with other windows while the dialog is open.
+   */
+  None,
+
+  /**
+   * @brief Application - Blocks the current application.
+   *
+   * Blocks interaction with all windows in the current application,
+   * but allows interaction with other applications.
+   */
+  Application,
+
+  /**
+   * @brief Window - Blocks the parent window (requires parent window handle).
+   *
+   * Blocks interaction with a specific parent window.
+   * Requires a parent window handle to be provided.
+   */
+  Window
+};
+
+/**
+ * @class Dialog
+ * @brief Base class for all dialog types.
+ *
+ * This abstract class provides the common interface for all dialog types
+ * in the system. Specific dialog types (MessageDialog, FileDialog, etc.)
+ * inherit from this class and implement their specific behavior.
+ *
+ * The Dialog class provides:
+ * - Modal and non-modal display modes
+ * - Modal state management
+ *
+ * @note This is an abstract base class. Use specific dialog types like
+ * MessageDialog, FileDialog, etc., to create actual dialogs.
+ *
+ * @example
+ * ```cpp
+ * // Create a message dialog (see MessageDialog for details)
+ * auto message_dialog = std::make_shared<MessageDialog>(
+ *     "Title", "Message", MessageDialogType::Info);
+ *
+ * // Set modal mode and open
+ * message_dialog->SetModality(DialogModality::Application);
+ * message_dialog->Open();
+ * ```
+ */
+class Dialog {
+ public:
+  /**
+   * @brief Virtual destructor.
+   *
+   * Ensures proper cleanup of derived classes and platform-specific resources.
+   */
+  virtual ~Dialog();
+
+  /**
+   * @brief Get the current modality setting of the dialog.
+   *
+   * @return The current DialogModality setting
+   */
+  virtual DialogModality GetModality() const;
+
+  /**
+   * @brief Set the modality of the dialog.
+   *
+   * The modality determines how the dialog blocks user interaction:
+   * - None: Non-modal dialog, does not block user interaction
+   * - Application: Blocks interaction with all windows in the current application
+   * - Window: Blocks interaction with a specific parent window (requires parent handle)
+   *
+   * @param modality The modality type to set
+   *
+   * @note This setting affects the behavior when Open() is called.
+   *       The modality should be set before opening the dialog.
+   *
+   * @example
+   * ```cpp
+   * dialog->SetModality(DialogModality::Application);  // Make it application modal
+   * dialog->Open();                                    // Open as modal dialog
+   * ```
+   */
+  virtual void SetModality(DialogModality modality);
+
+  /**
+   * @brief Open the dialog according to its modality setting.
+   *
+   * The dialog behavior depends on the current modality:
+   * - None: Opens non-modally, does not block the calling thread
+   * - Application/Window: Opens modally, blocks until the user dismisses the dialog
+   *
+   * @return true if the dialog was successfully opened, false otherwise
+   *
+   * @example
+   * ```cpp
+   * // Non-modal dialog
+   * dialog->SetModality(DialogModality::None);
+   * dialog->Open();
+   * // Application continues running...
+   *
+   * // Modal dialog
+   * dialog->SetModality(DialogModality::Application);
+   * dialog->Open();
+   * // Blocks until user dismisses dialog
+   * ```
+   */
+  virtual bool Open();
+
+  /**
+   * @brief Close the dialog programmatically.
+   *
+   * Dismisses the dialog as if the user had closed it.
+   *
+   * @return true if the dialog was successfully closed, false otherwise
+   */
+  virtual bool Close();
+
+ protected:
+  /**
+   * @brief Current modality setting.
+   */
+  DialogModality modality_ = DialogModality::None;
+};
+
+}  // namespace nativeapi