html5 canvas 2d

8/8/2019 Html5 Canvas 2d

1/54

Canvas 2D API Specification 1.0

W3C Editor's Draft 21 October 2009

This Version:http://dev.w3.org/html5/canvas-api/canvas-2d-api.html

Latest Version:http://dev.w3.org/html5/canvas-api/canvas-2d-api.html

Authors:The authors of this specification are the participants of the W3C HTMLWorking Group.

Editors:Ian Hickson, Google, Inc.David Hyatt, Apple, Inc.Doug Schepers, W3CEliot Graff, Microsoft Corporation

Copyright 2009W3C(MIT, ERCIM, Keio), All Rights Reserved. W3Cliability, trademarkanddocument userules apply.

Page 1 of 54The Canvas 2D API 1.0 Specification

25.02.2010http://dev.w3.org/cvsweb/~checkout~/html5/canvas-api/canvas-2d-api.html?rev=1.5&...


2/54

Abstract

This specification defines the 2D Canvas Drawing API, a commonprogrammatic interface to draw immediate-mode two-dimensional graphics onthe Web.




3/54

Status of This Document

This section describes the status of this document at the time of its publication.Other documents may supersede this document. A list of current W3Cpublications and the latest revision of this technical report can be found in theW3C technical reports indexat http://www.w3.org/TR/.

This is a First Public Working Draft of "The Canvas 2D API Specification1.0 ."

You can follow the change history for the specification through a browsableversion-control record of all changes. The CVSWeb interface with side-by-sidediffs can be found at http://dev.w3.org/html5/canvas-api/canvas-2d-api.html

This document was developed by the W3C HTML Working Group. TheWorking Group expects to advance this Working Draft to RecommendationStatus. The HTML Working Group Patent Policy Status is publicly available.

If you wish to make comments regarding this document, please send them [email protected] (subscribe, archives), [email protected] (subscribe, archives), or submit them using our public bugdatabase. All feedback is welcome. We maintain a list of all bug reports thathave not yet been resolved.

Publication as a Working Draft does not imply endorsement by the W3CMembership. This is a draft document and may be updated, replaced or madeobsolete by other documents at any time. It is inappropriate to cite thisdocument as other than work in progress.

This document was produced by a group operating under the 5 February 2004W3C Patent Policy. W3C maintains a public list of any patent disclosures madein connection with the deliverables of the group; that page also includesinstructions for disclosing a patent. An individual who has actual knowledge ofa patent which the individual believes contains Essential Claim(s) must disclosethe information in accordance with section 6 of the W3C Patent Policy.




4/54

Table of Contents

1. Introduction1.1. Definitions1.2. Not in This Specification1.3. Conformance

2. The Canvas Interface Element2.1. The canvas interface element

2.1.1. The getContext() Method2.1.2. The toDataURL() Method

3. The 2D Drawing Context3.1 The canvas state3.2 Transformations3.3 Compositing3.4 Colors and styles3.5 Line styles3.6 Shadows3.7 Simple shapes (rectangles)3.8 Complex shapes (paths)3.9 Text3.10 Images3.11 Pixel manipulation3.12 Drawing model

4. Color spaces and color correction5. Accessibility Considerations6. Security with Canvas Interface Elements7. Relationship to other specifications

7.1. HTML5

7.2. DOM Level 3 CoreA. Change HistoryB. References

Informative ReferencesNormative References

C. Acknowledgments




5/54

1. Introduction

This specification describes an immediate-mode API and associated utilitymethods for drawing two-dimensional vectorgraphics to a rasterrenderingarea. This API is suitable for implementation on any element which contains,describes, or references a raster image, as defined by the host language for

that element. Most notably, it is applicable to the canvas element defined inthe HTML5 specification but may also be available to the image element infuture versions of SVG. The API described in this specification issupplementary to any other interfaces defined for the element by the hostlanguage.

1.1. Definitions

This section is normative.

2DSee two-dimensional

3DSee three-dimensional

APIAn application programming interfaceconsisting of methods andproperties which allow the author to get or set data or execute commandsto the user agent.

canvas interface elementThe element implementing the methods and properties described in this

specification, and serving as the rendering context for the drawingcommands. In HTML5, this is the canvas element.drawing context

Represents a Cartesian surface whose origin (0,0) is at the top leftcorner, with the coordinate space having xvalues increasing when goingright, and yvalues increasing when going down.

immediate-modeA drawing format in which the drawing instructions are discarded frommemory after rendering. This API is an example of an immediate-modegraphics format.

retained-mode

A drawing format in which the drawing instructions are retained inmemory, such as in a DOM. SVG is an example of a retained-modegraphics format.

rasterA style of graphics in which the image is broken up into a matrix made upof rows, each of which contains a certain number of pixels.

source-over operatorAn operator that places the source over the destination. The color thatresults from the operation is a combination of the three sub-pixel regions:the source color from the overlapping region, the source color that isn'tobscured by the destination color, and the destination color that isn't

obscured by the source color contribution to the resultant color. Theresultant opacity is the combined opacity from all three contributingregions.




6/54

vectorA style of graphics in which the image is created from path-based,mathematical descriptions.

two-dimensionalIn graphics, describing relationships, orientation, and coordinates on aplanar surface, where location can be completely described with exactlytwo orthogonal axes, where x represents the horizontal and y representsthe vertical.

three-dimensionalIn graphics, describing relationships, orientation, and coordinates in acubic space, where location can be completely described with exactlythree orthogonal axes, where x represents the horizontal, y representsthe vertical, and z represents the depth.

1.2. Not in This Specification

This section is informative.

The manner in which a host language uses the functionality of the 2D CanvasDrawing API is not defined by this group. In particular, defining the canvaselement in HTML, and its attributes and characteristics, is not within the scopeof this specification.

This specification covers only a two-dimensional drawing API. Three-dimensional graphics are not within the scope of this specification.

1.3. Conformance

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT","SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" inthis document are to be interpreted as described in RFC 2119 [RFC2119]. Forpurposes of readability, these terms are not necessarily used in a case-sensitive manner in this document.

Sometimes, for readability, conformance requirements are phrased asrequirements on elements, attributes, methods, interfaces, properties or

functions. In all cases these are conformance requirements onimplementations. A conforming implementation of this specification meets allrequirements identified by the use of these terms, within the scope of itslanguage bindings.




7/54

2. The Canvas Interface Element

This section is normative.

This document defines an API intended for integration into a host language,such as HTML or SVG. The following abstract interface describes the

attributes, methods, and objects that must be implemented on a canvasinterface element which supports this specification. The interface name itselfmay be host-language dependent, as may any additional attributes, methods,and objects supported by the element.

The IDL fragments in this specification must be interpreted as required forconforming IDL fragments, as described in the Web IDL specification.[WEBIDL]

Except where otherwise specified, if an IDL attribute or a method argument thatis a floating point number type (float) is assigned an Infinity or Not-a-Number

(NaN) value, a NOT_SUPPORTED_ERR exception must be raised.

Which parent element the canvas interface element derives from, how theCanvas 2D API specification relates to other technologies, or whether theinterface should even be defined in this document are under discussion, andwill be reflected in this draft as progress is made.

2.1. The canvas interface element

A canvas interface elementrepresents a resolution-dependent bitmap canvas,which can be used for rendering graphs, game graphics, or other visual images

dynamically.

The definition of a canvas interface element in a host language must have ameans for an author to control the width and height of the coordinate space,

DOM interface:

interface CanvasElement : Element {attribute unsigned long

width;attribute unsigned long

height;

Object getContext(in DOMString

contextId);

DOMString toDataURL(optional inDOMString type, in any... args);

};




8/54

such as width and height attributes. These width and height attributes, whenspecified, must have values that are valid non-negative integers. The rules forparsing non-negative integers must be used to obtain their numeric values. Thehost language should provide default values for the width and height of thecanvas interface element to be used if value are not specified by the author.Optionally, a host language may allow the element to be sized arbitrarily by a

style sheet.The intrinsic dimensions of the canvas interface element equal the size of thecoordinate space, with the numbers interpreted in CSS pixels. Duringrendering, the image must be scaled to fit this layout size.

The size of the coordinate space does not necessarily represent the size of theactual bitmap that the user agent will use internally or during rendering. On high-definition displays, for instance, the user agent may internally use a bitmapwith two device pixels per unit in the coordinate space. In this case, therendering remains at high quality throughout the process.

