// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::EventController;
use crate::EventSequenceState;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem;
use std::mem::transmute;

glib::wrapper! {
    /// [`Gesture`][crate::Gesture] is the base object for gesture recognition, although this
    /// object is quite generalized to serve as a base for multi-touch gestures,
    /// it is suitable to implement single-touch and pointer-based gestures (using
    /// the special [`None`] [`gdk::EventSequence`][crate::gdk::EventSequence] value for these).
    ///
    /// The number of touches that a [`Gesture`][crate::Gesture] need to be recognized is controlled
    /// by the `property::Gesture::n-points` property, if a gesture is keeping track of less
    /// or more than that number of sequences, it won't check wether the gesture
    /// is recognized.
    ///
    /// As soon as the gesture has the expected number of touches, the gesture will
    /// run the `signal::Gesture::check` signal regularly on input events until the gesture
    /// is recognized, the criteria to consider a gesture as "recognized" is left to
    /// [`Gesture`][crate::Gesture] subclasses.
    ///
    /// A recognized gesture will then emit the following signals:
    /// - `signal::Gesture::begin` when the gesture is recognized.
    /// - A number of `signal::Gesture::update`, whenever an input event is processed.
    /// - `signal::Gesture::end` when the gesture is no longer recognized.
    ///
    /// ## Event propagation
    ///
    /// In order to receive events, a gesture needs to either set a propagation phase
    /// through [`EventControllerExt::set_propagation_phase()`][crate::prelude::EventControllerExt::set_propagation_phase()], or feed those manually
    /// through [`EventControllerExt::handle_event()`][crate::prelude::EventControllerExt::handle_event()].
    ///
    /// In the capture phase, events are propagated from the toplevel down to the
    /// target widget, and gestures that are attached to containers above the widget
    /// get a chance to interact with the event before it reaches the target.
    ///
    /// After the capture phase, GTK+ emits the traditional `signal::Widget::button-press-event`,
    /// `signal::Widget::button-release-event`, `signal::Widget::touch-event`, etc signals. Gestures
    /// with the [`PropagationPhase::Target`][crate::PropagationPhase::Target] phase are fed events from the default `signal::Widget::event`
    /// handlers.
    ///
    /// In the bubble phase, events are propagated up from the target widget to the
    /// toplevel, and gestures that are attached to containers above the widget get
    /// a chance to interact with events that have not been handled yet.
    ///
    /// ## States of a sequence # {`touch`-sequence-states}
    ///
    /// Whenever input interaction happens, a single event may trigger a cascade of
    /// `GtkGestures`, both across the parents of the widget receiving the event and
    /// in parallel within an individual widget. It is a responsibility of the
    /// widgets using those gestures to set the state of touch sequences accordingly
    /// in order to enable cooperation of gestures around the `GdkEventSequences`
    /// triggering those.
    ///
    /// Within a widget, gestures can be grouped through [`GestureExt::group_with()`][crate::prelude::GestureExt::group_with()],
    /// grouped gestures synchronize the state of sequences, so calling
    /// [`GestureExt::set_sequence_state()`][crate::prelude::GestureExt::set_sequence_state()] on one will effectively propagate
    /// the state throughout the group.
    ///
    /// By default, all sequences start out in the [`EventSequenceState::None`][crate::EventSequenceState::None] state,
    /// sequences in this state trigger the gesture event handler, but event
    /// propagation will continue unstopped by gestures.
    ///
    /// If a sequence enters into the [`EventSequenceState::Denied`][crate::EventSequenceState::Denied] state, the gesture
    /// group will effectively ignore the sequence, letting events go unstopped
    /// through the gesture, but the "slot" will still remain occupied while
    /// the touch is active.
    ///
    /// If a sequence enters in the [`EventSequenceState::Claimed`][crate::EventSequenceState::Claimed] state, the gesture
    /// group will grab all interaction on the sequence, by:
    /// - Setting the same sequence to [`EventSequenceState::Denied`][crate::EventSequenceState::Denied] on every other gesture
    ///  group within the widget, and every gesture on parent widgets in the propagation
    ///  chain.
    /// - calling `signal::Gesture::cancel` on every gesture in widgets underneath in the
    ///  propagation chain.
    /// - Stopping event propagation after the gesture group handles the event.
    ///
    /// Note: if a sequence is set early to [`EventSequenceState::Claimed`][crate::EventSequenceState::Claimed] on
    /// `GDK_TOUCH_BEGIN`/`GDK_BUTTON_PRESS` (so those events are captured before
    /// reaching the event widget, this implies [`PropagationPhase::Capture`][crate::PropagationPhase::Capture]), one similar
    /// event will emulated if the sequence changes to [`EventSequenceState::Denied`][crate::EventSequenceState::Denied].
    /// This way event coherence is preserved before event propagation is unstopped
    /// again.
    ///
    /// Sequence states can't be changed freely, see [`GestureExt::set_sequence_state()`][crate::prelude::GestureExt::set_sequence_state()]
    /// to know about the possible lifetimes of a [`gdk::EventSequence`][crate::gdk::EventSequence].
    ///
    /// ## Touchpad gestures
    ///
    /// On the platforms that support it, [`Gesture`][crate::Gesture] will handle transparently
    /// touchpad gesture events. The only precautions users of [`Gesture`][crate::Gesture] should do
    /// to enable this support are:
    /// - Enabling [`gdk::EventMask::TOUCHPAD_GESTURE_MASK`][crate::gdk::EventMask::TOUCHPAD_GESTURE_MASK] on their `GdkWindows`
    /// - If the gesture has [`PropagationPhase::None`][crate::PropagationPhase::None], ensuring events of type
    ///  `GDK_TOUCHPAD_SWIPE` and `GDK_TOUCHPAD_PINCH` are handled by the [`Gesture`][crate::Gesture]
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`GestureExt`][trait@crate::prelude::GestureExt], [`EventControllerExt`][trait@crate::prelude::EventControllerExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkGesture")]
    pub struct Gesture(Object<ffi::GtkGesture, ffi::GtkGestureClass>) @extends EventController;

    match fn {
        type_ => || ffi::gtk_gesture_get_type(),
    }
}

