#Module canvas

Canvas 2D (HTML §4.12.5): the 2D rendering context of <canvas> and OffscreenCanvas, drawn by a software rasterizer (package canvas2d) into a premultiplied RGBA8 bitmap that the shell shows as a texture, updated only when the drawing changed. Members shared by CanvasRenderingContext2D and OffscreenCanvasRenderingContext2D are one function imported under their mixin's name (CanvasState_save...); those of CanvasPath work on a context's current path or on a Path2D alike (CanvasPathTarget). Arguments that are NaN or infinite make a drawing or path call do nothing (the specification's rule); an enum given an invalid string leaves the attribute as it was.

• colors are CSS color strings, parsed by the browser's CSS parser (currentcolor is the canvas element's color); fillStyle / strokeStyle read back as #rrggbb or rgba(r, g, b, a);
• pixel data (ImageData) is straight-alpha RGBA8, rows top to bottom;
• a canvas that drew an image the page may not read (cross-origin without CORS) is tainted: reading it back (getImageData, toDataURL, toBlob...) raises Security;
• workers have OffscreenCanvas (drawn in the worker's thread; its text is not drawn yet: the shell's fonts belong to the interface thread); functions taking an element answer as for a dead handle there.

Exposed to: Window, Worker. Source: api/canvas.widl.

Odin: import "wren:canvas".

#Types

#handle HTMLCanvasElement : Element

Checked by the browser on every call (lookup_HTMLCanvasElement).

#handle CanvasRenderingContext2D : Object

A CanvasRenderingContext2D or an OffscreenCanvasRenderingContext2D.

Checked by the browser on every call (lookup_CanvasRenderingContext2D).

#handle CanvasPathTarget : Object

The target of the CanvasPath members: a context (its current path) or a Path2D.

Checked by the browser on every call (lookup_CanvasPathTarget).

#handle CanvasGradient : Object

Checked by the browser on every call (lookup_CanvasGradient).

#handle CanvasPattern : Object

Checked by the browser on every call (lookup_CanvasPattern).

#handle Path2D : Object

Checked by the browser on every call (lookup_Path2D).

#handle TextMetrics : Object

Checked by the browser on every call (lookup_TextMetrics).

#handle OffscreenCanvas : Object

Checked by the browser on every call (lookup_OffscreenCanvas).

#handle ImageBitmap : Object

Checked by the browser on every call (lookup_ImageBitmap).

#handle ImageBitmapRenderingContext : Object

Checked by the browser on every call (lookup_ImageBitmapRenderingContext).

#enum StyleKind : i32

What a fill or stroke style currently is.

#Functions

#HTMLCanvasElement_width

u32 HTMLCanvasElement_width(HTMLCanvasElement canvas)

///////////////////////////// canvas.width: the width attribute as HTML parses it (a non-negative integer, 300 when absent or invalid).

Host: HTMLCanvasElement_width :: proc(c: ^Call, canvas: Api_HTMLCanvasElement) -> u32

#HTMLCanvasElement_set_width

void HTMLCanvasElement_set_width(HTMLCanvasElement canvas, u32 value)

canvas.width = n: sets the attribute and resets the canvas (cleared, context state back to the default).

Host: HTMLCanvasElement_set_width :: proc(c: ^Call, canvas: Api_HTMLCanvasElement, value: u32)

#HTMLCanvasElement_height

u32 HTMLCanvasElement_height(HTMLCanvasElement canvas)

canvas.height: 150 when absent or invalid.

Host: HTMLCanvasElement_height :: proc(c: ^Call, canvas: Api_HTMLCanvasElement) -> u32

#HTMLCanvasElement_set_height

void HTMLCanvasElement_set_height(HTMLCanvasElement canvas, u32 value)

Host: HTMLCanvasElement_set_height :: proc(c: ^Call, canvas: Api_HTMLCanvasElement, value: u32)

#HTMLCanvasElement_context2d

CanvasRenderingContext2D HTMLCanvasElement_context2d(HTMLCanvasElement canvas, bool alpha, bool will_read_frequently) raises

getContext("2d", { alpha, willReadFrequently }): the canvas's 2D context, made on the first call (the bitmap is allocated then) and the same object afterwards. alpha false: an opaque canvas (black until drawn on). Quota when the size is over canvas.max_dimension / canvas.max_pixels or the page's canvas memory (canvas.max_page_bytes).

Raises: returns an Error (see web).

Host: HTMLCanvasElement_context2d :: proc(c: ^Call, canvas: Api_HTMLCanvasElement, alpha: bool, will_read_frequently: bool) -> (u64, Api_Error)

#Canvas_encode

Buffer Canvas_encode(u64 canvas, string type, f64 quality) raises

The canvas (an element, or an OffscreenCanvas handle) encoded as type: "image/png", or "image/jpeg" at quality (0 to 1; outside it the default, canvas.encode.jpeg_quality). Security when the canvas is tainted. An empty buffer for a canvas with no pixels (width or height 0).

Odin: canvas.encode.

Raises: returns an Error (see web).

Host: Canvas_encode :: proc(c: ^Call, canvas: u64, type: string, quality: f64) -> (u64, Api_Error)

#CanvasRenderingContext2D_canvas

HTMLCanvasElement CanvasRenderingContext2D_canvas(CanvasRenderingContext2D ctx)

///////////////////////////// context.canvas

Host: CanvasRenderingContext2D_canvas :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> u64