The width and height DOM attributes must reflect the respective derivedvalues, such as the content attributes of the same names.

Whenever the values of the width or height attributes are set (whether to a newvalue or to a previous value), the bitmap and any associated contexts must becleared back to their initial state and reinitialized with the newly specifiedcoordinate space dimensions. Because of this, only the last square is renderedat the end of the following HTML example:

// canvas is a reference to a element

var context = canvas.getContext('2d');context.fillRect(0,0,50,50);canvas.setAttribute('width', '300'); //

clears the canvascontext.fillRect(0,100,50,50);canvas.width = canvas.width; //

clears the canvascontext.fillRect(100,0,50,50); // only

this square remains

When the canvas is initialized it must be set to fully transparent black.

To draw on the canvas, authors must first obtain a reference to a context byusing the getContext(contextId) method of the canvas interface element.

context= canvas. getContext(contextId)

Returns an object that exposes an API for drawing on the canvas.

Returns null if the given context ID is not supported.

2.1.1. The getContext() Method




9/54

This specification only defines one context, with the name "2d". IfgetContext() is called with that exact string for its contextIdargument, then the UA mustreturn a reference to an object implementing CanvasRenderingContext2D.Other specifications may define their own contexts, which would return differentobjects.

Vendors may also define experimental contexts by using the syntaxvendorname-context, for example, moz-3d.

When the UA is passed an empty string or a string specifying a context that itdoes not support, then it must return null. String comparisons must be case-sensitive.

Note: A future version of this specification will probably define a3dcontext.

The toDataURL() method provides a means to return the current state of therendered canvas as a raster image.

url= canvas. toDataURL( [ type, ... ])

Returns a data: URL for the image in the canvas.

The toDataURL() method must, when called with no arguments, return adata: URL containing a representation of the image as a PNG file. [PNG].

If the canvas has no pixels (as when either its horizontal dimension or itsvertical dimension is zero) then the method must return the string "data:,".This is the shortest data: URL and represents the empty string in atext/plain resource.

The first argument, if provided, controls the type of the image to be returned(such as PNG or JPEG). The default type is image/png. The image/png typeis also used if the given type is not supported. The other arguments are specificto the type and control the way that the image is generated.

The toDataURL(type) method, when called with one or morearguments,must return a data: URL containing a representation of the image in theformat given by type. The possible values are MIME types with no parameters,for example image/png, image/jpeg, or even image/svg+xml, if theimplementation keeps enough information to reliably render an SVG imagefrom the canvas. If the method is invoked with the first argument giving a type

corresponding to one of the types given in the first column of the followingtable, and the user agent supports that type, then the subsequent arguments, ifany, must be treated as described in the second cell of that row.

2.1.2. The toDataURL() Method




10/54

Type Other arguments

image/jpeg The second argument, if it is a number between 0.0 and 1.0, mustbe treated as the desired quality level. If it is not a number or isoutside that range, the user agent must use its default value, as ifthe argument had been omitted.

Other arguments must be ignored and must not cause the user agent to raisean exception. A future version of this specification will probably define otherparameters to be passed to toDataURL() to allow authors to more carefullycontrol compression settings, image metadata, etc.

User agents must convert the provided type to ASCII lowercase beforeestablishing if they support that type and before creating the data: URL.

Only support forimage/png is required. User agents may support other types.If the user agent does not support the requested type, it must return the imageusing the PNG format.

Note: When trying to use types other thanimage/png, authorscan check if the image was really returned in the requestedformat by checking to see if the returned string starts with onethe exact strings "data:image/png," or "data:image/png;". Ifit does, the image is PNG, and thus the requested type was notsupported. (The one exception to this is if the canvas has eitherno height or no width, in which case the result might simply be"data:,".)

For image types that do not support an alpha channel, the image must becomposited onto a solid black background using the source-over operator, andthe resulting image must be the one used to create the data: URL.




11/54

3. The 2D Drawing Context

When the getContext() method of a canvas interface element is invokedwith 2d as the argument, a CanvasRenderingContext2Dobject is returned.The CanvasRenderingContext2Dobject is a 2D drawing context thatrepresents a flat Cartesian surface whose origin (0,0) is at the top left corner.The coordinate space xvalues increase going right, and the yvalues increasegoing down.

There is only one CanvasRenderingContext2Dobject per canvas. Callingthe getContext() method with the 2d argument a second time must returnthe same object.

interface CanvasRenderingContext2D {

// back-reference to the canvas

readonly attribute HTMLCanvasElement canvas;

// statevoid restore(); // pop state stack and restore

statevoid save(); // push state on state stack

// transformations (default transform is theidentity matrix)void rotate(in float angle);void scale(in float x, in float y);

void setTransform(in float m11, in float m12, infloat m21, in float m22, in float dx, in float dy);void transform(in float m11, in float m12, in

float m21, in float m22, in float dx, in float dy);void translate(in float x, in float y);

// compositingattribute float globalAlpha; // (default 1.0)attribute DOMString globalCompositeOperation; //

(default source-over)

// colors and stylesattribute any fillStyle; // (default black)attribute any strokeStyle; // (default black)CanvasGradient createLinearGradient(in float x0,

in float y0, in float x1, in float y1);CanvasGradient createRadialGradient(in float x0,

in float y0, in float r0, in float x1, in float y1,in float r1);CanvasPattern createPattern(in HTMLImageElement

image, in DOMString repetition);CanvasPattern createPattern(in HTMLCanvasElement

image, in DOMString repetition);CanvasPattern createPattern(in HTMLVideoElement

image, in DOMString repetition);




12/54

// line stylesattribute DOMString lineCap; // "butt", "round",

"square" (default "butt")attribute DOMString lineJoin; // "miter",

"round", "bevel" (default "miter")attribute float lineWidth; // (default 1)attribute float miterLimit; // (default 10)

// shadowsattribute float shadowBlur; // (default 0)attribute DOMString shadowColor; // (default

transparent black)attribute float shadowOffsetX; // (default 0)attribute float shadowOffsetY; // (default 0)

// rects

void clearRect(in float x, in float y, in floatw, in float h);void fillRect(in float x, in float y, in float w,

in float h);void strokeRect(in float x, in float y, in float

w, in float h);

// Complex shapes (paths) APIvoid arc(in float x, in float y, in float radius,

in float startAngle, in float endAngle, in booleananticlockwise);

void arcTo(in float x1, in float y1, in float x2,in float y2, in float radius);void beginPath();void bezierCurveTo(in float cp1x, in float cp1y,

in float cp2x, in float cp2y, in float x, in floaty);void clip();void closePath();void fill();void lineTo(in float x, in float y);void moveTo(in float x, in float y);

void quadraticCurveTo(in float cpx, in float cpy,in float x, in float y);void rect(in float x, in float y, in float w, in

float h);void stroke();boolean isPointInPath(in float x, in float y);

// textattribute DOMString font; // (default 10px sans-

serif)attribute DOMString textAlign; // "start", "end",

"left", "right", "center" (default: "start")attribute DOMString textBaseline; // "top","hanging", "middle", "alphabetic", "ideographic",




13/54

"bottom" (default: "alphabetic")void fillText(in DOMString text, in float x, in

float y, optional in float maxWidth);TextMetrics measureText(in DOMString text);void strokeText(in DOMString text, in float x, in

float y, optional in float maxWidth);

// drawing imagesvoid drawImage(in HTMLImageElement image, in

float dx, in float dy, optional in float dw, infloat dh);void drawImage(in HTMLImageElement image, in

float sx, in float sy, in float sw, in float sh, infloat dx, in float dy, in float dw, in float dh);void drawImage(in HTMLCanvasElement image, in

float dx, in float dy, optional in float dw, infloat dh);

void drawImage(in HTMLCanvasElement image, infloat sx, in float sy, in float sw, in float sh, infloat dx, in float dy, in float dw, in float dh);void drawImage(in HTMLVideoElement image, in

float dx, in float dy, optional in float dw, infloat dh);void drawImage(in HTMLVideoElement image, in

float sx, in float sy, in float sw, in float sh, infloat dx, in float dy, in float dw, in float dh);

// pixel manipulation

