Add geometry reader

examples/geometry_reader.rs

@@ -0,0 +1,21 @@
+#![feature(type_alias_impl_trait, impl_trait_in_assoc_type)]
+
+use nuit::{prelude::*, GeometryReader, Insets, Text};
+
+#[derive(Bind)]
+struct GeometryReaderView;
+
+impl View for GeometryReaderView {
+    type Body = impl View;
+
+    fn body(&self) -> Self::Body {
+        GeometryReader::new(|geometry| {
+            Text::new(format!("This view has width {} and height {}", geometry.width(), geometry.height()))
+                .padding(Insets::default())
+        })
+    }
+}
+
+fn main() {
+    nuit::run_app(GeometryReaderView);
+}

nuit-bridge-swiftui/Sources/NuitBridgeSwiftUI/Event/Event.swift

@@ -8,4 +8,5 @@ enum Event: Codable, Hashable {
     case updateSliderValue(value: Double)
     case updateNavigationPath(path: [Value])
     case getNavigationDestination(value: Value)
+    case getGeometryReaderView(geometry: Geometry)
 }

nuit-bridge-swiftui/Sources/NuitBridgeSwiftUI/Node.swift

@@ -15,6 +15,7 @@ indirect enum Node: Codable, Hashable {
     case group(children: [Identified<Node>])
 
     // MARK: Layout
+    case geometryReader
     case vStack(alignment: HorizontalAlignment, spacing: Double, wrapped: Identified<Node>)
     case hStack(alignment: VerticalAlignment, spacing: Double, wrapped: Identified<Node>)
     case zStack(alignment: Alignment, spacing: Double, wrapped: Identified<Node>)

nuit-bridge-swiftui/Sources/NuitBridgeSwiftUI/NodeView.swift

@@ -55,6 +55,12 @@ struct NodeView: View {
             }
 
         // MARK: Layout
+        case .geometryReader:
+            GeometryReader { proxy in
+                if case let .node(node: node) = root.fire(event: .getGeometryReaderView(geometry: .init(proxy)), for: idPath) {
+                    NodeView(node: node.value, idPath: idPath + [node.id])
+                }
+            }
         case let .vStack(alignment: alignment, spacing: spacing, wrapped: wrapped):
             VStack(alignment: .init(alignment), spacing: spacing) {
                 NodeView(node: wrapped.value, idPath: idPath + [wrapped.id])

nuit-core/src/compose/view/layout/geometry_reader.rs

@@ -0,0 +1,57 @@
+use std::marker::PhantomData;
+
+use nuit_derive::Bind;
+
+use crate::{Context, Event, EventResponse, Geometry, Id, IdPath, IdentifyExt, Node, View};
+
+#[derive(Debug, Clone, PartialEq, Eq, Bind)]
+pub struct GeometryReader<F, T> {
+    view_func: F,
+    phantom_view: PhantomData<T>,
+}
+
+impl<F, T> GeometryReader<F, T>
+where
+    F: Fn(Geometry) -> T,
+    T: View,
+{
+    #[must_use]
+    pub const fn new(view_func: F) -> Self {
+        Self {
+            view_func,
+            phantom_view: PhantomData,
+        }
+    }
+}
+
+impl<F, T> View for GeometryReader<F, T>
+where
+    F: Fn(Geometry) -> T,
+    T: View,
+{
+    fn fire(&self, event: &Event, event_path: &IdPath, context: &Context) -> EventResponse {
+        if let Some(head) = event_path.head() {
+            match head {
+                Id::Index(i) => panic!("Cannot fire event for child id {i} on GeometryReader"),
+                Id::String(geometry_json) => {
+                    let geometry = serde_json::from_str(&geometry_json).expect("Could not deserialize geometry reader id");
+                    let view = (self.view_func)(geometry);
+                    view.fire(event, event_path.tail(), &context.child(geometry_json))
+                },
+            }
+        } else if let Event::GetGeometryReaderView { geometry } = event {
+            let geometry_json = serde_json::to_string(geometry).expect("Could not serialize geometry reader id");
+            let id = Id::string(geometry_json);
+
+            let view = (self.view_func)(*geometry);
+            let node = view.render(&context.child(id.clone())).identify(id);
+            EventResponse::Node { node }
+        } else {
+            EventResponse::default()
+        }
+    }
+
+    fn render(&self, _context: &Context) -> Node {
+        Node::GeometryReader {}
+    }
+}

nuit-core/src/compose/view/layout/mod.rs

@@ -1,7 +1,9 @@
+mod geometry_reader;
 mod list;
 mod overlay;
 mod stack;
 
+pub use geometry_reader::*;
 pub use list::*;
 pub use overlay::*;
 pub use stack::*;

nuit-core/src/event/event.rs

@@ -1,7 +1,7 @@
 use serde::{Serialize, Deserialize};
 use serde_json::Value;
 
-use crate::Id;
+use crate::{Geometry, Id};
 
 use super::GestureEvent;
 
@@ -20,6 +20,9 @@ pub enum Event {
     UpdateNavigationPath { path: Vec<Value> },
     GetNavigationDestination { value: Value },
 
+    // Layout
+    GetGeometryReaderView { geometry: Geometry },
+
     // Lifecycle
     Appear,
     Disappear,

nuit-core/src/node/node.rs

@@ -24,6 +24,7 @@ pub enum Node {
     Group { children: Vec<Identified<Node>> },
 
     // Layout
+    GeometryReader {},
     VStack { alignment: HorizontalAlignment, spacing: f64, wrapped: Box<Identified<Node>> },
     HStack { alignment: VerticalAlignment, spacing: f64, wrapped: Box<Identified<Node>> },
     ZStack { alignment: Alignment, spacing: f64, wrapped: Box<Identified<Node>> },

nuit-core/src/utils/geometry.rs

@@ -14,4 +14,14 @@ impl Geometry {
     pub const fn size(self) -> Vec2<f64> {
         self.size
     }
+
+    #[must_use]
+    pub const fn width(self) -> f64 {
+        self.size.x
+    }
+
+    #[must_use]
+    pub const fn height(self) -> f64 {
+        self.size.y
+    }
 }