{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkGestureRotate@ is a @GtkGesture@ for 2-finger rotations.
-- 
-- Whenever the angle between both handled sequences changes, the
-- [GestureRotate::angleChanged]("GI.Gtk.Objects.GestureRotate#g:signal:angleChanged") signal is emitted.

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

module GI.Gtk.Objects.GestureRotate
    ( 

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


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [group]("GI.Gtk.Objects.Gesture#g:method:group"), [handlesSequence]("GI.Gtk.Objects.Gesture#g:method:handlesSequence"), [isActive]("GI.Gtk.Objects.Gesture#g:method:isActive"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isGroupedWith]("GI.Gtk.Objects.Gesture#g:method:isGroupedWith"), [isRecognized]("GI.Gtk.Objects.Gesture#g:method:isRecognized"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [reset]("GI.Gtk.Objects.EventController#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [ungroup]("GI.Gtk.Objects.Gesture#g:method:ungroup"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAngleDelta]("GI.Gtk.Objects.GestureRotate#g:method:getAngleDelta"), [getBoundingBox]("GI.Gtk.Objects.Gesture#g:method:getBoundingBox"), [getBoundingBoxCenter]("GI.Gtk.Objects.Gesture#g:method:getBoundingBoxCenter"), [getCurrentEvent]("GI.Gtk.Objects.EventController#g:method:getCurrentEvent"), [getCurrentEventDevice]("GI.Gtk.Objects.EventController#g:method:getCurrentEventDevice"), [getCurrentEventState]("GI.Gtk.Objects.EventController#g:method:getCurrentEventState"), [getCurrentEventTime]("GI.Gtk.Objects.EventController#g:method:getCurrentEventTime"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDevice]("GI.Gtk.Objects.Gesture#g:method:getDevice"), [getGroup]("GI.Gtk.Objects.Gesture#g:method:getGroup"), [getLastEvent]("GI.Gtk.Objects.Gesture#g:method:getLastEvent"), [getLastUpdatedSequence]("GI.Gtk.Objects.Gesture#g:method:getLastUpdatedSequence"), [getName]("GI.Gtk.Objects.EventController#g:method:getName"), [getPoint]("GI.Gtk.Objects.Gesture#g:method:getPoint"), [getPropagationLimit]("GI.Gtk.Objects.EventController#g:method:getPropagationLimit"), [getPropagationPhase]("GI.Gtk.Objects.EventController#g:method:getPropagationPhase"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSequenceState]("GI.Gtk.Objects.Gesture#g:method:getSequenceState"), [getSequences]("GI.Gtk.Objects.Gesture#g:method:getSequences"), [getWidget]("GI.Gtk.Objects.EventController#g:method:getWidget").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setName]("GI.Gtk.Objects.EventController#g:method:setName"), [setPropagationLimit]("GI.Gtk.Objects.EventController#g:method:setPropagationLimit"), [setPropagationPhase]("GI.Gtk.Objects.EventController#g:method:setPropagationPhase"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSequenceState]("GI.Gtk.Objects.Gesture#g:method:setSequenceState"), [setState]("GI.Gtk.Objects.Gesture#g:method:setState"), [setStaticName]("GI.Gtk.Objects.EventController#g:method:setStaticName").

#if defined(ENABLE_OVERLOADING)
    ResolveGestureRotateMethod              ,
#endif

-- ** getAngleDelta #method:getAngleDelta#

#if defined(ENABLE_OVERLOADING)
    GestureRotateGetAngleDeltaMethodInfo    ,
#endif
    gestureRotateGetAngleDelta              ,


-- ** new #method:new#

    gestureRotateNew                        ,




 -- * Signals


-- ** angleChanged #signal:angleChanged#

    GestureRotateAngleChangedCallback       ,
#if defined(ENABLE_OVERLOADING)
    GestureRotateAngleChangedSignalInfo     ,
#endif
    afterGestureRotateAngleChanged          ,
    onGestureRotateAngleChanged             ,




    ) 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.GHashTable as B.GHT
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.Coerce as Coerce
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 GHC.Records as R

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

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

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

foreign import ccall "gtk_gesture_rotate_get_type"
    c_gtk_gesture_rotate_get_type :: IO B.Types.GType

instance B.Types.TypedObject GestureRotate where
    glibType :: IO GType
glibType = IO GType
c_gtk_gesture_rotate_get_type

instance B.Types.GObject GestureRotate

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

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

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

-- | Convert 'GestureRotate' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe GestureRotate) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_gesture_rotate_get_type
    gvalueSet_ :: Ptr GValue -> Maybe GestureRotate -> IO ()
gvalueSet_ Ptr GValue
gv Maybe GestureRotate
P.Nothing = Ptr GValue -> Ptr GestureRotate -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr GestureRotate
forall a. Ptr a
FP.nullPtr :: FP.Ptr GestureRotate)
    gvalueSet_ Ptr GValue
gv (P.Just GestureRotate
obj) = GestureRotate -> (Ptr GestureRotate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr GestureRotate
obj (Ptr GValue -> Ptr GestureRotate -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe GestureRotate)
gvalueGet_ Ptr GValue
gv = do
        Ptr GestureRotate
ptr <- Ptr GValue -> IO (Ptr GestureRotate)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr GestureRotate)
        if Ptr GestureRotate
ptr Ptr GestureRotate -> Ptr GestureRotate -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr GestureRotate
forall a. Ptr a
FP.nullPtr
        then GestureRotate -> Maybe GestureRotate
forall a. a -> Maybe a
P.Just (GestureRotate -> Maybe GestureRotate)
-> IO GestureRotate -> IO (Maybe GestureRotate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr GestureRotate -> GestureRotate)
-> Ptr GestureRotate -> IO GestureRotate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr GestureRotate -> GestureRotate
GestureRotate Ptr GestureRotate
ptr
        else Maybe GestureRotate -> IO (Maybe GestureRotate)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GestureRotate
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveGestureRotateMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo
    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 "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 "getCurrentEvent" o = Gtk.EventController.EventControllerGetCurrentEventMethodInfo
    ResolveGestureRotateMethod "getCurrentEventDevice" o = Gtk.EventController.EventControllerGetCurrentEventDeviceMethodInfo
    ResolveGestureRotateMethod "getCurrentEventState" o = Gtk.EventController.EventControllerGetCurrentEventStateMethodInfo
    ResolveGestureRotateMethod "getCurrentEventTime" o = Gtk.EventController.EventControllerGetCurrentEventTimeMethodInfo
    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 "getName" o = Gtk.EventController.EventControllerGetNameMethodInfo
    ResolveGestureRotateMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo
    ResolveGestureRotateMethod "getPropagationLimit" o = Gtk.EventController.EventControllerGetPropagationLimitMethodInfo
    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 "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveGestureRotateMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveGestureRotateMethod "setName" o = Gtk.EventController.EventControllerSetNameMethodInfo
    ResolveGestureRotateMethod "setPropagationLimit" o = Gtk.EventController.EventControllerSetPropagationLimitMethodInfo
    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 "setStaticName" o = Gtk.EventController.EventControllerSetStaticNameMethodInfo
    ResolveGestureRotateMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveGestureRotateMethod t GestureRotate, O.OverloadedMethod info GestureRotate p, R.HasField t GestureRotate p) => R.HasField t GestureRotate p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveGestureRotateMethod t GestureRotate, O.OverloadedMethodInfo info GestureRotate) => OL.IsLabel t (O.MethodProxy info GestureRotate) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal GestureRotate::angle-changed
