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 
5 use crate::EventController;
6 use crate::EventSequenceState;
7 use glib::object::Cast;
8 use glib::object::IsA;
9 use glib::signal::connect_raw;
10 use glib::signal::SignalHandlerId;
11 use glib::translate::*;
12 use glib::StaticType;
13 use std::boxed::Box as Box_;
14 use std::fmt;
15 use std::mem;
16 use std::mem::transmute;
17 
18 glib::wrapper! {
19     #[doc(alias = "GtkGesture")]
20     pub struct Gesture(Object<ffi::GtkGesture, ffi::GtkGestureClass>) @extends EventController;
21 
22     match fn {
23         type_ => || ffi::gtk_gesture_get_type(),
24     }
25 }
26 
27 pub const NONE_GESTURE: Option<&Gesture> = None;
28 
29 pub trait GestureExt: 'static {
30     #[doc(alias = "gtk_gesture_get_bounding_box")]
31     #[doc(alias = "get_bounding_box")]
bounding_box(&self) -> Option<gdk::Rectangle>32     fn bounding_box(&self) -> Option<gdk::Rectangle>;
33 
34     #[doc(alias = "gtk_gesture_get_bounding_box_center")]
35     #[doc(alias = "get_bounding_box_center")]
bounding_box_center(&self) -> Option<(f64, f64)>36     fn bounding_box_center(&self) -> Option<(f64, f64)>;
37 
38     #[doc(alias = "gtk_gesture_get_device")]
39     #[doc(alias = "get_device")]
device(&self) -> Option<gdk::Device>40     fn device(&self) -> Option<gdk::Device>;
41 
42     #[doc(alias = "gtk_gesture_get_group")]
43     #[doc(alias = "get_group")]
group(&self) -> Vec<Gesture>44     fn group(&self) -> Vec<Gesture>;
45 
46     #[doc(alias = "gtk_gesture_get_last_event")]
47     #[doc(alias = "get_last_event")]
last_event(&self, sequence: Option<&gdk::EventSequence>) -> Option<gdk::Event>48     fn last_event(&self, sequence: Option<&gdk::EventSequence>) -> Option<gdk::Event>;
49 
50     #[doc(alias = "gtk_gesture_get_last_updated_sequence")]
51     #[doc(alias = "get_last_updated_sequence")]
last_updated_sequence(&self) -> Option<gdk::EventSequence>52     fn last_updated_sequence(&self) -> Option<gdk::EventSequence>;
53 
54     #[doc(alias = "gtk_gesture_get_point")]
55     #[doc(alias = "get_point")]
point(&self, sequence: Option<&gdk::EventSequence>) -> Option<(f64, f64)>56     fn point(&self, sequence: Option<&gdk::EventSequence>) -> Option<(f64, f64)>;
57 
58     #[doc(alias = "gtk_gesture_get_sequence_state")]
59     #[doc(alias = "get_sequence_state")]
sequence_state(&self, sequence: &gdk::EventSequence) -> EventSequenceState60     fn sequence_state(&self, sequence: &gdk::EventSequence) -> EventSequenceState;
61 
62     #[doc(alias = "gtk_gesture_get_sequences")]
63     #[doc(alias = "get_sequences")]
sequences(&self) -> Vec<gdk::EventSequence>64     fn sequences(&self) -> Vec<gdk::EventSequence>;
65 
66     #[doc(alias = "gtk_gesture_get_window")]
67     #[doc(alias = "get_window")]
window(&self) -> Option<gdk::Window>68     fn window(&self) -> Option<gdk::Window>;
69 
70     #[doc(alias = "gtk_gesture_group")]
71     #[doc(alias = "group")]
group_with<P: IsA<Gesture>>(&self, gesture: &P)72     fn group_with<P: IsA<Gesture>>(&self, gesture: &P);
73 
74     #[doc(alias = "gtk_gesture_handles_sequence")]
handles_sequence(&self, sequence: Option<&gdk::EventSequence>) -> bool75     fn handles_sequence(&self, sequence: Option<&gdk::EventSequence>) -> bool;
76 
77     #[doc(alias = "gtk_gesture_is_active")]
is_active(&self) -> bool78     fn is_active(&self) -> bool;
79 
80     #[doc(alias = "gtk_gesture_is_grouped_with")]
is_grouped_with<P: IsA<Gesture>>(&self, other: &P) -> bool81     fn is_grouped_with<P: IsA<Gesture>>(&self, other: &P) -> bool;
82 
83     #[doc(alias = "gtk_gesture_is_recognized")]
is_recognized(&self) -> bool84     fn is_recognized(&self) -> bool;
85 
86     #[doc(alias = "gtk_gesture_set_sequence_state")]
set_sequence_state(&self, sequence: &gdk::EventSequence, state: EventSequenceState) -> bool87     fn set_sequence_state(&self, sequence: &gdk::EventSequence, state: EventSequenceState) -> bool;
88 
89     #[doc(alias = "gtk_gesture_set_state")]
set_state(&self, state: EventSequenceState) -> bool90     fn set_state(&self, state: EventSequenceState) -> bool;
91 
92     #[doc(alias = "gtk_gesture_set_window")]
set_window(&self, window: Option<&gdk::Window>)93     fn set_window(&self, window: Option<&gdk::Window>);
94 
95     #[doc(alias = "gtk_gesture_ungroup")]
ungroup(&self)96     fn ungroup(&self);
97 
98     #[doc(alias = "n-points")]
n_points(&self) -> u3299     fn n_points(&self) -> u32;
100 
101     #[doc(alias = "begin")]
connect_begin<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId102     fn connect_begin<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
103         &self,
104         f: F,
105     ) -> SignalHandlerId;
106 
107     #[doc(alias = "cancel")]
connect_cancel<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId108     fn connect_cancel<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
109         &self,
110         f: F,
111     ) -> SignalHandlerId;
112 
113     #[doc(alias = "end")]
connect_end<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId114     fn connect_end<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
115         &self,
116         f: F,
117     ) -> SignalHandlerId;
118 
119     #[doc(alias = "sequence-state-changed")]
connect_sequence_state_changed< F: Fn(&Self, Option<&gdk::EventSequence>, EventSequenceState) + 'static, >( &self, f: F, ) -> SignalHandlerId120     fn connect_sequence_state_changed<
121         F: Fn(&Self, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
122     >(
123         &self,
124         f: F,
125     ) -> SignalHandlerId;
126 
127     #[doc(alias = "update")]
connect_update<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId128     fn connect_update<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
129         &self,
130         f: F,
131     ) -> SignalHandlerId;
132 
133     #[doc(alias = "window")]
connect_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId134     fn connect_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
135 }
136 
137 impl<O: IsA<Gesture>> GestureExt for O {
bounding_box(&self) -> Option<gdk::Rectangle>138     fn bounding_box(&self) -> Option<gdk::Rectangle> {
139         unsafe {
140             let mut rect = gdk::Rectangle::uninitialized();
141             let ret = from_glib(ffi::gtk_gesture_get_bounding_box(
142                 self.as_ref().to_glib_none().0,
143                 rect.to_glib_none_mut().0,
144             ));
145             if ret {
146                 Some(rect)
147             } else {
148                 None
149             }
150         }
151     }
152 
bounding_box_center(&self) -> Option<(f64, f64)>153     fn bounding_box_center(&self) -> Option<(f64, f64)> {
154         unsafe {
155             let mut x = mem::MaybeUninit::uninit();
156             let mut y = mem::MaybeUninit::uninit();
157             let ret = from_glib(ffi::gtk_gesture_get_bounding_box_center(
158                 self.as_ref().to_glib_none().0,
159                 x.as_mut_ptr(),
160                 y.as_mut_ptr(),
161             ));
162             let x = x.assume_init();
163             let y = y.assume_init();
164             if ret {
165                 Some((x, y))
166             } else {
167                 None
168             }
169         }
170     }
171 
device(&self) -> Option<gdk::Device>172     fn device(&self) -> Option<gdk::Device> {
173         unsafe { from_glib_none(ffi::gtk_gesture_get_device(self.as_ref().to_glib_none().0)) }
174     }
175 
group(&self) -> Vec<Gesture>176     fn group(&self) -> Vec<Gesture> {
177         unsafe {
178             FromGlibPtrContainer::from_glib_container(ffi::gtk_gesture_get_group(
179                 self.as_ref().to_glib_none().0,
180             ))
181         }
182     }
183 
last_event(&self, sequence: Option<&gdk::EventSequence>) -> Option<gdk::Event>184     fn last_event(&self, sequence: Option<&gdk::EventSequence>) -> Option<gdk::Event> {
185         unsafe {
186             from_glib_none(ffi::gtk_gesture_get_last_event(
187                 self.as_ref().to_glib_none().0,
188                 mut_override(sequence.to_glib_none().0),
189             ))
190         }
191     }
192 
last_updated_sequence(&self) -> Option<gdk::EventSequence>193     fn last_updated_sequence(&self) -> Option<gdk::EventSequence> {
194         unsafe {
195             from_glib_none(ffi::gtk_gesture_get_last_updated_sequence(
196                 self.as_ref().to_glib_none().0,
197             ))
198         }
199     }
200 
point(&self, sequence: Option<&gdk::EventSequence>) -> Option<(f64, f64)>201     fn point(&self, sequence: Option<&gdk::EventSequence>) -> Option<(f64, f64)> {
202         unsafe {
203             let mut x = mem::MaybeUninit::uninit();
204             let mut y = mem::MaybeUninit::uninit();
205             let ret = from_glib(ffi::gtk_gesture_get_point(
206                 self.as_ref().to_glib_none().0,
207                 mut_override(sequence.to_glib_none().0),
208                 x.as_mut_ptr(),
209                 y.as_mut_ptr(),
210             ));
211             let x = x.assume_init();
212             let y = y.assume_init();
213             if ret {
214                 Some((x, y))
215             } else {
216                 None
217             }
218         }
219     }
220 
sequence_state(&self, sequence: &gdk::EventSequence) -> EventSequenceState221     fn sequence_state(&self, sequence: &gdk::EventSequence) -> EventSequenceState {
222         unsafe {
223             from_glib(ffi::gtk_gesture_get_sequence_state(
224                 self.as_ref().to_glib_none().0,
225                 mut_override(sequence.to_glib_none().0),
226             ))
227         }
228     }
229 
sequences(&self) -> Vec<gdk::EventSequence>230     fn sequences(&self) -> Vec<gdk::EventSequence> {
231         unsafe {
232             FromGlibPtrContainer::from_glib_container(ffi::gtk_gesture_get_sequences(
233                 self.as_ref().to_glib_none().0,
234             ))
235         }
236     }
237 
window(&self) -> Option<gdk::Window>238     fn window(&self) -> Option<gdk::Window> {
239         unsafe { from_glib_none(ffi::gtk_gesture_get_window(self.as_ref().to_glib_none().0)) }
240     }
241 
group_with<P: IsA<Gesture>>(&self, gesture: &P)242     fn group_with<P: IsA<Gesture>>(&self, gesture: &P) {
243         unsafe {
244             ffi::gtk_gesture_group(
245                 self.as_ref().to_glib_none().0,
246                 gesture.as_ref().to_glib_none().0,
247             );
248         }
249     }
250 
handles_sequence(&self, sequence: Option<&gdk::EventSequence>) -> bool251     fn handles_sequence(&self, sequence: Option<&gdk::EventSequence>) -> bool {
252         unsafe {
253             from_glib(ffi::gtk_gesture_handles_sequence(
254                 self.as_ref().to_glib_none().0,
255                 mut_override(sequence.to_glib_none().0),
256             ))
257         }
258     }
259 
is_active(&self) -> bool260     fn is_active(&self) -> bool {
261         unsafe { from_glib(ffi::gtk_gesture_is_active(self.as_ref().to_glib_none().0)) }
262     }
263 
is_grouped_with<P: IsA<Gesture>>(&self, other: &P) -> bool264     fn is_grouped_with<P: IsA<Gesture>>(&self, other: &P) -> bool {
265         unsafe {
266             from_glib(ffi::gtk_gesture_is_grouped_with(
267                 self.as_ref().to_glib_none().0,
268                 other.as_ref().to_glib_none().0,
269             ))
270         }
271     }
272 
is_recognized(&self) -> bool273     fn is_recognized(&self) -> bool {
274         unsafe {
275             from_glib(ffi::gtk_gesture_is_recognized(
276                 self.as_ref().to_glib_none().0,
277             ))
278         }
279     }
280 
set_sequence_state(&self, sequence: &gdk::EventSequence, state: EventSequenceState) -> bool281     fn set_sequence_state(&self, sequence: &gdk::EventSequence, state: EventSequenceState) -> bool {
282         unsafe {
283             from_glib(ffi::gtk_gesture_set_sequence_state(
284                 self.as_ref().to_glib_none().0,
285                 mut_override(sequence.to_glib_none().0),
286                 state.into_glib(),
287             ))
288         }
289     }
290 
set_state(&self, state: EventSequenceState) -> bool291     fn set_state(&self, state: EventSequenceState) -> bool {
292         unsafe {
293             from_glib(ffi::gtk_gesture_set_state(
294                 self.as_ref().to_glib_none().0,
295                 state.into_glib(),
296             ))
297         }
298     }
299 
set_window(&self, window: Option<&gdk::Window>)300     fn set_window(&self, window: Option<&gdk::Window>) {
301         unsafe {
302             ffi::gtk_gesture_set_window(self.as_ref().to_glib_none().0, window.to_glib_none().0);
303         }
304     }
305 
ungroup(&self)306     fn ungroup(&self) {
307         unsafe {
308             ffi::gtk_gesture_ungroup(self.as_ref().to_glib_none().0);
309         }
310     }
311 
n_points(&self) -> u32312     fn n_points(&self) -> u32 {
313         unsafe {
314             let mut value = glib::Value::from_type(<u32 as StaticType>::static_type());
315             glib::gobject_ffi::g_object_get_property(
316                 self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
317                 b"n-points\0".as_ptr() as *const _,
318                 value.to_glib_none_mut().0,
319             );
320             value
321                 .get()
322                 .expect("Return Value for property `n-points` getter")
323         }
324     }
325 
connect_begin<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId326     fn connect_begin<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
327         &self,
328         f: F,
329     ) -> SignalHandlerId {
330         unsafe extern "C" fn begin_trampoline<
331             P: IsA<Gesture>,
332             F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
333         >(
334             this: *mut ffi::GtkGesture,
335             sequence: *mut gdk::ffi::GdkEventSequence,
336             f: glib::ffi::gpointer,
337         ) {
338             let f: &F = &*(f as *const F);
339             f(
340                 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
341                 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
342                     .as_ref()
343                     .as_ref(),
344             )
345         }
346         unsafe {
347             let f: Box_<F> = Box_::new(f);
348             connect_raw(
349                 self.as_ptr() as *mut _,
350                 b"begin\0".as_ptr() as *const _,
351                 Some(transmute::<_, unsafe extern "C" fn()>(
352                     begin_trampoline::<Self, F> as *const (),
353                 )),
354                 Box_::into_raw(f),
355             )
356         }
357     }
358 
connect_cancel<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId359     fn connect_cancel<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
360         &self,
361         f: F,
362     ) -> SignalHandlerId {
363         unsafe extern "C" fn cancel_trampoline<
364             P: IsA<Gesture>,
365             F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
366         >(
367             this: *mut ffi::GtkGesture,
368             sequence: *mut gdk::ffi::GdkEventSequence,
369             f: glib::ffi::gpointer,
370         ) {
371             let f: &F = &*(f as *const F);
372             f(
373                 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
374                 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
375                     .as_ref()
376                     .as_ref(),
377             )
378         }
379         unsafe {
380             let f: Box_<F> = Box_::new(f);
381             connect_raw(
382                 self.as_ptr() as *mut _,
383                 b"cancel\0".as_ptr() as *const _,
384                 Some(transmute::<_, unsafe extern "C" fn()>(
385                     cancel_trampoline::<Self, F> as *const (),
386                 )),
387                 Box_::into_raw(f),
388             )
389         }
390     }
391 
connect_end<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId392     fn connect_end<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
393         &self,
394         f: F,
395     ) -> SignalHandlerId {
396         unsafe extern "C" fn end_trampoline<
397             P: IsA<Gesture>,
398             F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
399         >(
400             this: *mut ffi::GtkGesture,
401             sequence: *mut gdk::ffi::GdkEventSequence,
402             f: glib::ffi::gpointer,
403         ) {
404             let f: &F = &*(f as *const F);
405             f(
406                 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
407                 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
408                     .as_ref()
409                     .as_ref(),
410             )
411         }
412         unsafe {
413             let f: Box_<F> = Box_::new(f);
414             connect_raw(
415                 self.as_ptr() as *mut _,
416                 b"end\0".as_ptr() as *const _,
417                 Some(transmute::<_, unsafe extern "C" fn()>(
418                     end_trampoline::<Self, F> as *const (),
419                 )),
420                 Box_::into_raw(f),
421             )
422         }
423     }
424 
connect_sequence_state_changed< F: Fn(&Self, Option<&gdk::EventSequence>, EventSequenceState) + 'static, >( &self, f: F, ) -> SignalHandlerId425     fn connect_sequence_state_changed<
426         F: Fn(&Self, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
427     >(
428         &self,
429         f: F,
430     ) -> SignalHandlerId {
431         unsafe extern "C" fn sequence_state_changed_trampoline<
432             P: IsA<Gesture>,
433             F: Fn(&P, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
434         >(
435             this: *mut ffi::GtkGesture,
436             sequence: *mut gdk::ffi::GdkEventSequence,
437             state: ffi::GtkEventSequenceState,
438             f: glib::ffi::gpointer,
439         ) {
440             let f: &F = &*(f as *const F);
441             f(
442                 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
443                 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
444                     .as_ref()
445                     .as_ref(),
446                 from_glib(state),
447             )
448         }
449         unsafe {
450             let f: Box_<F> = Box_::new(f);
451             connect_raw(
452                 self.as_ptr() as *mut _,
453                 b"sequence-state-changed\0".as_ptr() as *const _,
454                 Some(transmute::<_, unsafe extern "C" fn()>(
455                     sequence_state_changed_trampoline::<Self, F> as *const (),
456                 )),
457                 Box_::into_raw(f),
458             )
459         }
460     }
461 
connect_update<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>( &self, f: F, ) -> SignalHandlerId462     fn connect_update<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
463         &self,
464         f: F,
465     ) -> SignalHandlerId {
466         unsafe extern "C" fn update_trampoline<
467             P: IsA<Gesture>,
468             F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
469         >(
470             this: *mut ffi::GtkGesture,
471             sequence: *mut gdk::ffi::GdkEventSequence,
472             f: glib::ffi::gpointer,
473         ) {
474             let f: &F = &*(f as *const F);
475             f(
476                 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
477                 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
478                     .as_ref()
479                     .as_ref(),
480             )
481         }
482         unsafe {
483             let f: Box_<F> = Box_::new(f);
484             connect_raw(
485                 self.as_ptr() as *mut _,
486                 b"update\0".as_ptr() as *const _,
487                 Some(transmute::<_, unsafe extern "C" fn()>(
488                     update_trampoline::<Self, F> as *const (),
489                 )),
490                 Box_::into_raw(f),
491             )
492         }
493     }
494 
connect_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId495     fn connect_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
496         unsafe extern "C" fn notify_window_trampoline<P: IsA<Gesture>, F: Fn(&P) + 'static>(
497             this: *mut ffi::GtkGesture,
498             _param_spec: glib::ffi::gpointer,
499             f: glib::ffi::gpointer,
500         ) {
501             let f: &F = &*(f as *const F);
502             f(Gesture::from_glib_borrow(this).unsafe_cast_ref())
503         }
504         unsafe {
505             let f: Box_<F> = Box_::new(f);
506             connect_raw(
507                 self.as_ptr() as *mut _,
508                 b"notify::window\0".as_ptr() as *const _,
509                 Some(transmute::<_, unsafe extern "C" fn()>(
510                     notify_window_trampoline::<Self, F> as *const (),
511                 )),
512                 Box_::into_raw(f),
513             )
514         }
515     }
516 }
517 
518 impl fmt::Display for Gesture {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result519     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
520         f.write_str("Gesture")
521     }
522 }
523