...

ui/scroll_view.sx

@@ -0,0 +1,148 @@
+#import "modules/std.sx";
+#import "modules/math";
+#import "ui/types.sx";
+#import "ui/render.sx";
+#import "ui/events.sx";
+#import "ui/view.sx";
+
+ScrollAxes :: enum { vertical; horizontal; both; }
+
+ScrollView :: struct {
+    child: ViewChild;
+    offset: Point;
+    content_size: Size;
+    viewport_size: Size;
+    axes: ScrollAxes;
+    dragging: bool;
+    drag_pending: bool;
+    drag_start: Point;
+    drag_offset: Point;
+
+    SCROLL_SPEED  :f32: 20.0;
+    DRAG_THRESHOLD :f32: 4.0;
+
+    clamp_offset :: (self: *ScrollView) {
+        max_x := max(0.0, self.content_size.width - self.viewport_size.width);
+        max_y := max(0.0, self.content_size.height - self.viewport_size.height);
+
+        if self.axes == .vertical or self.axes == .both {
+            self.offset.y = clamp(self.offset.y, 0.0, max_y);
+        } else {
+            self.offset.y = 0.0;
+        }
+
+        if self.axes == .horizontal or self.axes == .both {
+            self.offset.x = clamp(self.offset.x, 0.0, max_x);
+        } else {
+            self.offset.x = 0.0;
+        }
+    }
+}
+
+impl View for ScrollView {
+    size_that_fits :: (self: *ScrollView, proposal: ProposedSize) -> Size {
+        // ScrollView takes all proposed space
+        Size.{
+            width = proposal.width ?? 0.0,
+            height = proposal.height ?? 0.0
+        };
+    }
+
+    layout :: (self: *ScrollView, bounds: Frame) {
+        self.viewport_size = bounds.size;
+
+        // Measure child with infinite space on scroll axes
+        child_proposal := ProposedSize.{
+            width = if self.axes == .horizontal or self.axes == .both then null else bounds.size.width,
+            height = if self.axes == .vertical or self.axes == .both then null else bounds.size.height
+        };
+        self.content_size = self.child.view.size_that_fits(child_proposal);
+        self.clamp_offset();
+
+        // Layout child offset by scroll position
+        self.child.computed_frame = Frame.make(
+            bounds.origin.x - self.offset.x,
+            bounds.origin.y - self.offset.y,
+            self.content_size.width,
+            self.content_size.height
+        );
+        self.child.view.layout(self.child.computed_frame);
+    }
+
+    render :: (self: *ScrollView, ctx: *RenderContext, frame: Frame) {
+        ctx.push_clip(frame);
+        self.child.view.render(ctx, self.child.computed_frame);
+        ctx.pop_clip();
+    }
+
+    handle_event :: (self: *ScrollView, event: *Event, frame: Frame) -> bool {
+        if pos := event_position(event) {
+            print("  ScrollView.handle_event: pos=({},{}) frame=({},{},{},{})\n", pos.x, pos.y, frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
+            if !frame.contains(pos) { print("  -> outside frame\n"); return false; }
+        }
+
+        if event.* == {
+            case .mouse_wheel: (d) {
+                if self.axes == .vertical or self.axes == .both {
+                    self.offset.y -= d.delta.y * ScrollView.SCROLL_SPEED;
+                }
+                if self.axes == .horizontal or self.axes == .both {
+                    self.offset.x -= d.delta.x * ScrollView.SCROLL_SPEED;
+                }
+                self.clamp_offset();
+                return true;
+            }
+            case .mouse_down: (d) {
+                // Always record drag start (like Zig preHandleEvent)
+                self.drag_pending = true;
+                self.drag_start = d.position;
+                self.drag_offset = self.offset;
+                // Forward to children — let buttons/tappables handle too
+                self.child.view.handle_event(event, self.child.computed_frame);
+                return true;
+            }
+            case .mouse_moved: (d) {
+                // Activate drag once movement exceeds threshold
+                if self.drag_pending and !self.dragging {
+                    dx := d.position.x - self.drag_start.x;
+                    dy := d.position.y - self.drag_start.y;
+                    dist := sqrt(dx * dx + dy * dy);
+                    if dist >= ScrollView.DRAG_THRESHOLD {
+                        self.dragging = true;
+                        self.drag_pending = false;
+                        // Cancel child press state — position far outside so on_tap won't fire
+                        cancel :Event = .mouse_up(MouseButtonData.{
+                            position = Point.{ x = 0.0 - 10000.0, y = 0.0 - 10000.0 },
+                            button = .none
+                        });
+                        self.child.view.handle_event(@cancel, self.child.computed_frame);
+                    }
+                }
+                if self.dragging {
+                    if self.axes == .vertical or self.axes == .both {
+                        self.offset.y = self.drag_offset.y - (d.position.y - self.drag_start.y);
+                    }
+                    if self.axes == .horizontal or self.axes == .both {
+                        self.offset.x = self.drag_offset.x - (d.position.x - self.drag_start.x);
+                    }
+                    self.clamp_offset();
+                    return true;
+                }
+                // Forward mouse_moved to children (for hover effects)
+                return self.child.view.handle_event(event, self.child.computed_frame);
+            }
+            case .mouse_up: {
+                was_dragging := self.dragging;
+                self.dragging = false;
+                self.drag_pending = false;
+                if was_dragging {
+                    return true;
+                }
+                // Forward to children (for tap completion)
+                return self.child.view.handle_event(event, self.child.computed_frame);
+            }
+        }
+        // Forward other events to child
+        self.child.view.handle_event(event, self.child.computed_frame);
+    }
+}