-- | Emitted when the angle between both tracked points changes.
type GestureRotateAngleChangedCallback =
    Double
    -- ^ /@angle@/: Current angle in radians
    -> Double
    -- ^ /@angleDelta@/: Difference with the starting angle, in radians
    -> IO ()

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

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

wrap_GestureRotateAngleChangedCallback :: 
    GObject a => (a -> GestureRotateAngleChangedCallback) ->
    C_GestureRotateAngleChangedCallback
wrap_GestureRotateAngleChangedCallback :: forall a.
GObject a =>
(a -> GestureRotateAngleChangedCallback)
-> C_GestureRotateAngleChangedCallback
wrap_GestureRotateAngleChangedCallback a -> GestureRotateAngleChangedCallback
gi'cb Ptr GestureRotate
gi'selfPtr CDouble
angle CDouble
angleDelta Ptr ()
_ = do
    let angle' :: Double
angle' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
angle
    let angleDelta' :: Double
angleDelta' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
angleDelta
    Ptr GestureRotate -> (GestureRotate -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr GestureRotate
gi'selfPtr ((GestureRotate -> IO ()) -> IO ())
-> (GestureRotate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \GestureRotate
gi'self -> a -> GestureRotateAngleChangedCallback
gi'cb (GestureRotate -> a
forall a b. Coercible a b => a -> b
Coerce.coerce GestureRotate
gi'self)  Double
angle' Double
angleDelta'


-- | Connect a signal handler for the [angleChanged](#signal:angleChanged) 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' gestureRotate #angleChanged callback
-- @
-- 
-- 
onGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId
onGestureRotateAngleChanged :: forall a (m :: * -> *).
(IsGestureRotate a, MonadIO m) =>
a
-> ((?self::a) => GestureRotateAngleChangedCallback)
-> m SignalHandlerId
onGestureRotateAngleChanged a
obj (?self::a) => GestureRotateAngleChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> GestureRotateAngleChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GestureRotateAngleChangedCallback
GestureRotateAngleChangedCallback
cb
    let wrapped' :: C_GestureRotateAngleChangedCallback
wrapped' = (a -> GestureRotateAngleChangedCallback)
-> C_GestureRotateAngleChangedCallback
forall a.
GObject a =>
(a -> GestureRotateAngleChangedCallback)
-> C_GestureRotateAngleChangedCallback
wrap_GestureRotateAngleChangedCallback a -> GestureRotateAngleChangedCallback
wrapped
    FunPtr C_GestureRotateAngleChangedCallback
wrapped'' <- C_GestureRotateAngleChangedCallback
-> IO (FunPtr C_GestureRotateAngleChangedCallback)
mk_GestureRotateAngleChangedCallback C_GestureRotateAngleChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_GestureRotateAngleChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"angle-changed" FunPtr C_GestureRotateAngleChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [angleChanged](#signal:angleChanged) 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' gestureRotate #angleChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId
afterGestureRotateAngleChanged :: forall a (m :: * -> *).
(IsGestureRotate a, MonadIO m) =>
a
-> ((?self::a) => GestureRotateAngleChangedCallback)
-> m SignalHandlerId
afterGestureRotateAngleChanged a
obj (?self::a) => GestureRotateAngleChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> GestureRotateAngleChangedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => GestureRotateAngleChangedCallback
GestureRotateAngleChangedCallback
cb
    let wrapped' :: C_GestureRotateAngleChangedCallback
wrapped' = (a -> GestureRotateAngleChangedCallback)
-> C_GestureRotateAngleChangedCallback
forall a.
GObject a =>
(a -> GestureRotateAngleChangedCallback)
-> C_GestureRotateAngleChangedCallback
wrap_GestureRotateAngleChangedCallback a -> GestureRotateAngleChangedCallback
wrapped
    FunPtr C_GestureRotateAngleChangedCallback
wrapped'' <- C_GestureRotateAngleChangedCallback
-> IO (FunPtr C_GestureRotateAngleChangedCallback)
mk_GestureRotateAngleChangedCallback C_GestureRotateAngleChangedCallback
wrapped'
    a
-> Text
-> FunPtr C_GestureRotateAngleChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"angle-changed" FunPtr C_GestureRotateAngleChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data GestureRotateAngleChangedSignalInfo
instance SignalInfo GestureRotateAngleChangedSignalInfo where
    type HaskellCallbackType GestureRotateAngleChangedSignalInfo = GestureRotateAngleChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_GestureRotateAngleChangedCallback cb
        cb'' <- mk_GestureRotateAngleChangedCallback cb'
        connectSignalFunPtr obj "angle-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.GestureRotate::angle-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-GestureRotate.html#g:signal:angleChanged"})

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList GestureRotate
type instance O.AttributeList GestureRotate = GestureRotateAttributeList
type GestureRotateAttributeList = ('[ '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("name", Gtk.EventController.EventControllerNamePropertyInfo), '("propagationLimit", Gtk.EventController.EventControllerPropagationLimitPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
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, *)])

