nomen-lang 0.0.7 → 0.0.8

package/core/System/Controls/Control.nm

@@ -0,0 +1,28 @@
+// The `Control` trait is the polymorphic interface the layout engine uses to
+// talk to every node in the UI tree. A control reports its desired size given a
+// set of constraints (measure), applies a concrete rectangle (set_frame), and can
+// report how big it would be with unbounded space (intrinsic_size).
+//
+// Native controls (Window, Text, …) and containers conform to it. See GUI.md
+// ("The Control trait") for the contract. The measure/arrange math is the same
+// regardless of storage: the handle-based `Container` applies frames directly via
+// native `setFrame:` today, but a control that also conforms to `Control` can be
+// driven through the trait interface (and slotted into `Array<Control>` /
+// `ClassBuffer<Control>` once the container migrates).
+
+/**
+ * The polymorphic interface every UI node implements (measure / set_frame / intrinsic_size)
+ **/
+pub trait Control {
+	// Given these constraints, report the size you want to be.
+	// Must satisfy min_width ≤ result.width ≤ max_width (ditto height).
+	func measure = (self, BoxConstraints constraints, out Size)
+
+	// Apply a concrete rectangle. For native controls this calls setFrame: on the
+	// platform handle. For containers this also arranges children.
+	func set_frame = (ref self, int x, int y, int width, int height)
+
+	// What size would you be with unbounded space? (Used by parents to decide
+	// wrapping, scrolling, etc. Default: call measure with infinity.)
+	func intrinsic_size = (self, out Size)
+}

package/core/System/Controls/Geometry.nm

@@ -0,0 +1,101 @@
+// Layout geometry types for the Nomen `core/System/Controls` UI layer.
+//
+// These are the pure-data types that flow through the layout engine: a parent
+// hands each child a `BoxConstraints` (min/max per axis) during the measure
+// phase, each child reports a `Size` back, and the engine assigns each node a
+// `Frame` (x, y, width, height) during the arrange phase. `Insets` are the
+// padding subtracted from a container's content rect. The `LayoutLength` /
+// `Alignment` enums describe how a child sits in its parent (see `LayoutParams`).
+//
+// The measure/arrange math is independent of the storage representation — these
+// flat structs are the trait-based `Container : Control` design's data model,
+// but the same types work with the handle-based v1 container.
+
+const MAX_DIM = 2147483647
+
+// ── Geometry ──
+
+/**
+ * A 2D size (width and height)
+ **/
+pub struct Size {
+	pub var width = 0
+	pub var height = 0
+}
+
+/**
+ * A rectangle (x, y, width, height) — a control's assigned position and size
+ **/
+pub struct Frame {
+	pub var x = 0
+	pub var y = 0
+	pub var width = 0
+	pub var height = 0
+}
+
+/**
+ * Per-edge padding (top, right, bottom, left)
+ **/
+pub struct Insets {
+	pub var top = 0
+	pub var right = 0
+	pub var bottom = 0
+	pub var left = 0
+}
+
+// ── Constraints (flow DOWN) ──
+
+/**
+ * Min/max size bounds a parent passes to a child during the layout measure phase
+ **/
+pub struct BoxConstraints {
+	pub var min_width = 0
+	pub var min_height = 0
+	pub var int max_width = MAX_DIM
+	pub var int max_height = MAX_DIM
+
+	pub func tighten_width = (self, int min, int max, out BoxConstraints) {
+		var BoxConstraints c = self
+		c.min_width = self.min_width
+		if min > c.min_width { c.min_width = min }
+		c.max_width = self.max_width
+		if max < c.max_width { c.max_width = max }
+		return c
+	}
+
+	pub func tighten_height = (self, int min, int max, out BoxConstraints) {
+		var BoxConstraints c = self
+		c.min_height = self.min_height
+		if min > c.min_height { c.min_height = min }
+		c.max_height = self.max_height
+		if max < c.max_height { c.max_height = max }
+		return c
+	}
+
+	pub func clamp_width = (self, int value, out int) {
+		if value < self.min_width { return self.min_width }
+		if value > self.max_width { return self.max_width }
+		return value
+	}
+
+	pub func clamp_height = (self, int value, out int) {
+		if value < self.min_height { return self.min_height }
+		if value > self.max_height { return self.max_height }
+		return value
+	}
+
+	pub func is_width_bounded = (self, out bool) {
+		return self.max_width < MAX_DIM
+	}
+
+	pub func is_height_bounded = (self, out bool) {
+		return self.max_height < MAX_DIM
+	}
+}
+
+// `LayoutLength`, `Alignment`, `LayoutParams`, and `DEFAULT_PARAMS` live in
+// `LayoutParams.nm`. They're split out so a module that only needs the
+// per-child length model (e.g. `Container.nm`) can pull them in without also
+// dragging `Size`/`Frame`/`Insets`/`BoxConstraints` along — `Size` and `Frame`
+// collide with macOS `MacTypes.h` typedefs once any Cocoa-using module
+// (Window, Controls) is in the build.

