cairo/
error.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use crate::ffi;
4use std::{fmt, fmt::Debug, io};
5
6#[derive(Debug, Clone, PartialEq, Copy, Eq)]
7#[non_exhaustive]
8#[doc(alias = "cairo_status_t")]
9pub enum Error {
10    #[doc(alias = "STATUS_NO_MEMORY")]
11    NoMemory,
12    #[doc(alias = "STATUS_INVALID_RESTORE")]
13    InvalidRestore,
14    #[doc(alias = "STATUS_INVALID_POP_GROUP")]
15    InvalidPopGroup,
16    #[doc(alias = "STATUS_NO_CURRENT_POINT")]
17    NoCurrentPoint,
18    #[doc(alias = "STATUS_INVALID_MATRIX")]
19    InvalidMatrix,
20    #[doc(alias = "STATUS_INVALID_STATUS")]
21    InvalidStatus,
22    #[doc(alias = "STATUS_NULL_POINTER")]
23    NullPointer,
24    #[doc(alias = "STATUS_INVALID_STRING")]
25    InvalidString,
26    #[doc(alias = "STATUS_INVALID_PATH_DATA")]
27    InvalidPathData,
28    #[doc(alias = "STATUS_READ_ERROR")]
29    ReadError,
30    #[doc(alias = "STATUS_WRITE_ERROR")]
31    WriteError,
32    #[doc(alias = "STATUS_SURFACE_FINISHED")]
33    SurfaceFinished,
34    #[doc(alias = "STATUS_SURFACE_TYPE_MISMATCH")]
35    SurfaceTypeMismatch,
36    #[doc(alias = "STATUS_PATTERN_TYPE_MISMATCH")]
37    PatternTypeMismatch,
38    #[doc(alias = "STATUS_INVALID_CONTENT")]
39    InvalidContent,
40    #[doc(alias = "STATUS_INVALID_FORMAT")]
41    InvalidFormat,
42    #[doc(alias = "STATUS_INVALID_VISUAL")]
43    InvalidVisual,
44    #[doc(alias = "STATUS_FILE_NOT_FOUND")]
45    FileNotFound,
46    #[doc(alias = "STATUS_INVALID_DASH")]
47    InvalidDash,
48    #[doc(alias = "STATUS_INVALID_DSC_COMMENT")]
49    InvalidDscComment,
50    #[doc(alias = "STATUS_INVALID_INDEX")]
51    InvalidIndex,
52    #[doc(alias = "STATUS_CLIP_NOT_REPRESENTABLE")]
53    ClipNotRepresentable,
54    #[doc(alias = "STATUS_TEMP_FILE_ERROR")]
55    TempFileError,
56    #[doc(alias = "STATUS_INVALID_STRIDE")]
57    InvalidStride,
58    #[doc(alias = "STATUS_FONT_TYPE_MISMATCH")]
59    FontTypeMismatch,
60    #[doc(alias = "STATUS_USER_FONT_IMMUTABLE")]
61    UserFontImmutable,
62    #[doc(alias = "STATUS_USER_FONT_ERROR")]
63    UserFontError,
64    #[doc(alias = "STATUS_NEGATIVE_COUNT")]
65    NegativeCount,
66    #[doc(alias = "STATUS_INVALID_CLUSTERS")]
67    InvalidClusters,
68    #[doc(alias = "STATUS_INVALID_SLANT")]
69    InvalidSlant,
70    #[doc(alias = "STATUS_INVALID_WEIGHT")]
71    InvalidWeight,
72    #[doc(alias = "STATUS_INVALID_SIZE")]
73    InvalidSize,
74    #[doc(alias = "STATUS_USER_FONT_NOT_IMPLEMENTED")]
75    UserFontNotImplemented,
76    #[doc(alias = "STATUS_DEVICE_TYPE_MISMATCH")]
77    DeviceTypeMismatch,
78    #[doc(alias = "STATUS_DEVICE_ERROR")]
79    DeviceError,
80    #[doc(alias = "STATUS_INVALID_MESH_CONSTRUCTION")]
81    InvalidMeshConstruction,
82    #[doc(alias = "STATUS_DEVICE_FINISHED")]
83    DeviceFinished,
84    #[doc(alias = "STATUS_J_BIG2_GLOBAL_MISSING")]
85    JBig2GlobalMissing,
86    #[doc(alias = "STATUS_PNG_ERROR")]
87    PngError,
88    #[doc(alias = "STATUS_FREETYPE_ERROR")]
89    FreetypeError,
90    #[doc(alias = "STATUS_WIN32_GDI_ERROR")]
91    Win32GdiError,
92    #[cfg(feature = "v1_16")]
93    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
94    #[doc(alias = "STATUS_TAG_ERROR")]
95    TagError,
96    #[cfg(feature = "v1_18")]
97    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
98    #[doc(alias = "STATUS_DWRITE_ERROR")]
99    DwriteError,
100    #[doc(alias = "STATUS_LAST_STATUS")]
101    LastStatus,
102    #[doc(hidden)]
103    __Unknown(i32),
104}
105
106impl std::error::Error for Error {}
107
108impl fmt::Display for Error {
109    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
110        match self {
111            Error::NoMemory => fmt.write_str("No Memory"),
112            Error::InvalidRestore => fmt.write_str("Invalid Restore"),
113            Error::InvalidPopGroup => fmt.write_str("Invalid Pop Group"),
114            Error::NoCurrentPoint => fmt.write_str("No Current Point"),
115            Error::InvalidMatrix => fmt.write_str("Invalid Matrix"),
116            Error::InvalidStatus => fmt.write_str("Invalid Status"),
117            Error::NullPointer => fmt.write_str("Null Pointer"),
118            Error::InvalidString => fmt.write_str("Invalid String"),
119            Error::InvalidPathData => fmt.write_str("Invalid Path Data"),
120            Error::ReadError => fmt.write_str("Cairo : Read Error"),
121            Error::WriteError => fmt.write_str("Write Error"),
122            Error::SurfaceFinished => fmt.write_str("Surface Finished"),
123            Error::SurfaceTypeMismatch => fmt.write_str("Surface Type Mismatch"),
124            Error::PatternTypeMismatch => fmt.write_str("Pattern Type Mismatch"),
125            Error::InvalidContent => fmt.write_str("Invalid Content"),
126            Error::InvalidFormat => fmt.write_str("Invalid Format"),
127            Error::InvalidVisual => fmt.write_str("Invalid Visual"),
128            Error::FileNotFound => fmt.write_str("File Not Found"),
129            Error::InvalidDash => fmt.write_str("Invalid Dash"),
130            Error::InvalidDscComment => fmt.write_str("Invalid Dash Comment"),
131            Error::InvalidIndex => fmt.write_str("Invalid Index"),
132            Error::ClipNotRepresentable => fmt.write_str("Clip Not Representable"),
133            Error::TempFileError => fmt.write_str("Temp File Error"),
134            Error::InvalidStride => fmt.write_str("Invalid Stride"),
135            Error::FontTypeMismatch => fmt.write_str("Font Type Mismatch"),
136            Error::UserFontImmutable => fmt.write_str("User Font Immutable"),
137            Error::UserFontError => fmt.write_str("User Font Error"),
138            Error::NegativeCount => fmt.write_str("Negative Count"),
139            Error::InvalidClusters => fmt.write_str("Invalid Clusters"),
140            Error::InvalidSlant => fmt.write_str("Invalid Slant"),
141            Error::InvalidWeight => fmt.write_str("Invalid Weight"),
142            Error::InvalidSize => fmt.write_str("Invalid Size"),
143            Error::UserFontNotImplemented => fmt.write_str("User Font Not Implemented"),
144            Error::DeviceTypeMismatch => fmt.write_str("Device Type Mismatch"),
145            Error::DeviceError => fmt.write_str("Device Error"),
146            Error::InvalidMeshConstruction => fmt.write_str("Invalid Mesh Construction"),
147            Error::DeviceFinished => fmt.write_str("Device Finished"),
148            Error::JBig2GlobalMissing => fmt.write_str("JBig2Global Missing"),
149            Error::PngError => fmt.write_str("PNG Error"),
150            Error::FreetypeError => fmt.write_str("Freetype Error"),
151            Error::Win32GdiError => fmt.write_str("Win32Gdi Error"),
152            #[cfg(feature = "v1_16")]
153            Error::TagError => fmt.write_str("Tag error"),
154            #[cfg(feature = "v1_18")]
155            Error::DwriteError => fmt.write_str("Dwrite error"),
156            Error::LastStatus => fmt.write_str("LastStatus"),
157            Error::__Unknown(value) => write!(fmt, "Unknown {value}"),
158        }
159    }
160}
161
162#[doc(hidden)]
163impl From<Error> for ffi::cairo_status_t {
164    fn from(err: Error) -> Self {
165        match err {
166            Error::NoMemory => ffi::STATUS_NO_MEMORY,
167            Error::InvalidRestore => ffi::STATUS_INVALID_RESTORE,
168            Error::InvalidPopGroup => ffi::STATUS_INVALID_POP_GROUP,
169            Error::NoCurrentPoint => ffi::STATUS_NO_CURRENT_POINT,
170            Error::InvalidMatrix => ffi::STATUS_INVALID_MATRIX,
171            Error::InvalidStatus => ffi::STATUS_INVALID_STATUS,
172            Error::NullPointer => ffi::STATUS_NULL_POINTER,
173            Error::InvalidString => ffi::STATUS_INVALID_STRING,
174            Error::InvalidPathData => ffi::STATUS_INVALID_PATH_DATA,
175            Error::ReadError => ffi::STATUS_READ_ERROR,
176            Error::WriteError => ffi::STATUS_WRITE_ERROR,
177            Error::SurfaceFinished => ffi::STATUS_SURFACE_FINISHED,
178            Error::SurfaceTypeMismatch => ffi::STATUS_SURFACE_TYPE_MISMATCH,
179            Error::PatternTypeMismatch => ffi::STATUS_PATTERN_TYPE_MISMATCH,
180            Error::InvalidContent => ffi::STATUS_INVALID_CONTENT,
181            Error::InvalidFormat => ffi::STATUS_INVALID_FORMAT,
182            Error::InvalidVisual => ffi::STATUS_INVALID_VISUAL,
183            Error::FileNotFound => ffi::STATUS_FILE_NOT_FOUND,
184            Error::InvalidDash => ffi::STATUS_INVALID_DASH,
185            Error::InvalidDscComment => ffi::STATUS_INVALID_DSC_COMMENT,
186            Error::InvalidIndex => ffi::STATUS_INVALID_INDEX,
187            Error::ClipNotRepresentable => ffi::STATUS_CLIP_NOT_REPRESENTABLE,
188            Error::TempFileError => ffi::STATUS_TEMP_FILE_ERROR,
189            Error::InvalidStride => ffi::STATUS_INVALID_STRIDE,
190            Error::FontTypeMismatch => ffi::STATUS_FONT_TYPE_MISMATCH,
191            Error::UserFontImmutable => ffi::STATUS_USER_FONT_IMMUTABLE,
192            Error::UserFontError => ffi::STATUS_USER_FONT_ERROR,
193            Error::NegativeCount => ffi::STATUS_NEGATIVE_COUNT,
194            Error::InvalidClusters => ffi::STATUS_INVALID_CLUSTERS,
195            Error::InvalidSlant => ffi::STATUS_INVALID_SLANT,
196            Error::InvalidWeight => ffi::STATUS_INVALID_WEIGHT,
197            Error::InvalidSize => ffi::STATUS_INVALID_SIZE,
198            Error::UserFontNotImplemented => ffi::STATUS_USER_FONT_NOT_IMPLEMENTED,
199            Error::DeviceTypeMismatch => ffi::STATUS_DEVICE_TYPE_MISMATCH,
200            Error::DeviceError => ffi::STATUS_DEVICE_ERROR,
201            Error::InvalidMeshConstruction => ffi::STATUS_INVALID_MESH_CONSTRUCTION,
202            Error::DeviceFinished => ffi::STATUS_DEVICE_FINISHED,
203            Error::JBig2GlobalMissing => ffi::STATUS_J_BIG2_GLOBAL_MISSING,
204            Error::PngError => ffi::STATUS_PNG_ERROR,
205            Error::FreetypeError => ffi::STATUS_FREETYPE_ERROR,
206            Error::Win32GdiError => ffi::STATUS_WIN32_GDI_ERROR,
207            #[cfg(feature = "v1_16")]
208            Error::TagError => ffi::STATUS_TAG_ERROR,
209            #[cfg(feature = "v1_18")]
210            Error::DwriteError => ffi::STATUS_DWRITE_ERROR,
211            Error::LastStatus => ffi::STATUS_LAST_STATUS,
212            Error::__Unknown(value) => value,
213        }
214    }
215}
216
217#[doc(hidden)]
218impl From<ffi::cairo_status_t> for Error {
219    fn from(value: ffi::cairo_status_t) -> Self {
220        match value {
221            ffi::STATUS_NO_MEMORY => Self::NoMemory,
222            ffi::STATUS_INVALID_RESTORE => Self::InvalidRestore,
223            ffi::STATUS_INVALID_POP_GROUP => Self::InvalidPopGroup,
224            ffi::STATUS_NO_CURRENT_POINT => Self::NoCurrentPoint,
225            ffi::STATUS_INVALID_MATRIX => Self::InvalidMatrix,
226            ffi::STATUS_INVALID_STATUS => Self::InvalidStatus,
227            ffi::STATUS_NULL_POINTER => Self::NullPointer,
228            ffi::STATUS_INVALID_STRING => Self::InvalidString,
229            ffi::STATUS_INVALID_PATH_DATA => Self::InvalidPathData,
230            ffi::STATUS_READ_ERROR => Self::ReadError,
231            ffi::STATUS_WRITE_ERROR => Self::WriteError,
232            ffi::STATUS_SURFACE_FINISHED => Self::SurfaceFinished,
233            ffi::STATUS_SURFACE_TYPE_MISMATCH => Self::SurfaceTypeMismatch,
234            ffi::STATUS_PATTERN_TYPE_MISMATCH => Self::PatternTypeMismatch,
235            ffi::STATUS_INVALID_CONTENT => Self::InvalidContent,
236            ffi::STATUS_INVALID_FORMAT => Self::InvalidFormat,
237            ffi::STATUS_INVALID_VISUAL => Self::InvalidVisual,
238            ffi::STATUS_FILE_NOT_FOUND => Self::FileNotFound,
239            ffi::STATUS_INVALID_DASH => Self::InvalidDash,
240            ffi::STATUS_INVALID_DSC_COMMENT => Self::InvalidDscComment,
241            ffi::STATUS_INVALID_INDEX => Self::InvalidIndex,
242            ffi::STATUS_CLIP_NOT_REPRESENTABLE => Self::ClipNotRepresentable,
243            ffi::STATUS_TEMP_FILE_ERROR => Self::TempFileError,
244            ffi::STATUS_INVALID_STRIDE => Self::InvalidStride,
245            ffi::STATUS_FONT_TYPE_MISMATCH => Self::FontTypeMismatch,
246            ffi::STATUS_USER_FONT_IMMUTABLE => Self::UserFontImmutable,
247            ffi::STATUS_USER_FONT_ERROR => Self::UserFontError,
248            ffi::STATUS_NEGATIVE_COUNT => Self::NegativeCount,
249            ffi::STATUS_INVALID_CLUSTERS => Self::InvalidClusters,
250            ffi::STATUS_INVALID_SLANT => Self::InvalidSlant,
251            ffi::STATUS_INVALID_WEIGHT => Self::InvalidWeight,
252            ffi::STATUS_INVALID_SIZE => Self::InvalidSize,
253            ffi::STATUS_USER_FONT_NOT_IMPLEMENTED => Self::UserFontNotImplemented,
254            ffi::STATUS_DEVICE_TYPE_MISMATCH => Self::DeviceTypeMismatch,
255            ffi::STATUS_DEVICE_ERROR => Self::DeviceError,
256            ffi::STATUS_INVALID_MESH_CONSTRUCTION => Self::InvalidMeshConstruction,
257            ffi::STATUS_DEVICE_FINISHED => Self::DeviceFinished,
258            ffi::STATUS_J_BIG2_GLOBAL_MISSING => Self::JBig2GlobalMissing,
259            ffi::STATUS_PNG_ERROR => Self::PngError,
260            ffi::STATUS_FREETYPE_ERROR => Self::FreetypeError,
261            ffi::STATUS_WIN32_GDI_ERROR => Self::Win32GdiError,
262            #[cfg(feature = "v1_16")]
263            ffi::STATUS_TAG_ERROR => Error::TagError,
264            #[cfg(feature = "v1_18")]
265            ffi::STATUS_DWRITE_ERROR => Error::DwriteError,
266            ffi::STATUS_LAST_STATUS => Self::LastStatus,
267            value => Self::__Unknown(value),
268        }
269    }
270}
271
272#[derive(Debug)]
273pub enum IoError {
274    Cairo(Error),
275    Io(io::Error),
276}
277
278impl std::error::Error for IoError {
279    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
280        match self {
281            IoError::Cairo(err) => Some(err),
282            IoError::Io(err) => Some(err),
283        }
284    }
285}
286
287impl fmt::Display for IoError {
288    fn fmt(&self, fmt: &mut fmt::Formatter) -> ::core::fmt::Result {
289        match self {
290            IoError::Cairo(err) => write!(fmt, "Cairo error: {err}"),
291            IoError::Io(err) => write!(fmt, "IO error: {err}"),
292        }
293    }
294}
295
296impl std::convert::From<Error> for IoError {
297    fn from(source: Error) -> Self {
298        IoError::Cairo(source)
299    }
300}
301
302impl std::convert::From<io::Error> for IoError {
303    fn from(source: io::Error) -> Self {
304        IoError::Io(source)
305    }
306}
307
308#[derive(Debug)]
309pub enum BorrowError {
310    Cairo(crate::Error),
311    NonExclusive,
312}
313
314impl std::error::Error for BorrowError {
315    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
316        match self {
317            BorrowError::Cairo(err) => Some(err),
318            BorrowError::NonExclusive => None,
319        }
320    }
321}
322
323impl fmt::Display for BorrowError {
324    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
325        match self {
326            BorrowError::Cairo(err) => write!(fmt, "Failed to borrow with Cairo error: {err}"),
327            BorrowError::NonExclusive => fmt.write_str("Can't get exclusive access"),
328        }
329    }
330}
331
332impl std::convert::From<crate::Error> for BorrowError {
333    fn from(err: crate::Error) -> Self {
334        BorrowError::Cairo(err)
335    }
336}
337
338pub type Result<T> = std::result::Result<T, Error>;