diff --git a/moli-renderer-v8/src/context_bootstrap/canvas.rs b/moli-renderer-v8/src/context_bootstrap/canvas.rs index 447bccdec7f..b6c18c32d5d 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas.rs @@ -133,8 +133,8 @@ pub(crate) use context2d::{ canvas_context_image_smoothing_enabled_setter_callback, canvas_context_image_smoothing_quality_getter_callback, canvas_context_image_smoothing_quality_setter_callback, - canvas_context_is_point_in_stroke_callback, canvas_context_line_cap_getter_callback, - canvas_context_line_cap_setter_callback, canvas_context_line_dash_offset_getter_callback, + canvas_context_line_cap_getter_callback, canvas_context_line_cap_setter_callback, + canvas_context_line_dash_offset_getter_callback, canvas_context_line_dash_offset_setter_callback, canvas_context_line_join_getter_callback, canvas_context_line_join_setter_callback, canvas_context_line_to_callback, canvas_context_line_width_getter_callback, canvas_context_line_width_setter_callback, diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs index 82d82ebe86a..aa9b59bfb85 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs @@ -1357,37 +1357,73 @@ fn context_stroke<'s>( path: moli_layout::PaintPath, transform: PaintTransform2D, ) -> PaintStroke { - let join = match context_string_slot(scope, context, CANVAS_CONTEXT_LINE_JOIN_SLOT).as_deref() { - Some("round") => PaintLineJoin::Round, - Some("bevel") => PaintLineJoin::Bevel, - _ => PaintLineJoin::Miter, - }; - let cap = match context_string_slot(scope, context, CANVAS_CONTEXT_LINE_CAP_SLOT).as_deref() { - Some("round") => PaintLineCap::Round, - Some("square") => PaintLineCap::Square, - _ => PaintLineCap::Butt, + let style = context_stroke_style(scope, context); + let cap = match style.start_cap { + kurbo::Cap::Round => PaintLineCap::Round, + kurbo::Cap::Square => PaintLineCap::Square, + kurbo::Cap::Butt => PaintLineCap::Butt, }; PaintStroke { path, color: PaintColor::WHITE, + width: style.width as f32, + join: match style.join { + kurbo::Join::Round => PaintLineJoin::Round, + kurbo::Join::Bevel => PaintLineJoin::Bevel, + kurbo::Join::Miter => PaintLineJoin::Miter, + }, + start_cap: cap, + end_cap: cap, + miter_limit: style.miter_limit as f32, + dash_pattern: style + .dash_pattern + .iter() + .map(|value| *value as f32) + .collect(), + dash_offset: style.dash_offset as f32, + transform, + } +} + +pub(super) fn context_stroke_style<'s>( + scope: &mut v8::PinScope<'s, '_>, + context: v8::Local<'s, v8::Object>, +) -> kurbo::Stroke { + let join = match context_string_slot(scope, context, CANVAS_CONTEXT_LINE_JOIN_SLOT).as_deref() { + Some("round") => kurbo::Join::Round, + Some("bevel") => kurbo::Join::Bevel, + _ => kurbo::Join::Miter, + }; + let cap = match context_string_slot(scope, context, CANVAS_CONTEXT_LINE_CAP_SLOT).as_deref() { + Some("round") => kurbo::Cap::Round, + Some("square") => kurbo::Cap::Square, + _ => kurbo::Cap::Butt, + }; + let dashes = context_line_dash(scope, context); + kurbo::Stroke { width: context_number_slot(scope, context, CANVAS_CONTEXT_LINE_WIDTH_SLOT) - .unwrap_or(DEFAULT_LINE_WIDTH) as f32, + .unwrap_or(DEFAULT_LINE_WIDTH), join, start_cap: cap, end_cap: cap, miter_limit: context_number_slot(scope, context, CANVAS_CONTEXT_MITER_LIMIT_SLOT) - .unwrap_or(DEFAULT_MITER_LIMIT) as f32, - dash_pattern: context_line_dash(scope, context), + .unwrap_or(DEFAULT_MITER_LIMIT), + // HTML treats an all-zero dash list as a solid stroke. Keep the + // original private list intact for getLineDash and save/restore. + dash_pattern: if dashes.iter().all(|dash| *dash == 0.0) { + Default::default() + } else { + dashes.into_iter().collect() + }, dash_offset: context_number_slot(scope, context, CANVAS_CONTEXT_LINE_DASH_OFFSET_SLOT) - .unwrap_or(DEFAULT_LINE_DASH_OFFSET) as f32, - transform, + .unwrap_or(DEFAULT_LINE_DASH_OFFSET), } } fn context_line_dash<'s>( scope: &mut v8::PinScope<'s, '_>, context: v8::Local<'s, v8::Object>, -) -> Vec { +) -> Vec { let Some(array) = get_private_value(scope, context, CANVAS_CONTEXT_LINE_DASH_SLOT) .and_then(|value| v8::Local::::try_from(value).ok()) else { @@ -1396,7 +1432,6 @@ fn context_line_dash<'s>( (0..array.length()) .filter_map(|index| array.get_index(scope, index)) .filter_map(|value| value.number_value(scope)) - .map(|value| value as f32) .collect() } @@ -1426,14 +1461,6 @@ fn rasterize_canvas_fragment<'s>( }); } -pub(crate) fn canvas_context_is_point_in_stroke_callback( - scope: &mut v8::PinScope<'_, '_>, - _args: v8::FunctionCallbackArguments<'_>, - mut rv: v8::ReturnValue<'_, v8::Value>, -) { - rv.set(v8::Boolean::new(scope, false).into()); -} - pub(crate) fn canvas_context_fill_text_callback<'s>( scope: &mut v8::PinScope<'s, '_>, args: v8::FunctionCallbackArguments<'s>, diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/path.rs b/moli-renderer-v8/src/context_bootstrap/canvas/path.rs index f44c0c60d8a..e5f241dcadb 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/path.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/path.rs @@ -31,6 +31,8 @@ impl Default for Canvas2dPathState { } } +use moli_svg::StrokeQueryLimitExceeded; + const TWO_PI: f64 = std::f64::consts::TAU; impl Canvas2dPathState { @@ -393,10 +395,18 @@ impl Canvas2dPathState { transform: LayoutTransform2D, fill_rule: moli_svg::SvgFillRule, ) -> bool { - let affine = kurbo::Affine::new(transform.coefficients); + let path = self.bezier_path(kurbo::Affine::new(transform.coefficients)); + moli_svg::is_point_in_path_with_rule( + &path, + moli_svg::SvgGeometryPoint::new(x, y), + fill_rule, + ) + } + + fn bezier_path(&self, affine: kurbo::Affine) -> kurbo::BezPath { let map = |point: LayoutPoint| affine * kurbo::Point::new(f64::from(point.x), f64::from(point.y)); - let path = kurbo::BezPath::from_vec( + kurbo::BezPath::from_vec( self.elements .iter() .map(|element| match *element { @@ -409,13 +419,17 @@ impl Canvas2dPathState { PaintPathElement::Close => kurbo::PathEl::ClosePath, }) .collect(), - ); - moli_svg::is_point_in_path_with_rule( - &path, - moli_svg::SvgGeometryPoint::new(x, y), - fill_rule, ) } + + pub(super) fn contains_stroke_point( + &self, + point: kurbo::Point, + geometry_transform: kurbo::Affine, + style: &kurbo::Stroke, + ) -> Result { + moli_svg::is_point_in_stroke_path(self.bezier_path(geometry_transform), point, style) + } } fn path_bounds(elements: &[PaintPathElement]) -> PaintRect { diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/path2d.rs b/moli-renderer-v8/src/context_bootstrap/canvas/path2d.rs index 9c5a02d2fed..89d1d1d640b 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/path2d.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/path2d.rs @@ -1,7 +1,10 @@ //! Native Path2D construction and shared CanvasPath bindings. use super::*; +mod hit_testing; use super::{path::Canvas2dPathState, state::canvas_path_state}; +use crate::webidl; +use hit_testing::{is_point_in_path_callback, is_point_in_stroke_callback}; use moli_webapi::{ canvas_context_values::transform::validate_transform_init, geometry::DomMatrix2DInit, }; @@ -55,6 +58,8 @@ macro_rules! canvas_draw_path_declaration { stroke: (), #[webapi(method = "isPointInPath", length = 2, callback = is_point_in_path_callback)] is_point_in_path: (), + #[webapi(method = "isPointInStroke", length = 2, callback = is_point_in_stroke_callback)] + is_point_in_stroke: (), } }; } @@ -123,78 +128,6 @@ impl CanvasFillRule { } } -#[derive(webidl::WebIdlArgs)] -#[webidl(prefix = "CanvasDrawPath.isPointInPath")] -struct PointArgs { - #[webidl(required, converter = "unrestricted_double")] - x: f64, - #[webidl(required, converter = "unrestricted_double")] - y: f64, - #[webidl(default = CanvasFillRule::Nonzero, converter = "enum")] - rule: CanvasFillRule, -} - -#[derive(webidl::WebIdlArgs)] -#[webidl(prefix = "CanvasDrawPath.isPointInPath")] -struct PathPointArgs<'s> { - #[webidl(required, interface = web_api_interfaces::Path2D)] - path: v8::Local<'s, v8::Object>, - #[webidl(required, converter = "unrestricted_double")] - x: f64, - #[webidl(required, converter = "unrestricted_double")] - y: f64, - #[webidl(default = CanvasFillRule::Nonzero, converter = "enum")] - rule: CanvasFillRule, -} - -fn is_point_in_path_callback<'s>( - scope: &mut v8::PinScope<'s, '_>, - args: v8::FunctionCallbackArguments<'s>, - mut rv: v8::ReturnValue<'_, v8::Value>, -) { - let explicit_path = args.length() >= 4 - || (args.length() == 3 - && path_object( - scope, - args.get(0), - webidl::Context::argument("CanvasDrawPath.isPointInPath", 1), - ) - .is_ok()); - let (path, x, y, rule) = if explicit_path { - let Some(parsed) = webidl::parse_args::(scope, &args) else { - return; - }; - let target = web_api_object_target(scope, parsed.path).expect("validated Path2D argument"); - (Some(target), parsed.x, parsed.y, parsed.rule) - } else { - let Some(parsed) = webidl::parse_args::(scope, &args) else { - return; - }; - (None, parsed.x, parsed.y, parsed.rule) - }; - if !x.is_finite() || !y.is_finite() { - rv.set_bool(false); - return; - } - // Read native state after all author conversions: valueOf can reset the - // context or append geometry. Only Path2D geometry uses the current CTM; - // the default path already froze each command's transform when recorded. - let context = web_api_object_target(scope, args.this()).expect("validated Canvas 2D receiver"); - let context_state = canvas_path_state(scope, context); - let transform = if path.is_some() { - context_state.borrow().transform() - } else { - moli_layout::LayoutTransform2D::IDENTITY - }; - let path_state = path - .map(|object| canvas_path_state(scope, object)) - .unwrap_or(context_state); - let contains = path_state - .borrow() - .contains_point(x, y, transform, rule.svg_rule()); - rv.set_bool(contains); -} - #[derive(webidl::WebIdlArgs)] #[webidl(prefix = "CanvasDrawPath.fill")] struct FillRuleArgs { diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/path2d/hit_testing.rs b/moli-renderer-v8/src/context_bootstrap/canvas/path2d/hit_testing.rs new file mode 100644 index 00000000000..e53d5e83ccb --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/canvas/path2d/hit_testing.rs @@ -0,0 +1,151 @@ +//! Native Canvas fill and stroke hit testing after WebIDL conversion. + +use super::*; + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "CanvasDrawPath.isPointInPath")] +struct PointArgs { + #[webidl(required, converter = "unrestricted_double")] + x: f64, + #[webidl(required, converter = "unrestricted_double")] + y: f64, + #[webidl(default = CanvasFillRule::Nonzero, converter = "enum")] + rule: CanvasFillRule, +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "CanvasDrawPath.isPointInPath")] +struct PathPointArgs<'s> { + #[webidl(required, interface = web_api_interfaces::Path2D)] + path: v8::Local<'s, v8::Object>, + #[webidl(required, converter = "unrestricted_double")] + x: f64, + #[webidl(required, converter = "unrestricted_double")] + y: f64, + #[webidl(default = CanvasFillRule::Nonzero, converter = "enum")] + rule: CanvasFillRule, +} + +pub(super) fn is_point_in_path_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let explicit_path = args.length() >= 4 + || (args.length() == 3 + && path_object( + scope, + args.get(0), + webidl::Context::argument("CanvasDrawPath.isPointInPath", 1), + ) + .is_ok()); + let (path, x, y, rule) = if explicit_path { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + let target = web_api_object_target(scope, parsed.path).expect("validated Path2D argument"); + (Some(target), parsed.x, parsed.y, parsed.rule) + } else { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + (None, parsed.x, parsed.y, parsed.rule) + }; + if !x.is_finite() || !y.is_finite() { + rv.set_bool(false); + return; + } + // Read native state after all author conversions: valueOf can reset the + // context or append geometry. Only Path2D geometry uses the current CTM; + // the default path already froze each command's transform when recorded. + let context = web_api_object_target(scope, args.this()).expect("validated Canvas 2D receiver"); + let context_state = canvas_path_state(scope, context); + let transform = if path.is_some() { + context_state.borrow().transform() + } else { + moli_layout::LayoutTransform2D::IDENTITY + }; + let path_state = path + .map(|object| canvas_path_state(scope, object)) + .unwrap_or(context_state); + let contains = path_state + .borrow() + .contains_point(x, y, transform, rule.svg_rule()); + rv.set_bool(contains); +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "CanvasDrawPath.isPointInStroke")] +struct StrokePointArgs { + #[webidl(required, converter = "unrestricted_double")] + x: f64, + #[webidl(required, converter = "unrestricted_double")] + y: f64, +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "CanvasDrawPath.isPointInStroke")] +struct StrokePathPointArgs<'s> { + #[webidl(required, interface = web_api_interfaces::Path2D)] + path: v8::Local<'s, v8::Object>, + #[webidl(required, converter = "unrestricted_double")] + x: f64, + #[webidl(required, converter = "unrestricted_double")] + y: f64, +} + +pub(super) fn is_point_in_stroke_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let (path, x, y) = if args.length() >= 3 { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + let target = web_api_object_target(scope, parsed.path).expect("validated Path2D argument"); + (Some(target), parsed.x, parsed.y) + } else { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + (None, parsed.x, parsed.y) + }; + if !x.is_finite() || !y.is_finite() { + rv.set_bool(false); + return; + } + let context = web_api_object_target(scope, args.this()).expect("validated Canvas 2D receiver"); + let context_state = canvas_path_state(scope, context); + let Some(inverse) = context_state.borrow().inverse_transform() else { + rv.set_bool(false); + return; + }; + let style = super::super::context2d::context_stroke_style(scope, context); + let geometry_transform = if path.is_some() { + kurbo::Affine::IDENTITY + } else { + inverse + }; + let state = path + .map(|object| canvas_path_state(scope, object)) + .unwrap_or(context_state); + // Stroke widths, caps and dashes are in the current user space. Transform + // both the query and the frozen default geometry back to that space; + // explicit Path2D geometry is already there. + match state.borrow().contains_stroke_point( + inverse * kurbo::Point::new(x, y), + geometry_transform, + &style, + ) { + Ok(contains) => rv.set_bool(contains), + Err(_) => { + let message = crate::util::v8str( + scope, + "Stroke hit testing exceeded the geometry allocation limit.", + ); + let error = v8::Exception::range_error(scope, message); + scope.throw_exception(error); + } + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs index 188eb4f42de..3d5de90a468 100644 --- a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs +++ b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs @@ -9,8 +9,8 @@ use super::canvas::{ canvas_context_image_smoothing_enabled_setter_callback, canvas_context_image_smoothing_quality_getter_callback, canvas_context_image_smoothing_quality_setter_callback, - canvas_context_is_point_in_stroke_callback, canvas_context_line_cap_getter_callback, - canvas_context_line_cap_setter_callback, canvas_context_line_dash_offset_getter_callback, + canvas_context_line_cap_getter_callback, canvas_context_line_cap_setter_callback, + canvas_context_line_dash_offset_getter_callback, canvas_context_line_dash_offset_setter_callback, canvas_context_line_join_getter_callback, canvas_context_line_join_setter_callback, canvas_context_line_width_getter_callback, canvas_context_line_width_setter_callback, canvas_context_measure_text_callback, @@ -219,13 +219,6 @@ struct CanvasRenderingContext2dTemplateDeclaration { #[webapi(method = "clip", length = 0, callback = canvas_context_noop_callback)] clip: (), - #[webapi( - method = "isPointInStroke", - length = 2, - callback = canvas_context_is_point_in_stroke_callback - )] - is_point_in_stroke: (), - #[webapi(method = "measureText", length = 1, callback = canvas_context_measure_text_callback)] measure_text: (), diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs b/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs index 1c8a974ae70..e8b64ac3ce3 100644 --- a/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs +++ b/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs @@ -1,5 +1,66 @@ use super::*; +#[test] +fn canvas_stroke_hit_testing_preserves_styles_transforms_and_webidl_order_across_realms() { + let mut vm = new_storage_page_task_executor_test_vm("https://canvas-stroke-hit.test/"); + vm.eval("document.body.innerHTML=''") + .unwrap(); + vm.eval(&format!( + "const strokeHitProbe={};const strokeHitRealms=[globalThis,document.getElementById('other').contentWindow];\ + globalThis.strokeHitChecks=[];\ + for(let owner=0;owner<2;owner++)for(let callee=0;callee<2;callee++)for(const kind of ['element','offscreen'])\ + strokeHitChecks.push(...strokeHitProbe(strokeHitRealms[owner],strokeHitRealms[callee],kind,owner+'-'+callee+'-'+kind));", + include_str!("canvas_stroke_hit_testing.js"), + )).unwrap(); + assert_eq!( + vm.eval("JSON.stringify(strokeHitChecks.filter(row=>!row.passed))") + .unwrap(), + "[]" + ); + assert_eq!(vm.eval("strokeHitChecks.length").unwrap(), "744"); +} + +#[test] +fn canvas_stroke_hit_testing_accepts_registered_native_context_and_path_proxies() { + let mut vm = new_storage_page_task_executor_test_vm("https://canvas-stroke-hit-proxy.test/"); + vm.eval("globalThis.strokeContext=new OffscreenCanvas(1,1).getContext('2d');globalThis.strokePath=new Path2D();strokePath.moveTo(10,20);strokePath.lineTo(30,20);").unwrap(); + let context_ptr = &vm.current_main_world().unwrap().context as *const _; + vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| { + let global = scope.get_current_context().global(scope); + for (source, destination) in [ + ("strokeContext", "strokeContextProxy"), + ("strokePath", "strokePathProxy"), + ] { + let key = crate::util::v8str(scope, source); + let target = + v8::Local::::try_from(global.get(scope, key.into()).unwrap()).unwrap(); + let handler = crate::util::new_null_prototype_object(scope); + let proxy = v8::Proxy::new(scope, target, handler).unwrap(); + moli_webapi_declare::register_web_api_proxy(scope, proxy)?; + let key = crate::util::v8str(scope, destination); + assert_eq!( + global.create_data_property(scope, key.into(), proxy.into()), + Some(true) + ); + } + Ok(()) + }) + .unwrap(); + assert_eq!(vm.eval(r#"(() => { + const hit=OffscreenCanvasRenderingContext2D.prototype.isPointInStroke; + if(!hit.call(strokeContextProxy,strokePathProxy,20,20))return false; + let conversions=0,traps=0; + const coordinate={valueOf(){conversions++;return 20;}}; + for(const [receiver,path] of [ + [new Proxy(strokeContextProxy,{get(){traps++;throw Error('trap');}}),strokePathProxy], + [strokeContextProxy,new Proxy(strokePathProxy,{get(){traps++;throw Error('trap');}})]]) { + let rejected=false;try{hit.call(receiver,path,coordinate,20);}catch(error){rejected=error instanceof TypeError;} + if(!rejected)return false; + } + return conversions===0&&traps===0; + })()"#).unwrap(),"true"); +} + #[test] fn canvas_fill_hit_testing_preserves_geometry_and_webidl_order_across_realms() { let mut vm = new_storage_page_task_executor_test_vm("https://canvas-hit-testing.test/"); diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_stroke_hit_testing.js b/moli-renderer-v8/src/script_vm/tests/canvas_stroke_hit_testing.js new file mode 100644 index 00000000000..f5ba014f28e --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/canvas_stroke_hit_testing.js @@ -0,0 +1,157 @@ +(owner, callee, kind, label) => { + const canvas = kind === 'element' ? owner.document.createElement('canvas') : new owner.OffscreenCanvas(100, 100); + const context = canvas.getContext('2d'); + const iface = kind === 'element' ? 'CanvasRenderingContext2D' : 'OffscreenCanvasRenderingContext2D'; + const method = callee[iface].prototype.isPointInStroke; + const hit = (...args) => Reflect.apply(method, context, args); + const rows = []; + const check = (name, run) => { + try { rows.push({name: label + ':' + name, passed: run() === true}); } + catch (error) { rows.push({name: label + ':' + name, passed: false, error: String(error)}); } + }; + const throws = run => { + try { run(); } catch (error) { return error instanceof callee.TypeError; } + return false; + }; + const line = () => { + context.reset(); context.lineWidth = 10; + context.moveTo(10, 20); context.lineTo(30, 20); + }; + check('method length', () => method.length === 2); + check('empty path', () => !hit(0, 0)); + line(); + for (const [x, y] of [[20,20],[10,20],[30,20],[20,15],[20,25]]) + check('butt stroke interior or boundary ' + x + ',' + y, () => hit(x,y)); + for (const [x, y] of [[9.99,20],[30.01,20],[20,14.99],[20,25.01]]) + check('butt stroke exterior ' + x + ',' + y, () => !hit(x,y)); + context.lineCap = 'round'; + check('round cap interior', () => hit(6,20)); + check('round cap boundary', () => hit(5,20)); + check('round cap excludes corner', () => !hit(6,24)); + context.lineCap = 'square'; + check('square cap includes corner', () => hit(6,24)); + check('square cap boundary', () => hit(5,25)); + check('square cap exterior', () => !hit(4.99,20)); + line(); context.beginPath(); context.moveTo(10,30); context.lineTo(30,30); context.lineTo(30,10); + check('miter join interior', () => hit(34,34)); + check('miter join boundary', () => hit(35,35)); + context.lineJoin = 'bevel'; + check('bevel join excludes outer corner', () => !hit(33,33)); + context.lineJoin = 'round'; + check('round join interior', () => hit(33,33)); + check('round join excludes outer corner', () => !hit(34,34)); + context.lineJoin = 'miter'; context.miterLimit = 1; + check('miter limit clips join', () => !hit(33,33)); + context.miterLimit = 10; + check('miter limit restores join', () => hit(33,33)); + line(); context.lineWidth = 2; context.scale(2,3); + check('default path freezes centerline', () => hit(20,20) && !hit(40,20)); + check('default stroke uses current anisotropic width', () => hit(20,22.5) && !hit(20,23.01)); + const path = new owner.Path2D(); path.moveTo(10,20); path.lineTo(30,20); + check('explicit path uses current transform', () => hit(path,40,60)); + check('explicit path uses current anisotropic width', () => hit(path,40,62.5) && !hit(path,40,63.01)); + check('explicit path does not use untransformed coordinates', () => !hit(path,20,20)); + context.setTransform(2,1,0.5,3,20,-10); context.lineWidth = 10; + check('sheared stroke interior', () => hit(path,72,82)); + check('sheared stroke exterior', () => !hit(path,73,88)); + context.resetTransform(); + check('query does not transform Path2D storage', () => hit(path,20,20)); + line(); context.beginPath(); context.moveTo(0,10); context.lineTo(50,10); context.lineWidth = 2; context.setLineDash([10,10]); + check('dash on segments', () => hit(5,10) && hit(25,10)); + check('dash gap', () => !hit(15,10)); + context.lineDashOffset = 5; + check('positive dash offset', () => hit(2,10) && !hit(7,10) && hit(17,10)); + context.lineDashOffset = -5; + check('negative dash offset', () => !hit(2,10) && hit(7,10) && !hit(17,10)); + context.lineDashOffset = 45; + check('dash offset wraps', () => hit(2,10) && !hit(7,10)); + context.lineDashOffset = 0; context.setLineDash([3,2,1]); + check('odd dash pattern repeats with parity', () => hit(1,10) && !hit(4,10) && hit(5.5,10) && !hit(7,10) && hit(10,10) && !hit(11.5,10)); + context.setLineDash([0,0]); + check('all-zero dashes are solid', () => hit(12,10)); + check('all-zero private list is preserved', () => context.getLineDash().join() === '0,0'); + context.save(); context.setLineDash([2,2]); context.restore(); + check('save restore keeps all-zero semantics', () => hit(12,10) && context.getLineDash().join() === '0,0'); + context.setLineDash([0,10]); + check('zero-length butt dashes have no area', () => !hit(10,10)); + context.lineCap = 'round'; + check('zero-length round dash produces a dot', () => hit(10,10) && !hit(5,10)); + context.lineCap = 'square'; + check('zero-length square dash includes cap corners', () => hit(10.9,10.9)); + check('zero-length square dash exterior', () => !hit(11.01,10)); + check('zero-length square dash gap', () => !hit(5,10)); + context.lineDashOffset = 2; + check('zero-length dash positive offset', () => hit(8,10) && !hit(3,10)); + context.lineDashOffset = -2; + check('zero-length dash negative offset', () => hit(2,10) && !hit(7,10)); + context.lineDashOffset = 0; context.beginPath(); context.moveTo(0,0); context.lineTo(20,20); + context.setLineDash([0,10*Math.SQRT2]); + check('zero-length square dash follows diagonal direction', () => hit(11.2,10)); + check('diagonal square dash excludes rotated corner', () => !hit(10.8,10.8)); + context.beginPath(); context.moveTo(0,0); context.quadraticCurveTo(10,20,20,0); context.setLineDash([0,10]); + check('zero-length square dash follows curve tangent', () => hit(-0.4,1.2)); + check('curve-tangent square dash exterior', () => !hit(-0.5,1.5)); + context.beginPath(); context.moveTo(0,0); context.bezierCurveTo(0,0,0,10,10,10); + check('zero first derivative uses next distinct control direction', () => hit(0.9,0.9)); + context.lineCap = 'round'; + check('zero-length curve dash round cap', () => hit(-0.9,0)); + line(); context.lineWidth = 2; context.beginPath(); context.moveTo(0,0); context.lineTo(20,0); context.lineTo(20,20); + check('open stroke is not implicitly closed', () => !hit(10,10)); + check('query leaves subpath open', () => { context.lineTo(0,20); return hit(10,20); }); + context.beginPath(); context.rect(0,0,20,20); context.setLineDash([15,10]); + check('closed dashed seam preserves join', () => hit(-0.5,-0.5)); + line(); context.globalAlpha = 0; context.strokeStyle = 'transparent'; + check('alpha and stroke color do not affect geometry', () => hit(20,20)); + check('queries are not clipped to bitmap bounds', () => { + context.beginPath(); context.moveTo(-100,-100); context.lineTo(-80,-100); return hit(-90,-100); + }); + line(); context.scale(0,0); + check('singular transform has no stroke area', () => !hit(20,20) && !hit(path,0,0)); + context.resetTransform(); + check('singular query does not mutate geometry', () => hit(20,20)); + check('point conversion precedes geometry snapshot', () => { + context.beginPath(); + return hit({valueOf() { context.moveTo(10,20); context.lineTo(30,20); return 20; }},20); + }); + check('point conversion precedes style snapshot', () => { + context.lineWidth = 2; + return hit({valueOf() { context.lineWidth = 20; return 20; }},28); + }); + check('point conversion precedes transform snapshot', () => { + context.lineWidth = 2; + return hit(path,{valueOf() { context.scale(2,3); return 40; }},62.5); + }); + check('resize during conversion resets native path', () => !hit({valueOf() { canvas.width = canvas.width; return 20; }},20)); + check('explicit path mutation during conversion is visible', () => { + const p = new owner.Path2D(); + return hit(p,{valueOf() { p.moveTo(10,20); p.lineTo(30,20); return 20; }},20); + }); + check('all coordinate conversions precede nonfinite return', () => { + const order=[]; + return !hit({valueOf(){order.push('x');return NaN;}},{valueOf(){order.push('y');return 0;}}) && order.join() === 'x,y'; + }); + check('original conversion exception propagates', () => { + const marker={};try { hit(NaN,{valueOf(){throw marker;}}); } catch(error) { return error===marker; } return false; + }); + for (const [x,y] of [[NaN,0],[0,NaN],[Infinity,0],[0,-Infinity]]) + check('nonfinite query ' + x + ',' + y, () => !hit(x,y)); + for (const args of [[],[1],[1,Symbol('y')],[1,1n],[1,1,1]]) + check('invalid arguments ' + args.map(String).join(','), () => throws(() => hit(...args))); + check('required arity precedes conversion', () => { + let calls=0;return throws(() => hit({valueOf(){calls++;return 1;}})) && calls===0; + }); + check('extra explicit path argument is ignored', () => hit(path,20,20,{toString(){throw Error('unused');}})); + const revoked = owner.Proxy.revocable(context,{}); revoked.revoke(); + for (const [index,receiver] of [null,undefined,{},Object.create(callee[iface].prototype),Object.create(context),new owner.Proxy(context,{}),revoked.proxy].entries()) { + check('invalid receiver before coordinates ' + index, () => { + let calls=0;return throws(() => Reflect.apply(method,receiver,[{valueOf(){calls++;return 1;}},1])) && calls===0; + }); + } + const revokedPath = owner.Proxy.revocable(path,{}); revokedPath.revoke(); + for (const [index,value] of [null,undefined,{},Object.create(owner.Path2D.prototype),Object.create(path),new owner.Proxy(path,{}),revokedPath.proxy].entries()) { + check('invalid path before coordinates ' + index, () => { + let calls=0;return throws(() => hit(value,{valueOf(){calls++;return 1;}},1)) && calls===0; + }); + } + return rows; +} diff --git a/moli-svg/src/lib.rs b/moli-svg/src/lib.rs index 85ac0b92304..4fd5c91ca05 100644 --- a/moli-svg/src/lib.rs +++ b/moli-svg/src/lib.rs @@ -3,6 +3,7 @@ mod helpers; mod length; mod matrix; mod path; +mod stroke; mod timing; mod transform; @@ -18,6 +19,7 @@ pub use length::{ }; pub use matrix::{SvgMatrixComponents, serialize_number}; pub use path::{SvgPathSegment, parse_path_segments}; +pub use stroke::{StrokeQueryLimitExceeded, is_point_in_stroke_path}; pub use timing::{ SvgAnimationEvent, SvgAnimationEventKind, SvgAnimationEvents, SvgAnimationInstanceTimes, SvgAnimationInterval, SvgAnimationRestart, SvgAnimationTiming, SvgPresentationClock, diff --git a/moli-svg/src/stroke.rs b/moli-svg/src/stroke.rs new file mode 100644 index 00000000000..55416f661cb --- /dev/null +++ b/moli-svg/src/stroke.rs @@ -0,0 +1,264 @@ +//! Stroke outline containment and zero-length dash caps in user coordinates. + +use kurbo::{ParamCurve, ParamCurveArclen, ParamCurveDeriv}; + +#[derive(Debug)] +pub struct StrokeQueryLimitExceeded; + +const MAX_STROKE_QUERY_ELEMENTS: usize = 1_000_000; +const DASH_ACCURACY: f64 = 1e-6; + +pub fn is_point_in_stroke_path( + mut path: kurbo::BezPath, + point: kurbo::Point, + style: &kurbo::Stroke, +) -> Result { + if !point.is_finite() + || !style.is_finite() + || style.width <= 0.0 + || style.dash_pattern.iter().any(|dash| *dash < 0.0) + { + return Ok(false); + } + let mut style = style.clone(); + if style.dash_pattern.iter().all(|dash| *dash == 0.0) { + style.dash_pattern.clear(); + } else if style.dash_pattern.len() % 2 == 1 { + let repeated = style.dash_pattern.clone(); + style.dash_pattern.extend(repeated); + } + let mut scale = 1.0; + // Avoid an infinite dash period: a negative offset normalized modulo + // infinity would otherwise prevent the dash iterator from advancing. + // Uniform power-of-two scaling preserves all geometric relationships. + while style.dash_pattern.iter().sum::().is_infinite() { + style.width *= 0.5; + style.dash_offset *= 0.5; + for dash in &mut style.dash_pattern { + *dash *= 0.5; + } + scale *= 0.5; + } + let point = kurbo::Point::new(point.x * scale, point.y * scale); + path.apply_affine(kurbo::Affine::scale(scale)); + if !path.is_finite() { + return Ok(false); + } + if zero_dash_cap_contains(&path, point, &style)? { + return Ok(true); + } + let path = if style.dash_pattern.is_empty() { + path + } else { + let mut dashed = kurbo::BezPath::new(); + for element in kurbo::dash(path.iter(), style.dash_offset, &style.dash_pattern) + .take(MAX_STROKE_QUERY_ELEMENTS + 1) + { + if dashed.elements().len() == MAX_STROKE_QUERY_ELEMENTS { + return Err(StrokeQueryLimitExceeded); + } + dashed.push(element); + } + style.dash_pattern.clear(); + dashed + }; + let tolerance = (0.001 * scale).max(style.width * 1e-6); + let outline = kurbo::stroke( + path.iter(), + &style, + &kurbo::StrokeOpts::default(), + tolerance, + ); + Ok(crate::is_point_in_path_with_rule( + &outline, + crate::SvgGeometryPoint::new(point.x, point.y), + crate::SvgFillRule::NonZero, + )) +} + +/// Zero-on dashes are introduced after zero-length source segments have been +/// pruned. Their caps need the direction at that exact source arc length; +/// reconstructing a direction from the expanded zero-length segment loses it. +fn zero_dash_cap_contains( + path: &kurbo::BezPath, + point: kurbo::Point, + style: &kurbo::Stroke, +) -> Result { + if style.start_cap == kurbo::Cap::Butt + || !style + .dash_pattern + .iter() + .step_by(2) + .any(|dash| *dash == 0.0) + { + return Ok(false); + } + let mut first = 0; + let mut visited = 0; + for (index, element) in path.elements().iter().enumerate() { + if index > first && matches!(element, kurbo::PathEl::MoveTo(_)) { + if subpath_dash_cap_contains( + &path.elements()[first..index], + point, + style, + &mut visited, + )? { + return Ok(true); + } + first = index; + } + } + subpath_dash_cap_contains(&path.elements()[first..], point, style, &mut visited) +} + +fn subpath_dash_cap_contains( + elements: &[kurbo::PathEl], + point: kurbo::Point, + style: &kurbo::Stroke, + visited: &mut usize, +) -> Result { + let segments = kurbo::segments(elements.iter().copied()) + .map(|segment| (segment, segment.arclen(DASH_ACCURACY))) + .filter(|(_, length)| *length > 0.0) + .collect::>(); + let length = segments.iter().map(|(_, length)| length).sum::(); + let period = style.dash_pattern.iter().sum::(); + if segments.is_empty() || period <= 0.0 { + return Ok(false); + } + let mut prefix = 0.0; + for (index, dash) in style.dash_pattern.iter().enumerate() { + if index.is_multiple_of(2) && *dash == 0.0 { + let difference = prefix - style.dash_offset; + let mut position = if difference.is_finite() { + difference.rem_euclid(period) + } else { + (prefix - style.dash_offset.rem_euclid(period)).rem_euclid(period) + }; + let mut segment_index = 0; + let mut segment_start = 0.0; + while position <= length { + *visited += 1; + if *visited > MAX_STROKE_QUERY_ELEMENTS { + return Err(StrokeQueryLimitExceeded); + } + while segment_index + 1 < segments.len() + && position >= segment_start + segments[segment_index].1 + { + segment_start += segments[segment_index].1; + segment_index += 1; + } + let (segment, segment_length) = segments[segment_index]; + let t = segment.inv_arclen( + (position - segment_start).min(segment_length), + DASH_ACCURACY, + ); + if dash_cap_contains(segment, t, point, style) { + return Ok(true); + } + let next = position + period; + if next <= position { + return Err(StrokeQueryLimitExceeded); + } + position = next; + } + } + prefix += dash; + } + Ok(false) +} + +fn dash_cap_contains( + segment: kurbo::PathSeg, + t: f64, + point: kurbo::Point, + style: &kurbo::Stroke, +) -> bool { + let center = segment.eval(t); + let half_width = style.width * 0.5; + if style.start_cap == kurbo::Cap::Round { + return point.distance(center) <= half_width; + } + let Some(direction) = dash_direction(segment, t) else { + return false; + }; + let delta = point - center; + delta.dot(direction).abs() <= half_width && delta.cross(direction).abs() <= half_width +} + +fn dash_direction(segment: kurbo::PathSeg, t: f64) -> Option { + let tangent = match segment { + kurbo::PathSeg::Line(line) => line.p1 - line.p0, + kurbo::PathSeg::Quad(curve) => curve.deriv().eval(t).to_vec2(), + kurbo::PathSeg::Cubic(curve) => curve.deriv().eval(t).to_vec2(), + }; + let length = tangent.hypot(); + if length > 0.0 && length.is_finite() { + return Some(tangent / length); + } + // Repeated controls can make the first derivative zero at an endpoint + // or cusp. The first distinct control gives the one-sided direction. + let at_end = t == 1.0; + let remaining = if at_end { + segment + } else { + segment.subsegment(t..1.0) + }; + let vectors = match (remaining, at_end) { + (kurbo::PathSeg::Line(line), _) => [line.p1 - line.p0; 3], + (kurbo::PathSeg::Quad(curve), false) => { + [curve.p1 - curve.p0, curve.p2 - curve.p0, kurbo::Vec2::ZERO] + } + (kurbo::PathSeg::Quad(curve), true) => { + [curve.p2 - curve.p1, curve.p2 - curve.p0, kurbo::Vec2::ZERO] + } + (kurbo::PathSeg::Cubic(curve), false) => [ + curve.p1 - curve.p0, + curve.p2 - curve.p0, + curve.p3 - curve.p0, + ], + (kurbo::PathSeg::Cubic(curve), true) => [ + curve.p3 - curve.p2, + curve.p3 - curve.p1, + curve.p3 - curve.p0, + ], + }; + vectors.into_iter().find_map(|vector| { + let length = vector.hypot(); + (length > 0.0 && length.is_finite()).then(|| vector / length) + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn stroke_query_preserves_finite_offsets_when_dash_period_overflows() { + let mut path = kurbo::BezPath::new(); + path.move_to((0.0, 0.0)); + path.line_to((100.0, 0.0)); + for (offset, expected) in [(0.0, true), (1e308, false), (-1e308, false)] { + let style = kurbo::Stroke::new(2.0) + .with_caps(kurbo::Cap::Butt) + .with_dashes(offset, [1e308, 1e308]); + assert_eq!( + is_point_in_stroke_path(path.clone(), kurbo::Point::new(50.0, 0.0), &style,) + .unwrap(), + expected, + "offset {offset}" + ); + } + } + + #[test] + fn stroke_query_reports_allocation_limit_for_extremely_dense_dashes() { + let mut path = kurbo::BezPath::new(); + path.move_to((0.0, 0.0)); + path.line_to((100.0, 0.0)); + let style = kurbo::Stroke::new(2.0).with_dashes(0.0, [1e-30, 1e-30]); + assert!( + is_point_in_stroke_path(path.clone(), kurbo::Point::new(50.0, 0.0), &style,).is_err() + ); + } +}