package/core/System/Controls/Layout.nm

@@ -0,0 +1,228 @@
+// All node data in flat Buffers. Buffer data pointers are shared even when
+// the struct is copied (value semantics copy the pointer, not the data).
+
+/**
+ * A flat, buffer-backed layout tree — nodes stored in parallel arrays for the layout engine
+ **/
+pub struct Layout {
+	var kinds = Buffer<int>() // 0=leaf, 1=vstack, 2=hstack
+	var ws = Buffer<int>() // intrinsic width (leaf) or 0
+	var hs = Buffer<int>() // intrinsic height (leaf) or 0
+	var gaps = Buffer<int>() // spacing between children (containers)
+	var par = Buffer<int>() // parent index (-1 = root)
+	var rx = Buffer<int>() // result x
+	var ry = Buffer<int>() // result y
+	var rw = Buffer<int>() // result width
+	var rh = Buffer<int>() // result height
+}
+
+/**
+ * Initializes a Layout tree with capacity for `cap` nodes
+ **/
+pub func init_layout = (ref Layout l, int cap) {
+	l.kinds.grow_int(cap)
+	l.ws.grow_int(cap)
+	l.hs.grow_int(cap)
+	l.gaps.grow_int(cap)
+	l.par.grow_int(cap)
+	l.rx.grow_int(cap)
+	l.ry.grow_int(cap)
+	l.rw.grow_int(cap)
+	l.rh.grow_int(cap)
+}
+
+/**
+ * Appends a leaf node (a sized control) under `parent` and returns its index
+ **/
+pub func add_leaf = (ref Layout l, int parent, int w, int h, out int) {
+	var idx = 0
+	while l.par.load_int(idx) != 0 || idx == 0; idx += 1 {
+		if l.kinds.load_int(idx) == 0 && l.ws.load_int(idx) == 0 && l.hs.load_int(idx) == 0 && l.par.load_int(idx) == 0 {
+			break
+		}
+	}
+	l.kinds.store_int(idx, 0)
+	l.ws.store_int(idx, w)
+	l.hs.store_int(idx, h)
+	l.gaps.store_int(idx, 0)
+	l.par.store_int(idx, parent + 1)
+	return idx
+}
+
+/**
+ * Appends a vertical stack container under `parent` and returns its index
+ **/
+pub func add_vstack = (ref Layout l, int parent, int spacing, out int) {
+	var idx = 0
+	while true; idx += 1 {
+		if l.kinds.load_int(idx) == 0 && l.ws.load_int(idx) == 0 && l.hs.load_int(idx) == 0 && l.par.load_int(idx) == 0 {
+			break
+		}
+	}
+	l.kinds.store_int(idx, 1)
+	l.ws.store_int(idx, 0)
+	l.hs.store_int(idx, 0)
+	l.gaps.store_int(idx, spacing)
+	l.par.store_int(idx, parent + 1)
+	return idx
+}
+
+/**
+ * Appends a horizontal stack container under `parent` and returns its index
+ **/
+pub func add_hstack = (ref Layout l, int parent, int spacing, out int) {
+	var idx = 0
+	while true; idx += 1 {
+		if l.kinds.load_int(idx) == 0 && l.ws.load_int(idx) == 0 && l.hs.load_int(idx) == 0 && l.par.load_int(idx) == 0 {
+			break
+		}
+	}
+	l.kinds.store_int(idx, 2)
+	l.ws.store_int(idx, 0)
+	l.hs.store_int(idx, 0)
+	l.gaps.store_int(idx, spacing)
+	l.par.store_int(idx, parent + 1)
+	return idx
+}
+
+func first_child = (Layout l, int count, int parent, out int) {
+	var int p = parent + 1
+	var i = 0
+	while i < count; i += 1 {
+		if l.par.load_int(i) == p { return i }
+	}
+	return -1
+}
+
+func next_sibling = (Layout l, int count, int after, int parent, out int) {
+	var int p = parent + 1
+	var int i = after + 1
+	while i < count; i += 1 {
+		if l.par.load_int(i) == p { return i }
+	}
+	return -1
+}
+
+// Returns Size via two out params (workaround: single out return).
+// Caller passes addresses; measure fills them.
+/**
+ * Measures node widths against the given constraints (layout measure phase)
+ **/
+pub func measure_w = (
+	Layout l,
+	int count,
+	int idx,
+	int min_w,
+	int max_w,
+	int min_h,
+	int max_h,
+	out int
+) {
+	var int kind = l.kinds.load_int(idx)
+	if kind == 0 {
+		var int w = l.ws.load_int(idx)
+		var int h = l.hs.load_int(idx)
+		if w > max_w { w = max_w }
+		if h > max_h { h = max_h }
+		if w < min_w { w = min_w }
+		if h < min_h { h = min_h }
+		// Encode w and h: return w, store h into rh as side effect
+		l.rh.store_int(idx, h)
+		return w
+	}
+	if kind == 1 {
+		// vstack: sum heights, max widths
+		var total_h = 0
+		var max_child_w = 0
+		var n = 0
+		var int ci = first_child(l, count, idx)
+		while ci != -1 {
+			var int cw = measure_w(l, count, ci, min_w, max_w, 0, 100000)
+			var int ch = l.rh.load_int(ci)
+			total_h = total_h + ch
+			if cw > max_child_w { max_child_w = cw }
+			n += 1
+			ci = next_sibling(l, count, ci, idx)
+		}
+		if n > 1 { total_h = total_h + l.gaps.load_int(idx) * (n - 1) }
+		if max_child_w < min_w { max_child_w = min_w }
+		if max_child_w > max_w { max_child_w = max_w }
+		if total_h < min_h { total_h = min_h }
+		if total_h > max_h { total_h = max_h }
+		l.rh.store_int(idx, total_h)
+		return max_child_w
+	}
+	// hstack: sum widths, max heights
+	var total_w = 0
+	var max_child_h = 0
+	var n = 0
+	var int ci = first_child(l, count, idx)
+	while ci != -1 {
+		var int cw = measure_w(l, count, ci, 0, 100000, min_h, max_h)
+		var int ch = l.rh.load_int(ci)
+		total_w = total_w + cw
+		if ch > max_child_h { max_child_h = ch }
+		n += 1
+		ci = next_sibling(l, count, ci, idx)
+	}
+	if n > 1 { total_w = total_w + l.gaps.load_int(idx) * (n - 1) }
+	if total_w < min_w { total_w = min_w }
+	if total_w > max_w { total_w = max_w }
+	if max_child_h < min_h { max_child_h = min_h }
+	if max_child_h > max_h { max_child_h = max_h }
+	l.rh.store_int(idx, max_child_h)
+	return total_w
+}
+
+/**
+ * Assigns concrete frames to nodes (layout arrange phase)
+ **/
+pub func arrange = (Layout l, int count, int idx, int x, int y, int w, int h) {
+	l.rx.store_int(idx, x)
+	l.ry.store_int(idx, y)
+	l.rw.store_int(idx, w)
+	l.rh.store_int(idx, h)
+	var int kind = l.kinds.load_int(idx)
+	if kind == 0 { return }
+
+	if kind == 1 {
+		// vstack: children top to bottom, full width
+		var int running_y = y
+		var int ci = first_child(l, count, idx)
+		while ci != -1 {
+			var int child_w = measure_w(l, count, ci, w, w, 0, 100000)
+			var int child_h = l.rh.load_int(ci)
+			arrange(l, count, ci, x, running_y, w, child_h)
+			running_y = running_y + child_h + l.gaps.load_int(idx)
+			ci = next_sibling(l, count, ci, idx)
+		}
+		return
+	}
+
+	// hstack: children left to right, full height
+	var int running_x = x
+	var int ci = first_child(l, count, idx)
+	while ci != -1 {
+		var int child_w = measure_w(l, count, ci, 0, 100000, h, h)
+		var int child_h = l.rh.load_int(ci)
+		arrange(l, count, ci, running_x, y, child_w, h)
+		running_x = running_x + child_w + l.gaps.load_int(idx)
+		ci = next_sibling(l, count, ci, idx)
+	}
+}
+
+/**
+ * Runs a full measure-then-arrange pass from `root` within the available space
+ **/
+pub func run_layout = (ref Layout l, int count, int root, int avail_w, int avail_h) {
+	var int root_w = measure_w(l, count, root, 0, avail_w, 0, avail_h)
+	var int root_h = l.rh.load_int(root)
+	arrange(l, count, root, 0, 0, root_w, root_h)
+}
+
+/**
+ * Formats a node and its subtree as a string (for debugging)
+ **/
+pub func fmt = (Layout l, int idx, out string) {
+	return "{" + l.rx.load_int(idx).to_string() + "," + l.ry.load_int(idx).to_string() + " " + l.rw.load_int(idx).to_string() + "x" + l.rh.load_int(idx).to_string() + "}"
+}

