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

module GI.Gtk.Objects.GestureMultiPress
    ( 

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


 -- * Methods
-- ** gestureMultiPressGetArea
    gestureMultiPressGetArea                ,


-- ** gestureMultiPressNew
    gestureMultiPressNew                    ,


-- ** gestureMultiPressSetArea
    gestureMultiPressSetArea                ,




 -- * Signals
-- ** Pressed
    GestureMultiPressPressedCallback        ,
    GestureMultiPressPressedCallbackC       ,
    GestureMultiPressPressedSignalInfo      ,
    afterGestureMultiPressPressed           ,
    gestureMultiPressPressedCallbackWrapper ,
    gestureMultiPressPressedClosure         ,
    mkGestureMultiPressPressedCallback      ,
    noGestureMultiPressPressedCallback      ,
    onGestureMultiPressPressed              ,


-- ** Released
    GestureMultiPressReleasedCallback       ,
    GestureMultiPressReleasedCallbackC      ,
    GestureMultiPressReleasedSignalInfo     ,
    afterGestureMultiPressReleased          ,
    gestureMultiPressReleasedCallbackWrapper,
    gestureMultiPressReleasedClosure        ,
    mkGestureMultiPressReleasedCallback     ,
    noGestureMultiPressReleasedCallback     ,
    onGestureMultiPressReleased             ,


-- ** Stopped
    GestureMultiPressStoppedCallback        ,
    GestureMultiPressStoppedCallbackC       ,
    GestureMultiPressStoppedSignalInfo      ,
    afterGestureMultiPressStopped           ,
    gestureMultiPressStoppedCallbackWrapper ,
    gestureMultiPressStoppedClosure         ,
    mkGestureMultiPressStoppedCallback      ,
    noGestureMultiPressStoppedCallback      ,
    onGestureMultiPressStopped              ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.Gtk.Types
import GI.Gtk.Callbacks
import qualified GI.GObject as GObject
import qualified GI.Cairo as Cairo

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

type instance ParentTypes GestureMultiPress = GestureMultiPressParentTypes
type GestureMultiPressParentTypes = '[GestureSingle, Gesture, EventController, GObject.Object]

instance GObject GestureMultiPress where
    gobjectIsInitiallyUnowned _ = False
    gobjectType _ = c_gtk_gesture_multi_press_get_type
    

class GObject o => GestureMultiPressK o
instance (GObject o, IsDescendantOf GestureMultiPress o) => GestureMultiPressK o

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

noGestureMultiPress :: Maybe GestureMultiPress
noGestureMultiPress = Nothing

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

noGestureMultiPressPressedCallback :: Maybe GestureMultiPressPressedCallback
noGestureMultiPressPressedCallback = Nothing

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

foreign import ccall "wrapper"
    mkGestureMultiPressPressedCallback :: GestureMultiPressPressedCallbackC -> IO (FunPtr GestureMultiPressPressedCallbackC)

gestureMultiPressPressedClosure :: GestureMultiPressPressedCallback -> IO Closure
gestureMultiPressPressedClosure cb = newCClosure =<< mkGestureMultiPressPressedCallback wrapped
    where wrapped = gestureMultiPressPressedCallbackWrapper cb

gestureMultiPressPressedCallbackWrapper ::
    GestureMultiPressPressedCallback ->
    Ptr () ->
    Int32 ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
gestureMultiPressPressedCallbackWrapper _cb _ n_press x y _ = do
    let x' = realToFrac x
    let y' = realToFrac y
    _cb  n_press 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
    cb' <- mkGestureMultiPressPressedCallback (gestureMultiPressPressedCallbackWrapper cb)
    connectSignalFunPtr obj "pressed" cb' after

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

noGestureMultiPressReleasedCallback :: Maybe GestureMultiPressReleasedCallback
noGestureMultiPressReleasedCallback = Nothing

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

foreign import ccall "wrapper"
    mkGestureMultiPressReleasedCallback :: GestureMultiPressReleasedCallbackC -> IO (FunPtr GestureMultiPressReleasedCallbackC)

gestureMultiPressReleasedClosure :: GestureMultiPressReleasedCallback -> IO Closure
gestureMultiPressReleasedClosure cb = newCClosure =<< mkGestureMultiPressReleasedCallback wrapped
    where wrapped = gestureMultiPressReleasedCallbackWrapper cb

gestureMultiPressReleasedCallbackWrapper ::
    GestureMultiPressReleasedCallback ->
    Ptr () ->
    Int32 ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
gestureMultiPressReleasedCallbackWrapper _cb _ n_press x y _ = do
    let x' = realToFrac x
    let y' = realToFrac y
    _cb  n_press 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
    cb' <- mkGestureMultiPressReleasedCallback (gestureMultiPressReleasedCallbackWrapper cb)
    connectSignalFunPtr obj "released" cb' after

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

noGestureMultiPressStoppedCallback :: Maybe GestureMultiPressStoppedCallback
noGestureMultiPressStoppedCallback = Nothing

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

foreign import ccall "wrapper"
    mkGestureMultiPressStoppedCallback :: GestureMultiPressStoppedCallbackC -> IO (FunPtr GestureMultiPressStoppedCallbackC)

gestureMultiPressStoppedClosure :: GestureMultiPressStoppedCallback -> IO Closure
gestureMultiPressStoppedClosure cb = newCClosure =<< mkGestureMultiPressStoppedCallback wrapped
    where wrapped = gestureMultiPressStoppedCallbackWrapper cb

gestureMultiPressStoppedCallbackWrapper ::
    GestureMultiPressStoppedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
gestureMultiPressStoppedCallbackWrapper _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
    cb' <- mkGestureMultiPressStoppedCallback (gestureMultiPressStoppedCallbackWrapper cb)
    connectSignalFunPtr obj "stopped" cb' after

type instance AttributeList GestureMultiPress = GestureMultiPressAttributeList
type GestureMultiPressAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", 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 SignalList GestureMultiPress = GestureMultiPressSignalList
type GestureMultiPressSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pressed", GestureMultiPressPressedSignalInfo), '("released", GestureMultiPressReleasedSignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("stopped", GestureMultiPressStoppedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method GestureMultiPress::new
-- method type : Constructor
-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Gtk" "GestureMultiPress"
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_multi_press_new" gtk_gesture_multi_press_new :: 
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    IO (Ptr GestureMultiPress)


gestureMultiPressNew ::
    (MonadIO m, WidgetK a) =>
    a ->                                    -- widget
    m GestureMultiPress
gestureMultiPressNew widget = liftIO $ do
    let widget' = unsafeManagedPtrCastPtr widget
    result <- gtk_gesture_multi_press_new widget'
    checkUnexpectedReturnNULL "gtk_gesture_multi_press_new" result
    result' <- (wrapObject GestureMultiPress) result
    touchManagedPtr widget
    return result'

-- method GestureMultiPress::get_area
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "cairo" "RectangleInt", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_multi_press_get_area" gtk_gesture_multi_press_get_area :: 
    Ptr GestureMultiPress ->                -- _obj : TInterface "Gtk" "GestureMultiPress"
    Ptr Cairo.RectangleInt ->               -- rect : TInterface "cairo" "RectangleInt"
    IO CInt


gestureMultiPressGetArea ::
    (MonadIO m, GestureMultiPressK a) =>
    a ->                                    -- _obj
    m (Bool,Cairo.RectangleInt)
gestureMultiPressGetArea _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    rect <- callocBoxedBytes 16 :: IO (Ptr Cairo.RectangleInt)
    result <- gtk_gesture_multi_press_get_area _obj' rect
    let result' = (/= 0) result
    rect' <- (wrapBoxed Cairo.RectangleInt) rect
    touchManagedPtr _obj
    return (result', rect')

-- method GestureMultiPress::set_area
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "cairo" "RectangleInt", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "cairo" "RectangleInt", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_multi_press_set_area" gtk_gesture_multi_press_set_area :: 
    Ptr GestureMultiPress ->                -- _obj : TInterface "Gtk" "GestureMultiPress"
    Ptr Cairo.RectangleInt ->               -- rect : TInterface "cairo" "RectangleInt"
    IO ()


gestureMultiPressSetArea ::
    (MonadIO m, GestureMultiPressK a) =>
    a ->                                    -- _obj
    Maybe (Cairo.RectangleInt) ->           -- rect
    m ()
gestureMultiPressSetArea _obj rect = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybeRect <- case rect of
        Nothing -> return nullPtr
        Just jRect -> do
            let jRect' = unsafeManagedPtrGetPtr jRect
            return jRect'
    gtk_gesture_multi_press_set_area _obj' maybeRect
    touchManagedPtr _obj
    whenJust rect touchManagedPtr
    return ()