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;
15
16glib_wrapper! {
17 pub struct Adjustment(Object<gtk_sys::GtkAdjustment, gtk_sys::GtkAdjustmentClass, AdjustmentClass>);
18
19 match fn {
20 get_type => || gtk_sys::gtk_adjustment_get_type(),
21 }
22}
23
24impl Adjustment {
25 pub fn new(
26 value: f64,
27 lower: f64,
28 upper: f64,
29 step_increment: f64,
30 page_increment: f64,
31 page_size: f64,
32 ) -> Adjustment {
33 assert_initialized_main_thread!();
34 unsafe {
35 from_glib_none(gtk_sys::gtk_adjustment_new(
36 value,
37 lower,
38 upper,
39 step_increment,
40 page_increment,
41 page_size,
42 ))
43 }
44 }
45}
46
47pub const NONE_ADJUSTMENT: Option<&Adjustment> = None;
48
49pub trait AdjustmentExt: 'static {
50 #[cfg_attr(feature = "v3_18", deprecated)]
51 fn changed(&self);
52
53 fn clamp_page(&self, lower: f64, upper: f64);
54
55 fn configure(
56 &self,
57 value: f64,
58 lower: f64,
59 upper: f64,
60 step_increment: f64,
61 page_increment: f64,
62 page_size: f64,
63 );
64
65 fn get_lower(&self) -> f64;
66
67 fn get_minimum_increment(&self) -> f64;
68
69 fn get_page_increment(&self) -> f64;
70
71 fn get_page_size(&self) -> f64;
72
73 fn get_step_increment(&self) -> f64;
74
75 fn get_upper(&self) -> f64;
76
77 fn get_value(&self) -> f64;
78
79 fn set_lower(&self, lower: f64);
80
81 fn set_page_increment(&self, page_increment: f64);
82
83 fn set_page_size(&self, page_size: f64);
84
85 fn set_step_increment(&self, step_increment: f64);
86
87 fn set_upper(&self, upper: f64);
88
89 fn set_value(&self, value: f64);
90
91 #[cfg_attr(feature = "v3_18", deprecated)]
92 fn value_changed(&self);
93
94 fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
95
96 fn connect_value_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
97
98 fn connect_property_lower_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
99
100 fn connect_property_page_increment_notify<F: Fn(&Self) + 'static>(
101 &self,
102 f: F,
103 ) -> SignalHandlerId;
104
105 fn connect_property_page_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
106
107 fn connect_property_step_increment_notify<F: Fn(&Self) + 'static>(
108 &self,
109 f: F,
110 ) -> SignalHandlerId;
111
112 fn connect_property_upper_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
113
114 fn connect_property_value_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
115}
116
117impl<O: IsA<Adjustment>> AdjustmentExt for O {
118 fn changed(&self) {
119 unsafe {
120 gtk_sys::gtk_adjustment_changed(self.as_ref().to_glib_none().0);
121 }
122 }
123
124 fn clamp_page(&self, lower: f64, upper: f64) {
125 unsafe {
126 gtk_sys::gtk_adjustment_clamp_page(self.as_ref().to_glib_none().0, lower, upper);
127 }
128 }
129
130 fn configure(
131 &self,
132 value: f64,
133 lower: f64,
134 upper: f64,
135 step_increment: f64,
136 page_increment: f64,
137 page_size: f64,
138 ) {
139 unsafe {
140 gtk_sys::gtk_adjustment_configure(
141 self.as_ref().to_glib_none().0,
142 value,
143 lower,
144 upper,
145 step_increment,
146 page_increment,
147 page_size,
148 );
149 }
150 }
151
152 fn get_lower(&self) -> f64 {
153 unsafe { gtk_sys::gtk_adjustment_get_lower(self.as_ref().to_glib_none().0) }
154 }
155
156 fn get_minimum_increment(&self) -> f64 {
157 unsafe { gtk_sys::gtk_adjustment_get_minimum_increment(self.as_ref().to_glib_none().0) }
158 }
159
160 fn get_page_increment(&self) -> f64 {
161 unsafe { gtk_sys::gtk_adjustment_get_page_increment(self.as_ref().to_glib_none().0) }
162 }
163
164 fn get_page_size(&self) -> f64 {
165 unsafe { gtk_sys::gtk_adjustment_get_page_size(self.as_ref().to_glib_none().0) }
166 }
167
168 fn get_step_increment(&self) -> f64 {
169 unsafe { gtk_sys::gtk_adjustment_get_step_increment(self.as_ref().to_glib_none().0) }
170 }
171
172 fn get_upper(&self) -> f64 {
173 unsafe { gtk_sys::gtk_adjustment_get_upper(self.as_ref().to_glib_none().0) }
174 }
175
176 fn get_value(&self) -> f64 {
177 unsafe { gtk_sys::gtk_adjustment_get_value(self.as_ref().to_glib_none().0) }
178 }
179
180 fn set_lower(&self, lower: f64) {
181 unsafe {
182 gtk_sys::gtk_adjustment_set_lower(self.as_ref().to_glib_none().0, lower);
183 }
184 }
185
186 fn set_page_increment(&self, page_increment: f64) {
187 unsafe {
188 gtk_sys::gtk_adjustment_set_page_increment(
189 self.as_ref().to_glib_none().0,
190 page_increment,
191 );
192 }
193 }
194
195 fn set_page_size(&self, page_size: f64) {
196 unsafe {
197 gtk_sys::gtk_adjustment_set_page_size(self.as_ref().to_glib_none().0, page_size);
198 }
199 }
200
201 fn set_step_increment(&self, step_increment: f64) {
202 unsafe {
203 gtk_sys::gtk_adjustment_set_step_increment(
204 self.as_ref().to_glib_none().0,
205 step_increment,
206 );
207 }
208 }
209
210 fn set_upper(&self, upper: f64) {
211 unsafe {
212 gtk_sys::gtk_adjustment_set_upper(self.as_ref().to_glib_none().0, upper);
213 }
214 }
215
216 fn set_value(&self, value: f64) {
217 unsafe {
218 gtk_sys::gtk_adjustment_set_value(self.as_ref().to_glib_none().0, value);
219 }
220 }
221
222 fn value_changed(&self) {
223 unsafe {
224 gtk_sys::gtk_adjustment_value_changed(self.as_ref().to_glib_none().0);
225 }
226 }
227
228 fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
229 unsafe extern "C" fn changed_trampoline<P, F: Fn(&P) + 'static>(
230 this: *mut gtk_sys::GtkAdjustment,
231 f: glib_sys::gpointer,
232 ) where
233 P: IsA<Adjustment>,
234 {
235 let f: &F = &*(f as *const F);
236 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
237 }
238 unsafe {
239 let f: Box_<F> = Box_::new(f);
240 connect_raw(
241 self.as_ptr() as *mut _,
242 b"changed\0".as_ptr() as *const _,
243 Some(transmute(changed_trampoline::<Self, F> as usize)),
244 Box_::into_raw(f),
245 )
246 }
247 }
248
249 fn connect_value_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
250 unsafe extern "C" fn value_changed_trampoline<P, F: Fn(&P) + 'static>(
251 this: *mut gtk_sys::GtkAdjustment,
252 f: glib_sys::gpointer,
253 ) where
254 P: IsA<Adjustment>,
255 {
256 let f: &F = &*(f as *const F);
257 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
258 }
259 unsafe {
260 let f: Box_<F> = Box_::new(f);
261 connect_raw(
262 self.as_ptr() as *mut _,
263 b"value-changed\0".as_ptr() as *const _,
264 Some(transmute(value_changed_trampoline::<Self, F> as usize)),
265 Box_::into_raw(f),
266 )
267 }
268 }
269
270 fn connect_property_lower_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
271 unsafe extern "C" fn notify_lower_trampoline<P, F: Fn(&P) + 'static>(
272 this: *mut gtk_sys::GtkAdjustment,
273 _param_spec: glib_sys::gpointer,
274 f: glib_sys::gpointer,
275 ) where
276 P: IsA<Adjustment>,
277 {
278 let f: &F = &*(f as *const F);
279 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
280 }
281 unsafe {
282 let f: Box_<F> = Box_::new(f);
283 connect_raw(
284 self.as_ptr() as *mut _,
285 b"notify::lower\0".as_ptr() as *const _,
286 Some(transmute(notify_lower_trampoline::<Self, F> as usize)),
287 Box_::into_raw(f),
288 )
289 }
290 }
291
292 fn connect_property_page_increment_notify<F: Fn(&Self) + 'static>(
293 &self,
294 f: F,
295 ) -> SignalHandlerId {
296 unsafe extern "C" fn notify_page_increment_trampoline<P, F: Fn(&P) + 'static>(
297 this: *mut gtk_sys::GtkAdjustment,
298 _param_spec: glib_sys::gpointer,
299 f: glib_sys::gpointer,
300 ) where
301 P: IsA<Adjustment>,
302 {
303 let f: &F = &*(f as *const F);
304 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
305 }
306 unsafe {
307 let f: Box_<F> = Box_::new(f);
308 connect_raw(
309 self.as_ptr() as *mut _,
310 b"notify::page-increment\0".as_ptr() as *const _,
311 Some(transmute(
312 notify_page_increment_trampoline::<Self, F> as usize,
313 )),
314 Box_::into_raw(f),
315 )
316 }
317 }
318
319 fn connect_property_page_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
320 unsafe extern "C" fn notify_page_size_trampoline<P, F: Fn(&P) + 'static>(
321 this: *mut gtk_sys::GtkAdjustment,
322 _param_spec: glib_sys::gpointer,
323 f: glib_sys::gpointer,
324 ) where
325 P: IsA<Adjustment>,
326 {
327 let f: &F = &*(f as *const F);
328 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
329 }
330 unsafe {
331 let f: Box_<F> = Box_::new(f);
332 connect_raw(
333 self.as_ptr() as *mut _,
334 b"notify::page-size\0".as_ptr() as *const _,
335 Some(transmute(notify_page_size_trampoline::<Self, F> as usize)),
336 Box_::into_raw(f),
337 )
338 }
339 }
340
341 fn connect_property_step_increment_notify<F: Fn(&Self) + 'static>(
342 &self,
343 f: F,
344 ) -> SignalHandlerId {
345 unsafe extern "C" fn notify_step_increment_trampoline<P, F: Fn(&P) + 'static>(
346 this: *mut gtk_sys::GtkAdjustment,
347 _param_spec: glib_sys::gpointer,
348 f: glib_sys::gpointer,
349 ) where
350 P: IsA<Adjustment>,
351 {
352 let f: &F = &*(f as *const F);
353 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
354 }
355 unsafe {
356 let f: Box_<F> = Box_::new(f);
357 connect_raw(
358 self.as_ptr() as *mut _,
359 b"notify::step-increment\0".as_ptr() as *const _,
360 Some(transmute(
361 notify_step_increment_trampoline::<Self, F> as usize,
362 )),
363 Box_::into_raw(f),
364 )
365 }
366 }
367
368 fn connect_property_upper_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
369 unsafe extern "C" fn notify_upper_trampoline<P, F: Fn(&P) + 'static>(
370 this: *mut gtk_sys::GtkAdjustment,
371 _param_spec: glib_sys::gpointer,
372 f: glib_sys::gpointer,
373 ) where
374 P: IsA<Adjustment>,
375 {
376 let f: &F = &*(f as *const F);
377 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
378 }
379 unsafe {
380 let f: Box_<F> = Box_::new(f);
381 connect_raw(
382 self.as_ptr() as *mut _,
383 b"notify::upper\0".as_ptr() as *const _,
384 Some(transmute(notify_upper_trampoline::<Self, F> as usize)),
385 Box_::into_raw(f),
386 )
387 }
388 }
389
390 fn connect_property_value_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
391 unsafe extern "C" fn notify_value_trampoline<P, F: Fn(&P) + 'static>(
392 this: *mut gtk_sys::GtkAdjustment,
393 _param_spec: glib_sys::gpointer,
394 f: glib_sys::gpointer,
395 ) where
396 P: IsA<Adjustment>,
397 {
398 let f: &F = &*(f as *const F);
399 f(&Adjustment::from_glib_borrow(this).unsafe_cast())
400 }
401 unsafe {
402 let f: Box_<F> = Box_::new(f);
403 connect_raw(
404 self.as_ptr() as *mut _,
405 b"notify::value\0".as_ptr() as *const _,
406 Some(transmute(notify_value_trampoline::<Self, F> as usize)),
407 Box_::into_raw(f),
408 )
409 }
410 }
411}
412
413impl fmt::Display for Adjustment {
414 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
415 write!(f, "Adjustment")
416 }
417}