pub const NONE_GESTURE: Option<&Gesture> = None;

/// Trait containing all [`struct@Gesture`] methods.
///
/// # Implementors
///
/// [`GestureRotate`][struct@crate::GestureRotate], [`GestureSingle`][struct@crate::GestureSingle], [`GestureZoom`][struct@crate::GestureZoom], [`Gesture`][struct@crate::Gesture]
pub trait GestureExt: 'static {
    /// If there are touch sequences being currently handled by `self`,
    /// this function returns [`true`] and fills in `rect` with the bounding
    /// box containing all active touches. Otherwise, [`false`] will be
    /// returned.
    ///
    /// Note: This function will yield unexpected results on touchpad
    /// gestures. Since there is no correlation between physical and
    /// pixel distances, these will look as if constrained in an
    /// infinitely small area, `rect` width and height will thus be 0
    /// regardless of the number of touchpoints.
    ///
    /// # Returns
    ///
    /// [`true`] if there are active touches, [`false`] otherwise
    ///
    /// ## `rect`
    /// bounding box containing all active touches.
    #[doc(alias = "gtk_gesture_get_bounding_box")]
    #[doc(alias = "get_bounding_box")]
    fn bounding_box(&self) -> Option<gdk::Rectangle>;

    /// If there are touch sequences being currently handled by `self`,
    /// this function returns [`true`] and fills in `x` and `y` with the center
    /// of the bounding box containing all active touches. Otherwise, [`false`]
    /// will be returned.
    ///
    /// # Returns
    ///
    /// [`false`] if no active touches are present, [`true`] otherwise
    ///
    /// ## `x`
    /// X coordinate for the bounding box center
    ///
    /// ## `y`
    /// Y coordinate for the bounding box center
    #[doc(alias = "gtk_gesture_get_bounding_box_center")]
    #[doc(alias = "get_bounding_box_center")]
    fn bounding_box_center(&self) -> Option<(f64, f64)>;

    /// Returns the master [`gdk::Device`][crate::gdk::Device] that is currently operating
    /// on `self`, or [`None`] if the gesture is not being interacted.
    ///
    /// # Returns
    ///
    /// a [`gdk::Device`][crate::gdk::Device], or [`None`]
    #[doc(alias = "gtk_gesture_get_device")]
    #[doc(alias = "get_device")]
    fn device(&self) -> Option<gdk::Device>;

    /// Returns all gestures in the group of `self`
    ///
    /// # Returns
    ///
    /// The list
    ///  of `GtkGestures`, free with `g_list_free()`
    #[doc(alias = "gtk_gesture_get_group")]
    #[doc(alias = "get_group")]
    fn group(&self) -> Vec<Gesture>;

    /// Returns the last event that was processed for `sequence`.
    ///
    /// Note that the returned pointer is only valid as long as the `sequence`
    /// is still interpreted by the `self`. If in doubt, you should make
    /// a copy of the event.
    /// ## `sequence`
    /// a [`gdk::EventSequence`][crate::gdk::EventSequence]
    ///
    /// # Returns
    ///
    /// The last event from `sequence`
    #[doc(alias = "gtk_gesture_get_last_event")]
    #[doc(alias = "get_last_event")]
    fn last_event(&self, sequence: Option<&gdk::EventSequence>) -> Option<gdk::Event>;

    /// Returns the [`gdk::EventSequence`][crate::gdk::EventSequence] that was last updated on `self`.
    ///
    /// # Returns
    ///
    /// The last updated sequence
    #[doc(alias = "gtk_gesture_get_last_updated_sequence")]
    #[doc(alias = "get_last_updated_sequence")]
    fn last_updated_sequence(&self) -> Option<gdk::EventSequence>;

    /// If `sequence` is currently being interpreted by `self`, this
    /// function returns [`true`] and fills in `x` and `y` with the last coordinates
    /// stored for that event sequence. The coordinates are always relative to the
    /// widget allocation.
    /// ## `sequence`
    /// a [`gdk::EventSequence`][crate::gdk::EventSequence], or [`None`] for pointer events
    ///
    /// # Returns
    ///
    /// [`true`] if `sequence` is currently interpreted
    ///
    /// ## `x`
    /// return location for X axis of the sequence coordinates
    ///
    /// ## `y`
    /// return location for Y axis of the sequence coordinates
    #[doc(alias = "gtk_gesture_get_point")]
    #[doc(alias = "get_point")]
    fn point(&self, sequence: Option<&gdk::EventSequence>) -> Option<(f64, f64)>;

    /// Returns the `sequence` state, as seen by `self`.
    /// ## `sequence`
    /// a [`gdk::EventSequence`][crate::gdk::EventSequence]
    ///
    /// # Returns
    ///
    /// The sequence state in `self`
    #[doc(alias = "gtk_gesture_get_sequence_state")]
    #[doc(alias = "get_sequence_state")]
    fn sequence_state(&self, sequence: &gdk::EventSequence) -> EventSequenceState;

    /// Returns the list of `GdkEventSequences` currently being interpreted
    /// by `self`.
    ///
    /// # Returns
    ///
    /// A list
    ///  of `GdkEventSequences`, the list elements are owned by GTK+
    ///  and must not be freed or modified, the list itself must be deleted
    ///  through `g_list_free()`
    #[doc(alias = "gtk_gesture_get_sequences")]
    #[doc(alias = "get_sequences")]
    fn sequences(&self) -> Vec<gdk::EventSequence>;

    /// Returns the user-defined window that receives the events
    /// handled by `self`. See [`set_window()`][Self::set_window()] for more
    /// information.
    ///
    /// # Returns
    ///
    /// the user defined window, or [`None`] if none
    #[doc(alias = "gtk_gesture_get_window")]
    #[doc(alias = "get_window")]
    fn window(&self) -> Option<gdk::Window>;

    /// Adds `gesture` to the same group than `self`. Gestures
    /// are by default isolated in their own groups.
    ///
    /// When gestures are grouped, the state of `GdkEventSequences`
    /// is kept in sync for all of those, so calling [`set_sequence_state()`][Self::set_sequence_state()],
    /// on one will transfer the same value to the others.
    ///
    /// Groups also perform an "implicit grabbing" of sequences, if a
    /// [`gdk::EventSequence`][crate::gdk::EventSequence] state is set to [`EventSequenceState::Claimed`][crate::EventSequenceState::Claimed] on one group,
    /// every other gesture group attached to the same [`Widget`][crate::Widget] will switch the
    /// state for that sequence to [`EventSequenceState::Denied`][crate::EventSequenceState::Denied].
    /// ## `gesture`
    /// a [`Gesture`][crate::Gesture]
    #[doc(alias = "gtk_gesture_group")]
    #[doc(alias = "group")]
    fn group_with<P: IsA<Gesture>>(&self, gesture: &P);

    /// Returns [`true`] if `self` is currently handling events corresponding to
    /// `sequence`.
    /// ## `sequence`
    /// a [`gdk::EventSequence`][crate::gdk::EventSequence] or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is handling `sequence`, [`false`] otherwise
    #[doc(alias = "gtk_gesture_handles_sequence")]
    fn handles_sequence(&self, sequence: Option<&gdk::EventSequence>) -> bool;

    /// Returns [`true`] if the gesture is currently active.
    /// A gesture is active meanwhile there are touch sequences
    /// interacting with it.
    ///
    /// # Returns
    ///
    /// [`true`] if gesture is active
    #[doc(alias = "gtk_gesture_is_active")]
    fn is_active(&self) -> bool;

    /// Returns [`true`] if both gestures pertain to the same group.
    /// ## `other`
    /// another [`Gesture`][crate::Gesture]
    ///
    /// # Returns
    ///
    /// whether the gestures are grouped
    #[doc(alias = "gtk_gesture_is_grouped_with")]
    fn is_grouped_with<P: IsA<Gesture>>(&self, other: &P) -> bool;

    /// Returns [`true`] if the gesture is currently recognized.
    /// A gesture is recognized if there are as many interacting
    /// touch sequences as required by `self`, and `signal::Gesture::check`
    /// returned [`true`] for the sequences being currently interpreted.
    ///
    /// # Returns
    ///
    /// [`true`] if gesture is recognized
    #[doc(alias = "gtk_gesture_is_recognized")]
    fn is_recognized(&self) -> bool;

    /// Sets the state of `sequence` in `self`. Sequences start
    /// in state [`EventSequenceState::None`][crate::EventSequenceState::None], and whenever they change
    /// state, they can never go back to that state. Likewise,
    /// sequences in state [`EventSequenceState::Denied`][crate::EventSequenceState::Denied] cannot turn
    /// back to a not denied state. With these rules, the lifetime
    /// of an event sequence is constrained to the next four:
    ///
    /// * None
    /// * None → Denied
    /// * None → Claimed
    /// * None → Claimed → Denied
    ///
    /// Note: Due to event handling ordering, it may be unsafe to
    /// set the state on another gesture within a `signal::Gesture::begin`
    /// signal handler, as the callback might be executed before
    /// the other gesture knows about the sequence. A safe way to
    /// perform this could be:
    ///
    ///
    /// ```text
    /// static void
    /// first_gesture_begin_cb (GtkGesture       *first_gesture,
    ///                         GdkEventSequence *sequence,
    ///                         gpointer          user_data)
    /// {
    ///   gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
    ///   gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
    /// }
    ///
    /// static void
    /// second_gesture_begin_cb (GtkGesture       *second_gesture,
    ///                          GdkEventSequence *sequence,
    ///                          gpointer          user_data)
    /// {
    ///   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
    ///     gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
    /// }
    /// ```
    ///
    /// If both gestures are in the same group, just set the state on
    /// the gesture emitting the event, the sequence will be already
    /// be initialized to the group's global state when the second
    /// gesture processes the event.
    /// ## `sequence`
    /// a [`gdk::EventSequence`][crate::gdk::EventSequence]
    /// ## `state`
    /// the sequence state
    ///
    /// # Returns
    ///
    /// [`true`] if `sequence` is handled by `self`,
    ///  and the state is changed successfully
    #[doc(alias = "gtk_gesture_set_sequence_state")]
    fn set_sequence_state(&self, sequence: &gdk::EventSequence, state: EventSequenceState) -> bool;

    /// Sets the state of all sequences that `self` is currently
    /// interacting with. See [`set_sequence_state()`][Self::set_sequence_state()]
    /// for more details on sequence states.
    /// ## `state`
    /// the sequence state
    ///
    /// # Returns
    ///
    /// [`true`] if the state of at least one sequence
    ///  was changed successfully
    #[doc(alias = "gtk_gesture_set_state")]
    fn set_state(&self, state: EventSequenceState) -> bool;

    /// Sets a specific window to receive events about, so `self`
    /// will effectively handle only events targeting `window`, or
    /// a child of it. `window` must pertain to [`EventControllerExt::widget()`][crate::prelude::EventControllerExt::widget()].
    /// ## `window`
    /// a [`gdk::Window`][crate::gdk::Window], or [`None`]
    #[doc(alias = "gtk_gesture_set_window")]
    fn set_window(&self, window: Option<&gdk::Window>);

    /// Separates `self` into an isolated group.
    #[doc(alias = "gtk_gesture_ungroup")]
    fn ungroup(&self);

    /// The number of touch points that trigger recognition on this gesture,
    #[doc(alias = "n-points")]
    fn n_points(&self) -> u32;

    /// This signal is emitted when the gesture is recognized. This means the
    /// number of touch sequences matches `property::Gesture::n-points`, and the `signal::Gesture::check`
    /// handler(s) returned [`true`].
    ///
    /// Note: These conditions may also happen when an extra touch (eg. a third touch
    /// on a 2-touches gesture) is lifted, in that situation `sequence` won't pertain
    /// to the current set of active touches, so don't rely on this being true.
    /// ## `sequence`
    /// the [`gdk::EventSequence`][crate::gdk::EventSequence] that made the gesture to be recognized
    #[doc(alias = "begin")]
    fn connect_begin<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// This signal is emitted whenever a sequence is cancelled. This usually
    /// happens on active touches when [`EventControllerExt::reset()`][crate::prelude::EventControllerExt::reset()] is called
    /// on `gesture` (manually, due to grabs...), or the individual `sequence`
    /// was claimed by parent widgets' controllers (see [`set_sequence_state()`][Self::set_sequence_state()]).
    ///
    /// `gesture` must forget everything about `sequence` as a reaction to this signal.
    /// ## `sequence`
    /// the [`gdk::EventSequence`][crate::gdk::EventSequence] that was cancelled
    #[doc(alias = "cancel")]
    fn connect_cancel<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// This signal is emitted when `gesture` either stopped recognizing the event
    /// sequences as something to be handled (the `signal::Gesture::check` handler returned
    /// [`false`]), or the number of touch sequences became higher or lower than
    /// `property::Gesture::n-points`.
    ///
    /// Note: `sequence` might not pertain to the group of sequences that were
    /// previously triggering recognition on `gesture` (ie. a just pressed touch
    /// sequence that exceeds `property::Gesture::n-points`). This situation may be detected
    /// by checking through [`handles_sequence()`][Self::handles_sequence()].
    /// ## `sequence`
    /// the [`gdk::EventSequence`][crate::gdk::EventSequence] that made gesture recognition to finish
    #[doc(alias = "end")]
    fn connect_end<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// This signal is emitted whenever a sequence state changes. See
    /// [`set_sequence_state()`][Self::set_sequence_state()] to know more about the expectable
    /// sequence lifetimes.
    /// ## `sequence`
    /// the [`gdk::EventSequence`][crate::gdk::EventSequence] that was cancelled
    /// ## `state`
    /// the new sequence state
    #[doc(alias = "sequence-state-changed")]
    fn connect_sequence_state_changed<
        F: Fn(&Self, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// This signal is emitted whenever an event is handled while the gesture is
    /// recognized. `sequence` is guaranteed to pertain to the set of active touches.
    /// ## `sequence`
    /// the [`gdk::EventSequence`][crate::gdk::EventSequence] that was updated
    #[doc(alias = "update")]
    fn connect_update<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "window")]
    fn connect_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Gesture>> GestureExt for O {
    fn bounding_box(&self) -> Option<gdk::Rectangle> {
        unsafe {
            let mut rect = gdk::Rectangle::uninitialized();
            let ret = from_glib(ffi::gtk_gesture_get_bounding_box(
                self.as_ref().to_glib_none().0,
                rect.to_glib_none_mut().0,
            ));
            if ret {
                Some(rect)
            } else {
                None
            }
        }
    }

    fn bounding_box_center(&self) -> Option<(f64, f64)> {
        unsafe {
            let mut x = mem::MaybeUninit::uninit();
            let mut y = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_gesture_get_bounding_box_center(
                self.as_ref().to_glib_none().0,
                x.as_mut_ptr(),
                y.as_mut_ptr(),
            ));
            let x = x.assume_init();
            let y = y.assume_init();
            if ret {
                Some((x, y))
            } else {
                None
            }
        }
    }

    fn device(&self) -> Option<gdk::Device> {
        unsafe { from_glib_none(ffi::gtk_gesture_get_device(self.as_ref().to_glib_none().0)) }
    }

    fn group(&self) -> Vec<Gesture> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_gesture_get_group(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn last_event(&self, sequence: Option<&gdk::EventSequence>) -> Option<gdk::Event> {
        unsafe {
            from_glib_none(ffi::gtk_gesture_get_last_event(
                self.as_ref().to_glib_none().0,
                mut_override(sequence.to_glib_none().0),
            ))
        }
    }

    fn last_updated_sequence(&self) -> Option<gdk::EventSequence> {
        unsafe {
            from_glib_none(ffi::gtk_gesture_get_last_updated_sequence(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn point(&self, sequence: Option<&gdk::EventSequence>) -> Option<(f64, f64)> {
        unsafe {
            let mut x = mem::MaybeUninit::uninit();
            let mut y = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_gesture_get_point(
                self.as_ref().to_glib_none().0,
                mut_override(sequence.to_glib_none().0),
                x.as_mut_ptr(),
                y.as_mut_ptr(),
            ));
            let x = x.assume_init();
            let y = y.assume_init();
            if ret {
                Some((x, y))
            } else {
                None
            }
        }
    }

    fn sequence_state(&self, sequence: &gdk::EventSequence) -> EventSequenceState {
        unsafe {
            from_glib(ffi::gtk_gesture_get_sequence_state(
                self.as_ref().to_glib_none().0,
                mut_override(sequence.to_glib_none().0),
            ))
        }
    }

    fn sequences(&self) -> Vec<gdk::EventSequence> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_gesture_get_sequences(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn window(&self) -> Option<gdk::Window> {
        unsafe { from_glib_none(ffi::gtk_gesture_get_window(self.as_ref().to_glib_none().0)) }
    }

    fn group_with<P: IsA<Gesture>>(&self, gesture: &P) {
        unsafe {
            ffi::gtk_gesture_group(
                self.as_ref().to_glib_none().0,
                gesture.as_ref().to_glib_none().0,
            );
        }
    }

    fn handles_sequence(&self, sequence: Option<&gdk::EventSequence>) -> bool {
        unsafe {
            from_glib(ffi::gtk_gesture_handles_sequence(
                self.as_ref().to_glib_none().0,
                mut_override(sequence.to_glib_none().0),
            ))
        }
    }

    fn is_active(&self) -> bool {
        unsafe { from_glib(ffi::gtk_gesture_is_active(self.as_ref().to_glib_none().0)) }
    }

    fn is_grouped_with<P: IsA<Gesture>>(&self, other: &P) -> bool {
        unsafe {
            from_glib(ffi::gtk_gesture_is_grouped_with(
                self.as_ref().to_glib_none().0,
                other.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_recognized(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_gesture_is_recognized(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn set_sequence_state(&self, sequence: &gdk::EventSequence, state: EventSequenceState) -> bool {
        unsafe {
            from_glib(ffi::gtk_gesture_set_sequence_state(
                self.as_ref().to_glib_none().0,
                mut_override(sequence.to_glib_none().0),
                state.into_glib(),
            ))
        }
    }

    fn set_state(&self, state: EventSequenceState) -> bool {
        unsafe {
            from_glib(ffi::gtk_gesture_set_state(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
            ))
        }
    }

    fn set_window(&self, window: Option<&gdk::Window>) {
        unsafe {
            ffi::gtk_gesture_set_window(self.as_ref().to_glib_none().0, window.to_glib_none().0);
        }
    }

    fn ungroup(&self) {
        unsafe {
            ffi::gtk_gesture_ungroup(self.as_ref().to_glib_none().0);
        }
    }

    fn n_points(&self) -> u32 {
        unsafe {
            let mut value = glib::Value::from_type(<u32 as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"n-points\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `n-points` getter")
        }
    }

    fn connect_begin<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn begin_trampoline<
            P: IsA<Gesture>,
            F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
        >(
            this: *mut ffi::GtkGesture,
            sequence: *mut gdk::ffi::GdkEventSequence,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Gesture::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<gdk::EventSequence>::from_glib_borrow(sequence)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"begin\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    begin_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_cancel<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn cancel_trampoline<
            P: IsA<Gesture>,
            F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
        >(
            this: *mut ffi::GtkGesture,
            sequence: *mut gdk::ffi::GdkEventSequence,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Gesture::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<gdk::EventSequence>::from_glib_borrow(sequence)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"cancel\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    cancel_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_end<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn end_trampoline<
            P: IsA<Gesture>,
            F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
        >(
            this: *mut ffi::GtkGesture,
            sequence: *mut gdk::ffi::GdkEventSequence,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Gesture::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<gdk::EventSequence>::from_glib_borrow(sequence)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"end\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    end_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_sequence_state_changed<
        F: Fn(&Self, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn sequence_state_changed_trampoline<
            P: IsA<Gesture>,
            F: Fn(&P, Option<&gdk::EventSequence>, EventSequenceState) + 'static,
        >(
            this: *mut ffi::GtkGesture,
            sequence: *mut gdk::ffi::GdkEventSequence,
            state: ffi::GtkEventSequenceState,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Gesture::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<gdk::EventSequence>::from_glib_borrow(sequence)
                    .as_ref()
                    .as_ref(),
                from_glib(state),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"sequence-state-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    sequence_state_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_update<F: Fn(&Self, Option<&gdk::EventSequence>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn update_trampoline<
            P: IsA<Gesture>,
            F: Fn(&P, Option<&gdk::EventSequence>) + 'static,
        >(
            this: *mut ffi::GtkGesture,
            sequence: *mut gdk::ffi::GdkEventSequence,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Gesture::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<gdk::EventSequence>::from_glib_borrow(sequence)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"update\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    update_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_window_trampoline<P: IsA<Gesture>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkGesture,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Gesture::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::window\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_window_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Gesture {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Gesture")
    }
}