glifparser 2.0.1

A parser and writer for UFO `.glif` files
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

pub mod vws;
pub mod pap;
pub mod dash;

use serde::{Serialize, Deserialize};
use self::{vws::VWSContour, pap::PAPContour, dash::DashContour};
use crate::{PointData, glif::MFEKContour};

use super::{pointdata::MFEKPointData, MFEKOutline};

pub fn unknown_op() {
    log::warn!("Found unknown contour operation attached to contour. File was generated with newer MFEKglif, please upgrade to edit properly.");
}

pub fn unknown_op_outline() -> MFEKOutline<MFEKPointData> {
    unknown_op();
    MFEKOutline::new()
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ContourOperations<PD: PointData> {
    VariableWidthStroke { data: VWSContour },
    PatternAlongPath { data: PAPContour<PD> },
    DashAlongPath { data: DashContour },
}

pub trait ContourOperation<PD: PointData> {
    fn sub(&mut self, begin: usize, end: usize);
    fn append(&mut self, append: &MFEKContour<PD>);
    fn remove_op(&mut self, idx: usize);
    fn insert_op(&mut self, idx: usize);
}


impl<PD: PointData> ContourOperation<PD> for Option<ContourOperations<PD>> {
    fn sub(&mut self, begin: usize, end: usize) {
        if let Some(op) = self.as_mut() {
            match op {
                ContourOperations::VariableWidthStroke { ref mut data } => {
                    <VWSContour as ContourOperation<PD>>::sub(data, begin, end);
                }
                ContourOperations::PatternAlongPath { ref mut data } => {
                    data.sub(begin, end)
                }
                ContourOperations::DashAlongPath { ref mut data } => <DashContour as ContourOperation<PD>>::sub(data, begin, end),
            }
        }
    }

    fn append(&mut self, append: &MFEKContour<PD>) {
        if let Some(op) = self.as_mut() {
            match op {
                ContourOperations::VariableWidthStroke { ref mut data } => {
                    data.append(append)
                }
                ContourOperations::PatternAlongPath { ref mut data } => {
                    data.append(append)
                }
                ContourOperations::DashAlongPath { ref mut data } => data.append(append),
            }
        }
    }

    fn insert_op(&mut self, idx: usize) {
        if let Some(op) = self.as_mut() {
            match op {
                ContourOperations::VariableWidthStroke { ref mut data } => {
                    <VWSContour as ContourOperation<PD>>::insert_op(data, idx)
                }
                ContourOperations::PatternAlongPath { ref mut data } => data.insert_op(idx),
                ContourOperations::DashAlongPath { ref mut data } => <DashContour as ContourOperation<PD>>::insert_op(data, idx),
            }
        }
    }

    fn remove_op(&mut self, idx: usize) {
        if let Some(op) = self.as_mut() {
            match op {
                ContourOperations::VariableWidthStroke { ref mut data } => {
                    <VWSContour as ContourOperation<PD>>::remove_op(data, idx)
                }
                ContourOperations::PatternAlongPath { ref mut data } => data.remove_op(idx),
                ContourOperations::DashAlongPath { ref mut data } => <DashContour as ContourOperation<PD>>::remove_op(data, idx),
            }
        }
    }
}