{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress' is a 'GI.Gtk.Objects.Gesture.Gesture' implementation able to recognize
multiple clicks on a nearby zone, which can be listened for through the
'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'::@/pressed/@ signal. Whenever time or distance between
clicks exceed the GTK+ defaults, 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'::@/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.
-}

module GI.Gtk.Objects.GestureMultiPress
    ( 

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


 -- * Methods
-- ** getArea #method:getArea#
    GestureMultiPressGetAreaMethodInfo      ,
    gestureMultiPressGetArea                ,


-- ** new #method:new#
    gestureMultiPressNew                    ,


-- ** setArea #method:setArea#
    GestureMultiPressSetAreaMethodInfo      ,
    gestureMultiPressSetArea                ,




 -- * Signals
-- ** pressed #signal:pressed#
    C_GestureMultiPressPressedCallback      ,
    GestureMultiPressPressedCallback        ,
    GestureMultiPressPressedSignalInfo      ,
    afterGestureMultiPressPressed           ,
    genClosure_GestureMultiPressPressed     ,
    mk_GestureMultiPressPressedCallback     ,
    noGestureMultiPressPressedCallback      ,
    onGestureMultiPressPressed              ,
    wrap_GestureMultiPressPressedCallback   ,


-- ** released #signal:released#
    C_GestureMultiPressReleasedCallback     ,
    GestureMultiPressReleasedCallback       ,
    GestureMultiPressReleasedSignalInfo     ,
    afterGestureMultiPressReleased          ,
    genClosure_GestureMultiPressReleased    ,
    mk_GestureMultiPressReleasedCallback    ,
    noGestureMultiPressReleasedCallback     ,
    onGestureMultiPressReleased             ,
    wrap_GestureMultiPressReleasedCallback  ,


-- ** stopped #signal:stopped#
    C_GestureMultiPressStoppedCallback      ,
    GestureMultiPressStoppedCallback        ,
    GestureMultiPressStoppedSignalInfo      ,
    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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 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

newtype GestureMultiPress = GestureMultiPress (ManagedPtr GestureMultiPress)
foreign import ccall "gtk_gesture_multi_press_get_type"
    c_gtk_gesture_multi_press_get_type :: IO GType

instance GObject GestureMultiPress where
    gobjectType _ = c_gtk_gesture_multi_press_get_type
    

class GObject o => IsGestureMultiPress o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError GestureMultiPress a) =>
    IsGestureMultiPress a
#endif
instance IsGestureMultiPress GestureMultiPress
instance Gtk.GestureSingle.IsGestureSingle GestureMultiPress
instance Gtk.Gesture.IsGesture GestureMultiPress
instance Gtk.EventController.IsEventController GestureMultiPress
instance GObject.Object.IsObject GestureMultiPress

toGestureMultiPress :: IsGestureMultiPress o => o -> IO GestureMultiPress
toGestureMultiPress = unsafeCastTo GestureMultiPress

noGestureMultiPress :: Maybe GestureMultiPress
noGestureMultiPress = Nothing

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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveGestureMultiPressMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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 "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) => O.IsLabelProxy t (GestureMultiPress -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveGestureMultiPressMethod t GestureMultiPress, O.MethodInfo info GestureMultiPress p) => O.IsLabel t (GestureMultiPress -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal GestureMultiPress::pressed
type GestureMultiPressPressedCallback =
    Int32 ->
    Double ->
    Double ->
    IO ()

noGestureMultiPressPressedCallback :: Maybe GestureMultiPressPressedCallback
noGestureMultiPressPressedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_GestureMultiPressPressedCallback :: C_GestureMultiPressPressedCallback -> IO (FunPtr C_GestureMultiPressPressedCallback)

genClosure_GestureMultiPressPressed :: GestureMultiPressPressedCallback -> IO Closure
genClosure_GestureMultiPressPressed cb = do
    let cb' = wrap_GestureMultiPressPressedCallback cb
    mk_GestureMultiPressPressedCallback cb' >>= newCClosure


wrap_GestureMultiPressPressedCallback ::
    GestureMultiPressPressedCallback ->
    Ptr () ->
    Int32 ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
wrap_GestureMultiPressPressedCallback _cb _ nPress x y _ = do
    let x' = realToFrac x
    let y' = realToFrac y
    _cb  nPress x' y'


