{- |
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.GestureDrag
    ( 

-- * Exported types
    GestureDrag(..)                         ,
    GestureDragK                            ,
    toGestureDrag                           ,
    noGestureDrag                           ,


 -- * Methods
-- ** gestureDragNew
    gestureDragNew                          ,




 -- * Signals
-- ** DragBegin
    GestureDragDragBeginCallback            ,
    GestureDragDragBeginCallbackC           ,
    GestureDragDragBeginSignalInfo          ,
    afterGestureDragDragBegin               ,
    gestureDragDragBeginCallbackWrapper     ,
    gestureDragDragBeginClosure             ,
    mkGestureDragDragBeginCallback          ,
    noGestureDragDragBeginCallback          ,
    onGestureDragDragBegin                  ,


-- ** DragEnd
    GestureDragDragEndCallback              ,
    GestureDragDragEndCallbackC             ,
    GestureDragDragEndSignalInfo            ,
    afterGestureDragDragEnd                 ,
    gestureDragDragEndCallbackWrapper       ,
    gestureDragDragEndClosure               ,
    mkGestureDragDragEndCallback            ,
    noGestureDragDragEndCallback            ,
    onGestureDragDragEnd                    ,


-- ** DragUpdate
    GestureDragDragUpdateCallback           ,
    GestureDragDragUpdateCallbackC          ,
    GestureDragDragUpdateSignalInfo         ,
    afterGestureDragDragUpdate              ,
    gestureDragDragUpdateCallbackWrapper    ,
    gestureDragDragUpdateClosure            ,
    mkGestureDragDragUpdateCallback         ,
    noGestureDragDragUpdateCallback         ,
    onGestureDragDragUpdate                 ,




    ) 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

newtype GestureDrag = GestureDrag (ForeignPtr GestureDrag)
foreign import ccall "gtk_gesture_drag_get_type"
    c_gtk_gesture_drag_get_type :: IO GType

type instance ParentTypes GestureDrag = GestureDragParentTypes
type GestureDragParentTypes = '[GestureSingle, Gesture, EventController, GObject.Object]

instance GObject GestureDrag where
    gobjectIsInitiallyUnowned _ = False
    gobjectType _ = c_gtk_gesture_drag_get_type
    

class GObject o => GestureDragK o
instance (GObject o, IsDescendantOf GestureDrag o) => GestureDragK o

toGestureDrag :: GestureDragK o => o -> IO GestureDrag
toGestureDrag = unsafeCastTo GestureDrag

noGestureDrag :: Maybe GestureDrag
noGestureDrag = Nothing

-- signal GestureDrag::drag-begin
type GestureDragDragBeginCallback =
    Double ->
    Double ->
    IO ()

noGestureDragDragBeginCallback :: Maybe GestureDragDragBeginCallback
noGestureDragDragBeginCallback = Nothing

type GestureDragDragBeginCallbackC =
    Ptr () ->                               -- object
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkGestureDragDragBeginCallback :: GestureDragDragBeginCallbackC -> IO (FunPtr GestureDragDragBeginCallbackC)

gestureDragDragBeginClosure :: GestureDragDragBeginCallback -> IO Closure
gestureDragDragBeginClosure cb = newCClosure =<< mkGestureDragDragBeginCallback wrapped
    where wrapped = gestureDragDragBeginCallbackWrapper cb

gestureDragDragBeginCallbackWrapper ::
    GestureDragDragBeginCallback ->
    Ptr () ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
gestureDragDragBeginCallbackWrapper _cb _ start_x start_y _ = do
    let start_x' = realToFrac start_x
    let start_y' = realToFrac start_y
    _cb  start_x' start_y'

onGestureDragDragBegin :: (GObject a, MonadIO m) => a -> GestureDragDragBeginCallback -> m SignalHandlerId
onGestureDragDragBegin obj cb = liftIO $ connectGestureDragDragBegin obj cb SignalConnectBefore
afterGestureDragDragBegin :: (GObject a, MonadIO m) => a -> GestureDragDragBeginCallback -> m SignalHandlerId
afterGestureDragDragBegin obj cb = connectGestureDragDragBegin obj cb SignalConnectAfter

connectGestureDragDragBegin :: (GObject a, MonadIO m) =>
                               a -> GestureDragDragBeginCallback -> SignalConnectMode -> m SignalHandlerId
connectGestureDragDragBegin obj cb after = liftIO $ do
    cb' <- mkGestureDragDragBeginCallback (gestureDragDragBeginCallbackWrapper cb)
    connectSignalFunPtr obj "drag-begin" cb' after

-- signal GestureDrag::drag-end
type GestureDragDragEndCallback =
    Double ->
    Double ->
    IO ()

noGestureDragDragEndCallback :: Maybe GestureDragDragEndCallback
noGestureDragDragEndCallback = Nothing

type GestureDragDragEndCallbackC =
    Ptr () ->                               -- object
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkGestureDragDragEndCallback :: GestureDragDragEndCallbackC -> IO (FunPtr GestureDragDragEndCallbackC)

gestureDragDragEndClosure :: GestureDragDragEndCallback -> IO Closure
gestureDragDragEndClosure cb = newCClosure =<< mkGestureDragDragEndCallback wrapped
    where wrapped = gestureDragDragEndCallbackWrapper cb

gestureDragDragEndCallbackWrapper ::
    GestureDragDragEndCallback ->
    Ptr () ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
gestureDragDragEndCallbackWrapper _cb _ offset_x offset_y _ = do
    let offset_x' = realToFrac offset_x
    let offset_y' = realToFrac offset_y
    _cb  offset_x' offset_y'

onGestureDragDragEnd :: (GObject a, MonadIO m) => a -> GestureDragDragEndCallback -> m SignalHandlerId
onGestureDragDragEnd obj cb = liftIO $ connectGestureDragDragEnd obj cb SignalConnectBefore
afterGestureDragDragEnd :: (GObject a, MonadIO m) => a -> GestureDragDragEndCallback -> m SignalHandlerId
afterGestureDragDragEnd obj cb = connectGestureDragDragEnd obj cb SignalConnectAfter

connectGestureDragDragEnd :: (GObject a, MonadIO m) =>
                             a -> GestureDragDragEndCallback -> SignalConnectMode -> m SignalHandlerId
connectGestureDragDragEnd obj cb after = liftIO $ do
    cb' <- mkGestureDragDragEndCallback (gestureDragDragEndCallbackWrapper cb)
    connectSignalFunPtr obj "drag-end" cb' after

-- signal GestureDrag::drag-update
type GestureDragDragUpdateCallback =
    Double ->
    Double ->
    IO ()

noGestureDragDragUpdateCallback :: Maybe GestureDragDragUpdateCallback
noGestureDragDragUpdateCallback = Nothing

type GestureDragDragUpdateCallbackC =
    Ptr () ->                               -- object
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkGestureDragDragUpdateCallback :: GestureDragDragUpdateCallbackC -> IO (FunPtr GestureDragDragUpdateCallbackC)

gestureDragDragUpdateClosure :: GestureDragDragUpdateCallback -> IO Closure
gestureDragDragUpdateClosure cb = newCClosure =<< mkGestureDragDragUpdateCallback wrapped
    where wrapped = gestureDragDragUpdateCallbackWrapper cb

gestureDragDragUpdateCallbackWrapper ::
    GestureDragDragUpdateCallback ->
    Ptr () ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
gestureDragDragUpdateCallbackWrapper _cb _ offset_x offset_y _ = do
    let offset_x' = realToFrac offset_x
    let offset_y' = realToFrac offset_y
    _cb  offset_x' offset_y'

onGestureDragDragUpdate :: (GObject a, MonadIO m) => a -> GestureDragDragUpdateCallback -> m SignalHandlerId
onGestureDragDragUpdate obj cb = liftIO $ connectGestureDragDragUpdate obj cb SignalConnectBefore
afterGestureDragDragUpdate :: (GObject a, MonadIO m) => a -> GestureDragDragUpdateCallback -> m SignalHandlerId
afterGestureDragDragUpdate obj cb = connectGestureDragDragUpdate obj cb SignalConnectAfter

connectGestureDragDragUpdate :: (GObject a, MonadIO m) =>
                                a -> GestureDragDragUpdateCallback -> SignalConnectMode -> m SignalHandlerId
connectGestureDragDragUpdate obj cb after = liftIO $ do
    cb' <- mkGestureDragDragUpdateCallback (gestureDragDragUpdateCallbackWrapper cb)
    connectSignalFunPtr obj "drag-update" cb' after

type instance AttributeList GestureDrag = GestureDragAttributeList
type GestureDragAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])

