use std::fmt;
pub use svgtypes::{
Align,
AspectRatio,
Color,
FuzzyEq,
FuzzyZero,
Transform,
};
use crate::geom::*;
pub use super::numbers::*;
macro_rules! impl_from_str {
($name:ident) => {
impl std::str::FromStr for $name {
type Err = &'static str;
fn from_str(s: &str) -> Result<Self, Self::Err> {
crate::svgtree::EnumFromStr::enum_from_str(s).ok_or("invalid value")
}
}
};
}
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum LineCap {
Butt,
Round,
Square,
}
impl_enum_default!(LineCap, Butt);
impl_enum_from_str!(LineCap,
"butt" => LineCap::Butt,
"round" => LineCap::Round,
"square" => LineCap::Square
);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum LineJoin {
Miter,
Round,
Bevel,
}
impl_enum_default!(LineJoin, Miter);
impl_enum_from_str!(LineJoin,
"miter" => LineJoin::Miter,
"round" => LineJoin::Round,
"bevel" => LineJoin::Bevel
);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum FillRule {
NonZero,
EvenOdd,
}
impl_enum_default!(FillRule, NonZero);
impl_enum_from_str!(FillRule,
"nonzero" => FillRule::NonZero,
"evenodd" => FillRule::EvenOdd
);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Units {
UserSpaceOnUse,
ObjectBoundingBox,
}
impl_enum_from_str!(Units,
"userSpaceOnUse" => Units::UserSpaceOnUse,
"objectBoundingBox" => Units::ObjectBoundingBox
);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum SpreadMethod {
Pad,
Reflect,
Repeat,
}
impl_enum_default!(SpreadMethod, Pad);
impl_enum_from_str!(SpreadMethod,
"pad" => SpreadMethod::Pad,
"reflect" => SpreadMethod::Reflect,
"repeat" => SpreadMethod::Repeat
);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Visibility {
Visible,
Hidden,
Collapse,
}
impl_enum_default!(Visibility, Visible);
impl_enum_from_str!(Visibility,
"visible" => Visibility::Visible,
"hidden" => Visibility::Hidden,
"collapse" => Visibility::Collapse
);
#[allow(missing_docs)]
#[derive(Clone)]
pub enum Paint {
Color(Color),
Link(String),
}
impl fmt::Debug for Paint {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Paint::Color(c) => write!(f, "Color({})", c),
Paint::Link(ref id) => write!(f, "Link({})", id),
}
}
}
#[allow(missing_docs)]
#[derive(Clone, Debug)]
pub struct Fill {
pub paint: Paint,
pub opacity: Opacity,
pub rule: FillRule,
}
impl Fill {
pub fn from_paint(paint: Paint) -> Self {
Fill {
paint,
..Fill::default()
}
}
}
impl Default for Fill {
fn default() -> Self {
Fill {
paint: Paint::Color(Color::black()),
opacity: Opacity::default(),
rule: FillRule::default(),
}
}
}
#[allow(missing_docs)]
#[derive(Clone, Debug)]
pub struct Stroke {
pub paint: Paint,
pub dasharray: Option<Vec<f64>>,
pub dashoffset: f32,
pub miterlimit: StrokeMiterlimit,
pub opacity: Opacity,
pub width: StrokeWidth,
pub linecap: LineCap,
pub linejoin: LineJoin,
}
impl Default for Stroke {
fn default() -> Self {
Stroke {
paint: Paint::Color(Color::black()),
dasharray: None,
dashoffset: 0.0,
miterlimit: StrokeMiterlimit::default(),
opacity: Opacity::default(),
width: StrokeWidth::default(),
linecap: LineCap::default(),
linejoin: LineJoin::default(),
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct ViewBox {
pub rect: Rect,
pub aspect: AspectRatio,
}
#[allow(missing_docs)]
#[derive(Clone, PartialEq, Debug)]
pub enum FilterInput {
SourceGraphic,
SourceAlpha,
BackgroundImage,
BackgroundAlpha,
FillPaint,
StrokePaint,
Reference(String),
}
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum ColorInterpolation {
SRGB,
LinearRGB,
}
impl_enum_default!(ColorInterpolation, LinearRGB);
impl_enum_from_str!(ColorInterpolation,
"sRGB" => ColorInterpolation::SRGB,
"linearRGB" => ColorInterpolation::LinearRGB
);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum ColorChannel {
R,
G,
B,
A,
}
#[derive(Clone)]
pub enum ImageKind {
JPEG(Vec<u8>),
PNG(Vec<u8>),
SVG(crate::Tree),
}
impl fmt::Debug for ImageKind {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ImageKind::JPEG(_) => f.write_str("ImageKind::JPEG(..)"),
ImageKind::PNG(_) => f.write_str("ImageKind::PNG(..)"),
ImageKind::SVG(_) => f.write_str("ImageKind::SVG(..)"),
}
}
}
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum FeBlendMode {
Normal,
Multiply,
Screen,
Darken,
Lighten,
}
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum FeCompositeOperator {
Over,
In,
Out,
Atop,
Xor,
Arithmetic {
k1: f64,
k2: f64,
k3: f64,
k4: f64,
},
}
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum FeMorphologyOperator {
Erode,
Dilate,
}
#[derive(Clone, Debug)]
pub enum FeImageKind {
Image(ImageKind),
Use(String),
}
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum FeEdgeMode {
None,
Duplicate,
Wrap,
}
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum FeTurbulenceKind {
FractalNoise,
Turbulence,
}
#[derive(Clone, Debug)]
pub struct ConvolveMatrix {
x: u32,
y: u32,
columns: u32,
rows: u32,
data: Vec<f64>,
}
impl ConvolveMatrix {
pub fn new(target_x: u32, target_y: u32, columns: u32, rows: u32, data: Vec<f64>) -> Option<Self> {
if (columns * rows) as usize != data.len()
|| target_x >= columns
|| target_y >= rows
{
return None;
}
Some(ConvolveMatrix {
x: target_x,
y: target_y,
columns,
rows,
data,
})
}
#[inline]
pub fn target_x(&self) -> u32 {
self.x
}
#[inline]
pub fn target_y(&self) -> u32 {
self.y
}
#[inline]
pub fn columns(&self) -> u32 {
self.columns
}
#[inline]
pub fn rows(&self) -> u32 {
self.rows
}
#[inline]
pub fn get(&self, x: u32, y: u32) -> f64 {
self.data[(y * self.columns + x) as usize]
}
#[inline]
pub fn data(&self) -> &[f64] {
&self.data
}
}
#[derive(Clone, Copy, PartialEq, Debug)]
#[allow(missing_docs)]
pub enum ShapeRendering {
OptimizeSpeed,
CrispEdges,
GeometricPrecision,
}
impl ShapeRendering {
pub fn use_shape_antialiasing(self) -> bool {
match self {
ShapeRendering::OptimizeSpeed => false,
ShapeRendering::CrispEdges => false,
ShapeRendering::GeometricPrecision => true,
}
}
}
impl_enum_default!(ShapeRendering, GeometricPrecision);
impl_enum_from_str!(ShapeRendering,
"optimizeSpeed" => ShapeRendering::OptimizeSpeed,
"crispEdges" => ShapeRendering::CrispEdges,
"geometricPrecision" => ShapeRendering::GeometricPrecision
);
impl_from_str!(ShapeRendering);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum TextRendering {
OptimizeSpeed,
OptimizeLegibility,
GeometricPrecision,
}
impl_enum_default!(TextRendering, OptimizeLegibility);
impl_enum_from_str!(TextRendering,
"optimizeSpeed" => TextRendering::OptimizeSpeed,
"optimizeLegibility" => TextRendering::OptimizeLegibility,
"geometricPrecision" => TextRendering::GeometricPrecision
);
impl_from_str!(TextRendering);
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum ImageRendering {
OptimizeQuality,
OptimizeSpeed,
}
impl_enum_default!(ImageRendering, OptimizeQuality);
impl_enum_from_str!(ImageRendering,
"optimizeQuality" => ImageRendering::OptimizeQuality,
"optimizeSpeed" => ImageRendering::OptimizeSpeed
);
impl_from_str!(ImageRendering);
#[derive(Clone, Copy, Debug)]
#[allow(missing_docs)]
pub struct EnableBackground(pub Option<Rect>);