gtk/
target_entry.rs

1use glib;
2use glib::translate::*;
3use gtk_sys;
4use libc::c_char;
5use std::ffi::CStr;
6use std::mem;
7use TargetFlags;
8
9#[derive(Clone, Debug)]
10#[repr(C)]
11pub struct TargetEntry {
12    target: String,
13    flags: TargetFlags,
14    info: u32,
15}
16
17impl TargetEntry {
18    pub fn new(target: &str, flags: TargetFlags, info: u32) -> TargetEntry {
19        assert_initialized_main_thread!();
20        TargetEntry {
21            target: target.to_owned(),
22            flags,
23            info,
24        }
25    }
26
27    pub fn get_target(&self) -> &str {
28        &self.target
29    }
30
31    pub fn get_flags(&self) -> TargetFlags {
32        self.flags
33    }
34
35    pub fn get_info(&self) -> u32 {
36        self.info
37    }
38}
39
40#[doc(hidden)]
41impl Uninitialized for TargetEntry {
42    #[inline]
43    unsafe fn uninitialized() -> Self {
44        mem::uninitialized()
45    }
46}
47
48#[doc(hidden)]
49impl<'a> ToGlibPtr<'a, *const gtk_sys::GtkTargetEntry> for TargetEntry {
50    type Storage = (Box<gtk_sys::GtkTargetEntry>, Stash<'a, *mut c_char, String>);
51
52    #[inline]
53    fn to_glib_none(&'a self) -> Stash<'a, *const gtk_sys::GtkTargetEntry, Self> {
54        let target = self.target.to_glib_none();
55
56        let target_entry = Box::new(gtk_sys::GtkTargetEntry {
57            target: target.0,
58            flags: self.flags.bits(),
59            info: self.info,
60        });
61        Stash(&*target_entry, (target_entry, target))
62    }
63}
64
65#[doc(hidden)]
66impl<'a> ToGlibPtrMut<'a, *mut gtk_sys::GtkTargetEntry> for TargetEntry {
67    type Storage = (Box<gtk_sys::GtkTargetEntry>, Stash<'a, *mut c_char, String>);
68
69    #[inline]
70    fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut gtk_sys::GtkTargetEntry, Self> {
71        let target = self.target.to_glib_none();
72
73        let mut target_entry = Box::new(gtk_sys::GtkTargetEntry {
74            target: target.0,
75            flags: self.flags.bits(),
76            info: self.info,
77        });
78        StashMut(&mut *target_entry, (target_entry, target))
79    }
80}
81
82#[doc(hidden)]
83impl FromGlibPtrNone<*const gtk_sys::GtkTargetEntry> for TargetEntry {
84    unsafe fn from_glib_none(ptr: *const gtk_sys::GtkTargetEntry) -> Self {
85        TargetEntry {
86            target: CStr::from_ptr((*ptr).target).to_string_lossy().into_owned(),
87            flags: TargetFlags::from_bits((*ptr).flags).unwrap(),
88            info: (*ptr).info,
89        }
90    }
91}
92
93#[doc(hidden)]
94impl FromGlibPtrNone<*mut gtk_sys::GtkTargetEntry> for TargetEntry {
95    unsafe fn from_glib_none(ptr: *mut gtk_sys::GtkTargetEntry) -> Self {
96        TargetEntry {
97            target: CStr::from_ptr((*ptr).target).to_string_lossy().into_owned(),
98            flags: TargetFlags::from_bits((*ptr).flags).unwrap(),
99            info: (*ptr).info,
100        }
101    }
102}
103
104#[doc(hidden)]
105impl FromGlibPtrFull<*mut gtk_sys::GtkTargetEntry> for TargetEntry {
106    #[inline]
107    unsafe fn from_glib_full(ptr: *mut gtk_sys::GtkTargetEntry) -> Self {
108        let target_entry = TargetEntry {
109            target: CStr::from_ptr((*ptr).target).to_string_lossy().into_owned(),
110            flags: TargetFlags::from_bits((*ptr).flags).unwrap(),
111            info: (*ptr).info,
112        };
113        gtk_sys::gtk_target_entry_free(ptr);
114        target_entry
115    }
116}
117
118impl glib::StaticType for TargetEntry {
119    fn static_type() -> glib::types::Type {
120        skip_assert_initialized!();
121        unsafe { from_glib(gtk_sys::gtk_target_entry_get_type()) }
122    }
123}