{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.GestureRotate
(
GestureRotate(..) ,
IsGestureRotate ,
toGestureRotate ,
#if defined(ENABLE_OVERLOADING)
ResolveGestureRotateMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
GestureRotateGetAngleDeltaMethodInfo ,
#endif
gestureRotateGetAngleDelta ,
gestureRotateNew ,
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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
import qualified GI.Gdk.Objects.Clipboard as Gdk.Clipboard
import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.Event as Gdk.Event
import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
import qualified GI.Gdk.Objects.Surface as Gdk.Surface
import qualified GI.Gdk.Objects.Texture as Gdk.Texture
import qualified GI.Gdk.Structs.EventSequence as Gdk.EventSequence
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import qualified GI.Graphene.Structs.Size as Graphene.Size
import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
import qualified GI.Gsk.Enums as Gsk.Enums
import qualified GI.Gsk.Objects.GLShader as Gsk.GLShader
import qualified GI.Gsk.Objects.RenderNode as Gsk.RenderNode
import qualified GI.Gsk.Objects.Renderer as Gsk.Renderer
import qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
import qualified GI.Gsk.Structs.Path as Gsk.Path
import qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
import qualified GI.Gsk.Structs.Shadow as Gsk.Shadow
import qualified GI.Gsk.Structs.Stroke as Gsk.Stroke
import qualified GI.Gsk.Structs.Transform as Gsk.Transform
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
import {-# SOURCE #-} qualified GI.Gtk.Objects.ATContext as Gtk.ATContext
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.LayoutChild as Gtk.LayoutChild
import {-# SOURCE #-} qualified GI.Gtk.Objects.LayoutManager as Gtk.LayoutManager
import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
import {-# SOURCE #-} qualified GI.Gtk.Objects.Snapshot as Gtk.Snapshot
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.FontMap as Pango.FontMap
import qualified GI.Pango.Objects.Layout as Pango.Layout
#else
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
#endif
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
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]
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
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 :: DK.Type) :: DK.Type 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
type GestureRotateAngleChangedCallback =
Double
-> Double
-> IO ()
type C_GestureRotateAngleChangedCallback =
Ptr GestureRotate ->
CDouble ->
CDouble ->
Ptr () ->
IO ()
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 o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject 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'
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
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.9/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, DK.Type)])
#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, DK.Type)])
#endif
foreign import ccall "gtk_gesture_rotate_new" gtk_gesture_rotate_new ::
IO (Ptr GestureRotate)
gestureRotateNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m GestureRotate
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
foreign import ccall "gtk_gesture_rotate_get_angle_delta" gtk_gesture_rotate_get_angle_delta ::
Ptr GestureRotate ->
IO CDouble
gestureRotateGetAngleDelta ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureRotate a) =>
a
-> m Double
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.9/docs/GI-Gtk-Objects-GestureRotate.html#v:gestureRotateGetAngleDelta"
})
#endif