{- |
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.GestureRotate.GestureRotate' is a 'GI.Gtk.Objects.Gesture.Gesture' implementation able to recognize
2-finger rotations, whenever the angle between both handled sequences
changes, the 'GI.Gtk.Objects.GestureRotate.GestureRotate'::@/angle-changed/@ signal is emitted.
-}

module GI.Gtk.Objects.GestureRotate
    ( 

-- * Exported types
    GestureRotate(..)                       ,
    IsGestureRotate                         ,
    toGestureRotate                         ,
    noGestureRotate                         ,


 -- * Methods
-- ** getAngleDelta #method:getAngleDelta#
    GestureRotateGetAngleDeltaMethodInfo    ,
    gestureRotateGetAngleDelta              ,


-- ** new #method:new#
    gestureRotateNew                        ,




 -- * Signals
-- ** angleChanged #signal:angleChanged#
    C_GestureRotateAngleChangedCallback     ,
    GestureRotateAngleChangedCallback       ,
    GestureRotateAngleChangedSignalInfo     ,
    afterGestureRotateAngleChanged          ,
    genClosure_GestureRotateAngleChanged    ,
    mk_GestureRotateAngleChangedCallback    ,
    noGestureRotateAngleChangedCallback     ,
    onGestureRotateAngleChanged             ,
    wrap_GestureRotateAngleChangedCallback  ,




    ) 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 {-# 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.Widget as Gtk.Widget

newtype GestureRotate = GestureRotate (ManagedPtr GestureRotate)
foreign import ccall "gtk_gesture_rotate_get_type"
    c_gtk_gesture_rotate_get_type :: IO GType

instance GObject GestureRotate where
    gobjectType _ = c_gtk_gesture_rotate_get_type
    

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

toGestureRotate :: IsGestureRotate o => o -> IO GestureRotate
toGestureRotate = unsafeCastTo GestureRotate

noGestureRotate :: Maybe GestureRotate
noGestureRotate = Nothing

type family ResolveGestureRotateMethod (t :: Symbol) (o :: *) :: * where
    ResolveGestureRotateMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveGestureRotateMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveGestureRotateMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveGestureRotateMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveGestureRotateMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo
    ResolveGestureRotateMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo
    ResolveGestureRotateMethod "handlesSequence" o = Gtk.Gesture.GestureHandlesSequenceMethodInfo
    ResolveGestureRotateMethod "isActive" o = Gtk.Gesture.GestureIsActiveMethodInfo
    ResolveGestureRotateMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveGestureRotateMethod "isGroupedWith" o = Gtk.Gesture.GestureIsGroupedWithMethodInfo
    ResolveGestureRotateMethod "isRecognized" o = Gtk.Gesture.GestureIsRecognizedMethodInfo
    ResolveGestureRotateMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveGestureRotateMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveGestureRotateMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveGestureRotateMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveGestureRotateMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveGestureRotateMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveGestureRotateMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
    ResolveGestureRotateMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveGestureRotateMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveGestureRotateMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveGestureRotateMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveGestureRotateMethod "ungroup" o = Gtk.Gesture.GestureUngroupMethodInfo
    ResolveGestureRotateMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveGestureRotateMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveGestureRotateMethod "getAngleDelta" o = GestureRotateGetAngleDeltaMethodInfo
    ResolveGestureRotateMethod "getBoundingBox" o = Gtk.Gesture.GestureGetBoundingBoxMethodInfo
    ResolveGestureRotateMethod "getBoundingBoxCenter" o = Gtk.Gesture.GestureGetBoundingBoxCenterMethodInfo
    ResolveGestureRotateMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveGestureRotateMethod "getDevice" o = Gtk.Gesture.GestureGetDeviceMethodInfo
    ResolveGestureRotateMethod "getGroup" o = Gtk.Gesture.GestureGetGroupMethodInfo
    ResolveGestureRotateMethod "getLastEvent" o = Gtk.Gesture.GestureGetLastEventMethodInfo
    ResolveGestureRotateMethod "getLastUpdatedSequence" o = Gtk.Gesture.GestureGetLastUpdatedSequenceMethodInfo
    ResolveGestureRotateMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo
    ResolveGestureRotateMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
    ResolveGestureRotateMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveGestureRotateMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveGestureRotateMethod "getSequenceState" o = Gtk.Gesture.GestureGetSequenceStateMethodInfo
    ResolveGestureRotateMethod "getSequences" o = Gtk.Gesture.GestureGetSequencesMethodInfo
    ResolveGestureRotateMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
    ResolveGestureRotateMethod "getWindow" o = Gtk.Gesture.GestureGetWindowMethodInfo
    ResolveGestureRotateMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveGestureRotateMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
    ResolveGestureRotateMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveGestureRotateMethod "setSequenceState" o = Gtk.Gesture.GestureSetSequenceStateMethodInfo
    ResolveGestureRotateMethod "setState" o = Gtk.Gesture.GestureSetStateMethodInfo
    ResolveGestureRotateMethod "setWindow" o = Gtk.Gesture.GestureSetWindowMethodInfo
    ResolveGestureRotateMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveGestureRotateMethod t GestureRotate, O.MethodInfo info GestureRotate p) => O.IsLabelProxy t (GestureRotate -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

-- signal GestureRotate::angle-changed
type GestureRotateAngleChangedCallback =
    Double ->
    Double ->
    IO ()

noGestureRotateAngleChangedCallback :: Maybe GestureRotateAngleChangedCallback
noGestureRotateAngleChangedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_GestureRotateAngleChangedCallback :: C_GestureRotateAngleChangedCallback -> IO (FunPtr C_GestureRotateAngleChangedCallback)

genClosure_GestureRotateAngleChanged :: GestureRotateAngleChangedCallback -> IO Closure
genClosure_GestureRotateAngleChanged cb = do
    let cb' = wrap_GestureRotateAngleChangedCallback cb
    mk_GestureRotateAngleChangedCallback cb' >>= newCClosure


wrap_GestureRotateAngleChangedCallback ::
    GestureRotateAngleChangedCallback ->
    Ptr () ->
    CDouble ->
    CDouble ->
    Ptr () ->
    IO ()
wrap_GestureRotateAngleChangedCallback _cb _ angle angleDelta _ = do
    let angle' = realToFrac angle
    let angleDelta' = realToFrac angleDelta
    _cb  angle' angleDelta'


onGestureRotateAngleChanged :: (GObject a, MonadIO m) => a -> GestureRotateAngleChangedCallback -> m SignalHandlerId
onGestureRotateAngleChanged obj cb = liftIO $ connectGestureRotateAngleChanged obj cb SignalConnectBefore
afterGestureRotateAngleChanged :: (GObject a, MonadIO m) => a -> GestureRotateAngleChangedCallback -> m SignalHandlerId
afterGestureRotateAngleChanged obj cb = connectGestureRotateAngleChanged obj cb SignalConnectAfter

connectGestureRotateAngleChanged :: (GObject a, MonadIO m) =>
                                    a -> GestureRotateAngleChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectGestureRotateAngleChanged obj cb after = liftIO $ do
    let cb' = wrap_GestureRotateAngleChangedCallback cb
    cb'' <- mk_GestureRotateAngleChangedCallback cb'
    connectSignalFunPtr obj "angle-changed" cb'' after

instance O.HasAttributeList GestureRotate
type instance O.AttributeList GestureRotate = GestureRotateAttributeList
type GestureRotateAttributeList = ('[ '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo), '("window", Gtk.Gesture.GestureWindowPropertyInfo)] :: [(Symbol, *)])

data GestureRotateAngleChangedSignalInfo
instance SignalInfo GestureRotateAngleChangedSignalInfo where
    type HaskellCallbackType GestureRotateAngleChangedSignalInfo = GestureRotateAngleChangedCallback
    connectSignal _ = connectGestureRotateAngleChanged

type instance O.SignalList GestureRotate = GestureRotateSignalList
type GestureRotateSignalList = ('[ '("angleChanged", GestureRotateAngleChangedSignalInfo), '("begin", Gtk.Gesture.GestureBeginSignalInfo), '("cancel", Gtk.Gesture.GestureCancelSignalInfo), '("end", Gtk.Gesture.GestureEndSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sequenceStateChanged", Gtk.Gesture.GestureSequenceStateChangedSignalInfo), '("update", Gtk.Gesture.GestureUpdateSignalInfo)] :: [(Symbol, *)])