#OffscreenCanvasRenderingContext2D_canvas

OffscreenCanvas OffscreenCanvasRenderingContext2D_canvas(CanvasRenderingContext2D ctx)

OffscreenCanvasRenderingContext2D.canvas

Host: OffscreenCanvasRenderingContext2D_canvas :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> u64

#CanvasSettings_alpha

bool CanvasSettings_alpha(CanvasRenderingContext2D ctx)

getContextAttributes().alpha / .willReadFrequently

Host: CanvasSettings_alpha :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> bool

#CanvasSettings_willReadFrequently

bool CanvasSettings_willReadFrequently(CanvasRenderingContext2D ctx)

Host: CanvasSettings_willReadFrequently :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> bool

#CanvasState_save

void CanvasState_save(CanvasRenderingContext2D ctx)

save(): ignored once canvas.max_save_depth states are saved.

Host: CanvasState_save :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D)

#CanvasState_restore

void CanvasState_restore(CanvasRenderingContext2D ctx)

Host: CanvasState_restore :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D)

#CanvasState_reset

void CanvasState_reset(CanvasRenderingContext2D ctx)

reset(): clears the canvas and puts every attribute back.

Host: CanvasState_reset :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D)

#CanvasState_isContextLost

bool CanvasState_isContextLost(CanvasRenderingContext2D ctx)

Always false: the software canvas is not lost.

Host: CanvasState_isContextLost :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> bool

#CanvasTransform_scale

void CanvasTransform_scale(CanvasRenderingContext2D ctx, f64 x, f64 y)

Host: CanvasTransform_scale :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x: f64, y: f64)

#CanvasTransform_rotate

void CanvasTransform_rotate(CanvasRenderingContext2D ctx, f64 angle)

Host: CanvasTransform_rotate :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, angle: f64)

#CanvasTransform_translate

void CanvasTransform_translate(CanvasRenderingContext2D ctx, f64 x, f64 y)

Host: CanvasTransform_translate :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x: f64, y: f64)

#CanvasTransform_transform

void CanvasTransform_transform(CanvasRenderingContext2D ctx, f64 m11, f64 m12, f64 m21, f64 m22, f64 m41, f64 m42)

Host: CanvasTransform_transform :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, m11: f64, m12: f64, m21: f64, m22: f64, m41: f64, m42: f64)

#CanvasTransform_setTransform

void CanvasTransform_setTransform(CanvasRenderingContext2D ctx, f64 m11, f64 m12, f64 m21, f64 m22, f64 m41, f64 m42)

Host: CanvasTransform_setTransform :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, m11: f64, m12: f64, m21: f64, m22: f64, m41: f64, m42: f64)

#CanvasTransform_resetTransform

void CanvasTransform_resetTransform(CanvasRenderingContext2D ctx)

Host: CanvasTransform_resetTransform :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D)

#CanvasTransform_matrixElement

f64 CanvasTransform_matrixElement(CanvasRenderingContext2D ctx, i32 index)

One element of the current transform: 0 to 5 are a, b, c, d, e, f.

Host: CanvasTransform_matrixElement :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, index: i32) -> f64

#CanvasCompositing_globalAlpha

f64 CanvasCompositing_globalAlpha(CanvasRenderingContext2D ctx)

Host: CanvasCompositing_globalAlpha :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> f64

#CanvasCompositing_set_globalAlpha

void CanvasCompositing_set_globalAlpha(CanvasRenderingContext2D ctx, f64 value)

Outside 0 to 1, or NaN: ignored.

Host: CanvasCompositing_set_globalAlpha :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: f64)

#CanvasCompositing_globalCompositeOperation

string CanvasCompositing_globalCompositeOperation(CanvasRenderingContext2D ctx)

Host: CanvasCompositing_globalCompositeOperation :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasCompositing_set_globalCompositeOperation

void CanvasCompositing_set_globalCompositeOperation(CanvasRenderingContext2D ctx, string value)

source-over, source-in, source-out, source-atop, destination-over / -in / -out / -atop, lighter, copy, xor, and the blend modes multiply, screen, overlay, darken, lighten, color-dodge, color-burn, hard-light, soft-light, difference, exclusion, hue, saturation, color, luminosity. Anything else is ignored.

Host: CanvasCompositing_set_globalCompositeOperation :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasImageSmoothing_imageSmoothingEnabled

bool CanvasImageSmoothing_imageSmoothingEnabled(CanvasRenderingContext2D ctx)

Host: CanvasImageSmoothing_imageSmoothingEnabled :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> bool

#CanvasImageSmoothing_set_imageSmoothingEnabled

void CanvasImageSmoothing_set_imageSmoothingEnabled(CanvasRenderingContext2D ctx, bool value)

Host: CanvasImageSmoothing_set_imageSmoothingEnabled :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: bool)

#CanvasImageSmoothing_imageSmoothingQuality

string CanvasImageSmoothing_imageSmoothingQuality(CanvasRenderingContext2D ctx)

Host: CanvasImageSmoothing_imageSmoothingQuality :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasImageSmoothing_set_imageSmoothingQuality

void CanvasImageSmoothing_set_imageSmoothingQuality(CanvasRenderingContext2D ctx, string value)

Host: CanvasImageSmoothing_set_imageSmoothingQuality :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasStyle_kind

StyleKind CanvasStyle_kind(CanvasRenderingContext2D ctx, bool stroke)

Which kind of style fillStyle (stroke false) or strokeStyle currently is.

