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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Clutter.Objects.ClickAction.ClickAction' structure contains
-- only private data and should be accessed using the provided API
-- 
-- /Since: 1.4/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Clutter.Objects.ClickAction
    ( 

-- * Exported types
    ClickAction(..)                         ,
    IsClickAction                           ,
    toClickAction                           ,


 -- * 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"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [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"), [release]("GI.Clutter.Objects.ClickAction#g:method:release"), [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"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getActor]("GI.Clutter.Objects.ActorMeta#g:method:getActor"), [getButton]("GI.Clutter.Objects.ClickAction#g:method:getButton"), [getCoords]("GI.Clutter.Objects.ClickAction#g:method:getCoords"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getEnabled]("GI.Clutter.Objects.ActorMeta#g:method:getEnabled"), [getName]("GI.Clutter.Objects.ActorMeta#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getState]("GI.Clutter.Objects.ClickAction#g:method:getState").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setEnabled]("GI.Clutter.Objects.ActorMeta#g:method:setEnabled"), [setName]("GI.Clutter.Objects.ActorMeta#g:method:setName"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveClickActionMethod                ,
#endif

-- ** getButton #method:getButton#

#if defined(ENABLE_OVERLOADING)
    ClickActionGetButtonMethodInfo          ,
#endif
    clickActionGetButton                    ,


-- ** getCoords #method:getCoords#

#if defined(ENABLE_OVERLOADING)
    ClickActionGetCoordsMethodInfo          ,
#endif
    clickActionGetCoords                    ,


-- ** getState #method:getState#

#if defined(ENABLE_OVERLOADING)
    ClickActionGetStateMethodInfo           ,
#endif
    clickActionGetState                     ,


-- ** new #method:new#

    clickActionNew                          ,


-- ** release #method:release#

#if defined(ENABLE_OVERLOADING)
    ClickActionReleaseMethodInfo            ,
#endif
    clickActionRelease                      ,




 -- * Properties


-- ** held #attr:held#
-- | Whether the clickable actor has the pointer grabbed
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ClickActionHeldPropertyInfo             ,
#endif
#if defined(ENABLE_OVERLOADING)
    clickActionHeld                         ,
#endif
    getClickActionHeld                      ,


-- ** longPressDuration #attr:longPressDuration#
-- | The minimum duration of a press for it to be recognized as a long
-- press gesture, in milliseconds.
-- 
-- A value of -1 will make the t'GI.Clutter.Objects.ClickAction.ClickAction' use the value of
-- the [Settings:longPressDuration]("GI.Clutter.Objects.Settings#g:attr:longPressDuration") property.
-- 
-- /Since: 1.8/

#if defined(ENABLE_OVERLOADING)
    ClickActionLongPressDurationPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    clickActionLongPressDuration            ,
#endif
    constructClickActionLongPressDuration   ,
    getClickActionLongPressDuration         ,
    setClickActionLongPressDuration         ,


-- ** longPressThreshold #attr:longPressThreshold#
-- | The maximum allowed distance that can be covered (on both axes) before
-- a long press gesture is cancelled, in pixels.
-- 
-- A value of -1 will make the t'GI.Clutter.Objects.ClickAction.ClickAction' use the value of
-- the [Settings:dndDragThreshold]("GI.Clutter.Objects.Settings#g:attr:dndDragThreshold") property.
-- 
-- /Since: 1.8/

#if defined(ENABLE_OVERLOADING)
    ClickActionLongPressThresholdPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    clickActionLongPressThreshold           ,
#endif
    constructClickActionLongPressThreshold  ,
    getClickActionLongPressThreshold        ,
    setClickActionLongPressThreshold        ,


-- ** pressed #attr:pressed#
-- | Whether the clickable actor should be in \"pressed\" state
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ClickActionPressedPropertyInfo          ,
#endif
#if defined(ENABLE_OVERLOADING)
    clickActionPressed                      ,
#endif
    getClickActionPressed                   ,




 -- * Signals


-- ** clicked #signal:clicked#

    ClickActionClickedCallback              ,
#if defined(ENABLE_OVERLOADING)
    ClickActionClickedSignalInfo            ,
#endif
    afterClickActionClicked                 ,
    onClickActionClicked                    ,


-- ** longPress #signal:longPress#

    ClickActionLongPressCallback            ,
#if defined(ENABLE_OVERLOADING)
    ClickActionLongPressSignalInfo          ,
#endif
    afterClickActionLongPress               ,
    onClickActionLongPress                  ,




    ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.RectangleInt as Cairo.RectangleInt
import qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Content as Clutter.Content
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Alpha as Clutter.Alpha
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animation as Clutter.Animation
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animator as Clutter.Animator
import {-# SOURCE #-} qualified GI.Clutter.Objects.Backend as Clutter.Backend
import {-# SOURCE #-} qualified GI.Clutter.Objects.ChildMeta as Clutter.ChildMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Constraint as Clutter.Constraint
import {-# SOURCE #-} qualified GI.Clutter.Objects.DeviceManager as Clutter.DeviceManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.Group as Clutter.Group
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Interval as Clutter.Interval
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutManager as Clutter.LayoutManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutMeta as Clutter.LayoutMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Script as Clutter.Script
import {-# SOURCE #-} qualified GI.Clutter.Objects.Shader as Clutter.Shader
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Objects.State as Clutter.State
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import {-# SOURCE #-} qualified GI.Clutter.Objects.Transition as Clutter.Transition
import {-# SOURCE #-} qualified GI.Clutter.Structs.ActorBox as Clutter.ActorBox
import {-# SOURCE #-} qualified GI.Clutter.Structs.AnimatorKey as Clutter.AnimatorKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.ButtonEvent as Clutter.ButtonEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.CrossingEvent as Clutter.CrossingEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.EventSequence as Clutter.EventSequence
import {-# SOURCE #-} qualified GI.Clutter.Structs.Fog as Clutter.Fog
import {-# SOURCE #-} qualified GI.Clutter.Structs.Geometry as Clutter.Geometry
import {-# SOURCE #-} qualified GI.Clutter.Structs.KeyEvent as Clutter.KeyEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Margin as Clutter.Margin
import {-# SOURCE #-} qualified GI.Clutter.Structs.Matrix as Clutter.Matrix
import {-# SOURCE #-} qualified GI.Clutter.Structs.MotionEvent as Clutter.MotionEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.PaintVolume as Clutter.PaintVolume
import {-# SOURCE #-} qualified GI.Clutter.Structs.Perspective as Clutter.Perspective
import {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import {-# SOURCE #-} qualified GI.Clutter.Structs.ScrollEvent as Clutter.ScrollEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Size as Clutter.Size
import {-# SOURCE #-} qualified GI.Clutter.Structs.StateKey as Clutter.StateKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.Vertex as Clutter.Vertex
import {-# SOURCE #-} qualified GI.Clutter.Unions.Event as Clutter.Event
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Json.Structs.Node as Json.Node
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.Layout as Pango.Layout

#else
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

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

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

foreign import ccall "clutter_click_action_get_type"
    c_clutter_click_action_get_type :: IO B.Types.GType

instance B.Types.TypedObject ClickAction where
    glibType :: IO GType
glibType = IO GType
c_clutter_click_action_get_type

instance B.Types.GObject ClickAction

-- | Type class for types which can be safely cast to `ClickAction`, for instance with `toClickAction`.
class (SP.GObject o, O.IsDescendantOf ClickAction o) => IsClickAction o
instance (SP.GObject o, O.IsDescendantOf ClickAction o) => IsClickAction o

instance O.HasParentTypes ClickAction
type instance O.ParentTypes ClickAction = '[Clutter.Action.Action, Clutter.ActorMeta.ActorMeta, GObject.Object.Object]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveClickActionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveClickActionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveClickActionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveClickActionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveClickActionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveClickActionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveClickActionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveClickActionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveClickActionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveClickActionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveClickActionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveClickActionMethod "release" o = ClickActionReleaseMethodInfo
    ResolveClickActionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveClickActionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveClickActionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveClickActionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveClickActionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveClickActionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveClickActionMethod "getActor" o = Clutter.ActorMeta.ActorMetaGetActorMethodInfo
    ResolveClickActionMethod "getButton" o = ClickActionGetButtonMethodInfo
    ResolveClickActionMethod "getCoords" o = ClickActionGetCoordsMethodInfo
    ResolveClickActionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveClickActionMethod "getEnabled" o = Clutter.ActorMeta.ActorMetaGetEnabledMethodInfo
    ResolveClickActionMethod "getName" o = Clutter.ActorMeta.ActorMetaGetNameMethodInfo
    ResolveClickActionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveClickActionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveClickActionMethod "getState" o = ClickActionGetStateMethodInfo
    ResolveClickActionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveClickActionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveClickActionMethod "setEnabled" o = Clutter.ActorMeta.ActorMetaSetEnabledMethodInfo
    ResolveClickActionMethod "setName" o = Clutter.ActorMeta.ActorMetaSetNameMethodInfo
    ResolveClickActionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveClickActionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveClickActionMethod t ClickAction, O.OverloadedMethod info ClickAction p) => OL.IsLabel t (ClickAction -> 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 ~ ResolveClickActionMethod t ClickAction, O.OverloadedMethod info ClickAction p, R.HasField t ClickAction p) => R.HasField t ClickAction p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal ClickAction::clicked
-- | The [clicked](#g:signal:clicked) signal is emitted when the t'GI.Clutter.Objects.Actor.Actor' to which
-- a t'GI.Clutter.Objects.ClickAction.ClickAction' has been applied should respond to a
-- pointer button press and release events
-- 
-- /Since: 1.4/
type ClickActionClickedCallback =
    Clutter.Actor.Actor
    -- ^ /@actor@/: the t'GI.Clutter.Objects.Actor.Actor' attached to the /@action@/
    -> IO ()

type C_ClickActionClickedCallback =
    Ptr ClickAction ->                      -- object
    Ptr Clutter.Actor.Actor ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_ClickActionClickedCallback :: 
    GObject a => (a -> ClickActionClickedCallback) ->
    C_ClickActionClickedCallback
wrap_ClickActionClickedCallback :: forall a.
GObject a =>
(a -> ClickActionClickedCallback) -> C_ClickActionClickedCallback
wrap_ClickActionClickedCallback a -> ClickActionClickedCallback
gi'cb Ptr ClickAction
gi'selfPtr Ptr Actor
actor Ptr ()
_ = do
    Actor
actor' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Clutter.Actor.Actor) Ptr Actor
actor
    Ptr ClickAction -> (ClickAction -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr ClickAction
gi'selfPtr ((ClickAction -> IO ()) -> IO ())
-> (ClickAction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ClickAction
gi'self -> a -> ClickActionClickedCallback
gi'cb (ClickAction -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ClickAction
gi'self)  Actor
actor'


-- | Connect a signal handler for the [clicked](#signal:clicked) 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' clickAction #clicked callback
-- @
-- 
-- 
onClickActionClicked :: (IsClickAction a, MonadIO m) => a -> ((?self :: a) => ClickActionClickedCallback) -> m SignalHandlerId
onClickActionClicked :: forall a (m :: * -> *).
(IsClickAction a, MonadIO m) =>
a
-> ((?self::a) => ClickActionClickedCallback) -> m SignalHandlerId
onClickActionClicked a
obj (?self::a) => ClickActionClickedCallback
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 -> ClickActionClickedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ClickActionClickedCallback
ClickActionClickedCallback
cb
    let wrapped' :: C_ClickActionClickedCallback
wrapped' = (a -> ClickActionClickedCallback) -> C_ClickActionClickedCallback
forall a.
GObject a =>
(a -> ClickActionClickedCallback) -> C_ClickActionClickedCallback
wrap_ClickActionClickedCallback a -> ClickActionClickedCallback
wrapped
    FunPtr C_ClickActionClickedCallback
wrapped'' <- C_ClickActionClickedCallback
-> IO (FunPtr C_ClickActionClickedCallback)
mk_ClickActionClickedCallback C_ClickActionClickedCallback
wrapped'
    a
-> Text
-> FunPtr C_ClickActionClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"clicked" FunPtr C_ClickActionClickedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [clicked](#signal:clicked) 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' clickAction #clicked 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.
-- 
afterClickActionClicked :: (IsClickAction a, MonadIO m) => a -> ((?self :: a) => ClickActionClickedCallback) -> m SignalHandlerId
afterClickActionClicked :: forall a (m :: * -> *).
(IsClickAction a, MonadIO m) =>
a
-> ((?self::a) => ClickActionClickedCallback) -> m SignalHandlerId
afterClickActionClicked a
obj (?self::a) => ClickActionClickedCallback
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 -> ClickActionClickedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ClickActionClickedCallback
ClickActionClickedCallback
cb
    let wrapped' :: C_ClickActionClickedCallback
wrapped' = (a -> ClickActionClickedCallback) -> C_ClickActionClickedCallback
forall a.
GObject a =>
(a -> ClickActionClickedCallback) -> C_ClickActionClickedCallback
wrap_ClickActionClickedCallback a -> ClickActionClickedCallback
wrapped
    FunPtr C_ClickActionClickedCallback
wrapped'' <- C_ClickActionClickedCallback
-> IO (FunPtr C_ClickActionClickedCallback)
mk_ClickActionClickedCallback C_ClickActionClickedCallback
wrapped'
    a
-> Text
-> FunPtr C_ClickActionClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"clicked" FunPtr C_ClickActionClickedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ClickActionClickedSignalInfo
instance SignalInfo ClickActionClickedSignalInfo where
    type HaskellCallbackType ClickActionClickedSignalInfo = ClickActionClickedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ClickActionClickedCallback cb
        cb'' <- mk_ClickActionClickedCallback cb'
        connectSignalFunPtr obj "clicked" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction::clicked"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#g:signal:clicked"})

#endif

-- signal ClickAction::long-press
-- | The [longPress](#g:signal:longPress) signal is emitted during the long press gesture
-- handling.
-- 
-- This signal can be emitted multiple times with different states.
-- 
-- The 'GI.Clutter.Enums.LongPressStateQuery' state will be emitted on button presses,
-- and its return value will determine whether the long press handling
-- should be initiated. If the signal handlers will return 'P.True', the
-- 'GI.Clutter.Enums.LongPressStateQuery' state will be followed either by a signal
-- emission with the 'GI.Clutter.Enums.LongPressStateActivate' state if the long press
-- constraints were respected, or by a signal emission with the
-- 'GI.Clutter.Enums.LongPressStateCancel' state if the long press was cancelled.
-- 
-- It is possible to forcibly cancel a long press detection using
-- 'GI.Clutter.Objects.ClickAction.clickActionRelease'.
-- 
-- /Since: 1.8/
type ClickActionLongPressCallback =
    Clutter.Actor.Actor
    -- ^ /@actor@/: the t'GI.Clutter.Objects.Actor.Actor' attached to the /@action@/
    -> Clutter.Enums.LongPressState
    -- ^ /@state@/: the long press state
    -> IO Bool
    -- ^ __Returns:__ Only the 'GI.Clutter.Enums.LongPressStateQuery' state uses the
    --   returned value of the handler; other states will ignore it

type C_ClickActionLongPressCallback =
    Ptr ClickAction ->                      -- object
    Ptr Clutter.Actor.Actor ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_ClickActionLongPressCallback :: 
    GObject a => (a -> ClickActionLongPressCallback) ->
    C_ClickActionLongPressCallback
wrap_ClickActionLongPressCallback :: forall a.
GObject a =>
(a -> ClickActionLongPressCallback)
-> C_ClickActionLongPressCallback
wrap_ClickActionLongPressCallback a -> ClickActionLongPressCallback
gi'cb Ptr ClickAction
gi'selfPtr Ptr Actor
actor CUInt
state Ptr ()
_ = do
    Actor
actor' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Clutter.Actor.Actor) Ptr Actor
actor
    let state' :: LongPressState
state' = (Int -> LongPressState
forall a. Enum a => Int -> a
toEnum (Int -> LongPressState)
-> (CUInt -> Int) -> CUInt -> LongPressState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
state
    Bool
result <- Ptr ClickAction -> (ClickAction -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr ClickAction
gi'selfPtr ((ClickAction -> IO Bool) -> IO Bool)
-> (ClickAction -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \ClickAction
gi'self -> a -> ClickActionLongPressCallback
gi'cb (ClickAction -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ClickAction
gi'self)  Actor
actor' LongPressState
state'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [longPress](#signal:longPress) 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' clickAction #longPress callback
-- @
-- 
-- 
onClickActionLongPress :: (IsClickAction a, MonadIO m) => a -> ((?self :: a) => ClickActionLongPressCallback) -> m SignalHandlerId
onClickActionLongPress :: forall a (m :: * -> *).
(IsClickAction a, MonadIO m) =>
a
-> ((?self::a) => ClickActionLongPressCallback)
-> m SignalHandlerId
onClickActionLongPress a
obj (?self::a) => ClickActionLongPressCallback
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 -> ClickActionLongPressCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ClickActionLongPressCallback
ClickActionLongPressCallback
cb
    let wrapped' :: C_ClickActionLongPressCallback
wrapped' = (a -> ClickActionLongPressCallback)
-> C_ClickActionLongPressCallback
forall a.
GObject a =>
(a -> ClickActionLongPressCallback)
-> C_ClickActionLongPressCallback
wrap_ClickActionLongPressCallback a -> ClickActionLongPressCallback
wrapped
    FunPtr C_ClickActionLongPressCallback
wrapped'' <- C_ClickActionLongPressCallback
-> IO (FunPtr C_ClickActionLongPressCallback)
mk_ClickActionLongPressCallback C_ClickActionLongPressCallback
wrapped'
    a
-> Text
-> FunPtr C_ClickActionLongPressCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"long-press" FunPtr C_ClickActionLongPressCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [longPress](#signal:longPress) 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' clickAction #longPress 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.
-- 
afterClickActionLongPress :: (IsClickAction a, MonadIO m) => a -> ((?self :: a) => ClickActionLongPressCallback) -> m SignalHandlerId
afterClickActionLongPress :: forall a (m :: * -> *).
(IsClickAction a, MonadIO m) =>
a
-> ((?self::a) => ClickActionLongPressCallback)
-> m SignalHandlerId
afterClickActionLongPress a
obj (?self::a) => ClickActionLongPressCallback
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 -> ClickActionLongPressCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ClickActionLongPressCallback
ClickActionLongPressCallback
cb
    let wrapped' :: C_ClickActionLongPressCallback
wrapped' = (a -> ClickActionLongPressCallback)
-> C_ClickActionLongPressCallback
forall a.
GObject a =>
(a -> ClickActionLongPressCallback)
-> C_ClickActionLongPressCallback
wrap_ClickActionLongPressCallback a -> ClickActionLongPressCallback
wrapped
    FunPtr C_ClickActionLongPressCallback
wrapped'' <- C_ClickActionLongPressCallback
-> IO (FunPtr C_ClickActionLongPressCallback)
mk_ClickActionLongPressCallback C_ClickActionLongPressCallback
wrapped'
    a
-> Text
-> FunPtr C_ClickActionLongPressCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"long-press" FunPtr C_ClickActionLongPressCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ClickActionLongPressSignalInfo
instance SignalInfo ClickActionLongPressSignalInfo where
    type HaskellCallbackType ClickActionLongPressSignalInfo = ClickActionLongPressCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ClickActionLongPressCallback cb
        cb'' <- mk_ClickActionLongPressCallback cb'
        connectSignalFunPtr obj "long-press" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction::long-press"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#g:signal:longPress"})

#endif

-- VVV Prop "held"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@held@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' clickAction #held
-- @
getClickActionHeld :: (MonadIO m, IsClickAction o) => o -> m Bool
getClickActionHeld :: forall (m :: * -> *) o. (MonadIO m, IsClickAction o) => o -> m Bool
getClickActionHeld o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"held"

#if defined(ENABLE_OVERLOADING)
data ClickActionHeldPropertyInfo
instance AttrInfo ClickActionHeldPropertyInfo where
    type AttrAllowedOps ClickActionHeldPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ClickActionHeldPropertyInfo = IsClickAction
    type AttrSetTypeConstraint ClickActionHeldPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ClickActionHeldPropertyInfo = (~) ()
    type AttrTransferType ClickActionHeldPropertyInfo = ()
    type AttrGetType ClickActionHeldPropertyInfo = Bool
    type AttrLabel ClickActionHeldPropertyInfo = "held"
    type AttrOrigin ClickActionHeldPropertyInfo = ClickAction
    attrGet = getClickActionHeld
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.held"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#g:attr:held"
        })
#endif

-- VVV Prop "long-press-duration"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@long-press-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' clickAction #longPressDuration
-- @
getClickActionLongPressDuration :: (MonadIO m, IsClickAction o) => o -> m Int32
getClickActionLongPressDuration :: forall (m :: * -> *) o.
(MonadIO m, IsClickAction o) =>
o -> m Int32
getClickActionLongPressDuration o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"long-press-duration"

-- | Set the value of the “@long-press-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' clickAction [ #longPressDuration 'Data.GI.Base.Attributes.:=' value ]
-- @
setClickActionLongPressDuration :: (MonadIO m, IsClickAction o) => o -> Int32 -> m ()
setClickActionLongPressDuration :: forall (m :: * -> *) o.
(MonadIO m, IsClickAction o) =>
o -> Int32 -> m ()
setClickActionLongPressDuration o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"long-press-duration" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@long-press-duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructClickActionLongPressDuration :: (IsClickAction o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructClickActionLongPressDuration :: forall o (m :: * -> *).
(IsClickAction o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructClickActionLongPressDuration Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"long-press-duration" Int32
val

#if defined(ENABLE_OVERLOADING)
data ClickActionLongPressDurationPropertyInfo
instance AttrInfo ClickActionLongPressDurationPropertyInfo where
    type AttrAllowedOps ClickActionLongPressDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ClickActionLongPressDurationPropertyInfo = IsClickAction
    type AttrSetTypeConstraint ClickActionLongPressDurationPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ClickActionLongPressDurationPropertyInfo = (~) Int32
    type AttrTransferType ClickActionLongPressDurationPropertyInfo = Int32
    type AttrGetType ClickActionLongPressDurationPropertyInfo = Int32
    type AttrLabel ClickActionLongPressDurationPropertyInfo = "long-press-duration"
    type AttrOrigin ClickActionLongPressDurationPropertyInfo = ClickAction
    attrGet = getClickActionLongPressDuration
    attrSet = setClickActionLongPressDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructClickActionLongPressDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.longPressDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#g:attr:longPressDuration"
        })
#endif

-- VVV Prop "long-press-threshold"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@long-press-threshold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' clickAction #longPressThreshold
-- @
getClickActionLongPressThreshold :: (MonadIO m, IsClickAction o) => o -> m Int32
getClickActionLongPressThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsClickAction o) =>
o -> m Int32
getClickActionLongPressThreshold o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"long-press-threshold"

-- | Set the value of the “@long-press-threshold@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' clickAction [ #longPressThreshold 'Data.GI.Base.Attributes.:=' value ]
-- @
setClickActionLongPressThreshold :: (MonadIO m, IsClickAction o) => o -> Int32 -> m ()
setClickActionLongPressThreshold :: forall (m :: * -> *) o.
(MonadIO m, IsClickAction o) =>
o -> Int32 -> m ()
setClickActionLongPressThreshold o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"long-press-threshold" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@long-press-threshold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructClickActionLongPressThreshold :: (IsClickAction o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructClickActionLongPressThreshold :: forall o (m :: * -> *).
(IsClickAction o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructClickActionLongPressThreshold Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"long-press-threshold" Int32
val

#if defined(ENABLE_OVERLOADING)
data ClickActionLongPressThresholdPropertyInfo
instance AttrInfo ClickActionLongPressThresholdPropertyInfo where
    type AttrAllowedOps ClickActionLongPressThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ClickActionLongPressThresholdPropertyInfo = IsClickAction
    type AttrSetTypeConstraint ClickActionLongPressThresholdPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ClickActionLongPressThresholdPropertyInfo = (~) Int32
    type AttrTransferType ClickActionLongPressThresholdPropertyInfo = Int32
    type AttrGetType ClickActionLongPressThresholdPropertyInfo = Int32
    type AttrLabel ClickActionLongPressThresholdPropertyInfo = "long-press-threshold"
    type AttrOrigin ClickActionLongPressThresholdPropertyInfo = ClickAction
    attrGet = getClickActionLongPressThreshold
    attrSet = setClickActionLongPressThreshold
    attrTransfer _ v = do
        return v
    attrConstruct = constructClickActionLongPressThreshold
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.longPressThreshold"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#g:attr:longPressThreshold"
        })
#endif

-- VVV Prop "pressed"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@pressed@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' clickAction #pressed
-- @
getClickActionPressed :: (MonadIO m, IsClickAction o) => o -> m Bool
getClickActionPressed :: forall (m :: * -> *) o. (MonadIO m, IsClickAction o) => o -> m Bool
getClickActionPressed o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"pressed"

#if defined(ENABLE_OVERLOADING)
data ClickActionPressedPropertyInfo
instance AttrInfo ClickActionPressedPropertyInfo where
    type AttrAllowedOps ClickActionPressedPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ClickActionPressedPropertyInfo = IsClickAction
    type AttrSetTypeConstraint ClickActionPressedPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ClickActionPressedPropertyInfo = (~) ()
    type AttrTransferType ClickActionPressedPropertyInfo = ()
    type AttrGetType ClickActionPressedPropertyInfo = Bool
    type AttrLabel ClickActionPressedPropertyInfo = "pressed"
    type AttrOrigin ClickActionPressedPropertyInfo = ClickAction
    attrGet = getClickActionPressed
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.pressed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#g:attr:pressed"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ClickAction
type instance O.AttributeList ClickAction = ClickActionAttributeList
type ClickActionAttributeList = ('[ '("actor", Clutter.ActorMeta.ActorMetaActorPropertyInfo), '("enabled", Clutter.ActorMeta.ActorMetaEnabledPropertyInfo), '("held", ClickActionHeldPropertyInfo), '("longPressDuration", ClickActionLongPressDurationPropertyInfo), '("longPressThreshold", ClickActionLongPressThresholdPropertyInfo), '("name", Clutter.ActorMeta.ActorMetaNamePropertyInfo), '("pressed", ClickActionPressedPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
clickActionHeld :: AttrLabelProxy "held"
clickActionHeld = AttrLabelProxy

clickActionLongPressDuration :: AttrLabelProxy "longPressDuration"
clickActionLongPressDuration = AttrLabelProxy

clickActionLongPressThreshold :: AttrLabelProxy "longPressThreshold"
clickActionLongPressThreshold = AttrLabelProxy

clickActionPressed :: AttrLabelProxy "pressed"
clickActionPressed = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ClickAction = ClickActionSignalList
type ClickActionSignalList = ('[ '("clicked", ClickActionClickedSignalInfo), '("longPress", ClickActionLongPressSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "clutter_click_action_new" clutter_click_action_new :: 
    IO (Ptr ClickAction)

-- | Creates a new t'GI.Clutter.Objects.ClickAction.ClickAction' instance
-- 
-- /Since: 1.4/
clickActionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ClickAction
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.ClickAction.ClickAction'
clickActionNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ClickAction
clickActionNew  = IO ClickAction -> m ClickAction
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ClickAction -> m ClickAction)
-> IO ClickAction -> m ClickAction
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClickAction
result <- IO (Ptr ClickAction)
clutter_click_action_new
    Text -> Ptr ClickAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"clickActionNew" Ptr ClickAction
result
    ClickAction
result' <- ((ManagedPtr ClickAction -> ClickAction)
-> Ptr ClickAction -> IO ClickAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ClickAction -> ClickAction
ClickAction) Ptr ClickAction
result
    ClickAction -> IO ClickAction
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ClickAction
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ClickAction::get_button
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ClickAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterClickAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_click_action_get_button" clutter_click_action_get_button :: 
    Ptr ClickAction ->                      -- action : TInterface (Name {namespace = "Clutter", name = "ClickAction"})
    IO Word32

-- | Retrieves the button that was pressed.
-- 
-- /Since: 1.4/
clickActionGetButton ::
    (B.CallStack.HasCallStack, MonadIO m, IsClickAction a) =>
    a
    -- ^ /@action@/: a t'GI.Clutter.Objects.ClickAction.ClickAction'
    -> m Word32
    -- ^ __Returns:__ the button value
clickActionGetButton :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClickAction a) =>
a -> m Word32
clickActionGetButton a
action = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClickAction
action' <- a -> IO (Ptr ClickAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
    Word32
result <- Ptr ClickAction -> IO Word32
clutter_click_action_get_button Ptr ClickAction
action'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ClickActionGetButtonMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsClickAction a) => O.OverloadedMethod ClickActionGetButtonMethodInfo a signature where
    overloadedMethod = clickActionGetButton

instance O.OverloadedMethodInfo ClickActionGetButtonMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.clickActionGetButton",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#v:clickActionGetButton"
        })


#endif

-- method ClickAction::get_coords
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ClickAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterClickAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "press_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the X coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "press_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the Y coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_click_action_get_coords" clutter_click_action_get_coords :: 
    Ptr ClickAction ->                      -- action : TInterface (Name {namespace = "Clutter", name = "ClickAction"})
    Ptr CFloat ->                           -- press_x : TBasicType TFloat
    Ptr CFloat ->                           -- press_y : TBasicType TFloat
    IO ()

-- | Retrieves the screen coordinates of the button press.
-- 
-- /Since: 1.8/
clickActionGetCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsClickAction a) =>
    a
    -- ^ /@action@/: a t'GI.Clutter.Objects.ClickAction.ClickAction'
    -> m ((Float, Float))
clickActionGetCoords :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClickAction a) =>
a -> m (Float, Float)
clickActionGetCoords a
action = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClickAction
action' <- a -> IO (Ptr ClickAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
    Ptr CFloat
pressX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
pressY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr ClickAction -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_click_action_get_coords Ptr ClickAction
action' Ptr CFloat
pressX Ptr CFloat
pressY
    CFloat
pressX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
pressX
    let pressX'' :: Float
pressX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
pressX'
    CFloat
pressY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
pressY
    let pressY'' :: Float
pressY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
pressY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
pressX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
pressY
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
pressX'', Float
pressY'')

#if defined(ENABLE_OVERLOADING)
data ClickActionGetCoordsMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsClickAction a) => O.OverloadedMethod ClickActionGetCoordsMethodInfo a signature where
    overloadedMethod = clickActionGetCoords

instance O.OverloadedMethodInfo ClickActionGetCoordsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.clickActionGetCoords",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#v:clickActionGetCoords"
        })


#endif

-- method ClickAction::get_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ClickAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterClickAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "ModifierType" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_click_action_get_state" clutter_click_action_get_state :: 
    Ptr ClickAction ->                      -- action : TInterface (Name {namespace = "Clutter", name = "ClickAction"})
    IO CUInt

-- | Retrieves the modifier state of the click action.
-- 
-- /Since: 1.6/
clickActionGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsClickAction a) =>
    a
    -- ^ /@action@/: a t'GI.Clutter.Objects.ClickAction.ClickAction'
    -> m [Clutter.Flags.ModifierType]
    -- ^ __Returns:__ the modifier state parameter, or 0
clickActionGetState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClickAction a) =>
a -> m [ModifierType]
clickActionGetState a
action = IO [ModifierType] -> m [ModifierType]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ModifierType] -> m [ModifierType])
-> IO [ModifierType] -> m [ModifierType]
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClickAction
action' <- a -> IO (Ptr ClickAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
    CUInt
result <- Ptr ClickAction -> IO CUInt
clutter_click_action_get_state Ptr ClickAction
action'
    let result' :: [ModifierType]
result' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
    [ModifierType] -> IO [ModifierType]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ModifierType]
result'

#if defined(ENABLE_OVERLOADING)
data ClickActionGetStateMethodInfo
instance (signature ~ (m [Clutter.Flags.ModifierType]), MonadIO m, IsClickAction a) => O.OverloadedMethod ClickActionGetStateMethodInfo a signature where
    overloadedMethod = clickActionGetState

instance O.OverloadedMethodInfo ClickActionGetStateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.clickActionGetState",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#v:clickActionGetState"
        })


#endif

-- method ClickAction::release
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "action"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ClickAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterClickAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_click_action_release" clutter_click_action_release :: 
    Ptr ClickAction ->                      -- action : TInterface (Name {namespace = "Clutter", name = "ClickAction"})
    IO ()

-- | Emulates a release of the pointer button, which ungrabs the pointer
-- and unsets the [ClickAction:pressed]("GI.Clutter.Objects.ClickAction#g:attr:pressed") state.
-- 
-- This function will also cancel the long press gesture if one was
-- initiated.
-- 
-- This function is useful to break a grab, for instance after a certain
-- amount of time has passed.
-- 
-- /Since: 1.4/
clickActionRelease ::
    (B.CallStack.HasCallStack, MonadIO m, IsClickAction a) =>
    a
    -- ^ /@action@/: a t'GI.Clutter.Objects.ClickAction.ClickAction'
    -> m ()
clickActionRelease :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClickAction a) =>
a -> m ()
clickActionRelease a
action = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ClickAction
action' <- a -> IO (Ptr ClickAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
action
    Ptr ClickAction -> IO ()
clutter_click_action_release Ptr ClickAction
action'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
action
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ClickActionReleaseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsClickAction a) => O.OverloadedMethod ClickActionReleaseMethodInfo a signature where
    overloadedMethod = clickActionRelease

instance O.OverloadedMethodInfo ClickActionReleaseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.ClickAction.clickActionRelease",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Objects-ClickAction.html#v:clickActionRelease"
        })


#endif