wechat/canvas · weapp

cancel_animation_frame

pub fn cancel_animation_frame(request_id i: Int) -> Nil

wx.cancelAnimationFrame Cancel animation frame

canvas_arc

</>

pub fn canvas_arc(
  ctx: CanvasContext,
  x: Float,
  y: Float,
  radius: Float,
  start_angle: Float,
  end_angle: Float,
  anticlockwise: Bool,
) -> Nil

CanvasContext.arc

canvas_arc_to

</>

pub fn canvas_arc_to(
  ctx: CanvasContext,
  x1: Float,
  y1: Float,
  x2: Float,
  y2: Float,
  radius: Float,
) -> Nil

CanvasContext.arcTo

canvas_begin_path

</>

pub fn canvas_begin_path(ctx: CanvasContext) -> Nil

CanvasContext.beginPath

canvas_bezier_curve_to

</>

pub fn canvas_bezier_curve_to(
  ctx: CanvasContext,
  cp1_x: Float,
  cp1_y: Float,
  cp2_x: Float,
  cp2_y: Float,
  ep_x: Float,
  ep_y: Float,
) -> Nil

CanvasContext.bezierCurveTo

canvas_clear_rect

</>

pub fn canvas_clear_rect(
  ctx: CanvasContext,
  x: Float,
  y: Float,
  width: Float,
  height: Float,
) -> Nil

CanvasContext.clearRect

canvas_clip

</>

pub fn canvas_clip(ctx: CanvasContext) -> Nil

CanvasContext.clip Clip drawing area

canvas_close_path

</>

pub fn canvas_close_path(ctx: CanvasContext) -> Nil

CanvasContext.closePath Close current path

canvas_create_circular_gradient

</>

pub fn canvas_create_circular_gradient(
  ctx: CanvasContext,
  x: Float,
  y: Float,
  r: Float,
) -> CanvasGradient

CanvasContext.createCircularGradient Create a circular gradient

canvas_create_linear_gradient

</>

pub fn canvas_create_linear_gradient(
  ctx: CanvasContext,
  x0: Float,
  y0: Float,
  x1: Float,
  y1: Float,
) -> CanvasGradient

CanvasContext.createLinearGradient Create a linear gradient

canvas_draw

</>

pub fn canvas_draw(ctx: CanvasContext, reserve: Bool) -> Nil

CanvasContext.draw

canvas_draw_image

</>

pub fn canvas_draw_image(
  ctx: CanvasContext,
  img_source: object.JsObject,
  sx: Float,
  sy: Float,
  sw: Float,
  sh: Float,
  dx: Float,
  dy: Float,
  dwidth: Float,
  dheight: Float,
) -> Nil

CanvasContext.drawImage

canvas_fill

</>

pub fn canvas_fill(ctx: CanvasContext) -> Nil

CanvasContext.fill Fill path

canvas_fill_rect

</>

pub fn canvas_fill_rect(
  ctx: CanvasContext,
  x: Float,
  y: Float,
  width: Float,
  height: Float,
) -> Nil

CanvasContext.fillRect

canvas_fill_text

</>

pub fn canvas_fill_text(
  ctx: CanvasContext,
  text: String,
  x: Float,
  y: Float,
  max_width: Float,
) -> Nil

CanvasContext.fillText

canvas_get_context

</>

pub fn canvas_get_context(
  canvas: object.JsObject,
  context_type ct: String,
) -> object.JsObject

Canvas.getContext Get canvas rendering context

canvas_get_image_data

</>

pub fn canvas_get_image_data(
  canvas_id c: String,
  x x: Float,
  y y: Float,
  width w: Float,
  height h: Float,
  complete cb: fn(object.JsObject) -> Nil,
) -> promise.Promise(object.JsObject)

wx.canvasGetImageData Get image data from canvas

canvas_gradient_add_color_stop

</>

pub fn canvas_gradient_add_color_stop(
  gradient: CanvasGradient,
  offset: Float,
  color: String,
) -> Nil

CanvasGradient.addColorStop Add color stop to gradient

canvas_line_to

</>

pub fn canvas_line_to(
  ctx: CanvasContext,
  x: Float,
  y: Float,
) -> Nil

CanvasContext.lineTo

canvas_measure_text

</>

pub fn canvas_measure_text(
  ctx: CanvasContext,
  text: String,
) -> object.JsObject

