1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
|
/* -*- 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" };
dictionary ContextAttributes2D {
// whether or not we're planning to do a lot of readback operations
boolean willReadFrequently = false;
// signal if the canvas contains an alpha channel
boolean alpha = true;
};
dictionary HitRegionOptions {
Path2D? path = null;
DOMString id = "";
Element? control = null;
};
typedef (HTMLImageElement or
SVGImageElement) HTMLOrSVGImageElement;
typedef (HTMLOrSVGImageElement or
HTMLCanvasElement or
HTMLVideoElement or
ImageBitmap or
OffscreenCanvas or
VideoFrame) CanvasImageSource;
interface CanvasRenderingContext2D {
// back-reference to the canvas. Might be null if we're not
// associated with a canvas.
readonly attribute HTMLCanvasElement? canvas;
// 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, Func="CanvasUtils::HasDrawWindowPrivilege"]
undefined drawWindow(Window window, double x, double y, double w, double h,
DOMString 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 CanvasPath;
CanvasRenderingContext2D includes CanvasHitRegions;
interface mixin CanvasState {
// state
undefined save(); // push state on state stack
undefined restore(); // pop state stack and restore state
};
interface mixin CanvasTransform {
// transformations (default transform is the identity matrix)
// NOT IMPLEMENTED attribute SVGMatrix currentTransform;
[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);
[Throws, LenientFloat]
undefined setTransform(double a, double b, double c, double d, double e, double f);
[Throws]
undefined resetTransform();
[NewObject, Throws]
DOMMatrix getTransform();
};
[NoInterfaceObject]
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 (DOMString or CanvasGradient or CanvasPattern) strokeStyle; // (default black)
attribute (DOMString 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, Throws]
CanvasPattern? createPattern(CanvasImageSource image, [TreatNullAs=EmptyString] DOMString repetition);
};
interface mixin CanvasShadowStyles {
[LenientFloat]
attribute double shadowOffsetX; // (default 0)
[LenientFloat]
attribute double shadowOffsetY; // (default 0)
[LenientFloat]
attribute double shadowBlur; // (default 0)
attribute DOMString shadowColor; // (default transparent black)
};
interface mixin CanvasFilters {
[Pref="canvas.filters.enabled", SetterThrows]
attribute DOMString 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 CanvasPath)
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 {
[Pref="canvas.focusring.enabled", Throws] undefined drawFocusIfNeeded(Element element);
// NOT IMPLEMENTED undefined drawSystemFocusRing(Path path, HTMLElement element);
[Pref="canvas.customfocusring.enabled"] boolean drawCustomFocusRing(Element element);
// NOT IMPLEMENTED boolean drawCustomFocusRing(Path path, HTMLElement 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);
};
interface mixin CanvasImageData {
// pixel manipulation
[NewObject, Throws]
ImageData createImageData(double sw, double sh);
[NewObject, Throws]
ImageData createImageData(ImageData imagedata);
[NewObject, Throws, NeedsSubjectPrincipal]
ImageData getImageData(double sx, double sy, double sw, double sh);
[Throws]
undefined putImageData(ImageData imagedata, double dx, double dy);
[Throws]
undefined putImageData(ImageData imagedata, double dx, double dy, double dirtyX, double dirtyY, double dirtyWidth, double dirtyHeight);
};
interface mixin CanvasPathDrawingStyles {
// line caps/joins
[LenientFloat]
attribute double lineWidth; // (default 1)
attribute DOMString lineCap; // "butt", "round", "square" (default "butt")
[GetterThrows]
attribute DOMString lineJoin; // "round", "bevel", "miter" (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 DOMString font; // (default 10px sans-serif)
attribute DOMString textAlign; // "start", "end", "left", "right", "center" (default: "start")
attribute DOMString textBaseline; // "top", "hanging", "middle", "alphabetic", "ideographic", "bottom" (default: "alphabetic")
};
interface mixin CanvasPath {
// shared path API methods
undefined closePath();
undefined moveTo(unrestricted double x, unrestricted double y);
undefined lineTo(unrestricted double x, unrestricted double y);
undefined quadraticCurveTo(unrestricted double cpx, unrestricted double cpy, unrestricted double x, unrestricted double y);
undefined bezierCurveTo(unrestricted double cp1x, unrestricted double cp1y, unrestricted double cp2x, unrestricted double cp2y, unrestricted double x, unrestricted double y);
[Throws]
undefined arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radius);
undefined rect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted 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]
undefined arc(unrestricted double x, unrestricted double y, unrestricted double radius, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
[Throws]
undefined ellipse(unrestricted double x, unrestricted double y, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
};
interface mixin CanvasHitRegions {
// hit regions
[Pref="canvas.hitregions.enabled", Throws] undefined addHitRegion(optional HitRegionOptions options);
[Pref="canvas.hitregions.enabled"] undefined removeHitRegion(DOMString id);
[Pref="canvas.hitregions.enabled"] undefined clearHitRegions();
};
interface CanvasGradient {
// opaque object
[Throws]
// addColorStop should take a double
undefined addColorStop(float offset, DOMString color);
};
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);
// No throw necessary here - SVGMatrix is always good.
undefined setTransform(SVGMatrix matrix);
};
interface TextMetrics {
// x-direction
readonly attribute double width; // advance width
readonly attribute double actualBoundingBoxLeft;
readonly attribute double actualBoundingBoxRight;
readonly attribute double fontBoundingBoxAscent;
readonly attribute double fontBoundingBoxDescent;
// y-direction
readonly attribute double actualBoundingBoxAscent;
readonly attribute double actualBoundingBoxDescent;
/*
* NOT IMPLEMENTED YET
readonly attribute double emHeightAscent;
readonly attribute double emHeightDescent;
readonly attribute double hangingBaseline;
readonly attribute double alphabeticBaseline;
readonly attribute double ideographicBaseline;
*/
};
[Pref="canvas.path.enabled",
Constructor,
Constructor(Path2D other),
Constructor(DOMString pathString)]
interface Path2D
{
undefined addPath(Path2D path, optional SVGMatrix transformation);
};
Path2D includes CanvasPath;
|