ImageData createImageData(in float sw, in floatsh);ImageData createImageData(in ImageData

imagedata);ImageData getImageData(in float sx, in float sy,

in float sw, in float sh);void putImageData(in ImageData imagedata, in

float dx, in float dy, optional in float dirtyX, infloat dirtyY, in float dirtyWidth, in floatdirtyHeight);};

interface CanvasGradient {// opaque objectvoid addColorStop(in float offset, in DOMString

color);};

interface CanvasPattern {// opaque object

};

interface TextMetrics {readonly attribute float width;};




14/54

interface ImageData {readonly attribute CanvasPixelArray data;readonly attribute unsigned long height;readonly attribute unsigned long width;

};

interface CanvasPixelArray {readonly attribute unsigned long length;getter octet (in unsigned long index);setter void (in unsigned long index, in octet

value);};

context. canvas

Returns the canvas interface element.

The canvas attribute must return the canvas interface element that the contextpaints on.

Unless otherwise stated, for the CanvasRenderingContext2D interface, anymethod call with a numeric argument whose value is infinite or a NaN valuemust be ignored.

Whenever the CSS value currentColor is used as a color in this API, for thepurposes of determining the computed value of the currentColor keyword,the "computed value of the 'color' property" is the computed value of the 'color'property on the element in question at the time that the color is specified. Forexample, the time the color is specified is when the appropriate attribute is set,or when the method is called; not when the color is rendered or otherwise used.If the computed value of the 'color' property is undefined for a particular case(such as because the element is not in a Document), then the "computed valueof the 'color' property" for the purposes of determining the computed value ofthe currentColor keyword is fully opaque black. [CSSCOLOR]

3.1 The canvas state

Each context maintains a stack of drawing states. Drawing states consist of:

The current transformation matrix.The current clipping region.The current values of the following attributes: fillStyle, font,globalAlpha, globalCompositeOperation, lineCap, lineJoin,lineWidth, miterLimit, shadowBlur, shadowColor,

shadowOffsetX, shadowOffsetY, strokeStyle, textAlign,textBaseline.




15/54

Note: The current path and the current bitmap are not part of thedrawing state. The current path is persistent, and can only bereset by using thebeginPath()method. The current bitmap is a

property of the canvas, not the context.

context. restore()

Pops the top state on the stack, restoring the context to that state.

context. save()

Pushes the current state onto the stack.

The restore() method must pop the top entry in the drawing state stack, and

reset the drawing state it describes. If there is no saved state, the method mustdo nothing.

The save() method must push a copy of the current drawing state onto thedrawing state stack.

3.2 Transformations

The transformation matrix is applied to coordinates when creating shapes and

paths.When the context is created, the transformation matrix must initially be theidentity transform. It may then be adjusted using the transformation methods.

The transformations must be performed in reverse order. For instance, if ascale transformation that doubles the width is applied, followed by a rotatetransformation that rotates drawing operations by a quarter turn, and arectangle twice as wide as it is tall is then drawn on the canvas, the actualresult will be a square.

context. rotate(angle)

Changes the transformation matrix to apply a rotationtransformation with the given characteristics.

context. scale(x, y)

Changes the transformation matrix to apply a scalingtransformation with the given characteristics.

context. setTransform(m11, m12, m21, m22, dx, dy)

Changes the transformation matrix tothe matrix given by thearguments as described below.




16/54

context. transform(m11, m12, m21, m22, dx, dy)

Changes the transformation matrix to apply the matrix given bythe arguments as described below.

context. translate(x, y)

Changes the transformation matrix to apply a translationtransformation with the given characteristics.

The rotate(angle) method must add the rotation transformation describedby the argument to the transformation matrix. The angleargument represents aclockwise rotation angle expressed in radians.

The scale(x, y) method must add the scaling transformation described bythe arguments to the transformation matrix. The xargument represents thescale factor in the horizontal direction and the yargument represents the scale

factor in the vertical direction. The factors are multiples.

The setTransform(m11, m12, m21, m22, dx, dy) method must resetthe current transform to the identity matrix (it should not change the image). Totransform the image, invoke the transform(m11, m12, m21, m22, dx,dy) method with the appropriate arguments.

The transform(m11, m12, m21, m22, dx, dy) method must multiplythe current transformation matrix with the matrix described by:

m11m21dx

m12m22dy

0 0 1

The translate(x, y) method must add the translation transformationdescribed by the arguments to the transformation matrix. The xargumentrepresents the translation distance in the horizontal direction and the yargument represents the translation distance in the vertical direction. Thearguments are in coordinate space units.

3.3 Compositing

context. globalAlpha [ = value]

Returns the current alpha value applied to rendering operations.

Can be set, to change the alpha value. Values outside of therange from 0.0 to 1.0 are ignored.

context. globalCompositeOperation [ = value]

Returns the current composition operation, from the list below.




17/54

Can be set, to change the composition operation. Unknownvalues are ignored.

All drawing operations are affected by the global compositing attributes,

globalAlpha and globalCompositeOperation.The globalAlpha attribute gives an alpha value that is applied to shapes andimages before they are composited onto the canvas. The value must be in therange from 0.0 (fully transparent) to 1.0 (no additional transparency). If anattempt is made to set the attribute to a value outside this range, including avalue set to infinity or not a number (NaN), the attribute must retain its previousvalue. When the context is created, the globalAlpha attribute must initiallyhave the value 1.0.

The globalCompositeOperationattribute sets how shapes and images are

drawn onto the existing bitmap, once they have had globalAlpha and thecurrent transformation matrix applied. It must be set to a value from thefollowing list. In the descriptions that follow, the source image, A, is the shapeor image being rendered, and the destination image, B, is the current state ofthe bitmap.

copy

A (Bis ignored). Display the source image instead of the destinationimage.

destination-atopBatop A. Display the destination image wherever both images are

opaque. Display the source image wherever the source image is opaquebut the destination image is transparent. Display transparency elsewhere.destination-in

Bin A. Display the destination image wherever both the destination imageand source image are opaque. Display transparency elsewhere.

destination-out

Bout A. Display the destination image wherever the destination image isopaque and the source image is transparent. Display transparencyelsewhere.

destination-over

BoverA. Display the destination image wherever the destination image is

opaque. Display the source image elsewhere.lighterA plus B. Display the sum of the source image and destination image,with color values approaching 1 as a limit.

source-atop

A atop B. Display the source image wherever both images are opaque.Display the destination image wherever the destination image is opaquebut the source image is transparent. Display transparency elsewhere.

source-in

A in B. Display the source image wherever both the source image anddestination image are opaque. Display transparency elsewhere.

source-out




18/54

A out B. Display the source image wherever the source image is opaqueand the destination image is transparent. Display transparencyelsewhere.

source-over(default)

A overB. Display the source image wherever the source image isopaque. Display the destination image elsewhere.

vendorName-operationName

Vendor-specific extensions to the list of composition operators should usethis syntax.

xorA xorB. Exclusive OR of the source image and destination image.

These values are all case-sensitive and must be used exactly as shown. Useragents must not recognize values that are not a case-sensitive match for one ofthe values given above.

The operators in the previous list must be treated as described by the Porter-Duff operator given at the start of their description (e.g. A overB).[PORTERDUFF]

On setting, if the user agent does not recognize the specified value, the valuemust be ignored, leaving the value ofglobalCompositeOperationunaffected.

When the context is created, the globalCompositeOperationattributemust initially have the value source-over.

3.4 Colors and styles

context. fillStyle [ = value]

Returns the current style used for filling shapes.

Can be set, to change the fill style.

The style can be either a string containing a CSS color, or aCanvasGradient orCanvasPattern object. Invalid values areignored.

context. strokeStyle [ = value]

Returns the current style used for the stroke of the shapes.

Can be set, to change the stroke style.

The style can be either a string containing a CSS color, or aCanvasGradient orCanvasPattern object. Invalid values areignored.

The strokeStyle attribute represents the color or style to use for the linesaround shapes, and the fillStyle attribute represents the color or style touse inside the shapes.




19/54

Both attributes can be either strings, CanvasGradient objects, orCanvasPattern objects. On setting, strings must be parsed as CSS values and the color assigned, and CanvasGradient and CanvasPatternobjects must be assigned themselves. [CSSCOLOR] If the value is a string butis not a valid color, or is neither a string, a CanvasGradient, nor aCanvasPattern, then the value must be ignored, and the attribute must retain

