1use gdk;
6use glib;
7use glib::object::Cast;
8use glib::object::IsA;
9use glib::object::ObjectExt;
10use glib::signal::connect_raw;
11use glib::signal::SignalHandlerId;
12use glib::translate::*;
13use glib_sys;
14use gobject_sys;
15use gtk_sys;
16use libc;
17use signal::Inhibit;
18use std::boxed::Box as Box_;
19use std::fmt;
20use std::mem;
21use std::mem::transmute;
22use Adjustment;
23use Buildable;
24use Orientable;
25use ScrollType;
26use SensitivityType;
27use Widget;
28
29glib_wrapper! {
30 pub struct Range(Object<gtk_sys::GtkRange, gtk_sys::GtkRangeClass, RangeClass>) @extends Widget, @implements Buildable, Orientable;
31
32 match fn {
33 get_type => || gtk_sys::gtk_range_get_type(),
34 }
35}
36
37pub const NONE_RANGE: Option<&Range> = None;
38
39pub trait RangeExt: 'static {
40 fn get_adjustment(&self) -> Adjustment;
41
42 fn get_fill_level(&self) -> f64;
43
44 fn get_flippable(&self) -> bool;
45
46 fn get_inverted(&self) -> bool;
47
48 fn get_lower_stepper_sensitivity(&self) -> SensitivityType;
49
50 #[cfg_attr(feature = "v3_20", deprecated)]
51 fn get_min_slider_size(&self) -> i32;
52
53 fn get_range_rect(&self) -> gdk::Rectangle;
54
55 fn get_restrict_to_fill_level(&self) -> bool;
56
57 fn get_round_digits(&self) -> i32;
58
59 fn get_show_fill_level(&self) -> bool;
60
61 fn get_slider_range(&self) -> (i32, i32);
62
63 fn get_slider_size_fixed(&self) -> bool;
64
65 fn get_upper_stepper_sensitivity(&self) -> SensitivityType;
66
67 fn get_value(&self) -> f64;
68
69 fn set_adjustment<P: IsA<Adjustment>>(&self, adjustment: &P);
70
71 fn set_fill_level(&self, fill_level: f64);
72
73 fn set_flippable(&self, flippable: bool);
74
75 fn set_increments(&self, step: f64, page: f64);
76
77 fn set_inverted(&self, setting: bool);
78
79 fn set_lower_stepper_sensitivity(&self, sensitivity: SensitivityType);
80
81 #[cfg_attr(feature = "v3_20", deprecated)]
82 fn set_min_slider_size(&self, min_size: i32);
83
84 fn set_range(&self, min: f64, max: f64);
85
86 fn set_restrict_to_fill_level(&self, restrict_to_fill_level: bool);
87
88 fn set_round_digits(&self, round_digits: i32);
89
90 fn set_show_fill_level(&self, show_fill_level: bool);
91
92 fn set_slider_size_fixed(&self, size_fixed: bool);
93
94 fn set_upper_stepper_sensitivity(&self, sensitivity: SensitivityType);
95
96 fn set_value(&self, value: f64);
97
98 fn connect_adjust_bounds<F: Fn(&Self, f64) + 'static>(&self, f: F) -> SignalHandlerId;
99
100 fn connect_change_value<F: Fn(&Self, ScrollType, f64) -> Inhibit + 'static>(
101 &self,
102 f: F,
103 ) -> SignalHandlerId;
104
105 fn connect_move_slider<F: Fn(&Self, ScrollType) + 'static>(&self, f: F) -> SignalHandlerId;
106
107 fn emit_move_slider(&self, step: ScrollType);
108
109 fn connect_value_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
110
111 fn connect_property_adjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
112
113 fn connect_property_fill_level_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
114
115 fn connect_property_inverted_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
116
117 fn connect_property_lower_stepper_sensitivity_notify<F: Fn(&Self) + 'static>(
118 &self,
119 f: F,
120 ) -> SignalHandlerId;
121
122 fn connect_property_restrict_to_fill_level_notify<F: Fn(&Self) + 'static>(
123 &self,
124 f: F,
125 ) -> SignalHandlerId;
126
127 fn connect_property_round_digits_notify<F: Fn(&Self) + 'static>(&self, f: F)
128 -> SignalHandlerId;
129
130 fn connect_property_show_fill_level_notify<F: Fn(&Self) + 'static>(
131 &self,
132 f: F,
133 ) -> SignalHandlerId;
134
135 fn connect_property_upper_stepper_sensitivity_notify<F: Fn(&Self) + 'static>(
136 &self,
137 f: F,
138 ) -> SignalHandlerId;
139}
140
141impl<O: IsA<Range>> RangeExt for O {
142 fn get_adjustment(&self) -> Adjustment {
143 unsafe {
144 from_glib_none(gtk_sys::gtk_range_get_adjustment(
145 self.as_ref().to_glib_none().0,
146 ))
147 }
148 }
149
150 fn get_fill_level(&self) -> f64 {
151 unsafe { gtk_sys::gtk_range_get_fill_level(self.as_ref().to_glib_none().0) }
152 }
153
154 fn get_flippable(&self) -> bool {
155 unsafe {
156 from_glib(gtk_sys::gtk_range_get_flippable(
157 self.as_ref().to_glib_none().0,
158 ))
159 }
160 }
161
162 fn get_inverted(&self) -> bool {
163 unsafe {
164 from_glib(gtk_sys::gtk_range_get_inverted(
165 self.as_ref().to_glib_none().0,
166 ))
167 }
168 }
169
170 fn get_lower_stepper_sensitivity(&self) -> SensitivityType {
171 unsafe {
172 from_glib(gtk_sys::gtk_range_get_lower_stepper_sensitivity(
173 self.as_ref().to_glib_none().0,
174 ))
175 }
176 }
177
178 fn get_min_slider_size(&self) -> i32 {
179 unsafe { gtk_sys::gtk_range_get_min_slider_size(self.as_ref().to_glib_none().0) }
180 }
181
182 fn get_range_rect(&self) -> gdk::Rectangle {
183 unsafe {
184 let mut range_rect = gdk::Rectangle::uninitialized();
185 gtk_sys::gtk_range_get_range_rect(
186 self.as_ref().to_glib_none().0,
187 range_rect.to_glib_none_mut().0,
188 );
189 range_rect
190 }
191 }
192
193 fn get_restrict_to_fill_level(&self) -> bool {
194 unsafe {
195 from_glib(gtk_sys::gtk_range_get_restrict_to_fill_level(
196 self.as_ref().to_glib_none().0,
197 ))
198 }
199 }
200
201 fn get_round_digits(&self) -> i32 {
202 unsafe { gtk_sys::gtk_range_get_round_digits(self.as_ref().to_glib_none().0) }
203 }
204
205 fn get_show_fill_level(&self) -> bool {
206 unsafe {
207 from_glib(gtk_sys::gtk_range_get_show_fill_level(
208 self.as_ref().to_glib_none().0,
209 ))
210 }
211 }
212
213 fn get_slider_range(&self) -> (i32, i32) {
214 unsafe {
215 let mut slider_start = mem::uninitialized();
216 let mut slider_end = mem::uninitialized();
217 gtk_sys::gtk_range_get_slider_range(
218 self.as_ref().to_glib_none().0,
219 &mut slider_start,
220 &mut slider_end,
221 );
222 (slider_start, slider_end)
223 }
224 }
225
226 fn get_slider_size_fixed(&self) -> bool {
227 unsafe {
228 from_glib(gtk_sys::gtk_range_get_slider_size_fixed(
229 self.as_ref().to_glib_none().0,
230 ))
231 }
232 }
233
234 fn get_upper_stepper_sensitivity(&self) -> SensitivityType {
235 unsafe {
236 from_glib(gtk_sys::gtk_range_get_upper_stepper_sensitivity(
237 self.as_ref().to_glib_none().0,
238 ))
239 }
240 }
241
242 fn get_value(&self) -> f64 {
243 unsafe { gtk_sys::gtk_range_get_value(self.as_ref().to_glib_none().0) }
244 }
245
246 fn set_adjustment<P: IsA<Adjustment>>(&self, adjustment: &P) {
247 unsafe {
248 gtk_sys::gtk_range_set_adjustment(
249 self.as_ref().to_glib_none().0,
250 adjustment.as_ref().to_glib_none().0,
251 );
252 }
253 }
254
255 fn set_fill_level(&self, fill_level: f64) {
256 unsafe {
257 gtk_sys::gtk_range_set_fill_level(self.as_ref().to_glib_none().0, fill_level);
258 }
259 }
260
261 fn set_flippable(&self, flippable: bool) {
262 unsafe {
263 gtk_sys::gtk_range_set_flippable(self.as_ref().to_glib_none().0, flippable.to_glib());
264 }
265 }
266
267 fn set_increments(&self, step: f64, page: f64) {
268 unsafe {
269 gtk_sys::gtk_range_set_increments(self.as_ref().to_glib_none().0, step, page);
270 }
271 }
272
273 fn set_inverted(&self, setting: bool) {
274 unsafe {
275 gtk_sys::gtk_range_set_inverted(self.as_ref().to_glib_none().0, setting.to_glib());
276 }
277 }
278
279 fn set_lower_stepper_sensitivity(&self, sensitivity: SensitivityType) {
280 unsafe {
281 gtk_sys::gtk_range_set_lower_stepper_sensitivity(
282 self.as_ref().to_glib_none().0,
283 sensitivity.to_glib(),
284 );
285 }
286 }
287
288 fn set_min_slider_size(&self, min_size: i32) {
289 unsafe {
290 gtk_sys::gtk_range_set_min_slider_size(self.as_ref().to_glib_none().0, min_size);
291 }
292 }
293
294 fn set_range(&self, min: f64, max: f64) {
295 unsafe {
296 gtk_sys::gtk_range_set_range(self.as_ref().to_glib_none().0, min, max);
297 }
298 }
299
300 fn set_restrict_to_fill_level(&self, restrict_to_fill_level: bool) {
301 unsafe {
302 gtk_sys::gtk_range_set_restrict_to_fill_level(
303 self.as_ref().to_glib_none().0,
304 restrict_to_fill_level.to_glib(),
305 );
306 }
307 }
308
309 fn set_round_digits(&self, round_digits: i32) {
310 unsafe {
311 gtk_sys::gtk_range_set_round_digits(self.as_ref().to_glib_none().0, round_digits);
312 }
313 }
314
315 fn set_show_fill_level(&self, show_fill_level: bool) {
316 unsafe {
317 gtk_sys::gtk_range_set_show_fill_level(
318 self.as_ref().to_glib_none().0,
319 show_fill_level.to_glib(),
320 );
321 }
322 }
323
324 fn set_slider_size_fixed(&self, size_fixed: bool) {
325 unsafe {
326 gtk_sys::gtk_range_set_slider_size_fixed(
327 self.as_ref().to_glib_none().0,
328 size_fixed.to_glib(),
329 );
330 }
331 }
332
333 fn set_upper_stepper_sensitivity(&self, sensitivity: SensitivityType) {
334 unsafe {
335 gtk_sys::gtk_range_set_upper_stepper_sensitivity(
336 self.as_ref().to_glib_none().0,
337 sensitivity.to_glib(),
338 );
339 }
340 }
341
342 fn set_value(&self, value: f64) {
343 unsafe {
344 gtk_sys::gtk_range_set_value(self.as_ref().to_glib_none().0, value);
345 }
346 }
347
348 fn connect_adjust_bounds<F: Fn(&Self, f64) + 'static>(&self, f: F) -> SignalHandlerId {
349 unsafe extern "C" fn adjust_bounds_trampoline<P, F: Fn(&P, f64) + 'static>(
350 this: *mut gtk_sys::GtkRange,
351 value: libc::c_double,
352 f: glib_sys::gpointer,
353 ) where
354 P: IsA<Range>,
355 {
356 let f: &F = &*(f as *const F);
357 f(&Range::from_glib_borrow(this).unsafe_cast(), value)
358 }
359 unsafe {
360 let f: Box_<F> = Box_::new(f);
361 connect_raw(
362 self.as_ptr() as *mut _,
363 b"adjust-bounds\0".as_ptr() as *const _,
364 Some(transmute(adjust_bounds_trampoline::<Self, F> as usize)),
365 Box_::into_raw(f),
366 )
367 }
368 }
369
370 fn connect_change_value<F: Fn(&Self, ScrollType, f64) -> Inhibit + 'static>(
371 &self,
372 f: F,
373 ) -> SignalHandlerId {
374 unsafe extern "C" fn change_value_trampoline<
375 P,
376 F: Fn(&P, ScrollType, f64) -> Inhibit + 'static,
377 >(
378 this: *mut gtk_sys::GtkRange,
379 scroll: gtk_sys::GtkScrollType,
380 value: libc::c_double,
381 f: glib_sys::gpointer,
382 ) -> glib_sys::gboolean
383 where
384 P: IsA<Range>,
385 {
386 let f: &F = &*(f as *const F);
387 f(
388 &Range::from_glib_borrow(this).unsafe_cast(),
389 from_glib(scroll),
390 value,
391 )
392 .to_glib()
393 }
394 unsafe {
395 let f: Box_<F> = Box_::new(f);
396 connect_raw(
397 self.as_ptr() as *mut _,
398 b"change-value\0".as_ptr() as *const _,
399 Some(transmute(change_value_trampoline::<Self, F> as usize)),
400 Box_::into_raw(f),
401 )
402 }
403 }
404
405 fn connect_move_slider<F: Fn(&Self, ScrollType) + 'static>(&self, f: F) -> SignalHandlerId {
406 unsafe extern "C" fn move_slider_trampoline<P, F: Fn(&P, ScrollType) + 'static>(
407 this: *mut gtk_sys::GtkRange,
408 step: gtk_sys::GtkScrollType,
409 f: glib_sys::gpointer,
410 ) where
411 P: IsA<Range>,
412 {
413 let f: &F = &*(f as *const F);
414 f(
415 &Range::from_glib_borrow(this).unsafe_cast(),
416 from_glib(step),
417 )
418 }
419 unsafe {
420 let f: Box_<F> = Box_::new(f);
421 connect_raw(
422 self.as_ptr() as *mut _,
423 b"move-slider\0".as_ptr() as *const _,
424 Some(transmute(move_slider_trampoline::<Self, F> as usize)),
425 Box_::into_raw(f),
426 )
427 }
428 }
429
430 fn emit_move_slider(&self, step: ScrollType) {
431 let _ = unsafe {
432 glib::Object::from_glib_borrow(self.to_glib_none().0 as *mut gobject_sys::GObject)
433 .emit("move-slider", &[&step])
434 .unwrap()
435 };
436 }
437
438 fn connect_value_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
439 unsafe extern "C" fn value_changed_trampoline<P, F: Fn(&P) + 'static>(
440 this: *mut gtk_sys::GtkRange,
441 f: glib_sys::gpointer,
442 ) where
443 P: IsA<Range>,
444 {
445 let f: &F = &*(f as *const F);
446 f(&Range::from_glib_borrow(this).unsafe_cast())
447 }
448 unsafe {
449 let f: Box_<F> = Box_::new(f);
450 connect_raw(
451 self.as_ptr() as *mut _,
452 b"value-changed\0".as_ptr() as *const _,
453 Some(transmute(value_changed_trampoline::<Self, F> as usize)),
454 Box_::into_raw(f),
455 )
456 }
457 }
458
459 fn connect_property_adjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
460 unsafe extern "C" fn notify_adjustment_trampoline<P, F: Fn(&P) + 'static>(
461 this: *mut gtk_sys::GtkRange,
462 _param_spec: glib_sys::gpointer,
463 f: glib_sys::gpointer,
464 ) where
465 P: IsA<Range>,
466 {
467 let f: &F = &*(f as *const F);
468 f(&Range::from_glib_borrow(this).unsafe_cast())
469 }
470 unsafe {
471 let f: Box_<F> = Box_::new(f);
472 connect_raw(
473 self.as_ptr() as *mut _,
474 b"notify::adjustment\0".as_ptr() as *const _,
475 Some(transmute(notify_adjustment_trampoline::<Self, F> as usize)),
476 Box_::into_raw(f),
477 )
478 }
479 }
480
481 fn connect_property_fill_level_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
482 unsafe extern "C" fn notify_fill_level_trampoline<P, F: Fn(&P) + 'static>(
483 this: *mut gtk_sys::GtkRange,
484 _param_spec: glib_sys::gpointer,
485 f: glib_sys::gpointer,
486 ) where
487 P: IsA<Range>,
488 {
489 let f: &F = &*(f as *const F);
490 f(&Range::from_glib_borrow(this).unsafe_cast())
491 }
492 unsafe {
493 let f: Box_<F> = Box_::new(f);
494 connect_raw(
495 self.as_ptr() as *mut _,
496 b"notify::fill-level\0".as_ptr() as *const _,
497 Some(transmute(notify_fill_level_trampoline::<Self, F> as usize)),
498 Box_::into_raw(f),
499 )
500 }
501 }
502
503 fn connect_property_inverted_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
504 unsafe extern "C" fn notify_inverted_trampoline<P, F: Fn(&P) + 'static>(
505 this: *mut gtk_sys::GtkRange,
506 _param_spec: glib_sys::gpointer,
507 f: glib_sys::gpointer,
508 ) where
509 P: IsA<Range>,
510 {
511 let f: &F = &*(f as *const F);
512 f(&Range::from_glib_borrow(this).unsafe_cast())
513 }
514 unsafe {
515 let f: Box_<F> = Box_::new(f);
516 connect_raw(
517 self.as_ptr() as *mut _,
518 b"notify::inverted\0".as_ptr() as *const _,
519 Some(transmute(notify_inverted_trampoline::<Self, F> as usize)),
520 Box_::into_raw(f),
521 )
522 }
523 }
524
525 fn connect_property_lower_stepper_sensitivity_notify<F: Fn(&Self) + 'static>(
526 &self,
527 f: F,
528 ) -> SignalHandlerId {
529 unsafe extern "C" fn notify_lower_stepper_sensitivity_trampoline<P, F: Fn(&P) + 'static>(
530 this: *mut gtk_sys::GtkRange,
531 _param_spec: glib_sys::gpointer,
532 f: glib_sys::gpointer,
533 ) where
534 P: IsA<Range>,
535 {
536 let f: &F = &*(f as *const F);
537 f(&Range::from_glib_borrow(this).unsafe_cast())
538 }
539 unsafe {
540 let f: Box_<F> = Box_::new(f);
541 connect_raw(
542 self.as_ptr() as *mut _,
543 b"notify::lower-stepper-sensitivity\0".as_ptr() as *const _,
544 Some(transmute(
545 notify_lower_stepper_sensitivity_trampoline::<Self, F> as usize,
546 )),
547 Box_::into_raw(f),
548 )
549 }
550 }
551
552 fn connect_property_restrict_to_fill_level_notify<F: Fn(&Self) + 'static>(
553 &self,
554 f: F,
555 ) -> SignalHandlerId {
556 unsafe extern "C" fn notify_restrict_to_fill_level_trampoline<P, F: Fn(&P) + 'static>(
557 this: *mut gtk_sys::GtkRange,
558 _param_spec: glib_sys::gpointer,
559 f: glib_sys::gpointer,
560 ) where
561 P: IsA<Range>,
562 {
563 let f: &F = &*(f as *const F);
564 f(&Range::from_glib_borrow(this).unsafe_cast())
565 }
566 unsafe {
567 let f: Box_<F> = Box_::new(f);
568 connect_raw(
569 self.as_ptr() as *mut _,
570 b"notify::restrict-to-fill-level\0".as_ptr() as *const _,
571 Some(transmute(
572 notify_restrict_to_fill_level_trampoline::<Self, F> as usize,
573 )),
574 Box_::into_raw(f),
575 )
576 }
577 }
578
579 fn connect_property_round_digits_notify<F: Fn(&Self) + 'static>(
580 &self,
581 f: F,
582 ) -> SignalHandlerId {
583 unsafe extern "C" fn notify_round_digits_trampoline<P, F: Fn(&P) + 'static>(
584 this: *mut gtk_sys::GtkRange,
585 _param_spec: glib_sys::gpointer,
586 f: glib_sys::gpointer,
587 ) where
588 P: IsA<Range>,
589 {
590 let f: &F = &*(f as *const F);
591 f(&Range::from_glib_borrow(this).unsafe_cast())
592 }
593 unsafe {
594 let f: Box_<F> = Box_::new(f);
595 connect_raw(
596 self.as_ptr() as *mut _,
597 b"notify::round-digits\0".as_ptr() as *const _,
598 Some(transmute(
599 notify_round_digits_trampoline::<Self, F> as usize,
600 )),
601 Box_::into_raw(f),
602 )
603 }
604 }
605
606 fn connect_property_show_fill_level_notify<F: Fn(&Self) + 'static>(
607 &self,
608 f: F,
609 ) -> SignalHandlerId {
610 unsafe extern "C" fn notify_show_fill_level_trampoline<P, F: Fn(&P) + 'static>(
611 this: *mut gtk_sys::GtkRange,
612 _param_spec: glib_sys::gpointer,
613 f: glib_sys::gpointer,
614 ) where
615 P: IsA<Range>,
616 {
617 let f: &F = &*(f as *const F);
618 f(&Range::from_glib_borrow(this).unsafe_cast())
619 }
620 unsafe {
621 let f: Box_<F> = Box_::new(f);
622 connect_raw(
623 self.as_ptr() as *mut _,
624 b"notify::show-fill-level\0".as_ptr() as *const _,
625 Some(transmute(
626 notify_show_fill_level_trampoline::<Self, F> as usize,
627 )),
628 Box_::into_raw(f),
629 )
630 }
631 }
632
633 fn connect_property_upper_stepper_sensitivity_notify<F: Fn(&Self) + 'static>(
634 &self,
635 f: F,
636 ) -> SignalHandlerId {
637 unsafe extern "C" fn notify_upper_stepper_sensitivity_trampoline<P, F: Fn(&P) + 'static>(
638 this: *mut gtk_sys::GtkRange,
639 _param_spec: glib_sys::gpointer,
640 f: glib_sys::gpointer,
641 ) where
642 P: IsA<Range>,
643 {
644 let f: &F = &*(f as *const F);
645 f(&Range::from_glib_borrow(this).unsafe_cast())
646 }
647 unsafe {
648 let f: Box_<F> = Box_::new(f);
649 connect_raw(
650 self.as_ptr() as *mut _,
651 b"notify::upper-stepper-sensitivity\0".as_ptr() as *const _,
652 Some(transmute(
653 notify_upper_stepper_sensitivity_trampoline::<Self, F> as usize,
654 )),
655 Box_::into_raw(f),
656 )
657 }
658 }
659}
660
661impl fmt::Display for Range {
662 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
663 write!(f, "Range")
664 }
665}