Host: CanvasStyle_kind :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, stroke: bool) -> Api_StyleKind

#CanvasStyle_color

string CanvasStyle_color(CanvasRenderingContext2D ctx, bool stroke)

The color style as #rrggbb or rgba(...).

Host: CanvasStyle_color :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, stroke: bool) -> string

#CanvasStyle_object

u64 CanvasStyle_object(CanvasRenderingContext2D ctx, bool stroke)

The script object of a gradient or pattern style: the one it was set from while that is alive, else a new one the caller owns (0 for a color style).

Host: CanvasStyle_object :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, stroke: bool) -> u64

#CanvasStyle_setColor

bool CanvasStyle_setColor(CanvasRenderingContext2D ctx, bool stroke, string color)

fillStyle = "color": false (and nothing changes) when it is not a color.

Host: CanvasStyle_setColor :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, stroke: bool, color: string) -> bool

#CanvasStyle_setObject

void CanvasStyle_setObject(CanvasRenderingContext2D ctx, bool stroke, u64 object)

fillStyle = gradient or pattern object.

Host: CanvasStyle_setObject :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, stroke: bool, object: u64)

#CanvasFillStrokeStyles_createLinearGradient

CanvasGradient CanvasFillStrokeStyles_createLinearGradient(CanvasRenderingContext2D ctx, f64 x0, f64 y0, f64 x1, f64 y1)

createLinearGradient (the arguments are finite: the binding refuses others).

Host: CanvasFillStrokeStyles_createLinearGradient :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x0: f64, y0: f64, x1: f64, y1: f64) -> u64

#CanvasFillStrokeStyles_createRadialGradient

CanvasGradient CanvasFillStrokeStyles_createRadialGradient(CanvasRenderingContext2D ctx, f64 x0, f64 y0, f64 r0, f64 x1, f64 y1, f64 r1) raises

createRadialGradient: a negative radius raises Index_Size.

Raises: returns an Error (see web).

Host: CanvasFillStrokeStyles_createRadialGradient :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x0: f64, y0: f64, r0: f64, x1: f64, y1: f64, r1: f64) -> (u64, Api_Error)

#CanvasFillStrokeStyles_createConicGradient

CanvasGradient CanvasFillStrokeStyles_createConicGradient(CanvasRenderingContext2D ctx, f64 start_angle, f64 x, f64 y)

Host: CanvasFillStrokeStyles_createConicGradient :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, start_angle: f64, x: f64, y: f64) -> u64

#Canvas_createPattern

CanvasPattern Canvas_createPattern(CanvasRenderingContext2D ctx, u64 source, string repetition) raises

createPattern(image, repetition): source is an element handle (img, canvas) or an object handle (ImageBitmap, OffscreenCanvas); repetition "repeat", "repeat-x", "repeat-y", "no-repeat". Not_Found: no pattern (an image that is not available yet); Syntax: bad repetition; Invalid_State: a canvas with no pixels.

Odin: canvas.createPattern.

Raises: returns an Error (see web).

Host: Canvas_createPattern :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, source: u64, repetition: string) -> (u64, Api_Error)

#CanvasGradient_addColorStop

void CanvasGradient_addColorStop(CanvasGradient gradient, f64 offset, string color) raises

addColorStop(offset, color): Index_Size outside 0 to 1, Syntax for a color that does not parse.

Raises: returns an Error (see web).

Host: CanvasGradient_addColorStop :: proc(c: ^Call, gradient: Api_CanvasGradient, offset: f64, color: string) -> Api_Error

#CanvasPattern_setTransformMatrix

void CanvasPattern_setTransformMatrix(CanvasPattern pattern, f64 m11, f64 m12, f64 m21, f64 m22, f64 m41, f64 m42)

pattern.setTransform(matrix): the six elements a b c d e f as m11 m12 m21 m22 m41 m42.

Host: CanvasPattern_setTransformMatrix :: proc(c: ^Call, pattern: Api_CanvasPattern, m11: f64, m12: f64, m21: f64, m22: f64, m41: f64, m42: f64)

#CanvasShadowStyles_shadowOffsetX

f64 CanvasShadowStyles_shadowOffsetX(CanvasRenderingContext2D ctx)

Host: CanvasShadowStyles_shadowOffsetX :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> f64

#CanvasShadowStyles_set_shadowOffsetX

void CanvasShadowStyles_set_shadowOffsetX(CanvasRenderingContext2D ctx, f64 value)

Host: CanvasShadowStyles_set_shadowOffsetX :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: f64)

#CanvasShadowStyles_shadowOffsetY

f64 CanvasShadowStyles_shadowOffsetY(CanvasRenderingContext2D ctx)

Host: CanvasShadowStyles_shadowOffsetY :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> f64

#CanvasShadowStyles_set_shadowOffsetY

void CanvasShadowStyles_set_shadowOffsetY(CanvasRenderingContext2D ctx, f64 value)

Host: CanvasShadowStyles_set_shadowOffsetY :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: f64)

#CanvasShadowStyles_shadowBlur

f64 CanvasShadowStyles_shadowBlur(CanvasRenderingContext2D ctx)

Host: CanvasShadowStyles_shadowBlur :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> f64

#CanvasShadowStyles_set_shadowBlur

void CanvasShadowStyles_set_shadowBlur(CanvasRenderingContext2D ctx, f64 value)

Negative or non-finite: ignored.

Host: CanvasShadowStyles_set_shadowBlur :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: f64)

