1#[cfg(feature = "v4_10")]
6#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
7use crate::AccessibleRange;
8use crate::{
9 ffi, Accessible, Adjustment, Buildable, ConstraintTarget, Orientable, ScrollType, Widget,
10};
11use glib::{
12 object::ObjectType as _,
13 prelude::*,
14 signal::{connect_raw, SignalHandlerId},
15 translate::*,
16};
17use std::boxed::Box as Box_;
18
19#[cfg(feature = "v4_10")]
20#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
21glib::wrapper! {
22 #[doc(alias = "GtkRange")]
23 pub struct Range(Object<ffi::GtkRange, ffi::GtkRangeClass>) @extends Widget, @implements Accessible, Buildable, ConstraintTarget, AccessibleRange, Orientable;
24
25 match fn {
26 type_ => || ffi::gtk_range_get_type(),
27 }
28}
29
30#[cfg(not(any(feature = "v4_10")))]
31glib::wrapper! {
32 #[doc(alias = "GtkRange")]
33 pub struct Range(Object<ffi::GtkRange, ffi::GtkRangeClass>) @extends Widget, @implements Accessible, Buildable, ConstraintTarget, Orientable;
34
35 match fn {
36 type_ => || ffi::gtk_range_get_type(),
37 }
38}
39
40impl Range {
41 pub const NONE: Option<&'static Range> = None;
42}
43
44pub trait RangeExt: IsA<Range> + 'static {
45 #[doc(alias = "gtk_range_get_adjustment")]
46 #[doc(alias = "get_adjustment")]
47 fn adjustment(&self) -> Adjustment {
48 unsafe {
49 from_glib_none(ffi::gtk_range_get_adjustment(
50 self.as_ref().to_glib_none().0,
51 ))
52 }
53 }
54
55 #[doc(alias = "gtk_range_get_fill_level")]
56 #[doc(alias = "get_fill_level")]
57 #[doc(alias = "fill-level")]
58 fn fill_level(&self) -> f64 {
59 unsafe { ffi::gtk_range_get_fill_level(self.as_ref().to_glib_none().0) }
60 }
61
62 #[doc(alias = "gtk_range_get_flippable")]
63 #[doc(alias = "get_flippable")]
64 fn is_flippable(&self) -> bool {
65 unsafe { from_glib(ffi::gtk_range_get_flippable(self.as_ref().to_glib_none().0)) }
66 }
67
68 #[doc(alias = "gtk_range_get_inverted")]
69 #[doc(alias = "get_inverted")]
70 #[doc(alias = "inverted")]
71 fn is_inverted(&self) -> bool {
72 unsafe { from_glib(ffi::gtk_range_get_inverted(self.as_ref().to_glib_none().0)) }
73 }
74
75 #[doc(alias = "gtk_range_get_range_rect")]
76 #[doc(alias = "get_range_rect")]
77 fn range_rect(&self) -> gdk::Rectangle {
78 unsafe {
79 let mut range_rect = gdk::Rectangle::uninitialized();
80 ffi::gtk_range_get_range_rect(
81 self.as_ref().to_glib_none().0,
82 range_rect.to_glib_none_mut().0,
83 );
84 range_rect
85 }
86 }
87
88 #[doc(alias = "gtk_range_get_restrict_to_fill_level")]
89 #[doc(alias = "get_restrict_to_fill_level")]
90 #[doc(alias = "restrict-to-fill-level")]
91 fn restricts_to_fill_level(&self) -> bool {
92 unsafe {
93 from_glib(ffi::gtk_range_get_restrict_to_fill_level(
94 self.as_ref().to_glib_none().0,
95 ))
96 }
97 }
98
99 #[doc(alias = "gtk_range_get_round_digits")]
100 #[doc(alias = "get_round_digits")]
101 #[doc(alias = "round-digits")]
102 fn round_digits(&self) -> i32 {
103 unsafe { ffi::gtk_range_get_round_digits(self.as_ref().to_glib_none().0) }
104 }
105
106 #[doc(alias = "gtk_range_get_show_fill_level")]
107 #[doc(alias = "get_show_fill_level")]
108 #[doc(alias = "show-fill-level")]
109 fn shows_fill_level(&self) -> bool {
110 unsafe {
111 from_glib(ffi::gtk_range_get_show_fill_level(
112 self.as_ref().to_glib_none().0,
113 ))
114 }
115 }
116
117 #[doc(alias = "gtk_range_get_slider_range")]
118 #[doc(alias = "get_slider_range")]
119 fn slider_range(&self) -> (i32, i32) {
120 unsafe {
121 let mut slider_start = std::mem::MaybeUninit::uninit();
122 let mut slider_end = std::mem::MaybeUninit::uninit();
123 ffi::gtk_range_get_slider_range(
124 self.as_ref().to_glib_none().0,
125 slider_start.as_mut_ptr(),
126 slider_end.as_mut_ptr(),
127 );
128 (slider_start.assume_init(), slider_end.assume_init())
129 }
130 }
131
132 #[doc(alias = "gtk_range_get_slider_size_fixed")]
133 #[doc(alias = "get_slider_size_fixed")]
134 fn is_slider_size_fixed(&self) -> bool {
135 unsafe {
136 from_glib(ffi::gtk_range_get_slider_size_fixed(
137 self.as_ref().to_glib_none().0,
138 ))
139 }
140 }
141
142 #[doc(alias = "gtk_range_get_value")]
143 #[doc(alias = "get_value")]
144 fn value(&self) -> f64 {
145 unsafe { ffi::gtk_range_get_value(self.as_ref().to_glib_none().0) }
146 }
147
148 #[doc(alias = "gtk_range_set_adjustment")]
149 #[doc(alias = "adjustment")]
150 fn set_adjustment(&self, adjustment: &impl IsA<Adjustment>) {
151 unsafe {
152 ffi::gtk_range_set_adjustment(
153 self.as_ref().to_glib_none().0,
154 adjustment.as_ref().to_glib_none().0,
155 );
156 }
157 }
158
159 #[doc(alias = "gtk_range_set_fill_level")]
160 #[doc(alias = "fill-level")]
161 fn set_fill_level(&self, fill_level: f64) {
162 unsafe {
163 ffi::gtk_range_set_fill_level(self.as_ref().to_glib_none().0, fill_level);
164 }
165 }
166
167 #[doc(alias = "gtk_range_set_flippable")]
168 fn set_flippable(&self, flippable: bool) {
169 unsafe {
170 ffi::gtk_range_set_flippable(self.as_ref().to_glib_none().0, flippable.into_glib());
171 }
172 }
173
174 #[doc(alias = "gtk_range_set_increments")]
175 fn set_increments(&self, step: f64, page: f64) {
176 unsafe {
177 ffi::gtk_range_set_increments(self.as_ref().to_glib_none().0, step, page);
178 }
179 }
180
181 #[doc(alias = "gtk_range_set_inverted")]
182 #[doc(alias = "inverted")]
183 fn set_inverted(&self, setting: bool) {
184 unsafe {
185 ffi::gtk_range_set_inverted(self.as_ref().to_glib_none().0, setting.into_glib());
186 }
187 }
188
189 #[doc(alias = "gtk_range_set_range")]
190 fn set_range(&self, min: f64, max: f64) {
191 unsafe {
192 ffi::gtk_range_set_range(self.as_ref().to_glib_none().0, min, max);
193 }
194 }
195
196 #[doc(alias = "gtk_range_set_restrict_to_fill_level")]
197 #[doc(alias = "restrict-to-fill-level")]
198 fn set_restrict_to_fill_level(&self, restrict_to_fill_level: bool) {
199 unsafe {
200 ffi::gtk_range_set_restrict_to_fill_level(
201 self.as_ref().to_glib_none().0,
202 restrict_to_fill_level.into_glib(),
203 );
204 }
205 }
206
207 #[doc(alias = "gtk_range_set_round_digits")]
208 #[doc(alias = "round-digits")]
209 fn set_round_digits(&self, round_digits: i32) {
210 unsafe {
211 ffi::gtk_range_set_round_digits(self.as_ref().to_glib_none().0, round_digits);
212 }
213 }
214
215 #[doc(alias = "gtk_range_set_show_fill_level")]
216 #[doc(alias = "show-fill-level")]
217 fn set_show_fill_level(&self, show_fill_level: bool) {
218 unsafe {
219 ffi::gtk_range_set_show_fill_level(
220 self.as_ref().to_glib_none().0,
221 show_fill_level.into_glib(),
222 );
223 }
224 }
225
226 #[doc(alias = "gtk_range_set_slider_size_fixed")]
227 fn set_slider_size_fixed(&self, size_fixed: bool) {
228 unsafe {
229 ffi::gtk_range_set_slider_size_fixed(
230 self.as_ref().to_glib_none().0,
231 size_fixed.into_glib(),
232 );
233 }
234 }
235
236 #[doc(alias = "gtk_range_set_value")]
237 fn set_value(&self, value: f64) {
238 unsafe {
239 ffi::gtk_range_set_value(self.as_ref().to_glib_none().0, value);
240 }
241 }
242
243 #[doc(alias = "adjust-bounds")]
244 fn connect_adjust_bounds<F: Fn(&Self, f64) + 'static>(&self, f: F) -> SignalHandlerId {
245 unsafe extern "C" fn adjust_bounds_trampoline<P: IsA<Range>, F: Fn(&P, f64) + 'static>(
246 this: *mut ffi::GtkRange,
247 value: std::ffi::c_double,
248 f: glib::ffi::gpointer,
249 ) {
250 let f: &F = &*(f as *const F);
251 f(Range::from_glib_borrow(this).unsafe_cast_ref(), value)
252 }
253 unsafe {
254 let f: Box_<F> = Box_::new(f);
255 connect_raw(
256 self.as_ptr() as *mut _,
257 c"adjust-bounds".as_ptr() as *const _,
258 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
259 adjust_bounds_trampoline::<Self, F> as *const (),
260 )),
261 Box_::into_raw(f),
262 )
263 }
264 }
265
266 #[doc(alias = "change-value")]
267 fn connect_change_value<F: Fn(&Self, ScrollType, f64) -> glib::Propagation + 'static>(
268 &self,
269 f: F,
270 ) -> SignalHandlerId {
271 unsafe extern "C" fn change_value_trampoline<
272 P: IsA<Range>,
273 F: Fn(&P, ScrollType, f64) -> glib::Propagation + 'static,
274 >(
275 this: *mut ffi::GtkRange,
276 scroll: ffi::GtkScrollType,
277 value: std::ffi::c_double,
278 f: glib::ffi::gpointer,
279 ) -> glib::ffi::gboolean {
280 let f: &F = &*(f as *const F);
281 f(
282 Range::from_glib_borrow(this).unsafe_cast_ref(),
283 from_glib(scroll),
284 value,
285 )
286 .into_glib()
287 }
288 unsafe {
289 let f: Box_<F> = Box_::new(f);
290 connect_raw(
291 self.as_ptr() as *mut _,
292 c"change-value".as_ptr() as *const _,
293 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
294 change_value_trampoline::<Self, F> as *const (),
295 )),
296 Box_::into_raw(f),
297 )
298 }
299 }
300
301 #[doc(alias = "move-slider")]
302 fn connect_move_slider<F: Fn(&Self, ScrollType) + 'static>(&self, f: F) -> SignalHandlerId {
303 unsafe extern "C" fn move_slider_trampoline<
304 P: IsA<Range>,
305 F: Fn(&P, ScrollType) + 'static,
306 >(
307 this: *mut ffi::GtkRange,
308 step: ffi::GtkScrollType,
309 f: glib::ffi::gpointer,
310 ) {
311 let f: &F = &*(f as *const F);
312 f(
313 Range::from_glib_borrow(this).unsafe_cast_ref(),
314 from_glib(step),
315 )
316 }
317 unsafe {
318 let f: Box_<F> = Box_::new(f);
319 connect_raw(
320 self.as_ptr() as *mut _,
321 c"move-slider".as_ptr() as *const _,
322 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
323 move_slider_trampoline::<Self, F> as *const (),
324 )),
325 Box_::into_raw(f),
326 )
327 }
328 }
329
330 fn emit_move_slider(&self, step: ScrollType) {
331 self.emit_by_name::<()>("move-slider", &[&step]);
332 }
333
334 #[doc(alias = "value-changed")]
335 fn connect_value_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
336 unsafe extern "C" fn value_changed_trampoline<P: IsA<Range>, F: Fn(&P) + 'static>(
337 this: *mut ffi::GtkRange,
338 f: glib::ffi::gpointer,
339 ) {
340 let f: &F = &*(f as *const F);
341 f(Range::from_glib_borrow(this).unsafe_cast_ref())
342 }
343 unsafe {
344 let f: Box_<F> = Box_::new(f);
345 connect_raw(
346 self.as_ptr() as *mut _,
347 c"value-changed".as_ptr() as *const _,
348 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
349 value_changed_trampoline::<Self, F> as *const (),
350 )),
351 Box_::into_raw(f),
352 )
353 }
354 }
355
356 #[doc(alias = "adjustment")]
357 fn connect_adjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
358 unsafe extern "C" fn notify_adjustment_trampoline<P: IsA<Range>, F: Fn(&P) + 'static>(
359 this: *mut ffi::GtkRange,
360 _param_spec: glib::ffi::gpointer,
361 f: glib::ffi::gpointer,
362 ) {
363 let f: &F = &*(f as *const F);
364 f(Range::from_glib_borrow(this).unsafe_cast_ref())
365 }
366 unsafe {
367 let f: Box_<F> = Box_::new(f);
368 connect_raw(
369 self.as_ptr() as *mut _,
370 c"notify::adjustment".as_ptr() as *const _,
371 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
372 notify_adjustment_trampoline::<Self, F> as *const (),
373 )),
374 Box_::into_raw(f),
375 )
376 }
377 }
378
379 #[doc(alias = "fill-level")]
380 fn connect_fill_level_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
381 unsafe extern "C" fn notify_fill_level_trampoline<P: IsA<Range>, F: Fn(&P) + 'static>(
382 this: *mut ffi::GtkRange,
383 _param_spec: glib::ffi::gpointer,
384 f: glib::ffi::gpointer,
385 ) {
386 let f: &F = &*(f as *const F);
387 f(Range::from_glib_borrow(this).unsafe_cast_ref())
388 }
389 unsafe {
390 let f: Box_<F> = Box_::new(f);
391 connect_raw(
392 self.as_ptr() as *mut _,
393 c"notify::fill-level".as_ptr() as *const _,
394 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
395 notify_fill_level_trampoline::<Self, F> as *const (),
396 )),
397 Box_::into_raw(f),
398 )
399 }
400 }
401
402 #[doc(alias = "inverted")]
403 fn connect_inverted_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
404 unsafe extern "C" fn notify_inverted_trampoline<P: IsA<Range>, F: Fn(&P) + 'static>(
405 this: *mut ffi::GtkRange,
406 _param_spec: glib::ffi::gpointer,
407 f: glib::ffi::gpointer,
408 ) {
409 let f: &F = &*(f as *const F);
410 f(Range::from_glib_borrow(this).unsafe_cast_ref())
411 }
412 unsafe {
413 let f: Box_<F> = Box_::new(f);
414 connect_raw(
415 self.as_ptr() as *mut _,
416 c"notify::inverted".as_ptr() as *const _,
417 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
418 notify_inverted_trampoline::<Self, F> as *const (),
419 )),
420 Box_::into_raw(f),
421 )
422 }
423 }
424
425 #[doc(alias = "restrict-to-fill-level")]
426 fn connect_restrict_to_fill_level_notify<F: Fn(&Self) + 'static>(
427 &self,
428 f: F,
429 ) -> SignalHandlerId {
430 unsafe extern "C" fn notify_restrict_to_fill_level_trampoline<
431 P: IsA<Range>,
432 F: Fn(&P) + 'static,
433 >(
434 this: *mut ffi::GtkRange,
435 _param_spec: glib::ffi::gpointer,
436 f: glib::ffi::gpointer,
437 ) {
438 let f: &F = &*(f as *const F);
439 f(Range::from_glib_borrow(this).unsafe_cast_ref())
440 }
441 unsafe {
442 let f: Box_<F> = Box_::new(f);
443 connect_raw(
444 self.as_ptr() as *mut _,
445 c"notify::restrict-to-fill-level".as_ptr() as *const _,
446 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
447 notify_restrict_to_fill_level_trampoline::<Self, F> as *const (),
448 )),
449 Box_::into_raw(f),
450 )
451 }
452 }
453
454 #[doc(alias = "round-digits")]
455 fn connect_round_digits_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
456 unsafe extern "C" fn notify_round_digits_trampoline<P: IsA<Range>, F: Fn(&P) + 'static>(
457 this: *mut ffi::GtkRange,
458 _param_spec: glib::ffi::gpointer,
459 f: glib::ffi::gpointer,
460 ) {
461 let f: &F = &*(f as *const F);
462 f(Range::from_glib_borrow(this).unsafe_cast_ref())
463 }
464 unsafe {
465 let f: Box_<F> = Box_::new(f);
466 connect_raw(
467 self.as_ptr() as *mut _,
468 c"notify::round-digits".as_ptr() as *const _,
469 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
470 notify_round_digits_trampoline::<Self, F> as *const (),
471 )),
472 Box_::into_raw(f),
473 )
474 }
475 }
476
477 #[doc(alias = "show-fill-level")]
478 fn connect_show_fill_level_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
479 unsafe extern "C" fn notify_show_fill_level_trampoline<
480 P: IsA<Range>,
481 F: Fn(&P) + 'static,
482 >(
483 this: *mut ffi::GtkRange,
484 _param_spec: glib::ffi::gpointer,
485 f: glib::ffi::gpointer,
486 ) {
487 let f: &F = &*(f as *const F);
488 f(Range::from_glib_borrow(this).unsafe_cast_ref())
489 }
490 unsafe {
491 let f: Box_<F> = Box_::new(f);
492 connect_raw(
493 self.as_ptr() as *mut _,
494 c"notify::show-fill-level".as_ptr() as *const _,
495 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
496 notify_show_fill_level_trampoline::<Self, F> as *const (),
497 )),
498 Box_::into_raw(f),
499 )
500 }
501 }
502}
503
504impl<O: IsA<Range>> RangeExt for O {}