1use glib::object::Cast;
6use glib::object::IsA;
7use glib::signal::connect_raw;
8use glib::signal::SignalHandlerId;
9use glib::translate::*;
10use glib_sys;
11use gtk_sys;
12use std::boxed::Box as Box_;
13use std::fmt;
14use std::mem::transmute;
15use Adjustment;
16#[cfg(any(feature = "v3_16", feature = "dox"))]
17use Border;
18use ScrollablePolicy;
19
20glib_wrapper! {
21 pub struct Scrollable(Interface<gtk_sys::GtkScrollable>);
22
23 match fn {
24 get_type => || gtk_sys::gtk_scrollable_get_type(),
25 }
26}
27
28pub const NONE_SCROLLABLE: Option<&Scrollable> = None;
29
30pub trait ScrollableExt: 'static {
31 #[cfg(any(feature = "v3_16", feature = "dox"))]
32 fn get_border(&self) -> Option<Border>;
33
34 fn get_hadjustment(&self) -> Option<Adjustment>;
35
36 fn get_hscroll_policy(&self) -> ScrollablePolicy;
37
38 fn get_vadjustment(&self) -> Option<Adjustment>;
39
40 fn get_vscroll_policy(&self) -> ScrollablePolicy;
41
42 fn set_hadjustment<P: IsA<Adjustment>>(&self, hadjustment: Option<&P>);
43
44 fn set_hscroll_policy(&self, policy: ScrollablePolicy);
45
46 fn set_vadjustment<P: IsA<Adjustment>>(&self, vadjustment: Option<&P>);
47
48 fn set_vscroll_policy(&self, policy: ScrollablePolicy);
49
50 fn connect_property_hadjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
51
52 fn connect_property_hscroll_policy_notify<F: Fn(&Self) + 'static>(
53 &self,
54 f: F,
55 ) -> SignalHandlerId;
56
57 fn connect_property_vadjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
58
59 fn connect_property_vscroll_policy_notify<F: Fn(&Self) + 'static>(
60 &self,
61 f: F,
62 ) -> SignalHandlerId;
63}
64
65impl<O: IsA<Scrollable>> ScrollableExt for O {
66 #[cfg(any(feature = "v3_16", feature = "dox"))]
67 fn get_border(&self) -> Option<Border> {
68 unsafe {
69 let mut border = Border::uninitialized();
70 let ret = from_glib(gtk_sys::gtk_scrollable_get_border(
71 self.as_ref().to_glib_none().0,
72 border.to_glib_none_mut().0,
73 ));
74 if ret {
75 Some(border)
76 } else {
77 None
78 }
79 }
80 }
81
82 fn get_hadjustment(&self) -> Option<Adjustment> {
83 unsafe {
84 from_glib_none(gtk_sys::gtk_scrollable_get_hadjustment(
85 self.as_ref().to_glib_none().0,
86 ))
87 }
88 }
89
90 fn get_hscroll_policy(&self) -> ScrollablePolicy {
91 unsafe {
92 from_glib(gtk_sys::gtk_scrollable_get_hscroll_policy(
93 self.as_ref().to_glib_none().0,
94 ))
95 }
96 }
97
98 fn get_vadjustment(&self) -> Option<Adjustment> {
99 unsafe {
100 from_glib_none(gtk_sys::gtk_scrollable_get_vadjustment(
101 self.as_ref().to_glib_none().0,
102 ))
103 }
104 }
105
106 fn get_vscroll_policy(&self) -> ScrollablePolicy {
107 unsafe {
108 from_glib(gtk_sys::gtk_scrollable_get_vscroll_policy(
109 self.as_ref().to_glib_none().0,
110 ))
111 }
112 }
113
114 fn set_hadjustment<P: IsA<Adjustment>>(&self, hadjustment: Option<&P>) {
115 unsafe {
116 gtk_sys::gtk_scrollable_set_hadjustment(
117 self.as_ref().to_glib_none().0,
118 hadjustment.map(|p| p.as_ref()).to_glib_none().0,
119 );
120 }
121 }
122
123 fn set_hscroll_policy(&self, policy: ScrollablePolicy) {
124 unsafe {
125 gtk_sys::gtk_scrollable_set_hscroll_policy(
126 self.as_ref().to_glib_none().0,
127 policy.to_glib(),
128 );
129 }
130 }
131
132 fn set_vadjustment<P: IsA<Adjustment>>(&self, vadjustment: Option<&P>) {
133 unsafe {
134 gtk_sys::gtk_scrollable_set_vadjustment(
135 self.as_ref().to_glib_none().0,
136 vadjustment.map(|p| p.as_ref()).to_glib_none().0,
137 );
138 }
139 }
140
141 fn set_vscroll_policy(&self, policy: ScrollablePolicy) {
142 unsafe {
143 gtk_sys::gtk_scrollable_set_vscroll_policy(
144 self.as_ref().to_glib_none().0,
145 policy.to_glib(),
146 );
147 }
148 }
149
150 fn connect_property_hadjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
151 unsafe extern "C" fn notify_hadjustment_trampoline<P, F: Fn(&P) + 'static>(
152 this: *mut gtk_sys::GtkScrollable,
153 _param_spec: glib_sys::gpointer,
154 f: glib_sys::gpointer,
155 ) where
156 P: IsA<Scrollable>,
157 {
158 let f: &F = &*(f as *const F);
159 f(&Scrollable::from_glib_borrow(this).unsafe_cast())
160 }
161 unsafe {
162 let f: Box_<F> = Box_::new(f);
163 connect_raw(
164 self.as_ptr() as *mut _,
165 b"notify::hadjustment\0".as_ptr() as *const _,
166 Some(transmute(notify_hadjustment_trampoline::<Self, F> as usize)),
167 Box_::into_raw(f),
168 )
169 }
170 }
171
172 fn connect_property_hscroll_policy_notify<F: Fn(&Self) + 'static>(
173 &self,
174 f: F,
175 ) -> SignalHandlerId {
176 unsafe extern "C" fn notify_hscroll_policy_trampoline<P, F: Fn(&P) + 'static>(
177 this: *mut gtk_sys::GtkScrollable,
178 _param_spec: glib_sys::gpointer,
179 f: glib_sys::gpointer,
180 ) where
181 P: IsA<Scrollable>,
182 {
183 let f: &F = &*(f as *const F);
184 f(&Scrollable::from_glib_borrow(this).unsafe_cast())
185 }
186 unsafe {
187 let f: Box_<F> = Box_::new(f);
188 connect_raw(
189 self.as_ptr() as *mut _,
190 b"notify::hscroll-policy\0".as_ptr() as *const _,
191 Some(transmute(
192 notify_hscroll_policy_trampoline::<Self, F> as usize,
193 )),
194 Box_::into_raw(f),
195 )
196 }
197 }
198
199 fn connect_property_vadjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
200 unsafe extern "C" fn notify_vadjustment_trampoline<P, F: Fn(&P) + 'static>(
201 this: *mut gtk_sys::GtkScrollable,
202 _param_spec: glib_sys::gpointer,
203 f: glib_sys::gpointer,
204 ) where
205 P: IsA<Scrollable>,
206 {
207 let f: &F = &*(f as *const F);
208 f(&Scrollable::from_glib_borrow(this).unsafe_cast())
209 }
210 unsafe {
211 let f: Box_<F> = Box_::new(f);
212 connect_raw(
213 self.as_ptr() as *mut _,
214 b"notify::vadjustment\0".as_ptr() as *const _,
215 Some(transmute(notify_vadjustment_trampoline::<Self, F> as usize)),
216 Box_::into_raw(f),
217 )
218 }
219 }
220
221 fn connect_property_vscroll_policy_notify<F: Fn(&Self) + 'static>(
222 &self,
223 f: F,
224 ) -> SignalHandlerId {
225 unsafe extern "C" fn notify_vscroll_policy_trampoline<P, F: Fn(&P) + 'static>(
226 this: *mut gtk_sys::GtkScrollable,
227 _param_spec: glib_sys::gpointer,
228 f: glib_sys::gpointer,
229 ) where
230 P: IsA<Scrollable>,
231 {
232 let f: &F = &*(f as *const F);
233 f(&Scrollable::from_glib_borrow(this).unsafe_cast())
234 }
235 unsafe {
236 let f: Box_<F> = Box_::new(f);
237 connect_raw(
238 self.as_ptr() as *mut _,
239 b"notify::vscroll-policy\0".as_ptr() as *const _,
240 Some(transmute(
241 notify_vscroll_policy_trampoline::<Self, F> as usize,
242 )),
243 Box_::into_raw(f),
244 )
245 }
246 }
247}
248
249impl fmt::Display for Scrollable {
250 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
251 write!(f, "Scrollable")
252 }
253}