Implement IsPointInPath

components/canvas/canvas_paint_task.rs

@@ -136,6 +136,9 @@ impl<'a> CanvasPaintTask<'a> {
                             Canvas2dMsg::Fill => painter.fill(),
                             Canvas2dMsg::Stroke => painter.stroke(),
                             Canvas2dMsg::Clip => painter.clip(),
+                            Canvas2dMsg::IsPointInPath(x, y, fill_rule, chan) => {
+                                painter.is_point_in_path(x, y, fill_rule, chan)
+                            },
                             Canvas2dMsg::DrawImage(imagedata, image_size, dest_rect, source_rect,
                                                    smoothing_enabled) => {
                                 painter.draw_image(imagedata, image_size, dest_rect, source_rect, smoothing_enabled)
@@ -318,6 +321,14 @@ impl<'a> CanvasPaintTask<'a> {
         self.drawtarget.push_clip(&self.path_builder.finish());
     }
 
+    fn is_point_in_path(&mut self, x: f64, y: f64,
+                        _fill_rule: FillRule, chan: IpcSender<bool>) {
+        let path = self.path_builder.finish();
+        let result = path.contains_point(x, y, &self.state.transform);
+        self.path_builder = path.copy_to_builder();
+        chan.send(result).unwrap();
+    }
+
     fn draw_image(&self, image_data: Vec<u8>, image_size: Size2D<f64>,
                   dest_rect: Rect<f64>, source_rect: Rect<f64>, smoothing_enabled: bool) {
         // We round up the floating pixel values to draw the pixels

components/canvas_traits/lib.rs

@@ -42,6 +42,12 @@ use std::str::FromStr;
 use std::sync::mpsc::Sender;
 use util::mem::HeapSizeOf;
 
+#[derive(Clone, Deserialize, Serialize)]
+pub enum FillRule {
+    Nonzero,
+    Evenodd,
+}
+
 #[derive(Clone, Deserialize, Serialize)]
 pub enum CanvasMsg {
     Canvas2d(Canvas2dMsg),
@@ -93,6 +99,7 @@ pub enum Canvas2dMsg {
     Fill,
     FillRect(Rect<f32>),
     GetImageData(Rect<i32>, Size2D<f64>, IpcSender<Vec<u8>>),
+    IsPointInPath(f64, f64, FillRule, IpcSender<bool>),
     LineTo(Point2D<f32>),
     MoveTo(Point2D<f32>),
     PutImageData(Vec<u8>, Point2D<f64>, Size2D<f64>, Rect<f64>),

components/script/dom/canvasrenderingcontext2d.rs

@@ -5,7 +5,7 @@
 use canvas::canvas_paint_task::RectToi32;
 use canvas_traits::{Canvas2dMsg, CanvasCommonMsg, CanvasMsg};
 use canvas_traits::{CompositionOrBlending, LineCapStyle, LineJoinStyle};
-use canvas_traits::{FillOrStrokeStyle, LinearGradientStyle, RadialGradientStyle, RepetitionStyle};
+use canvas_traits::{FillOrStrokeStyle, FillRule, LinearGradientStyle, RadialGradientStyle, RepetitionStyle};
 use cssparser::Color as CSSColor;
 use cssparser::{Parser, RGBA};
 use dom::bindings::cell::DOMRefCell;
@@ -695,6 +695,19 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
         self.ipc_renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Clip)).unwrap();
     }
 
+    // https://html.spec.whatwg.org/multipage/#dom-context-2d-ispointinpath
+    fn IsPointInPath(&self, x: f64, y: f64, fill_rule: CanvasFillRule) -> bool {
+        let fill_rule = match fill_rule {
+            CanvasFillRule::Nonzero => FillRule::Nonzero,
+            CanvasFillRule::Evenodd => FillRule::Evenodd,
+        };
+        let (sender, receiver) = ipc::channel::<bool>().unwrap();
+        self.ipc_renderer
+            .send(CanvasMsg::Canvas2d(Canvas2dMsg::IsPointInPath(x, y, fill_rule, sender)))
+            .unwrap();
+        receiver.recv().unwrap()
+    }
+
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-drawimage
     fn DrawImage(&self,
                  image: HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D,

components/script/dom/webidls/CanvasRenderingContext2D.webidl

@@ -94,13 +94,12 @@ interface CanvasRenderingContext2D {
   void clip(optional CanvasFillRule fillRule = "nonzero");
   //void clip(Path2D path, optional CanvasFillRule fillRule = "nonzero");
   //void resetClip();
-  //boolean isPointInPath(unrestricted double x, unrestricted double y,
+  boolean isPointInPath(unrestricted double x, unrestricted double y,
+                        optional CanvasFillRule fillRule = "nonzero");
+  //boolean isPointInPath(Path2D path, unrestricted double x, unrestricted double y,
   //                      optional CanvasFillRule fillRule = "nonzero");
-  //boolean isPointInPath(Path2D path, unrestricted double x, unrestricted
-  //                      double y, optional CanvasFillRule fillRule = "nonzero");
   //boolean isPointInStroke(unrestricted double x, unrestricted double y);
-  //                        boolean isPointInStroke(Path2D path, unrestricted double x,
-  //                        unrestricted double y);
+  //boolean isPointInStroke(Path2D path, unrestricted double x, unrestricted double y);
 
   // text (see also the CanvasDrawingStyles interface)
   //void fillText(DOMString text, unrestricted double x, unrestricted double y,