its previous value.On getting, if the value is a color, then the serialization of the colormust bereturned. Otherwise, if it is not a color but a CanvasGradient orCanvasPattern, then the respective object must be returned. (Such objectsare opaque and therefore only useful for assigning to other attributes or forcomparison to other gradients or patterns.)

The serialization of a color for a color value is a string, computed as follows:

If the value has an alpha equal to 1.0, then the string is a lowercase six-

digit hex value, with the digits being in the range 0-9 or a-f (U+0030 toU+0039 and U+0061 to U+0066), as follows:

The string is prefixed with a "#" character (U+0023 NUMBERSIGN), then

the first two digits represent the red component,the next two digits represent the green component, andthe last two digits represent the blue component.

Otherwise, the color value has alpha less than 1.0, and the string is thecolor value in the CSS rgba() functional-notation format, as follows:

The string is prefixed with the literal string rgba (U+0072 U+0067U+0062 U+0061), then

a U+0028 LEFT PARENTHESIS,a base-ten integer in the range 0-255 representing the redcomponent (using digits 0-9, U+0030 to U+0039, in the shortestform possible),

a literal U+002C COMMA and U+0020 SPACE,a base-ten integer in the range 0-255 representing the greencomponent (using digits 0-9, U+0030 to U+0039, in the shortestform possible),

a literal U+002C COMMA and U+0020 SPACE,a base-ten integer in the range 0-255 representing the bluecomponent (using digits 0-9, U+0030 to U+0039, in the shortestform possible),

a literal U+002C COMMA and U+0020 SPACE,a U+0030 DIGIT ZERO,a U+002E FULL STOP (representing the decimal point),one or more digits in the range 0-9 (U+0030 to U+0039)representing the fractional part of the alpha value, and

a U+0029 RIGHT PARENTHESIS.

When the context is created, the strokeStyle and fillStyle attributes

must initially have the string value #000000.




20/54

There are two types of gradients, linear gradients and radial gradients, bothrepresented by objects implementing the opaque CanvasGradient interface.

Once a gradient has been created by createLinearGradient() orcreateRadialGranient(), stops are placed along it to define how thecolors are distributed along the gradient. The color of the gradient at each stop

is the color specified for that stop. Between each such stop, the colors and thealpha component must be linearly interpolated over the RGBA space withoutpremultiplying the alpha value to find the color to use at that offset. Before thefirst stop, the color must be the color of the first stop. After the last stop, thecolor must be the color of the last stop. When there are no stops, the gradientis transparent black.

gradient. addColorStop(offset, color)

Adds a color stop with the given color to the gradient at the givenoffset. 0.0 is the offset at one end of the gradient, 1.0 is the offsetat the other end.If the offset is out of range, throws an INDEX_SIZE_ERRexception.

If the color cannot be parsed, throws a SYNTAX_ERR exception.

gradient= context. createLinearGradient(x0, y0, x1, y1)

Returns a CanvasGradient object that represents a lineargradient that paints along the line given by the coordinatesrepresented by the arguments.

If any of the arguments are not finite numbers, throws aNOT_SUPPORTED_ERR exception .

gradient= context. createRadialGradient(x0, y0, r0, x1, y1,

r1)

Returns a CanvasGradient object that represents a radialgradient that paints along the cone given by the circlesrepresented by the arguments.

If any of the arguments are not finite numbers, throws aNOT_SUPPORTED_ERR exception .

If either of the radii are negative, throws an INDEX_SIZE_ERRexception.

The addColorStop(offset, color) method on the CanvasGradientinterface adds a new stop to a gradient. Ifoffsetis less than 0, greater than 1,infinite, or NaN, then an INDEX_SIZE_ERR exception must be raised. Ifcolorcannot be parsed as a CSS color, then a SYNTAX_ERR exception must beraised. Otherwise, the gradient must have a new stop placed, at offset offset

relative to the whole gradient, and with the color obtained by parsing coloras aCSS value [CSSCOLOR]. If multiple stops are added at the sameoffset on a gradient, they must be placed in the order added, with the first one




21/54

closest to the start of the gradient, and each subsequent one infinitesimallyfurther along towards the end point (in effect causing all but the first and laststop added at each point to be ignored).

The createLinearGradient(x0, y0, x1, y1) method takes fourarguments that represent the start point (x0, y0) and end point (x1, y1) of thegradient. If any of the arguments to createLinearGradient() are infinite orNaN, the method must raise a NOT_SUPPORTED_ERR exception. Otherwise,the method must return a linearCanvasGradient initialized with the specifiedline.

Linear gradients must be rendered such that all points on a line perpendicularto the line that crosses the start and end points have the color at the pointwhere those two lines cross (with the colors coming from the interpolation andextrapolation described above). The points in the linear gradient must betransformed as described by the current transformation matrix when rendering.

Ifx0 = x1 and y0 = y1, then the linear gradient must paint nothing.

The createRadialGradient(x0, y0, r0, x1, y1, r1) method takessix arguments, the first three representing the start circle with origin (x0, y0)and radius r0, and the last three representing the end circle with origin (x1, y1)and radius r1. The values are in coordinate space units. If any of the argumentsare infinite or NaN, a NOT_SUPPORTED_ERR exception must be raised. If eitherofr0orr1 are negative, an INDEX_SIZE_ERR exception must be raised.Otherwise, the method must return a radial CanvasGradient initialized withthe two specified circles.

Radial gradients must be rendered by following these steps:

Ifx = x and y = y and r = r, then the radial gradient mustpaint nothing. Abort these steps.

1.

Let x() = (x-x) + x2.

Let y() = (y-y) + y

Let r() = (r-r) + r

Let the color at be the color at that position on the gradient (with the

colors coming from the interpolation and extrapolation described above).For all values ofwhere r() > 0, starting with the value ofnearest to positive infinity and ending with the value ofnearest tonegative infinity, draw the circumference of the circle with radius r() atposition (x(), y()), with the color at , but only painting on the partsof the canvas that have not yet been painted on by earlier circles in thisstep for this rendering of the gradient.

3.

Note: This effectively creates a cone, touched by the two circlesdefined in the creation of the gradient, with the part of the cone

before the start circle (0.0) using the color of the first offset, thepart of the cone after the end circle (1.0) using the color of the

0 1 0 1 0 1

1 0 0

1 0 0

1 0 0




22/54

last offset, and areas outside the cone untouched by the gradient(transparent black).

Gradients must be painted only where the relevant stroking or filling effectsrequires that they be drawn.

The points in the radial gradient must be transformed as described by thecurrent transformation matrix when rendering.

Patterns are represented by objects implementing the opaqueCanvasPattern interface.

pattern= context. createPattern(image, repetition)

Returns a CanvasPattern object that uses the given image andrepeats in the direction(s) given by the repetitionargument.

The allowed values forrepetition are repeat (bothdirections), repeat-x (horizontal only), repeat-y (verticalonly), and no-repeat (neither). If the repetitionargument isempty or null, the value repeat is used.

If the first argument is not an img, canvas interface element, orvideo element, throws a TYPE_MISMATCH_ERR exception.

If the image is not fully decoded yet or has no image data, throwsan INVALID_STATE_ERR exception.

If the second argument is not one of the allowed values, throws aSYNTAX_ERR exception.

To create objects of this type, the createPattern(image, repetition)method is used. The first argument gives the image to use as the pattern(either an HTMLImageElement or an HTMLCanvasElement). Modifying thisimage after calling the createPattern()method must not affect the pattern.The second argument must be a string with one of the following values:

repeat

repeat-x

repeat-y

no-repeat

If the empty string or null is specified, repeat must be assumed. If anunrecognized value is given, then the user agent must raise a SYNTAX_ERRexception. User agents must recognize the four values described above exactly

(they must not do case folding, for example). The createPattern()methodmust return a CanvasPattern object suitably initialized.




23/54

The imageargument is an instance of eitherHTMLImageElement,HTMLCanvasElement, orHTMLVideoElement. If the imageis of the wrongtype or null, the implementation must raise a TYPE_MISMATCH_ERR exception.

If the imageargument is an HTMLImageElement object whose completeattribute is false, then the implementation must raise an INVALID_STATE_ERR