-- method GestureRotate::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 = "GestureRotate"}))
-- throws : False
-- Skip return : False

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

{- |
Returns a newly created 'GI.Gtk.Objects.Gesture.Gesture' that recognizes 2-touch
rotation gestures.

@since 3.14
-}
gestureRotateNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m GestureRotate
    {- ^ __Returns:__ a newly created 'GI.Gtk.Objects.GestureRotate.GestureRotate' -}
gestureRotateNew widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_gesture_rotate_new widget'
    checkUnexpectedReturnNULL "gestureRotateNew" result
    result' <- (wrapObject GestureRotate) result
    touchManagedPtr widget
    return result'

-- method GestureRotate::get_angle_delta
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "gesture", argType = TInterface (Name {namespace = "Gtk", name = "GestureRotate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkGestureRotate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_gesture_rotate_get_angle_delta" gtk_gesture_rotate_get_angle_delta :: 
    Ptr GestureRotate ->                    -- gesture : TInterface (Name {namespace = "Gtk", name = "GestureRotate"})
    IO CDouble

{- |
If /@gesture@/ is active, this function returns the angle difference
in radians since the gesture was first recognized. If /@gesture@/ is
not active, 0 is returned.

@since 3.14
-}
gestureRotateGetAngleDelta ::
    (B.CallStack.HasCallStack, MonadIO m, IsGestureRotate a) =>
    a
    {- ^ /@gesture@/: a 'GI.Gtk.Objects.GestureRotate.GestureRotate' -}
    -> m Double
    {- ^ __Returns:__ the angle delta in radians -}
gestureRotateGetAngleDelta gesture = liftIO $ do
    gesture' <- unsafeManagedPtrCastPtr gesture
    result <- gtk_gesture_rotate_get_angle_delta gesture'
    let result' = realToFrac result
    touchManagedPtr gesture
    return result'

data GestureRotateGetAngleDeltaMethodInfo
instance (signature ~ (m Double), MonadIO m, IsGestureRotate a) => O.MethodInfo GestureRotateGetAngleDeltaMethodInfo a signature where
    overloadedMethod _ = gestureRotateGetAngleDelta