skia-canvas 0.2.0

GPU-accelerated, multi-threaded HTML Canvas-compatible 2D rendering for Rust and Node, powered by Skia.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::fmt;

use crate::{
    backend::RenderEngine,
    color::{LinearColorSpace, OutputColorSpace},
    geometry::Rect,
    pixels::{PixelColorSpace, PixelDepth, PixelFormat},
};

#[derive(Debug, Clone, PartialEq)]
pub enum Error {
    InvalidDimensions {
        width: f32,
        height: f32,
    },
    InvalidRect {
        rect: Rect,
    },
    UnsupportedColorSpace {
        color_space: LinearColorSpace,
    },
    UnsupportedOutputColorSpace {
        color_space: OutputColorSpace,
    },
    UnsupportedPixelColorSpace {
        color_space: PixelColorSpace,
    },
    UnsupportedPixelFormat {
        pixel_format: PixelFormat,
    },
    UnsupportedPixelDepth {
        depth: PixelDepth,
    },
    InvalidStride {
        expected: usize,
        actual: usize,
    },
    InvalidByteLength {
        expected: usize,
        actual: usize,
    },
    SurfaceCreate {
        reason: String,
    },
    DecodeImage {
        reason: String,
    },
    InvalidSvgPath {
        reason: String,
    },
    InvalidGradient {
        reason: String,
    },
    FontRegister {
        reason: String,
    },
    FilterCreate {
        reason: String,
    },
    Render {
        reason: String,
    },
    PixelReadback {
        reason: String,
    },
    PixelWrite {
        reason: String,
    },
    /// Caller pinned [`RenderEngine::Gpu`] but no GPU backend is
    /// compiled in or the runtime cannot reach a device.
    EngineUnavailable {
        engine: RenderEngine,
        reason: String,
    },
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidDimensions { width, height } => {
                write!(f, "invalid dimensions: {width}x{height}")
            }
            Self::InvalidRect { rect } => write!(f, "invalid rect: {rect:?}"),
            Self::UnsupportedColorSpace { color_space } => {
                write!(f, "unsupported linear color space: {color_space:?}")
            }
            Self::UnsupportedOutputColorSpace { color_space } => {
                write!(f, "unsupported output color space: {color_space:?}")
            }
            Self::UnsupportedPixelColorSpace { color_space } => {
                write!(f, "unsupported pixel color space: {color_space:?}")
            }
            Self::UnsupportedPixelFormat { pixel_format } => {
                write!(f, "unsupported pixel format: {pixel_format:?}")
            }
            Self::UnsupportedPixelDepth { depth } => {
                write!(f, "unsupported pixel depth: {depth:?}")
            }
            Self::InvalidStride { expected, actual } => {
                write!(f, "invalid stride: expected {expected}, got {actual}")
            }
            Self::InvalidByteLength { expected, actual } => {
                write!(
                    f,
                    "invalid byte length: expected {expected}, got {actual}"
                )
            }
            Self::SurfaceCreate { reason } => {
                write!(f, "surface create failed: {reason}")
            }
            Self::DecodeImage { reason } => {
                write!(f, "decode image failed: {reason}")
            }
            Self::InvalidSvgPath { reason } => {
                write!(f, "invalid SVG path: {reason}")
            }
            Self::InvalidGradient { reason } => {
                write!(f, "invalid gradient: {reason}")
            }
            Self::FontRegister { reason } => {
                write!(f, "font register failed: {reason}")
            }
            Self::FilterCreate { reason } => {
                write!(f, "filter create failed: {reason}")
            }
            Self::Render { reason } => write!(f, "render failed: {reason}"),
            Self::PixelReadback { reason } => {
                write!(f, "pixel readback failed: {reason}")
            }
            Self::PixelWrite { reason } => {
                write!(f, "pixel write failed: {reason}")
            }
            Self::EngineUnavailable { engine, reason } => {
                write!(f, "render engine {engine:?} unavailable: {reason}")
            }
        }
    }
}

impl std::error::Error for Error {}