exception.If the imageargument is an HTMLVideoElement object whose readyStateattribute is eitherHAVE_NOTHING orHAVE_METADATA, then theimplementation must raise an INVALID_STATE_ERR exception.

If the imageargument is an HTMLCanvasElement object with either ahorizontal dimension or a vertical dimension equal to zero, then theimplementation must raise an INVALID_STATE_ERR exception.

Patterns must be painted so that the top left of the first image is anchored at

the origin of the coordinate space, and images are then repeated horizontally tothe left and right (if the repeat-x string was specified) or vertically up anddown (if the repeat-y string was specified) or in all four directions all over thecanvas (if the repeat string was specified). The images are not scaled by thisprocess; one CSS pixel of the image must be painted on one coordinate spaceunit. Of course, patterns must actually be painted only where the stroking orfilling effect requires that they be drawn, and are affected by the currenttransformation matrix.

When the createPattern()method is passed an animated image as itsimageargument, the user agent must use the poster frame of the animation, or,

if there is no poster frame, the first frame of the animation.When the imageargument is an HTMLVideoElement, then the frame at thecurrent playback position must be used as the source image.

3.5 Line styles

context. lineCap [ = value]

Returns the current line cap style.

Can be set, to change the line cap style.

The possible line cap styles are butt, round, and square.Other values are ignored.

context. lineJoin [ = value]

Returns the current line join style.

Can be set, to change the line join style.

The possible line join styles are miter, round, and bevel.Other values are ignored.

context. lineWidth [ = value]




24/54

Returns the current line width.

Can be set, to change the line width.

Values that are not finite values greater than zero are ignored.

context.miterLimit [ = value]

Returns the current miter limit ratio.Can be set, to change the miter limit ratio.

Values that are not finite values greater than zero are ignored.

The lineCap attribute defines the type of endings that UAs will place on theend of lines. The three valid values are butt, round, and square. The buttvalue means that the end of each line has a flat edge perpendicular to thedirection of the line (and that no additional line cap is added). The round value

means that a semi-circle with the diameter equal to the width of the line mustthen be added on to the end of the line. The square value means that arectangle with the length of the line width and the width of half the line width,placed flat against the edge perpendicular to the direction of the line, must beadded at the end of each line. On setting, any other value than the literal stringsbutt, round, and square must be ignored, leaving the value unchanged.

When the context is created, the lineCap attribute must initially have thevalue butt.

The lineJoin attribute defines the type of corners that UAs will place where

two lines meet. The three valid values are bevel, round, and miter.

On setting, any other value than the literal strings bevel, round, and mitermust be ignored, leaving the value unchanged.

When the context is created, the lineJoin attribute must initially have thevalue miter.

A join exists at any point in a subpath shared by two consecutive lines. When asubpath is closed, then a join also exists at its first point (equivalent to its lastpoint) connecting the first and last lines in the subpath.

In addition to the point where the join occurs, two additional points are relevantto each join, one for each line: the two corners found half the line width awayfrom the join point, one perpendicular to each line, each on the side furthestfrom the other line.

A filled triangle connecting these two opposite corners with a straight line, withthe third point of the triangle being the join point, must be rendered at all joins.The lineJoin attribute controls whether anything else is rendered. The threeaforementioned values have the following meanings:

The bevel value means that this is all that is rendered at joins.The round value means that a filled arc connecting the twoaforementioned corners of the join, abutting (and not overlapping) the




25/54

aforementioned triangle, with the diameter equal to the line width and theorigin at the point of the join, must be rendered at joins.

The miter value means that a second filled triangle must (if possible,given the miter length) be rendered at the join, with one line being the linebetween the two aforementioned corners, abutting the first triangle, andthe other two being continuations of the outside edges of the two joininglines, as long as required to intersect without going over the miter length.

The miter length is the distance from the point where the join occurs to theintersection of the line edges on the outside of the join. The miter limit ratio isthe maximum allowed ratio of the miter length to half the line width. If the miterlength would cause the miter limit ratio to be exceeded, this second trianglemust not be rendered.

The miter limit ratio can be explicitly set using themiterLimit attribute. Onsetting, zero, negative, infinite, and NaN values must be ignored, leaving thevalue unchanged.

When the context is created, the miterLimit attribute must initially have thevalue 10.0.

The lineWidth attribute gives the width of lines, in coordinate space units. Onsetting, zero, negative, infinite, and NaN values must be ignored, leaving thevalue unchanged.

When the context is created, the lineWidth attribute must initially have thevalue 1.0.

3.6 Shadows

All drawing operations are affected by the four global shadow attributes.

context. shadowBlur [ = value]

Returns the current level of blur applied to shadows.

Can be set, to change the blur level. Values that are not finitenumbers greater than or equal to zero are ignored.

context. shadowColor [ = value]

Returns the current shadow color.

Can be set, to change the shadow color. Values that cannot beparsed as CSS colors are ignored.

context. shadowOffsetX [ = value]context. shadowOffsetY [ = value]

Returns the current shadow offset.




26/54

Can be set, to change the shadow offset. Values that are notfinite numbers are ignored.

The shadowBlur attribute specifies the size of the blurring effect. The units do

not map to coordinate space units and are not affected by the currenttransformation matrix.

When the context is created, the shadowBlur attribute must initially have thevalue 0.

On getting, the shadowBlurattribute must return its current value. On setting,the shadowBlurattribute must be set to the new value, except if the value isnegative, infinite or NaN, in which case the new value must be ignored.

The shadowColor attribute sets the color of the shadow.

When the context is created, the shadowColor attribute initially must be fully-transparent black.

On getting, the shadowColor attribute the serialization of the colormust bereturned.

On setting the shadowColor attribute, the new value must be parsed as aCSS value and the color assigned. If the value is not a valid color, thenit must be ignored, and the attribute must retain its previous value.[CSSCOLOR]

The shadowOffsetX and shadowOffsetY attributes specify the distancethat the shadow will be offset in the positive horizontal and positive verticaldistance respectively. Their values are in coordinate space units. They are notaffected by the current transformation matrix.

When the context is created, the shadow offset attributes must initially have thevalue 0.

On getting, the shadowOffsetX and shadowOffsetY attributes must returntheir current value. On setting, the attribute being set must be set to the newvalue, except if the value is infinite or NaN, in which case the new value must

be ignored.

Shadows are only drawn if the opacity component of the alpha component ofthe color ofshadowColor is non-zero and either the shadowBlur is non-zero, or the shadowOffsetX is non-zero, or the shadowOffsetY is non-zero.

When shadows are drawn, they must be rendered as follows:

Let A be the source image for which a shadow is being created.1.

Let Bbe an infinite transparent black bitmap, with a coordinate space and

an origin identical to A.

2.




27/54

Copy the alpha channel ofA to B, offset by shadowOffsetX in thepositive xdirection, and shadowOffsetY in the positive ydirection.

3.

IfshadowBlur is greater than 0:4.

IfshadowBlur is less than 8, let be half the value of

shadowBlur; otherwise, let be the square root of multiplying thevalue ofshadowBlur by 2.

1.

Perform a 2D Gaussian Blur on B, using as the standarddeviation.

2.

User agents may limit values ofto an implementation-specificmaximum value to avoid exceeding hardware limitations during theGaussian blur operation.

Set the red, green, and blue components of every pixel in Bto the red,green, and blue components (respectively) of the color ofshadowColor.

5.

Multiply the alpha component of every pixel in Bby the alpha componentof the color ofshadowColor.

6.

The shadow is in the bitmap B, and is rendered as part of the drawingmodel described below.

7.

3.7 Simple shapes (rectangles)

Three methods immediately draw rectangles to the bitmap. They each take fourarguments; the first two arguments give the xand ycoordinates of the top leftof the rectangle, and the second two arguments give the width wand height hof the rectangle, respectively.

The current transformation matrix must be applied to the following fourcoordinates, which form the path that must then be closed to get the specifiedrectangle: (x, y), (x+w, y), (x+w, y+h), (x, y+h).

Shapes are painted without affecting the current path. Shapes are subject tothe clipping region. With the exception ofclearRect(), shapes are also

subject to shadow effects, global alpha, and global composition operators.

context. clearRect(x, y, w, h)

Clears all pixels on the canvas in the given rectangle totransparent black.