data GestureDragDragBeginSignalInfo
instance SignalInfo GestureDragDragBeginSignalInfo where
    type HaskellCallbackType GestureDragDragBeginSignalInfo = GestureDragDragBeginCallback
    connectSignal _ = connectGestureDragDragBegin

data GestureDragDragEndSignalInfo
instance SignalInfo GestureDragDragEndSignalInfo where
    type HaskellCallbackType GestureDragDragEndSignalInfo = GestureDragDragEndCallback
    connectSignal _ = connectGestureDragDragEnd

data GestureDragDragUpdateSignalInfo
instance SignalInfo GestureDragDragUpdateSignalInfo where
    type HaskellCallbackType GestureDragDragUpdateSignalInfo = GestureDragDragUpdateCallback
    connectSignal _ = connectGestureDragDragUpdate

type instance SignalList GestureDrag = GestureDragSignalList
type GestureDragSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("drag-begin", GestureDragDragBeginSignalInfo), '("drag-end", GestureDragDragEndSignalInfo), '("drag-update", GestureDragDragUpdateSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method GestureDrag::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" "GestureDrag"
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_drag_new" gtk_gesture_drag_new :: 
    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"
    IO (Ptr GestureDrag)


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

-- XXX Could not generate method GestureDrag::get_offset
-- Error was : Bad introspection data: "argument \"x\" is not of nullable type (TBasicType TDouble), but it is marked as such."
-- XXX Could not generate method GestureDrag::get_start_point
-- Error was : Bad introspection data: "argument \"x\" is not of nullable type (TBasicType TDouble), but it is marked as such."