1 // Take a look at the license at the top of the repository in the LICENSE file. 2 3 use std::fmt::{self, Debug}; 4 5 use crate::error::Error; 6 7 #[cfg(feature = "use_glib")] 8 use glib::translate::*; 9 10 // Helper macro for our GValue related trait impls 11 #[cfg(feature = "use_glib")] 12 macro_rules! gvalue_impl { 13 ($name:ty, $get_type:expr) => { 14 impl glib::types::StaticType for $name { 15 fn static_type() -> glib::Type { 16 unsafe { from_glib($get_type()) } 17 } 18 } 19 20 impl glib::value::ValueType for $name { 21 type Type = Self; 22 } 23 24 unsafe impl<'a> glib::value::FromValue<'a> for $name { 25 type Checker = glib::value::GenericValueTypeChecker<Self>; 26 27 unsafe fn from_value(value: &'a glib::Value) -> Self { 28 Self::from(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) 29 } 30 } 31 32 impl glib::value::ToValue for $name { 33 fn to_value(&self) -> glib::Value { 34 let mut value = glib::Value::for_value_type::<Self>(); 35 unsafe { 36 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, (*self).into()); 37 } 38 value 39 } 40 41 fn value_type(&self) -> glib::Type { 42 <Self as glib::StaticType>::static_type() 43 } 44 } 45 }; 46 } 47 48 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 49 #[non_exhaustive] 50 #[doc(alias = "cairo_antialias_t")] 51 pub enum Antialias { 52 #[doc(alias = "ANTIALIAS_DEFAULT")] 53 Default, 54 55 /* method */ 56 #[doc(alias = "ANTIALIAS_NONE")] 57 None, 58 #[doc(alias = "ANTIALIAS_GRAY")] 59 Gray, 60 #[doc(alias = "ANTIALIAS_SUBPIXEL")] 61 Subpixel, 62 63 /* hints */ 64 #[doc(alias = "ANTIALIAS_FAST")] 65 Fast, 66 #[doc(alias = "ANTIALIAS_GOOD")] 67 Good, 68 #[doc(alias = "ANTIALIAS_BEST")] 69 Best, 70 #[doc(hidden)] 71 __Unknown(i32), 72 } 73 74 #[doc(hidden)] 75 impl From<Antialias> for ffi::cairo_antialias_t { from(val: Antialias) -> ffi::cairo_antialias_t76 fn from(val: Antialias) -> ffi::cairo_antialias_t { 77 match val { 78 Antialias::Default => ffi::ANTIALIAS_DEFAULT, 79 Antialias::None => ffi::ANTIALIAS_NONE, 80 Antialias::Gray => ffi::ANTIALIAS_GRAY, 81 Antialias::Subpixel => ffi::ANTIALIAS_SUBPIXEL, 82 Antialias::Fast => ffi::ANTIALIAS_FAST, 83 Antialias::Good => ffi::ANTIALIAS_GOOD, 84 Antialias::Best => ffi::ANTIALIAS_BEST, 85 Antialias::__Unknown(value) => value, 86 } 87 } 88 } 89 90 #[doc(hidden)] 91 impl From<ffi::cairo_antialias_t> for Antialias { from(value: ffi::cairo_antialias_t) -> Self92 fn from(value: ffi::cairo_antialias_t) -> Self { 93 match value { 94 ffi::ANTIALIAS_DEFAULT => Self::Default, 95 ffi::ANTIALIAS_NONE => Self::None, 96 ffi::ANTIALIAS_GRAY => Self::Gray, 97 ffi::ANTIALIAS_SUBPIXEL => Self::Subpixel, 98 ffi::ANTIALIAS_FAST => Self::Fast, 99 ffi::ANTIALIAS_GOOD => Self::Good, 100 ffi::ANTIALIAS_BEST => Self::Best, 101 value => Self::__Unknown(value), 102 } 103 } 104 } 105 106 impl fmt::Display for Antialias { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result107 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 108 write!( 109 f, 110 "Self::{}", 111 match *self { 112 Self::Default => "Default", 113 Self::None => "None", 114 Self::Gray => "Gray", 115 Self::Subpixel => "Subpixel", 116 Self::Fast => "Fast", 117 Self::Good => "Good", 118 Self::Best => "Best", 119 _ => "Unknown", 120 } 121 ) 122 } 123 } 124 125 #[cfg(feature = "use_glib")] 126 gvalue_impl!(Antialias, ffi::gobject::cairo_gobject_antialias_get_type); 127 128 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 129 #[non_exhaustive] 130 #[doc(alias = "cairo_fill_rule_t")] 131 pub enum FillRule { 132 #[doc(alias = "FILL_RULE_WINDING")] 133 Winding, 134 #[doc(alias = "FILL_RULE_EVEN_ODD")] 135 EvenOdd, 136 #[doc(hidden)] 137 __Unknown(i32), 138 } 139 140 #[doc(hidden)] 141 impl From<FillRule> for ffi::cairo_fill_rule_t { from(val: FillRule) -> ffi::cairo_fill_rule_t142 fn from(val: FillRule) -> ffi::cairo_fill_rule_t { 143 match val { 144 FillRule::Winding => ffi::FILL_RULE_WINDING, 145 FillRule::EvenOdd => ffi::FILL_RULE_EVEN_ODD, 146 FillRule::__Unknown(value) => value, 147 } 148 } 149 } 150 151 #[doc(hidden)] 152 impl From<ffi::cairo_fill_rule_t> for FillRule { from(value: ffi::cairo_fill_rule_t) -> Self153 fn from(value: ffi::cairo_fill_rule_t) -> Self { 154 match value { 155 ffi::FILL_RULE_WINDING => Self::Winding, 156 ffi::FILL_RULE_EVEN_ODD => Self::EvenOdd, 157 value => Self::__Unknown(value), 158 } 159 } 160 } 161 162 impl fmt::Display for FillRule { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result163 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 164 write!( 165 f, 166 "Self::{}", 167 match *self { 168 Self::Winding => "Winding", 169 Self::EvenOdd => "EvenOdd", 170 _ => "Unknown", 171 } 172 ) 173 } 174 } 175 176 #[cfg(feature = "use_glib")] 177 gvalue_impl!(FillRule, ffi::gobject::cairo_gobject_fill_rule_get_type); 178 179 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 180 #[non_exhaustive] 181 #[doc(alias = "cairo_line_cap_t")] 182 pub enum LineCap { 183 #[doc(alias = "LINE_CAP_BUTT")] 184 Butt, 185 #[doc(alias = "LINE_CAP_ROUND")] 186 Round, 187 #[doc(alias = "LINE_CAP_SQUARE")] 188 Square, 189 #[doc(hidden)] 190 __Unknown(i32), 191 } 192 193 #[doc(hidden)] 194 impl From<LineCap> for ffi::cairo_line_cap_t { from(val: LineCap) -> ffi::cairo_line_cap_t195 fn from(val: LineCap) -> ffi::cairo_line_cap_t { 196 match val { 197 LineCap::Butt => ffi::LINE_CAP_BUTT, 198 LineCap::Round => ffi::LINE_CAP_ROUND, 199 LineCap::Square => ffi::LINE_CAP_SQUARE, 200 LineCap::__Unknown(value) => value, 201 } 202 } 203 } 204 205 #[doc(hidden)] 206 impl From<ffi::cairo_line_cap_t> for LineCap { from(value: ffi::cairo_line_cap_t) -> Self207 fn from(value: ffi::cairo_line_cap_t) -> Self { 208 match value { 209 ffi::LINE_CAP_BUTT => Self::Butt, 210 ffi::LINE_CAP_ROUND => Self::Round, 211 ffi::LINE_CAP_SQUARE => Self::Square, 212 value => Self::__Unknown(value), 213 } 214 } 215 } 216 217 impl fmt::Display for LineCap { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result218 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 219 write!( 220 f, 221 "Self::{}", 222 match *self { 223 Self::Butt => "Butt", 224 Self::Round => "Round", 225 Self::Square => "Square", 226 _ => "Unknown", 227 } 228 ) 229 } 230 } 231 232 #[cfg(feature = "use_glib")] 233 gvalue_impl!(LineCap, ffi::gobject::cairo_gobject_line_cap_get_type); 234 235 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 236 #[non_exhaustive] 237 #[doc(alias = "cairo_line_join_t")] 238 pub enum LineJoin { 239 #[doc(alias = "LINE_JOIN_MITER")] 240 Miter, 241 #[doc(alias = "LINE_JOIN_ROUND")] 242 Round, 243 #[doc(alias = "LINE_JOIN_BEVEL")] 244 Bevel, 245 #[doc(hidden)] 246 __Unknown(i32), 247 } 248 249 #[doc(hidden)] 250 impl From<LineJoin> for ffi::cairo_line_join_t { from(val: LineJoin) -> ffi::cairo_line_join_t251 fn from(val: LineJoin) -> ffi::cairo_line_join_t { 252 match val { 253 LineJoin::Miter => ffi::LINE_JOIN_MITER, 254 LineJoin::Round => ffi::LINE_JOIN_ROUND, 255 LineJoin::Bevel => ffi::LINE_JOIN_BEVEL, 256 LineJoin::__Unknown(value) => value, 257 } 258 } 259 } 260 261 #[doc(hidden)] 262 impl From<ffi::cairo_line_join_t> for LineJoin { from(value: ffi::cairo_line_join_t) -> Self263 fn from(value: ffi::cairo_line_join_t) -> Self { 264 match value { 265 ffi::LINE_JOIN_MITER => Self::Miter, 266 ffi::LINE_JOIN_ROUND => Self::Round, 267 ffi::LINE_JOIN_BEVEL => Self::Bevel, 268 value => Self::__Unknown(value), 269 } 270 } 271 } 272 273 impl fmt::Display for LineJoin { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result274 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 275 write!( 276 f, 277 "Self::{}", 278 match *self { 279 Self::Miter => "Miter", 280 Self::Round => "Round", 281 Self::Bevel => "Bevel", 282 _ => "Unknown", 283 } 284 ) 285 } 286 } 287 288 #[cfg(feature = "use_glib")] 289 gvalue_impl!(LineJoin, ffi::gobject::cairo_gobject_line_join_get_type); 290 291 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 292 #[non_exhaustive] 293 #[doc(alias = "cairo_operator_t")] 294 pub enum Operator { 295 #[doc(alias = "OPERATOR_CLEAR")] 296 Clear, 297 298 #[doc(alias = "OPERATOR_SOURCE")] 299 Source, 300 #[doc(alias = "OPERATOR_OVER")] 301 Over, 302 #[doc(alias = "OPERATOR_IN")] 303 In, 304 #[doc(alias = "OPERATOR_OUT")] 305 Out, 306 #[doc(alias = "OPERATOR_ATOP")] 307 Atop, 308 309 #[doc(alias = "OPERATOR_DEST")] 310 Dest, 311 #[doc(alias = "OPERATOR_DEST_OVER")] 312 DestOver, 313 #[doc(alias = "OPERATOR_DEST_IN")] 314 DestIn, 315 #[doc(alias = "OPERATOR_DEST_OUT")] 316 DestOut, 317 #[doc(alias = "OPERATOR_DEST_ATOP")] 318 DestAtop, 319 320 #[doc(alias = "OPERATOR_XOR")] 321 Xor, 322 #[doc(alias = "OPERATOR_ADD")] 323 Add, 324 #[doc(alias = "OPERATOR_SATURATE")] 325 Saturate, 326 327 #[doc(alias = "OPERATOR_MULTIPLY")] 328 Multiply, 329 #[doc(alias = "OPERATOR_SCREEN")] 330 Screen, 331 #[doc(alias = "OPERATOR_OVERLAY")] 332 Overlay, 333 #[doc(alias = "OPERATOR_DARKEN")] 334 Darken, 335 #[doc(alias = "OPERATOR_LIGHTEN")] 336 Lighten, 337 #[doc(alias = "OPERATOR_COLOR_DODGE")] 338 ColorDodge, 339 #[doc(alias = "OPERATOR_COLOR_BURN")] 340 ColorBurn, 341 #[doc(alias = "OPERATOR_HARD_LIGHT")] 342 HardLight, 343 #[doc(alias = "OPERATOR_SOFT_LIGHT")] 344 SoftLight, 345 #[doc(alias = "OPERATOR_DIFFERENCE")] 346 Difference, 347 #[doc(alias = "OPERATOR_EXCLUSION")] 348 Exclusion, 349 #[doc(alias = "OPERATOR_HSL_HUE")] 350 HslHue, 351 #[doc(alias = "OPERATOR_HSL_SATURATION")] 352 HslSaturation, 353 #[doc(alias = "OPERATOR_HSL_COLOR")] 354 HslColor, 355 #[doc(alias = "OPERATOR_HSL_LUMINOSITY")] 356 HslLuminosity, 357 #[doc(hidden)] 358 __Unknown(i32), 359 } 360 361 #[doc(hidden)] 362 impl From<Operator> for ffi::cairo_operator_t { from(val: Operator) -> ffi::cairo_operator_t363 fn from(val: Operator) -> ffi::cairo_operator_t { 364 match val { 365 Operator::Clear => ffi::OPERATOR_CLEAR, 366 Operator::Source => ffi::OPERATOR_SOURCE, 367 Operator::Over => ffi::OPERATOR_OVER, 368 Operator::In => ffi::OPERATOR_IN, 369 Operator::Out => ffi::OPERATOR_OUT, 370 Operator::Atop => ffi::OPERATOR_ATOP, 371 Operator::Dest => ffi::OPERATOR_DEST, 372 Operator::DestOver => ffi::OPERATOR_DEST_OVER, 373 Operator::DestIn => ffi::OPERATOR_DEST_IN, 374 Operator::DestOut => ffi::OPERATOR_DEST_OUT, 375 Operator::DestAtop => ffi::OPERATOR_DEST_ATOP, 376 Operator::Xor => ffi::OPERATOR_XOR, 377 Operator::Add => ffi::OPERATOR_ADD, 378 Operator::Saturate => ffi::OPERATOR_SATURATE, 379 Operator::Multiply => ffi::OPERATOR_MULTIPLY, 380 Operator::Screen => ffi::OPERATOR_SCREEN, 381 Operator::Overlay => ffi::OPERATOR_OVERLAY, 382 Operator::Darken => ffi::OPERATOR_DARKEN, 383 Operator::Lighten => ffi::OPERATOR_LIGHTEN, 384 Operator::ColorDodge => ffi::OPERATOR_COLOR_DODGE, 385 Operator::ColorBurn => ffi::OPERATOR_COLOR_BURN, 386 Operator::HardLight => ffi::OPERATOR_HARD_LIGHT, 387 Operator::SoftLight => ffi::OPERATOR_SOFT_LIGHT, 388 Operator::Difference => ffi::OPERATOR_DIFFERENCE, 389 Operator::Exclusion => ffi::OPERATOR_EXCLUSION, 390 Operator::HslHue => ffi::OPERATOR_HSL_HUE, 391 Operator::HslSaturation => ffi::OPERATOR_HSL_SATURATION, 392 Operator::HslColor => ffi::OPERATOR_HSL_COLOR, 393 Operator::HslLuminosity => ffi::OPERATOR_HSL_LUMINOSITY, 394 Operator::__Unknown(value) => value, 395 } 396 } 397 } 398 399 #[doc(hidden)] 400 impl From<ffi::cairo_operator_t> for Operator { from(value: ffi::cairo_operator_t) -> Self401 fn from(value: ffi::cairo_operator_t) -> Self { 402 match value { 403 ffi::OPERATOR_CLEAR => Self::Clear, 404 ffi::OPERATOR_SOURCE => Self::Source, 405 ffi::OPERATOR_OVER => Self::Over, 406 ffi::OPERATOR_IN => Self::In, 407 ffi::OPERATOR_OUT => Self::Out, 408 ffi::OPERATOR_ATOP => Self::Atop, 409 ffi::OPERATOR_DEST => Self::Dest, 410 ffi::OPERATOR_DEST_OVER => Self::DestOver, 411 ffi::OPERATOR_DEST_IN => Self::DestIn, 412 ffi::OPERATOR_DEST_OUT => Self::DestOut, 413 ffi::OPERATOR_DEST_ATOP => Self::DestAtop, 414 ffi::OPERATOR_XOR => Self::Xor, 415 ffi::OPERATOR_ADD => Self::Add, 416 ffi::OPERATOR_SATURATE => Self::Saturate, 417 ffi::OPERATOR_MULTIPLY => Self::Multiply, 418 ffi::OPERATOR_SCREEN => Self::Screen, 419 ffi::OPERATOR_OVERLAY => Self::Overlay, 420 ffi::OPERATOR_DARKEN => Self::Darken, 421 ffi::OPERATOR_LIGHTEN => Self::Lighten, 422 ffi::OPERATOR_COLOR_DODGE => Self::ColorDodge, 423 ffi::OPERATOR_COLOR_BURN => Self::ColorBurn, 424 ffi::OPERATOR_HARD_LIGHT => Self::HardLight, 425 ffi::OPERATOR_SOFT_LIGHT => Self::SoftLight, 426 ffi::OPERATOR_DIFFERENCE => Self::Difference, 427 ffi::OPERATOR_EXCLUSION => Self::Exclusion, 428 ffi::OPERATOR_HSL_HUE => Self::HslHue, 429 ffi::OPERATOR_HSL_SATURATION => Self::HslSaturation, 430 ffi::OPERATOR_HSL_COLOR => Self::HslColor, 431 ffi::OPERATOR_HSL_LUMINOSITY => Self::HslLuminosity, 432 value => Self::__Unknown(value), 433 } 434 } 435 } 436 437 impl fmt::Display for Operator { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result438 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 439 write!( 440 f, 441 "Self::{}", 442 match *self { 443 Self::Clear => "Clear", 444 Self::Source => "Source", 445 Self::Over => "Over", 446 Self::In => "In", 447 Self::Out => "Out", 448 Self::Atop => "Atop", 449 Self::Dest => "Dest", 450 Self::DestOver => "DestOver", 451 Self::DestIn => "DestIn", 452 Self::DestOut => "DestOut", 453 Self::DestAtop => "DestAtop", 454 Self::Xor => "Xor", 455 Self::Add => "Add", 456 Self::Saturate => "Saturate", 457 Self::Multiply => "Multiply", 458 Self::Screen => "Screen", 459 Self::Overlay => "Overlay", 460 Self::Darken => "Darken", 461 Self::Lighten => "Lighten", 462 Self::ColorDodge => "ColorDodge", 463 Self::ColorBurn => "ColorBurn", 464 Self::HardLight => "HardLight", 465 Self::SoftLight => "SoftLight", 466 Self::Difference => "Difference", 467 Self::Exclusion => "Exclusion", 468 Self::HslHue => "HslHue", 469 Self::HslSaturation => "HslSaturation", 470 Self::HslColor => "HslColor", 471 Self::HslLuminosity => "HslLuminosity", 472 _ => "Unknown", 473 } 474 ) 475 } 476 } 477 478 #[cfg(feature = "use_glib")] 479 gvalue_impl!(Operator, ffi::gobject::cairo_gobject_operator_get_type); 480 481 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 482 #[non_exhaustive] 483 #[doc(alias = "cairo_path_data_type_t")] 484 pub enum PathDataType { 485 #[doc(alias = "PATH_DATA_TYPE_MOVE_TO")] 486 MoveTo, 487 #[doc(alias = "PATH_DATA_TYPE_LINE_TO")] 488 LineTo, 489 #[doc(alias = "PATH_DATA_TYPE_CURVE_TO")] 490 CurveTo, 491 #[doc(alias = "PATH_DATA_TYPE_CLOSE_PATH")] 492 ClosePath, 493 #[doc(hidden)] 494 __Unknown(i32), 495 } 496 497 #[doc(hidden)] 498 impl From<PathDataType> for ffi::cairo_path_data_type_t { from(val: PathDataType) -> ffi::cairo_path_data_type_t499 fn from(val: PathDataType) -> ffi::cairo_path_data_type_t { 500 match val { 501 PathDataType::MoveTo => ffi::PATH_DATA_TYPE_MOVE_TO, 502 PathDataType::LineTo => ffi::PATH_DATA_TYPE_LINE_TO, 503 PathDataType::CurveTo => ffi::PATH_DATA_TYPE_CURVE_TO, 504 PathDataType::ClosePath => ffi::PATH_DATA_TYPE_CLOSE_PATH, 505 PathDataType::__Unknown(value) => value, 506 } 507 } 508 } 509 510 #[doc(hidden)] 511 impl From<ffi::cairo_path_data_type_t> for PathDataType { from(value: ffi::cairo_path_data_type_t) -> Self512 fn from(value: ffi::cairo_path_data_type_t) -> Self { 513 match value { 514 ffi::PATH_DATA_TYPE_MOVE_TO => Self::MoveTo, 515 ffi::PATH_DATA_TYPE_LINE_TO => Self::LineTo, 516 ffi::PATH_DATA_TYPE_CURVE_TO => Self::CurveTo, 517 ffi::PATH_DATA_TYPE_CLOSE_PATH => Self::ClosePath, 518 value => Self::__Unknown(value), 519 } 520 } 521 } 522 523 impl fmt::Display for PathDataType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result524 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 525 write!( 526 f, 527 "Self::{}", 528 match *self { 529 Self::MoveTo => "MoveTo", 530 Self::LineTo => "LineTo", 531 Self::CurveTo => "CurveTo", 532 Self::ClosePath => "ClosePath", 533 _ => "Unknown", 534 } 535 ) 536 } 537 } 538 539 #[cfg(feature = "use_glib")] 540 gvalue_impl!( 541 PathDataType, 542 ffi::gobject::cairo_gobject_path_data_type_get_type 543 ); 544 545 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 546 #[non_exhaustive] 547 #[doc(alias = "cairo_content_t")] 548 pub enum Content { 549 #[doc(alias = "CONTENT_COLOR")] 550 Color, 551 #[doc(alias = "CONTENT_ALPHA")] 552 Alpha, 553 #[doc(alias = "CONTENT_COLOR_ALPHA")] 554 ColorAlpha, 555 #[doc(hidden)] 556 __Unknown(i32), 557 } 558 559 #[doc(hidden)] 560 impl From<Content> for ffi::cairo_content_t { from(val: Content) -> ffi::cairo_content_t561 fn from(val: Content) -> ffi::cairo_content_t { 562 match val { 563 Content::Color => ffi::CONTENT_COLOR, 564 Content::Alpha => ffi::CONTENT_ALPHA, 565 Content::ColorAlpha => ffi::CONTENT_COLOR_ALPHA, 566 Content::__Unknown(value) => value, 567 } 568 } 569 } 570 571 #[doc(hidden)] 572 impl From<ffi::cairo_content_t> for Content { from(value: ffi::cairo_content_t) -> Self573 fn from(value: ffi::cairo_content_t) -> Self { 574 match value { 575 ffi::CONTENT_COLOR => Self::Color, 576 ffi::CONTENT_ALPHA => Self::Alpha, 577 ffi::CONTENT_COLOR_ALPHA => Self::ColorAlpha, 578 value => Self::__Unknown(value), 579 } 580 } 581 } 582 583 impl fmt::Display for Content { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result584 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 585 write!( 586 f, 587 "Self::{}", 588 match *self { 589 Self::Color => "Color", 590 Self::Alpha => "Alpha", 591 Self::ColorAlpha => "ColorAlpha", 592 _ => "Unknown", 593 } 594 ) 595 } 596 } 597 598 #[cfg(feature = "use_glib")] 599 gvalue_impl!(Content, ffi::gobject::cairo_gobject_content_get_type); 600 601 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 602 #[non_exhaustive] 603 #[doc(alias = "cairo_extend_t")] 604 pub enum Extend { 605 #[doc(alias = "EXTEND_NONE")] 606 None, 607 #[doc(alias = "EXTEND_REPEAT")] 608 Repeat, 609 #[doc(alias = "EXTEND_REFLECT")] 610 Reflect, 611 #[doc(alias = "EXTEND_PAD")] 612 Pad, 613 #[doc(hidden)] 614 __Unknown(i32), 615 } 616 617 #[doc(hidden)] 618 impl From<Extend> for ffi::cairo_extend_t { from(val: Extend) -> ffi::cairo_extend_t619 fn from(val: Extend) -> ffi::cairo_extend_t { 620 match val { 621 Extend::None => ffi::EXTEND_NONE, 622 Extend::Repeat => ffi::EXTEND_REPEAT, 623 Extend::Reflect => ffi::EXTEND_REFLECT, 624 Extend::Pad => ffi::EXTEND_PAD, 625 Extend::__Unknown(value) => value, 626 } 627 } 628 } 629 630 #[doc(hidden)] 631 impl From<ffi::cairo_extend_t> for Extend { from(value: ffi::cairo_extend_t) -> Self632 fn from(value: ffi::cairo_extend_t) -> Self { 633 match value { 634 ffi::EXTEND_NONE => Self::None, 635 ffi::EXTEND_REPEAT => Self::Repeat, 636 ffi::EXTEND_REFLECT => Self::Reflect, 637 ffi::EXTEND_PAD => Self::Pad, 638 value => Self::__Unknown(value), 639 } 640 } 641 } 642 643 impl fmt::Display for Extend { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result644 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 645 write!( 646 f, 647 "Self::{}", 648 match *self { 649 Self::None => "None", 650 Self::Repeat => "Repeat", 651 Self::Reflect => "Reflect", 652 Self::Pad => "Pad", 653 _ => "Unknown", 654 } 655 ) 656 } 657 } 658 659 #[cfg(feature = "use_glib")] 660 gvalue_impl!(Extend, ffi::gobject::cairo_gobject_extend_get_type); 661 662 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 663 #[non_exhaustive] 664 #[doc(alias = "cairo_filter_t")] 665 pub enum Filter { 666 #[doc(alias = "FILTER_FAST")] 667 Fast, 668 #[doc(alias = "FILTER_GOOD")] 669 Good, 670 #[doc(alias = "FILTER_BEST")] 671 Best, 672 #[doc(alias = "FILTER_NEAREST")] 673 Nearest, 674 #[doc(alias = "FILTER_BILINEAR")] 675 Bilinear, 676 #[doc(alias = "FILTER_GAUSSIAN")] 677 Gaussian, 678 #[doc(hidden)] 679 __Unknown(i32), 680 } 681 682 #[doc(hidden)] 683 impl From<Filter> for ffi::cairo_filter_t { from(val: Filter) -> ffi::cairo_filter_t684 fn from(val: Filter) -> ffi::cairo_filter_t { 685 match val { 686 Filter::Fast => ffi::FILTER_FAST, 687 Filter::Good => ffi::FILTER_GOOD, 688 Filter::Best => ffi::FILTER_BEST, 689 Filter::Nearest => ffi::FILTER_NEAREST, 690 Filter::Bilinear => ffi::FILTER_BILINEAR, 691 Filter::Gaussian => ffi::FILTER_GAUSSIAN, 692 Filter::__Unknown(value) => value, 693 } 694 } 695 } 696 697 #[doc(hidden)] 698 impl From<ffi::cairo_filter_t> for Filter { from(value: ffi::cairo_filter_t) -> Self699 fn from(value: ffi::cairo_filter_t) -> Self { 700 match value { 701 ffi::FILTER_FAST => Self::Fast, 702 ffi::FILTER_GOOD => Self::Good, 703 ffi::FILTER_BEST => Self::Best, 704 ffi::FILTER_NEAREST => Self::Nearest, 705 ffi::FILTER_BILINEAR => Self::Bilinear, 706 ffi::FILTER_GAUSSIAN => Self::Gaussian, 707 value => Self::__Unknown(value), 708 } 709 } 710 } 711 712 impl fmt::Display for Filter { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result713 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 714 write!( 715 f, 716 "Self::{}", 717 match *self { 718 Self::Fast => "Fast", 719 Self::Good => "Good", 720 Self::Best => "Best", 721 Self::Nearest => "Nearest", 722 Self::Bilinear => "Bilinear", 723 Self::Gaussian => "Gaussian", 724 _ => "Unknown", 725 } 726 ) 727 } 728 } 729 730 #[cfg(feature = "use_glib")] 731 gvalue_impl!(Filter, ffi::gobject::cairo_gobject_filter_get_type); 732 733 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 734 #[non_exhaustive] 735 #[doc(alias = "cairo_pattern_type_t")] 736 pub enum PatternType { 737 #[doc(alias = "PATTERN_TYPE_SOLID")] 738 Solid, 739 #[doc(alias = "PATTERN_TYPE_SURFACE")] 740 Surface, 741 #[doc(alias = "PATTERN_TYPE_LINEAR_GRADIENT")] 742 LinearGradient, 743 #[doc(alias = "PATTERN_TYPE_RADIAL_GRADIENT")] 744 RadialGradient, 745 #[doc(alias = "PATTERN_TYPE_MESH")] 746 Mesh, 747 #[doc(alias = "PATTERN_TYPE_RASTER_SOURCE")] 748 RasterSource, 749 #[doc(hidden)] 750 __Unknown(i32), 751 } 752 753 #[doc(hidden)] 754 impl From<PatternType> for ffi::cairo_pattern_type_t { from(val: PatternType) -> ffi::cairo_pattern_type_t755 fn from(val: PatternType) -> ffi::cairo_pattern_type_t { 756 match val { 757 PatternType::Solid => ffi::PATTERN_TYPE_SOLID, 758 PatternType::Surface => ffi::PATTERN_TYPE_SURFACE, 759 PatternType::LinearGradient => ffi::PATTERN_TYPE_LINEAR_GRADIENT, 760 PatternType::RadialGradient => ffi::PATTERN_TYPE_RADIAL_GRADIENT, 761 PatternType::Mesh => ffi::PATTERN_TYPE_MESH, 762 PatternType::RasterSource => ffi::PATTERN_TYPE_RASTER_SOURCE, 763 PatternType::__Unknown(value) => value, 764 } 765 } 766 } 767 768 #[doc(hidden)] 769 impl From<ffi::cairo_pattern_type_t> for PatternType { from(value: ffi::cairo_pattern_type_t) -> Self770 fn from(value: ffi::cairo_pattern_type_t) -> Self { 771 match value { 772 ffi::PATTERN_TYPE_SOLID => Self::Solid, 773 ffi::PATTERN_TYPE_SURFACE => Self::Surface, 774 ffi::PATTERN_TYPE_LINEAR_GRADIENT => Self::LinearGradient, 775 ffi::PATTERN_TYPE_RADIAL_GRADIENT => Self::RadialGradient, 776 ffi::PATTERN_TYPE_MESH => Self::Mesh, 777 ffi::PATTERN_TYPE_RASTER_SOURCE => Self::RasterSource, 778 value => Self::__Unknown(value), 779 } 780 } 781 } 782 783 impl fmt::Display for PatternType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result784 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 785 write!( 786 f, 787 "Self::{}", 788 match *self { 789 Self::Solid => "Solid", 790 Self::Surface => "Surface", 791 Self::LinearGradient => "LinearGradient", 792 Self::RadialGradient => "RadialGradient", 793 Self::Mesh => "Mesh", 794 Self::RasterSource => "RasterSource", 795 _ => "Unknown", 796 } 797 ) 798 } 799 } 800 801 #[cfg(feature = "use_glib")] 802 gvalue_impl!( 803 PatternType, 804 ffi::gobject::cairo_gobject_pattern_type_get_type 805 ); 806 807 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 808 #[non_exhaustive] 809 #[doc(alias = "cairo_font_slant_t")] 810 pub enum FontSlant { 811 #[doc(alias = "FONT_SLANT_NORMAL")] 812 Normal, 813 #[doc(alias = "FONT_SLANT_ITALIC")] 814 Italic, 815 #[doc(alias = "FONT_SLANT_OBLIQUE")] 816 Oblique, 817 #[doc(hidden)] 818 __Unknown(i32), 819 } 820 821 #[doc(hidden)] 822 impl From<FontSlant> for ffi::cairo_font_slant_t { from(val: FontSlant) -> ffi::cairo_font_slant_t823 fn from(val: FontSlant) -> ffi::cairo_font_slant_t { 824 match val { 825 FontSlant::Normal => ffi::FONT_SLANT_NORMAL, 826 FontSlant::Italic => ffi::FONT_SLANT_ITALIC, 827 FontSlant::Oblique => ffi::FONT_SLANT_OBLIQUE, 828 FontSlant::__Unknown(value) => value, 829 } 830 } 831 } 832 833 #[doc(hidden)] 834 impl From<ffi::cairo_font_slant_t> for FontSlant { from(value: ffi::cairo_font_slant_t) -> Self835 fn from(value: ffi::cairo_font_slant_t) -> Self { 836 match value { 837 ffi::FONT_SLANT_NORMAL => Self::Normal, 838 ffi::FONT_SLANT_ITALIC => Self::Italic, 839 ffi::FONT_SLANT_OBLIQUE => Self::Oblique, 840 value => Self::__Unknown(value), 841 } 842 } 843 } 844 845 impl fmt::Display for FontSlant { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result846 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 847 write!( 848 f, 849 "Self::{}", 850 match *self { 851 Self::Normal => "Normal", 852 Self::Italic => "Italic", 853 Self::Oblique => "Oblique", 854 _ => "Unknown", 855 } 856 ) 857 } 858 } 859 860 #[cfg(feature = "use_glib")] 861 gvalue_impl!(FontSlant, ffi::gobject::cairo_gobject_font_slant_get_type); 862 863 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 864 #[non_exhaustive] 865 #[doc(alias = "cairo_font_weight_t")] 866 pub enum FontWeight { 867 #[doc(alias = "FONT_WEIGHT_NORMAL")] 868 Normal, 869 #[doc(alias = "FONT_WEIGHT_BOLD")] 870 Bold, 871 #[doc(hidden)] 872 __Unknown(i32), 873 } 874 875 #[doc(hidden)] 876 impl From<FontWeight> for ffi::cairo_font_weight_t { from(val: FontWeight) -> ffi::cairo_font_weight_t877 fn from(val: FontWeight) -> ffi::cairo_font_weight_t { 878 match val { 879 FontWeight::Normal => ffi::FONT_WEIGHT_NORMAL, 880 FontWeight::Bold => ffi::FONT_WEIGHT_BOLD, 881 FontWeight::__Unknown(value) => value, 882 } 883 } 884 } 885 886 #[doc(hidden)] 887 impl From<ffi::cairo_font_weight_t> for FontWeight { from(value: ffi::cairo_font_weight_t) -> Self888 fn from(value: ffi::cairo_font_weight_t) -> Self { 889 match value { 890 ffi::FONT_WEIGHT_NORMAL => Self::Normal, 891 ffi::FONT_WEIGHT_BOLD => Self::Bold, 892 value => Self::__Unknown(value), 893 } 894 } 895 } 896 897 impl fmt::Display for FontWeight { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result898 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 899 write!( 900 f, 901 "Self::{}", 902 match *self { 903 Self::Normal => "Normal", 904 Self::Bold => "Bold", 905 _ => "Unknown", 906 } 907 ) 908 } 909 } 910 911 #[cfg(feature = "use_glib")] 912 gvalue_impl!(FontWeight, ffi::gobject::cairo_gobject_font_weight_get_type); 913 914 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 915 #[non_exhaustive] 916 #[doc(alias = "cairo_text_cluster_flags_t")] 917 pub enum TextClusterFlags { 918 #[doc(alias = "TEXT_CLUSTER_FLAGS_NONE")] 919 None, 920 #[doc(alias = "TEXT_CLUSTER_FLAGS_BACKWARD")] 921 Backward, 922 #[doc(hidden)] 923 __Unknown(i32), 924 } 925 926 #[doc(hidden)] 927 impl From<TextClusterFlags> for ffi::cairo_text_cluster_flags_t { from(val: TextClusterFlags) -> ffi::cairo_text_cluster_flags_t928 fn from(val: TextClusterFlags) -> ffi::cairo_text_cluster_flags_t { 929 match val { 930 TextClusterFlags::None => ffi::TEXT_CLUSTER_FLAGS_NONE, 931 TextClusterFlags::Backward => ffi::TEXT_CLUSTER_FLAGS_BACKWARD, 932 TextClusterFlags::__Unknown(value) => value, 933 } 934 } 935 } 936 937 #[doc(hidden)] 938 impl From<ffi::cairo_text_cluster_flags_t> for TextClusterFlags { from(value: ffi::cairo_text_cluster_flags_t) -> Self939 fn from(value: ffi::cairo_text_cluster_flags_t) -> Self { 940 match value { 941 ffi::TEXT_CLUSTER_FLAGS_NONE => Self::None, 942 ffi::TEXT_CLUSTER_FLAGS_BACKWARD => Self::Backward, 943 value => Self::__Unknown(value), 944 } 945 } 946 } 947 948 impl fmt::Display for TextClusterFlags { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result949 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 950 write!( 951 f, 952 "Self::{}", 953 match *self { 954 Self::None => "None", 955 Self::Backward => "Backward", 956 _ => "Unknown", 957 } 958 ) 959 } 960 } 961 962 #[cfg(feature = "use_glib")] 963 gvalue_impl!( 964 TextClusterFlags, 965 ffi::gobject::cairo_gobject_text_cluster_flags_get_type 966 ); 967 968 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 969 #[non_exhaustive] 970 #[doc(alias = "cairo_font_type_t")] 971 pub enum FontType { 972 #[doc(alias = "FONT_TYPE_FONT_TYPE_TOY")] 973 FontTypeToy, 974 #[doc(alias = "FONT_TYPE_FONT_TYPE_FT")] 975 FontTypeFt, 976 #[doc(alias = "FONT_TYPE_FONT_TYPE_WIN32")] 977 FontTypeWin32, 978 #[doc(alias = "FONT_TYPE_FONT_TYPE_QUARTZ")] 979 FontTypeQuartz, 980 #[doc(alias = "FONT_TYPE_FONT_TYPE_USER")] 981 FontTypeUser, 982 #[doc(hidden)] 983 __Unknown(i32), 984 } 985 986 #[doc(hidden)] 987 impl From<FontType> for ffi::cairo_font_type_t { from(val: FontType) -> ffi::cairo_font_type_t988 fn from(val: FontType) -> ffi::cairo_font_type_t { 989 match val { 990 FontType::FontTypeToy => ffi::FONT_TYPE_FONT_TYPE_TOY, 991 FontType::FontTypeFt => ffi::FONT_TYPE_FONT_TYPE_FT, 992 FontType::FontTypeWin32 => ffi::FONT_TYPE_FONT_TYPE_WIN32, 993 FontType::FontTypeQuartz => ffi::FONT_TYPE_FONT_TYPE_QUARTZ, 994 FontType::FontTypeUser => ffi::FONT_TYPE_FONT_TYPE_USER, 995 FontType::__Unknown(value) => value, 996 } 997 } 998 } 999 1000 #[doc(hidden)] 1001 impl From<ffi::cairo_font_type_t> for FontType { from(value: ffi::cairo_font_type_t) -> Self1002 fn from(value: ffi::cairo_font_type_t) -> Self { 1003 match value { 1004 ffi::FONT_TYPE_FONT_TYPE_TOY => Self::FontTypeToy, 1005 ffi::FONT_TYPE_FONT_TYPE_FT => Self::FontTypeFt, 1006 ffi::FONT_TYPE_FONT_TYPE_WIN32 => Self::FontTypeWin32, 1007 ffi::FONT_TYPE_FONT_TYPE_QUARTZ => Self::FontTypeQuartz, 1008 ffi::FONT_TYPE_FONT_TYPE_USER => Self::FontTypeUser, 1009 value => Self::__Unknown(value), 1010 } 1011 } 1012 } 1013 1014 impl fmt::Display for FontType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1015 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1016 write!( 1017 f, 1018 "Self::{}", 1019 match *self { 1020 Self::FontTypeToy => "FontTypeToy", 1021 Self::FontTypeFt => "FontTypeFt", 1022 Self::FontTypeWin32 => "FontTypeWin32", 1023 Self::FontTypeQuartz => "FontTypeQuartz", 1024 Self::FontTypeUser => "FontTypeUser", 1025 _ => "Unknown", 1026 } 1027 ) 1028 } 1029 } 1030 1031 #[cfg(feature = "use_glib")] 1032 gvalue_impl!(FontType, ffi::gobject::cairo_gobject_font_type_get_type); 1033 1034 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 1035 #[non_exhaustive] 1036 #[doc(alias = "cairo_subpixel_order_t")] 1037 pub enum SubpixelOrder { 1038 #[doc(alias = "SUBPIXEL_ORDER_DEFAULT")] 1039 Default, 1040 #[doc(alias = "SUBPIXEL_ORDER_RGB")] 1041 Rgb, 1042 #[doc(alias = "SUBPIXEL_ORDER_BGR")] 1043 Bgr, 1044 #[doc(alias = "SUBPIXEL_ORDER_VRGB")] 1045 Vrgb, 1046 #[doc(alias = "SUBPIXEL_ORDER_VBGR")] 1047 Vbgr, 1048 #[doc(hidden)] 1049 __Unknown(i32), 1050 } 1051 1052 #[doc(hidden)] 1053 impl From<SubpixelOrder> for ffi::cairo_subpixel_order_t { from(val: SubpixelOrder) -> ffi::cairo_subpixel_order_t1054 fn from(val: SubpixelOrder) -> ffi::cairo_subpixel_order_t { 1055 match val { 1056 SubpixelOrder::Default => ffi::SUBPIXEL_ORDER_DEFAULT, 1057 SubpixelOrder::Rgb => ffi::SUBPIXEL_ORDER_RGB, 1058 SubpixelOrder::Bgr => ffi::SUBPIXEL_ORDER_BGR, 1059 SubpixelOrder::Vrgb => ffi::SUBPIXEL_ORDER_VRGB, 1060 SubpixelOrder::Vbgr => ffi::SUBPIXEL_ORDER_VBGR, 1061 SubpixelOrder::__Unknown(value) => value, 1062 } 1063 } 1064 } 1065 1066 #[doc(hidden)] 1067 impl From<ffi::cairo_subpixel_order_t> for SubpixelOrder { from(value: ffi::cairo_subpixel_order_t) -> Self1068 fn from(value: ffi::cairo_subpixel_order_t) -> Self { 1069 match value { 1070 ffi::SUBPIXEL_ORDER_DEFAULT => Self::Default, 1071 ffi::SUBPIXEL_ORDER_RGB => Self::Rgb, 1072 ffi::SUBPIXEL_ORDER_BGR => Self::Bgr, 1073 ffi::SUBPIXEL_ORDER_VRGB => Self::Vrgb, 1074 ffi::SUBPIXEL_ORDER_VBGR => Self::Vbgr, 1075 value => Self::__Unknown(value), 1076 } 1077 } 1078 } 1079 1080 impl fmt::Display for SubpixelOrder { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1081 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1082 write!( 1083 f, 1084 "Self::{}", 1085 match *self { 1086 Self::Default => "Default", 1087 Self::Rgb => "Rgb", 1088 Self::Bgr => "Bgr", 1089 Self::Vrgb => "Vrgb", 1090 Self::Vbgr => "Vbgr", 1091 _ => "Unknown", 1092 } 1093 ) 1094 } 1095 } 1096 1097 #[cfg(feature = "use_glib")] 1098 gvalue_impl!( 1099 SubpixelOrder, 1100 ffi::gobject::cairo_gobject_subpixel_order_get_type 1101 ); 1102 1103 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 1104 #[non_exhaustive] 1105 #[doc(alias = "cairo_hint_style_t")] 1106 pub enum HintStyle { 1107 #[doc(alias = "HINT_STYLE_DEFAULT")] 1108 Default, 1109 #[doc(alias = "HINT_STYLE_NONE")] 1110 None, 1111 #[doc(alias = "HINT_STYLE_SLIGHT")] 1112 Slight, 1113 #[doc(alias = "HINT_STYLE_MEDIUM")] 1114 Medium, 1115 #[doc(alias = "HINT_STYLE_FULL")] 1116 Full, 1117 #[doc(hidden)] 1118 __Unknown(i32), 1119 } 1120 1121 #[doc(hidden)] 1122 impl From<HintStyle> for ffi::cairo_hint_style_t { from(val: HintStyle) -> ffi::cairo_hint_style_t1123 fn from(val: HintStyle) -> ffi::cairo_hint_style_t { 1124 match val { 1125 HintStyle::Default => ffi::HINT_STYLE_DEFAULT, 1126 HintStyle::None => ffi::HINT_STYLE_NONE, 1127 HintStyle::Slight => ffi::HINT_STYLE_SLIGHT, 1128 HintStyle::Medium => ffi::HINT_STYLE_MEDIUM, 1129 HintStyle::Full => ffi::HINT_STYLE_FULL, 1130 HintStyle::__Unknown(value) => value, 1131 } 1132 } 1133 } 1134 1135 #[doc(hidden)] 1136 impl From<ffi::cairo_hint_style_t> for HintStyle { from(value: ffi::cairo_hint_style_t) -> Self1137 fn from(value: ffi::cairo_hint_style_t) -> Self { 1138 match value { 1139 ffi::HINT_STYLE_DEFAULT => Self::Default, 1140 ffi::HINT_STYLE_NONE => Self::None, 1141 ffi::HINT_STYLE_SLIGHT => Self::Slight, 1142 ffi::HINT_STYLE_MEDIUM => Self::Medium, 1143 ffi::HINT_STYLE_FULL => Self::Full, 1144 value => Self::__Unknown(value), 1145 } 1146 } 1147 } 1148 1149 impl fmt::Display for HintStyle { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1150 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1151 write!( 1152 f, 1153 "Self::{}", 1154 match *self { 1155 Self::Default => "Default", 1156 Self::None => "None", 1157 Self::Slight => "Slight", 1158 Self::Medium => "Medium", 1159 Self::Full => "Full", 1160 _ => "Unknown", 1161 } 1162 ) 1163 } 1164 } 1165 1166 #[cfg(feature = "use_glib")] 1167 gvalue_impl!(HintStyle, ffi::gobject::cairo_gobject_hint_style_get_type); 1168 1169 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 1170 #[non_exhaustive] 1171 #[doc(alias = "cairo_hint_metrics_t")] 1172 pub enum HintMetrics { 1173 #[doc(alias = "HINT_METRICS_DEFAULT")] 1174 Default, 1175 #[doc(alias = "HINT_METRICS_OFF")] 1176 Off, 1177 #[doc(alias = "HINT_METRICS_ON")] 1178 On, 1179 #[doc(hidden)] 1180 __Unknown(i32), 1181 } 1182 1183 #[doc(hidden)] 1184 impl From<HintMetrics> for ffi::cairo_hint_metrics_t { from(val: HintMetrics) -> ffi::cairo_hint_metrics_t1185 fn from(val: HintMetrics) -> ffi::cairo_hint_metrics_t { 1186 match val { 1187 HintMetrics::Default => ffi::HINT_METRICS_DEFAULT, 1188 HintMetrics::Off => ffi::HINT_METRICS_OFF, 1189 HintMetrics::On => ffi::HINT_METRICS_ON, 1190 HintMetrics::__Unknown(value) => value, 1191 } 1192 } 1193 } 1194 1195 #[doc(hidden)] 1196 impl From<ffi::cairo_hint_metrics_t> for HintMetrics { from(value: ffi::cairo_hint_metrics_t) -> Self1197 fn from(value: ffi::cairo_hint_metrics_t) -> Self { 1198 match value { 1199 ffi::HINT_METRICS_DEFAULT => Self::Default, 1200 ffi::HINT_METRICS_OFF => Self::Off, 1201 ffi::HINT_METRICS_ON => Self::On, 1202 value => Self::__Unknown(value), 1203 } 1204 } 1205 } 1206 1207 impl fmt::Display for HintMetrics { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1208 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1209 write!( 1210 f, 1211 "Self::{}", 1212 match *self { 1213 Self::Default => "Default", 1214 Self::Off => "Off", 1215 Self::On => "On", 1216 _ => "Unknown", 1217 } 1218 ) 1219 } 1220 } 1221 1222 #[cfg(feature = "use_glib")] 1223 gvalue_impl!( 1224 HintMetrics, 1225 ffi::gobject::cairo_gobject_hint_metrics_get_type 1226 ); 1227 1228 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1229 #[non_exhaustive] 1230 #[doc(alias = "cairo_surface_type_t")] 1231 pub enum SurfaceType { 1232 #[doc(alias = "SURFACE_TYPE_IMAGE")] 1233 Image, 1234 #[doc(alias = "SURFACE_TYPE_PDF")] 1235 Pdf, 1236 #[doc(alias = "SURFACE_TYPE_PS")] 1237 Ps, 1238 #[doc(alias = "SURFACE_TYPE_XLIB")] 1239 Xlib, 1240 #[doc(alias = "SURFACE_TYPE_XCB")] 1241 Xcb, 1242 #[doc(alias = "SURFACE_TYPE_GLITZ")] 1243 Glitz, 1244 #[doc(alias = "SURFACE_TYPE_QUARTZ")] 1245 Quartz, 1246 #[doc(alias = "SURFACE_TYPE_WIN32")] 1247 Win32, 1248 #[doc(alias = "SURFACE_TYPE_BE_OS")] 1249 BeOs, 1250 #[doc(alias = "SURFACE_TYPE_DIRECT_FB")] 1251 DirectFb, 1252 #[doc(alias = "SURFACE_TYPE_SVG")] 1253 Svg, 1254 #[doc(alias = "SURFACE_TYPE_OS2")] 1255 Os2, 1256 #[doc(alias = "SURFACE_TYPE_WIN32_PRINTING")] 1257 Win32Printing, 1258 #[doc(alias = "SURFACE_TYPE_QUARTZ_IMAGE")] 1259 QuartzImage, 1260 #[doc(alias = "SURFACE_TYPE_SCRIPT")] 1261 Script, 1262 #[doc(alias = "SURFACE_TYPE_QT")] 1263 Qt, 1264 #[doc(alias = "SURFACE_TYPE_RECORDING")] 1265 Recording, 1266 #[doc(alias = "SURFACE_TYPE_VG")] 1267 Vg, 1268 #[doc(alias = "SURFACE_TYPE_GL")] 1269 Gl, 1270 #[doc(alias = "SURFACE_TYPE_DRM")] 1271 Drm, 1272 #[doc(alias = "SURFACE_TYPE_TEE")] 1273 Tee, 1274 #[doc(alias = "SURFACE_TYPE_XML")] 1275 Xml, 1276 #[doc(alias = "SURFACE_TYPE_SKIA")] 1277 Skia, 1278 #[doc(alias = "SURFACE_TYPE_SUBSURFACE")] 1279 Subsurface, 1280 #[doc(alias = "SURFACE_TYPE_COGL")] 1281 Cogl, 1282 #[doc(hidden)] 1283 __Unknown(i32), 1284 } 1285 1286 #[doc(hidden)] 1287 impl From<SurfaceType> for ffi::cairo_surface_type_t { from(val: SurfaceType) -> ffi::cairo_surface_type_t1288 fn from(val: SurfaceType) -> ffi::cairo_surface_type_t { 1289 match val { 1290 SurfaceType::Image => ffi::SURFACE_TYPE_IMAGE, 1291 SurfaceType::Pdf => ffi::SURFACE_TYPE_PDF, 1292 SurfaceType::Ps => ffi::SURFACE_TYPE_PS, 1293 SurfaceType::Xlib => ffi::SURFACE_TYPE_XLIB, 1294 SurfaceType::Xcb => ffi::SURFACE_TYPE_XCB, 1295 SurfaceType::Glitz => ffi::SURFACE_TYPE_GLITZ, 1296 SurfaceType::Quartz => ffi::SURFACE_TYPE_QUARTZ, 1297 SurfaceType::Win32 => ffi::SURFACE_TYPE_WIN32, 1298 SurfaceType::BeOs => ffi::SURFACE_TYPE_BE_OS, 1299 SurfaceType::DirectFb => ffi::SURFACE_TYPE_DIRECT_FB, 1300 SurfaceType::Svg => ffi::SURFACE_TYPE_SVG, 1301 SurfaceType::Os2 => ffi::SURFACE_TYPE_OS2, 1302 SurfaceType::Win32Printing => ffi::SURFACE_TYPE_WIN32_PRINTING, 1303 SurfaceType::QuartzImage => ffi::SURFACE_TYPE_QUARTZ_IMAGE, 1304 SurfaceType::Script => ffi::SURFACE_TYPE_SCRIPT, 1305 SurfaceType::Qt => ffi::SURFACE_TYPE_QT, 1306 SurfaceType::Recording => ffi::SURFACE_TYPE_RECORDING, 1307 SurfaceType::Vg => ffi::SURFACE_TYPE_VG, 1308 SurfaceType::Gl => ffi::SURFACE_TYPE_GL, 1309 SurfaceType::Drm => ffi::SURFACE_TYPE_DRM, 1310 SurfaceType::Tee => ffi::SURFACE_TYPE_TEE, 1311 SurfaceType::Xml => ffi::SURFACE_TYPE_XML, 1312 SurfaceType::Skia => ffi::SURFACE_TYPE_SKIA, 1313 SurfaceType::Subsurface => ffi::SURFACE_TYPE_SUBSURFACE, 1314 SurfaceType::Cogl => ffi::SURFACE_TYPE_COGL, 1315 SurfaceType::__Unknown(value) => value, 1316 } 1317 } 1318 } 1319 1320 #[doc(hidden)] 1321 impl From<ffi::cairo_surface_type_t> for SurfaceType { from(value: ffi::cairo_surface_type_t) -> Self1322 fn from(value: ffi::cairo_surface_type_t) -> Self { 1323 match value { 1324 ffi::SURFACE_TYPE_IMAGE => Self::Image, 1325 ffi::SURFACE_TYPE_PDF => Self::Pdf, 1326 ffi::SURFACE_TYPE_PS => Self::Ps, 1327 ffi::SURFACE_TYPE_XLIB => Self::Xlib, 1328 ffi::SURFACE_TYPE_XCB => Self::Xcb, 1329 ffi::SURFACE_TYPE_GLITZ => Self::Glitz, 1330 ffi::SURFACE_TYPE_QUARTZ => Self::Quartz, 1331 ffi::SURFACE_TYPE_WIN32 => Self::Win32, 1332 ffi::SURFACE_TYPE_BE_OS => Self::BeOs, 1333 ffi::SURFACE_TYPE_DIRECT_FB => Self::DirectFb, 1334 ffi::SURFACE_TYPE_SVG => Self::Svg, 1335 ffi::SURFACE_TYPE_OS2 => Self::Os2, 1336 ffi::SURFACE_TYPE_WIN32_PRINTING => Self::Win32Printing, 1337 ffi::SURFACE_TYPE_QUARTZ_IMAGE => Self::QuartzImage, 1338 ffi::SURFACE_TYPE_SCRIPT => Self::Script, 1339 ffi::SURFACE_TYPE_QT => Self::Qt, 1340 ffi::SURFACE_TYPE_RECORDING => Self::Recording, 1341 ffi::SURFACE_TYPE_VG => Self::Vg, 1342 ffi::SURFACE_TYPE_GL => Self::Gl, 1343 ffi::SURFACE_TYPE_DRM => Self::Drm, 1344 ffi::SURFACE_TYPE_TEE => Self::Tee, 1345 ffi::SURFACE_TYPE_XML => Self::Xml, 1346 ffi::SURFACE_TYPE_SKIA => Self::Skia, 1347 ffi::SURFACE_TYPE_SUBSURFACE => Self::Subsurface, 1348 ffi::SURFACE_TYPE_COGL => Self::Cogl, 1349 value => Self::__Unknown(value), 1350 } 1351 } 1352 } 1353 1354 impl fmt::Display for SurfaceType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1355 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1356 write!( 1357 f, 1358 "Self::{}", 1359 match *self { 1360 Self::Image => "Image", 1361 Self::Pdf => "Pdf", 1362 Self::Ps => "Ps", 1363 Self::Xlib => "Xlib", 1364 Self::Xcb => "Xcb", 1365 Self::Glitz => "Glitz", 1366 Self::Quartz => "Quartz", 1367 Self::Win32 => "Win32", 1368 Self::BeOs => "BeOs", 1369 Self::DirectFb => "DirectFb", 1370 Self::Svg => "Svg", 1371 Self::Os2 => "Os2", 1372 Self::Win32Printing => "Win32Printing", 1373 Self::QuartzImage => "QuartzImage", 1374 Self::Script => "Script", 1375 Self::Qt => "Qt", 1376 Self::Recording => "Recording", 1377 Self::Vg => "Vg", 1378 Self::Gl => "Gl", 1379 Self::Drm => "Drm", 1380 Self::Tee => "Tee", 1381 Self::Xml => "Xml", 1382 Self::Skia => "Skia", 1383 Self::Subsurface => "Subsurface", 1384 Self::Cogl => "Cogl", 1385 _ => "Unknown", 1386 } 1387 ) 1388 } 1389 } 1390 1391 #[cfg(feature = "use_glib")] 1392 gvalue_impl!( 1393 SurfaceType, 1394 ffi::gobject::cairo_gobject_surface_type_get_type 1395 ); 1396 1397 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1398 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))] 1399 #[non_exhaustive] 1400 #[doc(alias = "cairo_svg_unit_t")] 1401 pub enum SvgUnit { 1402 #[doc(alias = "SVG_UNIT_USER")] 1403 User, 1404 #[doc(alias = "SVG_UNIT_EM")] 1405 Em, 1406 #[doc(alias = "SVG_UNIT_EX")] 1407 Ex, 1408 #[doc(alias = "SVG_UNIT_PX")] 1409 Px, 1410 #[doc(alias = "SVG_UNIT_IN")] 1411 In, 1412 #[doc(alias = "SVG_UNIT_CM")] 1413 Cm, 1414 #[doc(alias = "SVG_UNIT_MM")] 1415 Mm, 1416 #[doc(alias = "SVG_UNIT_PT")] 1417 Pt, 1418 #[doc(alias = "SVG_UNIT_PC")] 1419 Pc, 1420 #[doc(alias = "SVG_UNIT_PERCENT")] 1421 Percent, 1422 #[doc(hidden)] 1423 __Unknown(i32), 1424 } 1425 1426 #[doc(hidden)] 1427 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))] 1428 impl From<SvgUnit> for ffi::cairo_svg_unit_t { from(val: SvgUnit) -> ffi::cairo_svg_unit_t1429 fn from(val: SvgUnit) -> ffi::cairo_svg_unit_t { 1430 match val { 1431 SvgUnit::User => ffi::SVG_UNIT_USER, 1432 SvgUnit::Em => ffi::SVG_UNIT_EM, 1433 SvgUnit::Ex => ffi::SVG_UNIT_EX, 1434 SvgUnit::Px => ffi::SVG_UNIT_PX, 1435 SvgUnit::In => ffi::SVG_UNIT_IN, 1436 SvgUnit::Cm => ffi::SVG_UNIT_CM, 1437 SvgUnit::Mm => ffi::SVG_UNIT_MM, 1438 SvgUnit::Pt => ffi::SVG_UNIT_PT, 1439 SvgUnit::Pc => ffi::SVG_UNIT_PC, 1440 SvgUnit::Percent => ffi::SVG_UNIT_PERCENT, 1441 SvgUnit::__Unknown(value) => value, 1442 } 1443 } 1444 } 1445 1446 #[doc(hidden)] 1447 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))] 1448 impl From<ffi::cairo_svg_unit_t> for SvgUnit { from(value: ffi::cairo_svg_unit_t) -> Self1449 fn from(value: ffi::cairo_svg_unit_t) -> Self { 1450 match value { 1451 ffi::SVG_UNIT_USER => Self::User, 1452 ffi::SVG_UNIT_EM => Self::Em, 1453 ffi::SVG_UNIT_EX => Self::Ex, 1454 ffi::SVG_UNIT_PX => Self::Px, 1455 ffi::SVG_UNIT_IN => Self::In, 1456 ffi::SVG_UNIT_CM => Self::Cm, 1457 ffi::SVG_UNIT_MM => Self::Mm, 1458 ffi::SVG_UNIT_PT => Self::Pt, 1459 ffi::SVG_UNIT_PC => Self::Pc, 1460 ffi::SVG_UNIT_PERCENT => Self::Percent, 1461 value => Self::__Unknown(value), 1462 } 1463 } 1464 } 1465 1466 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))] 1467 impl fmt::Display for SvgUnit { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1468 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1469 write!( 1470 f, 1471 "Self::{}", 1472 match *self { 1473 Self::User => "User", 1474 Self::Em => "Em", 1475 Self::Ex => "Ex", 1476 Self::Px => "Px", 1477 Self::In => "In", 1478 Self::Cm => "Cm", 1479 Self::Mm => "Mm", 1480 Self::Pt => "Pt", 1481 Self::Pc => "Pc", 1482 Self::Percent => "Percent", 1483 _ => "Unknown", 1484 } 1485 ) 1486 } 1487 } 1488 1489 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1490 #[non_exhaustive] 1491 #[doc(alias = "cairo_format_t")] 1492 pub enum Format { 1493 #[doc(alias = "FORMAT_INVALID")] 1494 Invalid, 1495 #[doc(alias = "FORMAT_A_RGB32")] 1496 ARgb32, 1497 #[doc(alias = "FORMAT_RGB24")] 1498 Rgb24, 1499 #[doc(alias = "FORMAT_A8")] 1500 A8, 1501 #[doc(alias = "FORMAT_A1")] 1502 A1, 1503 #[doc(alias = "FORMAT_RGB16_565")] 1504 Rgb16_565, 1505 #[doc(alias = "FORMAT_RGB30")] 1506 Rgb30, 1507 #[doc(hidden)] 1508 __Unknown(i32), 1509 } 1510 1511 #[doc(hidden)] 1512 impl From<Format> for ffi::cairo_format_t { from(val: Format) -> ffi::cairo_format_t1513 fn from(val: Format) -> ffi::cairo_format_t { 1514 match val { 1515 Format::Invalid => ffi::FORMAT_INVALID, 1516 Format::ARgb32 => ffi::FORMAT_A_RGB32, 1517 Format::Rgb24 => ffi::FORMAT_RGB24, 1518 Format::A8 => ffi::FORMAT_A8, 1519 Format::A1 => ffi::FORMAT_A1, 1520 Format::Rgb16_565 => ffi::FORMAT_RGB16_565, 1521 Format::Rgb30 => ffi::FORMAT_RGB30, 1522 Format::__Unknown(value) => value, 1523 } 1524 } 1525 } 1526 1527 #[doc(hidden)] 1528 impl From<ffi::cairo_format_t> for Format { from(value: ffi::cairo_format_t) -> Self1529 fn from(value: ffi::cairo_format_t) -> Self { 1530 match value { 1531 ffi::FORMAT_INVALID => Self::Invalid, 1532 ffi::FORMAT_A_RGB32 => Self::ARgb32, 1533 ffi::FORMAT_RGB24 => Self::Rgb24, 1534 ffi::FORMAT_A8 => Self::A8, 1535 ffi::FORMAT_A1 => Self::A1, 1536 ffi::FORMAT_RGB16_565 => Self::Rgb16_565, 1537 ffi::FORMAT_RGB30 => Self::Rgb30, 1538 value => Self::__Unknown(value), 1539 } 1540 } 1541 } 1542 1543 impl fmt::Display for Format { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1544 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1545 write!( 1546 f, 1547 "Self::{}", 1548 match *self { 1549 Self::Invalid => "Invalid", 1550 Self::ARgb32 => "ARgb32", 1551 Self::Rgb24 => "Rgb24", 1552 Self::A8 => "A8", 1553 Self::A1 => "A1", 1554 Self::Rgb16_565 => "Rgb16_565", 1555 Self::Rgb30 => "Rgb30", 1556 _ => "Unknown", 1557 } 1558 ) 1559 } 1560 } 1561 1562 #[cfg(feature = "use_glib")] 1563 gvalue_impl!(Format, ffi::gobject::cairo_gobject_format_get_type); 1564 1565 impl Format { 1566 #[doc(alias = "cairo_format_stride_for_width")] stride_for_width(self, width: u32) -> Result<i32, Error>1567 pub fn stride_for_width(self, width: u32) -> Result<i32, Error> { 1568 assert!(width <= i32::MAX as u32); 1569 let width = width as i32; 1570 1571 let stride = unsafe { ffi::cairo_format_stride_for_width(self.into(), width) }; 1572 if stride == -1 { 1573 Err(Error::InvalidFormat) 1574 } else { 1575 Ok(stride) 1576 } 1577 } 1578 } 1579 1580 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1581 #[non_exhaustive] 1582 #[doc(alias = "cairo_region_overlap_t")] 1583 pub enum RegionOverlap { 1584 #[doc(alias = "REGION_OVERLAP_IN")] 1585 In, 1586 #[doc(alias = "REGION_OVERLAP_OUT")] 1587 Out, 1588 #[doc(alias = "REGION_OVERLAP_PART")] 1589 Part, 1590 #[doc(hidden)] 1591 __Unknown(i32), 1592 } 1593 1594 #[doc(hidden)] 1595 impl From<RegionOverlap> for ffi::cairo_region_overlap_t { from(val: RegionOverlap) -> ffi::cairo_region_overlap_t1596 fn from(val: RegionOverlap) -> ffi::cairo_region_overlap_t { 1597 match val { 1598 RegionOverlap::In => ffi::REGION_OVERLAP_IN, 1599 RegionOverlap::Out => ffi::REGION_OVERLAP_OUT, 1600 RegionOverlap::Part => ffi::REGION_OVERLAP_PART, 1601 RegionOverlap::__Unknown(value) => value, 1602 } 1603 } 1604 } 1605 1606 #[doc(hidden)] 1607 impl From<ffi::cairo_region_overlap_t> for RegionOverlap { from(value: ffi::cairo_region_overlap_t) -> Self1608 fn from(value: ffi::cairo_region_overlap_t) -> Self { 1609 match value { 1610 ffi::REGION_OVERLAP_IN => Self::In, 1611 ffi::REGION_OVERLAP_OUT => Self::Out, 1612 ffi::REGION_OVERLAP_PART => Self::Part, 1613 value => Self::__Unknown(value), 1614 } 1615 } 1616 } 1617 1618 impl fmt::Display for RegionOverlap { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1619 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1620 write!( 1621 f, 1622 "Self::{}", 1623 match *self { 1624 Self::In => "In", 1625 Self::Out => "Out", 1626 Self::Part => "Part", 1627 _ => "Unknown", 1628 } 1629 ) 1630 } 1631 } 1632 1633 #[cfg(feature = "use_glib")] 1634 gvalue_impl!( 1635 RegionOverlap, 1636 ffi::gobject::cairo_gobject_region_overlap_get_type 1637 ); 1638 1639 bitflags::bitflags! { 1640 pub struct PdfOutline: i32 { 1641 #[doc(alias = "PDF_OUTLINE_FLAG_OPEN")] 1642 const OPEN = ffi::PDF_OUTLINE_FLAG_OPEN; 1643 #[doc(alias = "PDF_OUTLINE_FLAG_BOLD")] 1644 const BOLD = ffi::PDF_OUTLINE_FLAG_BOLD; 1645 #[doc(alias = "PDF_OUTLINE_FLAG_ITALIC")] 1646 const ITALIC = ffi::PDF_OUTLINE_FLAG_ITALIC; 1647 } 1648 } 1649 1650 #[cfg(any(feature = "pdf", feature = "dox"))] 1651 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1652 #[non_exhaustive] 1653 #[doc(alias = "cairo_pdf_metadata_t")] 1654 pub enum PdfMetadata { 1655 #[doc(alias = "PDF_METADATA_TITLE")] 1656 Title, 1657 #[doc(alias = "PDF_METADATA_AUTHOR")] 1658 Author, 1659 #[doc(alias = "PDF_METADATA_SUBJECT")] 1660 Subject, 1661 #[doc(alias = "PDF_METADATA_KEYWORDS")] 1662 Keywords, 1663 #[doc(alias = "PDF_METADATA_CREATOR")] 1664 Creator, 1665 #[doc(alias = "PDF_METADATA_CREATE_DATE")] 1666 CreateDate, 1667 #[doc(alias = "PDF_METADATA_MOD_DATE")] 1668 ModDate, 1669 #[doc(hidden)] 1670 __Unknown(i32), 1671 } 1672 1673 #[cfg(any(all(feature = "pdf", feature = "v1_16"), feature = "dox"))] 1674 #[doc(hidden)] 1675 impl From<PdfMetadata> for ffi::cairo_pdf_metadata_t { from(val: PdfMetadata) -> ffi::cairo_pdf_metadata_t1676 fn from(val: PdfMetadata) -> ffi::cairo_pdf_metadata_t { 1677 match val { 1678 PdfMetadata::Title => ffi::PDF_METADATA_TITLE, 1679 PdfMetadata::Author => ffi::PDF_METADATA_AUTHOR, 1680 PdfMetadata::Subject => ffi::PDF_METADATA_SUBJECT, 1681 PdfMetadata::Keywords => ffi::PDF_METADATA_KEYWORDS, 1682 PdfMetadata::Creator => ffi::PDF_METADATA_CREATOR, 1683 PdfMetadata::CreateDate => ffi::PDF_METADATA_CREATE_DATE, 1684 PdfMetadata::ModDate => ffi::PDF_METADATA_MOD_DATE, 1685 PdfMetadata::__Unknown(value) => value, 1686 } 1687 } 1688 } 1689 1690 #[cfg(any(all(feature = "pdf", feature = "v1_16"), feature = "dox"))] 1691 #[doc(hidden)] 1692 impl From<ffi::cairo_pdf_metadata_t> for PdfMetadata { from(value: ffi::cairo_pdf_metadata_t) -> Self1693 fn from(value: ffi::cairo_pdf_metadata_t) -> Self { 1694 match value { 1695 ffi::PDF_METADATA_TITLE => Self::Title, 1696 ffi::PDF_METADATA_AUTHOR => Self::Author, 1697 ffi::PDF_METADATA_SUBJECT => Self::Subject, 1698 ffi::PDF_METADATA_KEYWORDS => Self::Keywords, 1699 ffi::PDF_METADATA_CREATOR => Self::Creator, 1700 ffi::PDF_METADATA_CREATE_DATE => Self::CreateDate, 1701 ffi::PDF_METADATA_MOD_DATE => Self::ModDate, 1702 value => Self::__Unknown(value), 1703 } 1704 } 1705 } 1706 1707 #[cfg(any(all(feature = "pdf", feature = "v1_16"), feature = "dox"))] 1708 impl fmt::Display for PdfMetadata { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1709 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1710 write!( 1711 f, 1712 "Self::{}", 1713 match *self { 1714 Self::Title => "Title", 1715 Self::Author => "Author", 1716 Self::Subject => "Subject", 1717 Self::Keywords => "Keywords", 1718 Self::Creator => "Creator", 1719 Self::CreateDate => "CreateDate", 1720 Self::ModDate => "ModDate", 1721 _ => "Unknown", 1722 } 1723 ) 1724 } 1725 } 1726 1727 #[cfg(any(feature = "pdf", feature = "dox"))] 1728 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1729 #[non_exhaustive] 1730 #[doc(alias = "cairo_pdf_version_t")] 1731 pub enum PdfVersion { 1732 #[doc(alias = "PDF_VERSION__1_4")] 1733 _1_4, 1734 #[doc(alias = "PDF_VERSION__1_5")] 1735 _1_5, 1736 #[doc(hidden)] 1737 __Unknown(i32), 1738 } 1739 1740 #[cfg(any(feature = "pdf", feature = "dox"))] 1741 #[doc(hidden)] 1742 impl From<PdfVersion> for ffi::cairo_pdf_version_t { from(val: PdfVersion) -> ffi::cairo_pdf_version_t1743 fn from(val: PdfVersion) -> ffi::cairo_pdf_version_t { 1744 match val { 1745 PdfVersion::_1_4 => ffi::PDF_VERSION__1_4, 1746 PdfVersion::_1_5 => ffi::PDF_VERSION__1_5, 1747 PdfVersion::__Unknown(value) => value, 1748 } 1749 } 1750 } 1751 1752 #[cfg(any(feature = "pdf", feature = "dox"))] 1753 #[doc(hidden)] 1754 impl From<ffi::cairo_pdf_version_t> for PdfVersion { from(value: ffi::cairo_pdf_version_t) -> Self1755 fn from(value: ffi::cairo_pdf_version_t) -> Self { 1756 match value { 1757 ffi::PDF_VERSION__1_4 => Self::_1_4, 1758 ffi::PDF_VERSION__1_5 => Self::_1_5, 1759 value => Self::__Unknown(value), 1760 } 1761 } 1762 } 1763 1764 #[cfg(any(feature = "pdf", feature = "dox"))] 1765 impl fmt::Display for PdfVersion { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1766 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1767 write!( 1768 f, 1769 "Self::{}", 1770 match *self { 1771 Self::_1_4 => "1_4", 1772 Self::_1_5 => "1_5", 1773 _ => "Unknown", 1774 } 1775 ) 1776 } 1777 } 1778 1779 #[cfg(any(feature = "svg", feature = "dox"))] 1780 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1781 #[non_exhaustive] 1782 #[doc(alias = "cairo_svg_version_t")] 1783 pub enum SvgVersion { 1784 #[doc(alias = "SVG_VERSION__1_1")] 1785 _1_1, 1786 #[doc(alias = "SVG_VERSION__1_2")] 1787 _1_2, 1788 #[doc(hidden)] 1789 __Unknown(i32), 1790 } 1791 1792 #[cfg(any(feature = "svg", feature = "dox"))] 1793 #[doc(hidden)] 1794 impl From<SvgVersion> for ffi::cairo_svg_version_t { from(val: SvgVersion) -> ffi::cairo_svg_version_t1795 fn from(val: SvgVersion) -> ffi::cairo_svg_version_t { 1796 match val { 1797 SvgVersion::_1_1 => ffi::SVG_VERSION__1_1, 1798 SvgVersion::_1_2 => ffi::SVG_VERSION__1_2, 1799 SvgVersion::__Unknown(value) => value, 1800 } 1801 } 1802 } 1803 1804 #[cfg(any(feature = "svg", feature = "dox"))] 1805 #[doc(hidden)] 1806 impl From<ffi::cairo_svg_version_t> for SvgVersion { from(value: ffi::cairo_svg_version_t) -> Self1807 fn from(value: ffi::cairo_svg_version_t) -> Self { 1808 match value { 1809 ffi::SVG_VERSION__1_1 => Self::_1_1, 1810 ffi::SVG_VERSION__1_2 => Self::_1_2, 1811 value => Self::__Unknown(value), 1812 } 1813 } 1814 } 1815 1816 #[cfg(any(feature = "svg", feature = "dox"))] 1817 impl fmt::Display for SvgVersion { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1818 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1819 write!( 1820 f, 1821 "Self::{}", 1822 match *self { 1823 Self::_1_1 => "1_1", 1824 Self::_1_2 => "1_2", 1825 _ => "Unknown", 1826 } 1827 ) 1828 } 1829 } 1830 1831 #[cfg(any(feature = "ps", feature = "dox"))] 1832 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 1833 #[non_exhaustive] 1834 #[doc(alias = "cairo_ps_level_t")] 1835 pub enum PsLevel { 1836 #[doc(alias = "PS_LEVEL__2")] 1837 _2, 1838 #[doc(alias = "PS_LEVEL__3")] 1839 _3, 1840 #[doc(hidden)] 1841 __Unknown(i32), 1842 } 1843 1844 #[cfg(any(feature = "ps", feature = "dox"))] 1845 #[doc(hidden)] 1846 impl From<PsLevel> for ffi::cairo_ps_level_t { from(val: PsLevel) -> ffi::cairo_ps_level_t1847 fn from(val: PsLevel) -> ffi::cairo_ps_level_t { 1848 match val { 1849 PsLevel::_2 => ffi::PS_LEVEL__2, 1850 PsLevel::_3 => ffi::PS_LEVEL__3, 1851 PsLevel::__Unknown(value) => value, 1852 } 1853 } 1854 } 1855 1856 #[cfg(any(feature = "ps", feature = "dox"))] 1857 #[doc(hidden)] 1858 impl From<ffi::cairo_ps_level_t> for PsLevel { from(value: ffi::cairo_ps_level_t) -> Self1859 fn from(value: ffi::cairo_ps_level_t) -> Self { 1860 match value { 1861 ffi::PS_LEVEL__2 => Self::_2, 1862 ffi::PS_LEVEL__3 => Self::_3, 1863 value => Self::__Unknown(value), 1864 } 1865 } 1866 } 1867 1868 #[cfg(any(feature = "ps", feature = "dox"))] 1869 impl fmt::Display for PsLevel { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1870 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1871 write!( 1872 f, 1873 "Self::{}", 1874 match *self { 1875 Self::_2 => "_2", 1876 Self::_3 => "_3", 1877 _ => "Unknown", 1878 } 1879 ) 1880 } 1881 } 1882 1883 #[derive(Clone, PartialEq, PartialOrd, Copy, Debug)] 1884 #[non_exhaustive] 1885 #[doc(alias = "cairo_mesh_corner_t")] 1886 pub enum MeshCorner { 1887 #[doc(alias = "MESH_CORNER_MESH_CORNER0")] 1888 MeshCorner0, 1889 #[doc(alias = "MESH_CORNER_MESH_CORNER1")] 1890 MeshCorner1, 1891 #[doc(alias = "MESH_CORNER_MESH_CORNER2")] 1892 MeshCorner2, 1893 #[doc(alias = "MESH_CORNER_MESH_CORNER3")] 1894 MeshCorner3, 1895 #[doc(hidden)] 1896 __Unknown(u32), 1897 } 1898 1899 #[doc(hidden)] 1900 impl From<MeshCorner> for ffi::cairo_mesh_corner_t { from(val: MeshCorner) -> ffi::cairo_mesh_corner_t1901 fn from(val: MeshCorner) -> ffi::cairo_mesh_corner_t { 1902 match val { 1903 MeshCorner::MeshCorner0 => ffi::MESH_CORNER_MESH_CORNER0, 1904 MeshCorner::MeshCorner1 => ffi::MESH_CORNER_MESH_CORNER1, 1905 MeshCorner::MeshCorner2 => ffi::MESH_CORNER_MESH_CORNER2, 1906 MeshCorner::MeshCorner3 => ffi::MESH_CORNER_MESH_CORNER3, 1907 MeshCorner::__Unknown(value) => value, 1908 } 1909 } 1910 } 1911 1912 #[doc(hidden)] 1913 impl From<ffi::cairo_mesh_corner_t> for MeshCorner { from(value: ffi::cairo_mesh_corner_t) -> Self1914 fn from(value: ffi::cairo_mesh_corner_t) -> Self { 1915 match value { 1916 ffi::MESH_CORNER_MESH_CORNER0 => Self::MeshCorner0, 1917 ffi::MESH_CORNER_MESH_CORNER1 => Self::MeshCorner1, 1918 ffi::MESH_CORNER_MESH_CORNER2 => Self::MeshCorner2, 1919 ffi::MESH_CORNER_MESH_CORNER3 => Self::MeshCorner3, 1920 value => Self::__Unknown(value), 1921 } 1922 } 1923 } 1924 1925 impl fmt::Display for MeshCorner { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1926 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1927 write!( 1928 f, 1929 "Self::{}", 1930 match *self { 1931 Self::MeshCorner0 => "MeshCorner0", 1932 Self::MeshCorner1 => "MeshCorner1", 1933 Self::MeshCorner2 => "MeshCorner2", 1934 Self::MeshCorner3 => "MeshCorner3", 1935 _ => "Unknown", 1936 } 1937 ) 1938 } 1939 } 1940 1941 #[cfg(any(feature = "freetype", feature = "dox"))] 1942 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 1943 #[non_exhaustive] 1944 #[doc(alias = "cairo_ft_synthesize_t")] 1945 pub enum FtSynthesize { 1946 #[doc(alias = "CAIRO_FT_SYNTHESIZE_BOLD")] 1947 Bold, 1948 #[doc(alias = "CAIRO_FT_SYNTHESIZE_OBLIQUE")] 1949 Oblique, 1950 #[doc(hidden)] 1951 __Unknown(u32), 1952 } 1953 1954 #[cfg(any(feature = "freetype", feature = "dox"))] 1955 #[doc(hidden)] 1956 impl From<FtSynthesize> for ffi::cairo_ft_synthesize_t { from(val: FtSynthesize) -> ffi::cairo_ft_synthesize_t1957 fn from(val: FtSynthesize) -> ffi::cairo_ft_synthesize_t { 1958 match val { 1959 FtSynthesize::Bold => ffi::CAIRO_FT_SYNTHESIZE_BOLD, 1960 FtSynthesize::Oblique => ffi::CAIRO_FT_SYNTHESIZE_OBLIQUE, 1961 FtSynthesize::__Unknown(value) => value, 1962 } 1963 } 1964 } 1965 1966 #[cfg(any(feature = "freetype", feature = "dox"))] 1967 #[doc(hidden)] 1968 impl From<ffi::cairo_ft_synthesize_t> for FtSynthesize { from(value: ffi::cairo_ft_synthesize_t) -> Self1969 fn from(value: ffi::cairo_ft_synthesize_t) -> Self { 1970 match value { 1971 ffi::CAIRO_FT_SYNTHESIZE_BOLD => Self::Bold, 1972 ffi::CAIRO_FT_SYNTHESIZE_OBLIQUE => Self::Oblique, 1973 value => Self::__Unknown(value), 1974 } 1975 } 1976 } 1977 1978 #[cfg(any(feature = "freetype", feature = "dox"))] 1979 impl fmt::Display for FtSynthesize { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1980 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 1981 write!( 1982 f, 1983 "Self::{}", 1984 match *self { 1985 Self::Bold => "Bold", 1986 Self::Oblique => "Oblique", 1987 Self::__Unknown(_) => "Unknown", 1988 } 1989 ) 1990 } 1991 } 1992 1993 #[cfg(any(feature = "script", feature = "dox"))] 1994 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 1995 #[non_exhaustive] 1996 #[doc(alias = "cairo_script_mode_t")] 1997 pub enum ScriptMode { 1998 #[doc(alias = "CAIRO_SCRIPT_MODE_ASCII")] 1999 Ascii, 2000 #[doc(alias = "CAIRO_SCRIPT_MODE_BINARY")] 2001 Binary, 2002 #[doc(hidden)] 2003 __Unknown(i32), 2004 } 2005 2006 #[cfg(any(feature = "script", feature = "dox"))] 2007 #[doc(hidden)] 2008 impl From<ScriptMode> for ffi::cairo_script_mode_t { from(val: ScriptMode) -> ffi::cairo_script_mode_t2009 fn from(val: ScriptMode) -> ffi::cairo_script_mode_t { 2010 match val { 2011 ScriptMode::Ascii => ffi::CAIRO_SCRIPT_MODE_ASCII, 2012 ScriptMode::Binary => ffi::CAIRO_SCRIPT_MODE_BINARY, 2013 ScriptMode::__Unknown(value) => value, 2014 } 2015 } 2016 } 2017 2018 #[cfg(any(feature = "script", feature = "dox"))] 2019 #[doc(hidden)] 2020 impl From<ffi::cairo_script_mode_t> for ScriptMode { from(value: ffi::cairo_script_mode_t) -> Self2021 fn from(value: ffi::cairo_script_mode_t) -> Self { 2022 match value { 2023 ffi::CAIRO_SCRIPT_MODE_ASCII => Self::Ascii, 2024 ffi::CAIRO_SCRIPT_MODE_BINARY => Self::Binary, 2025 value => Self::__Unknown(value), 2026 } 2027 } 2028 } 2029 2030 #[cfg(any(feature = "script", feature = "dox"))] 2031 impl fmt::Display for ScriptMode { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2032 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2033 write!( 2034 f, 2035 "Self::{}", 2036 match *self { 2037 Self::Ascii => "Ascii", 2038 Self::Binary => "Binary", 2039 Self::__Unknown(_) => "Unknown", 2040 } 2041 ) 2042 } 2043 } 2044 2045 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)] 2046 #[non_exhaustive] 2047 #[doc(alias = "cairo_device_type_t")] 2048 pub enum DeviceType { 2049 #[doc(alias = "CAIRO_DEVICE_TYPE_DRM")] 2050 Ascii, 2051 #[doc(alias = "CAIRO_DEVICE_TYPE_GL")] 2052 Binary, 2053 #[doc(alias = "CAIRO_DEVICE_TYPE_SCRIPT")] 2054 Script, 2055 #[doc(alias = "CAIRO_DEVICE_TYPE_XCB")] 2056 Xcb, 2057 #[doc(alias = "CAIRO_DEVICE_TYPE_XLIB")] 2058 Xlib, 2059 #[doc(alias = "CAIRO_DEVICE_TYPE_XML")] 2060 Xml, 2061 #[doc(alias = "CAIRO_DEVICE_TYPE_COGL")] 2062 Cogl, 2063 #[doc(alias = "CAIRO_DEVICE_TYPE_WIN32")] 2064 Win32, 2065 #[doc(alias = "CAIRO_DEVICE_TYPE_INVALID")] 2066 Invalid, 2067 #[doc(hidden)] 2068 __Unknown(i32), 2069 } 2070 2071 #[doc(hidden)] 2072 impl From<DeviceType> for ffi::cairo_device_type_t { from(val: DeviceType) -> ffi::cairo_device_type_t2073 fn from(val: DeviceType) -> ffi::cairo_device_type_t { 2074 match val { 2075 DeviceType::Ascii => ffi::CAIRO_DEVICE_TYPE_DRM, 2076 DeviceType::Binary => ffi::CAIRO_DEVICE_TYPE_GL, 2077 DeviceType::Script => ffi::CAIRO_DEVICE_TYPE_SCRIPT, 2078 DeviceType::Xcb => ffi::CAIRO_DEVICE_TYPE_XCB, 2079 DeviceType::Xlib => ffi::CAIRO_DEVICE_TYPE_XLIB, 2080 DeviceType::Xml => ffi::CAIRO_DEVICE_TYPE_XML, 2081 DeviceType::Cogl => ffi::CAIRO_DEVICE_TYPE_COGL, 2082 DeviceType::Win32 => ffi::CAIRO_DEVICE_TYPE_WIN32, 2083 DeviceType::Invalid => ffi::CAIRO_DEVICE_TYPE_INVALID, 2084 DeviceType::__Unknown(value) => value, 2085 } 2086 } 2087 } 2088 2089 #[doc(hidden)] 2090 impl From<ffi::cairo_device_type_t> for DeviceType { from(value: ffi::cairo_device_type_t) -> Self2091 fn from(value: ffi::cairo_device_type_t) -> Self { 2092 match value { 2093 ffi::CAIRO_DEVICE_TYPE_DRM => Self::Ascii, 2094 ffi::CAIRO_DEVICE_TYPE_GL => Self::Binary, 2095 ffi::CAIRO_DEVICE_TYPE_SCRIPT => Self::Script, 2096 ffi::CAIRO_DEVICE_TYPE_XCB => Self::Xcb, 2097 ffi::CAIRO_DEVICE_TYPE_XLIB => Self::Xlib, 2098 ffi::CAIRO_DEVICE_TYPE_XML => Self::Xml, 2099 ffi::CAIRO_DEVICE_TYPE_COGL => Self::Cogl, 2100 ffi::CAIRO_DEVICE_TYPE_WIN32 => Self::Win32, 2101 ffi::CAIRO_DEVICE_TYPE_INVALID => Self::Invalid, 2102 value => Self::__Unknown(value), 2103 } 2104 } 2105 } 2106 2107 impl fmt::Display for DeviceType { fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2108 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 2109 write!( 2110 f, 2111 "Self::{}", 2112 match *self { 2113 Self::Ascii => "Ascii", 2114 Self::Binary => "Binary", 2115 Self::Script => "Script", 2116 Self::Xcb => "Xcb", 2117 Self::Xlib => "Xlib", 2118 Self::Xml => "Xml", 2119 Self::Cogl => "Cogl", 2120 Self::Win32 => "Win32", 2121 Self::Invalid => "Invalid", 2122 Self::__Unknown(_) => "Unknown", 2123 } 2124 ) 2125 } 2126 } 2127 2128 #[cfg(feature = "use_glib")] 2129 gvalue_impl!(DeviceType, ffi::gobject::cairo_gobject_device_type_get_type); 2130 2131 #[cfg(test)] 2132 mod tests { 2133 use super::*; 2134 2135 #[test] 2136 #[should_panic] stride_panics_on_bad_value()2137 fn stride_panics_on_bad_value() { 2138 let _ = Format::Rgb24.stride_for_width(u32::MAX); 2139 } 2140 2141 #[test] stride_errors_on_large_width()2142 fn stride_errors_on_large_width() { 2143 assert!(Format::Rgb24.stride_for_width(i32::MAX as u32).is_err()); 2144 } 2145 2146 #[test] stride_works()2147 fn stride_works() { 2148 assert_eq!(Format::Rgb24.stride_for_width(1).unwrap(), 4); 2149 } 2150 } 2151