@geastack/apple 0.2.8

package/targets/ios/main/renderer/native_button.mm

@@ -0,0 +1,179 @@
+#include "ios_renderer_internal.h"
+
+#include "events.h"
+#include "font_registry.h"
+#include "ui/tree_internal.h"
+
+#include <algorithm>
+#include <cmath>
+
+extern "C" void gea_ios_touch_set_state(int touching, int x, int y);
+
+@implementation GeaNativeButton
+
+- (CGPoint)eventPoint
+{
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (self.nodeId < 0 || self.nodeId >= tree.nodeCount()) return CGPointZero;
+	const auto &node = tree.node(self.nodeId);
+	return CGPointMake(static_cast<CGFloat>(node.layout.x + node.layout.width / 2),
+	                   static_cast<CGFloat>(node.layout.y + node.layout.height / 2));
+}
+
+- (bool)dispatchPointerEvent:(gea::framework::events::PointerEventType)type activeTouch:(BOOL)activeTouch
+{
+	if (self.nodeId < 0) return false;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (self.nodeId >= tree.nodeCount()) return false;
+
+	const CGPoint point = [self eventPoint];
+	gea::framework::events::PointerEvent event{};
+	event.type = type;
+	event.targetId = self.nodeId;
+	event.pointerId = 1;
+	event.x = static_cast<int>(std::lround(point.x));
+	event.y = static_cast<int>(std::lround(point.y));
+	event.clientX = event.x;
+	event.clientY = event.y;
+	event.pageX = event.x;
+	event.pageY = event.y;
+	event.screenX = event.x;
+	event.screenY = event.y;
+	event.primary = true;
+	event.touchesLength = activeTouch ? 1 : 0;
+	event.targetTouchesLength = activeTouch ? 1 : 0;
+	event.changedTouchesLength = 1;
+	event.touches[0].identifier = 1;
+	event.touches[0].target = gea::framework::events::EventTarget(self.nodeId);
+	event.touches[0].screenX = event.x;
+	event.touches[0].screenY = event.y;
+	event.touches[0].clientX = event.x;
+	event.touches[0].clientY = event.y;
+	event.touches[0].pageX = event.x;
+	event.touches[0].pageY = event.y;
+	event.targetTouches[0] = event.touches[0];
+	event.changedTouches[0] = event.touches[0];
+	tree.dispatchEvent(event);
+	return event.defaultPrevented;
+}
+
+- (void)setNativeTouchState:(BOOL)touching
+{
+	const CGPoint point = [self eventPoint];
+	gea_ios_touch_set_state(touching ? 1 : 0,
+	                        static_cast<int>(std::lround(point.x)),
+	                        static_cast<int>(std::lround(point.y)));
+}
+
+- (void)handleTouchDown:(id)sender
+{
+	(void)sender;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (self.nodeId < 0 || self.nodeId >= tree.nodeCount()) return;
+	const CGPoint point = [self eventPoint];
+	const int x = static_cast<int>(std::lround(point.x));
+	const int y = static_cast<int>(std::lround(point.y));
+	[self setNativeTouchState:YES];
+	tree.pointerDown(x, y);
+	[self dispatchPointerEvent:gea::framework::events::PointerEventType::TouchStart activeTouch:YES];
+}
+
+- (void)handleTouchDrag:(id)sender
+{
+	(void)sender;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (self.nodeId < 0 || self.nodeId >= tree.nodeCount()) return;
+	const CGPoint point = [self eventPoint];
+	const int x = static_cast<int>(std::lround(point.x));
+	const int y = static_cast<int>(std::lround(point.y));
+	[self setNativeTouchState:YES];
+	[self dispatchPointerEvent:gea::framework::events::PointerEventType::TouchMove activeTouch:YES];
+	tree.pointerMove(x, y);
+}
+
+- (void)finishTouchInside:(BOOL)inside
+{
+	if (self.nodeId < 0) return;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (self.nodeId >= tree.nodeCount()) return;
+	[self setNativeTouchState:NO];
+	tree.pointerUp();
+	[self dispatchPointerEvent:gea::framework::events::PointerEventType::TouchEnd activeTouch:NO];
+	if (inside) {
+		[self dispatchPointerEvent:gea::framework::events::PointerEventType::Click activeTouch:NO];
+	}
+}
+
+- (void)handleTouchUpInside:(id)sender
+{
+	(void)sender;
+	[self finishTouchInside:YES];
+}
+
+- (void)handleTouchUpOutside:(id)sender
+{
+	(void)sender;
+	[self finishTouchInside:NO];
+}
+
+- (void)handleTouchCancel:(id)sender
+{
+	(void)sender;
+	[self finishTouchInside:NO];
+}
+
+@end
+
+namespace gea::ios::renderer {
+namespace {
+
+const gea::embedded::ui::Node *firstVisibleTextChild(int nodeId)
+{
+	using gea::embedded::ui::NodeType;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (nodeId < 0 || nodeId >= tree.nodeCount()) return nullptr;
+	const auto &buttonNode = tree.node(nodeId);
+	for (int child = buttonNode.first_child; child >= 0; child = tree.node(child).next_sibling) {
+		const auto &childNode = tree.node(child);
+		if (childNode.type == NodeType::Text && childNode.style.display != 1) return &childNode;
+	}
+	return nullptr;
+}
+
+NSAttributedString *attributedTitleForTextChild(const gea::embedded::ui::Node &textNode, CGFloat scale)
+{
+	NSString *raw = NSStringFromText(textNode.text);
+	const CGFloat fontSize = std::max<CGFloat>(1.0, static_cast<CGFloat>(textNode.style.font_size > 0 ? textNode.style.font_size : 16) * scale);
+	UIFont *font = gea::ios::fontForId(textNode.style.font_id, fontSize);
+	UIColor *color = rgb565ToUIColor(textNode.style.text_color);
+	NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
+	paragraph.alignment = textAlignmentForStyle(textNode.style.text_align);
+	paragraph.lineBreakMode = NSLineBreakByWordWrapping;
+	NSMutableDictionary *attrs = textAttributes(font, color, textNode.style.text_decoration);
+	attrs[NSParagraphStyleAttributeName] = paragraph;
+	return [[NSAttributedString alloc] initWithString:raw attributes:attrs];
+}
+
+}  // namespace
+
+void applyButtonProps(GeaNativeButton *button, const gea::embedded::ui::Node &node, int nodeId, CGFloat scale)
+{
+	button.nodeId = nodeId;
+	button.userInteractionEnabled = !(node.style.display == 1 || node.style.opacity == 0 ||
+	                                  node.layout.width <= 0 || node.layout.height <= 0);
+	button.contentHorizontalAlignment = UIControlContentHorizontalAlignmentCenter;
+	button.contentVerticalAlignment = UIControlContentVerticalAlignmentCenter;
+	button.titleLabel.numberOfLines = 0;
+	button.titleLabel.lineBreakMode = NSLineBreakByWordWrapping;
+
+	const gea::embedded::ui::Node *titleNode = firstVisibleTextChild(nodeId);
+	if (titleNode && !titleNode->text.empty()) {
+		button.titleLabel.hidden = NO;
+		[button setAttributedTitle:attributedTitleForTextChild(*titleNode, scale) forState:UIControlStateNormal];
+	} else {
+		button.titleLabel.hidden = YES;
+		[button setAttributedTitle:nil forState:UIControlStateNormal];
+	}
+}
+
+}  // namespace gea::ios::renderer

