clipper2_sys/
clipper_offset.rs

1use crate::{
2    clipper_clipper64_size, clipper_clipperoffset, clipper_clipperoffset_add_path64,
3    clipper_clipperoffset_add_paths64, clipper_clipperoffset_clear, clipper_clipperoffset_execute,
4    clipper_clipperoffset_get_arc_tolerance, clipper_clipperoffset_get_miter_limit,
5    clipper_clipperoffset_get_preserve_collinear, clipper_clipperoffset_get_reverse_solution,
6    clipper_clipperoffset_set_arc_tolerance, clipper_clipperoffset_set_miter_limit,
7    clipper_clipperoffset_set_preserve_collinear, clipper_clipperoffset_set_reverse_solution,
8    clipper_clipperoffset_size, clipper_delete_clipperoffset, clipper_delete_path64,
9    clipper_delete_paths64, malloc, ClipperClipperOffset, EndType, JoinType, Path64, Paths64,
10};
11
12pub struct ClipperOffset {
13    ptr: *mut ClipperClipperOffset,
14}
15
16impl ClipperOffset {
17    pub fn new(
18        miter_limit: f64,
19        arc_tolerance: f64,
20        preserve_collinear: bool,
21        reverse_solution: bool,
22    ) -> Self {
23        let ptr = unsafe {
24            let mem = malloc(clipper_clipperoffset_size());
25            clipper_clipperoffset(
26                mem,
27                miter_limit,
28                arc_tolerance,
29                if preserve_collinear { 1 } else { 0 },
30                if reverse_solution { 1 } else { 0 },
31            )
32        };
33        Self { ptr: ptr }
34    }
35
36    pub fn add_path(&self, path: Path64, join_type: JoinType, end_type: EndType) {
37        unsafe {
38            let path_prt = path.get_clipper_path();
39            clipper_clipperoffset_add_path64(self.ptr, path_prt, join_type.into(), end_type.into());
40            clipper_delete_path64(path_prt);
41        }
42    }
43
44    pub fn add_paths(&self, paths: Paths64, join_type: JoinType, end_type: EndType) {
45        unsafe {
46            let path_prt = paths.get_clipper_paths();
47            clipper_clipperoffset_add_paths64(
48                self.ptr,
49                path_prt,
50                join_type.into(),
51                end_type.into(),
52            );
53            clipper_delete_paths64(path_prt);
54        }
55    }
56
57    pub fn execute(&self, delta: f64) -> Paths64 {
58        unsafe {
59            let mem = malloc(clipper_clipper64_size());
60            let paths_ptr = clipper_clipperoffset_execute(mem, self.ptr, delta);
61            let paths = Paths64::from(paths_ptr);
62            clipper_delete_paths64(paths_ptr);
63            paths
64        }
65    }
66
67    pub fn clear(&self) {
68        unsafe { clipper_clipperoffset_clear(self.ptr) }
69    }
70
71    pub fn get_miter_limit(&self) -> f64 {
72        unsafe { clipper_clipperoffset_get_miter_limit(self.ptr) }
73    }
74
75    pub fn set_miter_limit(&self, miter_limit: f64) {
76        unsafe { clipper_clipperoffset_set_miter_limit(self.ptr, miter_limit) }
77    }
78
79    pub fn get_arc_tolerance(&self) -> f64 {
80        unsafe { clipper_clipperoffset_get_arc_tolerance(self.ptr) }
81    }
82
83    pub fn set_arc_tolerance(&self, arc_tolerance: f64) {
84        unsafe { clipper_clipperoffset_set_arc_tolerance(self.ptr, arc_tolerance) }
85    }
86
87    pub fn get_preserve_collinear(&self) -> bool {
88        unsafe { clipper_clipperoffset_get_preserve_collinear(self.ptr) == 1 }
89    }
90
91    pub fn set_preserve_collinear(&self, preserve_collinear: bool) {
92        unsafe {
93            clipper_clipperoffset_set_preserve_collinear(
94                self.ptr,
95                if preserve_collinear { 1 } else { 0 },
96            )
97        }
98    }
99
100    pub fn get_reverse_solution(&self) -> bool {
101        unsafe { clipper_clipperoffset_get_reverse_solution(self.ptr) == 1 }
102    }
103
104    pub fn set_reverse_solution(&self, reverse_solution: bool) {
105        unsafe {
106            clipper_clipperoffset_set_reverse_solution(
107                self.ptr,
108                if reverse_solution { 1 } else { 0 },
109            )
110        }
111    }
112}
113
114impl Drop for ClipperOffset {
115    fn drop(&mut self) {
116        unsafe { clipper_delete_clipperoffset(self.ptr) }
117    }
118}