nomen-lang 0.7.0 → 0.8.0

package/core/System/Controls/Menu.nm

@@ -0,0 +1,428 @@
+/**
+ * A context menu attachable to any control (NSMenu via `view.menu`)
+ *
+ * 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.
+ *
+ * Right-clicking an attached control shows the menu natively — AppKit runs
+ * its own modal tracking loop, so the manual event loop is untouched. Each
+ * item carries a tag (its index) and a shared target whose action records
+ * the tag in a C global; `clicked_item` polls it (edge-triggered: the read
+ * resets it to -1, "none"), and `on_item_select` is the registered form —
+ * the drain consumes the selection, the handler reads it through
+ * `selected_item`.
+ * iOS presentation differs (UIContextMenu-
+ * Interaction needs a scene-attached view — see GUI_PLAN Tier 2; the iOS
+ * blocks are TODO stubs).
+ **/
+pub mv struct Menu : Control {
+	var uint64 handle = 0
+
+	// File-scope helper: the shared item target. The action records the
+	// clicked item's tag (shared — one Menu per process, like List's row
+	// storage).
+	pub func #init = (self) {
+		```
+		#arch: c
+		#platform: macos
+		#scope: file
+		static long g_menu_last_tag = -1;
+		static id g_menu_target = 0;
+
+		static void nomen_menu_item_action(id self, SEL cmd, id sender) {
+			(void)self; (void)cmd;
+			g_menu_last_tag = ((long(*)(id, SEL))objc_msgSend)(sender, sel_registerName("tag"));
+		}
+
+		static id nomen_menu_target(void) {
+			Class Mt = objc_getClass("NomenMenuTarget");
+			if (!Mt) {
+				Mt = objc_allocateClassPair(objc_getClass("NSObject"), "NomenMenuTarget", 0);
+				if (Mt) {
+					class_addMethod(Mt, sel_registerName("nomenMenuItemAction:"),
+						(IMP)nomen_menu_item_action, "v@:@");
+					objc_registerClassPair(Mt);
+				}
+			}
+			if (!g_menu_target) {
+				g_menu_target = ((id(*)(id, SEL))objc_msgSend)(Mt, sel_registerName("new"));
+			}
+			return g_menu_target;
+		}
+
+		// Edge-triggered read: the poll consumes the tag (resets to -1).
+		long nomen_menu_last_tag(void) {
+			long tag = g_menu_last_tag;
+			g_menu_last_tag = -1;
+			return tag;
+		}
+
+		// The on_item_select drain's consume-and-stash: the drain consumes
+		// the selected tag exactly like the poll, and STASHES it for the
+		// handler body to read through Menu.selected_item (the drain runs
+		// first in its pump arm, so the stash is fresh when the handler
+		// body runs).
+		long g_menu_selected_tag = -1;
+		unsigned char nomen_menu_take_select(void) {
+			long tag = nomen_menu_last_tag();
+			if (tag < 0) return 0;
+			g_menu_selected_tag = tag;
+			return 1;
+		}
+		long nomen_menu_selected_tag(void) {
+			return g_menu_selected_tag;
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		#scope: file
+		static long g_menu_last_tag = -1;
+		static id g_menu_target = 0;
+
+		static void nomen_menu_item_action(id self, SEL cmd, id sender) {
+			(void)self; (void)cmd;
+			g_menu_last_tag = ((long(*)(id, SEL))objc_msgSend)(sender, sel_registerName("tag"));
+		}
+
+		static id nomen_menu_target(void) {
+			Class Mt = objc_getClass("NomenMenuTarget");
+			if (!Mt) {
+				Mt = objc_allocateClassPair(objc_getClass("NSObject"), "NomenMenuTarget", 0);
+				if (Mt) {
+					class_addMethod(Mt, sel_registerName("nomenMenuItemAction:"),
+						(IMP)nomen_menu_item_action, "v@:@");
+					objc_registerClassPair(Mt);
+				}
+			}
+			if (!g_menu_target) {
+				g_menu_target = ((id(*)(id, SEL))objc_msgSend)(Mt, sel_registerName("new"));
+			}
+			return g_menu_target;
+		}
+
+		// Edge-triggered read: the poll consumes the tag (resets to -1).
+		long nomen_menu_last_tag(void) {
+			long tag = g_menu_last_tag;
+			g_menu_last_tag = -1;
+			return tag;
+		}
+
+		// The on_item_select drain's consume-and-stash (see the c twin
+		// above).
+		long g_menu_selected_tag = -1;
+		unsigned char nomen_menu_take_select(void) {
+			long tag = nomen_menu_last_tag();
+			if (tag < 0) return 0;
+			g_menu_selected_tag = tag;
+			return 1;
+		}
+		long nomen_menu_selected_tag(void) {
+			return g_menu_selected_tag;
+		}
+		```
+		```
+		#arch: c
+		#platform: macos
+		id menu = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSMenu"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		self.handle = (uint64_t)menu;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id menu = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSMenu"), sel_registerName("alloc")),
+			sel_registerName("init"));
+		self->handle = (uint64_t)menu;
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS — UIContextMenuInteraction needs a scene-attached view
+		 * (see GUI_PLAN Tier 2; defer). */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// Append a clickable item. Its tag (and the `clicked_item` value it
+	// reports) is its ENTRY index in the menu — separators consume an index
+	// too, so `add_item` after `add_separator` reports the entry count.
+	pub func add_item = (self, string title) {
+		```
+		#arch: c
+		#platform: macos
+		id menu = (id)self->handle;
+		long tag = ((long(*)(id, SEL))objc_msgSend)(menu, sel_registerName("numberOfItems"));
+		id item = ((id(*)(id, SEL, id, SEL, id))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSMenuItem"), sel_registerName("alloc")),
+			sel_registerName("initWithTitle:action:keyEquivalent:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title.ptr),
+			sel_registerName("nomenMenuItemAction:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), ""));
+		((void(*)(id, SEL, long))objc_msgSend)(item, sel_registerName("setTag:"), tag);
+		((void(*)(id, SEL, id))objc_msgSend)(item, sel_registerName("setTarget:"), nomen_menu_target());
+		((void(*)(id, SEL, id))objc_msgSend)(menu, sel_registerName("addItem:"), item);
+		((void(*)(id, SEL))objc_msgSend)(item, sel_registerName("release"));
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id menu = (id)self->handle;
+		long tag = ((long(*)(id, SEL))objc_msgSend)(menu, sel_registerName("numberOfItems"));
+		id item = ((id(*)(id, SEL, id, SEL, id))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSMenuItem"), sel_registerName("alloc")),
+			sel_registerName("initWithTitle:action:keyEquivalent:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title.ptr),
+			sel_registerName("nomenMenuItemAction:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), ""));
+		((void(*)(id, SEL, long))objc_msgSend)(item, sel_registerName("setTag:"), tag);
+		((void(*)(id, SEL, id))objc_msgSend)(item, sel_registerName("setTarget:"), nomen_menu_target());
+		((void(*)(id, SEL, id))objc_msgSend)(menu, sel_registerName("addItem:"), item);
+		((void(*)(id, SEL))objc_msgSend)(item, sel_registerName("release"));
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// Append a separator line.
+	pub func add_separator = (self) {
+		```
+		#arch: c
+		#platform: macos
+		id sep = ((id(*)(id, SEL))objc_msgSend)(
+			(id)objc_getClass("NSMenuItem"), sel_registerName("separatorItem"));
+		((void(*)(id, SEL, id))objc_msgSend)((id)self->handle, sel_registerName("addItem:"), sep);
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		id sep = ((id(*)(id, SEL))objc_msgSend)(
+			(id)objc_getClass("NSMenuItem"), sel_registerName("separatorItem"));
+		((void(*)(id, SEL, id))objc_msgSend)((id)self->handle, sel_registerName("addItem:"), sep);
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// Show this menu on right-click of the control with the given handle.
+	pub func attach = (self, uint64 handle) {
+		```
+		#arch: c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)((id)handle, sel_registerName("setMenu:"), (id)self->handle);
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)((id)handle, sel_registerName("setMenu:"), (id)self->handle);
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		```
+	}
+
+	// The number of ENTRIES (items + separators).
+	pub func item_count = (self, out int) {
+		```
+		#arch: c
+		#platform: macos
+		return (int)((long(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("numberOfItems"));
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		return (int)((long(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("numberOfItems"));
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return 0;
+		```
+	}
+
+	// The tag of the most recently clicked item since the last read
+	// (edge-triggered; -1 = none). Poll it in the manual loop.
+	pub func clicked_item = (self, out int) {
+		```
+		#arch: c
+		#platform: macos
+		extern long nomen_menu_last_tag(void);
+		long tag = nomen_menu_last_tag();
+		return (int)tag;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern long nomen_menu_last_tag(void);
+		long tag = nomen_menu_last_tag();
+		return (int)tag;
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return -1;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return -1;
+		```
+	}
+
+	// The on_item_select desugar's drain (docs/HANDLERS.md): the synthesized
+	// pump arm polls this per frame. The selection is CONSUMED by the drain
+	// — like the poll, one record has one consumer, so a selection fires an
+	// arm exactly once — and the consumed tag is stashed for the handler
+	// body, which reads it through selected_item. The poll and the drain
+	// share one record: a selection consumed by one never reaches the other.
+	pub func take_item_select = (self, out bool) {
+		```
+		#arch: c
+		#platform: macos
+		extern unsigned char nomen_menu_take_select(void);
+		return nomen_menu_take_select();
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern unsigned char nomen_menu_take_select(void);
+		return nomen_menu_take_select();
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return false;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return false;
+		```
+	}
+
+	// The tag the last take_item_select consumed (-1 before the first
+	// selection) — the handler body's payload getter. The control-scoped
+	// analog of the dispatch-window getters (win.click_x() et al): the
+	// record is the menu's own, so the payload rides the menu, not the
+	// window.
+	pub func selected_item = (self, out int) {
+		```
+		#arch: c
+		#platform: macos
+		extern long nomen_menu_selected_tag(void);
+		return (int)nomen_menu_selected_tag();
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		extern long nomen_menu_selected_tag(void);
+		return (int)nomen_menu_selected_tag();
+		```
+		```
+		#arch: c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return -1;
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: ios
+		/* TODO: iOS (see #init) */
+		return -1;
+		```
+	}
+
+	// ── Control trait conformance ──
+	// A menu is not laid out: it has no frame of its own (it presents at the
+	// cursor under the attached control's right-click).
+	pub func set_frame = (ref self, int x, int y, int width, int height) {
+		// No-op: the menu presents at the cursor.
+	}
+
+	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("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: aarch64_use_c
+		#platform: macos
+		if (self->handle) {
+			((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) */
+		```
+	}
+}

package/core/System/Controls/NumberInput.nm

@@ -0,0 +1,56 @@
+/**
+ * A number field with stepper nudges — TextBox + Stepper composed
+ *
+ * PURE COMPOSITION (GUI_PLAN Tier 3 "reachable earlier"): no new native
+ * control, no drawing — a TextBox for the text and a Stepper for the
+ * nudges, wired side by side into the caller's grid (the box fills the
+ * row, the stepper takes its intrinsic width).
+ *
+ * `set_value` drives both controls: the stepper holds the value, the text
+ * mirrors it (whole values as ints, fractions via the float's %f
+ * rendering). Stepper clicks update the stepper — but free-typed text is
+ * NOT parsed back in v1 (no string→float round-trip yet), so editing the
+ * text only changes the display until the next nudge. Hit-test the box and
+ * stepper through their handles (fields read like every control's
+ * `handle`).
+ **/
+pub mv struct NumberInput {
+	var TextBox box
+	var Stepper step
+
+	pub func #init = (self, Window window) {
+		self.box = TextBox(window)
+		self.step = Stepper(window)
+	}
+
+	// The stepper's range and nudge size.
+	pub func set_range = (ref self, float min, float max, float increment) {
+		self.step.set_min(min)
+		self.step.set_max(max)
+		self.step.set_increment(increment)
+	}
+
+	// Drive BOTH controls: the stepper holds the value, the text mirrors it
+	// (the float's %f rendering).
+	pub func set_value = (ref self, float v) {
+		self.step.set_value(v)
+		var text = v.to_string()
+		self.box.set_text(text)
+	}
+
+	// The current value (the stepper's — typed text is not parsed back in
+	// v1; the next nudge overwrites the text).
+	pub func value = (self, out float) {
+		return self.step.value()
+	}
+
+	// Wire the pair into the caller's grid under `parent`: an hstack with
+	// the box filling the row and the stepper at its intrinsic width.
+	// Hit-testing works through the usual grid.contains on the fields'
+	// handles.
+	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(hs, self.box.handle, 0, 24, 1, 1)
+		grid.add_to_intrinsic(hs, self.step.handle, 1)
+	}
+}

package/core/System/Controls/OtpInput.nm

@@ -0,0 +1,50 @@
+/**
+ * A one-time-code field — five SecureFields composed
+ *
+ * PURE COMPOSITION (GUI_PLAN Tier 3 "reachable earlier"): no new native
+ * control, no drawing — five single-character SecureFields wired in a row
+ * into the caller's grid. `code` concatenates whatever the five fields
+ * hold (incomplete codes read as-is — no per-field auto-advance in v1;
+ * fields are hit-tested through their handles like every control's).
+ **/
+pub mv struct OtpInput {
+	var SecureField f0
+	var SecureField f1
+	var SecureField f2
+	var SecureField f3
+	var SecureField f4
+
+	pub func #init = (self, Window window) {
+		self.f0 = SecureField(window)
+		self.f1 = SecureField(window)
+		self.f2 = SecureField(window)
+		self.f3 = SecureField(window)
+		self.f4 = SecureField(window)
+	}
+
+	// Wire the five fields into the caller's grid under `parent`: an hstack
+	// of fixed-width boxes.
+	pub func add_to = (ref self, ref Container grid, int parent, int span) {
+		var int hs = grid.add_hstack(parent, 8, span)
+		grid.add_to(hs, self.f0.handle, 36, 28, 0, 1)
+		grid.add_to(hs, self.f1.handle, 36, 28, 0, 1)
+		grid.add_to(hs, self.f2.handle, 36, 28, 0, 1)
+		grid.add_to(hs, self.f3.handle, 36, 28, 0, 1)
+		grid.add_to(hs, self.f4.handle, 36, 28, 0, 1)
+	}
+
+	// The concatenated contents of the five fields, in order.
+	pub func code = (self, out string) {
+		return self.f0.get_text() + self.f1.get_text() + self.f2.get_text()
+		+self.f3.get_text() + self.f4.get_text()
+	}
+
+	// Empty every field.
+	pub func clear = (ref self) {
+		self.f0.set_text("")
+		self.f1.set_text("")
+		self.f2.set_text("")
+		self.f3.set_text("")
+		self.f4.set_text("")
+	}
+}