    {-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Recognizes click gestures.
    --
    -- It is able to recognize multiple clicks on a nearby zone, which
    -- can be listened for through the [GestureClick::pressed]("GI.Gtk.Objects.GestureClick#g:signal:pressed")
    -- signal. Whenever time or distance between clicks exceed the GTK
    -- defaults, [GestureClick::stopped]("GI.Gtk.Objects.GestureClick#g:signal:stopped") is emitted, and the
    -- click counter is reset.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gtk.Objects.GestureClick
        (

    -- * Exported types
        GestureClick(..)                        ,
        IsGestureClick                          ,
        toGestureClick                          ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [group]("GI.Gtk.Objects.Gesture#g:method:group"), [handlesSequence]("GI.Gtk.Objects.Gesture#g:method:handlesSequence"), [isActive]("GI.Gtk.Objects.Gesture#g:method:isActive"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isGroupedWith]("GI.Gtk.Objects.Gesture#g:method:isGroupedWith"), [isRecognized]("GI.Gtk.Objects.Gesture#g:method:isRecognized"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [reset]("GI.Gtk.Objects.EventController#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [ungroup]("GI.Gtk.Objects.Gesture#g:method:ungroup"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getBoundingBox]("GI.Gtk.Objects.Gesture#g:method:getBoundingBox"), [getBoundingBoxCenter]("GI.Gtk.Objects.Gesture#g:method:getBoundingBoxCenter"), [getButton]("GI.Gtk.Objects.GestureSingle#g:method:getButton"), [getCurrentButton]("GI.Gtk.Objects.GestureSingle#g:method:getCurrentButton"), [getCurrentEvent]("GI.Gtk.Objects.EventController#g:method:getCurrentEvent"), [getCurrentEventDevice]("GI.Gtk.Objects.EventController#g:method:getCurrentEventDevice"), [getCurrentEventState]("GI.Gtk.Objects.EventController#g:method:getCurrentEventState"), [getCurrentEventTime]("GI.Gtk.Objects.EventController#g:method:getCurrentEventTime"), [getCurrentSequence]("GI.Gtk.Objects.GestureSingle#g:method:getCurrentSequence"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDevice]("GI.Gtk.Objects.Gesture#g:method:getDevice"), [getExclusive]("GI.Gtk.Objects.GestureSingle#g:method:getExclusive"), [getGroup]("GI.Gtk.Objects.Gesture#g:method:getGroup"), [getLastEvent]("GI.Gtk.Objects.Gesture#g:method:getLastEvent"), [getLastUpdatedSequence]("GI.Gtk.Objects.Gesture#g:method:getLastUpdatedSequence"), [getName]("GI.Gtk.Objects.EventController#g:method:getName"), [getPoint]("GI.Gtk.Objects.Gesture#g:method:getPoint"), [getPropagationLimit]("GI.Gtk.Objects.EventController#g:method:getPropagationLimit"), [getPropagationPhase]("GI.Gtk.Objects.EventController#g:method:getPropagationPhase"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSequenceState]("GI.Gtk.Objects.Gesture#g:method:getSequenceState"), [getSequences]("GI.Gtk.Objects.Gesture#g:method:getSequences"), [getTouchOnly]("GI.Gtk.Objects.GestureSingle#g:method:getTouchOnly"), [getWidget]("GI.Gtk.Objects.EventController#g:method:getWidget").
    --
    -- ==== Setters
    -- [setButton]("GI.Gtk.Objects.GestureSingle#g:method:setButton"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setExclusive]("GI.Gtk.Objects.GestureSingle#g:method:setExclusive"), [setName]("GI.Gtk.Objects.EventController#g:method:setName"), [setPropagationLimit]("GI.Gtk.Objects.EventController#g:method:setPropagationLimit"), [setPropagationPhase]("GI.Gtk.Objects.EventController#g:method:setPropagationPhase"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSequenceState]("GI.Gtk.Objects.Gesture#g:method:setSequenceState"), [setState]("GI.Gtk.Objects.Gesture#g:method:setState"), [setStaticName]("GI.Gtk.Objects.EventController#g:method:setStaticName"), [setTouchOnly]("GI.Gtk.Objects.GestureSingle#g:method:setTouchOnly").

    #if defined(ENABLE_OVERLOADING)
        ResolveGestureClickMethod               ,
    #endif

    -- ** new #method:new#

        gestureClickNew                         ,

     -- * Signals

    -- ** pressed #signal:pressed#

        GestureClickPressedCallback             ,
    #if defined(ENABLE_OVERLOADING)
        GestureClickPressedSignalInfo           ,
    #endif
        afterGestureClickPressed                ,
        onGestureClickPressed                   ,

    -- ** released #signal:released#

        GestureClickReleasedCallback            ,
    #if defined(ENABLE_OVERLOADING)
        GestureClickReleasedSignalInfo          ,
    #endif
        afterGestureClickReleased               ,
        onGestureClickReleased                  ,

    -- ** stopped #signal:stopped#

        GestureClickStoppedCallback             ,
    #if defined(ENABLE_OVERLOADING)
        GestureClickStoppedSignalInfo           ,
    #endif
        afterGestureClickStopped                ,
        onGestureClickStopped                   ,

    -- ** unpairedRelease #signal:unpairedRelease#

        GestureClickUnpairedReleaseCallback     ,
    #if defined(ENABLE_OVERLOADING)
        GestureClickUnpairedReleaseSignalInfo   ,
    #endif
        afterGestureClickUnpairedRelease        ,
        onGestureClickUnpairedRelease           ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Flags as Gdk.Flags
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
    import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import qualified GI.Gdk.Objects.Device as Gdk.Device
    import qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.Event as Gdk.Event
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
    import qualified GI.Gdk.Objects.Surface as Gdk.Surface
    import qualified GI.Gdk.Objects.Texture as Gdk.Texture
    import qualified GI.Gdk.Structs.EventSequence as Gdk.EventSequence
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import qualified GI.Graphene.Structs.Point as Graphene.Point
    import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import qualified GI.Graphene.Structs.Rect as Graphene.Rect
    import qualified GI.Graphene.Structs.Size as Graphene.Size
    import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
    import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
    import qualified GI.Gsk.Enums as Gsk.Enums
    import qualified GI.Gsk.Flags as Gsk.Flags
    import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
    import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
    import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
    import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
    import qualified GI.Gsk.Structs.ComponentTransfer as Gsk.ComponentTransfer
    import qualified GI.Gsk.Structs.Path as Gsk.Path
    import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
    import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
    import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
    import qualified GI.Gsk.Structs.Transform as Gsk.Transform
    import qualified GI.Gtk.Callbacks as Gtk.Callbacks
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Gesture as Gtk.Gesture
    import {-# SOURCE #-} qualified GI.Gtk.Objects.GestureSingle as Gtk.GestureSingle
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutChild as Gtk.LayoutChild
    import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
    import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
    import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
    import qualified GI.Pango.Enums as Pango.Enums
    import qualified GI.Pango.Objects.Context as Pango.Context
    import qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import qualified GI.Pango.Objects.Layout as Pango.Layout

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Structs.EventSequence as Gdk.EventSequence
    import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Gesture as Gtk.Gesture
    import {-# SOURCE #-} qualified GI.Gtk.Objects.GestureSingle as Gtk.GestureSingle

    #endif

    -- | Memory-managed wrapper type.
    newtype GestureClick = GestureClick (SP.ManagedPtr GestureClick)
        deriving (GestureClick -> GestureClick -> Bool
    (GestureClick -> GestureClick -> Bool)
    -> (GestureClick -> GestureClick -> Bool) -> Eq GestureClick
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GestureClick -> GestureClick -> Bool
    == :: GestureClick -> GestureClick -> Bool
    $c/= :: GestureClick -> GestureClick -> Bool
    /= :: GestureClick -> GestureClick -> Bool
    Eq)

    instance SP.ManagedPtrNewtype GestureClick where
        toManagedPtr :: GestureClick -> ManagedPtr GestureClick
    toManagedPtr (GestureClick ManagedPtr GestureClick
    p) = ManagedPtr GestureClick
    p

    foreign import ccall "gtk_gesture_click_get_type"
        c_gtk_gesture_click_get_type :: IO B.Types.GType

    instance B.Types.TypedObject GestureClick where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_gesture_click_get_type

    instance B.Types.GObject GestureClick

    -- | Type class for types which can be safely cast to t'GestureClick', for instance with `toGestureClick`.
    class (SP.GObject o, O.IsDescendantOf GestureClick o) => IsGestureClick o
    instance (SP.GObject o, O.IsDescendantOf GestureClick o) => IsGestureClick o

    instance O.HasParentTypes GestureClick
    type instance O.ParentTypes GestureClick = '[Gtk.GestureSingle.GestureSingle, Gtk.Gesture.Gesture, Gtk.EventController.EventController, GObject.Object.Object]

    -- | Cast to t'GestureClick', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
    toGestureClick :: (MIO.MonadIO m, IsGestureClick o) => o -> m GestureClick
    toGestureClick :: forall (m :: * -> *) o.
    (MonadIO m, IsGestureClick o) =>
    o -> m GestureClick
    toGestureClick = IO GestureClick -> m GestureClick
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO GestureClick -> m GestureClick)
    -> (o -> IO GestureClick) -> o -> m GestureClick
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr GestureClick -> GestureClick) -> o -> IO GestureClick
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    B.ManagedPtr.unsafeCastTo ManagedPtr GestureClick -> GestureClick
    GestureClick

    -- | Convert t'GestureClick' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe GestureClick) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_gesture_click_get_type
        gvalueSet_ :: Ptr GValue -> Maybe GestureClick -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe GestureClick
    P.Nothing = Ptr GValue -> Ptr GestureClick -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr GestureClick
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr GestureClick)
        gvalueSet_ Ptr GValue
    gv (P.Just GestureClick
    obj) = GestureClick -> (Ptr GestureClick -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr GestureClick
    obj (Ptr GValue -> Ptr GestureClick -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe GestureClick)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr GestureClick)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr GestureClick)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject GestureClick ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveGestureClickMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveGestureClickMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveGestureClickMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveGestureClickMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveGestureClickMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveGestureClickMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveGestureClickMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo
        ResolveGestureClickMethod "handlesSequence" o = Gtk.Gesture.GestureHandlesSequenceMethodInfo
        ResolveGestureClickMethod "isActive" o = Gtk.Gesture.GestureIsActiveMethodInfo
        ResolveGestureClickMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveGestureClickMethod "isGroupedWith" o = Gtk.Gesture.GestureIsGroupedWithMethodInfo
        ResolveGestureClickMethod "isRecognized" o = Gtk.Gesture.GestureIsRecognizedMethodInfo
        ResolveGestureClickMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveGestureClickMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveGestureClickMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveGestureClickMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveGestureClickMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
        ResolveGestureClickMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveGestureClickMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveGestureClickMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveGestureClickMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveGestureClickMethod "ungroup" o = Gtk.Gesture.GestureUngroupMethodInfo
        ResolveGestureClickMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveGestureClickMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveGestureClickMethod "getBoundingBox" o = Gtk.Gesture.GestureGetBoundingBoxMethodInfo
        ResolveGestureClickMethod "getBoundingBoxCenter" o = Gtk.Gesture.GestureGetBoundingBoxCenterMethodInfo
        ResolveGestureClickMethod "getButton" o = Gtk.GestureSingle.GestureSingleGetButtonMethodInfo
        ResolveGestureClickMethod "getCurrentButton" o = Gtk.GestureSingle.GestureSingleGetCurrentButtonMethodInfo
        ResolveGestureClickMethod "getCurrentEvent" o = Gtk.EventController.EventControllerGetCurrentEventMethodInfo
        ResolveGestureClickMethod "getCurrentEventDevice" o = Gtk.EventController.EventControllerGetCurrentEventDeviceMethodInfo
        ResolveGestureClickMethod "getCurrentEventState" o = Gtk.EventController.EventControllerGetCurrentEventStateMethodInfo
        ResolveGestureClickMethod "getCurrentEventTime" o = Gtk.EventController.EventControllerGetCurrentEventTimeMethodInfo
        ResolveGestureClickMethod "getCurrentSequence" o = Gtk.GestureSingle.GestureSingleGetCurrentSequenceMethodInfo
        ResolveGestureClickMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveGestureClickMethod "getDevice" o = Gtk.Gesture.GestureGetDeviceMethodInfo
        ResolveGestureClickMethod "getExclusive" o = Gtk.GestureSingle.GestureSingleGetExclusiveMethodInfo
        ResolveGestureClickMethod "getGroup" o = Gtk.Gesture.GestureGetGroupMethodInfo
        ResolveGestureClickMethod "getLastEvent" o = Gtk.Gesture.GestureGetLastEventMethodInfo
        ResolveGestureClickMethod "getLastUpdatedSequence" o = Gtk.Gesture.GestureGetLastUpdatedSequenceMethodInfo
        ResolveGestureClickMethod "getName" o = Gtk.EventController.EventControllerGetNameMethodInfo
        ResolveGestureClickMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo
        ResolveGestureClickMethod "getPropagationLimit" o = Gtk.EventController.EventControllerGetPropagationLimitMethodInfo
        ResolveGestureClickMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
        ResolveGestureClickMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveGestureClickMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveGestureClickMethod "getSequenceState" o = Gtk.Gesture.GestureGetSequenceStateMethodInfo
        ResolveGestureClickMethod "getSequences" o = Gtk.Gesture.GestureGetSequencesMethodInfo
        ResolveGestureClickMethod "getTouchOnly" o = Gtk.GestureSingle.GestureSingleGetTouchOnlyMethodInfo
        ResolveGestureClickMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
        ResolveGestureClickMethod "setButton" o = Gtk.GestureSingle.GestureSingleSetButtonMethodInfo
        ResolveGestureClickMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveGestureClickMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveGestureClickMethod "setExclusive" o = Gtk.GestureSingle.GestureSingleSetExclusiveMethodInfo
        ResolveGestureClickMethod "setName" o = Gtk.EventController.EventControllerSetNameMethodInfo
        ResolveGestureClickMethod "setPropagationLimit" o = Gtk.EventController.EventControllerSetPropagationLimitMethodInfo
        ResolveGestureClickMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
        ResolveGestureClickMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveGestureClickMethod "setSequenceState" o = Gtk.Gesture.GestureSetSequenceStateMethodInfo
        ResolveGestureClickMethod "setState" o = Gtk.Gesture.GestureSetStateMethodInfo
        ResolveGestureClickMethod "setStaticName" o = Gtk.EventController.EventControllerSetStaticNameMethodInfo
        ResolveGestureClickMethod "setTouchOnly" o = Gtk.GestureSingle.GestureSingleSetTouchOnlyMethodInfo
        ResolveGestureClickMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveGestureClickMethod t GestureClick, O.OverloadedMethod info GestureClick p) => OL.IsLabel t (GestureClick -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveGestureClickMethod t GestureClick, O.OverloadedMethod info GestureClick p, R.HasField t GestureClick p) => R.HasField t GestureClick p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveGestureClickMethod t GestureClick, O.OverloadedMethodInfo info GestureClick) => OL.IsLabel t (O.MethodProxy info GestureClick) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif

    -- signal GestureClick::pressed
    -- | Emitted whenever a button or touch press happens.
    type GestureClickPressedCallback =
        Int32
        -- ^ /@nPress@/: how many touch\/button presses happened with this one
        -> Double
        -- ^ /@x@/: The X coordinate, in widget allocation coordinates
        -> Double
        -- ^ /@y@/: The Y coordinate, in widget allocation coordinates
        -> IO ()

    type C_GestureClickPressedCallback =
        Ptr GestureClick ->                     -- object
        Int32 ->
        CDouble ->
        CDouble ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_GestureClickPressedCallback`.
    foreign import ccall "wrapper"
        mk_GestureClickPressedCallback :: C_GestureClickPressedCallback -> IO (FunPtr C_GestureClickPressedCallback)

    wrap_GestureClickPressedCallback ::
        GObject a => (a -> GestureClickPressedCallback) ->
        C_GestureClickPressedCallback
    wrap_GestureClickPressedCallback :: forall a.
    GObject a =>
    (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    wrap_GestureClickPressedCallback a -> GestureClickPressedCallback
    gi'cb Ptr GestureClick
    gi'selfPtr Int32
    nPress CDouble
    x CDouble
    y Ptr ()
    _ = do
        let x' :: Double
    x' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    x
        let y' :: Double
    y' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    y
        Ptr GestureClick -> (GestureClick -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr GestureClick
    gi'selfPtr ((GestureClick -> IO ()) -> IO ())
    -> (GestureClick -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \GestureClick
    gi'self -> a -> GestureClickPressedCallback
    gi'cb (GestureClick -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce GestureClick
    gi'self)  Int32
    nPress Double
    x' Double
    y'

    -- | Connect a signal handler for the [pressed](#signal:pressed) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' gestureClick #pressed callback
    -- @
    --
    --
    onGestureClickPressed :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickPressedCallback) -> m SignalHandlerId
    onGestureClickPressed :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a
    -> ((?self::a) => GestureClickPressedCallback) -> m SignalHandlerId
    onGestureClickPressed a
    obj (?self::a) => GestureClickPressedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> GestureClickPressedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => GestureClickPressedCallback
    GestureClickPressedCallback
    cb
        let wrapped' :: C_GestureClickPressedCallback
    wrapped' = (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    forall a.
    GObject a =>
    (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    wrap_GestureClickPressedCallback a -> GestureClickPressedCallback
    wrapped
        wrapped'' <- C_GestureClickPressedCallback
    -> IO (FunPtr C_GestureClickPressedCallback)
    mk_GestureClickPressedCallback C_GestureClickPressedCallback
    wrapped'
        connectSignalFunPtr obj "pressed" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [pressed](#signal:pressed) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' gestureClick #pressed callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterGestureClickPressed :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickPressedCallback) -> m SignalHandlerId
    afterGestureClickPressed :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a
    -> ((?self::a) => GestureClickPressedCallback) -> m SignalHandlerId
    afterGestureClickPressed a
    obj (?self::a) => GestureClickPressedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> GestureClickPressedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => GestureClickPressedCallback
    GestureClickPressedCallback
    cb
        let wrapped' :: C_GestureClickPressedCallback
    wrapped' = (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    forall a.
    GObject a =>
    (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    wrap_GestureClickPressedCallback a -> GestureClickPressedCallback
    wrapped
        wrapped'' <- C_GestureClickPressedCallback
    -> IO (FunPtr C_GestureClickPressedCallback)
    mk_GestureClickPressedCallback C_GestureClickPressedCallback
    wrapped'
        connectSignalFunPtr obj "pressed" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data GestureClickPressedSignalInfo
    instance SignalInfo GestureClickPressedSignalInfo where
        type HaskellCallbackType GestureClickPressedSignalInfo = GestureClickPressedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_GestureClickPressedCallback cb
            cb'' <- mk_GestureClickPressedCallback cb'
            connectSignalFunPtr obj "pressed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.GestureClick::pressed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-GestureClick.html#g:signal:pressed"})

    #endif

    -- signal GestureClick::released
    -- | Emitted when a button or touch is released.
    --
    -- /@nPress@/ will report the number of press that is paired to
    -- this event, note that [GestureClick::stopped]("GI.Gtk.Objects.GestureClick#g:signal:stopped") may
    -- have been emitted between the press and its release, /@nPress@/
    -- will only start over at the next press.
    type GestureClickReleasedCallback =
        Int32
        -- ^ /@nPress@/: number of press that is paired with this release
        -> Double
        -- ^ /@x@/: The X coordinate, in widget allocation coordinates
        -> Double
        -- ^ /@y@/: The Y coordinate, in widget allocation coordinates
        -> IO ()

    type C_GestureClickReleasedCallback =
        Ptr GestureClick ->                     -- object
        Int32 ->
        CDouble ->
        CDouble ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_GestureClickReleasedCallback`.
    foreign import ccall "wrapper"
        mk_GestureClickReleasedCallback :: C_GestureClickReleasedCallback -> IO (FunPtr C_GestureClickReleasedCallback)

    wrap_GestureClickReleasedCallback ::
        GObject a => (a -> GestureClickReleasedCallback) ->
        C_GestureClickReleasedCallback
    wrap_GestureClickReleasedCallback :: forall a.
    GObject a =>
    (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    wrap_GestureClickReleasedCallback a -> GestureClickPressedCallback
    gi'cb Ptr GestureClick
    gi'selfPtr Int32
    nPress CDouble
    x CDouble
    y Ptr ()
    _ = do
        let x' :: Double
    x' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    x
        let y' :: Double
    y' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    y
        Ptr GestureClick -> (GestureClick -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr GestureClick
    gi'selfPtr ((GestureClick -> IO ()) -> IO ())
    -> (GestureClick -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \GestureClick
    gi'self -> a -> GestureClickPressedCallback
    gi'cb (GestureClick -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce GestureClick
    gi'self)  Int32
    nPress Double
    x' Double
    y'

    -- | Connect a signal handler for the [released](#signal:released) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' gestureClick #released callback
    -- @
    --
    --
    onGestureClickReleased :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickReleasedCallback) -> m SignalHandlerId
    onGestureClickReleased :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a
    -> ((?self::a) => GestureClickPressedCallback) -> m SignalHandlerId
    onGestureClickReleased a
    obj (?self::a) => GestureClickPressedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> GestureClickPressedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => GestureClickPressedCallback
    GestureClickPressedCallback
    cb
        let wrapped' :: C_GestureClickPressedCallback
    wrapped' = (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    forall a.
    GObject a =>
    (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    wrap_GestureClickReleasedCallback a -> GestureClickPressedCallback
    wrapped
        wrapped'' <- C_GestureClickPressedCallback
    -> IO (FunPtr C_GestureClickPressedCallback)
    mk_GestureClickReleasedCallback C_GestureClickPressedCallback
    wrapped'
        connectSignalFunPtr obj "released" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [released](#signal:released) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' gestureClick #released callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterGestureClickReleased :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickReleasedCallback) -> m SignalHandlerId
    afterGestureClickReleased :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a
    -> ((?self::a) => GestureClickPressedCallback) -> m SignalHandlerId
    afterGestureClickReleased a
    obj (?self::a) => GestureClickPressedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> GestureClickPressedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => GestureClickPressedCallback
    GestureClickPressedCallback
    cb
        let wrapped' :: C_GestureClickPressedCallback
    wrapped' = (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    forall a.
    GObject a =>
    (a -> GestureClickPressedCallback) -> C_GestureClickPressedCallback
    wrap_GestureClickReleasedCallback a -> GestureClickPressedCallback
    wrapped
        wrapped'' <- C_GestureClickPressedCallback
    -> IO (FunPtr C_GestureClickPressedCallback)
    mk_GestureClickReleasedCallback C_GestureClickPressedCallback
    wrapped'
        connectSignalFunPtr obj "released" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data GestureClickReleasedSignalInfo
    instance SignalInfo GestureClickReleasedSignalInfo where
        type HaskellCallbackType GestureClickReleasedSignalInfo = GestureClickReleasedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_GestureClickReleasedCallback cb
            cb'' <- mk_GestureClickReleasedCallback cb'
            connectSignalFunPtr obj "released" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.GestureClick::released"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-GestureClick.html#g:signal:released"})

    #endif

    -- signal GestureClick::stopped
    -- | Emitted whenever any time\/distance threshold has been exceeded.
    type GestureClickStoppedCallback =
        IO ()

    type C_GestureClickStoppedCallback =
        Ptr GestureClick ->                     -- object
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_GestureClickStoppedCallback`.
    foreign import ccall "wrapper"
        mk_GestureClickStoppedCallback :: C_GestureClickStoppedCallback -> IO (FunPtr C_GestureClickStoppedCallback)

    wrap_GestureClickStoppedCallback ::
        GObject a => (a -> GestureClickStoppedCallback) ->
        C_GestureClickStoppedCallback
    wrap_GestureClickStoppedCallback :: forall a.
    GObject a =>
    (a -> IO ()) -> C_GestureClickStoppedCallback
    wrap_GestureClickStoppedCallback a -> IO ()
    gi'cb Ptr GestureClick
    gi'selfPtr Ptr ()
    _ = do
        Ptr GestureClick -> (GestureClick -> IO ()) -> IO ()
    forall o b.
    (HasCallStack, GObject o) =>
    Ptr o -> (o -> IO b) -> IO b
    B.ManagedPtr.withNewObject Ptr GestureClick
    gi'selfPtr ((GestureClick -> IO ()) -> IO ())
    -> (GestureClick -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \GestureClick
    gi'self -> a -> IO ()
    gi'cb (GestureClick -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce GestureClick
    gi'self)

    -- | Connect a signal handler for the [stopped](#signal:stopped) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' gestureClick #stopped callback
    -- @
    --
    --
    onGestureClickStopped :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickStoppedCallback) -> m SignalHandlerId
    onGestureClickStopped :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    onGestureClickStopped a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_GestureClickStoppedCallback
    wrapped' = (a -> IO ()) -> C_GestureClickStoppedCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_GestureClickStoppedCallback
    wrap_GestureClickStoppedCallback a -> IO ()
    wrapped
        wrapped'' <- C_GestureClickStoppedCallback
    -> IO (FunPtr C_GestureClickStoppedCallback)
    mk_GestureClickStoppedCallback C_GestureClickStoppedCallback
    wrapped'
        connectSignalFunPtr obj "stopped" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [stopped](#signal:stopped) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' gestureClick #stopped callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterGestureClickStopped :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickStoppedCallback) -> m SignalHandlerId
    afterGestureClickStopped :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a -> ((?self::a) => IO ()) -> m SignalHandlerId
    afterGestureClickStopped a
    obj (?self::a) => IO ()
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> IO ()
    wrapped a
    self = let ?self = a
    ?self::a
    self in IO ()
    (?self::a) => IO ()
    cb
        let wrapped' :: C_GestureClickStoppedCallback
    wrapped' = (a -> IO ()) -> C_GestureClickStoppedCallback
    forall a.
    GObject a =>
    (a -> IO ()) -> C_GestureClickStoppedCallback
    wrap_GestureClickStoppedCallback a -> IO ()
    wrapped
        wrapped'' <- C_GestureClickStoppedCallback
    -> IO (FunPtr C_GestureClickStoppedCallback)
    mk_GestureClickStoppedCallback C_GestureClickStoppedCallback
    wrapped'
        connectSignalFunPtr obj "stopped" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data GestureClickStoppedSignalInfo
    instance SignalInfo GestureClickStoppedSignalInfo where
        type HaskellCallbackType GestureClickStoppedSignalInfo = GestureClickStoppedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_GestureClickStoppedCallback cb
            cb'' <- mk_GestureClickStoppedCallback cb'
            connectSignalFunPtr obj "stopped" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.GestureClick::stopped"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-GestureClick.html#g:signal:stopped"})

    #endif

    -- signal GestureClick::unpaired-release
    -- | Emitted whenever the gesture receives a release
    -- event that had no previous corresponding press.
    --
    -- Due to implicit grabs, this can only happen on situations
    -- where input is grabbed elsewhere mid-press or the pressed
    -- widget voluntarily relinquishes its implicit grab.
    type GestureClickUnpairedReleaseCallback =
        Double
        -- ^ /@x@/: X coordinate of the event
        -> Double
        -- ^ /@y@/: Y coordinate of the event
        -> Word32
        -- ^ /@button@/: Button being released
        -> Maybe Gdk.EventSequence.EventSequence
        -- ^ /@sequence@/: Sequence being released
        -> IO ()

    type C_GestureClickUnpairedReleaseCallback =
        Ptr GestureClick ->                     -- object
        CDouble ->
        CDouble ->
        Word32 ->
        Ptr Gdk.EventSequence.EventSequence ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_GestureClickUnpairedReleaseCallback`.
    foreign import ccall "wrapper"
        mk_GestureClickUnpairedReleaseCallback :: C_GestureClickUnpairedReleaseCallback -> IO (FunPtr C_GestureClickUnpairedReleaseCallback)

    wrap_GestureClickUnpairedReleaseCallback ::
        GObject a => (a -> GestureClickUnpairedReleaseCallback) ->
        C_GestureClickUnpairedReleaseCallback
    wrap_GestureClickUnpairedReleaseCallback :: forall a.
    GObject a =>
    (a -> GestureClickUnpairedReleaseCallback)
    -> C_GestureClickUnpairedReleaseCallback
    wrap_GestureClickUnpairedReleaseCallback a -> GestureClickUnpairedReleaseCallback
    gi'cb Ptr GestureClick
    gi'selfPtr CDouble
    x CDouble
    y Word32
    button Ptr EventSequence
    sequence Ptr ()
    _ = do
        let x' :: Double
    x' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    x
        let y' :: Double
    y' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    y
        maybeSequence <-
            if Ptr EventSequence
    sequence Ptr EventSequence -> Ptr EventSequence -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr EventSequence
    forall a. Ptr a
    FP.nullPtr
            then Maybe EventSequence -> IO (Maybe EventSequence)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe EventSequence
    forall a. Maybe a
    Nothing
            else do
                Ptr EventSequence
    -> (EventSequence -> IO (Maybe EventSequence))
    -> IO (Maybe EventSequence)
    forall a b.
    (HasCallStack, ManagedPtrNewtype a) =>
    Ptr a -> (a -> IO b) -> IO b
    B.ManagedPtr.withTransient  Ptr EventSequence
    sequence ((EventSequence -> IO (Maybe EventSequence))
     -> IO (Maybe EventSequence))
    -> (EventSequence -> IO (Maybe EventSequence))
    -> IO (Maybe EventSequence)
    forall a b. (a -> b) -> a -> b
    $ \EventSequence
    sequence' -> do
                    Maybe EventSequence -> IO (Maybe EventSequence)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe EventSequence -> IO (Maybe EventSequence))
    -> Maybe EventSequence -> IO (Maybe EventSequence)
    forall a b. (a -> b) -> a -> b
    $ EventSequence -> Maybe EventSequence
    forall a. a -> Maybe a
    Just EventSequence
    sequence'
        B.ManagedPtr.withNewObject gi'selfPtr $ \GestureClick
    gi'self -> a -> GestureClickUnpairedReleaseCallback
    gi'cb (GestureClick -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce GestureClick
    gi'self)  Double
    x' Double
    y' Word32
    button Maybe EventSequence
    maybeSequence

    -- | Connect a signal handler for the [unpairedRelease](#signal:unpairedRelease) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' gestureClick #unpairedRelease callback
    -- @
    --
    --
    onGestureClickUnpairedRelease :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickUnpairedReleaseCallback) -> m SignalHandlerId
    onGestureClickUnpairedRelease :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a
    -> ((?self::a) => GestureClickUnpairedReleaseCallback)
    -> m SignalHandlerId
    onGestureClickUnpairedRelease a
    obj (?self::a) => GestureClickUnpairedReleaseCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> GestureClickUnpairedReleaseCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => GestureClickUnpairedReleaseCallback
    GestureClickUnpairedReleaseCallback
    cb
        let wrapped' :: C_GestureClickUnpairedReleaseCallback
    wrapped' = (a -> GestureClickUnpairedReleaseCallback)
    -> C_GestureClickUnpairedReleaseCallback
    forall a.
    GObject a =>
    (a -> GestureClickUnpairedReleaseCallback)
    -> C_GestureClickUnpairedReleaseCallback
    wrap_GestureClickUnpairedReleaseCallback a -> GestureClickUnpairedReleaseCallback
    wrapped
        wrapped'' <- C_GestureClickUnpairedReleaseCallback
    -> IO (FunPtr C_GestureClickUnpairedReleaseCallback)
    mk_GestureClickUnpairedReleaseCallback C_GestureClickUnpairedReleaseCallback
    wrapped'
        connectSignalFunPtr obj "unpaired-release" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [unpairedRelease](#signal:unpairedRelease) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' gestureClick #unpairedRelease callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterGestureClickUnpairedRelease :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickUnpairedReleaseCallback) -> m SignalHandlerId
    afterGestureClickUnpairedRelease :: forall a (m :: * -> *).
    (IsGestureClick a, MonadIO m) =>
    a
    -> ((?self::a) => GestureClickUnpairedReleaseCallback)
    -> m SignalHandlerId
    afterGestureClickUnpairedRelease a
    obj (?self::a) => GestureClickUnpairedReleaseCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> GestureClickUnpairedReleaseCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => GestureClickUnpairedReleaseCallback
    GestureClickUnpairedReleaseCallback
    cb
        let wrapped' :: C_GestureClickUnpairedReleaseCallback
    wrapped' = (a -> GestureClickUnpairedReleaseCallback)
    -> C_GestureClickUnpairedReleaseCallback
    forall a.
    GObject a =>
    (a -> GestureClickUnpairedReleaseCallback)
    -> C_GestureClickUnpairedReleaseCallback
    wrap_GestureClickUnpairedReleaseCallback a -> GestureClickUnpairedReleaseCallback
    wrapped
        wrapped'' <- C_GestureClickUnpairedReleaseCallback
    -> IO (FunPtr C_GestureClickUnpairedReleaseCallback)
    mk_GestureClickUnpairedReleaseCallback C_GestureClickUnpairedReleaseCallback
    wrapped'
        connectSignalFunPtr obj "unpaired-release" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data GestureClickUnpairedReleaseSignalInfo
    instance SignalInfo GestureClickUnpairedReleaseSignalInfo where
        type HaskellCallbackType GestureClickUnpairedReleaseSignalInfo = GestureClickUnpairedReleaseCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_GestureClickUnpairedReleaseCallback cb
            cb'' <- mk_GestureClickUnpairedReleaseCallback cb'
            connectSignalFunPtr obj "unpaired-release" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.GestureClick::unpaired-release"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-GestureClick.html#g:signal:unpairedRelease"})

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList GestureClick
    type instance O.AttributeList GestureClick = GestureClickAttributeList
    type GestureClickAttributeList = ('[ '("button", Gtk.GestureSingle.GestureSingleButtonPropertyInfo), '("exclusive", Gtk.GestureSingle.GestureSingleExclusivePropertyInfo), '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("name", Gtk.EventController.EventControllerNamePropertyInfo), '("propagationLimit", Gtk.EventController.EventControllerPropagationLimitPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("touchOnly", Gtk.GestureSingle.GestureSingleTouchOnlyPropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList GestureClick = GestureClickSignalList
    type GestureClickSignalList = ('[ '("begin", Gtk.Gesture.GestureBeginSignalInfo), '("cancel", Gtk.Gesture.GestureCancelSignalInfo), '("end", Gtk.Gesture.GestureEndSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pressed", GestureClickPressedSignalInfo), '("released", GestureClickReleasedSignalInfo), '("sequenceStateChanged", Gtk.Gesture.GestureSequenceStateChangedSignalInfo), '("stopped", GestureClickStoppedSignalInfo), '("unpairedRelease", GestureClickUnpairedReleaseSignalInfo), '("update", Gtk.Gesture.GestureUpdateSignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method GestureClick::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gtk" , name = "GestureClick" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_gesture_click_new" gtk_gesture_click_new ::
        IO (Ptr GestureClick)

    -- | Returns a newly created @GtkGesture@ that recognizes
    -- single and multiple presses.
    gestureClickNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m GestureClick
        -- ^ __Returns:__ a newly created @GtkGestureClick@
    gestureClickNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m GestureClick
    gestureClickNew  = IO GestureClick -> m GestureClick
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GestureClick -> m GestureClick)
    -> IO GestureClick -> m GestureClick
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr GestureClick)
    gtk_gesture_click_new
        checkUnexpectedReturnNULL "gestureClickNew" result
        result' <- (wrapObject GestureClick) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif