{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.GestureMultiPress
(
GestureMultiPress(..) ,
IsGestureMultiPress ,
toGestureMultiPress ,
#if defined(ENABLE_OVERLOADING)
ResolveGestureMultiPressMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
GestureMultiPressGetAreaMethodInfo ,
#endif
gestureMultiPressGetArea ,
gestureMultiPressNew ,
#if defined(ENABLE_OVERLOADING)
GestureMultiPressSetAreaMethodInfo ,
#endif
gestureMultiPressSetArea ,
GestureMultiPressPressedCallback ,
#if defined(ENABLE_OVERLOADING)
GestureMultiPressPressedSignalInfo ,
#endif
afterGestureMultiPressPressed ,
onGestureMultiPressPressed ,
GestureMultiPressReleasedCallback ,
#if defined(ENABLE_OVERLOADING)
GestureMultiPressReleasedSignalInfo ,
#endif
afterGestureMultiPressReleased ,
onGestureMultiPressReleased ,
GestureMultiPressStoppedCallback ,
#if defined(ENABLE_OVERLOADING)
GestureMultiPressStoppedSignalInfo ,
#endif
afterGestureMultiPressStopped ,
onGestureMultiPressStopped ,
) 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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
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.GestureSingle as Gtk.GestureSingle
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
newtype GestureMultiPress = GestureMultiPress (SP.ManagedPtr GestureMultiPress)
deriving (GestureMultiPress -> GestureMultiPress -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GestureMultiPress -> GestureMultiPress -> Bool
$c/= :: GestureMultiPress -> GestureMultiPress -> Bool
== :: GestureMultiPress -> GestureMultiPress -> Bool
$c== :: GestureMultiPress -> GestureMultiPress -> Bool
Eq)
instance SP.ManagedPtrNewtype GestureMultiPress where
toManagedPtr :: GestureMultiPress -> ManagedPtr GestureMultiPress
toManagedPtr (GestureMultiPress ManagedPtr GestureMultiPress
p) = ManagedPtr GestureMultiPress
p
foreign import ccall "gtk_gesture_multi_press_get_type"
c_gtk_gesture_multi_press_get_type :: IO B.Types.GType
instance B.Types.TypedObject GestureMultiPress where
glibType :: IO GType
glibType = IO GType
c_gtk_gesture_multi_press_get_type
instance B.Types.GObject GestureMultiPress
class (SP.GObject o, O.IsDescendantOf GestureMultiPress o) => IsGestureMultiPress o
instance (SP.GObject o, O.IsDescendantOf GestureMultiPress o) => IsGestureMultiPress o
instance O.HasParentTypes GestureMultiPress
type instance O.ParentTypes GestureMultiPress = '[Gtk.GestureSingle.GestureSingle, Gtk.Gesture.Gesture, Gtk.EventController.EventController, GObject.Object.Object]
toGestureMultiPress :: (MIO.MonadIO m, IsGestureMultiPress o) => o -> m GestureMultiPress
toGestureMultiPress :: forall (m :: * -> *) o.
(MonadIO m, IsGestureMultiPress o) =>
o -> m GestureMultiPress
toGestureMultiPress = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr GestureMultiPress -> GestureMultiPress
GestureMultiPress
instance B.GValue.IsGValue (Maybe GestureMultiPress) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_gesture_multi_press_get_type
gvalueSet_ :: Ptr GValue -> Maybe GestureMultiPress -> IO ()
gvalueSet_ Ptr GValue
gv Maybe GestureMultiPress
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr GestureMultiPress)
gvalueSet_ Ptr GValue
gv (P.Just GestureMultiPress
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr GestureMultiPress
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe GestureMultiPress)
gvalueGet_ Ptr GValue
gv = do
Ptr GestureMultiPress
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr GestureMultiPress)
if Ptr GestureMultiPress
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr GestureMultiPress -> GestureMultiPress
GestureMultiPress Ptr GestureMultiPress
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveGestureMultiPressMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveGestureMultiPressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveGestureMultiPressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveGestureMultiPressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveGestureMultiPressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveGestureMultiPressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveGestureMultiPressMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo
ResolveGestureMultiPressMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo
ResolveGestureMultiPressMethod "handlesSequence" o = Gtk.Gesture.GestureHandlesSequenceMethodInfo
ResolveGestureMultiPressMethod "isActive" o = Gtk.Gesture.GestureIsActiveMethodInfo
ResolveGestureMultiPressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveGestureMultiPressMethod "isGroupedWith" o = Gtk.Gesture.GestureIsGroupedWithMethodInfo
ResolveGestureMultiPressMethod "isRecognized" o = Gtk.Gesture.GestureIsRecognizedMethodInfo
ResolveGestureMultiPressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveGestureMultiPressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveGestureMultiPressMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveGestureMultiPressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveGestureMultiPressMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
ResolveGestureMultiPressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveGestureMultiPressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveGestureMultiPressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveGestureMultiPressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveGestureMultiPressMethod "ungroup" o = Gtk.Gesture.GestureUngroupMethodInfo
ResolveGestureMultiPressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveGestureMultiPressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveGestureMultiPressMethod "getArea" o = GestureMultiPressGetAreaMethodInfo
ResolveGestureMultiPressMethod "getBoundingBox" o = Gtk.Gesture.GestureGetBoundingBoxMethodInfo
ResolveGestureMultiPressMethod "getBoundingBoxCenter" o = Gtk.Gesture.GestureGetBoundingBoxCenterMethodInfo
ResolveGestureMultiPressMethod "getButton" o = Gtk.GestureSingle.GestureSingleGetButtonMethodInfo
ResolveGestureMultiPressMethod "getCurrentButton" o = Gtk.GestureSingle.GestureSingleGetCurrentButtonMethodInfo
ResolveGestureMultiPressMethod "getCurrentSequence" o = Gtk.GestureSingle.GestureSingleGetCurrentSequenceMethodInfo
ResolveGestureMultiPressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveGestureMultiPressMethod "getDevice" o = Gtk.Gesture.GestureGetDeviceMethodInfo
ResolveGestureMultiPressMethod "getExclusive" o = Gtk.GestureSingle.GestureSingleGetExclusiveMethodInfo
ResolveGestureMultiPressMethod "getGroup" o = Gtk.Gesture.GestureGetGroupMethodInfo
ResolveGestureMultiPressMethod "getLastEvent" o = Gtk.Gesture.GestureGetLastEventMethodInfo
ResolveGestureMultiPressMethod "getLastUpdatedSequence" o = Gtk.Gesture.GestureGetLastUpdatedSequenceMethodInfo
ResolveGestureMultiPressMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo
ResolveGestureMultiPressMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
ResolveGestureMultiPressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveGestureMultiPressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveGestureMultiPressMethod "getSequenceState" o = Gtk.Gesture.GestureGetSequenceStateMethodInfo
ResolveGestureMultiPressMethod "getSequences" o = Gtk.Gesture.GestureGetSequencesMethodInfo
ResolveGestureMultiPressMethod "getTouchOnly" o = Gtk.GestureSingle.GestureSingleGetTouchOnlyMethodInfo
ResolveGestureMultiPressMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
ResolveGestureMultiPressMethod "getWindow" o = Gtk.Gesture.GestureGetWindowMethodInfo
ResolveGestureMultiPressMethod "setArea" o = GestureMultiPressSetAreaMethodInfo
ResolveGestureMultiPressMethod "setButton" o = Gtk.GestureSingle.GestureSingleSetButtonMethodInfo
ResolveGestureMultiPressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveGestureMultiPressMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveGestureMultiPressMethod "setExclusive" o = Gtk.GestureSingle.GestureSingleSetExclusiveMethodInfo
ResolveGestureMultiPressMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
ResolveGestureMultiPressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveGestureMultiPressMethod "setSequenceState" o = Gtk.Gesture.GestureSetSequenceStateMethodInfo
ResolveGestureMultiPressMethod "setState" o = Gtk.Gesture.GestureSetStateMethodInfo
ResolveGestureMultiPressMethod "setTouchOnly" o = Gtk.GestureSingle.GestureSingleSetTouchOnlyMethodInfo
ResolveGestureMultiPressMethod "setWindow" o = Gtk.Gesture.GestureSetWindowMethodInfo
ResolveGestureMultiPressMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveGestureMultiPressMethod t GestureMultiPress, O.OverloadedMethod info GestureMultiPress p) => OL.IsLabel t (GestureMultiPress -> 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 ~ ResolveGestureMultiPressMethod t GestureMultiPress, O.OverloadedMethod info GestureMultiPress p, R.HasField t GestureMultiPress p) => R.HasField t GestureMultiPress p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveGestureMultiPressMethod t GestureMultiPress, O.OverloadedMethodInfo info GestureMultiPress) => OL.IsLabel t (O.MethodProxy info GestureMultiPress) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type GestureMultiPressPressedCallback =
Int32
-> Double
-> Double
-> IO ()
type C_GestureMultiPressPressedCallback =
Ptr GestureMultiPress ->
Int32 ->
CDouble ->
CDouble ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_GestureMultiPressPressedCallback :: C_GestureMultiPressPressedCallback -> IO (FunPtr C_GestureMultiPressPressedCallback)
wrap_GestureMultiPressPressedCallback ::
GObject a => (a -> GestureMultiPressPressedCallback) ->
C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback :: forall a.
GObject a =>
(a -> GestureMultiPressPressedCallback)
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback a -> GestureMultiPressPressedCallback
gi'cb Ptr GestureMultiPress
gi'selfPtr Int32
nPress CDouble
x CDouble
y Ptr ()
_ = do
let x' :: Double
x' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x
let y' :: Double
y' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr GestureMultiPress
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \GestureMultiPress
gi'self -> a -> GestureMultiPressPressedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce GestureMultiPress
gi'self) Int32
nPress Double
x' Double
y'
onGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressPressedCallback) -> m SignalHandlerId
onGestureMultiPressPressed :: forall a (m :: * -> *).
(IsGestureMultiPress a, MonadIO m) =>
a
-> ((?self::a) => GestureMultiPressPressedCallback)
-> m SignalHandlerId
onGestureMultiPressPressed a
obj (?self::a) => GestureMultiPressPressedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> GestureMultiPressPressedCallback
wrapped a
self = let ?self = a
self in (?self::a) => GestureMultiPressPressedCallback
cb
let wrapped' :: C_GestureMultiPressPressedCallback
wrapped' = forall a.
GObject a =>
(a -> GestureMultiPressPressedCallback)
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback a -> GestureMultiPressPressedCallback
wrapped
FunPtr C_GestureMultiPressPressedCallback
wrapped'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressPressedCallback C_GestureMultiPressPressedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pressed" FunPtr C_GestureMultiPressPressedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressPressedCallback) -> m SignalHandlerId
afterGestureMultiPressPressed :: forall a (m :: * -> *).
(IsGestureMultiPress a, MonadIO m) =>
a
-> ((?self::a) => GestureMultiPressPressedCallback)
-> m SignalHandlerId
afterGestureMultiPressPressed a
obj (?self::a) => GestureMultiPressPressedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> GestureMultiPressPressedCallback
wrapped a
self = let ?self = a
self in (?self::a) => GestureMultiPressPressedCallback
cb
let wrapped' :: C_GestureMultiPressPressedCallback
wrapped' = forall a.
GObject a =>
(a -> GestureMultiPressPressedCallback)
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressPressedCallback a -> GestureMultiPressPressedCallback
wrapped
FunPtr C_GestureMultiPressPressedCallback
wrapped'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressPressedCallback C_GestureMultiPressPressedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pressed" FunPtr C_GestureMultiPressPressedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data GestureMultiPressPressedSignalInfo
instance SignalInfo GestureMultiPressPressedSignalInfo where
type HaskellCallbackType GestureMultiPressPressedSignalInfo = GestureMultiPressPressedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_GestureMultiPressPressedCallback cb
cb'' <- mk_GestureMultiPressPressedCallback cb'
connectSignalFunPtr obj "pressed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.GestureMultiPress::pressed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-GestureMultiPress.html#g:signal:pressed"})
#endif
type GestureMultiPressReleasedCallback =
Int32
-> Double
-> Double
-> IO ()
type C_GestureMultiPressReleasedCallback =
Ptr GestureMultiPress ->
Int32 ->
CDouble ->
CDouble ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_GestureMultiPressReleasedCallback :: C_GestureMultiPressReleasedCallback -> IO (FunPtr C_GestureMultiPressReleasedCallback)
wrap_GestureMultiPressReleasedCallback ::
GObject a => (a -> GestureMultiPressReleasedCallback) ->
C_GestureMultiPressReleasedCallback
wrap_GestureMultiPressReleasedCallback :: forall a.
GObject a =>
(a -> GestureMultiPressPressedCallback)
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressReleasedCallback a -> GestureMultiPressPressedCallback
gi'cb Ptr GestureMultiPress
gi'selfPtr Int32
nPress CDouble
x CDouble
y Ptr ()
_ = do
let x' :: Double
x' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x
let y' :: Double
y' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr GestureMultiPress
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \GestureMultiPress
gi'self -> a -> GestureMultiPressPressedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce GestureMultiPress
gi'self) Int32
nPress Double
x' Double
y'
onGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressReleasedCallback) -> m SignalHandlerId
onGestureMultiPressReleased :: forall a (m :: * -> *).
(IsGestureMultiPress a, MonadIO m) =>
a
-> ((?self::a) => GestureMultiPressPressedCallback)
-> m SignalHandlerId
onGestureMultiPressReleased a
obj (?self::a) => GestureMultiPressPressedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> GestureMultiPressPressedCallback
wrapped a
self = let ?self = a
self in (?self::a) => GestureMultiPressPressedCallback
cb
let wrapped' :: C_GestureMultiPressPressedCallback
wrapped' = forall a.
GObject a =>
(a -> GestureMultiPressPressedCallback)
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressReleasedCallback a -> GestureMultiPressPressedCallback
wrapped
FunPtr C_GestureMultiPressPressedCallback
wrapped'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressReleasedCallback C_GestureMultiPressPressedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"released" FunPtr C_GestureMultiPressPressedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressReleasedCallback) -> m SignalHandlerId
afterGestureMultiPressReleased :: forall a (m :: * -> *).
(IsGestureMultiPress a, MonadIO m) =>
a
-> ((?self::a) => GestureMultiPressPressedCallback)
-> m SignalHandlerId
afterGestureMultiPressReleased a
obj (?self::a) => GestureMultiPressPressedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> GestureMultiPressPressedCallback
wrapped a
self = let ?self = a
self in (?self::a) => GestureMultiPressPressedCallback
cb
let wrapped' :: C_GestureMultiPressPressedCallback
wrapped' = forall a.
GObject a =>
(a -> GestureMultiPressPressedCallback)
-> C_GestureMultiPressPressedCallback
wrap_GestureMultiPressReleasedCallback a -> GestureMultiPressPressedCallback
wrapped
FunPtr C_GestureMultiPressPressedCallback
wrapped'' <- C_GestureMultiPressPressedCallback
-> IO (FunPtr C_GestureMultiPressPressedCallback)
mk_GestureMultiPressReleasedCallback C_GestureMultiPressPressedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"released" FunPtr C_GestureMultiPressPressedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data GestureMultiPressReleasedSignalInfo
instance SignalInfo GestureMultiPressReleasedSignalInfo where
type HaskellCallbackType GestureMultiPressReleasedSignalInfo = GestureMultiPressReleasedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_GestureMultiPressReleasedCallback cb
cb'' <- mk_GestureMultiPressReleasedCallback cb'
connectSignalFunPtr obj "released" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.GestureMultiPress::released"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-GestureMultiPress.html#g:signal:released"})
#endif
type GestureMultiPressStoppedCallback =
IO ()
type C_GestureMultiPressStoppedCallback =
Ptr GestureMultiPress ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_GestureMultiPressStoppedCallback :: C_GestureMultiPressStoppedCallback -> IO (FunPtr C_GestureMultiPressStoppedCallback)
wrap_GestureMultiPressStoppedCallback ::
GObject a => (a -> GestureMultiPressStoppedCallback) ->
C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback a -> IO ()
gi'cb Ptr GestureMultiPress
gi'selfPtr Ptr ()
_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr GestureMultiPress
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \GestureMultiPress
gi'self -> a -> IO ()
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce GestureMultiPress
gi'self)
onGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressStoppedCallback) -> m SignalHandlerId
onGestureMultiPressStopped :: forall a (m :: * -> *).
(IsGestureMultiPress a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onGestureMultiPressStopped a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_GestureMultiPressStoppedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback a -> IO ()
wrapped
FunPtr C_GestureMultiPressStoppedCallback
wrapped'' <- C_GestureMultiPressStoppedCallback
-> IO (FunPtr C_GestureMultiPressStoppedCallback)
mk_GestureMultiPressStoppedCallback C_GestureMultiPressStoppedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"stopped" FunPtr C_GestureMultiPressStoppedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressStoppedCallback) -> m SignalHandlerId
afterGestureMultiPressStopped :: forall a (m :: * -> *).
(IsGestureMultiPress a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterGestureMultiPressStopped a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_GestureMultiPressStoppedCallback
wrapped' = forall a.
GObject a =>
(a -> IO ()) -> C_GestureMultiPressStoppedCallback
wrap_GestureMultiPressStoppedCallback a -> IO ()
wrapped
FunPtr C_GestureMultiPressStoppedCallback
wrapped'' <- C_GestureMultiPressStoppedCallback
-> IO (FunPtr C_GestureMultiPressStoppedCallback)
mk_GestureMultiPressStoppedCallback C_GestureMultiPressStoppedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"stopped" FunPtr C_GestureMultiPressStoppedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data GestureMultiPressStoppedSignalInfo
instance SignalInfo GestureMultiPressStoppedSignalInfo where
type HaskellCallbackType GestureMultiPressStoppedSignalInfo = GestureMultiPressStoppedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_GestureMultiPressStoppedCallback cb
cb'' <- mk_GestureMultiPressStoppedCallback cb'
connectSignalFunPtr obj "stopped" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.GestureMultiPress::stopped"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-GestureMultiPress.html#g:signal:stopped"})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList GestureMultiPress
type instance O.AttributeList GestureMultiPress = GestureMultiPressAttributeList
type GestureMultiPressAttributeList = ('[ '("button", Gtk.GestureSingle.GestureSingleButtonPropertyInfo), '("exclusive", Gtk.GestureSingle.GestureSingleExclusivePropertyInfo), '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("touchOnly", Gtk.GestureSingle.GestureSingleTouchOnlyPropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo), '("window", Gtk.Gesture.GestureWindowPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList GestureMultiPress = GestureMultiPressSignalList
type GestureMultiPressSignalList = ('[ '("begin", Gtk.Gesture.GestureBeginSignalInfo), '("cancel", Gtk.Gesture.GestureCancelSignalInfo), '("end", Gtk.Gesture.GestureEndSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pressed", GestureMultiPressPressedSignalInfo), '("released", GestureMultiPressReleasedSignalInfo), '("sequenceStateChanged", Gtk.Gesture.GestureSequenceStateChangedSignalInfo), '("stopped", GestureMultiPressStoppedSignalInfo), '("update", Gtk.Gesture.GestureUpdateSignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gtk_gesture_multi_press_new" gtk_gesture_multi_press_new ::
Ptr Gtk.Widget.Widget ->
IO (Ptr GestureMultiPress)
gestureMultiPressNew ::
(B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>
a
-> m GestureMultiPress
gestureMultiPressNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
a -> m GestureMultiPress
gestureMultiPressNew a
widget = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Widget
widget' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
widget
Ptr GestureMultiPress
result <- Ptr Widget -> IO (Ptr GestureMultiPress)
gtk_gesture_multi_press_new Ptr Widget
widget'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"gestureMultiPressNew" Ptr GestureMultiPress
result
GestureMultiPress
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr GestureMultiPress -> GestureMultiPress
GestureMultiPress) Ptr GestureMultiPress
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
widget
forall (m :: * -> *) a. Monad m => a -> m a
return GestureMultiPress
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_gesture_multi_press_get_area" gtk_gesture_multi_press_get_area ::
Ptr GestureMultiPress ->
Ptr Gdk.Rectangle.Rectangle ->
IO CInt
gestureMultiPressGetArea ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureMultiPress a) =>
a
-> m ((Bool, Gdk.Rectangle.Rectangle))
gestureMultiPressGetArea :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGestureMultiPress a) =>
a -> m (Bool, Rectangle)
gestureMultiPressGetArea a
gesture = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GestureMultiPress
gesture' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gesture
Ptr Rectangle
rect <- forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Gdk.Rectangle.Rectangle)
CInt
result <- Ptr GestureMultiPress -> Ptr Rectangle -> IO CInt
gtk_gesture_multi_press_get_area Ptr GestureMultiPress
gesture' Ptr Rectangle
rect
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Rectangle
rect' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle) Ptr Rectangle
rect
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gesture
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Rectangle
rect')
#if defined(ENABLE_OVERLOADING)
data GestureMultiPressGetAreaMethodInfo
instance (signature ~ (m ((Bool, Gdk.Rectangle.Rectangle))), MonadIO m, IsGestureMultiPress a) => O.OverloadedMethod GestureMultiPressGetAreaMethodInfo a signature where
overloadedMethod = gestureMultiPressGetArea
instance O.OverloadedMethodInfo GestureMultiPressGetAreaMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.GestureMultiPress.gestureMultiPressGetArea",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-GestureMultiPress.html#v:gestureMultiPressGetArea"
})
#endif
foreign import ccall "gtk_gesture_multi_press_set_area" gtk_gesture_multi_press_set_area ::
Ptr GestureMultiPress ->
Ptr Gdk.Rectangle.Rectangle ->
IO ()
gestureMultiPressSetArea ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureMultiPress a) =>
a
-> Maybe (Gdk.Rectangle.Rectangle)
-> m ()
gestureMultiPressSetArea :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsGestureMultiPress a) =>
a -> Maybe Rectangle -> m ()
gestureMultiPressSetArea a
gesture Maybe Rectangle
rect = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GestureMultiPress
gesture' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
gesture
Ptr Rectangle
maybeRect <- case Maybe Rectangle
rect of
Maybe Rectangle
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Rectangle
jRect -> do
Ptr Rectangle
jRect' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
jRect
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rectangle
jRect'
Ptr GestureMultiPress -> Ptr Rectangle -> IO ()
gtk_gesture_multi_press_set_area Ptr GestureMultiPress
gesture' Ptr Rectangle
maybeRect
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
gesture
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Rectangle
rect forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data GestureMultiPressSetAreaMethodInfo
instance (signature ~ (Maybe (Gdk.Rectangle.Rectangle) -> m ()), MonadIO m, IsGestureMultiPress a) => O.OverloadedMethod GestureMultiPressSetAreaMethodInfo a signature where
overloadedMethod = gestureMultiPressSetArea
instance O.OverloadedMethodInfo GestureMultiPressSetAreaMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.GestureMultiPress.gestureMultiPressSetArea",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-GestureMultiPress.html#v:gestureMultiPressSetArea"
})
#endif