Rebrand to Galaxy, major improvements to Bedrock support, still needs some TLC though

crates/galaxyui_core/src/windowing/mod.rs

@@ -0,0 +1,110 @@
+pub mod state;
+
+mod system;
+
+use std::rc::Rc;
+
+use pathfinder_geometry::rect::RectF;
+pub use state::{State, StateEvent, WindowManager};
+pub use system::{CreateWindowingSystemError, System};
+
+use crate::{
+    actions::StandardAction, platform::WindowContext, AppContext, AppContextRefMut, CursorInfo,
+    Event, Scene,
+};
+
+/// Result of dispatching an event through the UI framework.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct EventDispatchResult {
+    /// Whether the event was handled by the UI framework.
+    pub handled: bool,
+    /// Whether the soft keyboard should be shown (mobile WASM only).
+    pub soft_keyboard_requested: bool,
+}
+
+pub(crate) type EventCallback = Box<dyn Fn(Event, &mut AppContext) -> EventDispatchResult>;
+pub(crate) type ResizeCallback = Box<dyn Fn(&dyn WindowContext, &mut AppContext)>;
+pub(crate) type StandardActionCallback = Box<dyn Fn(StandardAction, &mut AppContext)>;
+pub(crate) type ActiveCursorPositionCallback = Box<dyn Fn(&mut AppContext) -> Option<CursorInfo>>;
+pub(crate) type MoveCallback = Box<dyn Fn(RectF, &mut AppContext)>;
+pub(crate) type FrameCallback = Box<dyn Fn(&mut AppContext)>;
+pub(crate) type BuildSceneCallback = Box<dyn Fn(&dyn WindowContext, &mut AppContext) -> Rc<Scene>>;
+
+/// A collection of callbacks that are used to update UI framework state in
+/// response to platform-level events.
+pub struct WindowCallbacks {
+    /// Dispatches a [`StandardAction`].
+    pub standard_action_callback: StandardActionCallback,
+    /// Dispatches an [`Event`].
+    pub event_callback: EventCallback,
+    /// Notifies the UI framework that the window was resized.
+    pub resize_callback: ResizeCallback,
+    /// Requests that the UI framework construct a scene to render.
+    pub build_scene_callback: BuildSceneCallback,
+    /// Notifies the UI framework that a frame was rendered.
+    pub frame_callback: FrameCallback,
+    /// Notifies the UI framework that a frame failed to draw.
+    pub draw_frame_error_callback: FrameCallback,
+    /// Notifies the UI framework that the window moved.
+    pub move_callback: MoveCallback,
+    /// Returns the current location of the text editing cursor, if an
+    /// editable text field is focused.
+    pub active_cursor_position_callback: ActiveCursorPositionCallback,
+}
+
+/// A helper structure to simplify and standardize the act of making calls from
+/// platform code into platform-independent UI framework code.
+pub struct WindowCallbackDispatcher<'a> {
+    callbacks: &'a WindowCallbacks,
+    ctx: AppContextRefMut<'a>,
+}
+
+impl<'a> WindowCallbackDispatcher<'a> {
+    pub(crate) fn new(callbacks: &'a WindowCallbacks, ctx: AppContextRefMut<'a>) -> Self {
+        Self { callbacks, ctx }
+    }
+
+    pub fn dispatch_event(&mut self, event: Event) -> EventDispatchResult {
+        (self.callbacks.event_callback)(event, &mut self.ctx)
+    }
+
+    pub fn window_resized(&mut self, window: &dyn WindowContext) {
+        (self.callbacks.resize_callback)(window, &mut self.ctx)
+    }
+
+    pub fn frame_drawn(&mut self) {
+        (self.callbacks.frame_callback)(&mut self.ctx)
+    }
+
+    #[cfg_attr(target_os = "macos", allow(dead_code))]
+    pub fn frame_failed_to_draw(&mut self) {
+        (self.callbacks.draw_frame_error_callback)(&mut self.ctx)
+    }
+
+    pub fn get_active_cursor_position(&mut self) -> Option<CursorInfo> {
+        (self.callbacks.active_cursor_position_callback)(&mut self.ctx)
+    }
+
+    pub fn window_moved(&mut self, bounds: RectF) {
+        (self.callbacks.move_callback)(bounds, &mut self.ctx)
+    }
+
+    pub fn build_scene(&mut self, window: &dyn WindowContext) -> Rc<Scene> {
+        (self.callbacks.build_scene_callback)(window, &mut self.ctx)
+    }
+}
+
+// Functions in WindowCallbackDispatcher that relate to application menus.
+//
+// This is marked as `allow(dead_code)` on Linux and wasm, as they do not
+// support application menus, so these never get called.
+// TODO(CORE-2691): implement native Windows OS app menus
+#[cfg_attr(
+    any(target_os = "linux", target_os = "windows", target_family = "wasm"),
+    allow(dead_code)
+)]
+impl WindowCallbackDispatcher<'_> {
+    pub fn dispatch_standard_action(&mut self, action: StandardAction) {
+        (self.callbacks.standard_action_callback)(action, &mut self.ctx)
+    }
+}