onGestureMultiPressPressed :: (GObject a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId
onGestureMultiPressPressed obj cb = liftIO $ connectGestureMultiPressPressed obj cb SignalConnectBefore
afterGestureMultiPressPressed :: (GObject a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId
afterGestureMultiPressPressed obj cb = connectGestureMultiPressPressed obj cb SignalConnectAfter

connectGestureMultiPressPressed :: (GObject a, MonadIO m) =>
                                   a -> GestureMultiPressPressedCallback -> SignalConnectMode -> m SignalHandlerId
connectGestureMultiPressPressed obj cb after = liftIO $ do
    let cb' = wrap_GestureMultiPressPressedCallback cb
    cb'' <- mk_GestureMultiPressPressedCallback cb'
    connectSignalFunPtr obj "pressed" cb'' after

-- signal GestureMultiPress::released
type GestureMultiPressReleasedCallback =
    Int32 ->
    Double ->
    Double ->
    IO ()

noGestureMultiPressReleasedCallback :: Maybe GestureMultiPressReleasedCallback
noGestureMultiPressReleasedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_GestureMultiPressReleasedCallback :: C_GestureMultiPressReleasedCallback -> IO (FunPtr C_GestureMultiPressReleasedCallback)

genClosure_GestureMultiPressReleased :: GestureMultiPressReleasedCallback -> IO Closure
genClosure_GestureMultiPressReleased cb = do
    let cb' = wrap_GestureMultiPressReleasedCallback cb
    mk_GestureMultiPressReleasedCallback cb' >>= newCClosure


wrap_GestureMultiPressReleasedCallback ::
    GestureMultiPressReleasedCallback ->
    Ptr () ->
    Int32 ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
wrap_GestureMultiPressReleasedCallback _cb _ nPress x y _ = do
    let x' = realToFrac x
    let y' = realToFrac y
    _cb  nPress x' y'


onGestureMultiPressReleased :: (GObject a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId
onGestureMultiPressReleased obj cb = liftIO $ connectGestureMultiPressReleased obj cb SignalConnectBefore
afterGestureMultiPressReleased :: (GObject a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId
afterGestureMultiPressReleased obj cb = connectGestureMultiPressReleased obj cb SignalConnectAfter

connectGestureMultiPressReleased :: (GObject a, MonadIO m) =>
                                    a -> GestureMultiPressReleasedCallback -> SignalConnectMode -> m SignalHandlerId
connectGestureMultiPressReleased obj cb after = liftIO $ do
    let cb' = wrap_GestureMultiPressReleasedCallback cb
    cb'' <- mk_GestureMultiPressReleasedCallback cb'
    connectSignalFunPtr obj "released" cb'' after

-- signal GestureMultiPress::stopped
type GestureMultiPressStoppedCallback =
    IO ()

noGestureMultiPressStoppedCallback :: Maybe GestureMultiPressStoppedCallback
noGestureMultiPressStoppedCallback = Nothing

type C_GestureMultiPressStoppedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_GestureMultiPressStoppedCallback :: C_GestureMultiPressStoppedCallback -> IO (FunPtr C_GestureMultiPressStoppedCallback)

genClosure_GestureMultiPressStopped :: GestureMultiPressStoppedCallback -> IO Closure
genClosure_GestureMultiPressStopped cb = do
    let cb' = wrap_GestureMultiPressStoppedCallback cb
    mk_GestureMultiPressStoppedCallback cb' >>= newCClosure


wrap_GestureMultiPressStoppedCallback ::
    GestureMultiPressStoppedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_GestureMultiPressStoppedCallback _cb _ _ = do
    _cb 


onGestureMultiPressStopped :: (GObject a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId
onGestureMultiPressStopped obj cb = liftIO $ connectGestureMultiPressStopped obj cb SignalConnectBefore
afterGestureMultiPressStopped :: (GObject a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId
afterGestureMultiPressStopped obj cb = connectGestureMultiPressStopped obj cb SignalConnectAfter

connectGestureMultiPressStopped :: (GObject a, MonadIO m) =>
                                   a -> GestureMultiPressStoppedCallback -> SignalConnectMode -> m SignalHandlerId
connectGestureMultiPressStopped obj cb after = liftIO $ do
    let cb' = wrap_GestureMultiPressStoppedCallback cb
    cb'' <- mk_GestureMultiPressStoppedCallback cb'
    connectSignalFunPtr obj "stopped" cb'' after

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, *)])

data GestureMultiPressPressedSignalInfo
instance SignalInfo GestureMultiPressPressedSignalInfo where
    type HaskellCallbackType GestureMultiPressPressedSignalInfo = GestureMultiPressPressedCallback
    connectSignal _ = connectGestureMultiPressPressed

data GestureMultiPressReleasedSignalInfo
instance SignalInfo GestureMultiPressReleasedSignalInfo where
    type HaskellCallbackType GestureMultiPressReleasedSignalInfo = GestureMultiPressReleasedCallback
    connectSignal _ = connectGestureMultiPressReleased

data GestureMultiPressStoppedSignalInfo
instance SignalInfo GestureMultiPressStoppedSignalInfo where
    type HaskellCallbackType GestureMultiPressStoppedSignalInfo = GestureMultiPressStoppedCallback
    connectSignal _ = connectGestureMultiPressStopped

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, *)])

-- 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 '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 'GI.Gtk.Objects.Widget.Widget' -}
    -> m GestureMultiPress
    {- ^ __Returns:__ a newly created 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress' -}
gestureMultiPressNew widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_gesture_multi_press_new widget'
    checkUnexpectedReturnNULL "gestureMultiPressNew" result
    result' <- (wrapObject GestureMultiPress) result
    touchManagedPtr widget
    return result'

-- 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 '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 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress' -}
    -> m (Bool,Gdk.Rectangle.Rectangle)
    {- ^ __Returns:__ 'True' if /@rect@/ was filled with the press area -}
gestureMultiPressGetArea gesture = liftIO $ do
    gesture' <- unsafeManagedPtrCastPtr gesture
    rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    result <- gtk_gesture_multi_press_get_area gesture' rect
    let result' = (/= 0) result
    rect' <- (wrapBoxed Gdk.Rectangle.Rectangle) rect
    touchManagedPtr gesture
    return (result', rect')

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

-- 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 #GtkGesture", 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-'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 @/NULL/@, 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 'GI.Gtk.Objects.Gesture.Gesture' -}
    -> Maybe (Gdk.Rectangle.Rectangle)
    {- ^ /@rect@/: rectangle to receive coordinates on -}
    -> m ()
gestureMultiPressSetArea gesture rect = liftIO $ do
    gesture' <- unsafeManagedPtrCastPtr gesture
    maybeRect <- case rect of
        Nothing -> return nullPtr
        Just jRect -> do
            jRect' <- unsafeManagedPtrGetPtr jRect
            return jRect'
    gtk_gesture_multi_press_set_area gesture' maybeRect
    touchManagedPtr gesture
    whenJust rect touchManagedPtr
    return ()

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