{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.EventController
(
EventController(..) ,
IsEventController ,
toEventController ,
#if defined(ENABLE_OVERLOADING)
ResolveEventControllerMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
EventControllerGetPropagationPhaseMethodInfo,
#endif
eventControllerGetPropagationPhase ,
#if defined(ENABLE_OVERLOADING)
EventControllerGetWidgetMethodInfo ,
#endif
eventControllerGetWidget ,
#if defined(ENABLE_OVERLOADING)
EventControllerHandleEventMethodInfo ,
#endif
eventControllerHandleEvent ,
#if defined(ENABLE_OVERLOADING)
EventControllerResetMethodInfo ,
#endif
eventControllerReset ,
#if defined(ENABLE_OVERLOADING)
EventControllerSetPropagationPhaseMethodInfo,
#endif
eventControllerSetPropagationPhase ,
#if defined(ENABLE_OVERLOADING)
EventControllerPropagationPhasePropertyInfo,
#endif
constructEventControllerPropagationPhase,
#if defined(ENABLE_OVERLOADING)
eventControllerPropagationPhase ,
#endif
getEventControllerPropagationPhase ,
setEventControllerPropagationPhase ,
#if defined(ENABLE_OVERLOADING)
EventControllerWidgetPropertyInfo ,
#endif
constructEventControllerWidget ,
#if defined(ENABLE_OVERLOADING)
eventControllerWidget ,
#endif
getEventControllerWidget ,
) 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.Unions.Event as Gdk.Event
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
newtype EventController = EventController (SP.ManagedPtr EventController)
deriving (EventController -> EventController -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventController -> EventController -> Bool
$c/= :: EventController -> EventController -> Bool
== :: EventController -> EventController -> Bool
$c== :: EventController -> EventController -> Bool
Eq)
instance SP.ManagedPtrNewtype EventController where
toManagedPtr :: EventController -> ManagedPtr EventController
toManagedPtr (EventController ManagedPtr EventController
p) = ManagedPtr EventController
p
foreign import ccall "gtk_event_controller_get_type"
c_gtk_event_controller_get_type :: IO B.Types.GType
instance B.Types.TypedObject EventController where
glibType :: IO GType
glibType = IO GType
c_gtk_event_controller_get_type
instance B.Types.GObject EventController
class (SP.GObject o, O.IsDescendantOf EventController o) => IsEventController o
instance (SP.GObject o, O.IsDescendantOf EventController o) => IsEventController o
instance O.HasParentTypes EventController
type instance O.ParentTypes EventController = '[GObject.Object.Object]
toEventController :: (MIO.MonadIO m, IsEventController o) => o -> m EventController
toEventController :: forall (m :: * -> *) o.
(MonadIO m, IsEventController o) =>
o -> m EventController
toEventController = 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 EventController -> EventController
EventController
instance B.GValue.IsGValue (Maybe EventController) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_event_controller_get_type
gvalueSet_ :: Ptr GValue -> Maybe EventController -> IO ()
gvalueSet_ Ptr GValue
gv Maybe EventController
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 EventController)
gvalueSet_ Ptr GValue
gv (P.Just EventController
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EventController
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe EventController)
gvalueGet_ Ptr GValue
gv = do
Ptr EventController
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr EventController)
if Ptr EventController
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 EventController -> EventController
EventController Ptr EventController
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveEventControllerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveEventControllerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveEventControllerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveEventControllerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveEventControllerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveEventControllerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveEventControllerMethod "handleEvent" o = EventControllerHandleEventMethodInfo
ResolveEventControllerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveEventControllerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveEventControllerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveEventControllerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveEventControllerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveEventControllerMethod "reset" o = EventControllerResetMethodInfo
ResolveEventControllerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveEventControllerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveEventControllerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveEventControllerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveEventControllerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveEventControllerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveEventControllerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveEventControllerMethod "getPropagationPhase" o = EventControllerGetPropagationPhaseMethodInfo
ResolveEventControllerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveEventControllerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveEventControllerMethod "getWidget" o = EventControllerGetWidgetMethodInfo
ResolveEventControllerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveEventControllerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveEventControllerMethod "setPropagationPhase" o = EventControllerSetPropagationPhaseMethodInfo
ResolveEventControllerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveEventControllerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEventControllerMethod t EventController, O.OverloadedMethod info EventController p) => OL.IsLabel t (EventController -> 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 ~ ResolveEventControllerMethod t EventController, O.OverloadedMethod info EventController p, R.HasField t EventController p) => R.HasField t EventController p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEventControllerMethod t EventController, O.OverloadedMethodInfo info EventController) => OL.IsLabel t (O.MethodProxy info EventController) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> m Gtk.Enums.PropagationPhase
getEventControllerPropagationPhase :: forall (m :: * -> *) o.
(MonadIO m, IsEventController o) =>
o -> m PropagationPhase
getEventControllerPropagationPhase o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"propagation-phase"
setEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> Gtk.Enums.PropagationPhase -> m ()
setEventControllerPropagationPhase :: forall (m :: * -> *) o.
(MonadIO m, IsEventController o) =>
o -> PropagationPhase -> m ()
setEventControllerPropagationPhase o
obj PropagationPhase
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"propagation-phase" PropagationPhase
val
constructEventControllerPropagationPhase :: (IsEventController o, MIO.MonadIO m) => Gtk.Enums.PropagationPhase -> m (GValueConstruct o)
constructEventControllerPropagationPhase :: forall o (m :: * -> *).
(IsEventController o, MonadIO m) =>
PropagationPhase -> m (GValueConstruct o)
constructEventControllerPropagationPhase PropagationPhase
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"propagation-phase" PropagationPhase
val
#if defined(ENABLE_OVERLOADING)
data EventControllerPropagationPhasePropertyInfo
instance AttrInfo EventControllerPropagationPhasePropertyInfo where
type AttrAllowedOps EventControllerPropagationPhasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint EventControllerPropagationPhasePropertyInfo = IsEventController
type AttrSetTypeConstraint EventControllerPropagationPhasePropertyInfo = (~) Gtk.Enums.PropagationPhase
type AttrTransferTypeConstraint EventControllerPropagationPhasePropertyInfo = (~) Gtk.Enums.PropagationPhase
type AttrTransferType EventControllerPropagationPhasePropertyInfo = Gtk.Enums.PropagationPhase
type AttrGetType EventControllerPropagationPhasePropertyInfo = Gtk.Enums.PropagationPhase
type AttrLabel EventControllerPropagationPhasePropertyInfo = "propagation-phase"
type AttrOrigin EventControllerPropagationPhasePropertyInfo = EventController
attrGet = getEventControllerPropagationPhase
attrSet = setEventControllerPropagationPhase
attrTransfer _ v = do
return v
attrConstruct = constructEventControllerPropagationPhase
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.EventController.propagationPhase"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-EventController.html#g:attr:propagationPhase"
})
#endif
getEventControllerWidget :: (MonadIO m, IsEventController o) => o -> m Gtk.Widget.Widget
getEventControllerWidget :: forall (m :: * -> *) o.
(MonadIO m, IsEventController o) =>
o -> m Widget
getEventControllerWidget o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getEventControllerWidget" forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"widget" ManagedPtr Widget -> Widget
Gtk.Widget.Widget
constructEventControllerWidget :: (IsEventController o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructEventControllerWidget :: forall o (m :: * -> *) a.
(IsEventController o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructEventControllerWidget a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"widget" (forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data EventControllerWidgetPropertyInfo
instance AttrInfo EventControllerWidgetPropertyInfo where
type AttrAllowedOps EventControllerWidgetPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint EventControllerWidgetPropertyInfo = IsEventController
type AttrSetTypeConstraint EventControllerWidgetPropertyInfo = Gtk.Widget.IsWidget
type AttrTransferTypeConstraint EventControllerWidgetPropertyInfo = Gtk.Widget.IsWidget
type AttrTransferType EventControllerWidgetPropertyInfo = Gtk.Widget.Widget
type AttrGetType EventControllerWidgetPropertyInfo = Gtk.Widget.Widget
type AttrLabel EventControllerWidgetPropertyInfo = "widget"
type AttrOrigin EventControllerWidgetPropertyInfo = EventController
attrGet = getEventControllerWidget
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Gtk.Widget.Widget v
attrConstruct = constructEventControllerWidget
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.EventController.widget"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-EventController.html#g:attr:widget"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventController
type instance O.AttributeList EventController = EventControllerAttributeList
type EventControllerAttributeList = ('[ '("propagationPhase", EventControllerPropagationPhasePropertyInfo), '("widget", EventControllerWidgetPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
eventControllerPropagationPhase :: AttrLabelProxy "propagationPhase"
eventControllerPropagationPhase = AttrLabelProxy
eventControllerWidget :: AttrLabelProxy "widget"
eventControllerWidget = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList EventController = EventControllerSignalList
type EventControllerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gtk_event_controller_get_propagation_phase" gtk_event_controller_get_propagation_phase ::
Ptr EventController ->
IO CUInt
eventControllerGetPropagationPhase ::
(B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
a
-> m Gtk.Enums.PropagationPhase
eventControllerGetPropagationPhase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEventController a) =>
a -> m PropagationPhase
eventControllerGetPropagationPhase a
controller = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr EventController
controller' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
CUInt
result <- Ptr EventController -> IO CUInt
gtk_event_controller_get_propagation_phase Ptr EventController
controller'
let result' :: PropagationPhase
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
forall (m :: * -> *) a. Monad m => a -> m a
return PropagationPhase
result'
#if defined(ENABLE_OVERLOADING)
data EventControllerGetPropagationPhaseMethodInfo
instance (signature ~ (m Gtk.Enums.PropagationPhase), MonadIO m, IsEventController a) => O.OverloadedMethod EventControllerGetPropagationPhaseMethodInfo a signature where
overloadedMethod = eventControllerGetPropagationPhase
instance O.OverloadedMethodInfo EventControllerGetPropagationPhaseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.EventController.eventControllerGetPropagationPhase",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-EventController.html#v:eventControllerGetPropagationPhase"
})
#endif
foreign import ccall "gtk_event_controller_get_widget" gtk_event_controller_get_widget ::
Ptr EventController ->
IO (Ptr Gtk.Widget.Widget)
eventControllerGetWidget ::
(B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
a
-> m Gtk.Widget.Widget
eventControllerGetWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEventController a) =>
a -> m Widget
eventControllerGetWidget a
controller = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr EventController
controller' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
Ptr Widget
result <- Ptr EventController -> IO (Ptr Widget)
gtk_event_controller_get_widget Ptr EventController
controller'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventControllerGetWidget" Ptr Widget
result
Widget
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'
#if defined(ENABLE_OVERLOADING)
data EventControllerGetWidgetMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsEventController a) => O.OverloadedMethod EventControllerGetWidgetMethodInfo a signature where
overloadedMethod = eventControllerGetWidget
instance O.OverloadedMethodInfo EventControllerGetWidgetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.EventController.eventControllerGetWidget",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-EventController.html#v:eventControllerGetWidget"
})
#endif
foreign import ccall "gtk_event_controller_handle_event" gtk_event_controller_handle_event ::
Ptr EventController ->
Ptr Gdk.Event.Event ->
IO CInt
eventControllerHandleEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
a
-> Gdk.Event.Event
-> m Bool
eventControllerHandleEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEventController a) =>
a -> Event -> m Bool
eventControllerHandleEvent a
controller Event
event = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr EventController
controller' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
Ptr Event
event' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr EventController -> Ptr Event -> IO CInt
gtk_event_controller_handle_event Ptr EventController
controller' Ptr Event
event'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data EventControllerHandleEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m Bool), MonadIO m, IsEventController a) => O.OverloadedMethod EventControllerHandleEventMethodInfo a signature where
overloadedMethod = eventControllerHandleEvent
instance O.OverloadedMethodInfo EventControllerHandleEventMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.EventController.eventControllerHandleEvent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-EventController.html#v:eventControllerHandleEvent"
})
#endif
foreign import ccall "gtk_event_controller_reset" gtk_event_controller_reset ::
Ptr EventController ->
IO ()
eventControllerReset ::
(B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
a
-> m ()
eventControllerReset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEventController a) =>
a -> m ()
eventControllerReset a
controller = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr EventController
controller' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
Ptr EventController -> IO ()
gtk_event_controller_reset Ptr EventController
controller'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventControllerResetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEventController a) => O.OverloadedMethod EventControllerResetMethodInfo a signature where
overloadedMethod = eventControllerReset
instance O.OverloadedMethodInfo EventControllerResetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.EventController.eventControllerReset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-EventController.html#v:eventControllerReset"
})
#endif
foreign import ccall "gtk_event_controller_set_propagation_phase" gtk_event_controller_set_propagation_phase ::
Ptr EventController ->
CUInt ->
IO ()
eventControllerSetPropagationPhase ::
(B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
a
-> Gtk.Enums.PropagationPhase
-> m ()
eventControllerSetPropagationPhase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEventController a) =>
a -> PropagationPhase -> m ()
eventControllerSetPropagationPhase a
controller PropagationPhase
phase = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr EventController
controller' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
controller
let phase' :: CUInt
phase' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) PropagationPhase
phase
Ptr EventController -> CUInt -> IO ()
gtk_event_controller_set_propagation_phase Ptr EventController
controller' CUInt
phase'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
controller
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventControllerSetPropagationPhaseMethodInfo
instance (signature ~ (Gtk.Enums.PropagationPhase -> m ()), MonadIO m, IsEventController a) => O.OverloadedMethod EventControllerSetPropagationPhaseMethodInfo a signature where
overloadedMethod = eventControllerSetPropagationPhase
instance O.OverloadedMethodInfo EventControllerSetPropagationPhaseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.EventController.eventControllerSetPropagationPhase",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-EventController.html#v:eventControllerSetPropagationPhase"
})
#endif