summaryrefslogtreecommitdiffstats
path: root/dom/webidl/CanvasRenderingContext2D.webidl
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/webidl/CanvasRenderingContext2D.webidl
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/webidl/CanvasRenderingContext2D.webidl')
-rw-r--r--dom/webidl/CanvasRenderingContext2D.webidl414
1 files changed, 414 insertions, 0 deletions
diff --git a/dom/webidl/CanvasRenderingContext2D.webidl b/dom/webidl/CanvasRenderingContext2D.webidl
new file mode 100644
index 0000000000..c89c098928
--- /dev/null
+++ b/dom/webidl/CanvasRenderingContext2D.webidl
@@ -0,0 +1,414 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/.
+ *
+ * The origin of this IDL file is
+ * http://www.whatwg.org/specs/web-apps/current-work/
+ *
+ * © Copyright 2004-2011 Apple Computer, Inc., Mozilla Foundation, and
+ * Opera Software ASA. You are granted a license to use, reproduce
+ * and create derivative works of this document.
+ */
+
+enum CanvasWindingRule { "nonzero", "evenodd" };
+
+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" };
+enum CanvasFontKerning { "auto", "normal", "none" };
+enum CanvasFontStretch { "ultra-condensed", "extra-condensed", "condensed", "semi-condensed", "normal", "semi-expanded", "expanded", "extra-expanded", "ultra-expanded" };
+enum CanvasFontVariantCaps { "normal", "small-caps", "all-small-caps", "petite-caps", "all-petite-caps", "unicase", "titling-caps" };
+enum CanvasTextRendering { "auto", "optimizeSpeed", "optimizeLegibility", "geometricPrecision" };
+
+[GenerateInit]
+dictionary CanvasRenderingContext2DSettings {
+ // signal if the canvas contains an alpha channel
+ boolean alpha = true;
+
+ boolean desynchronized = false;
+
+ PredefinedColorSpace colorSpace = "srgb";
+
+ // whether or not we're planning to do a lot of readback operations
+ boolean willReadFrequently = false;
+};
+
+dictionary HitRegionOptions {
+ Path2D? path = null;
+ DOMString id = "";
+ Element? control = null;
+};
+
+typedef (HTMLImageElement or
+ SVGImageElement) HTMLOrSVGImageElement;
+
+typedef (HTMLOrSVGImageElement or
+ HTMLCanvasElement or
+ HTMLVideoElement or
+ OffscreenCanvas or
+ ImageBitmap or
+ VideoFrame) CanvasImageSource;
+
+[Exposed=Window]
+interface CanvasRenderingContext2D {
+
+ // back-reference to the canvas. Might be null if we're not
+ // associated with a canvas.
+ readonly attribute HTMLCanvasElement? canvas;
+
+ CanvasRenderingContext2DSettings getContextAttributes();
+
+ // Show the caret if appropriate when drawing
+ [Func="CanvasUtils::HasDrawWindowPrivilege"]
+ const unsigned long DRAWWINDOW_DRAW_CARET = 0x01;
+ // Don't flush pending layout notifications that could otherwise
+ // be batched up
+ [Func="CanvasUtils::HasDrawWindowPrivilege"]
+ const unsigned long DRAWWINDOW_DO_NOT_FLUSH = 0x02;
+ // Draw scrollbars and scroll the viewport if they are present
+ [Func="CanvasUtils::HasDrawWindowPrivilege"]
+ const unsigned long DRAWWINDOW_DRAW_VIEW = 0x04;
+ // Use the widget layer manager if available. This means hardware
+ // acceleration may be used, but it might actually be slower or
+ // lower quality than normal. It will however more accurately reflect
+ // the pixels rendered to the screen.
+ [Func="CanvasUtils::HasDrawWindowPrivilege"]
+ const unsigned long DRAWWINDOW_USE_WIDGET_LAYERS = 0x08;
+ // Don't synchronously decode images - draw what we have
+ [Func="CanvasUtils::HasDrawWindowPrivilege"]
+ const unsigned long DRAWWINDOW_ASYNC_DECODE_IMAGES = 0x10;
+
+ /**
+ * Renders a region of a window into the canvas. The contents of
+ * the window's viewport are rendered, ignoring viewport clipping
+ * and scrolling.
+ *
+ * @param x
+ * @param y
+ * @param w
+ * @param h specify the area of the window to render, in CSS
+ * pixels.
+ *
+ * @param backgroundColor the canvas is filled with this color
+ * before we render the window into it. This color may be
+ * transparent/translucent. It is given as a CSS color string
+ * (e.g., rgb() or rgba()).
+ *
+ * @param flags Used to better control the drawWindow call.
+ * Flags can be ORed together.
+ *
+ * Of course, the rendering obeys the current scale, transform and
+ * globalAlpha values.
+ *
+ * Hints:
+ * -- If 'rgba(0,0,0,0)' is used for the background color, the
+ * drawing will be transparent wherever the window is transparent.
+ * -- Top-level browsed documents are usually not transparent
+ * because the user's background-color preference is applied,
+ * but IFRAMEs are transparent if the page doesn't set a background.
+ * -- If an opaque color is used for the background color, rendering
+ * will be faster because we won't have to compute the window's
+ * transparency.
+ *
+ * This API cannot currently be used by Web content. It is chrome
+ * and Web Extensions (with a permission) only.
+ */
+ [Throws, NeedsSubjectPrincipal, Func="CanvasUtils::HasDrawWindowPrivilege"]
+ undefined drawWindow(Window window, double x, double y, double w, double h,
+ UTF8String bgColor, optional unsigned long flags = 0);
+
+ /**
+ * This causes a context that is currently using a hardware-accelerated
+ * backend to fallback to a software one. All state should be preserved.
+ */
+ [ChromeOnly]
+ undefined demote();
+};
+
+CanvasRenderingContext2D includes CanvasState;
+CanvasRenderingContext2D includes CanvasTransform;
+CanvasRenderingContext2D includes CanvasCompositing;
+CanvasRenderingContext2D includes CanvasImageSmoothing;
+CanvasRenderingContext2D includes CanvasFillStrokeStyles;
+CanvasRenderingContext2D includes CanvasShadowStyles;
+CanvasRenderingContext2D includes CanvasFilters;
+CanvasRenderingContext2D includes CanvasRect;
+CanvasRenderingContext2D includes CanvasDrawPath;
+CanvasRenderingContext2D includes CanvasUserInterface;
+CanvasRenderingContext2D includes CanvasText;
+CanvasRenderingContext2D includes CanvasDrawImage;
+CanvasRenderingContext2D includes CanvasImageData;
+CanvasRenderingContext2D includes CanvasPathDrawingStyles;
+CanvasRenderingContext2D includes CanvasTextDrawingStyles;
+CanvasRenderingContext2D includes CanvasPathMethods;
+
+
+interface mixin CanvasState {
+ // state
+ undefined save(); // push state on state stack
+ undefined restore(); // pop state stack and restore state
+ undefined reset(); // reset the rendering context to its default state
+};
+
+interface mixin CanvasTransform {
+ // transformations (default transform is the identity matrix)
+ [Throws, LenientFloat]
+ undefined scale(double x, double y);
+ [Throws, LenientFloat]
+ undefined rotate(double angle);
+ [Throws, LenientFloat]
+ undefined translate(double x, double y);
+ [Throws, LenientFloat]
+ undefined transform(double a, double b, double c, double d, double e, double f);
+
+ [NewObject, Throws] DOMMatrix getTransform();
+ [Throws, LenientFloat]
+ undefined setTransform(double a, double b, double c, double d, double e, double f);
+ [Throws]
+ undefined setTransform(optional DOMMatrix2DInit transform = {});
+ [Throws]
+ undefined resetTransform();
+};
+
+interface mixin CanvasCompositing {
+ attribute unrestricted double globalAlpha; // (default 1.0)
+ [Throws]
+ attribute DOMString globalCompositeOperation; // (default source-over)
+};
+
+interface mixin CanvasImageSmoothing {
+ // drawing images
+ attribute boolean imageSmoothingEnabled;
+};
+
+interface mixin CanvasFillStrokeStyles {
+ // colors and styles (see also the CanvasPathDrawingStyles interface)
+ attribute (UTF8String or CanvasGradient or CanvasPattern) strokeStyle; // (default black)
+ attribute (UTF8String or CanvasGradient or CanvasPattern) fillStyle; // (default black)
+ [NewObject]
+ CanvasGradient createLinearGradient(double x0, double y0, double x1, double y1);
+ [NewObject, Throws]
+ CanvasGradient createRadialGradient(double x0, double y0, double r0, double x1, double y1, double r1);
+ [NewObject]
+ CanvasGradient createConicGradient(double angle, double cx, double cy);
+ [NewObject, Throws]
+ CanvasPattern? createPattern(CanvasImageSource image, [LegacyNullToEmptyString] DOMString repetition);
+};
+
+interface mixin CanvasShadowStyles {
+ [LenientFloat]
+ attribute double shadowOffsetX; // (default 0)
+ [LenientFloat]
+ attribute double shadowOffsetY; // (default 0)
+ [LenientFloat]
+ attribute double shadowBlur; // (default 0)
+ attribute UTF8String shadowColor; // (default transparent black)
+};
+
+interface mixin CanvasFilters {
+ [SetterThrows]
+ attribute UTF8String filter; // (default empty string = no filter)
+};
+
+interface mixin CanvasRect {
+ [LenientFloat]
+ undefined clearRect(double x, double y, double w, double h);
+ [LenientFloat]
+ undefined fillRect(double x, double y, double w, double h);
+ [LenientFloat]
+ undefined strokeRect(double x, double y, double w, double h);
+};
+
+interface mixin CanvasDrawPath {
+ // path API (see also CanvasPathMethods)
+ undefined beginPath();
+ undefined fill(optional CanvasWindingRule winding = "nonzero");
+ undefined fill(Path2D path, optional CanvasWindingRule winding = "nonzero");
+ undefined stroke();
+ undefined stroke(Path2D path);
+ undefined clip(optional CanvasWindingRule winding = "nonzero");
+ undefined clip(Path2D path, optional CanvasWindingRule winding = "nonzero");
+// NOT IMPLEMENTED undefined resetClip();
+ [NeedsSubjectPrincipal]
+ boolean isPointInPath(unrestricted double x, unrestricted double y, optional CanvasWindingRule winding = "nonzero");
+ [NeedsSubjectPrincipal] // Only required because overloads can't have different extended attributes.
+ boolean isPointInPath(Path2D path, unrestricted double x, unrestricted double y, optional CanvasWindingRule winding = "nonzero");
+ [NeedsSubjectPrincipal]
+ boolean isPointInStroke(double x, double y);
+ [NeedsSubjectPrincipal] // Only required because overloads can't have different extended attributes.
+ boolean isPointInStroke(Path2D path, unrestricted double x, unrestricted double y);
+};
+
+interface mixin CanvasUserInterface {
+ [Throws] undefined drawFocusIfNeeded(Element element);
+// NOT IMPLEMENTED undefined scrollPathIntoView();
+// NOT IMPLEMENTED undefined scrollPathIntoView(Path path);
+};
+
+interface mixin CanvasText {
+ // text (see also the CanvasPathDrawingStyles interface)
+ [Throws, LenientFloat]
+ undefined fillText(DOMString text, double x, double y, optional double maxWidth);
+ [Throws, LenientFloat]
+ undefined strokeText(DOMString text, double x, double y, optional double maxWidth);
+ [NewObject, Throws]
+ TextMetrics measureText(DOMString text);
+};
+
+interface mixin CanvasDrawImage {
+ [Throws, LenientFloat]
+ undefined drawImage(CanvasImageSource image, double dx, double dy);
+ [Throws, LenientFloat]
+ undefined drawImage(CanvasImageSource image, double dx, double dy, double dw, double dh);
+ [Throws, LenientFloat]
+ undefined drawImage(CanvasImageSource image, double sx, double sy, double sw, double sh, double dx, double dy, double dw, double dh);
+};
+
+// See https://github.com/whatwg/html/issues/6262 for [EnforceRange] usage.
+interface mixin CanvasImageData {
+ // pixel manipulation
+ [NewObject, Throws]
+ ImageData createImageData([EnforceRange] long sw, [EnforceRange] long sh);
+ [NewObject, Throws]
+ ImageData createImageData(ImageData imagedata);
+ [NewObject, Throws, NeedsSubjectPrincipal]
+ ImageData getImageData([EnforceRange] long sx, [EnforceRange] long sy, [EnforceRange] long sw, [EnforceRange] long sh);
+ [Throws]
+ undefined putImageData(ImageData imagedata, [EnforceRange] long dx, [EnforceRange] long dy);
+ [Throws]
+ undefined putImageData(ImageData imagedata, [EnforceRange] long dx, [EnforceRange] long dy, [EnforceRange] long dirtyX, [EnforceRange] long dirtyY, [EnforceRange] long dirtyWidth, [EnforceRange] long dirtyHeight);
+};
+
+interface mixin CanvasPathDrawingStyles {
+ // line caps/joins
+ [LenientFloat]
+ attribute double lineWidth; // (default 1)
+ attribute CanvasLineCap lineCap; // (default "butt")
+ attribute CanvasLineJoin lineJoin; // (default "miter")
+ [LenientFloat]
+ attribute double miterLimit; // (default 10)
+
+ // dashed lines
+ [LenientFloat, Throws] undefined setLineDash(sequence<double> segments); // default empty
+ sequence<double> getLineDash();
+ [LenientFloat] attribute double lineDashOffset;
+};
+
+interface mixin CanvasTextDrawingStyles {
+ // text
+ [SetterThrows]
+ attribute UTF8String font; // (default 10px sans-serif)
+ attribute CanvasTextAlign textAlign; // (default: "start")
+ attribute CanvasTextBaseline textBaseline; // (default: "alphabetic")
+ attribute CanvasDirection direction; // (default: "inherit")
+ attribute UTF8String letterSpacing; // default: "0px"
+ attribute CanvasFontKerning fontKerning; // (default: "auto")
+ attribute CanvasFontStretch fontStretch; // (default: "normal")
+ attribute CanvasFontVariantCaps fontVariantCaps; // (default: "normal")
+ attribute CanvasTextRendering textRendering; // (default: "auto")
+ attribute UTF8String wordSpacing; // default: "0px"
+};
+
+interface mixin CanvasPathMethods {
+ // shared path API methods
+ undefined closePath();
+ [LenientFloat]
+ undefined moveTo(double x, double y);
+ [LenientFloat]
+ undefined lineTo(double x, double y);
+ [LenientFloat]
+ undefined quadraticCurveTo(double cpx, double cpy, double x, double y);
+
+ [LenientFloat]
+ undefined bezierCurveTo(double cp1x, double cp1y, double cp2x, double cp2y, double x, double y);
+
+ [Throws, LenientFloat]
+ undefined arcTo(double x1, double y1, double x2, double y2, double radius);
+// NOT IMPLEMENTED [LenientFloat] undefined arcTo(double x1, double y1, double x2, double y2, double radiusX, double radiusY, double rotation);
+
+ [LenientFloat]
+ undefined rect(double x, double y, double w, double h);
+
+ [Throws]
+ undefined roundRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h, optional (unrestricted double or DOMPointInit or sequence<(unrestricted double or DOMPointInit)>) radii = 0);
+
+ [Throws, LenientFloat]
+ undefined arc(double x, double y, double radius, double startAngle, double endAngle, optional boolean anticlockwise = false);
+
+ [Throws, LenientFloat]
+ undefined ellipse(double x, double y, double radiusX, double radiusY, double rotation, double startAngle, double endAngle, optional boolean anticlockwise = false);
+};
+
+[Exposed=(Window,Worker),
+ Func="mozilla::dom::OffscreenCanvas::PrefEnabledOnWorkerThread"]
+interface CanvasGradient {
+ // opaque object
+ [Throws]
+ // addColorStop should take a double
+ undefined addColorStop(float offset, UTF8String color);
+};
+
+[Exposed=(Window,Worker),
+ Func="mozilla::dom::OffscreenCanvas::PrefEnabledOnWorkerThread"]
+interface CanvasPattern {
+ // opaque object
+ // [Throws, LenientFloat] - could not do this overload because of bug 1020975
+ // undefined setTransform(double a, double b, double c, double d, double e, double f);
+
+ [Throws]
+ undefined setTransform(optional DOMMatrix2DInit matrix = {});
+};
+
+[Exposed=(Window,Worker)]
+interface TextMetrics {
+
+ // x-direction
+ readonly attribute double width; // advance width
+
+ // [experimental] actualBoundingBox* attributes
+ [Pref="dom.textMetrics.actualBoundingBox.enabled"]
+ readonly attribute double actualBoundingBoxLeft;
+ [Pref="dom.textMetrics.actualBoundingBox.enabled"]
+ readonly attribute double actualBoundingBoxRight;
+
+ // y-direction
+ // [experimental] fontBoundingBox* attributes
+ [Pref="dom.textMetrics.fontBoundingBox.enabled"]
+ readonly attribute double fontBoundingBoxAscent;
+ [Pref="dom.textMetrics.fontBoundingBox.enabled"]
+ readonly attribute double fontBoundingBoxDescent;
+
+ // [experimental] actualBoundingBox* attributes
+ [Pref="dom.textMetrics.actualBoundingBox.enabled"]
+ readonly attribute double actualBoundingBoxAscent;
+ [Pref="dom.textMetrics.actualBoundingBox.enabled"]
+ readonly attribute double actualBoundingBoxDescent;
+
+ // [experimental] emHeight* attributes
+ [Pref="dom.textMetrics.emHeight.enabled"]
+ readonly attribute double emHeightAscent;
+ [Pref="dom.textMetrics.emHeight.enabled"]
+ readonly attribute double emHeightDescent;
+
+ // [experimental] *Baseline attributes
+ [Pref="dom.textMetrics.baselines.enabled"]
+ readonly attribute double hangingBaseline;
+ [Pref="dom.textMetrics.baselines.enabled"]
+ readonly attribute double alphabeticBaseline;
+ [Pref="dom.textMetrics.baselines.enabled"]
+ readonly attribute double ideographicBaseline;
+};
+
+[Exposed=(Window,Worker)]
+interface Path2D
+{
+ constructor();
+ constructor(Path2D other);
+ constructor(DOMString pathString);
+
+ [Throws] undefined addPath(Path2D path, optional DOMMatrix2DInit transform = {});
+};
+Path2D includes CanvasPathMethods;