context. fillRect(x, y, w, h)

Paints the given rectangle onto the canvas, using the current fillstyle.

context. strokeRect(x, y, w, h)




28/54

Paints the box that outlines the given rectangle onto the canvas,using the current stroke style.

The clearRect(x, y, w, h) method must clear the pixels in the specifiedrectangle that also intersect the current clipping region to a fully transparent

black, erasing any previous image. If either height or width are zero, thismethod has no effect.

The fillRect(x, y, w, h) method must paint the specified rectangulararea using the fillStyle. If either height or width are zero, this method hasno effect.

The strokeRect(x, y, w, h) method must must draw the outline of thespecified rectangle's path using the strokeStyle, lineWidth, lineJoin,and (if appropriate) miterLimit attributes. If both height and width are zero,this method has no effect, because there is no path to draw the stroke over (thepath is a point). If either height or width is zero, the method draws a straightstroke instead (the path for the outline is just a straight line along the non-zerodimension).

3.8 Complex shapes (paths)

The context always has a current path. There is only one current path, it is notpart of the drawing state.

A path has a list of zero or more subpaths. Each subpath consists of a list ofone or more points, connected by straight or curved lines, and a flag indicatingwhether the subpath is closed or not. A closed subpath is one where the lastpoint of the subpath is connected to the first point of the subpath by a straightline. Subpaths with fewer than two points are ignored when painting the path.

context. arc(x, y, radius, startAngle, endAngle, anticlockwise)

Adds points to the subpath such that the arc described by thecircumference of the circle described by the argumentsstarting

at the given start angle, ending at the given end angle, and goingin the given directionis added to the path, connected to theprevious point by a straight line.

If the given radius is negative, throws an INDEX_SIZE_ERRexception .

context. arcTo(x1, y1, x2, y2, radius)

Adds a point to the current path, connected to the previous oneby a straight line, then adds a second point to the current path,connected to the previous one by an arc whose properties are

described by the arguments.If the given radius is negative, throws an INDEX_SIZE_ERRexception .




29/54

context.beginPath()

Resets the current path.

context.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y)

Adds the given point to the current path, connected to theprevious one by a cubic Bzier curve with the given controlpoints.

context. clip()

Further constrains the clipping region to the given path.

context. closePath()

Marks the current subpath as closed, and starts a new subpathwith a point the same as the start and end of the newly closedsubpath.

context. fill()

Fills the subpaths with the current fill style.

context. lineTo(x, y)

Adds the given point to the current subpath, connected to theprevious point by a straight line.

context.moveTo(x, y)

Creates a new subpath with the given point as its first (and only)point.

context. quadraticCurveTo(cpx, cpy, x, y)

Adds the given point to the current path, connected to theprevious one by a quadratic Bzier curve with the given controlpoint.

context. rect(x, y, w, h)

Adds a new closed subpath to the path, representing the givenrectangle.

context. stroke()

Creates the strokes of the subpaths with the current stroke style.

context. isPointInPath(x, y)

Returns true if the given point is in the current path.

Initially, the context's path must have zero subpaths.

The points and lines added to the path by these methods must be transformedaccording to the current transformation matrix as they are added.




30/54

ThebeginPath() method must empty the list of subpaths so that the contextonce again has zero subpaths.

ThemoveTo(x, y) method must create a new subpath with the specifiedpoint as its first (and only) point.

When the user agent is to ensure there is a subpath for a coordinate (x, y),the user agent must check to see if the context has any subpaths, and if it doesnot, then the user agent must create a new subpath with the point (x, y) as itsfirst (and only) point, as if the moveTo() method had been called.

The closePath() method must do nothing if the context has no subpaths.Otherwise, it must mark the last subpath as closed, create a new subpathwhose first point is the same as the previous subpath's first point, and finallyadd this new subpath to the path.

Note: If the last subpath had more than one point in its list of

points, then this is equivalent to adding a straight lineconnecting the last point back to the first point, thus "closing"the shape, and then repeating the last (possibly implied)moveTo

() call.

New points and the lines connecting them are added to subpaths by using thearc(), arcTo(), bezierCurveTo(), lineTo(), orquadraticCurveTo()methods, described below. In all cases, the methods only modify the lastsubpath in the context's paths.

The lineTo(x, y) method must ensure there is a subpath for (x, y) if the

context has no subpaths. Otherwise, the method must connect the last point inthe subpath to the given point (x, y) using a straight line, and must then add thegiven point (x, y) to the subpath.

The quadraticCurveTo(cpx, cpy, x, y) method must ensure there is asubpath for (cpx, cpy), connect the last point in the subpath to the given point(x, y) by using a quadratic Bzier curve with control point (cpx, cpy), and thenmust then add the given point (x, y) to the subpath. [BEZIER]

ThebezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) method mustensure there is a subpath for (cp1x, cp1y), connect the last point in the subpath

to the given point (x, y) by using a cubic Bzier curve with control points(cp1x, cp1y) and (cp2x, cp2y), and then must add the point (x, y) to thesubpath. [BEZIER]

The arcTo(x1, y1, x2, y2, radius) method must first ensure there is asubpath for (x1, y1). Then, the behavior depends on the arguments and the lastpoint in the subpath, as described below.

Let the point (x0, y0) be the last point in the subpath.

If the point (x0, y0) is equal to the point (x1, y1), or if the point (x1, y1) isequal to the point (x2, y2), or if the radius radiusis zero, then the methodmust add the point (x1, y1) to the subpath, and connect that point to theprevious point (x0, y0) by a straight line.




31/54

Otherwise, if the points (x0, y0), (x1, y1), and (x2, y2) all lie on a singlestraight line, then the method must add the point (x1, y1) to the subpath,and connect that point to the previous point (x0, y0) by a straight line.

Otherwise, let The Arcbe the shortest arc given by circumference of thecircle that has radius radius, and that has one point tangent to the half-infinite line that crosses the point (x0, y0) and ends at the point (x1, y1),and that has a different point tangent to the half-infinite line that ends atthe point (x1, y1) and crosses the point (x2, y2). The points at which thiscircle touches these two lines are called the start and end tangent pointsrespectively. The method must connect the point (x0, y0) to the starttangent point by a straight line, adding the start tangent point to thesubpath, and then must connect the start tangent point to the end tangentpoint by The Arc, adding the end tangent point to the subpath.

If the value forradiusis a negative number, the implementation must raise anINDEX_SIZE_ERR exception.

The arc(x, y, radius, startAngle, endAngle, anticlockwise)method draws an arc. If the context has any subpaths, then the method mustadd a straight line from the last point in the subpath to the start point of the arc.In any case, the arc() method must draw the arc between the start point ofthe arc and the end point of the arc, and add the start and end points of the arcto the subpath. The arc and its start and end points are defined as follows:

Consider a circle that has its origin at (x, y) and that has radius radius.The points at startAngleand endAnglealong this circle's circumferencemeasured in radians clockwise from the positive x-axisare the start and

end points, respectively.

If the anticlockwiseargument is false and endAngle-startAngleis equal toor greater than 2, or, if the anticlockwiseargument is trueandstartAngle-endAngleis equal to or greater than 2, then the arc is thewhole circumference of this circle.

Otherwise, the arc is the path along the circumference of this circle fromthe start point to the end point, going anti-clockwise if the anticlockwiseargument is true, and clockwise if the anticlockwiseargument is false.Because the points are on the circle, as opposed to being simply angles

from zero, the arc can never cover an angle greater than 2 radians. Ifthe two points are the same, or if the radius is zero, then the arc isdefined as being of zero length in both directions. [GRAPHICS]

If the value forradiusis a negative number, the implementation must raise anINDEX_SIZE_ERR exception.

The rect(x, y, w, h) method must create a new subpath containing justthe four points: (x, y), (x+w, y), (x+w, y+h), (x, y+h). Those four points must beconnected by straight lines, and the rect() method must then mark the

subpath as closed. The method must then create a new subpath with the point(x, y) as the only point in the subpath.




32/54

The fill() method must fill all the subpaths of the current path, by using thefillStyle method, and by using the non-zero winding number rule. Opensubpaths must be implicitly closed when being filled (without affecting theactual subpaths).

Note: Thus, if two overlapping but otherwise independent

