{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress' is a t'GI.Gtk.Objects.Gesture.Gesture' implementation able to recognize
-- multiple clicks on a nearby zone, which can be listened for through the
-- [pressed]("GI.Gtk.Objects.GestureMultiPress#g:signal:pressed") signal. Whenever time or distance between
-- clicks exceed the GTK+ defaults, [stopped]("GI.Gtk.Objects.GestureMultiPress#g:signal:stopped") is emitted,
-- and the click counter is reset.
-- 
-- Callers may also restrict the area that is considered valid for a >1
-- touch\/button press through 'GI.Gtk.Objects.GestureMultiPress.gestureMultiPressSetArea', so any
-- click happening outside that area is considered to be a first click of
-- its own.

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

module GI.Gtk.Objects.GestureMultiPress
    ( 

-- * Exported types
    GestureMultiPress(..)                   ,
    IsGestureMultiPress                     ,
    toGestureMultiPress                     ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveGestureMultiPressMethod          ,
#endif


-- ** getArea #method:getArea#

#if defined(ENABLE_OVERLOADING)
    GestureMultiPressGetAreaMethodInfo      ,
#endif
    gestureMultiPressGetArea                ,


-- ** new #method:new#

    gestureMultiPressNew                    ,


-- ** setArea #method:setArea#

#if defined(ENABLE_OVERLOADING)
    GestureMultiPressSetAreaMethodInfo      ,
#endif
    gestureMultiPressSetArea                ,




 -- * Signals
-- ** pressed #signal:pressed#

    C_GestureMultiPressPressedCallback      ,
    GestureMultiPressPressedCallback        ,
#if defined(ENABLE_OVERLOADING)
    GestureMultiPressPressedSignalInfo      ,
#endif
    afterGestureMultiPressPressed           ,
    genClosure_GestureMultiPressPressed     ,
    mk_GestureMultiPressPressedCallback     ,
    noGestureMultiPressPressedCallback      ,
    onGestureMultiPressPressed              ,
    wrap_GestureMultiPressPressedCallback   ,


-- ** released #signal:released#

    C_GestureMultiPressReleasedCallback     ,
    GestureMultiPressReleasedCallback       ,
#if defined(ENABLE_OVERLOADING)
    GestureMultiPressReleasedSignalInfo     ,
#endif
    afterGestureMultiPressReleased          ,
    genClosure_GestureMultiPressReleased    ,
    mk_GestureMultiPressReleasedCallback    ,
    noGestureMultiPressReleasedCallback     ,
    onGestureMultiPressReleased             ,
    wrap_GestureMultiPressReleasedCallback  ,


-- ** stopped #signal:stopped#

    C_GestureMultiPressStoppedCallback      ,
    GestureMultiPressStoppedCallback        ,
#if defined(ENABLE_OVERLOADING)
    GestureMultiPressStoppedSignalInfo      ,
#endif
    afterGestureMultiPressStopped           ,
    genClosure_GestureMultiPressStopped     ,
    mk_GestureMultiPressStoppedCallback     ,
    noGestureMultiPressStoppedCallback      ,
    onGestureMultiPressStopped              ,
    wrap_GestureMultiPressStoppedCallback   ,




    ) 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.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.Text as T
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
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.Widget as Gtk.Widget

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

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

foreign import ccall "gtk_gesture_multi_press_get_type"
    c_gtk_gesture_multi_press_get_type :: IO B.Types.GType

instance B.Types.TypedObject GestureMultiPress where
    glibType :: IO GType
glibType = IO GType
c_gtk_gesture_multi_press_get_type

instance B.Types.GObject GestureMultiPress

-- | Convert 'GestureMultiPress' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue GestureMultiPress where
    toGValue :: GestureMultiPress -> IO GValue
toGValue GestureMultiPress
o = do
        GType
gtype <- IO GType
c_gtk_gesture_multi_press_get_type
        GestureMultiPress
-> (Ptr GestureMultiPress -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr GestureMultiPress
o (GType
-> (GValue -> Ptr GestureMultiPress -> IO ())
-> Ptr GestureMultiPress
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr GestureMultiPress -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO GestureMultiPress
fromGValue GValue
gv = do
        Ptr GestureMultiPress
ptr <- GValue -> IO (Ptr GestureMultiPress)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr GestureMultiPress)
        (ManagedPtr GestureMultiPress -> GestureMultiPress)
-> Ptr GestureMultiPress -> IO GestureMultiPress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr GestureMultiPress -> GestureMultiPress
GestureMultiPress Ptr GestureMultiPress
ptr
        
    

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveGestureMultiPressMethod (t :: Symbol) (o :: *) :: * where
    ResolveGestureMultiPressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveGestureMultiPressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveGestureMultiPressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveGestureMultiPressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveGestureMultiPressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveGestureMultiPressMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo
    ResolveGestureMultiPressMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo
    ResolveGestureMultiPressMethod "handlesSequence" o = Gtk.Gesture.GestureHandlesSequenceMethodInfo
    ResolveGestureMultiPressMethod "isActive" o = Gtk.Gesture.GestureIsActiveMethodInfo
    ResolveGestureMultiPressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveGestureMultiPressMethod "isGroupedWith" o = Gtk.Gesture.GestureIsGroupedWithMethodInfo
    ResolveGestureMultiPressMethod "isRecognized" o = Gtk.Gesture.GestureIsRecognizedMethodInfo
    ResolveGestureMultiPressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveGestureMultiPressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveGestureMultiPressMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveGestureMultiPressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveGestureMultiPressMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
    ResolveGestureMultiPressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveGestureMultiPressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveGestureMultiPressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveGestureMultiPressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveGestureMultiPressMethod "ungroup" o = Gtk.Gesture.GestureUngroupMethodInfo
    ResolveGestureMultiPressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveGestureMultiPressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveGestureMultiPressMethod "getArea" o = GestureMultiPressGetAreaMethodInfo
    ResolveGestureMultiPressMethod "getBoundingBox" o = Gtk.Gesture.GestureGetBoundingBoxMethodInfo
    ResolveGestureMultiPressMethod "getBoundingBoxCenter" o = Gtk.Gesture.GestureGetBoundingBoxCenterMethodInfo
    ResolveGestureMultiPressMethod "getButton" o = Gtk.GestureSingle.GestureSingleGetButtonMethodInfo
    ResolveGestureMultiPressMethod "getCurrentButton" o = Gtk.GestureSingle.GestureSingleGetCurrentButtonMethodInfo
    ResolveGestureMultiPressMethod "getCurrentSequence" o = Gtk.GestureSingle.GestureSingleGetCurrentSequenceMethodInfo
    ResolveGestureMultiPressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveGestureMultiPressMethod "getDevice" o = Gtk.Gesture.GestureGetDeviceMethodInfo
    ResolveGestureMultiPressMethod "getExclusive" o = Gtk.GestureSingle.GestureSingleGetExclusiveMethodInfo
    ResolveGestureMultiPressMethod "getGroup" o = Gtk.Gesture.GestureGetGroupMethodInfo
    ResolveGestureMultiPressMethod "getLastEvent" o = Gtk.Gesture.GestureGetLastEventMethodInfo
    ResolveGestureMultiPressMethod "getLastUpdatedSequence" o = Gtk.Gesture.GestureGetLastUpdatedSequenceMethodInfo
    ResolveGestureMultiPressMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo
    ResolveGestureMultiPressMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
    ResolveGestureMultiPressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveGestureMultiPressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveGestureMultiPressMethod "getSequenceState" o = Gtk.Gesture.GestureGetSequenceStateMethodInfo
    ResolveGestureMultiPressMethod "getSequences" o = Gtk.Gesture.GestureGetSequencesMethodInfo
    ResolveGestureMultiPressMethod "getTouchOnly" o = Gtk.GestureSingle.GestureSingleGetTouchOnlyMethodInfo
    ResolveGestureMultiPressMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
    ResolveGestureMultiPressMethod "getWindow" o = Gtk.Gesture.GestureGetWindowMethodInfo
    ResolveGestureMultiPressMethod "setArea" o = GestureMultiPressSetAreaMethodInfo
    ResolveGestureMultiPressMethod "setButton" o = Gtk.GestureSingle.GestureSingleSetButtonMethodInfo
    ResolveGestureMultiPressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveGestureMultiPressMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveGestureMultiPressMethod "setExclusive" o = Gtk.GestureSingle.GestureSingleSetExclusiveMethodInfo
    ResolveGestureMultiPressMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
    ResolveGestureMultiPressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveGestureMultiPressMethod "setSequenceState" o = Gtk.Gesture.GestureSetSequenceStateMethodInfo
    ResolveGestureMultiPressMethod "setState" o = Gtk.Gesture.GestureSetStateMethodInfo
    ResolveGestureMultiPressMethod "setTouchOnly" o = Gtk.GestureSingle.GestureSingleSetTouchOnlyMethodInfo
    ResolveGestureMultiPressMethod "setWindow" o = Gtk.Gesture.GestureSetWindowMethodInfo
    ResolveGestureMultiPressMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal GestureMultiPress::pressed
-- | This signal is emitted whenever a button or touch press happens.
-- 
-- /Since: 3.14/
type GestureMultiPressPressedCallback =
    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 ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GestureMultiPressPressedCallback`@.
noGestureMultiPressPressedCallback :: Maybe GestureMultiPressPressedCallback
noGestureMultiPressPressedCallback :: Maybe GestureMultiPressPressedCallback
noGestureMultiPressPressedCallback = Maybe GestureMultiPressPressedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_GestureMultiPressPressedCallback =
    Ptr () ->                               -- object
    Int32 ->
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_GestureMultiPressPressed :: MonadIO m => GestureMultiPressPressedCallback -> m (GClosure C_GestureMultiPressPressedCallback)
genClosure_GestureMultiPressPressed :: GestureMultiPressPressedCallback
-> m (GClosure C_GestureMultiPressPressedCallback)
genClosure_GestureMultiPressPressed GestureMultiPressPressedCallback
cb = IO (GClosure C_GestureMultiPressPressedCallback)
-> m (GClosure C_GestureMultiPressPressedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GestureMultiPressPressedCallback)
 -> m (GClosure C_GestureMultiPressPressedCallback))
-> IO (GClosure C_GestureMultiPressPressedCallback)
-> m (GClosure C_GestureMultiPressPressedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GestureMultiPressPressedCallback
cb' = GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback GestureMultiPressPressedCallback
cb
    C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressPressedCallback C_GestureMultiPressPressedCallback
cb' IO (FunPtr C_GestureMultiPressPressedCallback)
-> (FunPtr C_GestureMultiPressPressedCallback
    -> IO (GClosure C_GestureMultiPressPressedCallback))
-> IO (GClosure C_GestureMultiPressPressedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GestureMultiPressPressedCallback
-> IO (GClosure C_GestureMultiPressPressedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GestureMultiPressPressedCallback` into a `C_GestureMultiPressPressedCallback`.
wrap_GestureMultiPressPressedCallback ::
    GestureMultiPressPressedCallback ->
    C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback :: GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback GestureMultiPressPressedCallback
_cb Ptr ()
_ 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
    GestureMultiPressPressedCallback
_cb  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' gestureMultiPress #pressed callback
-- @
-- 
-- 
onGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId
onGestureMultiPressPressed :: a -> GestureMultiPressPressedCallback -> m SignalHandlerId
onGestureMultiPressPressed a
obj GestureMultiPressPressedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_GestureMultiPressPressedCallback
cb' = GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback GestureMultiPressPressedCallback
cb
    FunPtr C_GestureMultiPressPressedCallback
cb'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressPressedCallback C_GestureMultiPressPressedCallback
cb'
    a
-> Text
-> FunPtr C_GestureMultiPressPressedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pressed" FunPtr C_GestureMultiPressPressedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
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' gestureMultiPress #pressed callback
-- @
-- 
-- 
afterGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId
afterGestureMultiPressPressed :: a -> GestureMultiPressPressedCallback -> m SignalHandlerId
afterGestureMultiPressPressed a
obj GestureMultiPressPressedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_GestureMultiPressPressedCallback
cb' = GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback GestureMultiPressPressedCallback
cb
    FunPtr C_GestureMultiPressPressedCallback
cb'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressPressedCallback C_GestureMultiPressPressedCallback
cb'
    a
-> Text
-> FunPtr C_GestureMultiPressPressedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pressed" FunPtr C_GestureMultiPressPressedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GestureMultiPressPressedSignalInfo
instance SignalInfo GestureMultiPressPressedSignalInfo where
    type HaskellCallbackType GestureMultiPressPressedSignalInfo = GestureMultiPressPressedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GestureMultiPressPressedCallback cb
        cb'' <- mk_GestureMultiPressPressedCallback cb'
        connectSignalFunPtr obj "pressed" cb'' connectMode detail

#endif

-- signal GestureMultiPress::released
-- | This signal is emitted when a button or touch is released. /@nPress@/
-- will report the number of press that is paired to this event, note
-- that [stopped]("GI.Gtk.Objects.GestureMultiPress#g:signal:stopped") may have been emitted between the
-- press and its release, /@nPress@/ will only start over at the next press.
-- 
-- /Since: 3.14/
type GestureMultiPressReleasedCallback =
    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 ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GestureMultiPressReleasedCallback`@.
noGestureMultiPressReleasedCallback :: Maybe GestureMultiPressReleasedCallback
noGestureMultiPressReleasedCallback :: Maybe GestureMultiPressPressedCallback
noGestureMultiPressReleasedCallback = Maybe GestureMultiPressPressedCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_GestureMultiPressReleasedCallback =
    Ptr () ->                               -- object
    Int32 ->
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_GestureMultiPressReleased :: MonadIO m => GestureMultiPressReleasedCallback -> m (GClosure C_GestureMultiPressReleasedCallback)
genClosure_GestureMultiPressReleased :: GestureMultiPressPressedCallback
-> m (GClosure C_GestureMultiPressPressedCallback)
genClosure_GestureMultiPressReleased GestureMultiPressPressedCallback
cb = IO (GClosure C_GestureMultiPressPressedCallback)
-> m (GClosure C_GestureMultiPressPressedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GestureMultiPressPressedCallback)
 -> m (GClosure C_GestureMultiPressPressedCallback))
-> IO (GClosure C_GestureMultiPressPressedCallback)
-> m (GClosure C_GestureMultiPressPressedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GestureMultiPressPressedCallback
cb' = GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressReleasedCallback GestureMultiPressPressedCallback
cb
    C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressReleasedCallback C_GestureMultiPressPressedCallback
cb' IO (FunPtr C_GestureMultiPressPressedCallback)
-> (FunPtr C_GestureMultiPressPressedCallback
    -> IO (GClosure C_GestureMultiPressPressedCallback))
-> IO (GClosure C_GestureMultiPressPressedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GestureMultiPressPressedCallback
-> IO (GClosure C_GestureMultiPressPressedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GestureMultiPressReleasedCallback` into a `C_GestureMultiPressReleasedCallback`.
wrap_GestureMultiPressReleasedCallback ::
    GestureMultiPressReleasedCallback ->
    C_GestureMultiPressReleasedCallback
wrap_GestureMultiPressReleasedCallback :: GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressReleasedCallback GestureMultiPressPressedCallback
_cb Ptr ()
_ 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
    GestureMultiPressPressedCallback
_cb  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' gestureMultiPress #released callback
-- @
-- 
-- 
onGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId
onGestureMultiPressReleased :: a -> GestureMultiPressPressedCallback -> m SignalHandlerId
onGestureMultiPressReleased a
obj GestureMultiPressPressedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_GestureMultiPressPressedCallback
cb' = GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressReleasedCallback GestureMultiPressPressedCallback
cb
    FunPtr C_GestureMultiPressPressedCallback
cb'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressReleasedCallback C_GestureMultiPressPressedCallback
cb'
    a
-> Text
-> FunPtr C_GestureMultiPressPressedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"released" FunPtr C_GestureMultiPressPressedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
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' gestureMultiPress #released callback
-- @
-- 
-- 
afterGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId
afterGestureMultiPressReleased :: a -> GestureMultiPressPressedCallback -> m SignalHandlerId
afterGestureMultiPressReleased a
obj GestureMultiPressPressedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_GestureMultiPressPressedCallback
cb' = GestureMultiPressPressedCallback
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressReleasedCallback GestureMultiPressPressedCallback
cb
    FunPtr C_GestureMultiPressPressedCallback
cb'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressReleasedCallback C_GestureMultiPressPressedCallback
cb'
    a
-> Text
-> FunPtr C_GestureMultiPressPressedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"released" FunPtr C_GestureMultiPressPressedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GestureMultiPressReleasedSignalInfo
instance SignalInfo GestureMultiPressReleasedSignalInfo where
    type HaskellCallbackType GestureMultiPressReleasedSignalInfo = GestureMultiPressReleasedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GestureMultiPressReleasedCallback cb
        cb'' <- mk_GestureMultiPressReleasedCallback cb'
        connectSignalFunPtr obj "released" cb'' connectMode detail

#endif

-- signal GestureMultiPress::stopped
-- | This signal is emitted whenever any time\/distance threshold has
-- been exceeded.
-- 
-- /Since: 3.14/
type GestureMultiPressStoppedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `GestureMultiPressStoppedCallback`@.
noGestureMultiPressStoppedCallback :: Maybe GestureMultiPressStoppedCallback
noGestureMultiPressStoppedCallback :: Maybe (IO ())
noGestureMultiPressStoppedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_GestureMultiPressStoppedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_GestureMultiPressStopped :: MonadIO m => GestureMultiPressStoppedCallback -> m (GClosure C_GestureMultiPressStoppedCallback)
genClosure_GestureMultiPressStopped :: IO () -> m (GClosure C_GestureMultiPressStoppedCallback)
genClosure_GestureMultiPressStopped IO ()
cb = IO (GClosure C_GestureMultiPressStoppedCallback)
-> m (GClosure C_GestureMultiPressStoppedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_GestureMultiPressStoppedCallback)
 -> m (GClosure C_GestureMultiPressStoppedCallback))
-> IO (GClosure C_GestureMultiPressStoppedCallback)
-> m (GClosure C_GestureMultiPressStoppedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_GestureMultiPressStoppedCallback
cb' = IO () -> C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback IO ()
cb
    C_GestureMultiPressStoppedCallback
-> IO (FunPtr C_GestureMultiPressStoppedCallback)
mk_GestureMultiPressStoppedCallback C_GestureMultiPressStoppedCallback
cb' IO (FunPtr C_GestureMultiPressStoppedCallback)
-> (FunPtr C_GestureMultiPressStoppedCallback
    -> IO (GClosure C_GestureMultiPressStoppedCallback))
-> IO (GClosure C_GestureMultiPressStoppedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_GestureMultiPressStoppedCallback
-> IO (GClosure C_GestureMultiPressStoppedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `GestureMultiPressStoppedCallback` into a `C_GestureMultiPressStoppedCallback`.
wrap_GestureMultiPressStoppedCallback ::
    GestureMultiPressStoppedCallback ->
    C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback :: IO () -> C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | 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' gestureMultiPress #stopped callback
-- @
-- 
-- 
onGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId
onGestureMultiPressStopped :: a -> IO () -> m SignalHandlerId
onGestureMultiPressStopped a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_GestureMultiPressStoppedCallback
cb' = IO () -> C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback IO ()
cb
    FunPtr C_GestureMultiPressStoppedCallback
cb'' <- C_GestureMultiPressStoppedCallback
-> IO (FunPtr C_GestureMultiPressStoppedCallback)
mk_GestureMultiPressStoppedCallback C_GestureMultiPressStoppedCallback
cb'
    a
-> Text
-> FunPtr C_GestureMultiPressStoppedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"stopped" FunPtr C_GestureMultiPressStoppedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
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' gestureMultiPress #stopped callback
-- @
-- 
-- 
afterGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId
afterGestureMultiPressStopped :: a -> IO () -> m SignalHandlerId
afterGestureMultiPressStopped a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_GestureMultiPressStoppedCallback
cb' = IO () -> C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback IO ()
cb
    FunPtr C_GestureMultiPressStoppedCallback
cb'' <- C_GestureMultiPressStoppedCallback
-> IO (FunPtr C_GestureMultiPressStoppedCallback)
mk_GestureMultiPressStoppedCallback C_GestureMultiPressStoppedCallback
cb'
    a
-> Text
-> FunPtr C_GestureMultiPressStoppedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"stopped" FunPtr C_GestureMultiPressStoppedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GestureMultiPressStoppedSignalInfo
instance SignalInfo GestureMultiPressStoppedSignalInfo where
    type HaskellCallbackType GestureMultiPressStoppedSignalInfo = GestureMultiPressStoppedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GestureMultiPressStoppedCallback cb
        cb'' <- mk_GestureMultiPressStoppedCallback cb'
        connectSignalFunPtr obj "stopped" cb'' connectMode detail

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList GestureMultiPress
type instance O.AttributeList GestureMultiPress = GestureMultiPressAttributeList
type GestureMultiPressAttributeList = ('[ '("button", Gtk.GestureSingle.GestureSingleButtonPropertyInfo), '("exclusive", Gtk.GestureSingle.GestureSingleExclusivePropertyInfo), '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("touchOnly", Gtk.GestureSingle.GestureSingleTouchOnlyPropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo), '("window", Gtk.Gesture.GestureWindowPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList GestureMultiPress = GestureMultiPressSignalList
type GestureMultiPressSignalList = ('[ '("begin", Gtk.Gesture.GestureBeginSignalInfo), '("cancel", Gtk.Gesture.GestureCancelSignalInfo), '("end", Gtk.Gesture.GestureEndSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pressed", GestureMultiPressPressedSignalInfo), '("released", GestureMultiPressReleasedSignalInfo), '("sequenceStateChanged", Gtk.Gesture.GestureSequenceStateChangedSignalInfo), '("stopped", GestureMultiPressStoppedSignalInfo), '("update", Gtk.Gesture.GestureUpdateSignalInfo)] :: [(Symbol, *)])

#endif

-- method GestureMultiPress::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gtk" , name = "GestureMultiPress" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_multi_press_new" gtk_gesture_multi_press_new :: 
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr GestureMultiPress)

-- | Returns a newly created t'GI.Gtk.Objects.Gesture.Gesture' that recognizes single and multiple
-- presses.
-- 
-- /Since: 3.14/
gestureMultiPressNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>
    a
    -- ^ /@widget@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> m GestureMultiPress
    -- ^ __Returns:__ a newly created t'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'
gestureMultiPressNew :: a -> m GestureMultiPress
gestureMultiPressNew a
widget = IO GestureMultiPress -> m GestureMultiPress
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GestureMultiPress -> m GestureMultiPress)
-> IO GestureMultiPress -> m GestureMultiPress
forall a b. (a -> b) -> a -> b
$ do
    Ptr Widget
widget' <- a -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
widget
    Ptr GestureMultiPress
result <- Ptr Widget -> IO (Ptr GestureMultiPress)
gtk_gesture_multi_press_new Ptr Widget
widget'
    Text -> Ptr GestureMultiPress -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gestureMultiPressNew" Ptr GestureMultiPress
result
    GestureMultiPress
result' <- ((ManagedPtr GestureMultiPress -> GestureMultiPress)
-> Ptr GestureMultiPress -> IO GestureMultiPress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr GestureMultiPress -> GestureMultiPress
GestureMultiPress) Ptr GestureMultiPress
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
widget
    GestureMultiPress -> IO GestureMultiPress
forall (m :: * -> *) a. Monad m => a -> m a
return GestureMultiPress
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method GestureMultiPress::get_area
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gesture"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GestureMultiPress" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGestureMultiPress"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rect"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the press area"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_multi_press_get_area" gtk_gesture_multi_press_get_area :: 
    Ptr GestureMultiPress ->                -- gesture : TInterface (Name {namespace = "Gtk", name = "GestureMultiPress"})
    Ptr Gdk.Rectangle.Rectangle ->          -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO CInt

-- | If an area was set through 'GI.Gtk.Objects.GestureMultiPress.gestureMultiPressSetArea',
-- this function will return 'P.True' and fill in /@rect@/ with the
-- press area. See 'GI.Gtk.Objects.GestureMultiPress.gestureMultiPressSetArea' for more
-- details on what the press area represents.
-- 
-- /Since: 3.14/
gestureMultiPressGetArea ::
    (B.CallStack.HasCallStack, MonadIO m, IsGestureMultiPress a) =>
    a
    -- ^ /@gesture@/: a t'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'
    -> m ((Bool, Gdk.Rectangle.Rectangle))
    -- ^ __Returns:__ 'P.True' if /@rect@/ was filled with the press area
gestureMultiPressGetArea :: a -> m (Bool, Rectangle)
gestureMultiPressGetArea a
gesture = IO (Bool, Rectangle) -> m (Bool, Rectangle)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Rectangle) -> m (Bool, Rectangle))
-> IO (Bool, Rectangle) -> m (Bool, Rectangle)
forall a b. (a -> b) -> a -> b
$ do
    Ptr GestureMultiPress
gesture' <- a -> IO (Ptr GestureMultiPress)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gesture
    Ptr Rectangle
rect <- Int -> IO (Ptr Rectangle)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    CInt
result <- Ptr GestureMultiPress -> Ptr Rectangle -> IO CInt
gtk_gesture_multi_press_get_area Ptr GestureMultiPress
gesture' Ptr Rectangle
rect
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Rectangle
rect' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle) Ptr Rectangle
rect
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gesture
    (Bool, Rectangle) -> IO (Bool, Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Rectangle
rect')

#if defined(ENABLE_OVERLOADING)
data GestureMultiPressGetAreaMethodInfo
instance (signature ~ (m ((Bool, Gdk.Rectangle.Rectangle))), MonadIO m, IsGestureMultiPress a) => O.MethodInfo GestureMultiPressGetAreaMethodInfo a signature where
    overloadedMethod = gestureMultiPressGetArea

#endif

-- method GestureMultiPress::set_area
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "gesture"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "GestureMultiPress" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkGestureMultiPress"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rect"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "rectangle to receive coordinates on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_multi_press_set_area" gtk_gesture_multi_press_set_area :: 
    Ptr GestureMultiPress ->                -- gesture : TInterface (Name {namespace = "Gtk", name = "GestureMultiPress"})
    Ptr Gdk.Rectangle.Rectangle ->          -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

-- | If /@rect@/ is non-'P.Nothing', the press area will be checked to be
-- confined within the rectangle, otherwise the button count
-- will be reset so the press is seen as being the first one.
-- If /@rect@/ is 'P.Nothing', the area will be reset to an unrestricted
-- state.
-- 
-- Note: The rectangle is only used to determine whether any
-- non-first click falls within the expected area. This is not
-- akin to an input shape.
-- 
-- /Since: 3.14/
gestureMultiPressSetArea ::
    (B.CallStack.HasCallStack, MonadIO m, IsGestureMultiPress a) =>
    a
    -- ^ /@gesture@/: a t'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'
    -> Maybe (Gdk.Rectangle.Rectangle)
    -- ^ /@rect@/: rectangle to receive coordinates on
    -> m ()
gestureMultiPressSetArea :: a -> Maybe Rectangle -> m ()
gestureMultiPressSetArea a
gesture Maybe Rectangle
rect = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr GestureMultiPress
gesture' <- a -> IO (Ptr GestureMultiPress)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gesture
    Ptr Rectangle
maybeRect <- case Maybe Rectangle
rect of
        Maybe Rectangle
Nothing -> Ptr Rectangle -> IO (Ptr Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rectangle
forall a. Ptr a
nullPtr
        Just Rectangle
jRect -> do
            Ptr Rectangle
jRect' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
jRect
            Ptr Rectangle -> IO (Ptr Rectangle)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rectangle
jRect'
    Ptr GestureMultiPress -> Ptr Rectangle -> IO ()
gtk_gesture_multi_press_set_area Ptr GestureMultiPress
gesture' Ptr Rectangle
maybeRect
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gesture
    Maybe Rectangle -> (Rectangle -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Rectangle
rect Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data GestureMultiPressSetAreaMethodInfo
instance (signature ~ (Maybe (Gdk.Rectangle.Rectangle) -> m ()), MonadIO m, IsGestureMultiPress a) => O.MethodInfo GestureMultiPressSetAreaMethodInfo a signature where
    overloadedMethod = gestureMultiPressSetArea

#endif