1#![allow(deprecated)]
5
6use crate::{ffi, EventController, EventSequenceState};
7use glib::{
8 object::ObjectType as _,
9 prelude::*,
10 signal::{connect_raw, SignalHandlerId},
11 translate::*,
12};
13use std::boxed::Box as Box_;
14
15glib::wrapper! {
16 #[doc(alias = "GtkGesture")]
17 pub struct Gesture(Object<ffi::GtkGesture, ffi::GtkGestureClass>) @extends EventController;
18
19 match fn {
20 type_ => || ffi::gtk_gesture_get_type(),
21 }
22}
23
24impl Gesture {
25 pub const NONE: Option<&'static Gesture> = None;
26}
27
28pub trait GestureExt: IsA<Gesture> + 'static {
29 #[doc(alias = "gtk_gesture_get_bounding_box")]
30 #[doc(alias = "get_bounding_box")]
31 fn bounding_box(&self) -> Option<gdk::Rectangle> {
32 unsafe {
33 let mut rect = gdk::Rectangle::uninitialized();
34 let ret = from_glib(ffi::gtk_gesture_get_bounding_box(
35 self.as_ref().to_glib_none().0,
36 rect.to_glib_none_mut().0,
37 ));
38 if ret {
39 Some(rect)
40 } else {
41 None
42 }
43 }
44 }
45
46 #[doc(alias = "gtk_gesture_get_bounding_box_center")]
47 #[doc(alias = "get_bounding_box_center")]
48 fn bounding_box_center(&self) -> Option<(f64, f64)> {
49 unsafe {
50 let mut x = std::mem::MaybeUninit::uninit();
51 let mut y = std::mem::MaybeUninit::uninit();
52 let ret = from_glib(ffi::gtk_gesture_get_bounding_box_center(
53 self.as_ref().to_glib_none().0,
54 x.as_mut_ptr(),
55 y.as_mut_ptr(),
56 ));
57 if ret {
58 Some((x.assume_init(), y.assume_init()))
59 } else {
60 None
61 }
62 }
63 }
64
65 #[doc(alias = "gtk_gesture_get_device")]
66 #[doc(alias = "get_device")]
67 fn device(&self) -> Option<gdk::Device> {
68 unsafe { from_glib_none(ffi::gtk_gesture_get_device(self.as_ref().to_glib_none().0)) }
69 }
70
71 #[doc(alias = "gtk_gesture_get_group")]
72 #[doc(alias = "get_group")]
73 fn group(&self) -> Vec<Gesture> {
74 unsafe {
75 FromGlibPtrContainer::from_glib_container(ffi::gtk_gesture_get_group(
76 self.as_ref().to_glib_none().0,
77 ))
78 }
79 }
80
81 #[doc(alias = "gtk_gesture_get_last_event")]
82 #[doc(alias = "get_last_event")]
83 fn last_event(&self, sequence: Option<&gdk::EventSequence>) -> Option<gdk::Event> {
84 unsafe {
85 from_glib_none(ffi::gtk_gesture_get_last_event(
86 self.as_ref().to_glib_none().0,
87 mut_override(sequence.to_glib_none().0),
88 ))
89 }
90 }
91
92 #[doc(alias = "gtk_gesture_get_last_updated_sequence")]
93 #[doc(alias = "get_last_updated_sequence")]
94 fn last_updated_sequence(&self) -> Option<gdk::EventSequence> {
95 unsafe {
96 from_glib_none(ffi::gtk_gesture_get_last_updated_sequence(
97 self.as_ref().to_glib_none().0,
98 ))
99 }
100 }
101
102 #[doc(alias = "gtk_gesture_get_point")]
103 #[doc(alias = "get_point")]
104 fn point(&self, sequence: Option<&gdk::EventSequence>) -> Option<(f64, f64)> {
105 unsafe {
106 let mut x = std::mem::MaybeUninit::uninit();
107 let mut y = std::mem::MaybeUninit::uninit();
108 let ret = from_glib(ffi::gtk_gesture_get_point(
109 self.as_ref().to_glib_none().0,
110 mut_override(sequence.to_glib_none().0),
111 x.as_mut_ptr(),
112 y.as_mut_ptr(),
113 ));
114 if ret {
115 Some((x.assume_init(), y.assume_init()))
116 } else {
117 None
118 }
119 }
120 }
121
122 #[doc(alias = "gtk_gesture_get_sequence_state")]
123 #[doc(alias = "get_sequence_state")]
124 fn sequence_state(&self, sequence: &gdk::EventSequence) -> EventSequenceState {
125 unsafe {
126 from_glib(ffi::gtk_gesture_get_sequence_state(
127 self.as_ref().to_glib_none().0,
128 mut_override(sequence.to_glib_none().0),
129 ))
130 }
131 }
132
133 #[doc(alias = "gtk_gesture_get_sequences")]
134 #[doc(alias = "get_sequences")]
135 fn sequences(&self) -> Vec<gdk::EventSequence> {
136 unsafe {
137 FromGlibPtrContainer::from_glib_container(ffi::gtk_gesture_get_sequences(
138 self.as_ref().to_glib_none().0,
139 ))
140 }
141 }
142
143 #[doc(alias = "gtk_gesture_group")]
144 #[doc(alias = "group")]
145 fn group_with(&self, gesture: &impl IsA<Gesture>) {
146 unsafe {
147 ffi::gtk_gesture_group(
148 self.as_ref().to_glib_none().0,
149 gesture.as_ref().to_glib_none().0,
150 );
151 }
152 }
153
154 #[doc(alias = "gtk_gesture_handles_sequence")]
155 fn handles_sequence(&self, sequence: Option<&gdk::EventSequence>) -> bool {
156 unsafe {
157 from_glib(ffi::gtk_gesture_handles_sequence(
158 self.as_ref().to_glib_none().0,
159 mut_override(sequence.to_glib_none().0),
160 ))
161 }
162 }
163
164 #[doc(alias = "gtk_gesture_is_active")]
165 fn is_active(&self) -> bool {
166 unsafe { from_glib(ffi::gtk_gesture_is_active(self.as_ref().to_glib_none().0)) }
167 }
168
169 #[doc(alias = "gtk_gesture_is_grouped_with")]
170 fn is_grouped_with(&self, other: &impl IsA<Gesture>) -> bool {
171 unsafe {
172 from_glib(ffi::gtk_gesture_is_grouped_with(
173 self.as_ref().to_glib_none().0,
174 other.as_ref().to_glib_none().0,
175 ))
176 }
177 }
178
179 #[doc(alias = "gtk_gesture_is_recognized")]
180 fn is_recognized(&self) -> bool {
181 unsafe {
182 from_glib(ffi::gtk_gesture_is_recognized(
183 self.as_ref().to_glib_none().0,
184 ))
185 }
186 }
187
188 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
189 #[allow(deprecated)]
190 #[doc(alias = "gtk_gesture_set_sequence_state")]
191 fn set_sequence_state(&self, sequence: &gdk::EventSequence, state: EventSequenceState) -> bool {
192 unsafe {
193 from_glib(ffi::gtk_gesture_set_sequence_state(
194 self.as_ref().to_glib_none().0,
195 mut_override(sequence.to_glib_none().0),
196 state.into_glib(),
197 ))
198 }
199 }
200
201 #[doc(alias = "gtk_gesture_set_state")]
202 fn set_state(&self, state: EventSequenceState) -> bool {
203 unsafe {
204 from_glib(ffi::gtk_gesture_set_state(
205 self.as_ref().to_glib_none().0,
206 state.into_glib(),
207 ))
208 }
209 }
210
211 #[doc(alias = "gtk_gesture_ungroup")]
212 fn ungroup(&self) {
213 unsafe {
214 ffi::gtk_gesture_ungroup(self.as_ref().to_glib_none().0);
215 }
216 }
217
218 #[doc(alias = "n-points")]
219 fn n_points(&self) -> u32 {
220 ObjectExt::property(self.as_ref(), "n-points")
221 }
222
223 #[doc(alias = "begin")]
224 fn connect_begin<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
225 &self,
226 f: F,
227 ) -> SignalHandlerId {
228 unsafe extern "C" fn begin_trampoline<
229 P: IsA<Gesture>,
230 F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
231 >(
232 this: *mut ffi::GtkGesture,
233 sequence: *mut gdk::ffi::GdkEventSequence,
234 f: glib::ffi::gpointer,
235 ) {
236 let f: &F = &*(f as *const F);
237 f(
238 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
239 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
240 .as_ref()
241 .as_ref(),
242 )
243 }
244 unsafe {
245 let f: Box_<F> = Box_::new(f);
246 connect_raw(
247 self.as_ptr() as *mut _,
248 c"begin".as_ptr() as *const _,
249 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
250 begin_trampoline::<Self, F> as *const (),
251 )),
252 Box_::into_raw(f),
253 )
254 }
255 }
256
257 #[doc(alias = "cancel")]
258 fn connect_cancel<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
259 &self,
260 f: F,
261 ) -> SignalHandlerId {
262 unsafe extern "C" fn cancel_trampoline<
263 P: IsA<Gesture>,
264 F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
265 >(
266 this: *mut ffi::GtkGesture,
267 sequence: *mut gdk::ffi::GdkEventSequence,
268 f: glib::ffi::gpointer,
269 ) {
270 let f: &F = &*(f as *const F);
271 f(
272 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
273 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
274 .as_ref()
275 .as_ref(),
276 )
277 }
278 unsafe {
279 let f: Box_<F> = Box_::new(f);
280 connect_raw(
281 self.as_ptr() as *mut _,
282 c"cancel".as_ptr() as *const _,
283 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
284 cancel_trampoline::<Self, F> as *const (),
285 )),
286 Box_::into_raw(f),
287 )
288 }
289 }
290
291 #[doc(alias = "end")]
292 fn connect_end<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
293 &self,
294 f: F,
295 ) -> SignalHandlerId {
296 unsafe extern "C" fn end_trampoline<
297 P: IsA<Gesture>,
298 F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
299 >(
300 this: *mut ffi::GtkGesture,
301 sequence: *mut gdk::ffi::GdkEventSequence,
302 f: glib::ffi::gpointer,
303 ) {
304 let f: &F = &*(f as *const F);
305 f(
306 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
307 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
308 .as_ref()
309 .as_ref(),
310 )
311 }
312 unsafe {
313 let f: Box_<F> = Box_::new(f);
314 connect_raw(
315 self.as_ptr() as *mut _,
316 c"end".as_ptr() as *const _,
317 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
318 end_trampoline::<Self, F> as *const (),
319 )),
320 Box_::into_raw(f),
321 )
322 }
323 }
324
325 #[doc(alias = "sequence-state-changed")]
326 fn connect_sequence_state_changed<
327 F: Fn(&Self, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
328 >(
329 &self,
330 f: F,
331 ) -> SignalHandlerId {
332 unsafe extern "C" fn sequence_state_changed_trampoline<
333 P: IsA<Gesture>,
334 F: Fn(&P, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
335 >(
336 this: *mut ffi::GtkGesture,
337 sequence: *mut gdk::ffi::GdkEventSequence,
338 state: ffi::GtkEventSequenceState,
339 f: glib::ffi::gpointer,
340 ) {
341 let f: &F = &*(f as *const F);
342 f(
343 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
344 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
345 .as_ref()
346 .as_ref(),
347 from_glib(state),
348 )
349 }
350 unsafe {
351 let f: Box_<F> = Box_::new(f);
352 connect_raw(
353 self.as_ptr() as *mut _,
354 c"sequence-state-changed".as_ptr() as *const _,
355 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
356 sequence_state_changed_trampoline::<Self, F> as *const (),
357 )),
358 Box_::into_raw(f),
359 )
360 }
361 }
362
363 #[doc(alias = "update")]
364 fn connect_update<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
365 &self,
366 f: F,
367 ) -> SignalHandlerId {
368 unsafe extern "C" fn update_trampoline<
369 P: IsA<Gesture>,
370 F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
371 >(
372 this: *mut ffi::GtkGesture,
373 sequence: *mut gdk::ffi::GdkEventSequence,
374 f: glib::ffi::gpointer,
375 ) {
376 let f: &F = &*(f as *const F);
377 f(
378 Gesture::from_glib_borrow(this).unsafe_cast_ref(),
379 Option::<gdk::EventSequence>::from_glib_borrow(sequence)
380 .as_ref()
381 .as_ref(),
382 )
383 }
384 unsafe {
385 let f: Box_<F> = Box_::new(f);
386 connect_raw(
387 self.as_ptr() as *mut _,
388 c"update".as_ptr() as *const _,
389 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
390 update_trampoline::<Self, F> as *const (),
391 )),
392 Box_::into_raw(f),
393 )
394 }
395 }
396}
397
398impl<O: IsA<Gesture>> GestureExt for O {}