1 // Take a look at the license at the top of the repository in the LICENSE file. 2 3 use glib::translate::*; 4 use glib::GString; 5 use std::mem; 6 use std::ptr; 7 8 #[derive(Copy, Clone, PartialEq, Eq)] 9 #[doc(alias = "GdkAtom")] 10 pub struct Atom(ffi::GdkAtom); 11 12 pub const NONE: Atom = Atom(0 as *mut _); 13 pub const SELECTION_PRIMARY: Atom = Atom(1 as *mut _); 14 pub const SELECTION_SECONDARY: Atom = Atom(2 as *mut _); 15 pub const SELECTION_CLIPBOARD: Atom = Atom(69 as *mut _); 16 pub const TARGET_BITMAP: Atom = Atom(5 as *mut _); 17 pub const TARGET_COLORMAP: Atom = Atom(7 as *mut _); 18 pub const TARGET_DRAWABLE: Atom = Atom(17 as *mut _); 19 pub const TARGET_PIXMAP: Atom = Atom(20 as *mut _); 20 pub const TARGET_STRING: Atom = Atom(31 as *mut _); 21 pub const SELECTION_TYPE_ATOM: Atom = Atom(4 as *mut _); 22 pub const SELECTION_TYPE_BITMAP: Atom = Atom(5 as *mut _); 23 pub const SELECTION_TYPE_COLORMAP: Atom = Atom(7 as *mut _); 24 pub const SELECTION_TYPE_DRAWABLE: Atom = Atom(17 as *mut _); 25 pub const SELECTION_TYPE_INTEGER: Atom = Atom(19 as *mut _); 26 pub const SELECTION_TYPE_PIXMAP: Atom = Atom(20 as *mut _); 27 pub const SELECTION_TYPE_WINDOW: Atom = Atom(33 as *mut _); 28 pub const SELECTION_TYPE_STRING: Atom = Atom(31 as *mut _); 29 30 impl Atom { 31 #[doc(alias = "gdk_atom_intern")] intern(atom_name: &str) -> Atom32 pub fn intern(atom_name: &str) -> Atom { 33 assert_initialized_main_thread!(); 34 unsafe { 35 Atom(ffi::gdk_atom_intern( 36 atom_name.to_glib_none().0, 37 false.into_glib(), 38 )) 39 } 40 } 41 42 #[doc(alias = "gdk_atom_name")] name(self) -> GString43 pub fn name(self) -> GString { 44 unsafe { from_glib_full(ffi::gdk_atom_name(self.0)) } 45 } 46 value(self) -> usize47 pub unsafe fn value(self) -> usize { 48 self.0 as usize 49 } 50 } 51 52 impl GlibPtrDefault for Atom { 53 type GlibType = ffi::GdkAtom; 54 } 55 56 #[doc(hidden)] 57 impl Uninitialized for Atom { 58 #[inline] uninitialized() -> Self59 unsafe fn uninitialized() -> Self { 60 mem::zeroed() 61 } 62 } 63 64 impl<'a> ToGlibPtr<'a, ffi::GdkAtom> for Atom { 65 type Storage = (); 66 67 #[inline] to_glib_none(&self) -> Stash<'a, ffi::GdkAtom, Atom>68 fn to_glib_none(&self) -> Stash<'a, ffi::GdkAtom, Atom> { 69 Stash(self.0, ()) 70 } 71 } 72 73 impl<'a> ToGlibPtrMut<'a, *mut ffi::GdkAtom> for Atom { 74 type Storage = (); 75 76 #[inline] to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::GdkAtom, Atom>77 fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::GdkAtom, Atom> { 78 StashMut(&mut self.0, ()) 79 } 80 } 81 82 impl<'a> ToGlibContainerFromSlice<'a, *mut ffi::GdkAtom> for &'a Atom { 83 type Storage = ( 84 Vec<Stash<'a, ffi::GdkAtom, &'a Atom>>, 85 Option<Vec<ffi::GdkAtom>>, 86 ); 87 to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*mut ffi::GdkAtom, Self::Storage)88 fn to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*mut ffi::GdkAtom, Self::Storage) { 89 skip_assert_initialized!(); 90 91 let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect(); 92 let mut v_ptr: Vec<_> = v.iter().map(|s| s.0).collect(); 93 v_ptr.push(ptr::null_mut()); 94 95 (v_ptr.as_ptr() as *mut ffi::GdkAtom, (v, Some(v_ptr))) 96 } 97 to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*mut ffi::GdkAtom, Self::Storage)98 fn to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*mut ffi::GdkAtom, Self::Storage) { 99 skip_assert_initialized!(); 100 101 let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect(); 102 103 let v_ptr = unsafe { 104 let v_ptr = glib::ffi::g_malloc0(mem::size_of::<ffi::GdkAtom>() * (t.len() + 1)) 105 as *mut ffi::GdkAtom; 106 107 for (i, s) in v.iter().enumerate() { 108 ptr::write(v_ptr.add(i), s.0); 109 } 110 111 v_ptr 112 }; 113 114 (v_ptr, (v, None)) 115 } 116 to_glib_full_from_slice(_: &[&'a Atom]) -> *mut ffi::GdkAtom117 fn to_glib_full_from_slice(_: &[&'a Atom]) -> *mut ffi::GdkAtom { 118 skip_assert_initialized!(); 119 120 unimplemented!() 121 } 122 } 123 124 impl<'a> ToGlibContainerFromSlice<'a, *const ffi::GdkAtom> for &'a Atom { 125 type Storage = ( 126 Vec<Stash<'a, ffi::GdkAtom, &'a Atom>>, 127 Option<Vec<ffi::GdkAtom>>, 128 ); 129 to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*const ffi::GdkAtom, Self::Storage)130 fn to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*const ffi::GdkAtom, Self::Storage) { 131 skip_assert_initialized!(); 132 133 let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect(); 134 let mut v_ptr: Vec<_> = v.iter().map(|s| s.0).collect(); 135 v_ptr.push(ptr::null_mut()); 136 137 (v_ptr.as_ptr() as *const ffi::GdkAtom, (v, Some(v_ptr))) 138 } 139 to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*const ffi::GdkAtom, Self::Storage)140 fn to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*const ffi::GdkAtom, Self::Storage) { 141 skip_assert_initialized!(); 142 143 let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect(); 144 145 let v_ptr = unsafe { 146 let v_ptr = glib::ffi::g_malloc0(mem::size_of::<ffi::GdkAtom>() * (t.len() + 1)) 147 as *mut ffi::GdkAtom; 148 149 for (i, s) in v.iter().enumerate() { 150 ptr::write(v_ptr.add(i), s.0); 151 } 152 153 v_ptr as *const ffi::GdkAtom 154 }; 155 156 (v_ptr, (v, None)) 157 } 158 to_glib_full_from_slice(_: &[&'a Atom]) -> *const ffi::GdkAtom159 fn to_glib_full_from_slice(_: &[&'a Atom]) -> *const ffi::GdkAtom { 160 skip_assert_initialized!(); 161 162 unimplemented!() 163 } 164 } 165 166 impl FromGlibPtrNone<ffi::GdkAtom> for Atom { 167 #[inline] from_glib_none(ptr: ffi::GdkAtom) -> Atom168 unsafe fn from_glib_none(ptr: ffi::GdkAtom) -> Atom { 169 Atom(ptr) 170 } 171 } 172 173 impl FromGlibPtrBorrow<ffi::GdkAtom> for Atom { 174 #[inline] from_glib_borrow(ptr: ffi::GdkAtom) -> glib::translate::Borrowed<Atom>175 unsafe fn from_glib_borrow(ptr: ffi::GdkAtom) -> glib::translate::Borrowed<Atom> { 176 glib::translate::Borrowed::new(Atom(ptr)) 177 } 178 } 179 180 impl FromGlibPtrFull<ffi::GdkAtom> for Atom { 181 #[inline] from_glib_full(_: ffi::GdkAtom) -> Atom182 unsafe fn from_glib_full(_: ffi::GdkAtom) -> Atom { 183 unimplemented!() 184 } 185 } 186 187 impl FromGlibContainerAsVec<ffi::GdkAtom, *mut ffi::GdkAtom> for Atom { from_glib_none_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self>188 unsafe fn from_glib_none_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self> { 189 if num == 0 || ptr.is_null() { 190 return Vec::new(); 191 } 192 193 let mut res = Vec::with_capacity(num); 194 for i in 0..num { 195 res.push(from_glib_none(ptr::read(ptr.add(i)))); 196 } 197 res 198 } 199 from_glib_container_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self>200 unsafe fn from_glib_container_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self> { 201 let res = FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, num); 202 glib::ffi::g_free(ptr as *mut _); 203 res 204 } 205 from_glib_full_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self>206 unsafe fn from_glib_full_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self> { 207 if num == 0 || ptr.is_null() { 208 return Vec::new(); 209 } 210 211 let mut res = Vec::with_capacity(num); 212 for i in 0..num { 213 res.push(from_glib_full(ptr::read(ptr.add(i)))); 214 } 215 glib::ffi::g_free(ptr as *mut _); 216 res 217 } 218 } 219 220 impl FromGlibPtrArrayContainerAsVec<ffi::GdkAtom, *mut ffi::GdkAtom> for Atom { from_glib_none_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self>221 unsafe fn from_glib_none_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self> { 222 FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, c_ptr_array_len(ptr)) 223 } 224 from_glib_container_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self>225 unsafe fn from_glib_container_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self> { 226 FromGlibContainerAsVec::from_glib_container_num_as_vec(ptr, c_ptr_array_len(ptr)) 227 } 228 from_glib_full_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self>229 unsafe fn from_glib_full_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self> { 230 FromGlibContainerAsVec::from_glib_full_num_as_vec(ptr, c_ptr_array_len(ptr)) 231 } 232 } 233 234 impl<'a> From<&'a str> for Atom { from(r: &'a str) -> Atom235 fn from(r: &'a str) -> Atom { 236 skip_assert_initialized!(); 237 Atom::intern(r) 238 } 239 } 240