nomen-lang 0.7.1 → 0.9.0

package/core/System/Controls/Pagination.nm

@@ -0,0 +1,142 @@
+/**
+ * A page-picker row — prev/next plus one numbered Button per page composed
+ *
+ * PURE COMPOSITION (GUI_PLAN Tier 3 "reachable earlier"): no new native
+ * control, no drawing — a row of Buttons wired into the caller's grid.
+ * The page count is fixed at construction (1..5; spare buttons are hidden
+ * and skipped by the layout's hidden-leaf pass). The composite is its own
+ * HANDLER HOST (docs/HANDLERS.md Stage 2): #init registers a handler per
+ * button and the arms keep `current` up to date — the run loop forwards
+ * into whatever app field hosts the pagination. Changes the app cares
+ * about travel UP via the id up-call (Stage 3): `on_page_change(id)`
+ * enrolls interest, the mutators raise the pending flag, and the app
+ * forwards itself down once per frame — `pag.tick(ref self, ref win)` —
+ * for the callback into its `run_handler`. Value polling (`page`) remains
+ * for apps that don't need the event. Handles (`prev_handle`/
+ * `next_handle`/`page_handle`) remain for coordinate hit-testing.
+ **/
+pub mv struct Pagination {
+	var Button prev
+	var Button next
+	var Button b0
+	var Button b1
+	var Button b2
+	var Button b3
+	var Button b4
+	var pages = 1
+	var current = 0
+	// The up-call plumbing: the dispatch id the app enrolled (—1 = none)
+	// and whether a page change is waiting for the next tick.
+	var int page_change_id = -1
+	var page_change_pending = false
+
+	pub func #init = (self, Window window, int pages: pages > 0 && pages <= 5) {
+		self.prev = Button(window, "<")
+		self.next = Button(window, ">")
+		self.b0 = Button(window, "1")
+		self.b1 = Button(window, "2")
+		self.b2 = Button(window, "3")
+		self.b3 = Button(window, "4")
+		self.b4 = Button(window, "5")
+		self.pages = pages
+		// Spare page buttons stay hidden (the layout skips hidden leaves).
+		if pages <= 4 {
+			self.b4.set_hidden(true)
+		}
+		if pages <= 3 {
+			self.b3.set_hidden(true)
+		}
+		if pages <= 2 {
+			self.b2.set_hidden(true)
+		}
+		if pages <= 1 {
+			self.b1.set_hidden(true)
+		}
+		// The row self-drives: one registered handler per button (hidden
+		// spares can never be clicked). The closures hoist to hidden methods
+		// on Pagination and run with `ref self` — the app's dispatch
+		// forwards into the field that hosts the row. No polls to starve.
+		self.prev.on_click(func() { self.prev() })
+		self.next.on_click(func() { self.next() })
+		self.b0.on_click(func() { self.select(0) })
+		self.b1.on_click(func() { self.select(1) })
+		self.b2.on_click(func() { self.select(2) })
+		self.b3.on_click(func() { self.select(3) })
+		self.b4.on_click(func() { self.select(4) })
+	}
+
+	// Wire the row into the caller's grid under `parent`.
+	pub func add_to = (ref self, ref Container grid, int parent, int span) {
+		var int hs = grid.add_hstack(parent, 6, span)
+		grid.add_to_intrinsic(hs, self.prev.handle, 1)
+		grid.add_to_intrinsic(hs, self.b0.handle, 1)
+		grid.add_to_intrinsic(hs, self.b1.handle, 1)
+		grid.add_to_intrinsic(hs, self.b2.handle, 1)
+		grid.add_to_intrinsic(hs, self.b3.handle, 1)
+		grid.add_to_intrinsic(hs, self.b4.handle, 1)
+		grid.add_to_intrinsic(hs, self.next.handle, 1)
+	}
+
+	// The page buttons' handles, for grid.contains hit-testing.
+	pub func prev_handle = (self, out uint64) {
+		return self.prev.handle
+	}
+
+	pub func next_handle = (self, out uint64) {
+		return self.next.handle
+	}
+
+	pub func page_handle = (self, int index, out uint64) {
+		if index == 0 { return self.b0.handle }
+		if index == 1 { return self.b1.handle }
+		if index == 2 { return self.b2.handle }
+		if index == 3 { return self.b3.handle }
+		if index == 4 { return self.b4.handle }
+		return 0
+	}
+
+	// The current page (0-based), clamped to the page count.
+	pub func page = (self, out int) {
+		return self.current
+	}
+
+	pub func select = (ref self, int index) {
+		var int i = index
+		if i < 0 { i = 0 }
+		if i > self.pages - 1 { i = self.pages - 1 }
+		self.current = i
+		self.page_change_pending = true
+	}
+
+	pub func next = (ref self) {
+		if self.current < self.pages - 1 {
+			self.current += 1
+			self.page_change_pending = true
+		}
+	}
+
+	pub func prev = (ref self) {
+		if self.current > 0 {
+			self.current -= 1
+			self.page_change_pending = true
+		}
+	}
+
+	// The declared event API (docs/HANDLERS.md Stage 3): the desugar's
+	// enrollment rewrite calls this with the app handler's dispatch id.
+	pub func on_page_change = (ref self, int id) {
+		self.page_change_id = id
+	}
+
+	// One tick of the up-call protocol: the app forwards itself down once
+	// per frame — `self.pag.tick(ref self, ref win)` — and a pending page
+	// change calls back into the app's `run_handler` (one vtable hop into
+	// the concrete override). The borrow flows down per call; nothing is
+	// stored and nothing outlives the tick.
+	pub func tick = (ref self, ref App owner, ref Window win) {
+		if self.page_change_pending && self.page_change_id >= 0 {
+			owner.run_handler(self.page_change_id, ref win)
+		}
+		self.page_change_pending = false
+	}
+}