#CanvasShadowStyles_shadowColor

string CanvasShadowStyles_shadowColor(CanvasRenderingContext2D ctx)

Host: CanvasShadowStyles_shadowColor :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasShadowStyles_set_shadowColor

void CanvasShadowStyles_set_shadowColor(CanvasRenderingContext2D ctx, string value)

Host: CanvasShadowStyles_set_shadowColor :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasFilters_filter

string CanvasFilters_filter(CanvasRenderingContext2D ctx)

Host: CanvasFilters_filter :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasFilters_set_filter

void CanvasFilters_set_filter(CanvasRenderingContext2D ctx, string value)

"none" or a list of CSS filter functions (blur, brightness, contrast, grayscale, hue-rotate, invert, opacity, saturate, sepia, drop-shadow); anything that does not parse is ignored.

Host: CanvasFilters_set_filter :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasRect_clearRect

void CanvasRect_clearRect(CanvasRenderingContext2D ctx, f64 x, f64 y, f64 w, f64 h)

Host: CanvasRect_clearRect :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x: f64, y: f64, w: f64, h: f64)

#CanvasRect_fillRect

void CanvasRect_fillRect(CanvasRenderingContext2D ctx, f64 x, f64 y, f64 w, f64 h)

Host: CanvasRect_fillRect :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x: f64, y: f64, w: f64, h: f64)

#CanvasRect_strokeRect

void CanvasRect_strokeRect(CanvasRenderingContext2D ctx, f64 x, f64 y, f64 w, f64 h)

Host: CanvasRect_strokeRect :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x: f64, y: f64, w: f64, h: f64)

#CanvasDrawPath_beginPath

void CanvasDrawPath_beginPath(CanvasRenderingContext2D ctx)

Host: CanvasDrawPath_beginPath :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D)

#CanvasDrawPath_fill

void CanvasDrawPath_fill(CanvasRenderingContext2D ctx, u64 path, string rule)

fill(path?, rule): path is a Path2D handle, 0 for the current path; rule "nonzero" or "evenodd".

Host: CanvasDrawPath_fill :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, path: u64, rule: string)

#CanvasDrawPath_stroke

void CanvasDrawPath_stroke(CanvasRenderingContext2D ctx, u64 path)

Host: CanvasDrawPath_stroke :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, path: u64)

#CanvasDrawPath_clip

void CanvasDrawPath_clip(CanvasRenderingContext2D ctx, u64 path, string rule)

Host: CanvasDrawPath_clip :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, path: u64, rule: string)

#CanvasDrawPath_isPointInPath

bool CanvasDrawPath_isPointInPath(CanvasRenderingContext2D ctx, u64 path, f64 x, f64 y, string rule)

Host: CanvasDrawPath_isPointInPath :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, path: u64, x: f64, y: f64, rule: string) -> bool

#CanvasDrawPath_isPointInStroke

bool CanvasDrawPath_isPointInStroke(CanvasRenderingContext2D ctx, u64 path, f64 x, f64 y)

Host: CanvasDrawPath_isPointInStroke :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, path: u64, x: f64, y: f64) -> bool

#CanvasText_fillText

void CanvasText_fillText(CanvasRenderingContext2D ctx, string text, f64 x, f64 y, f64 max_width, bool has_max)

fillText(text, x, y, maxWidth): has_max false when maxWidth was not given.

Host: CanvasText_fillText :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, text: string, x: f64, y: f64, max_width: f64, has_max: bool)

#CanvasText_strokeText

void CanvasText_strokeText(CanvasRenderingContext2D ctx, string text, f64 x, f64 y, f64 max_width, bool has_max)

Host: CanvasText_strokeText :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, text: string, x: f64, y: f64, max_width: f64, has_max: bool)

#CanvasText_measureText

TextMetrics CanvasText_measureText(CanvasRenderingContext2D ctx, string text)

Host: CanvasText_measureText :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, text: string) -> u64

#TextMetrics_width

f64 TextMetrics_width(TextMetrics m)

Host: TextMetrics_width :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_actualBoundingBoxLeft

f64 TextMetrics_actualBoundingBoxLeft(TextMetrics m)

Host: TextMetrics_actualBoundingBoxLeft :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_actualBoundingBoxRight

f64 TextMetrics_actualBoundingBoxRight(TextMetrics m)

Host: TextMetrics_actualBoundingBoxRight :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_fontBoundingBoxAscent

f64 TextMetrics_fontBoundingBoxAscent(TextMetrics m)

Host: TextMetrics_fontBoundingBoxAscent :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_fontBoundingBoxDescent

f64 TextMetrics_fontBoundingBoxDescent(TextMetrics m)

Host: TextMetrics_fontBoundingBoxDescent :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_actualBoundingBoxAscent

f64 TextMetrics_actualBoundingBoxAscent(TextMetrics m)

Host: TextMetrics_actualBoundingBoxAscent :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_actualBoundingBoxDescent

f64 TextMetrics_actualBoundingBoxDescent(TextMetrics m)

Host: TextMetrics_actualBoundingBoxDescent :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_emHeightAscent

f64 TextMetrics_emHeightAscent(TextMetrics m)

Host: TextMetrics_emHeightAscent :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_emHeightDescent

f64 TextMetrics_emHeightDescent(TextMetrics m)

Host: TextMetrics_emHeightDescent :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_hangingBaseline

f64 TextMetrics_hangingBaseline(TextMetrics m)

