Permalink
Browse files

Update CanvasRenderingContext2D WebIDL definition

CanvasImageSource was never supposed to include CanvasRenderingContext2D.
  • Loading branch information...
nox committed Sep 14, 2018
1 parent dd9d526 commit d006bee67c1c6e4f4fed810f0a69efd91f581ebb
@@ -246,8 +246,6 @@ impl CanvasRenderingContext2D {
CanvasImageSource::HTMLCanvasElement(canvas) => {
canvas.origin_is_clean()
}
CanvasImageSource::CanvasRenderingContext2D(image) =>
image.origin_is_clean(),
CanvasImageSource::HTMLImageElement(image) => {
let image_origin = image.get_origin().expect("Image's origin is missing");
image_origin.same_origin(GlobalScope::entry().origin())
@@ -294,11 +292,6 @@ impl CanvasRenderingContext2D {
sx, sy, sw, sh,
dx, dy, dw, dh)
}
CanvasImageSource::CanvasRenderingContext2D(ref image) => {
self.draw_html_canvas_element(&image.Canvas(),
sx, sy, sw, sh,
dx, dy, dw, dh)
}
CanvasImageSource::HTMLImageElement(ref image) => {
// https://html.spec.whatwg.org/multipage/#img-error
// If the image argument is an HTMLImageElement object that is in the broken state,
@@ -1216,12 +1209,6 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
canvas.fetch_all_data().ok_or(Error::InvalidState)?
},
CanvasImageSource::CanvasRenderingContext2D(ref context) => {
let canvas = context.Canvas();
let _ = canvas.get_or_init_2d_context();
canvas.fetch_all_data().ok_or(Error::InvalidState)?
}
CanvasImageSource::CSSStyleValue(ref value) => {
value.get_url(self.base_url.clone())
.and_then(|url| self.fetch_image_data(url))
@@ -6,12 +6,12 @@ use canvas_traits::canvas::CanvasImageData;
use canvas_traits::canvas::CanvasMsg;
use canvas_traits::canvas::FromLayoutMsg;
use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasFillRule;
use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasImageSource;
use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasLineCap;
use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasLineJoin;
use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasRenderingContext2DMethods;
use dom::bindings::codegen::Bindings::PaintRenderingContext2DBinding;
use dom::bindings::codegen::Bindings::PaintRenderingContext2DBinding::PaintRenderingContext2DMethods;
use dom::bindings::codegen::UnionTypes::HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2DOrCSSStyleValue;
use dom::bindings::codegen::UnionTypes::StringOrCanvasGradientOrCanvasPattern;
use dom::bindings::error::ErrorResult;
use dom::bindings::error::Fallible;
@@ -194,37 +194,40 @@ impl PaintRenderingContext2DMethods for PaintRenderingContext2D {
}
// https://html.spec.whatwg.org/multipage/#dom-context-2d-drawimage
fn DrawImage(&self,
image: HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2DOrCSSStyleValue,
dx: f64,
dy: f64)
-> ErrorResult {
fn DrawImage(
&self,
image: CanvasImageSource,
dx: f64,
dy: f64,
) -> ErrorResult {
self.context.DrawImage(image, dx, dy)
}
// https://html.spec.whatwg.org/multipage/#dom-context-2d-drawimage
fn DrawImage_(&self,
image: HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2DOrCSSStyleValue,
dx: f64,
dy: f64,
dw: f64,
dh: f64)
-> ErrorResult {
fn DrawImage_(
&self,
image: CanvasImageSource,
dx: f64,
dy: f64,
dw: f64,
dh: f64,
) -> ErrorResult {
self.context.DrawImage_(image, dx, dy, dw, dh)
}
// https://html.spec.whatwg.org/multipage/#dom-context-2d-drawimage
fn DrawImage__(&self,
image: HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2DOrCSSStyleValue,
sx: f64,
sy: f64,
sw: f64,
sh: f64,
dx: f64,
dy: f64,
dw: f64,
dh: f64)
-> ErrorResult {
fn DrawImage__(
&self,
image: CanvasImageSource,
sx: f64,
sy: f64,
sw: f64,
sh: f64,
dx: f64,
dy: f64,
dw: f64,
dh: f64,
) -> ErrorResult {
self.context.DrawImage__(image, sx, sy, sw, sh, dx, dy, dw, dh)
}
@@ -321,10 +324,11 @@ impl PaintRenderingContext2DMethods for PaintRenderingContext2D {
}
// https://html.spec.whatwg.org/multipage/#dom-context-2d-createpattern
fn CreatePattern(&self,
image: HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2DOrCSSStyleValue,
repetition: DOMString)
-> Fallible<DomRoot<CanvasPattern>> {
fn CreatePattern(
&self,
image: CanvasImageSource,
repetition: DOMString,
) -> Fallible<DomRoot<CanvasPattern>> {
self.context.CreatePattern(image, repetition)
}
@@ -2,56 +2,51 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
enum CanvasFillRule { "nonzero", "evenodd" };
// https://html.spec.whatwg.org/multipage/#2dcontext
typedef (HTMLImageElement or
/* HTMLVideoElement or */
// typedef (HTMLImageElement or
// SVGImageElement) HTMLOrSVGImageElement;
typedef HTMLImageElement HTMLOrSVGImageElement;
typedef (HTMLOrSVGImageElement or
/*HTMLVideoElement or*/
HTMLCanvasElement or
CanvasRenderingContext2D or
/* ImageBitmap or */
// This should probably be a CSSImageValue
// https://github.com/w3c/css-houdini-drafts/issues/416
CSSStyleValue) CanvasImageSource;
/*ImageBitmap or*/
/*OffscreenCanvas or*/
/*CSSImageValue*/ CSSStyleValue) CanvasImageSource;
//[Constructor(optional unsigned long width, unsigned long height)]
interface CanvasRenderingContext2D {
enum CanvasFillRule { "nonzero", "evenodd" };
[Exposed=Window]
interface CanvasRenderingContext2D {
// back-reference to the canvas
readonly attribute HTMLCanvasElement canvas;
// canvas dimensions
// attribute unsigned long width;
// attribute unsigned long height;
// for contexts that aren't directly fixed to a specific canvas
//void commit(); // push the image to the output bitmap
};
CanvasRenderingContext2D implements CanvasState;
CanvasRenderingContext2D implements CanvasTransform;
CanvasRenderingContext2D implements CanvasCompositing;
CanvasRenderingContext2D implements CanvasImageSmoothing;
CanvasRenderingContext2D implements CanvasFillStrokeStyles;
CanvasRenderingContext2D implements CanvasShadowStyles;
CanvasRenderingContext2D implements CanvasFilters;
CanvasRenderingContext2D implements CanvasRect;
CanvasRenderingContext2D implements CanvasDrawPath;
CanvasRenderingContext2D implements CanvasUserInterface;
CanvasRenderingContext2D implements CanvasText;
CanvasRenderingContext2D implements CanvasDrawImage;
CanvasRenderingContext2D implements CanvasHitRegion;
CanvasRenderingContext2D implements CanvasImageData;
CanvasRenderingContext2D implements CanvasPathDrawingStyles;
CanvasRenderingContext2D implements CanvasTextDrawingStyles;
CanvasRenderingContext2D implements CanvasPath;
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasState {
// state
void save(); // push state on state stack
void restore(); // pop state stack and restore state
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasTransform {
// transformations (default transform is the identity matrix)
void scale(unrestricted double x, unrestricted double y);
@@ -75,23 +70,22 @@ interface CanvasTransform {
void resetTransform();
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasCompositing {
// compositing
attribute unrestricted double globalAlpha; // (default 1.0)
attribute DOMString globalCompositeOperation; // (default source-over)
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasImageSmoothing {
// image smoothing
attribute boolean imageSmoothingEnabled; // (default true)
// attribute ImageSmoothingQuality imageSmoothingQuality; // (default low)
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasFillStrokeStyles {
// colours and styles (see also the CanvasDrawingStyles interface)
attribute (DOMString or CanvasGradient or CanvasPattern) strokeStyle; // (default black)
attribute (DOMString or CanvasGradient or CanvasPattern) fillStyle; // (default black)
@@ -102,7 +96,7 @@ interface CanvasFillStrokeStyles {
CanvasPattern createPattern(CanvasImageSource image, [TreatNullAs=EmptyString] DOMString repetition);
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasShadowStyles {
// shadows
attribute unrestricted double shadowOffsetX; // (default 0)
@@ -111,32 +105,30 @@ interface CanvasShadowStyles {
attribute DOMString shadowColor; // (default transparent black)
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasFilters {
// filters
//attribute DOMString filter; // (default "none")
};
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasRect {
// rects
//[LenientFloat]
void clearRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
//[LenientFloat]
void fillRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
//[LenientFloat]
void strokeRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasDrawPath {
// path API (see also CanvasPathMethods)
// path API (see also CanvasPath)
void beginPath();
void fill(optional CanvasFillRule fillRule = "nonzero");
//void fill(Path2D path, optional CanvasFillRule fillRule = "nonzero");
void stroke();
//void stroke(Path2D path);
//void drawFocusIfNeeded(Element element);
//void drawFocusIfNeeded(Path2D path, Element element);
//void scrollPathIntoView();
//void scrollPathIntoView(Path2D path);
void clip(optional CanvasFillRule fillRule = "nonzero");
//void clip(Path2D path, optional CanvasFillRule fillRule = "nonzero");
//void resetClip();
boolean isPointInPath(unrestricted double x, unrestricted double y,
optional CanvasFillRule fillRule = "nonzero");
//boolean isPointInPath(Path2D path, unrestricted double x, unrestricted double y,
@@ -145,14 +137,17 @@ interface CanvasDrawPath {
//boolean isPointInStroke(Path2D path, unrestricted double x, unrestricted double y);
};
[NoInterfaceObject]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasUserInterface {
// TODO?
//void drawFocusIfNeeded(Element element);
//void drawFocusIfNeeded(Path2D path, Element element);
//void scrollPathIntoView();
//void scrollPathIntoView(Path2D path);
};
[NoInterfaceObject]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasText {
// text (see also the CanvasDrawingStyles interface)
// text (see also the CanvasPathDrawingStyles and CanvasTextDrawingStyles interfaces)
[Pref="dom.canvas-text.enabled"]
void fillText(DOMString text, unrestricted double x, unrestricted double y,
optional unrestricted double maxWidth);
@@ -161,7 +156,7 @@ interface CanvasText {
//TextMetrics measureText(DOMString text);
};
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasDrawImage {
// drawing images
[Throws]
@@ -176,15 +171,7 @@ interface CanvasDrawImage {
unrestricted double dw, unrestricted double dh);
};
[NoInterfaceObject]
interface CanvasHitRegion {
// hit regions
//void addHitRegion(optional HitRegionOptions options);
//void removeHitRegion(DOMString id);
//void clearHitRegions();
};
[NoInterfaceObject]
[Exposed=Window, NoInterfaceObject]
interface CanvasImageData {
// pixel manipulation
[Throws]
@@ -199,22 +186,19 @@ interface CanvasImageData {
double dirtyX, double dirtyY,
double dirtyWidth, double dirtyHeight);
};
CanvasRenderingContext2D implements CanvasPathDrawingStyles;
CanvasRenderingContext2D implements CanvasTextDrawingStyles;
CanvasRenderingContext2D implements CanvasPath;
enum CanvasLineCap { "butt", "round", "square" };
enum CanvasLineJoin { "round", "bevel", "miter"};
enum CanvasTextAlign { "start", "end", "left", "right", "center" };
enum CanvasTextBaseline { "top", "hanging", "middle", "alphabetic", "ideographic", "bottom" };
enum CanvasDirection { "ltr", "rtl", "inherit" };
[NoInterfaceObject, Exposed=(Window, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasPathDrawingStyles {
// line caps/joins
attribute unrestricted double lineWidth; // (default 1)
attribute CanvasLineCap lineCap; // "butt", "round", "square" (default "butt")
attribute CanvasLineJoin lineJoin; // "round", "bevel", "miter" (default "miter")
attribute CanvasLineCap lineCap; // (default "butt")
attribute CanvasLineJoin lineJoin; // (default "miter")
attribute unrestricted double miterLimit; // (default 10)
// dashed lines
@@ -223,7 +207,7 @@ interface CanvasPathDrawingStyles {
//attribute unrestricted double lineDashOffset;
};
[NoInterfaceObject]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasTextDrawingStyles {
// text
//attribute DOMString font; // (default 10px sans-serif)
@@ -233,7 +217,7 @@ interface CanvasTextDrawingStyles {
//attribute CanvasDirection direction; // "ltr", "rtl", "inherit" (default: "inherit")
};
[NoInterfaceObject, Exposed=(Window, Worker, PaintWorklet)]
[Exposed=(PaintWorklet, Window), NoInterfaceObject]
interface CanvasPath {
// shared path API methods
void closePath();
@@ -253,17 +237,12 @@ interface CanvasPath {
void arcTo(unrestricted double x1, unrestricted double y1,
unrestricted double x2, unrestricted double y2,
unrestricted double radius);
// [LenientFloat] void arcTo(double x1, double y1, double x2, double y2,
// double radiusX, double radiusY, double rotation);
void rect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
[Throws]
void arc(unrestricted double x, unrestricted double y, unrestricted double radius,
unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
// [LenientFloat] void ellipse(double x, double y, double radiusX, double radiusY,
// double rotation, double startAngle, double endAngle,
// boolean anticlockwise);
[Throws]
void ellipse(unrestricted double x, unrestricted double y, unrestricted double radius_x,

0 comments on commit d006bee

Please sign in to comment.