Files
endorphin-tessera-gui/src/bridge/ui_bridge/calls.rs
T

931 lines
43 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 把 Endor 方法调用分派到对应宿主操作。这里处理构造、树修改、绑定、状态与页面能力。
//! 先检查参数和只读阶段限制,再修改托管状态;对象引用的生命周期仍交给 NativeContext 和 Aster 管理。
//!
//! Native Block operations executed on the owning VM worker.
use super::*;
impl NativeCallable for Function {
/// 给出参数与返回值的托管类型契约;实际操作在 invoke 中执行。
fn signature(&self) -> Option<CallSignature> {
self.signature.clone()
}
/// 接收已经剥离 receiver 的显式参数,数量沿用 Operation 的范围。
fn arity(&self) -> Option<endor_core::CallArity> {
Some(self.operation.arity())
}
/// 统一校验数量与只读限制,再按 Operation 分派构造、树修改、页面、绑定、状态与能力调用,返回托管结果或 VM 续调用。
fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
use Operation::*;
let arity = self.operation.arity();
let (minimum, maximum) = (arity.required, arity.maximum);
// Function 接收已剥离 receiver 的显式参数;先校验数量,后面索引 args 才安全。
if !(minimum..=maximum).contains(&args.len()) {
return Err(invalid("incorrect UI method argument count"));
}
if matches!(self.operation, Camera2D) {
let camera = new_camera2d(cx, &self.session, self.requested_type, args)?;
return Ok(NativeResult::Return(Value::Object(camera)));
}
// 3D 构造与普通 Block 分开,requested_type 保留源子类名义身份,否则从本 desktop 取默认类型。
if let SceneObject(kind) = self.operation {
let desktop = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?
.desktop;
let definition =
self.requested_type
.unwrap_or(desktop_type(cx.store(), kind.name(), desktop)?);
let object = crate::scene3d_model::allocate(cx, desktop, definition, kind, args)?;
return Ok(NativeResult::Return(Value::Object(object)));
}
if matches!(self.operation, CameraControl) {
crate::scene3d_model::control(
cx,
self.owner
.ok_or(invalid("controller requires a receiver"))?,
object(args.first())?,
object(args.get(1))?,
)?;
return Ok(NativeResult::Return(Value::Nil));
}
if matches!(self.operation, Translate3D | Rotate3D) {
crate::scene3d_model::transform(
cx,
self.owner
.ok_or(invalid("3D transform requires a receiver"))?,
args,
matches!(self.operation, Rotate3D),
)?;
return Ok(NativeResult::Return(Value::Nil));
}
// implement 修改显式能力关系;implements 查类型,supports 查对象实际能力,不靠同名字段鸭子类型推断。
if matches!(self.operation, Implement | Implements | Supports) {
let capability = object(args.get(1))?;
let value = match self.operation {
Implement => {
cx.implement_trait(object(args.first())?, capability)?;
Value::Nil
}
Implements => Value::Bool(
cx.store()
.implements_trait(object(args.first())?, capability)?,
),
Supports => {
// Validate the contract even for immediate scalar values.
cx.store()
.payload::<endor_core::EndorTraitObject>(capability, "Trait")?;
Value::Bool(match args[0] {
Value::Object(value) => cx.store().supports(value, capability)?,
_ => false,
})
}
_ => unreachable!(),
};
return Ok(NativeResult::Return(value));
}
if matches!(self.operation, IsInstance | IsSubtype) {
let candidate = object(args.first())?;
let expected = object(args.get(1))?;
let value = if matches!(self.operation, IsInstance) {
cx.store().is_instance(candidate, expected)?
} else {
cx.store().is_subtype(candidate, expected)?
};
return Ok(NativeResult::Return(Value::Bool(value)));
}
// 显式失效属于模型变更,只读阶段拒绝;paint/layout/content 精度不同,后续分别清理对应缓存。
if matches!(self.operation, Invalidate) {
if cx.store().is_read_only() {
return Err(invalid(
"invalidation is forbidden during read-only rendering",
));
}
let reason = args
.first()
.map(|value| text(Some(value)))
.transpose()?
.unwrap_or_else(|| "layout".into());
if !matches!(reason.as_str(), "paint" | "layout" | "content") {
return Err(invalid(
"invalidation reason must be paint, layout or content",
));
}
let owner = self.owner.ok_or(invalid("invalidation requires a Block"))?;
let (data, _) = block::resolve(cx.store(), owner)?;
let mut session = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
let mut affected = std::collections::HashSet::new();
// 找出解析到同一底层 Data 的所有别名,失效共享数据时不能只刷新调用者包装身份。
for weak in &session.nodes {
if let Some(block) = cx.upgrade(*weak)?
&& block::resolve(cx.store(), block)?.0 == data
{
affected.insert(block);
}
}
for presentation in session.presentations.values_mut() {
presentation.invalidate(cx, &affected, &reason)?;
}
return Ok(NativeResult::Return(Value::Nil));
}
if matches!(self.operation, Mounts) {
let owner = self.owner.ok_or(invalid("mount query requires a Block"))?;
let session = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
let mut positions = Vec::new();
for (window, presentation) in &session.presentations {
for (id, weak) in &presentation.mounts.active {
if let Some(object) = cx.upgrade(*weak)?
&& cx
.store()
.payload::<crate::mount::Mount>(object, "Mount")?
.block
== owner
{
positions.push((*window, *id, object));
}
}
}
// 跨窗口 Mount 查询按窗口/出现 ID 稳定排序,不依赖 HashMap 遍历顺序;返回每个具体出现而非几何副本。
positions.sort_unstable_by_key(|(window, id, _)| (*window, *id));
let set = crate::mount::collection(
cx,
positions.into_iter().map(|(_, _, object)| object).collect(),
session.desktop,
)?;
return Ok(NativeResult::Return(Value::Object(set)));
}
if matches!(self.operation, NewWindow) {
let mut state = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
let definition = self
.requested_type
.ok_or(invalid("Window constructor requires a type"))?;
let window = create_window(cx, &mut state, definition)?;
return Ok(NativeResult::Return(Value::Object(window)));
}
if matches!(self.operation, CloseWindow) {
let window = self
.owner
.ok_or(invalid("window close requires a receiver"))?;
let id = cx
.store()
.payload::<crate::window::ManagedWindow>(window, "Window")?
.id;
crate::window::close(cx, window)?;
let mut state = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
// 关闭托管窗口后为 Presentation 排空 pending 并标 closing,后续刷新才安排 Mount 退役与空帧。
if let Some(view) = state.presentations.get_mut(&id) {
cx.set_attr(view.desktop, "pending", Value::Nil)?;
view.pending = Some(None);
view.force_frame = true;
view.closing = true;
}
return Ok(NativeResult::Return(Value::Nil));
}
if matches!(self.operation, Window) {
let desktop = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?
.desktop;
return Ok(NativeResult::Return(
cx.store().get_attr(desktop, "window")?,
));
}
if matches!(self.operation, Viewport) {
let desktop = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?
.desktop;
let Value::Object(input) = cx.store().get_attr(desktop, "viewport")? else {
return Err(invalid("window viewport is unavailable"));
};
let width = cx.store().get_attr(input, "width")?;
let height = cx.store().get_attr(input, "height")?;
return Ok(NativeResult::Return(Value::Object(
crate::native_visual::record(
cx,
desktop,
"MeasureResult",
vec![("width", width), ("height", height)],
)?,
)));
}
// 诊断会读对象总数与宿主变化统计,禁止在只读渲染中观察并形成反馈依赖。
if matches!(self.operation, Stats) {
if cx.store().is_read_only() {
return Err(invalid(
"runtime statistics are unavailable during read-only rendering",
));
}
let session = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
let mut blocks = 0_i64;
let mut pages = 0_i64;
for weak in &session.nodes {
if let Some(object) = cx.upgrade(*weak)? {
blocks += 1;
if cx.store().payload::<block::Block>(object, "Block")?.page {
pages += 1;
}
}
}
let objects = cx.store().object_count() as i64;
let tabs = cx.store().dict_items(session.tabs)?.len() as i64;
let stats = cx.new_object()?;
for (name, value) in [
("objects", objects),
("blocks", blocks),
("pages", pages),
("tabs", tabs),
("mounts", session.mounts.active.len() as i64),
("snapshotVisited", session.snapshot_visited as i64),
("snapshotReused", session.snapshot_reused as i64),
("measured", session.layout.measured as i64),
("sourceMeasureHits", session.measure_cache.hits as i64),
("sourceMeasureMisses", session.measure_cache.misses as i64),
("arranged", session.layout.arranged as i64),
("layoutPasses", session.layout.settle_passes as i64),
("layoutSlices", session.layout.slices as i64),
("refreshYields", session.refresh_yields as i64),
("refreshRestarts", session.refresh_restarts as i64),
("layoutCancels", session.layout_cancels as i64),
("paintCancels", session.paint_cancels as i64),
("paintSlices", session.paint_slices as i64),
("bindingEvaluations", session.binding_evaluations as i64),
(
"dependencyInvalidations",
session.dependency_invalidations as i64,
),
] {
cx.set_attr(stats, name, Value::Number(value.into()))?;
}
cx.set_attr(
stats,
"lastInvalidDependency",
Value::Text(session.last_invalid_dependency.clone()),
)?;
cx.set_attr(
stats,
"windowDependencyDiagnostics",
Value::Text(
session
.presentations
.iter()
.filter(|(_, view)| !view.last_invalid_dependency.is_empty())
.map(|(id, view)| format!("{id}: {}", view.last_invalid_dependency))
.collect::<Vec<_>>()
.join("; "),
),
)?;
return Ok(NativeResult::Return(Value::Object(stats)));
}
// 状态是普通名义 Object,value 属性经 VM 追踪,set/increment 方法捕获同一对象,不额外建立原生状态副本。
if matches!(self.operation, State) {
let state = cx.new_object()?;
attach_named_type(cx, state, "Object", &self.session)?;
cx.set_attr(state, "value", args[0].clone())?;
bind(cx, state, "set", StateSet, &self.session)?;
bind(cx, state, "increment", Increment, &self.session)?;
return Ok(NativeResult::Return(Value::Object(state)));
}
if matches!(self.operation, StateSet | Increment) {
let owner = self.owner.ok_or(invalid("state method has no owner"))?;
let value = if matches!(self.operation, StateSet) {
args[0].clone()
} else {
let Value::Number(value) = cx.store().get_attr(owner, "value")? else {
return Err(invalid("increment requires an integer state"));
};
// increment 要求可表示为 i64 的整数且加一不溢出,不能把任意浮点状态强转整数。
let next = value
.as_i64()
.and_then(|n| n.checked_add(1))
.ok_or(invalid("integer state increment exceeds its range"))?;
Value::Number(next.into())
};
cx.set_attr(owner, "value", value)?;
return Ok(NativeResult::Return(Value::Nil));
}
if matches!(self.operation, TextOf) {
let source = object(args.first())?;
let field = text(args.get(1))?;
// textOf 建立前确认字段可读取,具体字符串化与依赖记录发生在快照提取时。
cx.store().get_attr(source, &field)?;
let size = args
.get(2)
.map(|v| integer(Some(v)))
.transpose()?
.unwrap_or(1);
if !(1..=8).contains(&size) {
return Err(invalid("text size must be 1 through 8"));
}
let mut data = Data::new(
Kind::Text {
value: String::new(),
size: size as u32,
color: color(args.get(3), "#242422")?,
},
vec![],
0.0,
0.0,
);
// 保留源对象强边与字段名,不在创建时复制一个静态字符串;后续属性变化会让文字快照重算。
data.text_binding = Some((source, field));
return Ok(NativeResult::Return(Value::Object(new_block(
cx,
data,
&self.session,
)?)));
}
// 普通组件先组装 Data,再统一由 new_typed_block 安装 Cell、属性和名义类型;不直接写原生窗口。
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())?,
size: args
.get(1)
.map(|v| integer(Some(v)))
.transpose()?
.unwrap_or(1)
.try_into()
.map_err(|_| invalid("text size exceeds limits"))?,
color: color(args.get(2), "#242422")?,
},
vec![],
0.0,
0.0,
)),
Rect => Some(Data::new(
Kind::Rect {
width: dimension(args.first())?,
height: dimension(args.get(1))?,
radius: args
.get(2)
.map(|v| dimension(Some(v)))
.transpose()?
.unwrap_or(0.0),
color: color(args.get(3), "#DCE8FF")?,
},
vec![],
0.0,
0.0,
)),
Spacer => Some(Data::new(
Kind::Spacer(dimension(args.first())?),
vec![],
0.0,
0.0,
)),
Row | Column | Overlay => Some(Data::new(
if matches!(self.operation, Row) {
Kind::Row
} else if matches!(self.operation, Overlay) {
Kind::Overlay
} else {
Kind::Column
},
// 线性容器固定前两参为 padding/gap,后续都是孩子对象;组成合法性在 Block 分配前统一检查。
args[2..]
.iter()
.map(|v| object(Some(v)))
.collect::<Result<_, _>>()?,
dimension(args.first())?,
dimension(args.get(1))?,
)),
Page => Some(Data::new(Kind::Page, vec![], 0.0, 0.0)),
Scene2D => Some(Data::new(
Kind::Scene2D,
args.iter()
.map(|value| object(Some(value)))
.collect::<Result<_, _>>()?,
0.0,
0.0,
)),
CanvasViewport => {
let mut data = Data::new(
Kind::CanvasViewport {
width: dimension(args.first())?,
height: dimension(args.get(1))?,
},
vec![object(args.get(2))?],
0.0,
0.0,
);
// 每个新二维视口默认新建独立 Camera2D;显式属性共享相机才会联动其他视口。
data.camera = Some(new_camera2d(cx, &self.session, None, &[])?);
Some(data)
}
Viewport3D => {
let desktop = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?
.desktop;
let definition = desktop_type(cx.store(), "PerspectiveCamera", desktop)?;
let camera = crate::scene3d_model::allocate(
cx,
desktop,
definition,
crate::scene3d_model::Constructor::Perspective,
&[],
)?;
let mut data = Data::new(
Kind::Viewport3D {
width: dimension(args.first())?,
height: dimension(args.get(1))?,
},
vec![],
0.,
0.,
);
data.camera = Some(camera);
data.scene3d = Some(object(args.get(2))?);
let definition = desktop_type(cx.store(), "OrbitController", desktop)?;
// 三维视口默认独立透视相机及 OrbitController,Scene3D 引用则来自调用者,可显式共享世界。
data.controller = Some(crate::scene3d_model::allocate(
cx,
desktop,
definition,
crate::scene3d_model::Constructor::Orbit,
&[],
)?);
Some(data)
}
// 按钮标签也是普通 TextBlock 孩子,布局和生命周期沿同一组成树,不是原生按钮硬编码文字。
Button => {
let label = new_block(
cx,
Data::new(
Kind::Text {
value: text(args.first())?,
size: 1,
color: "#243047".into(),
},
vec![],
0.0,
0.0,
),
&self.session,
)?;
Some(Data::new(Kind::Button, vec![label], 10.0, 0.0))
}
_ => None,
};
// 统一检查文本等级和 UTF-8 字节量,再按 requested_type 生成实际对象,保留子类工厂身份。
if let Some(data) = constructor {
if let Kind::Text { size, value, .. } = &data.kind
&& (!(1..=8).contains(size) || value.len() > 16_384)
{
return Err(invalid("text exceeds size limits"));
}
return Ok(NativeResult::Return(Value::Object(new_typed_block(
cx,
data,
&self.session,
self.requested_type,
)?)));
}
if matches!(self.operation, OpenValue | Present)
&& let Value::Object(value) = args[0]
{
let (desktop, current) = {
let state = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
(state.master, state.desktop)
};
// 非 Block 对象若显式支持 Presentable,调用其 present;已有 Block 直接进入下面的展示转换。
let capability = desktop_type(cx.store(), "Presentable", desktop)?;
if !cx
.store()
.object(value)?
.payload()
.as_any()
.is::<block::Block>()
&& cx.store().supports(value, capability)?
{
let definition = cx
.store()
.type_of(value)?
.ok_or(invalid("untyped Presentable"))?;
let function = cx
.store()
.lookup_method(definition, "present")?
.ok_or(invalid("missing present method"))?;
let window = object(Some(&cx.store().get_attr(current, "window")?))?;
let complete = cx.allocate(ContextNativeFunction::new(
"validate presentation",
PresentResult {
open: matches!(self.operation, OpenValue),
session: self.session.clone(),
},
vec![desktop],
))?;
// 小驱动先调用 present(value, window),再把结果交 PresentResult 验证/可选打开,所有委托共用当前 VM 预算。
let instructions = [
endor_core::Instruction::new(endor_core::Opcode::LoadConst, 0),
endor_core::Instruction::simple(endor_core::Opcode::PushNull),
endor_core::Instruction::new(endor_core::Opcode::LoadConst, 1),
endor_core::Instruction::simple(endor_core::Opcode::PushNull),
endor_core::Instruction::new(endor_core::Opcode::LoadConst, 2),
endor_core::Instruction::new(endor_core::Opcode::LoadConst, 3),
endor_core::Instruction::new(endor_core::Opcode::Call, 2),
endor_core::Instruction::new(endor_core::Opcode::Call, 1),
endor_core::Instruction::simple(endor_core::Opcode::ReturnValue),
];
let code = endor_core::EndorCode::from_instructions(
&instructions,
vec![
Value::Object(complete),
Value::Object(function),
Value::Object(value),
Value::Object(window),
],
endor_core::CodeLayout::default(),
)?
.with_location("Presentable.present", "<tessera>", 1);
let code = cx.allocate(endor_core::EndorCodeObject::new(code))?;
let globals = cx.new_dict()?;
let driver = cx.new_function("Presentable.present", code, globals)?;
attach_desktop_type(cx, driver, "Function", desktop)?;
return Ok(NativeResult::Invoke {
function: driver,
arguments: vec![],
});
}
}
// ui.open 把普通结果转换为根组件,再在必要时包一层 Page 并展示;ui.present 仅转换,不自动打开页面。
if matches!(self.operation, OpenValue) {
let root = present_value(cx, &args[0], &self.session)?;
let page = if cx.store().payload::<block::Block>(root, "Block")?.page {
root
} else {
new_block(
cx,
Data::new(Kind::Page, vec![root], 0.0, 0.0),
&self.session,
)?
};
show(cx, page, &self.session)?;
return Ok(NativeResult::Return(Value::Object(page)));
}
if matches!(self.operation, Present) {
return Ok(NativeResult::Return(Value::Object(present_value(
cx,
&args[0],
&self.session,
)?)));
}
// 从这里起都是需要接收者的 Block/Page 方法,未绑定 owner 时不能继续修改任意全局对象。
let owner = self.owner.ok_or(invalid("method has no owner"))?;
if matches!(self.operation, Bind) {
let field = text(args.first())?;
let compute = object(args.get(1))?;
return Ok(NativeResult::Return(Value::Object(
crate::binding::connect(
cx,
owner,
&field,
compute,
self.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?
.master,
)?,
)));
}
// moveTab 重排同窗口页面索引并强制下一帧更新标签;移动的是原 Page,非新页面副本。
if matches!(self.operation, MoveTab) {
let position = usize::try_from(integer(args.first())?)
.map_err(|_| invalid("tab position out of range"))?;
let mut state = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
let id = page_window(cx.store(), &state, owner)?.ok_or(invalid("Page is not open"))?;
let view = state
.presentations
.get_mut(&id)
.ok_or(invalid("missing window"))?;
let window = object(Some(&cx.store().get_attr(view.desktop, "window")?))?;
crate::window::move_page(cx, window, owner, position)?;
view.force_frame = true;
return Ok(NativeResult::Return(Value::Object(owner)));
}
// 接收者可能是共享转发别名,解析到最终 Data 后修改副本,最后用一次 replace_payload 写入结构边。
let (data_ref, data) = block::resolve(cx.store(), owner)?;
let mut data = data.clone();
let mut result = Value::Nil;
match self.operation {
SetText => match &mut data.kind {
Kind::Text { value, .. } => {
let next = text(args.first())?;
if next.len() > 16_384 {
return Err(invalid("text exceeds 16 KiB"));
}
*value = next;
// 直接 setText 取代旧 textOf 推导;同时更新普通 text 属性,使快照属性读取与 payload 描述保持一致。
data.text_binding = None;
cx.set_attr(owner, "text", args[0].clone())?;
}
_ => return Err(invalid("setText requires a text Block")),
},
SetColor => match &mut data.kind {
Kind::Text { color: value, .. } | Kind::Rect { color: value, .. } => {
*value = color(args.first(), "#242422")?;
cx.set_attr(owner, "color", Value::Text(value.clone()))?;
}
_ => return Err(invalid("this Block has no color")),
},
Append | Insert | Remove | Replace | Move => {
if !data.is_container() {
return Err(invalid("expected a container Block"));
}
if matches!(self.operation, Append | Insert) {
let (position, argument) = if matches!(self.operation, Insert) {
let position = usize::try_from(integer(args.first())?)
.map_err(|_| invalid("child position out of range"))?;
if position > data.children.len() {
return Err(invalid("child position out of range"));
}
(position, args.get(1))
} else {
(data.children.len(), args.first())
};
let child = object(argument)?;
// 插入前禁止孩子图回到当前 Data,避免循环组成;position 是插入位置,返回值却是稳定 slot。
block::validate(cx.store(), child, Some(data_ref))?;
let slot = data.next_slot;
// slot 单调增加且限制到 i64 正范围,不复用已删除身份;前后插入/重排不会把其他孩子 slot 改号。
data.next_slot = slot
.checked_add(1)
.filter(|next| *next <= i64::MAX as u64)
.ok_or(VmError::IdentityExhausted)?;
data.children.insert(position, Child { slot, block: child });
result = Value::Number((slot as i64).into());
} else {
// remove/replace/move 首参为稳定 slot 而非当前数组下标;只有 move 的第二参才是目标位置。
let slot = integer(args.first())?;
let index = data
.children
.iter()
.position(|v| v.slot == slot)
.ok_or(invalid("child slot does not exist"))?;
match self.operation {
Remove => {
data.children.remove(index);
}
Replace => {
let child = object(args.get(1))?;
block::validate(cx.store(), child, Some(data_ref))?;
// replace 保留该组成边 slot,但换实际 Block;出现键还含 Block 身份,因此可能产生新的 Mount 上下文。
data.children[index].block = child;
}
Move => {
let to = usize::try_from(integer(args.get(1))?)
.map_err(|_| invalid("child position out of range"))?;
if to >= data.children.len() {
return Err(invalid("child position out of range"));
}
let child = data.children.remove(index);
data.children.insert(to, child);
}
_ => unreachable!(),
}
}
}
// children 查询返回 slot文本->Block 的托管字典,不把当前顺序假装成稳定 slot 连号数组。
Children => {
let result = cx.new_dict()?;
for child in data.children {
cx.dict_set(
result,
Value::Text(child.slot.to_string()),
Value::Object(child.block),
)?;
}
return Ok(NativeResult::Return(Value::Object(result)));
}
Render | Navigate => {
if !matches!(data.kind, Kind::Page) {
return Err(invalid("expected a Page"));
}
let root = object(args.first())?;
block::validate(cx.store(), root, Some(data_ref))?;
if matches!(self.operation, Navigate) {
// 首次 navigate 把当前根纳入历史,之后新导航先截断前进分支,再追加新根,保持浏览历史语义。
if data.history.is_empty() {
if let Some(old) = data.children.first() {
data.history.push(old.block);
}
} else {
data.history.truncate(data.history_index + 1);
}
data.history.push(root);
data.history_index = data.history.len() - 1;
}
// 页面内容统一保留根 slot0,render/navigate 改的是根对象;show 只记录待展示请求,后续刷新再布局。
data.children = vec![Child {
slot: 0,
block: root,
}];
data.next_slot = data.next_slot.max(1);
show(cx, owner, &self.session)?;
}
Back | Forward => {
if data.history.is_empty() {
return Ok(NativeResult::Return(Value::Nil));
}
// 后退/前进钳到历史首尾,复用已保留根对象而非重新执行旧源码。
let next = if matches!(self.operation, Back) {
data.history_index.saturating_sub(1)
} else {
(data.history_index + 1).min(data.history.len() - 1)
};
data.history_index = next;
data.children = vec![Child {
slot: 0,
block: data.history[next],
}];
show(cx, owner, &self.session)?;
}
// 分离先创建新 Window,再把同一 Page 展示到它;跨窗口出现上下文由后续展示同步重建。
Detach => {
let window = {
let mut state = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
let definition = desktop_type(cx.store(), "Window", state.master)?;
create_window(cx, &mut state, definition)?
};
show_in(cx, owner, &self.session, Some(window))?;
return Ok(NativeResult::Return(Value::Object(window)));
}
PageWindow => {
let state = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
let value = if let Some(id) = page_window(cx.store(), &state, owner)? {
cx.store()
.get_attr(state.presentations[&id].desktop, "window")?
} else {
Value::Nil
};
return Ok(NativeResult::Return(value));
}
Open | Activate | MoveWindow => {
if matches!(self.operation, MoveWindow)
&& matches!(args.first(), None | Some(Value::Nil))
{
return Err(invalid("Page.moveToWindow requires a Window"));
}
let target = match args.first() {
None | Some(Value::Nil) => None,
Some(value) => Some(object(Some(value))?),
};
show_in(cx, owner, &self.session, target)?;
return Ok(NativeResult::Return(Value::Object(owner)));
}
// unmount 清内容但不关闭 Page 标签,也不直接等同于销毁整个业务对象。
Unmount => {
data.children.clear();
}
Close => {
// 关闭 Page 当场取消页面和所属 Mount 任务,即使同一输入稍后又打开它,也不能复活旧异步工作。
crate::tasks::cancel_owner(cx, owner)?;
let mut state = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?;
if let Some(id) = page_window(cx.store(), &state, owner)? {
// Closing the tab ends its presentation even if source
// reopens it before the next layout can detach the Mounts.
let page = cx.store().downgrade(owner)?;
for weak in state.presentations[&id].mounts.ordered() {
if let Some(mount) = cx.upgrade(weak)?
&& cx
.store()
.payload::<crate::mount::Mount>(mount, "Mount")?
.page
== Some(page)
{
crate::tasks::cancel_owner(cx, mount)?;
}
}
remove_page(
cx,
state
.presentations
.get_mut(&id)
.ok_or(invalid("missing window"))?,
owner,
)?;
}
return Ok(NativeResult::Return(Value::Nil));
}
OnClick => {
let handler = object(args.first())?;
crate::event_dispatch::validate_handler(cx.store(), handler)?;
data.click = Some(handler);
result = Value::Object(owner);
}
On => {
let kind = text(args.first())?;
if kind.is_empty() || kind.len() > 128 {
return Err(invalid("invalid event kind"));
}
let handler = object(args.get(1))?;
crate::event_dispatch::validate_handler(cx.store(), handler)?;
// 订阅默认非捕获;可用 Bool 或 capture/bubble 文本明确阶段,其他值拒绝而不做真值转换。
let capture = match args.get(2) {
None | Some(Value::Bool(false)) => false,
Some(Value::Bool(true)) => true,
Some(Value::Text(phase)) if phase == "capture" => true,
Some(Value::Text(phase)) if phase == "bubble" => false,
_ => return Err(invalid("phase must be capture or bubble")),
};
// 清掉已断开连接后再计算容量,保留仍有效订阅顺序;新 Connection 拥有 handler,返回 token 仅弱引用连接。
let mut active = Vec::new();
for token in &data.subscriptions {
if cx
.store()
.payload::<crate::event_dispatch::Connection>(*token, "Connection")?
.handler
.is_some()
{
active.push(*token);
}
}
if active.len() >= MAX_UI_NODES {
return Err(invalid("too many event subscriptions"));
}
let connection = cx.allocate(crate::event_dispatch::Connection {
kind,
handler: Some(handler),
capture,
})?;
let token = cx.allocate(crate::event_dispatch::Subscription {
connection: cx.store().downgrade(connection)?,
})?;
attach_named_type(cx, token, "Subscription", &self.session)?;
active.push(connection);
data.subscriptions = active;
result = Value::Object(token);
}
// 基类事件/挂载回调默认空实现,子类可覆盖;不在这条默认路径生成额外状态。
OnEvent | OnMount | OnUnmount => return Ok(NativeResult::Return(Value::Nil)),
Click | Dispatch => {
let desktop = self
.session
.lock()
.map_err(|_| invalid("UI session poisoned"))?
.desktop;
// click 新建种类为 click 的 Event,dispatch 使用调用者提供事件;两者都将可选具体 Mount 交传播模块验证。
let (event, mount) = if matches!(self.operation, Click) {
let definition = desktop_type(cx.store(), "Event", desktop)?;
(
crate::event_dispatch::new_event(cx, definition, "click")?,
args.first(),
)
} else {
(object(args.first())?, args.get(1))
};
let mount = mount.map(|value| object(Some(value))).transpose()?;
return crate::event_dispatch::dispatch(cx, owner, event, mount, desktop);
}
_ => return Err(invalid("unsupported Block operation")),
}
// 非提前返回的结构编辑/订阅操作在末尾统一经过写屏障,触发拥有边更新和变更日志。
cx.replace_payload(data_ref, data)?;
Ok(NativeResult::Return(result))
}
}