gtk/auto/
adjustment.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use 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}