CanvasContext.measureText

canvas_move_to

</>

pub fn canvas_move_to(
  ctx: CanvasContext,
  x: Float,
  y: Float,
) -> Nil

CanvasContext.moveTo

canvas_put_image_data

</>

pub fn canvas_put_image_data(
  canvas_id c: String,
  data d: object.JsObject,
  x x: Float,
  y y: Float,
  width w: Float,
  height h: Float,
) -> Nil

wx.canvasPutImageData Put image data onto canvas

canvas_quadratic_curve_to

</>

pub fn canvas_quadratic_curve_to(
  ctx: CanvasContext,
  control_point_x: Float,
  control_point_y: Float,
  end_point_x: Float,
  end_point_y: Float,
) -> Nil

CanvasContext.quadraticCurveTo

canvas_rect

</>

pub fn canvas_rect(
  ctx: CanvasContext,
  x: Float,
  y: Float,
  width: Float,
  height: Float,
) -> Nil

CanvasContext.rect Draw rectangle path

canvas_restore

</>

pub fn canvas_restore(ctx: CanvasContext) -> Nil

CanvasContext.restore

canvas_rotate

</>

pub fn canvas_rotate(ctx: CanvasContext, angle: Float) -> Nil

CanvasContext.rotate

canvas_save

</>

pub fn canvas_save(ctx: CanvasContext) -> Nil

CanvasContext.save

canvas_scale

</>

pub fn canvas_scale(
  ctx: CanvasContext,
  sx: Float,
  sy: Float,
) -> Nil

CanvasContext.scale

canvas_set_fill_style

</>

pub fn canvas_set_fill_style(
  ctx: CanvasContext,
  color: String,
) -> Nil

CanvasContext.fillStyle

canvas_set_font_size

</>

pub fn canvas_set_font_size(
  ctx: CanvasContext,
  size: Float,
) -> Nil

CanvasContext.setFontSize Set font size

canvas_set_global_alpha

</>

pub fn canvas_set_global_alpha(
  ctx: CanvasContext,
  alpha: Float,
) -> Nil

CanvasContext.setGlobalAlpha Set global transparency

canvas_set_line_cap

</>

pub fn canvas_set_line_cap(
  ctx: CanvasContext,
  line_cap: String,
) -> Nil

CanvasContext.setLineCap

canvas_set_line_dash

</>

pub fn canvas_set_line_dash(
  ctx: CanvasContext,
  pattern: List(Int),
) -> Nil

CanvasContext.setLineDash

canvas_set_line_join

</>

pub fn canvas_set_line_join(
  ctx: CanvasContext,
  line_join: String,
) -> Nil

CanvasContext.setLineJoin

canvas_set_line_width

</>

pub fn canvas_set_line_width(
  ctx: CanvasContext,
  width: Float,
) -> Nil

CanvasContext.setLineWidth

canvas_set_miter_limit

</>

pub fn canvas_set_miter_limit(
  ctx: CanvasContext,
  miter: Float,
) -> Nil

CanvasContext.setMiterLimit

canvas_set_shadow

</>

pub fn canvas_set_shadow(
  ctx: CanvasContext,
  color: String,
  blur: Float,
  offset_x: Float,
  offset_y: Float,
) -> Nil

CanvasContext.setShadow

canvas_set_stroke_style

</>

pub fn canvas_set_stroke_style(
  ctx: CanvasContext,
  color: String,
) -> Nil

CanvasContext.setStrokeStyle Set stroke style

canvas_set_text_align

</>

pub fn canvas_set_text_align(
  ctx: CanvasContext,
  align: String,
) -> Nil

CanvasContext.setTextAlign Set text alignment

canvas_set_text_baseline

</>

pub fn canvas_set_text_baseline(
  ctx: CanvasContext,
  baseline: String,
) -> Nil

CanvasContext.setTextBaseline Set text baseline

canvas_set_transform

</>

pub fn canvas_set_transform(
  ctx: CanvasContext,
  a: Float,
  b: Float,
  c: Float,
  d: Float,
  e: Float,
  f: Float,
) -> Nil

CanvasContext.setTransform Set transformation matrix

canvas_stroke

</>

pub fn canvas_stroke(ctx: CanvasContext) -> Nil

CanvasContext.stroke Stroke path

canvas_stroke_rect