package/core/System/Controls/LayoutParams.nm

@@ -0,0 +1,50 @@
+// Per-child layout parameter types for the Nomen `core/System/Controls` UI
+// layer. Split out of `Geometry.nm` so a module that only needs the
+// length-model enums (e.g. `Container.nm`) can pull them in without also
+// dragging `Size`/`Frame`/`Insets`/`BoxConstraints` along — `Size` and `Frame`
+// collide with macOS `MacTypes.h` typedefs once any Cocoa-using module
+// (Window, Controls) is in the build.
+
+// ── Requested size (user-facing, on LayoutParams) ──
+
+/**
+ * How a child dimension is sized: auto (to content), fixed, percent, or fill
+ **/
+pub enum LayoutLength {
+	case auto // size to content (intrinsic measurement)
+	case fixed(int pixels) // exact size
+	case percent(int numerator) // numerator/100 of available space (e.g. 50 = 50%)
+	case fill // fill all available space (same as grow=1)
+}
+
+/**
+ * How a child is positioned within available space (start / center / end / stretch)
+ **/
+pub enum Alignment {
+	case start
+	case center
+	case end
+	case stretch
+}
+
+// ── Per-child layout parameters ──
+
+/**
+ * Per-child layout preferences: requested dimensions, flex grow/shrink weights, and alignment
+ **/
+pub struct LayoutParams {
+	pub var LayoutLength width = .auto
+	pub var LayoutLength height = .auto
+	pub var grow = 0 // flex weight for distributing surplus space
+	pub var shrink = 0 // flex weight for distributing deficit
+	pub var Alignment align_self = .stretch // cross-axis alignment override
+}
+
+// Sensible defaults so most children just work
+const LayoutParams DEFAULT_PARAMS = LayoutParams() + [
+	width = .auto,
+	height = .auto,
+	grow = 0,
+	shrink = 1,
+	align_self = .stretch,
+]