Host: TextMetrics_hangingBaseline :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_alphabeticBaseline

f64 TextMetrics_alphabeticBaseline(TextMetrics m)

Host: TextMetrics_alphabeticBaseline :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#TextMetrics_ideographicBaseline

f64 TextMetrics_ideographicBaseline(TextMetrics m)

Host: TextMetrics_ideographicBaseline :: proc(c: ^Call, m: Api_TextMetrics) -> f64

#CanvasDrawImage_drawImage

void CanvasDrawImage_drawImage(CanvasRenderingContext2D ctx, u64 source, i32 form, f64 sx, f64 sy, f64 sw, f64 sh, f64 dx, f64 dy, f64 dw, f64 dh) raises

drawImage: source is an element handle (img, canvas, video) or an object handle (ImageBitmap, OffscreenCanvas); form is the number of arguments after the image, 2 (dx, dy), 4 (dx, dy, dw, dh) or 8 (sx, sy, sw, sh, dx, dy, dw, dh); the unused ones are 0. An image that is not available yet draws nothing; a broken one, or a canvas with no pixels, raises Invalid_State.

Raises: returns an Error (see web).

Host: CanvasDrawImage_drawImage :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, source: u64, form: i32, sx: f64, sy: f64, sw: f64, sh: f64, dx: f64, dy: f64, dw: f64, dh: f64) -> Api_Error

#CanvasImageData_maxBytes

u64 CanvasImageData_maxBytes()

The largest ImageData a script may make or read back, in bytes (canvas.max_image_data_bytes).

Host: CanvasImageData_maxBytes :: proc(c: ^Call) -> u64

#CanvasImageData_get

void CanvasImageData_get(CanvasRenderingContext2D ctx, i32 x, i32 y, i32 w, i32 h, out bytes data) raises

getImageData's pixels: straight RGBA8 of the w x h block at (x, y) into data (w * h * 4 bytes). Security when the canvas is tainted, Index_Size for an empty block (blocks over canvas.max_image_data_bytes never get here: the binding asks CanvasImageData_maxBytes first and throws a RangeError).

Raises: returns an Error (see web).

Host: CanvasImageData_get :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, x: i32, y: i32, w: i32, h: i32, data: []u8) -> Api_Error

#CanvasImageData_put

void CanvasImageData_put(CanvasRenderingContext2D ctx, bytes data, i32 data_w, i32 data_h, i32 dx, i32 dy, i32 dirty_x, i32 dirty_y, i32 dirty_w, i32 dirty_h)

putImageData: the dirty rectangle of data (data_w x data_h straight RGBA8) at (dx, dy).

Host: CanvasImageData_put :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, data: []u8, data_w: i32, data_h: i32, dx: i32, dy: i32, dirty_x: i32, dirty_y: i32, dirty_w: i32, dirty_h: i32)

#CanvasPathDrawingStyles_lineWidth

f64 CanvasPathDrawingStyles_lineWidth(CanvasRenderingContext2D ctx)

Host: CanvasPathDrawingStyles_lineWidth :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> f64

#CanvasPathDrawingStyles_set_lineWidth

void CanvasPathDrawingStyles_set_lineWidth(CanvasRenderingContext2D ctx, f64 value)

Zero, negative or non-finite: ignored.

Host: CanvasPathDrawingStyles_set_lineWidth :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: f64)

#CanvasPathDrawingStyles_lineCap

string CanvasPathDrawingStyles_lineCap(CanvasRenderingContext2D ctx)

Host: CanvasPathDrawingStyles_lineCap :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasPathDrawingStyles_set_lineCap

void CanvasPathDrawingStyles_set_lineCap(CanvasRenderingContext2D ctx, string value)

Host: CanvasPathDrawingStyles_set_lineCap :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasPathDrawingStyles_lineJoin

string CanvasPathDrawingStyles_lineJoin(CanvasRenderingContext2D ctx)

Host: CanvasPathDrawingStyles_lineJoin :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasPathDrawingStyles_set_lineJoin

void CanvasPathDrawingStyles_set_lineJoin(CanvasRenderingContext2D ctx, string value)

Host: CanvasPathDrawingStyles_set_lineJoin :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasPathDrawingStyles_miterLimit

f64 CanvasPathDrawingStyles_miterLimit(CanvasRenderingContext2D ctx)

Host: CanvasPathDrawingStyles_miterLimit :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> f64

#CanvasPathDrawingStyles_set_miterLimit

void CanvasPathDrawingStyles_set_miterLimit(CanvasRenderingContext2D ctx, f64 value)

Host: CanvasPathDrawingStyles_set_miterLimit :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: f64)

#CanvasPathDrawingStyles_lineDashOffset

f64 CanvasPathDrawingStyles_lineDashOffset(CanvasRenderingContext2D ctx)

Host: CanvasPathDrawingStyles_lineDashOffset :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> f64

#CanvasPathDrawingStyles_set_lineDashOffset

void CanvasPathDrawingStyles_set_lineDashOffset(CanvasRenderingContext2D ctx, f64 value)

Host: CanvasPathDrawingStyles_set_lineDashOffset :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: f64)

#CanvasPathDrawingStyles_setLineDash

void CanvasPathDrawingStyles_setLineDash(CanvasRenderingContext2D ctx, f64[] segments)

setLineDash(segments): ignored when an entry is negative or not finite; an odd count is repeated.

Host: CanvasPathDrawingStyles_setLineDash :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, segments: []f64)

