clippers 0.1.2

Cross-platform clipboard management library
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use super::ffi;
use std::{fmt::Debug, hash::Hash, mem::MaybeUninit, ops::Deref};

/// RGBA image
pub struct ClipperImage(pub(crate) ffi::ClipperImage);
impl ClipperImage {
	#[inline(always)]
	/// Returns the width of the image
	pub fn width(&self) -> u32 {
		self.0.width
	}

	#[inline(always)]
	/// Returns the height of the image
	pub fn height(&self) -> u32 {
		self.0.height
	}

	pub(crate) fn size(&self) -> usize {
		(self.0.width * self.0.height * 4) as usize
	}

	/// Returns the image as a slice of RGBA pixels
	pub fn rgba(&self) -> &[u8] {
		unsafe { std::slice::from_raw_parts(self.0.rgba, self.size()) }
	}
}
impl From<ClipperImage> for Vec<u8> {
	fn from(img: ClipperImage) -> Self {
		img.as_ref().to_vec()
	}
}
impl From<ClipperImage> for Box<[u8]> {
	fn from(img: ClipperImage) -> Self {
		img.as_ref().into()
	}
}
impl AsRef<[u8]> for ClipperImage {
	fn as_ref(&self) -> &[u8] {
		unsafe { std::slice::from_raw_parts(self.0.rgba, self.size()) }
	}
}
impl Deref for ClipperImage {
	type Target = [u8];

	#[inline]
	fn deref(&self) -> &Self::Target {
		self.as_ref()
	}
}
impl Debug for ClipperImage {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		f.debug_struct("ClipperImage")
			.field("width", &self.width())
			.field("height", &self.height())
			.field("rgba", &self.as_ref())
			.finish()
	}
}
impl Drop for ClipperImage {
	fn drop(&mut self) {
		unsafe {
			ffi::clipper_free_tagged_data(ffi::TaggedClipperData {
				tag: ffi::ClipperTag::Image,
				data: MaybeUninit::new(ffi::ClipperData { image: self.0 }),
			})
		}
	}
}

impl Eq for ClipperImage {}
impl PartialEq for ClipperImage {
	#[inline]
	fn eq(&self, other: &Self) -> bool {
		self.as_ref() == other.as_ref()
	}
}
impl PartialEq<[u8]> for ClipperImage {
	fn eq(&self, other: &[u8]) -> bool {
		self.as_ref() == other
	}
}
impl PartialEq<ClipperImage> for [u8] {
	fn eq(&self, other: &ClipperImage) -> bool {
		self == other.as_ref()
	}
}
impl PartialEq<Vec<u8>> for ClipperImage {
	fn eq(&self, other: &Vec<u8>) -> bool {
		self.as_ref() == other.as_slice()
	}
}
impl PartialEq<ClipperImage> for Vec<u8> {
	fn eq(&self, other: &ClipperImage) -> bool {
		self.as_slice() == other.as_ref()
	}
}

impl Ord for ClipperImage {
	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
		self.as_ref().cmp(other.as_ref())
	}
}
impl PartialOrd for ClipperImage {
	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
		Some(self.cmp(other))
	}
}
impl PartialOrd<[u8]> for ClipperImage {
	fn partial_cmp(&self, other: &[u8]) -> Option<std::cmp::Ordering> {
		Some(self.as_ref().cmp(other))
	}
}
impl PartialOrd<ClipperImage> for [u8] {
	fn partial_cmp(&self, other: &ClipperImage) -> Option<std::cmp::Ordering> {
		Some(self.cmp(other.as_ref()))
	}
}
impl PartialOrd<Vec<u8>> for ClipperImage {
	fn partial_cmp(&self, other: &Vec<u8>) -> Option<std::cmp::Ordering> {
		Some(self.as_ref().cmp(other.as_slice()))
	}
}
impl PartialOrd<ClipperImage> for Vec<u8> {
	fn partial_cmp(&self, other: &ClipperImage) -> Option<std::cmp::Ordering> {
		Some(self.as_slice().cmp(other.as_ref()))
	}
}

impl Hash for ClipperImage {
	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
		self.as_ref().hash(state)
	}
}