package/core/System/Controls/Popover.nm

@@ -0,0 +1,296 @@
+/**
+ * An anchored transient popup (NSPopover)
+ *
+ * An OWNING STRUCT (STRUCT_PLAN_3 Phase R, tranche 4 — the shape menu): the
+ * single field is a platform handle, so the value is movable and its
+ * `#destroy` releases what the handle names. The constructor's `self` is
+ * the inline instance (the `.` accessor); methods keep the pointer form.
+ *
+ * `show(handle)` anchors the popover to ANY control by its native handle
+ * (the popover appears above it and the user dismisses it by clicking
+ * elsewhere — NSPopover's transient behavior). Sizing drives the content
+ * view's frame; hosting arbitrary controls inside the popover needs the
+ * same layout-root shim as Sheet and lands with that design work. iOS
+ * defers to UIPopoverPresentationController (TODO stubs; see GUI_PLAN
+ * Tier 1 #21).
+ **/
+/**
+ * The popover content area's size (`Popover.content_size`'s return value)
+ **/
+pub struct PopSize {
+	pub var width = 0
+	pub var height = 0
+}
+
+pub mv struct Popover: Control {
+	var uint64 handle = 0
+
+	pub func #init = (self, Window window) {
+		```
+		#arch: c
+		#platform: macos
+		id pop = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSPopover"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		id vc = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSViewController"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		id content = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSView"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(0, 0, 200, 120));
+		((void(*)(id, SEL, id))objc_msgSend)(vc, sel_registerName("setView:"), content);
+		((void(*)(id, SEL, id))objc_msgSend)(pop, sel_registerName("setContentViewController:"), vc);
+		((void(*)(id, SEL, double, double))objc_msgSend)(
+			pop, sel_registerName("setContentSize:"), 200.0, 120.0);
+		// The window argument satisfies the Control-constructor shape; the
+		// popover presents relative to an anchor view, not into the window.
+		(void)window->handle;
+		self.handle = (uint64_t)pop;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id pop = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSPopover"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		id vc = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSViewController"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		id content = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSView"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(0, 0, 200, 120));
+		((void(*)(id, SEL, id))objc_msgSend)(vc, sel_registerName("setView:"), content);
+		((void(*)(id, SEL, id))objc_msgSend)(pop, sel_registerName("setContentViewController:"), vc);
+		((void(*)(id, SEL, double, double))objc_msgSend)(
+			pop, sel_registerName("setContentSize:"), 200.0, 120.0);
+		// The window argument satisfies the Control-constructor shape; the
+		// popover presents relative to an anchor view, not into the window.
+		(void)window->handle;
+		self->handle = (uint64_t)pop;
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS — UIPopoverPresentationController needs a source view +
+		 * presenting controller (see GUI_PLAN Tier 1 #21; defer). */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS — UIPopoverPresentationController needs a source view +
+		 * presenting controller (see GUI_PLAN Tier 1 #21; defer). */
+		```
+	}
+
+	// Resize the popover's content area.
+	pub func set_content_size = (self, int width, int height) {
+		```
+		#arch: c
+		#platform: macos
+		((void(*)(id, SEL, double, double))objc_msgSend)(
+			(id)self->handle, sel_registerName("setContentSize:"),
+			(double)width, (double)height);
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, double, double))objc_msgSend)(
+			(id)self->handle, sel_registerName("setContentSize:"),
+			(double)width, (double)height);
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// The content area's current size.
+	pub func content_size = (self, out PopSize) {
+		```
+		#arch: c
+		#platform: macos
+		CGSize sz = ((CGSize(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("contentSize"));
+		struct PopSize r;
+		r.width = (int)sz.width;
+		r.height = (int)sz.height;
+		return r;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		CGSize sz = ((CGSize(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("contentSize"));
+		struct PopSize r;
+		r.width = (int)sz.width;
+		r.height = (int)sz.height;
+		return r;
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		{
+			struct PopSize r;
+			r.width = 0;
+			r.height = 0;
+			return r;
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		{
+			struct PopSize r;
+			r.width = 0;
+			r.height = 0;
+			return r;
+		}
+		```
+	}
+
+	// Present the popover anchored above the view `handle` names (any
+	// control's handle). Non-blocking; the user dismisses it by clicking
+	// elsewhere (transient behavior).
+	pub func show = (self, uint64 anchor) {
+		```
+		#arch: c
+		#platform: macos
+		id view = (id)anchor;
+		CGRect bounds = ((CGRect(*)(id, SEL))objc_msgSend)(view, sel_registerName("bounds"));
+		((void(*)(id, SEL, CGRect, id, long))objc_msgSend)(
+			(id)self->handle, sel_registerName("showRelativeToRect:ofView:preferredEdge:"),
+			bounds, view, 3); // NSRectEdgeMaxY = 3 (anchor above)
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id view = (id)anchor;
+		CGRect bounds = ((CGRect(*)(id, SEL))objc_msgSend)(view, sel_registerName("bounds"));
+		((void(*)(id, SEL, CGRect, id, long))objc_msgSend)(
+			(id)self->handle, sel_registerName("showRelativeToRect:ofView:preferredEdge:"),
+			bounds, view, 3); // NSRectEdgeMaxY = 3 (anchor above)
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	pub func dismiss = (self) {
+		```
+		#arch: c
+		#platform: macos
+		((void(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("close"));
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("close"));
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// True while the popover is on screen.
+	pub func is_shown = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		BOOL shown = ((BOOL(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("isShown"));
+		return shown ? 1 : 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		BOOL shown = ((BOOL(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("isShown"));
+		return shown ? 1 : 0;
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+	}
+
+	// ── Control trait conformance ──
+	// A popover is window-coordinated: the layout engine never frames it.
+	pub func set_frame = (ref self, int x, int y, int width, int height) {
+		// No-op: the popover positions itself relative to its anchor.
+	}
+
+	pub func intrinsic_size = (self, out Size) {
+		var s = Size()
+		return s
+	}
+
+	pub func measure = (self, BoxConstraints constraints, out Size) {
+		var s = Size()
+		return s
+	}
+
+	func #destroy = () {
+		```
+		#arch: c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("close"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("close"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+}