Add per-Mount scrolling with shared paint and input clipping
Verify Tessera GUI / verify (push) Failing after 7m33s
Verify Tessera GUI / verify (push) Failing after 7m33s
This commit is contained in:
@@ -176,7 +176,7 @@ container append/remove/replace/move, Page open/close/navigation, ui.present,
|
||||
ui.state(value), ui.textOf(state, "value"), and button.onClick/click are available
|
||||
in the persistent Console. Method bodies can call other methods without a trailing
|
||||
return. Bound text tracks its source property; clean derived subtrees and unchanged measurements are reused. Buttons have a native background, focus ring and pointer/keyboard activation.
|
||||
`Page()`, `TextBlock(...)`, `Row(...)`, `Column(...)` and `Button(...)` are callable managed type objects; `Page.base` is ContainerBlock and `page.type` is Page. `isInstance(page, Block)` and `isSubtype(Page, Block)` query nominal relations. Object and Type are explicitly bootstrapped in the same GC heap. Ordinary source class declarations, positional field construction, member assignment and inherited method dispatch are supported; source subclasses of concrete native visual types now reuse their real native allocator; abstract types remain unconstructible. Traits are still pending. Native visual methods now live on their nominal type tables and use the same receiver binding as source methods. See [managed-types.endor](examples/managed-types.endor), [classes.endor](examples/classes.endor) and [native-subclasses.endor](examples/native-subclasses.endor).
|
||||
`Page()`, `TextBlock(...)`, `Row(...)`, `Column(...)`, `ScrollBlock(...)` and `Button(...)` are callable managed type objects; `Page.base` is ContainerBlock and `page.type` is Page. `isInstance(page, Block)` and `isSubtype(Page, Block)` query nominal relations. Object and Type are explicitly bootstrapped in the same GC heap. Ordinary source class declarations, positional field construction, member assignment and inherited method dispatch are supported; source subclasses of concrete native visual types now reuse their real native allocator; abstract types remain unconstructible. Explicit host-registered capabilities are available; formal trait syntax and full type/effect checks remain pending. Native visual methods now live on their nominal type tables and use the same receiver binding as source methods. See [managed-types.endor](examples/managed-types.endor), [classes.endor](examples/classes.endor) and [native-subclasses.endor](examples/native-subclasses.endor).
|
||||
|
||||
Source native subclass construction takes native arguments first, followed by all inherited and own declared fields. For example, a TextBlock subclass with one field accepts `CustomText("text", 2, "#242422", fieldValue)`; optional native arguments can be omitted before the required field suffix. Field storage belongs to the current shared Block content: replacement updates aliases and bindings and releases the previous fields through Aster. This is an implementation subset; field annotations are not yet runtime checked.
|
||||
|
||||
@@ -200,6 +200,12 @@ Visual, EventTarget, Children and Presentable are explicit managed Trait definit
|
||||
|
||||
A plain source object can declare Presentable by implementing `present(self, window: Window): Block` and calling `ui.implement(MyType, Presentable)`. `ui.present(value)` invokes this method with the calling window and checks the returned actual Block; `ui.open(value)` also opens the result in a Page. Block values pass through directly. The existing summary viewer remains the fallback for unregistered values, and merely viewing a function does not execute it. Presentation runs through the same bounded VM call sequence; there is no recursive host evaluator. A source adapter can keep the original object through fields/callbacks/bindings; [presentable.endor](examples/presentable.endor) shows a source-preserving view and GUI calls to the original object's method. Presentation methods are ordinary calls; visual measure/arrange/paint/hitTest still run read-only and check their nominal results at runtime. Source implementations of EventTarget.on/dispatch must provide the contract's canonical 3/2 arguments after self; native methods retain their existing optional convenience arguments.
|
||||
|
||||
`ScrollBlock(width, height, child)` is a ContainerBlock with a bounded viewport and unconstrained content measurement. It also supports inherited child operations and padding/gap. Its width/height are managed attributes and can be bound or assigned. Each attached Mount owns its scroll offset; two occurrences of the same ScrollBlock scroll independently. Moving/remounting content creates a new Mount and starts at zero. Changes to content or viewport clamp offsets to the new limits.
|
||||
|
||||
`mount.scrollTo(x,y)` and `scrollBy(dx,dy)` update that occurrence; multiple relative requests in one input accumulate. `scrollPosition()` returns a snapshot with x/y/maxX/maxY from the last committed layout. `mount.scrollIntoView()` minimally adjusts all scrollable ancestors, and requestFocus() uses it too. Requests settle at the same successful input/event boundary as other UI changes. Detached mounts and mutations during read-only rendering are rejected. Wheel input selects an eligible scrolling ancestor of the foremost visible occurrence, with outer scrolling when the inner range is exhausted; Shift+wheel selects the horizontal axis. A diagonal gesture currently goes to one eligible container rather than splitting axes across ancestors. Scrollbars/thumb dragging, touch inertia and PageUp/PageDown are not yet implemented.
|
||||
|
||||
Native/source painting, focus outlines, pointer selection and Mount.hitTest share the final translated geometry and intersected ancestor clip rectangles. A clipped descendant keeps its identity and state but cannot receive pointer clicks outside the viewport. This does not remove it from the managed object graph. Paint x/y may be negative within the existing coordinate budget after projection; dimensions and radii remain nonnegative. See [scroll.endor](examples/scroll.endor) for a shared object tree in two independent native windows.
|
||||
|
||||
`block.bind(property, compute)` binds an existing managed field to a zero-argument function and returns a Subscription with disconnect()/isConnected(). Targets are Block fields, including source-defined fields; arbitrary non-Block objects are not binding targets yet. Native visual fields are now ordinary attributes: TextBlock.text/size/color, RectBlock.width/height/radius/color, Spacer.size and container padding/gap. Direct assignments and native setters feed the same visual snapshot. Text size remains 1..8, geometry must be finite/nonnegative and within the existing limits, and colors use the existing color parser. Legacy textOf still owns its derived text until setText or a text binding replaces it.
|
||||
|
||||
The target's managed content owns its bindings; each binding traces the actual compute function and its captures. Tokens and the host registry hold weak references. Rebinding a field disconnects its previous binding; disconnecting leaves the last value in place. Hidden but still-referenced Blocks update at successful input/event/viewport stabilization boundaries. Functions run read-only against existing objects; they may construct result objects. Dependencies are recorded from actual VM reads, with object-level versions and conservative global-dictionary invalidation. This replaces the earlier candidate API's explicit source list. Binding results are settled before frame publication, including across windows and after lifecycle changes. Values read earlier in the same input precede this batch boundary. Explicit dependencies and property-level dependency precision remain future work.
|
||||
@@ -230,7 +236,7 @@ Native creation and commands remain local until the input/candidate succeeds. Fa
|
||||
|
||||
The native window publishes its current logical content size to the existing VM worker on startup, resize and scale changes. The worker coalesces the latest size, updates the managed viewport input, and refreshes the same runtime without adding Console source/history entries. ui.viewport() returns a fresh managed width/height snapshot; reads during rendering depend on the private input object. User changes to a returned snapshot do not resize the window. Unchanged sizes cause no frame; a fresh or unopened Console runtime updates its inputs without replacing a preserved displayed page. Failed resize layouts stop the affected runtime and preserve the displayed frame.
|
||||
|
||||
The default Column/Button policy propagates available cross-axis width minus padding and leaves height unconstrained; Row propagates available height and leaves width unconstrained. Page uses both viewport bounds. Native and source desired sizes are clamped to their supplied constraints, while source arrange can still allocate explicit child bounds. The window clips overflow and pointer targeting to its extent; container scrolling, wrapping and general multi-pass constraint negotiation remain future work. See [layout-cache.endor](examples/layout-cache.endor). GET code also exposes X-Tessera-Viewport-Width/Height headers without evaluating source.
|
||||
The default Column/Button policy propagates available cross-axis width minus padding and leaves height unconstrained; Row propagates available height and leaves width unconstrained. Page uses both viewport bounds. Native and source desired sizes are clamped to their supplied constraints, while source arrange can still allocate explicit child bounds. The window clips overflow and pointer targeting to its extent; wrapping and general multi-pass constraint negotiation remain future work. See [layout-cache.endor](examples/layout-cache.endor). GET code also exposes X-Tessera-Viewport-Width/Height headers without evaluating source.
|
||||
|
||||
Native pointer clicks now resolve source `hitTest(self, mount, point): Bool` overrides in reverse paint order, then dispatch through the existing capture/target/bubble route. The Point is local to that occurrence; `point.inside(bounds)` uses a half-open rectangle and `point.inCircle(cx, cy, radius)` includes the circle boundary. Each candidate is first restricted to its Mount rectangle, so hit shapes can refine that area, but cannot expand it. A rejected target falls through to another interactive occurrence, including a parent. Ordinary Blocks become interactive through a live click subscription or a source onEvent override; disconnecting the final click subscription updates that status. See [source-hit.endor](examples/source-hit.endor).
|
||||
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
class Painted: RectBlock {
|
||||
function paint(self: Painted, mount: Mount, geometry: Bounds): DisplayList {
|
||||
return RectBlock.paint(self,mount,geometry)
|
||||
}
|
||||
}
|
||||
class Actions {
|
||||
count: Object
|
||||
function click(self: Actions, event: Event): Unit { self.count.increment() }
|
||||
}
|
||||
count = ui.state(0)
|
||||
actions = Actions(count)
|
||||
first = Button("顶部按钮")
|
||||
middle = Button("中间按钮")
|
||||
last = Button("底部按钮")
|
||||
firstConnection = first.on("click",actions.click)
|
||||
middleConnection = middle.on("click",actions.click)
|
||||
lastConnection = last.on("click",actions.click)
|
||||
body = Column(12,12,first,Painted(520,180,8,"#DCE8FF"),middle,RectBlock(520,180,8,"#E3EFE5"),last)
|
||||
scroller = ScrollBlock(320,180,body)
|
||||
root = Column(24,16,TextBlock("同一 Block,两处 Mount 独立滚动"),ui.textOf(count,"value"),scroller)
|
||||
page = Page()
|
||||
page.title = "滚动示例"
|
||||
page.render(root)
|
||||
other = Window()
|
||||
other.setTitle("Scroll Secondary")
|
||||
second = Page()
|
||||
second.title = "独立滚动位置"
|
||||
second.open(other)
|
||||
second.render(root)
|
||||
ui.window().setTitle("Scroll Primary")
|
||||
@@ -29,6 +29,7 @@
|
||||
| app.rs | Window events, logical viewport publication, redraw and system widget pointer/keyboard/IME routing |
|
||||
| clipboard.rs | UTF-8 macOS clipboard adapter independent of Finder locale, with strict decoding and surfaced errors |
|
||||
| system_ui/ | Host-only management widget library: stable IDs, interaction, theme and reusable control drawing |
|
||||
| scroll.rs | Per-Mount offsets, nested scrollIntoView, shared geometry/clip projection and wheel ancestor selection |
|
||||
| scene.rs | Page and developer-tools display-list composition |
|
||||
| developer_tools.rs | Unified Console prompt/output stream, caret/IME mapping, full Sources, Network inspector, theme, scrolling, overlay splitters and focus |
|
||||
| sources.rs | Disconnected cloud workspace and provider boundary for listing/opening complete source files |
|
||||
@@ -115,3 +116,13 @@ current call budget, passes the current managed Window, and validates a real
|
||||
Block result before opening it. Native base visual methods and runtime result
|
||||
checks remain the rendering boundary. Matching present names without an explicit
|
||||
implementation keep the summary fallback and do not execute guest methods.
|
||||
|
||||
ScrollBlock keeps viewport dimensions in the managed Block properties and keeps
|
||||
scroll offsets on Mounts. Layout measures content without a finite viewport bound;
|
||||
a post-layout projection clamps offsets, translates descendants and intersects
|
||||
ancestor clips before committing Mount geometry. It rebuilds native commands and
|
||||
per-command clips; source painting preserves the same clip table. Input, focus
|
||||
outlines and public hit queries consume this projection. Wheel transport carries
|
||||
finite signed deltas, validates the frame/window/session, and invokes the actual
|
||||
Mount.scrollBy method without changing guest focus. Mount requests mark a
|
||||
per-window projection refresh; snapshots/caches never own business objects.
|
||||
|
||||
+17
-5
@@ -635,7 +635,13 @@ impl Worker {
|
||||
};
|
||||
if !matches!(
|
||||
input.kind.as_str(),
|
||||
"click" | "focus" | "tab-activate" | "tab-close" | "tab-detach" | "window-close"
|
||||
"click"
|
||||
| "focus"
|
||||
| "scroll"
|
||||
| "tab-activate"
|
||||
| "tab-close"
|
||||
| "tab-detach"
|
||||
| "window-close"
|
||||
) {
|
||||
return error_response(StatusCode(400), "unsupported event kind");
|
||||
}
|
||||
@@ -684,10 +690,11 @@ impl Worker {
|
||||
) {
|
||||
!frame.tabs.iter().any(|tab| tab.id == input.mount)
|
||||
} else {
|
||||
!frame
|
||||
.mounts
|
||||
.iter()
|
||||
.any(|mount| mount.id == input.mount && mount.interactive)
|
||||
!frame.mounts.iter().any(|mount| {
|
||||
mount.id == input.mount
|
||||
&& (mount.interactive
|
||||
|| input.kind == "scroll" && mount.scroll.is_some())
|
||||
})
|
||||
}
|
||||
|| self.repl.as_ref().is_none_or(|(context, runtime)| {
|
||||
*context != epoch
|
||||
@@ -1042,6 +1049,10 @@ Source measure and arrange overrides execute bottom-up and top-down in one read-
|
||||
|
||||
Source paint overrides execute in the actual frame pipeline under a read-only heap policy. Source hitTest overrides similarly refine native pointer targets in VM paint order; Point.inside(bounds) and Point.inCircle(cx, cy, radius) provide primitive shape queries. Managed DisplayList/ObjectList/PaintCommand and Constraints/Bounds/Point results are ordinary runtime objects.
|
||||
|
||||
ScrollBlock(width,height,child) is a ContainerBlock with managed viewport dimensions and independent per-Mount offsets. mount.scrollTo(x,y), scrollBy(dx,dy), scrollPosition() and scrollIntoView() operate on actual occurrences. Position snapshots expose x/y/maxX/maxY from committed layout; relative requests accumulate and offsets clamp after content/viewport changes. Detached Mounts and read-only rendering mutations are rejected. scrollIntoView and requestFocus adjust nested scrollable ancestors. Native/source paint, focus outlines, hit testing and pointer selection share translated geometry and ancestor clips. Remounting starts a new offset. Paint x/y may be signed after scrolling; dimensions/radii remain nonnegative and coordinate budgets still apply. See examples/scroll.endor. Wheel chooses one eligible ancestor (not per-axis split); native scrollbar dragging, touch inertia and PageUp/PageDown remain pending.
|
||||
|
||||
Native wheel POST /events uses kind scroll with the normal window/session/layout_version, a scrollable mount ID, point=[x,y], delta=[dx,dy], and no press_point. Deltas are signed finite logical pixels within +/-1000000; positive moves toward the end of content. Other kinds must omit delta. Native Shift+wheel maps to horizontal. The host checks the active committed frame, target attachment and clipped viewport before invoking Mount.scrollBy. These fields are transport metadata; source code uses the Endor methods above.
|
||||
|
||||
Trait definitions Visual, EventTarget, Children and Presentable are managed nominal capabilities. ui.implement(type,capability) explicitly declares an implementation after required-method/positional-arity checks; ui.implements(type,capability) and ui.supports(value,capability) query it. Block declares Visual/EventTarget; ContainerBlock declares Children, inherited by Page. Same-name methods alone never declare an implementation. Source subclass construction and host method replacement validate inherited/affected descendant contracts. Native callable signatures are trusted; full parameter/return annotation and effect checks and formal trait syntax remain pending. EventTarget requires canonical on/dispatch/onEvent arities 3/2/1 after self; native optional convenience forms remain.
|
||||
|
||||
For a plain object explicitly implementing Presentable, present(self, window: Window): Block is invoked by ui.present(value) or ui.open(value), using the current managed Window and the same VM budget. The result must be an actual Block. Blocks pass through directly; unregistered values retain the summary fallback. Source views retain their business object via managed fields/callbacks/bindings, as in examples/presentable.endor. Viewing function definitions does not itself execute them. Rendering methods still run read-only with nominal result checks.
|
||||
@@ -1217,6 +1228,7 @@ mod tests {
|
||||
mount: 0,
|
||||
kind: "window-close".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
},
|
||||
1,
|
||||
|
||||
+39
@@ -270,6 +270,7 @@ impl TesseraApp {
|
||||
mount,
|
||||
kind: "focus".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
});
|
||||
}
|
||||
@@ -398,6 +399,7 @@ impl TesseraApp {
|
||||
mount: mount.id,
|
||||
kind: "click".into(),
|
||||
point: Some([point.x, point.y]),
|
||||
delta: None,
|
||||
press_point: Some([point.x, point.y]),
|
||||
})
|
||||
}
|
||||
@@ -423,6 +425,7 @@ impl TesseraApp {
|
||||
mount: frame.tabs[index].id,
|
||||
kind: if close { "tab-close" } else { "tab-activate" }.into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
})
|
||||
});
|
||||
@@ -457,6 +460,7 @@ impl TesseraApp {
|
||||
mount: id,
|
||||
kind: if close { "tab-close" } else { "tab-activate" }.into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
})
|
||||
}
|
||||
@@ -505,6 +509,7 @@ impl TesseraApp {
|
||||
mount: targets[index].id,
|
||||
kind: "focus".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
})
|
||||
});
|
||||
@@ -725,6 +730,7 @@ impl ApplicationHandler<AppEvent> for TesseraApp {
|
||||
mount: 0,
|
||||
kind: "window-close".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
});
|
||||
if let Some(input) = input {
|
||||
@@ -839,6 +845,39 @@ impl ApplicationHandler<AppEvent> for TesseraApp {
|
||||
dx = dy;
|
||||
dy = 0.0;
|
||||
}
|
||||
if !self.guest_covered(self.pointer) {
|
||||
let input = self.namespace.read().ok().and_then(|namespace| {
|
||||
let frame = &namespace.document.frame;
|
||||
let offset = crate::tabs::height(&frame.tabs);
|
||||
if frame.session == 0
|
||||
|| frame.fault.is_some()
|
||||
|| self.pointer.y < offset
|
||||
|| namespace.viewport.is_some_and(|s| {
|
||||
self.pointer.x < 0.0
|
||||
|| self.pointer.x >= s.width
|
||||
|| self.pointer.y >= s.height
|
||||
})
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let point = Point::new(self.pointer.x, self.pointer.y - offset);
|
||||
let delta = [-dx, -dy];
|
||||
let mount = crate::scroll::wheel_target(frame, point, delta)?;
|
||||
Some(crate::events::Input {
|
||||
window: self.resource,
|
||||
session: frame.session,
|
||||
layout_version: frame.layout_version,
|
||||
mount,
|
||||
kind: "scroll".into(),
|
||||
point: Some([point.x, point.y]),
|
||||
press_point: None,
|
||||
delta: Some(delta),
|
||||
})
|
||||
});
|
||||
if let Some(input) = input {
|
||||
self.send_guest(input);
|
||||
}
|
||||
}
|
||||
self.developer_tools
|
||||
.wheel(&self.layout.developer_tools, self.pointer, dx, dy);
|
||||
window.request_redraw();
|
||||
|
||||
+10
-1
@@ -26,6 +26,10 @@ pub enum Kind {
|
||||
color: String,
|
||||
},
|
||||
Spacer(f32),
|
||||
Scroll {
|
||||
width: f32,
|
||||
height: f32,
|
||||
},
|
||||
Row,
|
||||
Column,
|
||||
Button,
|
||||
@@ -147,7 +151,7 @@ impl Data {
|
||||
pub fn is_container(&self) -> bool {
|
||||
matches!(
|
||||
self.kind,
|
||||
Kind::Row | Kind::Column | Kind::Button | Kind::Page
|
||||
Kind::Row | Kind::Column | Kind::Button | Kind::Page | Kind::Scroll { .. }
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -317,6 +321,9 @@ pub fn native_properties(data: &Data) -> Vec<(&'static str, Value)> {
|
||||
("radius", number(*radius)),
|
||||
("color", Value::Text(color.clone())),
|
||||
]),
|
||||
Kind::Scroll { width, height } => {
|
||||
fields.extend([("width", number(*width)), ("height", number(*height))])
|
||||
}
|
||||
Kind::Spacer(size) => fields.push(("size", number(*size))),
|
||||
_ => {}
|
||||
}
|
||||
@@ -375,6 +382,8 @@ pub fn apply_visual_property(data: &mut Data, name: &str, value: &Value) -> Resu
|
||||
crate::document::parse_color(value).map_err(|_| bad())?;
|
||||
color.clone_from(value);
|
||||
}
|
||||
(Kind::Scroll { width, .. }, "width") => *width = number()?,
|
||||
(Kind::Scroll { height, .. }, "height") => *height = number()?,
|
||||
(Kind::Rect { width, .. }, "width") => *width = number()?,
|
||||
(Kind::Rect { height, .. }, "height") => *height = number()?,
|
||||
(Kind::Rect { radius, .. }, "radius") => *radius = number()?,
|
||||
|
||||
+57
-5
@@ -136,6 +136,14 @@ impl RenderDocument {
|
||||
bail!("invalid window identity");
|
||||
}
|
||||
parse_color(&self.frame.background)?;
|
||||
if !self.frame.command_clips.is_empty()
|
||||
&& self.frame.command_clips.len() != self.frame.commands.len()
|
||||
{
|
||||
bail!("invalid command clip table");
|
||||
}
|
||||
for clip in self.frame.command_clips.iter().flatten() {
|
||||
validate_rect(clip[0], clip[1], clip[2], clip[3], 0.0)?;
|
||||
}
|
||||
for command in &self.frame.commands {
|
||||
command.validate()?;
|
||||
}
|
||||
@@ -159,6 +167,17 @@ impl RenderDocument {
|
||||
bail!("invalid or duplicate mount identity");
|
||||
}
|
||||
validate_rect(mount.x, mount.y, mount.width, mount.height, 0.0)?;
|
||||
if let Some(clip) = mount.clip {
|
||||
validate_rect(clip[0], clip[1], clip[2], clip[3], 0.0)?;
|
||||
}
|
||||
if let Some(scroll) = mount.scroll
|
||||
&& (!scroll.iter().all(|n| {
|
||||
n.is_finite() && (0.0..=crate::ui_bridge::MAX_DIMENSION as f32).contains(n)
|
||||
}) || scroll[0] > scroll[2]
|
||||
|| scroll[1] > scroll[3])
|
||||
{
|
||||
bail!("invalid scroll projection");
|
||||
}
|
||||
}
|
||||
for mount in &self.frame.mounts {
|
||||
for linked in [mount.parent, mount.first_child, mount.next_sibling]
|
||||
@@ -191,13 +210,27 @@ impl RenderDocument {
|
||||
let frame = &self.frame;
|
||||
let mut list = DisplayList::default();
|
||||
list.push(DrawCommand::Clear(parse_color(&frame.background)?));
|
||||
for command in &frame.commands {
|
||||
for (index, command) in frame.commands.iter().enumerate() {
|
||||
let clip = frame.command_clips.get(index).copied().flatten();
|
||||
if let Some(clip) = clip {
|
||||
list.push(DrawCommand::PushClip(scaled_rect(
|
||||
clip[0], clip[1], clip[2], clip[3], scale,
|
||||
)));
|
||||
}
|
||||
list.push(command.to_draw_command(scale)?);
|
||||
if clip.is_some() {
|
||||
list.push(DrawCommand::PopClip);
|
||||
}
|
||||
}
|
||||
if let Some(focus) = frame
|
||||
.focus
|
||||
.and_then(|id| frame.mounts.iter().find(|m| m.id == id))
|
||||
{
|
||||
if let Some(c) = focus.clip {
|
||||
list.push(DrawCommand::PushClip(scaled_rect(
|
||||
c[0], c[1], c[2], c[3], scale,
|
||||
)));
|
||||
}
|
||||
list.push(
|
||||
RenderCommand::StrokeRoundedRect {
|
||||
x: focus.x,
|
||||
@@ -210,6 +243,9 @@ impl RenderDocument {
|
||||
}
|
||||
.to_draw_command(scale)?,
|
||||
);
|
||||
if focus.clip.is_some() {
|
||||
list.push(DrawCommand::PopClip);
|
||||
}
|
||||
}
|
||||
if let Some(error) = &frame.fault {
|
||||
list.push(
|
||||
@@ -292,6 +328,8 @@ pub struct Frame {
|
||||
#[serde(default)]
|
||||
pub commands: Vec<RenderCommand>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub command_clips: Vec<Option<[f32; 4]>>,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub mounts: Vec<MountGeometry>,
|
||||
#[serde(default)]
|
||||
pub layout_version: u64,
|
||||
@@ -311,6 +349,7 @@ impl Default for Frame {
|
||||
window: crate::window::MAIN_WINDOW,
|
||||
background: default_background(),
|
||||
commands: Vec::new(),
|
||||
command_clips: Vec::new(),
|
||||
mounts: Vec::new(),
|
||||
layout_version: 0,
|
||||
session: 0,
|
||||
@@ -324,6 +363,10 @@ impl Default for Frame {
|
||||
/// A position in a published frame. Identifiers are opaque data, never VM handles.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
||||
pub struct MountGeometry {
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub clip: Option<[f32; 4]>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub scroll: Option<[f32; 4]>,
|
||||
pub id: u64,
|
||||
pub block_id: String,
|
||||
pub parent: Option<u64>,
|
||||
@@ -336,15 +379,24 @@ pub struct MountGeometry {
|
||||
pub interactive: bool,
|
||||
}
|
||||
|
||||
impl MountGeometry {
|
||||
pub fn contains(&self, point: Point) -> bool {
|
||||
Rect::new(self.x, self.y, self.width, self.height).contains(point)
|
||||
&& self.clip.is_none_or(|c| {
|
||||
c[2] > 0.0 && c[3] > 0.0 && Rect::new(c[0], c[1], c[2], c[3]).contains(point)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Frame {
|
||||
pub fn hit_test(&self, point: Point) -> Option<&MountGeometry> {
|
||||
if self.fault.is_some() {
|
||||
return None;
|
||||
}
|
||||
self.mounts.iter().rev().find(|mount| {
|
||||
mount.interactive
|
||||
&& Rect::new(mount.x, mount.y, mount.width, mount.height).contains(point)
|
||||
})
|
||||
self.mounts
|
||||
.iter()
|
||||
.rev()
|
||||
.find(|mount| mount.interactive && mount.contains(point))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1008,6 +1008,7 @@ mod tests {
|
||||
mount,
|
||||
kind: "click".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None
|
||||
})
|
||||
.is_err()
|
||||
@@ -1190,6 +1191,7 @@ mod tests {
|
||||
mount: initial.frame.tabs[0].id,
|
||||
kind: "tab-activate".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
};
|
||||
let selected = session.dispatch(&input).unwrap().document.unwrap();
|
||||
@@ -1217,6 +1219,7 @@ mod tests {
|
||||
mount: renamed.frame.tabs[1].id,
|
||||
kind: "tab-close".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
})
|
||||
.unwrap()
|
||||
@@ -1431,6 +1434,7 @@ mod tests {
|
||||
mount: mount.id,
|
||||
kind: "click".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
})
|
||||
.unwrap()
|
||||
@@ -1757,6 +1761,7 @@ mod tests {
|
||||
mount: circle.id,
|
||||
kind: "click".into(),
|
||||
point: Some(release),
|
||||
delta: None,
|
||||
press_point: Some(press),
|
||||
})
|
||||
.unwrap();
|
||||
@@ -1800,6 +1805,7 @@ mod tests {
|
||||
mount: circle.id,
|
||||
kind: "click".into(),
|
||||
point: Some([64.0, 64.0]),
|
||||
delta: None,
|
||||
press_point: Some([64.0, 64.0]),
|
||||
})
|
||||
.err()
|
||||
@@ -2265,6 +2271,7 @@ mod tests {
|
||||
mount: mount.id,
|
||||
kind: "click".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
})
|
||||
.unwrap()
|
||||
@@ -2544,6 +2551,7 @@ mod tests {
|
||||
mount: mount.id,
|
||||
kind: "click".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
};
|
||||
let updated = session.dispatch(&event).unwrap().document.unwrap();
|
||||
@@ -2562,6 +2570,154 @@ mod tests {
|
||||
assert!(!session.is_faulted());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() {
|
||||
let (mut session, initial) =
|
||||
ReplSession::load(include_str!("../examples/scroll.endor"), "app.main", 1, 240)
|
||||
.unwrap();
|
||||
let globals = session.candidate.globals.unwrap();
|
||||
let Value::Object(middle) = session
|
||||
.candidate
|
||||
.vm
|
||||
.dict_get(globals, &Value::Text("middle".into()))
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
else {
|
||||
panic!("expected Block");
|
||||
};
|
||||
let target = initial
|
||||
.frame
|
||||
.mounts
|
||||
.iter()
|
||||
.find(|m| m.block_id == middle.to_string())
|
||||
.unwrap();
|
||||
let point = [
|
||||
target.x + target.width / 2.0,
|
||||
target.y + target.height / 2.0,
|
||||
];
|
||||
assert!(!target.contains(crate::geometry::Point::new(point[0], point[1])));
|
||||
session
|
||||
.dispatch(&crate::events::Input {
|
||||
window: 1,
|
||||
session: 240,
|
||||
layout_version: initial.frame.layout_version,
|
||||
mount: target.id,
|
||||
kind: "click".into(),
|
||||
point: Some(point),
|
||||
press_point: Some(point),
|
||||
delta: None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
session.execute("count.value", "app.main").unwrap().value,
|
||||
"0"
|
||||
);
|
||||
session.execute("saved = scroller.mounts().at(0)\nsaved.scrollTo(0,100)\nsaved.scrollBy(0,20)\nsaved.scrollBy(0,30)","app.main").unwrap();
|
||||
assert_eq!(
|
||||
session
|
||||
.execute("saved.scrollPosition().y", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"150"
|
||||
);
|
||||
assert_eq!(
|
||||
session
|
||||
.execute("scroller.mounts().at(1).scrollPosition().y", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"0"
|
||||
);
|
||||
session
|
||||
.execute("last.mounts().at(0).scrollIntoView()", "app.main")
|
||||
.unwrap();
|
||||
let Value::Object(last) = session
|
||||
.candidate
|
||||
.vm
|
||||
.dict_get(globals, &Value::Text("last".into()))
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
else {
|
||||
panic!("expected Block");
|
||||
};
|
||||
let frame = &session.documents[&crate::window::MAIN_WINDOW].frame;
|
||||
let target = frame
|
||||
.mounts
|
||||
.iter()
|
||||
.find(|m| m.block_id == last.to_string())
|
||||
.unwrap();
|
||||
assert!(target.contains(crate::geometry::Point::new(
|
||||
target.x + target.width / 2.0,
|
||||
target.y + target.height / 2.0
|
||||
)));
|
||||
assert_eq!(frame.command_clips.len(), frame.commands.len());
|
||||
session
|
||||
.execute("scroller.height = 1000", "app.main")
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
session
|
||||
.execute("saved.scrollPosition().y", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"0"
|
||||
);
|
||||
assert_eq!(
|
||||
session
|
||||
.execute("saved.scrollPosition().maxY", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"0"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nested_scroll_into_view_and_source_paint_share_clipped_geometry() {
|
||||
let mut session = ReplSession::new(241).unwrap();
|
||||
let result = session
|
||||
.execute(
|
||||
r#"
|
||||
class Painted: RectBlock {
|
||||
function paint(self: Painted, mount: Mount, geometry: Bounds): DisplayList {
|
||||
return RectBlock.paint(self,mount,geometry)
|
||||
}
|
||||
}
|
||||
last = Button("last")
|
||||
inner = ScrollBlock(160,100,Column(0,8,Painted(200,180),last))
|
||||
outer = ScrollBlock(180,140,Column(0,8,RectBlock(180,180),inner))
|
||||
page = Page()
|
||||
page.render(outer)
|
||||
"#,
|
||||
"app.main",
|
||||
)
|
||||
.unwrap()
|
||||
.document
|
||||
.unwrap();
|
||||
assert!(result.frame.command_clips.iter().any(Option::is_some));
|
||||
session
|
||||
.execute("last.mounts().at(0).scrollIntoView()", "app.main")
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
session
|
||||
.execute("inner.mounts().at(0).scrollPosition().y", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"128"
|
||||
);
|
||||
assert_eq!(
|
||||
session
|
||||
.execute("outer.mounts().at(0).scrollPosition().y", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"148"
|
||||
);
|
||||
assert_eq!(
|
||||
session
|
||||
.execute("last.mounts().at(0).hitTest(10,110)", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"true"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn presentable_dispatch_preserves_source_identity_and_reactive_display() {
|
||||
let (mut session, initial) = ReplSession::load(
|
||||
|
||||
@@ -22,6 +22,8 @@ pub struct Input {
|
||||
pub point: Option<[f32; 2]>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub press_point: Option<[f32; 2]>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub delta: Option<[f32; 2]>,
|
||||
}
|
||||
|
||||
fn default_window() -> u64 {
|
||||
@@ -33,6 +35,24 @@ impl Input {
|
||||
if self.window == 0 {
|
||||
return Err("window identity must be nonzero");
|
||||
}
|
||||
if self.kind == "scroll" {
|
||||
return match (self.point, self.press_point, self.delta) {
|
||||
(Some(point), None, Some(delta))
|
||||
if point
|
||||
.iter()
|
||||
.all(|v| v.is_finite() && (0.0..=1_000_000.0).contains(v))
|
||||
&& delta
|
||||
.iter()
|
||||
.all(|v| v.is_finite() && v.abs() <= 1_000_000.0) =>
|
||||
{
|
||||
Ok(())
|
||||
}
|
||||
_ => Err("scroll requires point and finite delta, with no press_point"),
|
||||
};
|
||||
}
|
||||
if self.delta.is_some() {
|
||||
return Err("delta is only accepted for scroll input");
|
||||
}
|
||||
match (self.point, self.press_point) {
|
||||
(None, None) => Ok(()),
|
||||
(Some(point), Some(press))
|
||||
|
||||
@@ -64,6 +64,9 @@ pub fn root_constraints(viewport: Option<Size>) -> [f32; 4] {
|
||||
[0.0, 0.0, size.width, size.height]
|
||||
}
|
||||
pub fn child_constraints(node: &UiNode, parent: [f32; 4]) -> [f32; 4] {
|
||||
if matches!(node.kind, UiKind::Scroll { .. }) {
|
||||
return [0.0, 0.0, MAX_DIMENSION as f32, MAX_DIMENSION as f32];
|
||||
}
|
||||
match container(node) {
|
||||
Some((true, padding, _)) => [
|
||||
0.0,
|
||||
@@ -90,6 +93,7 @@ pub fn constrained(size: Size, constraints: [f32; 4]) -> Size {
|
||||
fn container(node: &UiNode) -> Option<(bool, f32, f32)> {
|
||||
match &node.kind {
|
||||
UiKind::Row { padding, gap, .. } => Some((true, *padding, *gap)),
|
||||
UiKind::Scroll { padding, gap, .. } => Some((false, *padding, *gap)),
|
||||
UiKind::Column { padding, gap, .. } | UiKind::Button { padding, gap, .. } => {
|
||||
Some((false, *padding, *gap))
|
||||
}
|
||||
@@ -145,6 +149,7 @@ fn shape(node: &UiNode, children: Vec<Size>) -> Result<Shape> {
|
||||
UiKind::Text { value, size, .. } => Shape::Text(value.clone(), *size),
|
||||
UiKind::Rect { width, height, .. } => Shape::Rect(*width, *height),
|
||||
UiKind::Spacer(size) => Shape::Rect(*size, *size),
|
||||
UiKind::Scroll { width, height, .. } => Shape::Rect(*width, *height),
|
||||
_ => {
|
||||
let (row, padding, gap) = container(node).context("unknown native visual protocol")?;
|
||||
Shape::Container(row, padding, gap, children)
|
||||
@@ -345,6 +350,8 @@ impl LayoutRuntime {
|
||||
bounded(y + size.height)?;
|
||||
mounts.push(MountGeometry {
|
||||
id: item.id,
|
||||
clip: None,
|
||||
scroll: None,
|
||||
block_id: item.node.block_id.clone(),
|
||||
parent: item.parent.map(|i| items[i].id),
|
||||
first_child: item.children.first().map(|i| items[*i].id),
|
||||
|
||||
@@ -19,6 +19,7 @@ mod object_list;
|
||||
mod presentation;
|
||||
mod protocols;
|
||||
mod scene;
|
||||
mod scroll;
|
||||
mod snapshot;
|
||||
mod software_renderer;
|
||||
mod source_hit;
|
||||
|
||||
+64
-14
@@ -18,6 +18,7 @@ pub struct Mount {
|
||||
pub first_child: Option<WeakObjectRef>,
|
||||
pub next_sibling: Option<WeakObjectRef>,
|
||||
pub geometry: MountGeometry,
|
||||
pub scroll_offset: [f32; 2],
|
||||
pub version: u64,
|
||||
pub mounted: bool,
|
||||
// Private derived scratch, installed before the read-only layout call and
|
||||
@@ -46,6 +47,10 @@ impl ObjectPayload for Mount {
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
enum Query {
|
||||
Bounds,
|
||||
ScrollTo,
|
||||
ScrollBy,
|
||||
ScrollPosition,
|
||||
ScrollIntoView,
|
||||
Parent,
|
||||
FirstChild,
|
||||
NextSibling,
|
||||
@@ -64,10 +69,24 @@ struct Method {
|
||||
impl NativeCallable for Method {
|
||||
fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
|
||||
let mount = cx.store().payload::<Mount>(self.owner, "Mount")?.clone();
|
||||
if !mount.mounted && matches!(self.query, Query::Bounds | Query::Focus | Query::HitTest) {
|
||||
if !mount.mounted
|
||||
&& matches!(
|
||||
self.query,
|
||||
Query::Bounds
|
||||
| Query::Focus
|
||||
| Query::HitTest
|
||||
| Query::ScrollTo
|
||||
| Query::ScrollBy
|
||||
| Query::ScrollIntoView
|
||||
| Query::ScrollPosition
|
||||
)
|
||||
{
|
||||
return Err(VmError::InvalidArgument("Mount is no longer attached"));
|
||||
}
|
||||
let arity = if matches!(self.query, Query::HitTest) {
|
||||
let arity = if matches!(
|
||||
self.query,
|
||||
Query::HitTest | Query::ScrollTo | Query::ScrollBy
|
||||
) {
|
||||
2
|
||||
} else {
|
||||
0
|
||||
@@ -76,6 +95,34 @@ impl NativeCallable for Method {
|
||||
return Err(VmError::InvalidArgument("incorrect Mount method arity"));
|
||||
}
|
||||
let value = match self.query {
|
||||
Query::ScrollTo | Query::ScrollBy => {
|
||||
crate::scroll::set(
|
||||
cx,
|
||||
self.owner,
|
||||
self.desktop,
|
||||
[
|
||||
crate::scroll::coordinate(&args[0])?,
|
||||
crate::scroll::coordinate(&args[1])?,
|
||||
],
|
||||
matches!(self.query, Query::ScrollBy),
|
||||
)?;
|
||||
Value::Nil
|
||||
}
|
||||
Query::ScrollIntoView => {
|
||||
crate::scroll::into_view(cx, self.owner, self.desktop)?;
|
||||
Value::Nil
|
||||
}
|
||||
Query::ScrollPosition => {
|
||||
let p = mount
|
||||
.geometry
|
||||
.scroll
|
||||
.ok_or(VmError::InvalidArgument("Mount is not scrollable"))?;
|
||||
let result = cx.new_object()?;
|
||||
for (name, value) in [("x", p[0]), ("y", p[1]), ("maxX", p[2]), ("maxY", p[3])] {
|
||||
cx.set_attr(result, name, Value::Number((value as f64).into()))?;
|
||||
}
|
||||
Value::Object(result)
|
||||
}
|
||||
Query::Bounds => {
|
||||
let geometry = if let Some(layout) = &mount.layout {
|
||||
layout
|
||||
@@ -110,6 +157,7 @@ impl NativeCallable for Method {
|
||||
Value::Object(bounds)
|
||||
}
|
||||
Query::Focus => {
|
||||
crate::scroll::into_view(cx, self.owner, self.desktop)?;
|
||||
if !mount.geometry.interactive {
|
||||
return Err(VmError::InvalidArgument("Mount is not focusable"));
|
||||
}
|
||||
@@ -145,18 +193,10 @@ impl NativeCallable for Method {
|
||||
}
|
||||
Ok(number)
|
||||
};
|
||||
Value::Bool(
|
||||
crate::geometry::Rect::new(
|
||||
mount.geometry.x,
|
||||
mount.geometry.y,
|
||||
mount.geometry.width,
|
||||
mount.geometry.height,
|
||||
)
|
||||
.contains(crate::geometry::Point::new(
|
||||
number(&args[0])?,
|
||||
number(&args[1])?,
|
||||
)),
|
||||
)
|
||||
Value::Bool(mount.geometry.contains(crate::geometry::Point::new(
|
||||
number(&args[0])?,
|
||||
number(&args[1])?,
|
||||
)))
|
||||
}
|
||||
query => {
|
||||
let weak = match query {
|
||||
@@ -277,6 +317,7 @@ impl NativeCallable for Sync {
|
||||
first_child: None,
|
||||
next_sibling: None,
|
||||
geometry: geometry.clone(),
|
||||
scroll_offset: [0.0, 0.0],
|
||||
version: self.frame.layout_version,
|
||||
mounted: true,
|
||||
layout: None,
|
||||
@@ -284,6 +325,10 @@ impl NativeCallable for Sync {
|
||||
crate::ui_bridge::attach_desktop_type(cx, object, "Mount", self.desktop)?;
|
||||
for (name, query) in [
|
||||
("bounds", Query::Bounds),
|
||||
("scrollTo", Query::ScrollTo),
|
||||
("scrollBy", Query::ScrollBy),
|
||||
("scrollPosition", Query::ScrollPosition),
|
||||
("scrollIntoView", Query::ScrollIntoView),
|
||||
("parent", Query::Parent),
|
||||
("firstChild", Query::FirstChild),
|
||||
("nextSibling", Query::NextSibling),
|
||||
@@ -322,6 +367,11 @@ impl NativeCallable for Sync {
|
||||
first_child: link(geometry.first_child)?,
|
||||
next_sibling: link(geometry.next_sibling)?,
|
||||
geometry: geometry.clone(),
|
||||
scroll_offset: if self.preparing {
|
||||
cx.store().payload::<Mount>(object, "Mount")?.scroll_offset
|
||||
} else {
|
||||
geometry.scroll.map(|s| [s[0], s[1]]).unwrap_or([0.0, 0.0])
|
||||
},
|
||||
version: self.frame.layout_version,
|
||||
mounted: true,
|
||||
layout: if self.preparing {
|
||||
|
||||
@@ -192,8 +192,8 @@ impl NativeCallable for Method {
|
||||
)?)
|
||||
}
|
||||
Query::Paint => {
|
||||
let x = number(cx, input, "x", false)?;
|
||||
let y = number(cx, input, "y", false)?;
|
||||
let x = number(cx, input, "x", true)?;
|
||||
let y = number(cx, input, "y", true)?;
|
||||
let width = number(cx, input, "width", false)?;
|
||||
let height = number(cx, input, "height", false)?;
|
||||
if x + width > MAX_DIMENSION as f32 || y + height > MAX_DIMENSION as f32 {
|
||||
|
||||
+241
@@ -0,0 +1,241 @@
|
||||
//! Per-occurrence scroll state and a single geometry/clip projection shared by
|
||||
//! native paint, source paint and input. No business object is copied.
|
||||
use crate::{
|
||||
document::Frame,
|
||||
geometry::Point,
|
||||
layout::{self, Size},
|
||||
mount::{Mount, MountTable},
|
||||
ui_bridge::{UiKind, UiNode},
|
||||
};
|
||||
use anyhow::{Result, bail};
|
||||
use endor_core::{NativeContext, ObjectRef, Value, Vm, VmError, WeakObjectRef};
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn intersection(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
|
||||
let x = a[0].max(b[0]);
|
||||
let y = a[1].max(b[1]);
|
||||
[
|
||||
x,
|
||||
y,
|
||||
(a[0] + a[2]).min(b[0] + b[2]).max(x) - x,
|
||||
(a[1] + a[3]).min(b[1] + b[3]).max(y) - y,
|
||||
]
|
||||
}
|
||||
pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame) -> Result<()> {
|
||||
let mut nodes = HashMap::new();
|
||||
let mut work = vec![root];
|
||||
while let Some(node) = work.pop() {
|
||||
nodes.insert(node.block_id.as_str(), node);
|
||||
work.extend(node.children().iter().map(|node| node.as_ref()));
|
||||
}
|
||||
let indices: HashMap<_, _> = frame
|
||||
.mounts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, m)| (m.id, i))
|
||||
.collect();
|
||||
let scrolling: Vec<_> = frame
|
||||
.mounts
|
||||
.iter()
|
||||
.map(|m| matches!(nodes[m.block_id.as_str()].kind, UiKind::Scroll { .. }))
|
||||
.collect();
|
||||
let mut extent: Vec<_> = frame
|
||||
.mounts
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let padding = match nodes[m.block_id.as_str()].kind {
|
||||
UiKind::Scroll { padding, .. } => padding,
|
||||
_ => 0.0,
|
||||
};
|
||||
(m.x + m.width - padding, m.y + m.height - padding)
|
||||
})
|
||||
.collect();
|
||||
for i in (0..frame.mounts.len()).rev() {
|
||||
let m = &frame.mounts[i];
|
||||
if let Some(parent) = m.parent {
|
||||
let parent = indices[&parent];
|
||||
let e = if scrolling[i] {
|
||||
(m.x + m.width, m.y + m.height)
|
||||
} else {
|
||||
extent[i]
|
||||
};
|
||||
extent[parent].0 = extent[parent].0.max(e.0);
|
||||
extent[parent].1 = extent[parent].1.max(e.1);
|
||||
}
|
||||
}
|
||||
let mut contexts = HashMap::<u64, (f32, f32, Option<[f32; 4]>)>::new();
|
||||
frame.commands.clear();
|
||||
frame.command_clips.clear();
|
||||
for (i, m) in frame.mounts.iter_mut().enumerate() {
|
||||
let (dx, dy, clip) = m
|
||||
.parent
|
||||
.and_then(|id| contexts.get(&id).copied())
|
||||
.unwrap_or_default();
|
||||
let padding = match nodes[m.block_id.as_str()].kind {
|
||||
UiKind::Scroll { padding, .. } => padding,
|
||||
_ => 0.0,
|
||||
};
|
||||
let limits = [
|
||||
(extent[i].0 + padding - m.x - m.width).max(0.0),
|
||||
(extent[i].1 + padding - m.y - m.height).max(0.0),
|
||||
];
|
||||
m.x -= dx;
|
||||
m.y -= dy;
|
||||
m.clip = clip;
|
||||
let mut child = (dx, dy, clip);
|
||||
if scrolling[i] {
|
||||
let weak = table
|
||||
.active
|
||||
.get(&m.id)
|
||||
.ok_or_else(|| anyhow::anyhow!("missing scroll Mount"))?;
|
||||
let owner = vm
|
||||
.upgrade(*weak)?
|
||||
.ok_or_else(|| anyhow::anyhow!("expired scroll Mount"))?;
|
||||
let offset = vm
|
||||
.payload::<Mount>(owner, "Mount")
|
||||
.map(|mount| mount.scroll_offset);
|
||||
vm.release(owner)?;
|
||||
let offset = offset?;
|
||||
let x = offset[0].clamp(0.0, limits[0]);
|
||||
let y = offset[1].clamp(0.0, limits[1]);
|
||||
m.scroll = Some([x, y, limits[0], limits[1]]);
|
||||
let viewport = [m.x, m.y, m.width, m.height];
|
||||
child = (
|
||||
dx + x,
|
||||
dy + y,
|
||||
Some(
|
||||
clip.map(|clip| intersection(clip, viewport))
|
||||
.unwrap_or(viewport),
|
||||
),
|
||||
);
|
||||
}
|
||||
contexts.insert(m.id, child);
|
||||
if let Some(command) = layout::paint_native(
|
||||
nodes[m.block_id.as_str()],
|
||||
m.x,
|
||||
m.y,
|
||||
Size {
|
||||
width: m.width,
|
||||
height: m.height,
|
||||
},
|
||||
) {
|
||||
frame.commands.push(command);
|
||||
frame.command_clips.push(m.clip);
|
||||
}
|
||||
}
|
||||
if frame.commands.len() > 10_000 {
|
||||
bail!("scroll paint command budget exceeded");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn coordinate(value: &Value) -> Result<f32, VmError> {
|
||||
let Value::Number(value) = value else {
|
||||
return Err(VmError::InvalidArgument(
|
||||
"scroll coordinates must be numbers",
|
||||
));
|
||||
};
|
||||
let n = value
|
||||
.to_string()
|
||||
.parse::<f32>()
|
||||
.map_err(|_| VmError::InvalidArgument("invalid scroll coordinate"))?;
|
||||
if !n.is_finite() || n.abs() > 1_000_000.0 {
|
||||
return Err(VmError::InvalidArgument("scroll coordinate exceeds limits"));
|
||||
}
|
||||
Ok(n)
|
||||
}
|
||||
pub fn set(
|
||||
cx: &mut NativeContext<'_>,
|
||||
owner: ObjectRef,
|
||||
desktop: WeakObjectRef,
|
||||
point: [f32; 2],
|
||||
relative: bool,
|
||||
) -> Result<(), VmError> {
|
||||
let mut mount = cx.store().payload::<Mount>(owner, "Mount")?.clone();
|
||||
if !mount.mounted || mount.layout.is_some() {
|
||||
return Err(VmError::InvalidArgument(
|
||||
"scroll requires committed attached Mount",
|
||||
));
|
||||
}
|
||||
let bounds = mount
|
||||
.geometry
|
||||
.scroll
|
||||
.ok_or(VmError::InvalidArgument("Mount is not scrollable"))?;
|
||||
let next = if relative {
|
||||
[
|
||||
mount.scroll_offset[0] + point[0],
|
||||
mount.scroll_offset[1] + point[1],
|
||||
]
|
||||
} else {
|
||||
point
|
||||
};
|
||||
mount.scroll_offset = [next[0].clamp(0.0, bounds[2]), next[1].clamp(0.0, bounds[3])];
|
||||
let desktop = cx
|
||||
.upgrade(desktop)?
|
||||
.ok_or(VmError::InvalidArgument("Mount window expired"))?;
|
||||
// Check the normal mutation barrier even when the clamped result is equal.
|
||||
cx.replace_payload(owner, mount)?;
|
||||
cx.set_attr(desktop, "scrollRequested", Value::Bool(true))
|
||||
}
|
||||
pub fn into_view(
|
||||
cx: &mut NativeContext<'_>,
|
||||
owner: ObjectRef,
|
||||
desktop: WeakObjectRef,
|
||||
) -> Result<(), VmError> {
|
||||
let mount = cx.store().payload::<Mount>(owner, "Mount")?.clone();
|
||||
if !mount.mounted || mount.layout.is_some() {
|
||||
return Err(VmError::InvalidArgument(
|
||||
"scrollIntoView requires committed attached Mount",
|
||||
));
|
||||
}
|
||||
let mut rect = [
|
||||
mount.geometry.x,
|
||||
mount.geometry.y,
|
||||
mount.geometry.width,
|
||||
mount.geometry.height,
|
||||
];
|
||||
let mut parent = mount.parent;
|
||||
while let Some(weak) = parent {
|
||||
let Some(owner) = cx.upgrade(weak)? else {
|
||||
break;
|
||||
};
|
||||
let mount = cx.store().payload::<Mount>(owner, "Mount")?.clone();
|
||||
parent = mount.parent;
|
||||
if let Some(offset) = mount.geometry.scroll {
|
||||
let delta = |start: f32, length: f32, viewport: f32, size: f32| {
|
||||
if start < viewport {
|
||||
start - viewport
|
||||
} else {
|
||||
(start + length - viewport - size).max(0.0)
|
||||
}
|
||||
};
|
||||
let dx = delta(rect[0], rect[2], mount.geometry.x, mount.geometry.width);
|
||||
let dy = delta(rect[1], rect[3], mount.geometry.y, mount.geometry.height);
|
||||
let x = (offset[0] + dx).clamp(0.0, offset[2]);
|
||||
let y = (offset[1] + dy).clamp(0.0, offset[3]);
|
||||
rect[0] -= x - offset[0];
|
||||
rect[1] -= y - offset[1];
|
||||
if x != offset[0] || y != offset[1] {
|
||||
set(cx, owner, desktop, [x, y], false)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn wheel_target(frame: &Frame, point: Point, delta: [f32; 2]) -> Option<u64> {
|
||||
let indices: HashMap<_, _> = frame.mounts.iter().map(|mount| (mount.id, mount)).collect();
|
||||
let mut current = frame
|
||||
.mounts
|
||||
.iter()
|
||||
.rev()
|
||||
.find(|mount| mount.contains(point));
|
||||
while let Some(mount) = current {
|
||||
if mount.scroll.is_some_and(|s| {
|
||||
(s[0] + delta[0]).clamp(0.0, s[2]) != s[0] || (s[1] + delta[1]).clamp(0.0, s[3]) != s[1]
|
||||
}) {
|
||||
return Some(mount.id);
|
||||
}
|
||||
current = mount.parent.and_then(|id| indices.get(&id).copied());
|
||||
}
|
||||
None
|
||||
}
|
||||
@@ -236,6 +236,13 @@ impl RenderCache {
|
||||
radius: *radius,
|
||||
color: color.clone(),
|
||||
},
|
||||
Kind::Scroll { width, height } => UiKind::Scroll {
|
||||
width: *width,
|
||||
height: *height,
|
||||
padding: data.padding,
|
||||
gap: data.gap,
|
||||
children,
|
||||
},
|
||||
Kind::Spacer(size) => UiKind::Spacer(*size),
|
||||
Kind::Row => UiKind::Row {
|
||||
padding: data.padding,
|
||||
|
||||
+6
-1
@@ -62,7 +62,12 @@ fn selector(
|
||||
.upgrade(*weak)?
|
||||
.ok_or(VmError::InvalidArgument("pointer Mount expired"))?;
|
||||
let target = cx.store().payload::<Mount>(mount, "Mount")?.clone();
|
||||
if !target.mounted || !target.geometry.interactive {
|
||||
if !target.mounted
|
||||
|| !target.geometry.interactive
|
||||
|| !target
|
||||
.geometry
|
||||
.contains(crate::geometry::Point::new(point[0], point[1]))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let geometry = &target.geometry;
|
||||
|
||||
+8
-1
@@ -42,7 +42,10 @@ fn number(store: &ObjectStore, object: ObjectRef, name: &str) -> Result<f32, VmE
|
||||
.to_string()
|
||||
.parse::<f32>()
|
||||
.map_err(|_| invalid("invalid paint number"))?;
|
||||
if !value.is_finite() || !(0.0..=MAX_DIMENSION as f32).contains(&value) {
|
||||
if !value.is_finite()
|
||||
|| value.abs() > MAX_DIMENSION as f32
|
||||
|| (!matches!(name, "x" | "y") && value < 0.0)
|
||||
{
|
||||
return Err(invalid("paint number exceeds bounds"));
|
||||
}
|
||||
Ok(value)
|
||||
@@ -294,7 +297,9 @@ pub fn render(
|
||||
pending.extend(node.children().iter().map(|node| node.as_ref()));
|
||||
}
|
||||
let mut commands = Vec::new();
|
||||
let mut clips = Vec::new();
|
||||
for mount in &frame.mounts {
|
||||
let before = commands.len();
|
||||
if let Some(custom) = output.commands.get(&mount.id) {
|
||||
commands.extend(custom.iter().cloned());
|
||||
} else {
|
||||
@@ -313,11 +318,13 @@ pub fn render(
|
||||
commands.push(command);
|
||||
}
|
||||
}
|
||||
clips.extend(std::iter::repeat_n(mount.clip, commands.len() - before));
|
||||
if commands.len() > 10_000 {
|
||||
bail!("paint command budget exceeded");
|
||||
}
|
||||
}
|
||||
frame.commands = commands;
|
||||
frame.command_clips = clips;
|
||||
let registry = object(vm.get_attr(desktop, "types")?)?;
|
||||
Ok(reads
|
||||
.into_iter()
|
||||
|
||||
+100
-2
@@ -27,6 +27,7 @@ pub const TYPE_NAMES: &[&str] = &[
|
||||
"Presentable",
|
||||
"Block",
|
||||
"ContainerBlock",
|
||||
"ScrollBlock",
|
||||
"TextBlock",
|
||||
"RectBlock",
|
||||
"Spacer",
|
||||
@@ -69,7 +70,8 @@ impl UiNode {
|
||||
match &self.kind {
|
||||
UiKind::Column { children, .. }
|
||||
| UiKind::Row { children, .. }
|
||||
| UiKind::Button { children, .. } => children,
|
||||
| UiKind::Button { children, .. }
|
||||
| UiKind::Scroll { children, .. } => children,
|
||||
_ => &[],
|
||||
}
|
||||
}
|
||||
@@ -118,6 +120,22 @@ impl UiNode {
|
||||
},
|
||||
) => (a, b, c, d) == (e, f, g, h),
|
||||
(UiKind::Spacer(a), UiKind::Spacer(b)) => a == b,
|
||||
(
|
||||
UiKind::Scroll {
|
||||
width: a,
|
||||
height: b,
|
||||
padding: pa,
|
||||
gap: ga,
|
||||
children: _,
|
||||
},
|
||||
UiKind::Scroll {
|
||||
width: c,
|
||||
height: d,
|
||||
padding: pb,
|
||||
gap: gb,
|
||||
children: _,
|
||||
},
|
||||
) => a == c && b == d && pa == pb && ga == gb && same_children(),
|
||||
(
|
||||
UiKind::Column {
|
||||
padding: a, gap: b, ..
|
||||
@@ -176,6 +194,13 @@ pub enum UiKind {
|
||||
children: Vec<Arc<UiNode>>,
|
||||
},
|
||||
Spacer(f32),
|
||||
Scroll {
|
||||
width: f32,
|
||||
height: f32,
|
||||
padding: f32,
|
||||
gap: f32,
|
||||
children: Vec<Arc<UiNode>>,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
@@ -232,6 +257,7 @@ enum Operation {
|
||||
Text,
|
||||
Rect,
|
||||
Spacer,
|
||||
Scroll,
|
||||
Row,
|
||||
Column,
|
||||
Button,
|
||||
@@ -428,6 +454,7 @@ fn new_typed_block(
|
||||
Kind::Text { .. } => "TextBlock",
|
||||
Kind::Rect { .. } => "RectBlock",
|
||||
Kind::Spacer(_) => "Spacer",
|
||||
Kind::Scroll { .. } => "ScrollBlock",
|
||||
Kind::Row => "Row",
|
||||
Kind::Column => "Column",
|
||||
Kind::Button => "Button",
|
||||
@@ -659,6 +686,7 @@ impl NativeCallable for Function {
|
||||
State | StateSet => (1, 1),
|
||||
Increment => (0, 0),
|
||||
TextOf => (2, 4),
|
||||
Scroll => (3, 3),
|
||||
Text => (1, 3),
|
||||
Rect => (2, 4),
|
||||
MoveWindow | OpenValue | Spacer | SetText | SetColor | Append | Remove | Render
|
||||
@@ -931,6 +959,15 @@ impl NativeCallable for Function {
|
||||
)?)));
|
||||
}
|
||||
let constructor = match self.operation {
|
||||
Scroll => Some(Data::new(
|
||||
Kind::Scroll {
|
||||
width: dimension(args.first())?,
|
||||
height: dimension(args.get(1))?,
|
||||
},
|
||||
vec![object(args.get(2))?],
|
||||
0.0,
|
||||
0.0,
|
||||
)),
|
||||
Text => Some(Data::new(
|
||||
Kind::Text {
|
||||
value: text(args.first())?,
|
||||
@@ -1674,9 +1711,56 @@ impl UiBridge {
|
||||
.ok_or_else(|| anyhow::anyhow!("Mount is no longer active"))?,
|
||||
state.desktop,
|
||||
state.mounts.ordered(),
|
||||
state.layout.viewport,
|
||||
state.layout.viewport.map(|size| crate::layout::Size {
|
||||
width: size.width,
|
||||
height: (size.height - crate::tabs::height(&state.last_tabs)).max(0.0),
|
||||
}),
|
||||
)
|
||||
};
|
||||
if input.kind == "scroll" {
|
||||
let mount = vm
|
||||
.upgrade(weak)?
|
||||
.ok_or_else(|| anyhow::anyhow!("scroll Mount expired"))?;
|
||||
let result = (|| {
|
||||
let data = vm.payload::<crate::mount::Mount>(mount, "Mount")?;
|
||||
let point = input
|
||||
.point
|
||||
.ok_or_else(|| anyhow::anyhow!("scroll has no pointer"))?;
|
||||
if !data.mounted
|
||||
|| data.version != input.layout_version
|
||||
|| viewport
|
||||
.is_some_and(|size| point[0] >= size.width || point[1] >= size.height)
|
||||
|| !data
|
||||
.geometry
|
||||
.contains(crate::geometry::Point::new(point[0], point[1]))
|
||||
{
|
||||
bail!("scroll targets an obsolete or clipped Mount");
|
||||
}
|
||||
let delta = input
|
||||
.delta
|
||||
.ok_or_else(|| anyhow::anyhow!("scroll has no delta"))?;
|
||||
let method = vm.bind_attr(mount, "scrollBy")?;
|
||||
let result = match method {
|
||||
Value::Object(function) => vm.call_with_limits(
|
||||
function,
|
||||
&[
|
||||
Value::Number((delta[0] as f64).into()),
|
||||
Value::Number((delta[1] as f64).into()),
|
||||
],
|
||||
endor_core::ExecutionLimits {
|
||||
max_frames: 128,
|
||||
max_instructions: 100_000,
|
||||
},
|
||||
),
|
||||
_ => Err(invalid("scrollBy is not callable")),
|
||||
};
|
||||
vm.release_value(method)?;
|
||||
vm.release_value(result?)?;
|
||||
Ok(())
|
||||
})();
|
||||
vm.release(mount)?;
|
||||
return result;
|
||||
}
|
||||
let mount = if let (Some(press), Some(release)) = (input.press_point, input.point) {
|
||||
if viewport.is_some_and(|size| {
|
||||
[press, release]
|
||||
@@ -1830,6 +1914,10 @@ impl UiBridge {
|
||||
let changed = state.pending.is_some()
|
||||
|| !same
|
||||
|| focus_changed
|
||||
|| matches!(
|
||||
vm.get_attr(state.desktop, "scrollRequested"),
|
||||
Ok(Value::Bool(true))
|
||||
)
|
||||
|| state.force_frame
|
||||
|| tabs != state.last_tabs;
|
||||
if changed {
|
||||
@@ -1863,6 +1951,7 @@ impl UiBridge {
|
||||
}
|
||||
vm.set_attr(state.desktop, "pending", Value::Nil)?;
|
||||
vm.set_attr(state.desktop, "focusRequested", Value::Bool(false))?;
|
||||
vm.set_attr(state.desktop, "scrollRequested", Value::Bool(false))?;
|
||||
state.force_frame = false;
|
||||
state.last_snapshot = snapshot;
|
||||
state.last_tabs = frame.tabs.clone();
|
||||
@@ -2025,6 +2114,13 @@ impl UiBridge {
|
||||
&mut layout,
|
||||
&mut cache,
|
||||
)?;
|
||||
{
|
||||
let state = self
|
||||
.session
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("UI session poisoned"))?;
|
||||
crate::scroll::project(vm, &state.mounts, &root, &mut frame)?;
|
||||
}
|
||||
// Native layout may replace the structural Frame; attach chrome only
|
||||
// after either layout path has produced the final page geometry.
|
||||
frame.tabs = tabs;
|
||||
@@ -2161,6 +2257,7 @@ pub fn install(vm: &mut Vm, roots: &mut Vec<ObjectRef>) -> Result<UiBridge> {
|
||||
("TextBlock", "Block", Some("text")),
|
||||
("RectBlock", "Block", Some("rect")),
|
||||
("Spacer", "Block", Some("spacer")),
|
||||
("ScrollBlock", "ContainerBlock", Some("scroll")),
|
||||
("Row", "ContainerBlock", Some("row")),
|
||||
("Column", "ContainerBlock", Some("column")),
|
||||
("Button", "ContainerBlock", Some("button")),
|
||||
@@ -2200,6 +2297,7 @@ pub fn install(vm: &mut Vm, roots: &mut Vec<ObjectRef>) -> Result<UiBridge> {
|
||||
"text" => Operation::Text,
|
||||
"rect" => Operation::Rect,
|
||||
"spacer" => Operation::Spacer,
|
||||
"scroll" => Operation::Scroll,
|
||||
"row" => Operation::Row,
|
||||
"column" => Operation::Column,
|
||||
"button" => Operation::Button,
|
||||
|
||||
Reference in New Issue
Block a user