#CanvasPathDrawingStyles_lineDashCount

i32 CanvasPathDrawingStyles_lineDashCount(CanvasRenderingContext2D ctx)

Host: CanvasPathDrawingStyles_lineDashCount :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> i32

#CanvasPathDrawingStyles_lineDashAt

f64 CanvasPathDrawingStyles_lineDashAt(CanvasRenderingContext2D ctx, i32 index)

Host: CanvasPathDrawingStyles_lineDashAt :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, index: i32) -> f64

#CanvasTextDrawingStyles_lang

string CanvasTextDrawingStyles_lang(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_lang :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_lang

void CanvasTextDrawingStyles_set_lang(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_lang :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_font

string CanvasTextDrawingStyles_font(CanvasRenderingContext2D ctx)

The CSS font shorthand; one that does not parse is ignored. Relative units (em, %) are relative to the canvas element's font size.

Host: CanvasTextDrawingStyles_font :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_font

void CanvasTextDrawingStyles_set_font(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_font :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_textAlign

string CanvasTextDrawingStyles_textAlign(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_textAlign :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_textAlign

void CanvasTextDrawingStyles_set_textAlign(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_textAlign :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_textBaseline

string CanvasTextDrawingStyles_textBaseline(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_textBaseline :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_textBaseline

void CanvasTextDrawingStyles_set_textBaseline(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_textBaseline :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_direction

string CanvasTextDrawingStyles_direction(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_direction :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_direction

void CanvasTextDrawingStyles_set_direction(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_direction :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_letterSpacing

string CanvasTextDrawingStyles_letterSpacing(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_letterSpacing :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_letterSpacing

void CanvasTextDrawingStyles_set_letterSpacing(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_letterSpacing :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_wordSpacing

string CanvasTextDrawingStyles_wordSpacing(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_wordSpacing :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_wordSpacing

void CanvasTextDrawingStyles_set_wordSpacing(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_wordSpacing :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_fontKerning

string CanvasTextDrawingStyles_fontKerning(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_fontKerning :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_fontKerning

void CanvasTextDrawingStyles_set_fontKerning(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_fontKerning :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_fontStretch

string CanvasTextDrawingStyles_fontStretch(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_fontStretch :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_fontStretch

void CanvasTextDrawingStyles_set_fontStretch(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_fontStretch :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_fontVariantCaps

string CanvasTextDrawingStyles_fontVariantCaps(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_fontVariantCaps :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_fontVariantCaps

void CanvasTextDrawingStyles_set_fontVariantCaps(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_fontVariantCaps :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasTextDrawingStyles_textRendering

string CanvasTextDrawingStyles_textRendering(CanvasRenderingContext2D ctx)

Host: CanvasTextDrawingStyles_textRendering :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D) -> string

#CanvasTextDrawingStyles_set_textRendering

void CanvasTextDrawingStyles_set_textRendering(CanvasRenderingContext2D ctx, string value)

Host: CanvasTextDrawingStyles_set_textRendering :: proc(c: ^Call, ctx: Api_CanvasRenderingContext2D, value: string)

#CanvasPath_closePath

void CanvasPath_closePath(CanvasPathTarget p)

/////////////////////////////

Host: CanvasPath_closePath :: proc(c: ^Call, p: Api_CanvasPathTarget)

#CanvasPath_moveTo

void CanvasPath_moveTo(CanvasPathTarget p, f64 x, f64 y)

Host: CanvasPath_moveTo :: proc(c: ^Call, p: Api_CanvasPathTarget, x: f64, y: f64)

#CanvasPath_lineTo

void CanvasPath_lineTo(CanvasPathTarget p, f64 x, f64 y)

Host: CanvasPath_lineTo :: proc(c: ^Call, p: Api_CanvasPathTarget, x: f64, y: f64)

#CanvasPath_quadraticCurveTo

void CanvasPath_quadraticCurveTo(CanvasPathTarget p, f64 cpx, f64 cpy, f64 x, f64 y)

Host: CanvasPath_quadraticCurveTo :: proc(c: ^Call, p: Api_CanvasPathTarget, cpx: f64, cpy: f64, x: f64, y: f64)

#CanvasPath_bezierCurveTo

void CanvasPath_bezierCurveTo(CanvasPathTarget p, f64 cp1x, f64 cp1y, f64 cp2x, f64 cp2y, f64 x, f64 y)

Host: CanvasPath_bezierCurveTo :: proc(c: ^Call, p: Api_CanvasPathTarget, cp1x: f64, cp1y: f64, cp2x: f64, cp2y: f64, x: f64, y: f64)

#CanvasPath_arcTo

void CanvasPath_arcTo(CanvasPathTarget p, f64 x1, f64 y1, f64 x2, f64 y2, f64 radius) raises

A negative radius raises Index_Size.

Raises: returns an Error (see web).

Host: CanvasPath_arcTo :: proc(c: ^Call, p: Api_CanvasPathTarget, x1: f64, y1: f64, x2: f64, y2: f64, radius: f64) -> Api_Error

#CanvasPath_rect

void CanvasPath_rect(CanvasPathTarget p, f64 x, f64 y, f64 w, f64 h)

Host: CanvasPath_rect :: proc(c: ^Call, p: Api_CanvasPathTarget, x: f64, y: f64, w: f64, h: f64)

#CanvasPath_roundRect

void CanvasPath_roundRect(CanvasPathTarget p, f64 x, f64 y, f64 w, f64 h, f64[] radii) raises

roundRect: radii are the 8 numbers of the four corners (upper-left, upper-right, lower-right, lower-left), x then y radius each. A negative radius raises Range.

Raises: returns an Error (see web).

Host: CanvasPath_roundRect :: proc(c: ^Call, p: Api_CanvasPathTarget, x: f64, y: f64, w: f64, h: f64, radii: []f64) -> Api_Error

#CanvasPath_arc

void CanvasPath_arc(CanvasPathTarget p, f64 x, f64 y, f64 radius, f64 start_angle, f64 end_angle, bool counterclockwise = false) raises

Raises: returns an Error (see web).

Host: CanvasPath_arc :: proc(c: ^Call, p: Api_CanvasPathTarget, x: f64, y: f64, radius: f64, start_angle: f64, end_angle: f64, counterclockwise: bool) -> Api_Error

#CanvasPath_ellipse

void CanvasPath_ellipse(CanvasPathTarget p, f64 x, f64 y, f64 radius_x, f64 radius_y, f64 rotation, f64 start_angle, f64 end_angle, bool counterclockwise = false) raises

Raises: returns an Error (see web).

Host: CanvasPath_ellipse :: proc(c: ^Call, p: Api_CanvasPathTarget, x: f64, y: f64, radius_x: f64, radius_y: f64, rotation: f64, start_angle: f64, end_angle: f64, counterclockwise: bool) -> Api_Error

#Path2D_create

Path2D Path2D_create(u64 from, string svg)

new Path2D(): empty; from a Path2D handle to copy (0 for none); svg path data (M, L, H, V, C, S, Q, T, A, Z and their relative forms) appended when not empty (an invalid string leaves what parsed before the error).

Host: Path2D_create :: proc(c: ^Call, from: u64, svg: string) -> u64

#Path2D_addPath

void Path2D_addPath(Path2D target, Path2D path, f64 m11, f64 m12, f64 m21, f64 m22, f64 m41, f64 m42)

addPath(path, matrix).

Host: Path2D_addPath :: proc(c: ^Call, target: Api_Path2D, path: Api_Path2D, m11: f64, m12: f64, m21: f64, m22: f64, m41: f64, m42: f64)

#HTMLCanvasElement_transferControl

OffscreenCanvas HTMLCanvasElement_transferControl(HTMLCanvasElement canvas) raises

///////////////////////////// canvas.transferControlToOffscreen(): an OffscreenCanvas (in this realm, for now) whose frames this element shows. Invalid_State: it has a context or was transferred before.

Raises: returns an Error (see web).

Host: HTMLCanvasElement_transferControl :: proc(c: ^Call, canvas: Api_HTMLCanvasElement) -> (u64, Api_Error)

#OffscreenCanvas_takeForTransfer

u64 OffscreenCanvas_takeForTransfer(OffscreenCanvas canvas) raises

Transferring an OffscreenCanvas in a message: a token the receiving realm adopts; the object is left detached. Invalid_State: it has a context. Data_Clone: it was transferred before.

Raises: returns an Error (see web).

Host: OffscreenCanvas_takeForTransfer :: proc(c: ^Call, canvas: Api_OffscreenCanvas) -> (u64, Api_Error)

#OffscreenCanvas_adoptTransfer

OffscreenCanvas OffscreenCanvas_adoptTransfer(u64 token) raises

Raises: returns an Error (see web).

Host: OffscreenCanvas_adoptTransfer :: proc(c: ^Call, token: u64) -> (u64, Api_Error)

#OffscreenCanvas_create

OffscreenCanvas OffscreenCanvas_create(u64 width, u64 height) raises

new OffscreenCanvas(width, height): Quota over the limits.

Raises: returns an Error (see web).

Host: OffscreenCanvas_create :: proc(c: ^Call, width: u64, height: u64) -> (u64, Api_Error)

#OffscreenCanvas_width

u64 OffscreenCanvas_width(OffscreenCanvas canvas)

Host: OffscreenCanvas_width :: proc(c: ^Call, canvas: Api_OffscreenCanvas) -> u64

#OffscreenCanvas_height

u64 OffscreenCanvas_height(OffscreenCanvas canvas)

Host: OffscreenCanvas_height :: proc(c: ^Call, canvas: Api_OffscreenCanvas) -> u64

#OffscreenCanvas_set_width

void OffscreenCanvas_set_width(OffscreenCanvas canvas, u64 value) raises

Sets the size: the canvas is cleared and its context reset. Quota over the limits.

Raises: returns an Error (see web).

Host: OffscreenCanvas_set_width :: proc(c: ^Call, canvas: Api_OffscreenCanvas, value: u64) -> Api_Error

#OffscreenCanvas_set_height

void OffscreenCanvas_set_height(OffscreenCanvas canvas, u64 value) raises

Raises: returns an Error (see web).

Host: OffscreenCanvas_set_height :: proc(c: ^Call, canvas: Api_OffscreenCanvas, value: u64) -> Api_Error

#OffscreenCanvas_context2d

CanvasRenderingContext2D OffscreenCanvas_context2d(OffscreenCanvas canvas, bool alpha, bool will_read_frequently) raises

Raises: returns an Error (see web).

Host: OffscreenCanvas_context2d :: proc(c: ^Call, canvas: Api_OffscreenCanvas, alpha: bool, will_read_frequently: bool) -> (u64, Api_Error)

#OffscreenCanvas_transferToImageBitmap

ImageBitmap OffscreenCanvas_transferToImageBitmap(OffscreenCanvas canvas) raises

transferToImageBitmap(): the pixels move to a new ImageBitmap and the canvas is cleared.

Raises: returns an Error (see web).

Host: OffscreenCanvas_transferToImageBitmap :: proc(c: ^Call, canvas: Api_OffscreenCanvas) -> (u64, Api_Error)

#ImageBitmap_width

u32 ImageBitmap_width(ImageBitmap bitmap)

Host: ImageBitmap_width :: proc(c: ^Call, bitmap: Api_ImageBitmap) -> u32

#ImageBitmap_height

u32 ImageBitmap_height(ImageBitmap bitmap)

Host: ImageBitmap_height :: proc(c: ^Call, bitmap: Api_ImageBitmap) -> u32

#ImageBitmap_close

void ImageBitmap_close(ImageBitmap bitmap)

bitmap.close(): the pixels are freed; the bitmap is 0 x 0 from then on.

Host: ImageBitmap_close :: proc(c: ^Call, bitmap: Api_ImageBitmap)

#Canvas_createBitmap

ImageBitmap Canvas_createBitmap(u64 source, i32 form, f64 sx, f64 sy, f64 sw, f64 sh, i32 orient, i32 premul, i32 colorspace, i32 resize_w, i32 resize_h, i32 resize_q) raises

createImageBitmap(image, sx, sy, sw, sh, options): source as for drawImage, form 0 (whole image) or 4 (a rectangle). The bitmap is a copy of the pixels now, with the full ImageBitmapOptions applied natively: orient (0 from-image, 1 flipY), premul (0 default, 1 premultiply, 2 none — the result stored premultiplied either way; none only affects a source whose alpha is not premultiplied, which never happens for our premultiplied bitmaps, so it is a no-op here and kept for completeness), colorspace (0 default, 1 none — we keep the source sRGB bytes so both behave the same), resize_w / resize_h the wanted output size (0 means keep that axis) and resize_q (0 pixelated, 1 low, 2 medium, 3 high). Not_Found: no pixels yet (the image is not available); Invalid_State: broken or empty image; Index_Size: an empty rectangle or an out-of-range resize.

Odin: canvas.createBitmap.

Raises: returns an Error (see web).

Host: Canvas_createBitmap :: proc(c: ^Call, source: u64, form: i32, sx: f64, sy: f64, sw: f64, sh: f64, orient: i32, premul: i32, colorspace: i32, resize_w: i32, resize_h: i32, resize_q: i32) -> (u64, Api_Error)

#Canvas_bitmapFromPixels

ImageBitmap Canvas_bitmapFromPixels(bytes data, i32 width, i32 height, i32 orient, i32 premul, i32 colorspace, i32 resize_w, i32 resize_h, i32 resize_q) raises

An ImageBitmap of straight RGBA8 pixels (an ImageData, a decoded Blob, a VideoFrame read back). orient, premul, colorspace, resize_* and resize_q as Canvas_createBitmap.

Odin: canvas.bitmapFromPixels.

Raises: returns an Error (see web).

Host: Canvas_bitmapFromPixels :: proc(c: ^Call, data: []u8, width: i32, height: i32, orient: i32, premul: i32, colorspace: i32, resize_w: i32, resize_h: i32, resize_q: i32) -> (u64, Api_Error)

#HTMLCanvasElement_bitmapRenderer

ImageBitmapRenderingContext HTMLCanvasElement_bitmapRenderer(HTMLCanvasElement canvas, bool alpha) raises

///////////////////////////// getContext("bitmaprenderer", {alpha}) on a <canvas> element / an OffscreenCanvas: 0 when a 2D context already holds the canvas (the kinds cannot be mixed).

Raises: returns an Error (see web).

Host: HTMLCanvasElement_bitmapRenderer :: proc(c: ^Call, canvas: Api_HTMLCanvasElement, alpha: bool) -> (u64, Api_Error)

#OffscreenCanvas_bitmapRenderer

ImageBitmapRenderingContext OffscreenCanvas_bitmapRenderer(OffscreenCanvas canvas, bool alpha) raises

Raises: returns an Error (see web).

Host: OffscreenCanvas_bitmapRenderer :: proc(c: ^Call, canvas: Api_OffscreenCanvas, alpha: bool) -> (u64, Api_Error)

#ImageBitmapRenderingContext_canvas

u64 ImageBitmapRenderingContext_canvas(ImageBitmapRenderingContext ctx)

context.canvas: the owning <canvas> node or OffscreenCanvas object (0 when the canvas is gone).

Host: ImageBitmapRenderingContext_canvas :: proc(c: ^Call, ctx: Api_ImageBitmapRenderingContext) -> u64

#ImageBitmapRenderingContext_transferFromImageBitmap

void ImageBitmapRenderingContext_transferFromImageBitmap(ImageBitmapRenderingContext ctx, u64 bitmap, bool has_bitmap) raises

transferFromImageBitmap(bitmap): display the bitmap (its pixels move into the canvas and it is detached); has_bitmap false is the null argument (clear the canvas). Type when the argument is not an ImageBitmap.

Raises: returns an Error (see web).

Host: ImageBitmapRenderingContext_transferFromImageBitmap :: proc(c: ^Call, ctx: Api_ImageBitmapRenderingContext, bitmap: u64, has_bitmap: bool) -> Api_Error

Edit this page on GitHub