subpaths have opposite windings, they cancel out and result inno fill. If the overlapping but otherwise independent subpathshave the same winding, that area just gets painted once.

The stroke() method must calculate the strokes of all the subpaths of thecurrent path, by using the lineWidth, lineCap, lineJoin, and (ifappropriate) miterLimit attributes, and then must fill the combined strokearea by using the strokeStyle attribute.

Note: Because the subpaths are drawn as one stroke,

overlapping parts of the paths in one stroke operation are treatedas if their union was what was painted.

Paths, when filled or drawn with strokes, must be painted without affecting thecurrent path, and must be subject to shadow effects, global alpha, the clippingregion, and global composition operators. (Transformations affect the pathwhen the path is created, not when it is painted, though the stroke styleis stillaffected by the transformation during painting.)

Zero-length line segments must be pruned before drawing a stroke for a path.Empty subpaths must be ignored.

The clip() method must create a new clipping region by calculating theintersection of the current clipping region and the area described by the currentpath, using the non-zero winding number rule. [GRAPHICS] Open subpathsmust be implicitly closed when computing the clipping region, without affectingthe actual subpaths. The new clipping region replaces the current clippingregion.

When the context is initialized, the clipping region must be set to the rectanglewith the top left corner at (0,0) and the width and height of the coordinatespace.

The isPointInPath(x, y) method must return true if the point given by thexand ycoordinates passed to the method, when treated as coordinates in thecanvas coordinate space unaffected by the current transformation, is inside thecurrent path as determined by the non-zero winding number rule; and mustreturn false otherwise. Points on the path itself are considered to be inside thepath. If either of the arguments is infinite or NaN, then the method must returnfalse.




33/54

3.9 Text

context. font [ = value]

Returns the current font settings.

Can be set, to change the font. The syntax is the same as for theCSS 'font' property; values that cannot be parsed as CSS fontvalues are ignored.

Relative keywords and lengths are computed relative to the fontof the canvas interface element.

context. textAlign [ = value]

Returns the current text alignment settings.

Can be set, to change the alignment. The possible values arestart, end, left, right, and center. The default is start.

Other values are ignored.

context. textBaseline [ = value]

Returns the current baseline alignment settings.

Can be set, to change the baseline alignment. The possiblevalues are top, hanging, middle, alphabetic,ideographic, and bottom. The default is alphabetic. Othervalues are ignored.

context. fillText(text, x, y[, maxWidth] )

Renders fill for the given text at the given position. If a maximumwidth is provided, the text is scaled to fit that width if necessary.

context. strokeText(text, x, y[, maxWidth] )

Renders strokes for the given text at the given position. If amaximum width is provided, the text is scaled to fit that width ifnecessary.

metrics= context.measureText(text)

Returns a TextMetrics object with the metrics of the given textin the current font.

metrics. width

Returns the advance width of the text that was passed to themeasureText()method.

The font DOM attribute, on setting, must be parsed the same way as the 'font'property of CSS (but without supporting property-independent stylesheet

syntax like 'inherit'), and the resulting font must be assigned to the context. The'line-height' component must be forced to 'normal', the 'font-size' componentconverted to CSS pixels, and system fonts computed to explicit values. If the




34/54

new value is syntactically incorrect (including using property-independentstylesheet syntax like 'inherit' or 'initial'), then the value must be ignored,without assigning a new font value. [CSS]

Font names must be interpreted in the context of the canvas interfaceelement's stylesheets; any fonts embedded using @font-face must thereforebe available once they are loaded. (If a font is referenced before it is fullyloaded, then it must be treated as if it is an unknown font, falling back toanother as described by the relevant CSS specifications.) [CSSFONTS]

Only vector fonts should be used by the user agent; if a user agent were to usebitmap fonts then transformations would likely have adverse affect on the font.

On getting, the font attribute must return the serialized form of the current fontof the context (with no 'line-height' component). [CSSOM]

For example, after the following statement:

context.font = 'italic 400 12px/2 Unknown Font,sans-serif';

...the expression context.font evaluates to the string"italic 12px "Unknown Font", sans-serif". The "400"font-weight does not appear, because that is the default value; the line-height does not appear because it is forced to "normal", the defaultvalue.

When the context is created, the font of the context must be set to 10px sans-serif. When the 'font-size' component is set to lengths using percentages, 'em'

or 'ex' units, or the 'larger' or 'smaller' keywords, these must be interpretedrelative to the computed value of the 'font-size' property of the correspondingcanvas interface element at the time that the attribute is set. When the 'font-weight' component is set to the relative values 'bolder' and 'lighter', these mustbe interpreted relative to the computed value of the 'font-weight' property of thecorresponding canvas interface element at the time that the attribute is set. Ifthe computed values are undefined for a particular case (because the canvasinterface element is not in a Document, for instance), then the relativekeywords must be interpreted relative to the normal-weight 10px sans-serifdefault.

When the context is created, the textAlign attribute must initially have thevalue start. On getting, the textAlign DOM attribute must return thecurrent value. On setting, if the value is one ofstart, end, left, right, orcenter, then the value of the textAlign attribute must be changed to thenew value. Otherwise, the new value must be ignored.

When the context is created, the textBaseline attribute must initially havethe value alphabetic. On getting, the textBaseline DOM attribute mustreturn the current value. On setting, if the value is one oftop, hanging,middle, alphabetic, ideographic, orbottom, then the value of thetextBaseline must be changed to the new value. Otherwise, the new value

must be ignored.




35/54

The textBaseline attribute's allowed keywords correspond to alignmentpoints in the font:

The keywords map to these alignment points as follows:

topThe top of the em square

hangingThe hanging baseline

middle

The middle of the em square

alphabeticThe alphabetic baseline

ideographic

The ideographic baselinebottom

The bottom of the em square

The fillText() and strokeText() methods take three (or four)arguments: text, x, y, and (optionally) maxWidth. These methods render thegiven textat the given (x, y) coordinates (ensuring that the text isn't wider thanmaxWidthif specified). The fillText() and strokeText() methods use

the current font, textAlign, and textBaseline values. Specifically, whenthe methods are called, the user agent must run the following steps:

Let fontbe the current font of the context, as given by the font attribute.1.

Replace all the space characters in textwith U+0020 SPACE characters.2.

Form a hypothetical infinitely wide CSS line box containing a single inlinebox containing the text text. Set all the properties of the inline box at theirinitial values except the 'font' property of the inline box set to fontand the'direction' property of the inline box set to the directionality of the canvas

interface element. [CSS]

3.




36/54

If the maxWidthargument was specified and the hypothetical width of theinline box in the hypothetical line box is greater than maxWidthCSSpixels, then change fontto have a more condensed font (if one isavailable or if a reasonably readable one can be synthesized by applyinga horizontal scale factor to the font) or a smaller font, and return to theprevious step.

4.

Let the anchor pointbe a point on the inline box, determined by thetextAlign and textBaseline values, as follows:

5.

Horizontal position:

If textAlign is left, or

If textAlign is start and the directionality of the canvas interfaceelement is 'ltr', orIf textAlign is end and the directionality of the canvas interfaceelement is 'rtl', then

Let the anchor point's horizontal position be the left edge of theinline box.

If textAlign is right, or

If textAlign is end and the directionality of the canvas interfaceelement is 'ltr', orIf textAlign is start and the directionality of the canvas interfaceelement is 'rtl', then

Let the anchor point's horizontal position be the right edge of theinline box.

If textAlign is center, then

Let the anchor point's horizontal position be half way between theleft and right edges of the inline box.

Vertical position:

If textBaseline is top, thenLet the anchor point's vertical position be the top of the em box ofthe first available font of the inline box.

If textBaseline is hanging, thenLet the anchor point's vertical position be the hanging baseline ofthe first available font of the inline box.

If textBaseline ismiddle, thenLet the anchor point's vertical position be half way between thebottom and the top of the em box of the first available font of theinline box.

If textBaseline is alphabetic, then

Let the anchor point's vertical position be the alphabetic baseline ofthe first available font of the inline box.

If textBaseline is ideographic, then

Let the anchor point's vertical position be the ideographic baselineof the first available font of the inline box.

If textBaseline isbottom, then

Let the anchor point's vertical position be the bottom of the em boxof the first available font of the inline box.




37/54

Paint the hypothetical inline box as the shape given by the text's glyphs,as transformed by the current transformation matrix, and anchored andsized so that before applying the current transformation matrix, theanchor pointis at (x, y) and each CSS pixel is mapped to one coordinatespace unit.

6.

For the fillText() method, the fillStyle attribute must be appliedto the glyphs and the strokeStyle attribute must be ignored. ForstrokeText() the reverse holds: strokeStyle must be applied to theglyph outlines and fillStyle must be ignored.

Text is painted without affecting the current path and is subject to shadoweffects, global alpha, the clipping region, and global compositionoperators.

ThemeasureText() method takes one argument, text. When the method isinvoked, the user agent must replace all the space characters in textwithU+0020 SPACE characters. The user agent must then form a hypotheticalinfinitely wide CSS line box containing a single inline box containing the texttext, with all the properties at their initial values except the 'font' property of theinline element set to the current font of the context, as given by the fontattribute. The user agent must then return a new TextMetrics object with itswidth attribute set to the width of that inline box, in CSS pixels. [CSS]

The TextMetrics interface is used for the objects returned frommeasureText(). It has one attribute, width, which is set by themeasureText() method.

Note: Glyphs rendered usingfillText() andstrokeText()can spill out of the box given by the font size (the em squaresize) and the width returned bymeasureText() (the text width).This version of the specification does not provide a way to obtainthe bounding box dimensions of the text. If the text is to berendered and removed, care needs to be taken to replace theentire area of the canvas that the clipping region covers, not justthe box given by the em square height and measured text width.

Note: A future version of the 2D context API may provide a way

to render fragments of documents, rendered using CSS, straightto the canvas. This would be provided in preference to adedicated way of doing multiline layout.

3.10 Images

To draw images onto the canvas, the drawImage method can be used.

This method can be invoked with three different sets of arguments:

drawImage(image, dx, dy)drawImage(image, dx, dy, dw, dh)




38/54

drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh)

