Struct script::canvas_state::CanvasState

pub(crate) struct CanvasState {
    ipc_renderer: IpcSender<CanvasMsg>,
    canvas_id: CanvasId,
    state: DomRefCell<CanvasContextState>,
    origin_clean: Cell<bool>,
    image_cache: Arc<dyn ImageCache>,
    base_url: ServoUrl,
    origin: ImmutableOrigin,
    missing_image_urls: DomRefCell<Vec<ServoUrl>>,
    saved_states: DomRefCell<Vec<CanvasContextState>>,
}

Fields

ipc_renderer: IpcSender<CanvasMsg>

canvas_id: CanvasId

state: DomRefCell<CanvasContextState>

origin_clean: Cell<bool>

image_cache: Arc<dyn ImageCache>

base_url: ServoUrl

The base URL for resolving CSS image URL values. Needed because of https://github.com/servo/servo/issues/17625

origin: ImmutableOrigin

missing_image_urls: DomRefCell<Vec<ServoUrl>>

Any missing image URLs.

saved_states: DomRefCell<Vec<CanvasContextState>>

Implementations

impl CanvasState

pub(crate) fn new(global: &GlobalScope, size: Size2D<u64>) -> CanvasState

pub fn get_ipc_renderer(&self) -> &IpcSender<CanvasMsg>

pub fn get_missing_image_urls(&self) -> &DomRefCell<Vec<ServoUrl>>

pub fn get_canvas_id(&self) -> CanvasId

pub fn send_canvas_2d_msg(&self, msg: Canvas2dMsg)

pub fn set_bitmap_dimensions(&self, size: Size2D<u64>)

pub fn reset_to_initial_state(&self)

fn create_drawable_rect(&self, x: f64, y: f64, w: f64, h: f64) -> Option<Rect<f32>>

pub fn origin_is_clean(&self) -> bool

fn set_origin_unclean(&self)

fn is_origin_clean(&self, image: CanvasImageSource) -> bool

fn fetch_image_data(
    &self,
    url: ServoUrl,
    cors_setting: Option<CorsSettings>
) -> Option<(Vec<u8>, Size2D<u32>)>

fn request_image_from_cache(
    &self,
    url: ServoUrl,
    cors_setting: Option<CorsSettings>
) -> ImageResponse

fn parse_color(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    string: &str
) -> Result<RGBA, ()>

pub fn get_rect(&self, canvas_size: Size2D<u64>, rect: Rect<u64>) -> Vec<u8>

fn draw_image_internal(
    &self,
    htmlcanvas: Option<&HTMLCanvasElement>,
    image: CanvasImageSource,
    sx: f64,
    sy: f64,
    sw: Option<f64>,
    sh: Option<f64>,
    dx: f64,
    dy: f64,
    dw: Option<f64>,
    dh: Option<f64>
) -> Result<(), Error>

fn draw_offscreen_canvas(
    &self,
    canvas: &OffscreenCanvas,
    htmlcanvas: Option<&HTMLCanvasElement>,
    sx: f64,
    sy: f64,
    sw: Option<f64>,
    sh: Option<f64>,
    dx: f64,
    dy: f64,
    dw: Option<f64>,
    dh: Option<f64>
) -> Result<(), Error>

fn draw_html_canvas_element(
    &self,
    canvas: &HTMLCanvasElement,
    htmlcanvas: Option<&HTMLCanvasElement>,
    sx: f64,
    sy: f64,
    sw: Option<f64>,
    sh: Option<f64>,
    dx: f64,
    dy: f64,
    dw: Option<f64>,
    dh: Option<f64>
) -> Result<(), Error>

fn fetch_and_draw_image_data(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    url: ServoUrl,
    cors_setting: Option<CorsSettings>,
    sx: f64,
    sy: f64,
    sw: Option<f64>,
    sh: Option<f64>,
    dx: f64,
    dy: f64,
    dw: Option<f64>,
    dh: Option<f64>
) -> Result<(), Error>

pub fn mark_as_dirty(&self, canvas: Option<&HTMLCanvasElement>)

fn adjust_source_dest_rects(
    &self,
    image_size: Size2D<f64>,
    sx: f64,
    sy: f64,
    sw: f64,
    sh: f64,
    dx: f64,
    dy: f64,
    dw: f64,
    dh: f64
) -> (Rect<f64>, Rect<f64>)

fn update_transform(&self)

pub fn fill_rect(&self, x: f64, y: f64, width: f64, height: f64)

pub fn clear_rect(&self, x: f64, y: f64, width: f64, height: f64)

pub fn stroke_rect(&self, x: f64, y: f64, width: f64, height: f64)

pub fn shadow_offset_x(&self) -> f64

pub fn set_shadow_offset_x(&self, value: f64)

pub fn shadow_offset_y(&self) -> f64

pub fn set_shadow_offset_y(&self, value: f64)

pub fn shadow_blur(&self) -> f64

pub fn set_shadow_blur(&self, value: f64)

pub fn shadow_color(&self) -> DOMString

pub fn set_shadow_color(&self, value: DOMString)

pub fn stroke_style(&self) -> StringOrCanvasGradientOrCanvasPattern

pub fn set_stroke_style(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    value: StringOrCanvasGradientOrCanvasPattern
)

pub fn fill_style(&self) -> StringOrCanvasGradientOrCanvasPattern

pub fn set_fill_style(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    value: StringOrCanvasGradientOrCanvasPattern
)

pub fn create_linear_gradient(
    &self,
    global: &GlobalScope,
    x0: Finite<f64>,
    y0: Finite<f64>,
    x1: Finite<f64>,
    y1: Finite<f64>
) -> Root<Dom<CanvasGradient>>