</>

pub fn canvas_stroke_rect(
  ctx: CanvasContext,
  x: Float,
  y: Float,
  width: Float,
  height: Float,
) -> Nil

CanvasContext.strokeRect

canvas_stroke_text

</>

pub fn canvas_stroke_text(
  ctx: CanvasContext,
  text: String,
  x: Float,
  y: Float,
  max_width: Float,
) -> Nil

CanvasContext.strokeText

canvas_to_data_url

</>

pub fn canvas_to_data_url(
  canvas: object.JsObject,
  file_type ft: String,
  quality q: Float,
) -> promise.Promise(object.JsObject)

Canvas.toDataURL (OffscreenCanvas only) Export canvas as data URL string

canvas_to_temp_file_path

</>

pub fn canvas_to_temp_file_path(
  canvas_id c: String,
  file_type ft: String,
  quality q: Float,
  complete cb: fn(object.JsObject) -> Nil,
) -> promise.Promise(object.JsObject)

wx.canvasToTempFilePath Export canvas to temporary file path

canvas_transform

</>

pub fn canvas_transform(
  ctx: CanvasContext,
  a: Float,
  b: Float,
  c: Float,
  d: Float,
  e: Float,
  f: Float,
) -> Nil

CanvasContext.transform

canvas_translate

</>

pub fn canvas_translate(
  ctx: CanvasContext,
  dx: Float,
  dy: Float,
) -> Nil

CanvasContext.translate

create_canvas_context

</>

pub fn create_canvas_context(canvas_id: String) -> CanvasContext

wx.createCanvasContext Create canvas context

create_image

</>

pub fn create_image() -> object.JsObject

Canvas Utility Methods

wx.createImage Create an image object

create_image_data

</>

pub fn create_image_data(
  width w: Float,
  height h: Float,
) -> object.JsObject

wx.createImageData Create an ImageData object

create_offscreen_canvas

</>

pub fn create_offscreen_canvas(
  options o: object.JsObject,
) -> object.JsObject

Phase 16: Canvas Advanced

Canvas Creation

wx.createOffscreenCanvas Create an offscreen canvas

create_path_2d

</>

pub fn create_path_2d() -> object.JsObject

wx.createPath2D Create a Path2D object

offscreen_canvas_create_image

</>

pub fn offscreen_canvas_create_image(
  canvas: object.JsObject,
) -> object.JsObject

OffscreenCanvas.createImage Create Image object for offscreen canvas

path_2d_add_path

</>

pub fn path_2d_add_path(path: Path2D, other_path: Path2D) -> Nil

Path2D.addPath Add another path

path_2d_arc

</>

pub fn path_2d_arc(
  path: Path2D,
  x: Float,
  y: Float,
  radius: Float,
  start_angle: Float,
  end_angle: Float,
  anticlockwise: Bool,
) -> Nil

Path2D.arc Draw arc

path_2d_bezier_curve_to

</>

pub fn path_2d_bezier_curve_to(
  path: Path2D,
  cp1x: Float,
  cp1y: Float,
  cp2x: Float,
  cp2y: Float,
  x: Float,
  y: Float,
) -> Nil

Path2D.bezierCurveTo Draw cubic bezier curve

path_2d_close_path

</>

pub fn path_2d_close_path(path: Path2D) -> Nil

Path2D.closePath Close path

path_2d_line_to

</>

pub fn path_2d_line_to(path: Path2D, x: Float, y: Float) -> Nil

Path2D.lineTo Draw line to point

path_2d_move_to

</>

pub fn path_2d_move_to(path: Path2D, x: Float, y: Float) -> Nil

Path2D.moveTo Move to point

path_2d_quadratic_curve_to

</>

pub fn path_2d_quadratic_curve_to(
  path: Path2D,
  cpx: Float,
  cpy: Float,
  x: Float,
  y: Float,
) -> Nil

Path2D.quadraticCurveTo Draw quadratic bezier curve

path_2d_rect

</>

pub fn path_2d_rect(
  path: Path2D,
  x: Float,
  y: Float,
  width: Float,
  height: Float,
) -> Nil

Path2D.rect Draw rectangle

request_animation_frame

</>

pub fn request_animation_frame(
  callback cb: fn(object.JsObject) -> Nil,
) -> Int

wx.requestAnimationFrame Request animation frame