package/core/System/Controls/Text.nm

@@ -0,0 +1,129 @@
+/**
+ * A read-only text label control
+ **/
+pub class Text: Control {
+	var uint64 handle = 0
+	var text = ""
+
+	pub func #init = (self, Window window) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id label = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSTextField"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(10, 10, 200, 30));
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			label, sel_registerName("setEditable:"), 0);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			label, sel_registerName("setSelectable:"), 0);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			label, sel_registerName("setBordered:"), 0);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			label, sel_registerName("setDrawsBackground:"), 0);
+		id contentView = ((id(*)(id, SEL))objc_msgSend)(
+			(id)window->handle, sel_registerName("contentView"));
+		((void(*)(id, SEL, id))objc_msgSend)(
+			contentView, sel_registerName("addSubview:"), label);
+		self->handle = (uint64_t)label;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		id label = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)(objc_getClass("UILabel"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(10, 10, 200, 30));
+		((void(*)(id, SEL, id))objc_msgSend)(
+			label, sel_registerName("setText:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), ""));
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			label, sel_registerName("setUserInteractionEnabled:"), 0);
+		id parentView = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)(
+				(id)window->handle, sel_registerName("rootViewController")),
+			sel_registerName("view"));
+		((void(*)(id, SEL, id))objc_msgSend)(
+			parentView, sel_registerName("addSubview:"), label);
+		self->handle = (uint64_t)label;
+		```
+	}
+
+	pub func set_text = (ref self, string text) {
+		self.text = text
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setStringValue:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), text));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setText:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), text));
+		```
+	}
+
+	// ── Control trait conformance ──
+	// A text control sizes to its content. v1 assumes an 8px monospace font, so a
+	// line is `text.length × 8` wide and 8px tall (see GUI.md "Native control
+	// refactor"). The default frame is 0,0,0,0; layout drives the real rectangle.
+
+	pub func measure = (self, BoxConstraints constraints, out Size) {
+		var s = Size()
+		s.width = self.text.length * 8
+		s.height = 8
+		return s
+	}
+
+	pub func intrinsic_size = (self, out Size) {
+		var s = Size()
+		s.width = self.text.length * 8
+		s.height = 8
+		return s
+	}
+
+	pub func set_frame = (ref self, int x, int y, int width, int height) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+	}
+
+	func #destroy = () {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("removeFromSuperview"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("removeFromSuperview"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+	}
+}