Each of those three can take either an HTMLImageElement, anHTMLCanvasElement, or an HTMLVideoElement for the imageargument.

context. drawImage(image, dx, dy)context. drawImage(image, dx, dy, dw, dh)context. drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh)

Draws the given image onto the canvas. The arguments areinterpreted as follows:

If the first argument is not an img, canvas interface element, orvideo element, throws a TYPE_MISMATCH_ERR exception.

If the image is not fully decoded yet, or has no image data, throwsan INVALID_STATE_ERR exception.

If the second argument is not one of the allowed values, throws aSYNTAX_ERR exception.

The source rectangle is the rectangle whose corners are the four points (sx,sy), (sx+sw, sy), (sx+sw, sy+sh), (sx, sy+sh).

The destination rectangle is the rectangle whose corners are the four points(dx, dy), (dx+dw, dy), (dx+dw, dy+dh), (dx, dy+dh).

If not specified, the dwand dharguments must default to the values ofswandsh, interpreted such that one CSS pixel in the image is treated as one unit in

the canvas coordinate space. If the sx, sy, sw, and sharguments are omitted,they must default to 0, 0, the image's intrinsic width in image pixels, and theimage's intrinsic height in image pixels, respectively.




39/54

Images are painted without affecting the current path, and are subject toshadow effects, global alpha, the clipping region, and global compositionoperators.

When drawImage() is invoked, the region of the image specified by thesource rectangle must be painted on the region of the canvas specified by thedestination rectangle, after applying the current transformation matrix to thepoints of the destination rectangle.

The original image data of the source image must be used, not the image as itis rendered (for example, width and height attributes on the source elementhave no effect). The image data must be processed in the original direction,even if the dimensions given are negative.

Note: This specification does not define the algorithm to usewhen scaling the image, if necessary.

Note: When a canvas is drawn onto itself, the drawing modelrequires the source to be copied before the image is drawn backonto the canvas, so it is possible to copy parts of a canvas ontooverlapping parts of itself.

If the source rectangle is not entirely within the source image, or if one of thesworsharguments is zero, the implementation must raise anINDEX_SIZE_ERR exception.

The imageargument is an instance of eitherHTMLImageElement,

HTMLCanvasElement, orHTMLVideoElement. If the imageis of the wrongtype or null, the implementation must raise a TYPE_MISMATCH_ERR exception.

If the imageargument is an HTMLImageElement object whose completeattribute is false, then the implementation must raise an INVALID_STATE_ERRexception.

If the imageargument is an HTMLCanvasElement object with either ahorizontal dimension or a vertical dimension equal to zero, then theimplementation must raise an INVALID_STATE_ERR exception.

If the imageargument is an HTMLVideoElement object whose readyStateattribute is eitherHAVE_NOTHING orHAVE_METADATA, then theimplementation must raise an INVALID_STATE_ERR exception.

When the imageargument is an HTMLVideoElement, then the frame at thecurrent playback position must be used as the source image.

When the drawImage() method is passed an animated image as its imageargument, the user agent must use the poster frame of the animation, or, ifthere is no poster frame, the first frame of the animation.




40/54

3.11 Pixel manipulation

imagedata= context. createImageData(sw, sh)

Returns an ImageData object with the given dimensions in CSSpixels (Note that the CSS pixels might map to a different numberof actual device pixels exposed by the object itself). All the pixelsin the returned object are transparent black.

imagedata= context. createImageData(imagedata)

Returns an ImageData object with the same dimensions as theargument. All the pixels in the returned object are transparentblack.

If the argument is null, throws a NOT_SUPPORTED_ERRexception.

imagedata= context. getImageData(sx, sy, sw, sh)

Returns an ImageData object containing the image data for thegiven rectangle of the canvas.

If any of the arguments are not finite, throws aNOT_SUPPORTED_ERR exception.

If the either the width or height argument is zero, throws anINDEX_SIZE_ERR exception.

imagedata. data

Returns the one-dimensional array containing the data for theImageData object.

imagedata. height

Returns the actual dimensions of the data in the ImageDataobject, in device pixels.

imagedata. width

Returns the actual dimensions of the data in the ImageDataobject, in device pixels.

context.putImageData(imagedata, dx, dy[, dirtyX, dirtyY,

dirtyWidth, dirtyHeight])

Paints the data from the given ImageData object onto thecanvas. If a dirty rectangle is provided, only the pixels from thatrectangle are painted.

The globalAlpha and globalCompositeOperationattributes, as well as the shadow attributes, are ignored for thepurposes of this method call; pixels in the canvas are replacedwholesale, with no composition, alpha blending, shadows, etc.

If the first argument is not an ImageData object, throws aTYPE_MISMATCH_ERR exception.




41/54

If any numerical arguments are not finite, throws aNOT_SUPPORTED_ERR exception .

The createImageData()method is used to instantiate a new blank

ImageData object. When the method is invoked with two arguments swandsh, it must return an ImageData object representing a rectangle with a width inCSS pixels equal to the absolute magnitude ofswand a height in CSS pixelsequal to the absolute magnitude ofsh. When invoked with a single imagedataargument, it must return an ImageData object representing a rectangle withthe same dimensions as the ImageData object passed as the argument. TheImageData object return must be filled with transparent black.

The getImageData(sx, sy, sw, sh) method must return an ImageDataobject representing the underlying pixel data for the area of the canvas denotedby the rectangle whose corners are the four points (sx, sy), (sx+sw, sy),

(sx+sw, sy+sh), (sx, sy+sh), in canvas coordinate space units. Pixels outsidethe canvas must be returned as transparent black. Pixels must be returned asalpha values that have not been premultiplied.

If any of the arguments to createImageData() orgetImageData() areinfinite or NaN, or if the createImageData()method is invoked with only oneargument but that argument is null, the method must instead raise aNOT_SUPPORTED_ERR exception. If either the sworsharguments are zero,the method must instead raise an INDEX_SIZE_ERR exception.

ImageData objects must be initialized so that theirwidth attribute is set to w,

the number of physical device pixels per row in the image data, theirheightattribute is set to h, the number of rows in the image data, and theirdataattribute is initialized to a CanvasPixelArray object holding the image data.At least one pixel's worth of image data must be returned.

The CanvasPixelArray object provides ordered, indexed access to the colorcomponents of each pixel of the image data. The data must be represented inleft-to-right order, row by row top to bottom, starting with the top left, with eachpixel's red, green, bl

html5 canvas 2d

Documents