package/targets/ios/main/renderer/native_label.mm

@@ -0,0 +1,161 @@
+#include "ios_renderer_internal.h"
+
+#include "font_registry.h"
+#include "graphics/font.h"
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <vector>
+
+@implementation GeaNativeLabel
+
+- (void)drawRect:(CGRect)rect
+{
+	if (!self.geaUseBitmapFont) {
+		[super drawRect:rect];
+		return;
+	}
+	(void)rect;
+	CGContextRef ctx = UIGraphicsGetCurrentContext();
+	if (!ctx) return;
+
+	const CGFloat pixel = std::max<CGFloat>(1.0, self.geaBitmapGlyphScale);
+	const CGFloat glyphW = gea::framework::graphics::BitmapFont8x16::kWidth * pixel;
+	const CGFloat glyphH = gea::framework::graphics::BitmapFont8x16::kHeight * pixel;
+	if (glyphW <= 0 || glyphH <= 0) return;
+
+	std::string text = self.geaBitmapText ? self.geaBitmapText.UTF8String : "";
+	const std::size_t maxChars = std::max<std::size_t>(1, static_cast<std::size_t>(std::floor(self.bounds.size.width / glyphW)));
+	std::vector<std::string> lines;
+	std::string line;
+	for (unsigned char c : text) {
+		if (c == '\r') continue;
+		if (c == '\n') {
+			lines.push_back(line);
+			line.clear();
+			continue;
+		}
+		if (line.size() >= maxChars) {
+			lines.push_back(line);
+			line.clear();
+		}
+		line.push_back(c >= 0x20 && c <= 0x7e ? static_cast<char>(c) : '?');
+	}
+	lines.push_back(line);
+
+	UIColor *color = self.geaBitmapColor ?: UIColor.whiteColor;
+	[color setFill];
+	const auto &font = gea::framework::graphics::BitmapFont8x16::instance();
+	for (std::size_t lineIndex = 0; lineIndex < lines.size(); lineIndex++) {
+		const std::string &textLine = lines[lineIndex];
+		const CGFloat lineWidth = static_cast<CGFloat>(textLine.size()) * glyphW;
+		CGFloat penX = 0;
+		if (self.textAlignment == NSTextAlignmentCenter) {
+			penX = std::max<CGFloat>(0, (self.bounds.size.width - lineWidth) / 2.0);
+		} else if (self.textAlignment == NSTextAlignmentRight) {
+			penX = std::max<CGFloat>(0, self.bounds.size.width - lineWidth);
+		}
+		const CGFloat lineStartX = penX;
+		const CGFloat penY = static_cast<CGFloat>(lineIndex) * glyphH;
+		if (penY >= self.bounds.size.height) break;
+		for (unsigned char c : textLine) {
+			const std::uint8_t *rows = font.glyphRows(static_cast<char>(c));
+			for (int row = 0; row < gea::framework::graphics::BitmapFont8x16::kHeight; row++) {
+				for (int col = 0; col < gea::framework::graphics::BitmapFont8x16::kWidth; col++) {
+					if ((rows[row] & (0x80 >> col)) == 0) continue;
+					CGContextFillRect(ctx, CGRectMake(penX + static_cast<CGFloat>(col) * pixel,
+					                                  penY + static_cast<CGFloat>(row) * pixel,
+					                                  pixel,
+					                                  pixel));
+				}
+			}
+			penX += glyphW;
+		}
+		const CGFloat thickness = std::max<CGFloat>(1.0, std::ceil(pixel));
+		if (self.geaBitmapTextDecoration == 1) {
+			CGContextFillRect(ctx, CGRectMake(lineStartX, penY + glyphH * 0.88, lineWidth, thickness));
+		} else if (self.geaBitmapTextDecoration == 2) {
+			CGContextFillRect(ctx, CGRectMake(lineStartX, penY + glyphH * 0.58, lineWidth, thickness));
+		}
+	}
+}
+
+@end
+
+namespace gea::ios::renderer {
+namespace {
+
+void fitNativeButtonLabelIfNeeded(GeaNativeLabel *label)
+{
+	if (!label || ![label.superview isKindOfClass:[GeaNativeButton class]] || label.geaUseBitmapFont) return;
+	if (label.attributedText.length == 0) return;
+
+	const CGSize nativeSize = [label sizeThatFits:CGSizeMake(CGFLOAT_MAX, CGFLOAT_MAX)];
+	if (nativeSize.width <= 0 || nativeSize.height <= 0) return;
+
+	UIView *button = label.superview;
+	const CGRect bounds = button.bounds;
+	CGRect frame = label.frame;
+	const CGFloat nextWidth = std::ceil(nativeSize.width) + 1.0;
+	const CGFloat nextHeight = std::ceil(nativeSize.height) + 1.0;
+	if (nextWidth > frame.size.width) {
+		const CGFloat centerX = CGRectGetMidX(frame);
+		frame.size.width = nextWidth;
+		frame.origin.x = centerX - nextWidth / 2.0;
+		if (bounds.size.width > 0 && nextWidth <= bounds.size.width) {
+			frame.origin.x = std::clamp<CGFloat>(frame.origin.x, 0, bounds.size.width - nextWidth);
+		}
+	}
+	if (nextHeight > frame.size.height) {
+		const CGFloat centerY = CGRectGetMidY(frame);
+		frame.size.height = nextHeight;
+		frame.origin.y = centerY - nextHeight / 2.0;
+		if (bounds.size.height > 0 && nextHeight <= bounds.size.height) {
+			frame.origin.y = std::clamp<CGFloat>(frame.origin.y, 0, bounds.size.height - nextHeight);
+		}
+	}
+	label.frame = frame;
+}
+
+}  // namespace
+
+void applyTextProps(GeaNativeLabel *label, const gea::embedded::ui::Node &node, CGFloat scale)
+{
+	NSString *raw = NSStringFromText(node.text);
+	const CGFloat fontSize = std::max<CGFloat>(1.0, static_cast<CGFloat>(node.style.font_size > 0 ? node.style.font_size : 16) * scale);
+	UIColor *color = rgb565ToUIColor(node.style.text_color);
+	label.geaHostedByNativeButtonTitle = [label.superview isKindOfClass:[GeaNativeButton class]];
+	label.hidden = label.geaHostedByNativeButtonTitle;
+	label.textAlignment = textAlignmentForStyle(node.style.text_align);
+	if (node.style.font_id < 0) {
+		label.geaUseBitmapFont = YES;
+		label.geaBitmapText = raw;
+		label.geaBitmapColor = color;
+		label.geaBitmapGlyphScale = fontSize / gea::framework::graphics::BitmapFont8x16::kHeight;
+		label.geaBitmapTextDecoration = node.style.text_decoration;
+		label.attributedText = nil;
+		label.text = nil;
+		label.font = [UIFont systemFontOfSize:fontSize];
+		label.textColor = color;
+		[label setNeedsDisplay];
+		return;
+	}
+
+	label.geaUseBitmapFont = NO;
+	label.geaBitmapText = nil;
+	label.geaBitmapColor = nil;
+	UIFont *font = gea::ios::fontForId(node.style.font_id, fontSize);
+	NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
+	paragraph.alignment = textAlignmentForStyle(node.style.text_align);
+	paragraph.lineBreakMode = NSLineBreakByWordWrapping;
+	NSMutableDictionary *attrs = textAttributes(font, color, node.style.text_decoration);
+	attrs[NSParagraphStyleAttributeName] = paragraph;
+	label.attributedText = [[NSAttributedString alloc] initWithString:raw attributes:attrs];
+	label.font = font;
+	label.textColor = color;
+	fitNativeButtonLabelIfNeeded(label);
+	[label setNeedsDisplay];
+}
+
+}  // namespace gea::ios::renderer

