674 lines
23 KiB
Rust
674 lines
23 KiB
Rust
//! General retained graphics resources for source paint: images, fonts, prepared
|
|
//! text, geometric exclusions and numerical functions. No application behaviour.
|
|
use crate::{
|
|
document::{RenderCommand, parse_color},
|
|
geometry::{Point, Rect},
|
|
render::{
|
|
image::Image,
|
|
text_flow::{Cursor, Prepared},
|
|
},
|
|
text::{TextFamily, TextStyle},
|
|
};
|
|
use endor_core::{
|
|
ContextNativeFunction, NativeCallable, NativeContext, NativeResult, ObjectPayload, ObjectRef,
|
|
ObjectStore, Value, Vm, VmError,
|
|
};
|
|
use std::{any::Any, sync::Arc};
|
|
fn invalid(message: &'static str) -> VmError {
|
|
VmError::InvalidArgument(message)
|
|
}
|
|
fn object(v: &Value) -> Result<ObjectRef, VmError> {
|
|
if let Value::Object(o) = v {
|
|
Ok(*o)
|
|
} else {
|
|
Err(invalid("expected Object"))
|
|
}
|
|
}
|
|
fn number(v: &Value) -> Result<f32, VmError> {
|
|
let Value::Number(v) = v else {
|
|
return Err(invalid("expected Number"));
|
|
};
|
|
let n = v.to_f64()?;
|
|
if n.abs() > 1_000_000. {
|
|
return Err(invalid("graphics number exceeds bounds"));
|
|
}
|
|
Ok(n as f32)
|
|
}
|
|
fn text(v: &Value) -> Result<&str, VmError> {
|
|
if let Value::Text(s) = v {
|
|
Ok(s)
|
|
} else {
|
|
Err(invalid("expected String"))
|
|
}
|
|
}
|
|
fn n(v: f32) -> Value {
|
|
Value::Number((v as f64).into())
|
|
}
|
|
#[derive(Debug)]
|
|
pub(crate) struct ImageResource(pub Arc<Image>);
|
|
#[derive(Debug)]
|
|
struct FontResource(TextFamily);
|
|
#[derive(Debug)]
|
|
struct TextResource {
|
|
prepared: Arc<Prepared>,
|
|
line: f32,
|
|
}
|
|
#[derive(Debug)]
|
|
struct Exclusion {
|
|
circle: Option<(Point, f32)>,
|
|
polygon: Vec<Point>,
|
|
padding: f32,
|
|
}
|
|
macro_rules! resource {
|
|
($t:ty,$name:literal) => {
|
|
impl ObjectPayload for $t {
|
|
fn as_any(&self) -> &dyn Any {
|
|
self
|
|
}
|
|
fn kind_name(&self) -> &'static str {
|
|
$name
|
|
}
|
|
fn allows_attributes(&self) -> bool {
|
|
true
|
|
}
|
|
fn reference_assignment_only(&self) -> bool {
|
|
true
|
|
}
|
|
}
|
|
};
|
|
}
|
|
resource!(ImageResource, "image-resource");
|
|
resource!(FontResource, "font-resource");
|
|
resource!(TextResource, "prepared-text");
|
|
resource!(Exclusion, "layout-exclusion");
|
|
fn attach(cx: &mut NativeContext<'_>, o: ObjectRef, desktop: ObjectRef) -> Result<(), VmError> {
|
|
crate::ui_bridge::attach_desktop_type(cx, o, "Object", desktop)
|
|
}
|
|
fn file(path: &str, limit: u64) -> Result<Vec<u8>, VmError> {
|
|
use std::io::Read;
|
|
if path.len() > 8192 {
|
|
return Err(invalid("resource path too long"));
|
|
}
|
|
let f = std::fs::File::open(path).map_err(|_| invalid("resource file cannot be opened"))?;
|
|
let meta = f
|
|
.metadata()
|
|
.map_err(|_| invalid("resource metadata unavailable"))?;
|
|
if !meta.is_file() || meta.len() > limit {
|
|
return Err(invalid("resource must be a bounded regular file"));
|
|
}
|
|
let mut data = Vec::new();
|
|
f.take(limit + 1)
|
|
.read_to_end(&mut data)
|
|
.map_err(|_| invalid("resource read failed"))?;
|
|
if data.len() as u64 > limit {
|
|
return Err(invalid("resource exceeds byte limit"));
|
|
}
|
|
Ok(data)
|
|
}
|
|
fn field(s: &ObjectStore, o: ObjectRef, key: &str) -> Result<f32, VmError> {
|
|
number(&s.get_attr(o, key)?)
|
|
}
|
|
pub(crate) fn decode_image(s: &ObjectStore, c: ObjectRef) -> Result<RenderCommand, VmError> {
|
|
let resource = object(&s.get_attr(c, "image")?)?;
|
|
let image = s
|
|
.payload::<ImageResource>(resource, "ImageResource")?
|
|
.0
|
|
.clone();
|
|
let tint = match s.get_attr(c, "tint") {
|
|
Ok(Value::Text(v)) => Some(parse_color(&v).map_err(|_| invalid("invalid image tint"))?),
|
|
Ok(Value::Nil) | Err(VmError::AttributeNotFound(_)) => None,
|
|
_ => return Err(invalid("invalid image tint")),
|
|
};
|
|
let c = RenderCommand::Image {
|
|
x: field(s, c, "x")?,
|
|
y: field(s, c, "y")?,
|
|
width: field(s, c, "width")?,
|
|
height: field(s, c, "height")?,
|
|
offset_x: field(s, c, "offsetX")?,
|
|
offset_y: field(s, c, "offsetY")?,
|
|
angle: field(s, c, "angle")?,
|
|
opacity: field(s, c, "opacity")?,
|
|
tint,
|
|
image,
|
|
};
|
|
c.validate()
|
|
.map_err(|_| invalid("invalid image geometry"))?;
|
|
Ok(c)
|
|
}
|
|
fn command(
|
|
cx: &mut NativeContext<'_>,
|
|
desktop: ObjectRef,
|
|
image: ObjectRef,
|
|
origin: Point,
|
|
rect: Rect,
|
|
angle: f32,
|
|
opacity: f32,
|
|
) -> Result<ObjectRef, VmError> {
|
|
let c = crate::native_visual::record(
|
|
cx,
|
|
desktop,
|
|
"PaintCommand",
|
|
vec![
|
|
("kind", Value::Text("image".into())),
|
|
("image", Value::Object(image)),
|
|
("x", n(origin.x)),
|
|
("y", n(origin.y)),
|
|
("width", n(rect.width)),
|
|
("height", n(rect.height)),
|
|
("offsetX", n(rect.x)),
|
|
("offsetY", n(rect.y)),
|
|
("angle", n(angle)),
|
|
("opacity", n(opacity)),
|
|
],
|
|
)?;
|
|
Ok(c)
|
|
}
|
|
#[derive(Debug, Clone, Copy)]
|
|
enum Op {
|
|
LoadImage,
|
|
LoadFont,
|
|
ReadText,
|
|
Slice,
|
|
Stringify,
|
|
Floor,
|
|
Now,
|
|
Prepare,
|
|
Sprite,
|
|
ImageExclusion,
|
|
Circle,
|
|
Rectangle,
|
|
Flow,
|
|
Float,
|
|
Sin,
|
|
Cos,
|
|
Sqrt,
|
|
Atan2,
|
|
Abs,
|
|
Min,
|
|
Max,
|
|
Clamp,
|
|
}
|
|
#[derive(Debug)]
|
|
struct Function {
|
|
op: Op,
|
|
desktop: ObjectRef,
|
|
}
|
|
impl NativeCallable for Function {
|
|
fn arity(&self) -> Option<endor_core::CallArity> {
|
|
use Op::*;
|
|
Some(endor_core::CallArity::exact(match self.op {
|
|
Now => 0,
|
|
LoadImage | ReadText | Float | Sin | Cos | Sqrt | Abs | Stringify | Floor => 1,
|
|
LoadFont | Atan2 | Min | Max | ImageExclusion => 2,
|
|
Circle | Clamp | Slice => 3,
|
|
Rectangle => 4,
|
|
Prepare => 6,
|
|
Flow => 7,
|
|
Sprite => 9,
|
|
}))
|
|
}
|
|
fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result<NativeResult, VmError> {
|
|
use Op::*;
|
|
let desktop = self.desktop;
|
|
let result = match self.op {
|
|
Now => {
|
|
if cx.store().is_read_only() {
|
|
return Err(invalid(
|
|
"sample the clock in an event/task and store it in the model",
|
|
));
|
|
}
|
|
static START: std::sync::OnceLock<std::time::Instant> = std::sync::OnceLock::new();
|
|
Value::Number(
|
|
START
|
|
.get_or_init(std::time::Instant::now)
|
|
.elapsed()
|
|
.as_secs_f64()
|
|
.into(),
|
|
)
|
|
}
|
|
LoadImage => {
|
|
if cx.store().is_read_only() {
|
|
return Err(invalid("load resources outside paint/layout"));
|
|
}
|
|
let image = Image::png(&file(text(&args[0])?, 4_194_304)?)
|
|
.map_err(|_| invalid("invalid or oversized PNG"))?;
|
|
let (w, h) = (image.width, image.height);
|
|
let resource = cx.allocate(ImageResource(image))?;
|
|
attach(cx, resource, desktop)?;
|
|
cx.set_attr(resource, "width", n(w as f32))?;
|
|
cx.set_attr(resource, "height", n(h as f32))?;
|
|
Value::Object(resource)
|
|
}
|
|
LoadFont => {
|
|
if cx.store().is_read_only() {
|
|
return Err(invalid("load resources outside paint/layout"));
|
|
}
|
|
let family = text(&args[1])?;
|
|
if family.len() > 128 {
|
|
return Err(invalid("font family name too long"));
|
|
}
|
|
let font = crate::text::register_font(file(text(&args[0])?, 4_194_304)?, family)
|
|
.map_err(|_| invalid("invalid font family or registry budget"))?;
|
|
let resource = cx.allocate(FontResource(font))?;
|
|
attach(cx, resource, desktop)?;
|
|
Value::Object(resource)
|
|
}
|
|
ReadText => {
|
|
if cx.store().is_read_only() {
|
|
return Err(invalid("load resources outside paint/layout"));
|
|
}
|
|
Value::Text(
|
|
String::from_utf8(file(text(&args[0])?, 16_384)?)
|
|
.map_err(|_| invalid("resource is not UTF-8"))?,
|
|
)
|
|
}
|
|
Slice => {
|
|
let value = text(&args[0])?;
|
|
let start = number(&args[1])?;
|
|
let end = number(&args[2])?;
|
|
if start < 0. || end < start || start.fract() != 0. || end.fract() != 0. {
|
|
return Err(invalid("invalid text slice"));
|
|
}
|
|
let lo = value
|
|
.char_indices()
|
|
.nth(start as usize)
|
|
.map_or(value.len(), |(i, _)| i);
|
|
let hi = value
|
|
.char_indices()
|
|
.nth(end as usize)
|
|
.map_or(value.len(), |(i, _)| i);
|
|
Value::Text(value[lo..hi].into())
|
|
}
|
|
Stringify => Value::Text(match &args[0] {
|
|
Value::Text(s) => s.clone(),
|
|
Value::Number(v) => v.to_string(),
|
|
Value::Bool(v) => v.to_string(),
|
|
Value::Nil => "nil".into(),
|
|
_ => return Err(invalid("string expects scalar value")),
|
|
}),
|
|
Prepare => {
|
|
let value = text(&args[0])?;
|
|
if value.len() > 16_384 {
|
|
return Err(invalid("prepared text exceeds 16 KiB"));
|
|
}
|
|
let family = cx
|
|
.store()
|
|
.payload::<FontResource>(object(&args[1])?, "FontResource")?
|
|
.0;
|
|
let size = number(&args[2])?;
|
|
let line = number(&args[3])?;
|
|
let scale = number(&args[5])?;
|
|
if !(8. ..=96.).contains(&size)
|
|
|| !(size..=192.).contains(&line)
|
|
|| !(0.5..=4.).contains(&scale)
|
|
{
|
|
return Err(invalid("invalid text metrics"));
|
|
}
|
|
let color =
|
|
parse_color(text(&args[4])?).map_err(|_| invalid("invalid text color"))?;
|
|
let prepared = Prepared::new(
|
|
value,
|
|
TextStyle {
|
|
font_size: size,
|
|
line_height: line,
|
|
family,
|
|
},
|
|
scale,
|
|
color,
|
|
);
|
|
let prepared = prepared.map_err(invalid)?;
|
|
let resource = cx.allocate(TextResource {
|
|
prepared: Arc::new(prepared),
|
|
line,
|
|
})?;
|
|
attach(cx, resource, desktop)?;
|
|
Value::Object(resource)
|
|
}
|
|
Sprite => {
|
|
let image = object(&args[0])?;
|
|
cx.store()
|
|
.payload::<ImageResource>(image, "ImageResource")?;
|
|
let x = number(&args[1])?;
|
|
let y = number(&args[2])?;
|
|
let w = number(&args[3])?;
|
|
let h = number(&args[4])?;
|
|
let a = number(&args[5])?;
|
|
let ax = number(&args[6])?;
|
|
let ay = number(&args[7])?;
|
|
let opacity = number(&args[8])?;
|
|
let c = command(
|
|
cx,
|
|
desktop,
|
|
image,
|
|
Point::new(x, y),
|
|
Rect::new(-w * ax, -h * ay, w, h),
|
|
a,
|
|
opacity,
|
|
)?;
|
|
decode_image(cx.store(), c)?;
|
|
Value::Object(c)
|
|
}
|
|
ImageExclusion => {
|
|
let RenderCommand::Image {
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
offset_x,
|
|
offset_y,
|
|
angle,
|
|
image,
|
|
..
|
|
} = decode_image(cx.store(), object(&args[0])?)?
|
|
else {
|
|
unreachable!()
|
|
};
|
|
let padding = number(&args[1])?;
|
|
if !(0. ..=1000.).contains(&padding) {
|
|
return Err(invalid("invalid exclusion padding"));
|
|
}
|
|
let (sin, cos) = angle.sin_cos();
|
|
let polygon = image
|
|
.outline
|
|
.iter()
|
|
.map(|p| {
|
|
let px = offset_x + p.x / image.width as f32 * width;
|
|
let py = offset_y + p.y / image.height as f32 * height;
|
|
Point::new(x + cos * px - sin * py, y + sin * px + cos * py)
|
|
})
|
|
.collect();
|
|
let e = cx.allocate(Exclusion {
|
|
circle: None,
|
|
polygon,
|
|
padding,
|
|
})?;
|
|
attach(cx, e, desktop)?;
|
|
Value::Object(e)
|
|
}
|
|
Circle | Rectangle => {
|
|
let x = number(&args[0])?;
|
|
let y = number(&args[1])?;
|
|
let size = number(&args[2])?;
|
|
if size < 0. {
|
|
return Err(invalid("negative exclusion extent"));
|
|
}
|
|
let e = if matches!(self.op, Circle) {
|
|
Exclusion {
|
|
circle: Some((Point::new(x, y), size)),
|
|
polygon: vec![],
|
|
padding: 0.,
|
|
}
|
|
} else {
|
|
let h = number(&args[3])?;
|
|
if h < 0. {
|
|
return Err(invalid("negative exclusion height"));
|
|
}
|
|
Exclusion {
|
|
circle: None,
|
|
polygon: vec![
|
|
Point::new(x, y),
|
|
Point::new(x + size, y),
|
|
Point::new(x + size, y + h),
|
|
Point::new(x, y + h),
|
|
],
|
|
padding: 0.,
|
|
}
|
|
};
|
|
let e = cx.allocate(e)?;
|
|
attach(cx, e, desktop)?;
|
|
Value::Object(e)
|
|
}
|
|
Flow => flow(cx, desktop, args)?,
|
|
_ => {
|
|
let real = |v: &Value| -> Result<f64, VmError> {
|
|
if let Value::Number(n) = v {
|
|
n.to_f64()
|
|
} else {
|
|
Err(invalid("math expects Number"))
|
|
}
|
|
};
|
|
let x = real(&args[0])?;
|
|
if matches!(self.op, Floor) {
|
|
if x.abs() > 1_000_000_000. {
|
|
return Err(invalid("floor result exceeds integer conversion budget"));
|
|
}
|
|
return Ok(NativeResult::Return(Value::Number(
|
|
(x.floor() as i64).into(),
|
|
)));
|
|
}
|
|
let v = match self.op {
|
|
Float => x,
|
|
Sin => x.sin(),
|
|
Cos => x.cos(),
|
|
Sqrt => x.sqrt(),
|
|
Atan2 => x.atan2(real(&args[1])?),
|
|
Abs => x.abs(),
|
|
Min => x.min(real(&args[1])?),
|
|
Max => x.max(real(&args[1])?),
|
|
Clamp => {
|
|
let lo = real(&args[1])?;
|
|
let hi = real(&args[2])?;
|
|
if lo > hi {
|
|
return Err(invalid("clamp minimum exceeds maximum"));
|
|
}
|
|
x.clamp(lo, hi)
|
|
}
|
|
_ => unreachable!(),
|
|
};
|
|
if !v.is_finite() {
|
|
return Err(invalid("non-finite math result"));
|
|
}
|
|
Value::Number(v.into())
|
|
}
|
|
};
|
|
Ok(NativeResult::Return(result))
|
|
}
|
|
}
|
|
|
|
fn ranges(left: f32, right: f32, y: f32, line: f32, exclusions: &[&Exclusion]) -> Vec<(f32, f32)> {
|
|
let mut blocked = Vec::new();
|
|
for e in exclusions {
|
|
if let Some((p, r)) = e.circle {
|
|
let gap = (y - p.y).max(p.y - y - line).max(0.);
|
|
if gap < r {
|
|
let dx = (r * r - gap * gap).sqrt();
|
|
blocked.push((p.x - dx, p.x + dx));
|
|
}
|
|
}
|
|
let (top, bottom) = (y - e.padding, y + line + e.padding);
|
|
let mut xs = Vec::new();
|
|
for i in 0..e.polygon.len() {
|
|
let a = e.polygon[i];
|
|
let b = e.polygon[(i + 1) % e.polygon.len()];
|
|
if a.y >= top && a.y <= bottom {
|
|
xs.push(a.x);
|
|
}
|
|
for edge in [top, bottom] {
|
|
if (a.y < edge && b.y > edge) || (b.y < edge && a.y > edge) {
|
|
xs.push(a.x + (b.x - a.x) * (edge - a.y) / (b.y - a.y));
|
|
}
|
|
}
|
|
}
|
|
if !xs.is_empty() {
|
|
blocked.push((
|
|
xs.iter().copied().fold(f32::INFINITY, f32::min) - e.padding,
|
|
xs.iter().copied().fold(f32::NEG_INFINITY, f32::max) + e.padding,
|
|
));
|
|
}
|
|
}
|
|
blocked.sort_by(|a, b| a.0.total_cmp(&b.0));
|
|
let mut x = left;
|
|
let mut ranges = Vec::new();
|
|
for (lo, hi) in blocked {
|
|
if hi <= left || lo >= right {
|
|
continue;
|
|
}
|
|
if lo > x {
|
|
ranges.push((x, lo.min(right)));
|
|
}
|
|
x = x.max(hi).min(right);
|
|
}
|
|
if x < right {
|
|
ranges.push((x, right));
|
|
}
|
|
ranges.into_iter().filter(|(l, r)| r - l >= 8.).collect()
|
|
}
|
|
fn flow(cx: &mut NativeContext<'_>, desktop: ObjectRef, args: &[Value]) -> Result<Value, VmError> {
|
|
let resource = object(&args[0])?;
|
|
let text = cx
|
|
.store()
|
|
.payload::<TextResource>(resource, "PreparedText")?;
|
|
let prepared = text.prepared.clone();
|
|
let line = text.line;
|
|
let x = number(&args[1])?;
|
|
let y = number(&args[2])?;
|
|
let width = number(&args[3])?;
|
|
let height = number(&args[4])?;
|
|
let letters = number(&args[6])? != 0.;
|
|
if width < 0. || height < 0. || height / line > 1024. {
|
|
return Err(invalid("text flow bounds exceed budget"));
|
|
}
|
|
let items = crate::object_list::items(cx.store(), object(&args[5])?)?;
|
|
if items.len() > 512 {
|
|
return Err(invalid("text flow exceeds 512 exclusions"));
|
|
}
|
|
let exclusions = items
|
|
.iter()
|
|
.map(|&o| cx.store().payload::<Exclusion>(o, "Exclusion"))
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
let mut placements = Vec::new();
|
|
let mut cursor = Cursor::default();
|
|
let mut top = y;
|
|
while top + line <= y + height && cursor.word < prepared.words.len() {
|
|
let intervals = ranges(x, x + width, top, line, &exclusions);
|
|
prepared.row(&mut cursor, &intervals, top, &mut placements);
|
|
top += line;
|
|
}
|
|
let mut commands = Vec::new();
|
|
for p in placements {
|
|
let word = &prepared.words[p.word];
|
|
let inks = if let Some(i) = p.letter {
|
|
std::slice::from_ref(&word.letters[i])
|
|
} else if letters {
|
|
&word.letters[..]
|
|
} else {
|
|
std::slice::from_ref(&word.ink)
|
|
};
|
|
let mut px = p.x;
|
|
for ink in inks {
|
|
let image = cx.allocate(ImageResource(ink.image.clone()))?;
|
|
attach(cx, image, desktop)?;
|
|
commands.push(command(
|
|
cx,
|
|
desktop,
|
|
image,
|
|
Point::new(px, p.y),
|
|
ink.rect,
|
|
0.,
|
|
1.,
|
|
)?);
|
|
px += ink.width;
|
|
if commands.len() > 10_000 {
|
|
return Err(invalid("text flow command budget exceeded"));
|
|
}
|
|
}
|
|
}
|
|
let commands = crate::object_list::collection(cx, commands, desktop)?;
|
|
Ok(Value::Object(crate::native_visual::record(
|
|
cx,
|
|
desktop,
|
|
"DisplayList",
|
|
vec![("commands", Value::Object(commands))],
|
|
)?))
|
|
}
|
|
pub(crate) fn install(
|
|
vm: &mut Vm,
|
|
roots: &mut Vec<ObjectRef>,
|
|
ui: ObjectRef,
|
|
desktop: ObjectRef,
|
|
) -> Result<(), VmError> {
|
|
let graphics = vm.new_object()?;
|
|
roots.push(graphics);
|
|
attach_vm(vm, graphics, "Object", desktop)?;
|
|
let math = vm.new_object()?;
|
|
roots.push(math);
|
|
attach_vm(vm, math, "Object", desktop)?;
|
|
for (owner, name, op) in [
|
|
(graphics, "loadImage", Op::LoadImage),
|
|
(graphics, "loadFont", Op::LoadFont),
|
|
(graphics, "readText", Op::ReadText),
|
|
(graphics, "textSlice", Op::Slice),
|
|
(graphics, "string", Op::Stringify),
|
|
(math, "floor", Op::Floor),
|
|
(math, "now", Op::Now),
|
|
(graphics, "prepareText", Op::Prepare),
|
|
(graphics, "sprite", Op::Sprite),
|
|
(graphics, "imageExclusion", Op::ImageExclusion),
|
|
(graphics, "circleExclusion", Op::Circle),
|
|
(graphics, "rectExclusion", Op::Rectangle),
|
|
(graphics, "flowText", Op::Flow),
|
|
(math, "float", Op::Float),
|
|
(math, "sin", Op::Sin),
|
|
(math, "cos", Op::Cos),
|
|
(math, "sqrt", Op::Sqrt),
|
|
(math, "atan2", Op::Atan2),
|
|
(math, "abs", Op::Abs),
|
|
(math, "min", Op::Min),
|
|
(math, "max", Op::Max),
|
|
(math, "clamp", Op::Clamp),
|
|
] {
|
|
let f = vm.allocate(ContextNativeFunction::new(
|
|
name,
|
|
Function { op, desktop },
|
|
vec![desktop],
|
|
))?;
|
|
roots.push(f);
|
|
attach_vm(vm, f, "Function", desktop)?;
|
|
vm.set_attr(owner, name, Value::Object(f))?;
|
|
}
|
|
vm.set_attr(math, "pi", Value::Number(std::f64::consts::PI.into()))?;
|
|
vm.set_attr(graphics, "math", Value::Object(math))?;
|
|
vm.set_attr(ui, "graphics", Value::Object(graphics))?;
|
|
Ok(())
|
|
}
|
|
|
|
fn attach_vm(vm: &mut Vm, o: ObjectRef, name: &str, desktop: ObjectRef) -> Result<(), VmError> {
|
|
let t = crate::ui_bridge::desktop_type(vm.object_store(), name, desktop)?;
|
|
vm.attach_type(o, t)
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct PointerDispatch {
|
|
pub owner: ObjectRef,
|
|
pub mount: ObjectRef,
|
|
pub desktop: ObjectRef,
|
|
pub kind: String,
|
|
pub point: Point,
|
|
}
|
|
impl NativeCallable for PointerDispatch {
|
|
fn arity(&self) -> Option<endor_core::CallArity> {
|
|
Some(endor_core::CallArity::exact(0))
|
|
}
|
|
fn invoke(&self, cx: &mut NativeContext<'_>, _: &[Value]) -> Result<NativeResult, VmError> {
|
|
let data = cx
|
|
.store()
|
|
.payload::<crate::mount::Mount>(self.mount, "Mount")?;
|
|
let g = &data.geometry;
|
|
if !data.mounted || !g.pointer_events {
|
|
return Err(invalid(
|
|
"pointer target is detached or has no pointer subscriptions",
|
|
));
|
|
}
|
|
let local = g
|
|
.view_point(self.point, false)
|
|
.map(|p| g.view.unwrap_or_default().inverse(p))
|
|
.ok_or(invalid("pointer cannot be projected"))?;
|
|
let (x, y) = (local.x - g.x, local.y - g.y);
|
|
let definition = crate::ui_bridge::desktop_type(cx.store(), "Event", self.desktop)?;
|
|
let event = crate::event_dispatch::new_event(cx, definition, &self.kind)?;
|
|
cx.set_attr(event, "x", n(x))?;
|
|
cx.set_attr(event, "y", n(y))?;
|
|
crate::event_dispatch::dispatch(cx, self.owner, event, Some(self.mount), self.desktop)
|
|
}
|
|
}
|