package/core/System/Controls/TextBox.nm

@@ -0,0 +1,157 @@
+/**
+ * An editable single-line text input control
+ **/
+pub class TextBox : Control {
+	var uint64 handle = 0
+
+	pub func #init = (self, Window window) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id field = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSTextField"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(0, 0, 200, 24));
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			field, sel_registerName("setEditable:"), 1);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			field, sel_registerName("setSelectable:"), 1);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			field, sel_registerName("setBordered:"), 1);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			field, sel_registerName("setBezeled:"), 1);
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			field, sel_registerName("setDrawsBackground:"), 1);
+		((void(*)(id, SEL, id))objc_msgSend)(
+			field, sel_registerName("setStringValue:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), ""));
+		id contentView = ((id(*)(id, SEL))objc_msgSend)(
+			(id)window->handle, sel_registerName("contentView"));
+		((void(*)(id, SEL, id))objc_msgSend)(
+			contentView, sel_registerName("addSubview:"), field);
+		self->handle = (uint64_t)field;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		id field = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("UITextField"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(0, 0, 200, 30));
+		((void(*)(id, SEL, BOOL))objc_msgSend)(
+			field, sel_registerName("setBorderStyle:"), 1); // UITextBorderStyleRoundedRect = 1
+		id parentView = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)(
+				(id)window->handle, sel_registerName("rootViewController")),
+			sel_registerName("view"));
+		((void(*)(id, SEL, id))objc_msgSend)(
+			parentView, sel_registerName("addSubview:"), field);
+		self->handle = (uint64_t)field;
+		```
+	}
+
+	pub func set_frame = (ref self, int x, int y, int width, int height) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+	}
+
+	pub func set_text = (self, string text) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setStringValue:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), text));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setText:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), text));
+		```
+	}
+
+	pub func get_text = (self, out string) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id str = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("stringValue"));
+		const char *cstr = ((const char*(*)(id, SEL))objc_msgSend)(
+			str, sel_registerName("UTF8String"));
+		return strdup(cstr);
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		id str = ((id(*)(id, SEL))objc_msgSend)(
+			(id)self->handle, sel_registerName("text"));
+		const char *cstr = ((const char*(*)(id, SEL))objc_msgSend)(
+			str, sel_registerName("UTF8String"));
+		return strdup(cstr);
+		```
+	}
+
+	// ── Control trait conformance ──
+	pub func intrinsic_size = (self, out Size) {
+		var [w, h] = native_intrinsic(self.handle)
+		var Size s = Size()
+		s.width = w
+		s.height = h
+		return s
+	}
+
+	pub func measure = (self, BoxConstraints constraints, out Size) {
+		var Size s = self.intrinsic_size()
+		if s.width > constraints.max_width {
+			s.width = constraints.max_width
+		}
+		if s.width < constraints.min_width {
+			s.width = constraints.min_width
+		}
+		if s.height > constraints.max_height {
+			s.height = constraints.max_height
+		}
+		if s.height < constraints.min_height {
+			s.height = constraints.min_height
+		}
+		return s
+	}
+
+	func #destroy = () {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("removeFromSuperview"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("removeFromSuperview"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+	}
+}