package/targets/ios/main/renderer/native_scroll_container.mm

@@ -0,0 +1,279 @@
+#include "ios_renderer_internal.h"
+
+#include "ui/tree_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+
+namespace gea::ios::renderer {
+namespace {
+
+bool scrollDebugMarkersEnabled()
+{
+	static int cached = -1;
+	if (cached >= 0) return cached == 1;
+	bool enabled = false;
+	const char *env = std::getenv("GEA_IOS_SCROLL_DEBUG_MARKERS");
+	if (env && env[0] && std::strcmp(env, "0") != 0 && std::strcmp(env, "false") != 0) enabled = true;
+	for (NSString *arg in NSProcessInfo.processInfo.arguments) {
+		if ([arg isEqualToString:@"--gea-scroll-debug-markers"]) {
+			enabled = true;
+			break;
+		}
+	}
+	cached = enabled ? 1 : 0;
+	return enabled;
+}
+
+UILabel *makeScrollDebugLabel(NSString *identifier, UIColor *background)
+{
+	UILabel *label = [[UILabel alloc] initWithFrame:CGRectZero];
+	label.accessibilityIdentifier = identifier;
+	label.isAccessibilityElement = YES;
+	label.backgroundColor = background;
+	label.textColor = UIColor.whiteColor;
+	label.numberOfLines = 2;
+	label.font = [UIFont monospacedSystemFontOfSize:11.0 weight:UIFontWeightSemibold];
+	label.textAlignment = NSTextAlignmentLeft;
+	label.userInteractionEnabled = NO;
+	label.layer.cornerRadius = 4.0;
+	label.clipsToBounds = YES;
+	return label;
+}
+
+bool nearlyEqual(CGFloat a, CGFloat b)
+{
+	return std::fabs(a - b) <= 0.5;
+}
+
+bool rectNearlyEqual(CGRect a, CGRect b)
+{
+	return nearlyEqual(a.origin.x, b.origin.x) &&
+	       nearlyEqual(a.origin.y, b.origin.y) &&
+	       nearlyEqual(a.size.width, b.size.width) &&
+	       nearlyEqual(a.size.height, b.size.height);
+}
+
+}  // namespace
+}  // namespace gea::ios::renderer
+
+@implementation GeaNativeScrollContainer
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+	self = [super initWithFrame:frame];
+	if (self) {
+		_nodeId = -1;
+		_syncingFromTree = NO;
+		_minObservedContentOffsetY = CGFLOAT_MAX;
+		_maxObservedContentOffsetY = -CGFLOAT_MAX;
+		self.delegate = self;
+		self.backgroundColor = UIColor.clearColor;
+		self.opaque = NO;
+		self.clipsToBounds = YES;
+		self.isAccessibilityElement = YES;
+		self.accessibilityIdentifier = @"gea-native-scroll";
+		self.bounces = YES;
+		self.alwaysBounceVertical = YES;
+		self.alwaysBounceHorizontal = NO;
+		self.directionalLockEnabled = YES;
+		self.decelerationRate = UIScrollViewDecelerationRateNormal;
+		self.showsVerticalScrollIndicator = NO;
+		self.showsHorizontalScrollIndicator = NO;
+		self.delaysContentTouches = NO;
+		self.canCancelContentTouches = YES;
+		self.scrollsToTop = NO;
+		if (@available(iOS 11.0, *)) self.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+		_contentView = [[UIView alloc] initWithFrame:CGRectZero];
+		_contentView.userInteractionEnabled = NO;
+		_contentView.backgroundColor = UIColor.clearColor;
+		[self addSubview:_contentView];
+		UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTap:)];
+		tap.cancelsTouchesInView = NO;
+		[self addGestureRecognizer:tap];
+	}
+	return self;
+}
+
+- (void)ensureDebugMarkers
+{
+	if (!gea::ios::renderer::scrollDebugMarkersEnabled()) return;
+	if (!self.debugTelemetryLabel) {
+		self.debugTelemetryLabel = gea::ios::renderer::makeScrollDebugLabel(
+		    @"gea-scroll-telemetry", [UIColor colorWithRed:0.02 green:0.04 blue:0.08 alpha:0.86]);
+		[self addSubview:self.debugTelemetryLabel];
+	}
+	if (!self.debugTopMarkerLabel) {
+		self.debugTopMarkerLabel = gea::ios::renderer::makeScrollDebugLabel(
+		    @"gea-scroll-content-top-marker", [UIColor colorWithRed:0.85 green:0.10 blue:0.10 alpha:0.82]);
+		self.debugTopMarkerLabel.text = @" content y=0";
+		[self.contentView addSubview:self.debugTopMarkerLabel];
+	}
+	if (!self.debugBottomMarkerLabel) {
+		self.debugBottomMarkerLabel = gea::ios::renderer::makeScrollDebugLabel(
+		    @"gea-scroll-content-bottom-marker", [UIColor colorWithRed:0.10 green:0.42 blue:0.95 alpha:0.82]);
+		[self.contentView addSubview:self.debugBottomMarkerLabel];
+	}
+}
+
+- (void)layoutDebugMarkers
+{
+	if (!gea::ios::renderer::scrollDebugMarkersEnabled()) return;
+	[self ensureDebugMarkers];
+	const CGFloat visibleX = self.contentOffset.x + 8.0;
+	const CGFloat visibleY = self.contentOffset.y + 8.0;
+	const CGFloat markerWidth = std::max<CGFloat>(160.0, self.bounds.size.width - 16.0);
+	self.debugTelemetryLabel.frame = CGRectMake(visibleX, visibleY, markerWidth, 42.0);
+	const CGFloat contentWidth = std::max<CGFloat>(self.contentSize.width, self.bounds.size.width);
+	self.debugTopMarkerLabel.frame = CGRectMake(0, 0, contentWidth, 24.0);
+	const CGFloat bottomY = std::max<CGFloat>(28.0, self.contentSize.height - 28.0);
+	self.debugBottomMarkerLabel.frame = CGRectMake(0, bottomY, contentWidth, 28.0);
+	[self bringSubviewToFront:self.debugTelemetryLabel];
+}
+
+- (void)layoutSubviews
+{
+	[super layoutSubviews];
+	[self layoutDebugMarkers];
+}
+
+- (void)updateScrollTelemetryWithScale:(CGFloat)scale
+{
+	if (self.nodeId < 0) return;
+	const CGFloat rawY = self.contentOffset.y;
+	if (rawY < self.minObservedContentOffsetY) self.minObservedContentOffsetY = rawY;
+	if (rawY > self.maxObservedContentOffsetY) self.maxObservedContentOffsetY = rawY;
+
+	auto &tree = gea::embedded::ui::Tree::instance();
+	const int treeY = self.nodeId < tree.nodeCount() ? tree.scrollTop(self.nodeId) : 0;
+	const CGFloat maxY = std::max<CGFloat>(0, self.contentSize.height - self.bounds.size.height);
+	const CGFloat overTop = std::min<CGFloat>(0, rawY);
+	const CGFloat overBottom = std::max<CGFloat>(0, rawY - maxY);
+	const CGFloat visualContentY = self.contentView.frame.origin.y - rawY;
+	NSString *value = [NSString stringWithFormat:@"node=%d rawY=%.2f treeY=%d maxY=%.2f minRawY=%.2f maxRawY=%.2f overTop=%.2f overBottom=%.2f visualY=%.2f scale=%.3f tracking=%d dragging=%d decel=%d",
+	                   self.nodeId, rawY, treeY, maxY, self.minObservedContentOffsetY, self.maxObservedContentOffsetY,
+	                   overTop, overBottom, visualContentY, scale, self.tracking ? 1 : 0, self.dragging ? 1 : 0,
+	                   self.decelerating ? 1 : 0];
+	self.accessibilityValue = value;
+
+	if (gea::ios::renderer::scrollDebugMarkersEnabled()) {
+		[self ensureDebugMarkers];
+		self.debugTelemetryLabel.text = [NSString stringWithFormat:@"rawY=%.1f treeY=%d maxY=%.1f\nmin=%.1f max=%.1f over=%.1f/%.1f",
+		                                 rawY, treeY, maxY, self.minObservedContentOffsetY,
+		                                 self.maxObservedContentOffsetY, overTop, overBottom];
+		self.debugTelemetryLabel.accessibilityValue = value;
+		self.debugBottomMarkerLabel.text = [NSString stringWithFormat:@" content y=max %.0f", maxY];
+		[self layoutDebugMarkers];
+	}
+}
+
+- (void)commitNativeScrollTopWithScale:(CGFloat)scale
+{
+	if (self.nodeId < 0) return;
+	auto &tree = gea::embedded::ui::Tree::instance();
+	if (self.nodeId >= tree.nodeCount()) return;
+
+	const CGFloat maxOffset = std::max<CGFloat>(0, self.contentSize.height - self.bounds.size.height);
+	const CGFloat rawOffset = self.contentOffset.y;
+	if (rawOffset < -0.5 || rawOffset > maxOffset + 0.5) {
+		[self updateScrollTelemetryWithScale:scale];
+		return;
+	}
+
+	const CGFloat logicalOffset = std::clamp(rawOffset, static_cast<CGFloat>(0), maxOffset);
+	const int before = tree.scrollTop(self.nodeId);
+	const int next = static_cast<int>(std::lround(logicalOffset / std::max<CGFloat>(scale, 0.0001)));
+	tree.setScrollTop(self.nodeId, next);
+	if (tree.scrollTop(self.nodeId) != before && tree.mountedRoot() >= 0) {
+		tree.refresh(tree.mountedRoot(), tree.mountedWidth(), tree.mountedHeight());
+	}
+	[self updateScrollTelemetryWithScale:scale];
+}
+
+- (void)handleTap:(UITapGestureRecognizer *)recognizer
+{
+	if (recognizer.state != UIGestureRecognizerStateEnded) return;
+	gea::ios::renderer::dispatchSyntheticTap(self.superview, [recognizer locationInView:self.superview]);
+}
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView
+{
+	if (self.nodeId < 0) return;
+	(void)scrollView;
+	const CGFloat scale = gea::ios::renderer::canvasScaleForView(self.superview);
+	if (self.syncingFromTree) {
+		[self updateScrollTelemetryWithScale:scale];
+		return;
+	}
+	const CGFloat maxOffset = std::max<CGFloat>(0, scrollView.contentSize.height - scrollView.bounds.size.height);
+	const CGFloat rawOffset = scrollView.contentOffset.y;
+	const BOOL nativeScrollActive = scrollView.tracking || scrollView.dragging || scrollView.decelerating;
+	const BOOL rubberBanding = rawOffset < -0.5 || rawOffset > maxOffset + 0.5;
+	if (nativeScrollActive || rubberBanding) {
+		[self updateScrollTelemetryWithScale:scale];
+		return;
+	}
+	[self commitNativeScrollTopWithScale:scale];
+}
+
+- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate
+{
+	(void)scrollView;
+	if (decelerate) return;
+	[self commitNativeScrollTopWithScale:gea::ios::renderer::canvasScaleForView(self.superview)];
+}
+
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
+{
+	(void)scrollView;
+	[self commitNativeScrollTopWithScale:gea::ios::renderer::canvasScaleForView(self.superview)];
+}
+
+- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
+{
+	(void)scrollView;
+	[self commitNativeScrollTopWithScale:gea::ios::renderer::canvasScaleForView(self.superview)];
+}
+
+@end
+
+namespace gea::ios::renderer {
+
+void applyScrollProps(GeaNativeScrollContainer *scrollView,
+                      const gea::embedded::ui::Node &node,
+                      int nodeId,
+                      CGFloat scale)
+{
+	scrollView.nodeId = nodeId;
+	const CGFloat w = static_cast<CGFloat>(node.layout.width) * scale;
+	const CGFloat h = static_cast<CGFloat>(std::max<int>(node.layout.height, node.layout.scroll_content_height)) * scale;
+	const CGSize nextContentSize = CGSizeMake(w, h);
+	if (std::fabs(scrollView.contentSize.width - nextContentSize.width) > 0.5 ||
+	    std::fabs(scrollView.contentSize.height - nextContentSize.height) > 0.5) {
+		scrollView.contentSize = nextContentSize;
+	}
+	const CGRect nextContentFrame = CGRectMake(0, 0, w, h);
+	if (!rectNearlyEqual(scrollView.contentView.frame, nextContentFrame)) scrollView.contentView.frame = nextContentFrame;
+	scrollView.hidden = node.style.display == 1 || node.style.opacity == 0;
+	scrollView.userInteractionEnabled = !scrollView.hidden;
+
+	const CGFloat maxOffset = std::max<CGFloat>(0, scrollView.contentSize.height - scrollView.bounds.size.height);
+	const CGFloat rawOffset = scrollView.contentOffset.y;
+	const BOOL nativeScrollActive = scrollView.tracking || scrollView.dragging || scrollView.decelerating;
+	const BOOL rubberBanding = rawOffset < -0.5 || rawOffset > maxOffset + 0.5;
+	if (!nativeScrollActive && !rubberBanding) {
+		const CGFloat desired = std::clamp(static_cast<CGFloat>(gea::embedded::ui::Tree::instance().scrollTop(nodeId)) * scale,
+		                                   static_cast<CGFloat>(0),
+		                                   maxOffset);
+		if (std::fabs(scrollView.contentOffset.y - desired) > 0.5) {
+			scrollView.syncingFromTree = YES;
+			scrollView.contentOffset = CGPointMake(0, desired);
+			scrollView.syncingFromTree = NO;
+		}
+	}
+	[scrollView updateScrollTelemetryWithScale:scale];
+}
+
+}  // namespace gea::ios::renderer