pub fn create_radial_gradient(
    &self,
    global: &GlobalScope,
    x0: Finite<f64>,
    y0: Finite<f64>,
    r0: Finite<f64>,
    x1: Finite<f64>,
    y1: Finite<f64>,
    r1: Finite<f64>
) -> Result<Root<Dom<CanvasGradient>>, Error>

pub fn create_pattern(
    &self,
    global: &GlobalScope,
    image: CanvasImageSource,
    repetition: DOMString
) -> Result<Option<Root<Dom<CanvasPattern>>>, Error>

pub fn save(&self)

pub fn restore(&self)

pub fn global_alpha(&self) -> f64

pub fn set_global_alpha(&self, alpha: f64)

pub fn global_composite_operation(&self) -> DOMString

pub fn set_global_composite_operation(&self, op_str: DOMString)

pub fn image_smoothing_enabled(&self) -> bool

pub fn set_image_smoothing_enabled(&self, value: bool)

pub fn fill_text(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    text: DOMString,
    x: f64,
    y: f64,
    max_width: Option<f64>
)

pub fn measure_text(
    &self,
    global: &GlobalScope,
    _text: DOMString
) -> Root<Dom<TextMetrics>>

pub fn set_font(&self, canvas: Option<&HTMLCanvasElement>, value: DOMString)

pub fn font(&self) -> DOMString

pub fn text_align(&self) -> CanvasTextAlign

pub fn set_text_align(&self, value: CanvasTextAlign)

pub fn text_baseline(&self) -> CanvasTextBaseline

pub fn set_text_baseline(&self, value: CanvasTextBaseline)

pub fn direction(&self) -> CanvasDirection

pub fn set_direction(&self, value: CanvasDirection)

pub fn line_width(&self) -> f64

pub fn set_line_width(&self, width: f64)

pub fn line_cap(&self) -> CanvasLineCap

pub fn set_line_cap(&self, cap: CanvasLineCap)

pub fn line_join(&self) -> CanvasLineJoin

pub fn set_line_join(&self, join: CanvasLineJoin)

pub fn miter_limit(&self) -> f64

pub fn set_miter_limit(&self, limit: f64)

pub fn create_image_data(
    &self,
    global: &GlobalScope,
    sw: i32,
    sh: i32
) -> Result<Root<Dom<ImageData>>, Error>

pub fn create_image_data_(
    &self,
    global: &GlobalScope,
    imagedata: &ImageData
) -> Result<Root<Dom<ImageData>>, Error>

pub fn get_image_data(
    &self,
    canvas_size: Size2D<u64>,
    global: &GlobalScope,
    sx: i32,
    sy: i32,
    sw: i32,
    sh: i32
) -> Result<Root<Dom<ImageData>>, Error>

pub fn put_image_data(
    &self,
    canvas_size: Size2D<u64>,
    imagedata: &ImageData,
    dx: i32,
    dy: i32
)

pub fn put_image_data_(
    &self,
    canvas_size: Size2D<u64>,
    imagedata: &ImageData,
    dx: i32,
    dy: i32,
    dirty_x: i32,
    dirty_y: i32,
    dirty_width: i32,
    dirty_height: i32
)

pub fn draw_image(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    image: CanvasImageSource,
    dx: f64,
    dy: f64
) -> Result<(), Error>

pub fn draw_image_(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    image: CanvasImageSource,
    dx: f64,
    dy: f64,
    dw: f64,
    dh: f64
) -> Result<(), Error>

pub fn draw_image__(
    &self,
    canvas: Option<&HTMLCanvasElement>,
    image: CanvasImageSource,
    sx: f64,
    sy: f64,
    sw: f64,
    sh: f64,
    dx: f64,
    dy: f64,
    dw: f64,
    dh: f64
) -> Result<(), Error>

pub fn begin_path(&self)

pub fn fill(&self, _fill_rule: CanvasFillRule)

pub fn stroke(&self)

pub fn clip(&self, _fill_rule: CanvasFillRule)

pub fn is_point_in_path(
    &self,
    global: &GlobalScope,
    x: f64,
    y: f64,
    fill_rule: CanvasFillRule
) -> bool

pub fn scale(&self, x: f64, y: f64)

pub fn rotate(&self, angle: f64)

pub fn translate(&self, x: f64, y: f64)

pub fn transform(&self, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64)

pub fn get_transform(&self, global: &GlobalScope) -> Root<Dom<DOMMatrix>>

pub fn set_transform(&self, a: f64, b: f64, c: f64, d: f64, e: f64, f: f64)

pub fn reset_transform(&self)

pub fn close_path(&self)

pub fn move_to(&self, x: f64, y: f64)

pub fn line_to(&self, x: f64, y: f64)

pub fn rect(&self, x: f64, y: f64, width: f64, height: f64)

pub fn quadratic_curve_to(&self, cpx: f64, cpy: f64, x: f64, y: f64)

pub fn bezier_curve_to(
    &self,
    cp1x: f64,
    cp1y: f64,
    cp2x: f64,
    cp2y: f64,
    x: f64,
    y: f64
)

pub fn arc(
    &self,
    x: f64,
    y: f64,
    r: f64,
    start: f64,
    end: f64,
    ccw: bool
) -> Result<(), Error>

pub fn arc_to(
    &self,
    cp1x: f64,
    cp1y: f64,
    cp2x: f64,
    cp2y: f64,
    r: f64
) -> Result<(), Error>

pub fn ellipse(
    &self,
    x: f64,
    y: f64,
    rx: f64,
    ry: f64,
    rotation: f64,
    start: f64,
    end: f64,
    ccw: bool
) -> Result<(), Error>

Trait Implementations

impl JSTraceable for CanvasState

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

impl MallocSizeOf for CanvasState

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.