#endif

-- method GestureRotate::new
-- method type : Constructor
-- Args: []
-- 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 :: 
    IO (Ptr GestureRotate)

-- | Returns a newly created @GtkGesture@ that recognizes 2-touch
-- rotation gestures.
gestureRotateNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m GestureRotate
    -- ^ __Returns:__ a newly created @GtkGestureRotate@
gestureRotateNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m GestureRotate
gestureRotateNew  = IO GestureRotate -> m GestureRotate
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GestureRotate -> m GestureRotate)
-> IO GestureRotate -> m GestureRotate
forall a b. (a -> b) -> a -> b
$ do
    Ptr GestureRotate
result <- IO (Ptr GestureRotate)
gtk_gesture_rotate_new
    Text -> Ptr GestureRotate -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gestureRotateNew" Ptr GestureRotate
result
    GestureRotate
result' <- ((ManagedPtr GestureRotate -> GestureRotate)
-> Ptr GestureRotate -> IO GestureRotate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr GestureRotate -> GestureRotate
GestureRotate) Ptr GestureRotate
result
    GestureRotate -> IO GestureRotate
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GestureRotate
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- 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

-- | Gets the angle delta in radians.
-- 
-- 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.
gestureRotateGetAngleDelta ::
    (B.CallStack.HasCallStack, MonadIO m, IsGestureRotate a) =>
    a
    -- ^ /@gesture@/: a @GtkGestureRotate@
    -> m Double
    -- ^ __Returns:__ the angle delta in radians
gestureRotateGetAngleDelta :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGestureRotate a) =>
a -> m Double
gestureRotateGetAngleDelta a
gesture = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr GestureRotate
gesture' <- a -> IO (Ptr GestureRotate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gesture
    CDouble
result <- Ptr GestureRotate -> IO CDouble
gtk_gesture_rotate_get_angle_delta Ptr GestureRotate
gesture'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gesture
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data GestureRotateGetAngleDeltaMethodInfo
instance (signature ~ (m Double), MonadIO m, IsGestureRotate a) => O.OverloadedMethod GestureRotateGetAngleDeltaMethodInfo a signature where
    overloadedMethod = gestureRotateGetAngleDelta

instance O.OverloadedMethodInfo GestureRotateGetAngleDeltaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.GestureRotate.gestureRotateGetAngleDelta",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-GestureRotate.html#v:gestureRotateGetAngleDelta"
        })


#endif