{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.EventControllerScroll
(
EventControllerScroll(..) ,
IsEventControllerScroll ,
toEventControllerScroll ,
noEventControllerScroll ,
#if defined(ENABLE_OVERLOADING)
ResolveEventControllerScrollMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
EventControllerScrollGetFlagsMethodInfo ,
#endif
eventControllerScrollGetFlags ,
eventControllerScrollNew ,
#if defined(ENABLE_OVERLOADING)
EventControllerScrollSetFlagsMethodInfo ,
#endif
eventControllerScrollSetFlags ,
#if defined(ENABLE_OVERLOADING)
EventControllerScrollFlagsPropertyInfo ,
#endif
constructEventControllerScrollFlags ,
#if defined(ENABLE_OVERLOADING)
eventControllerScrollFlags ,
#endif
getEventControllerScrollFlags ,
setEventControllerScrollFlags ,
C_EventControllerScrollDecelerateCallback,
EventControllerScrollDecelerateCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerScrollDecelerateSignalInfo,
#endif
afterEventControllerScrollDecelerate ,
genClosure_EventControllerScrollDecelerate,
mk_EventControllerScrollDecelerateCallback,
noEventControllerScrollDecelerateCallback,
onEventControllerScrollDecelerate ,
wrap_EventControllerScrollDecelerateCallback,
C_EventControllerScrollScrollCallback ,
EventControllerScrollScrollCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerScrollScrollSignalInfo ,
#endif
afterEventControllerScrollScroll ,
genClosure_EventControllerScrollScroll ,
mk_EventControllerScrollScrollCallback ,
noEventControllerScrollScrollCallback ,
onEventControllerScrollScroll ,
wrap_EventControllerScrollScrollCallback,
C_EventControllerScrollScrollBeginCallback,
EventControllerScrollScrollBeginCallback,
#if defined(ENABLE_OVERLOADING)
EventControllerScrollScrollBeginSignalInfo,
#endif
afterEventControllerScrollScrollBegin ,
genClosure_EventControllerScrollScrollBegin,
mk_EventControllerScrollScrollBeginCallback,
noEventControllerScrollScrollBeginCallback,
onEventControllerScrollScrollBegin ,
wrap_EventControllerScrollScrollBeginCallback,
C_EventControllerScrollScrollEndCallback,
EventControllerScrollScrollEndCallback ,
#if defined(ENABLE_OVERLOADING)
EventControllerScrollScrollEndSignalInfo,
#endif
afterEventControllerScrollScrollEnd ,
genClosure_EventControllerScrollScrollEnd,
mk_EventControllerScrollScrollEndCallback,
noEventControllerScrollScrollEndCallback,
onEventControllerScrollScrollEnd ,
wrap_EventControllerScrollScrollEndCallback,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
newtype EventControllerScroll = EventControllerScroll (ManagedPtr EventControllerScroll)
deriving (Eq)
foreign import ccall "gtk_event_controller_scroll_get_type"
c_gtk_event_controller_scroll_get_type :: IO GType
instance GObject EventControllerScroll where
gobjectType = c_gtk_event_controller_scroll_get_type
instance B.GValue.IsGValue EventControllerScroll where
toGValue o = do
gtype <- c_gtk_event_controller_scroll_get_type
B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)
fromGValue gv = do
ptr <- B.GValue.get_object gv :: IO (Ptr EventControllerScroll)
B.ManagedPtr.newObject EventControllerScroll ptr
class (GObject o, O.IsDescendantOf EventControllerScroll o) => IsEventControllerScroll o
instance (GObject o, O.IsDescendantOf EventControllerScroll o) => IsEventControllerScroll o
instance O.HasParentTypes EventControllerScroll
type instance O.ParentTypes EventControllerScroll = '[Gtk.EventController.EventController, GObject.Object.Object]
toEventControllerScroll :: (MonadIO m, IsEventControllerScroll o) => o -> m EventControllerScroll
toEventControllerScroll = liftIO . unsafeCastTo EventControllerScroll
noEventControllerScroll :: Maybe EventControllerScroll
noEventControllerScroll = Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveEventControllerScrollMethod (t :: Symbol) (o :: *) :: * where
ResolveEventControllerScrollMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveEventControllerScrollMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveEventControllerScrollMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveEventControllerScrollMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveEventControllerScrollMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveEventControllerScrollMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo
ResolveEventControllerScrollMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveEventControllerScrollMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveEventControllerScrollMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveEventControllerScrollMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveEventControllerScrollMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveEventControllerScrollMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
ResolveEventControllerScrollMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveEventControllerScrollMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveEventControllerScrollMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveEventControllerScrollMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveEventControllerScrollMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveEventControllerScrollMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveEventControllerScrollMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveEventControllerScrollMethod "getFlags" o = EventControllerScrollGetFlagsMethodInfo
ResolveEventControllerScrollMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
ResolveEventControllerScrollMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveEventControllerScrollMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveEventControllerScrollMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
ResolveEventControllerScrollMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveEventControllerScrollMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveEventControllerScrollMethod "setFlags" o = EventControllerScrollSetFlagsMethodInfo
ResolveEventControllerScrollMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
ResolveEventControllerScrollMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveEventControllerScrollMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEventControllerScrollMethod t EventControllerScroll, O.MethodInfo info EventControllerScroll p) => OL.IsLabel t (EventControllerScroll -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type EventControllerScrollDecelerateCallback =
Double
-> Double
-> IO ()
noEventControllerScrollDecelerateCallback :: Maybe EventControllerScrollDecelerateCallback
noEventControllerScrollDecelerateCallback = Nothing
type C_EventControllerScrollDecelerateCallback =
Ptr () ->
CDouble ->
CDouble ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerScrollDecelerateCallback :: C_EventControllerScrollDecelerateCallback -> IO (FunPtr C_EventControllerScrollDecelerateCallback)
genClosure_EventControllerScrollDecelerate :: MonadIO m => EventControllerScrollDecelerateCallback -> m (GClosure C_EventControllerScrollDecelerateCallback)
genClosure_EventControllerScrollDecelerate cb = liftIO $ do
let cb' = wrap_EventControllerScrollDecelerateCallback cb
mk_EventControllerScrollDecelerateCallback cb' >>= B.GClosure.newGClosure
wrap_EventControllerScrollDecelerateCallback ::
EventControllerScrollDecelerateCallback ->
C_EventControllerScrollDecelerateCallback
wrap_EventControllerScrollDecelerateCallback _cb _ velX velY _ = do
let velX' = realToFrac velX
let velY' = realToFrac velY
_cb velX' velY'
onEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollDecelerateCallback -> m SignalHandlerId
onEventControllerScrollDecelerate obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollDecelerateCallback cb
cb'' <- mk_EventControllerScrollDecelerateCallback cb'
connectSignalFunPtr obj "decelerate" cb'' SignalConnectBefore Nothing
afterEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollDecelerateCallback -> m SignalHandlerId
afterEventControllerScrollDecelerate obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollDecelerateCallback cb
cb'' <- mk_EventControllerScrollDecelerateCallback cb'
connectSignalFunPtr obj "decelerate" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data EventControllerScrollDecelerateSignalInfo
instance SignalInfo EventControllerScrollDecelerateSignalInfo where
type HaskellCallbackType EventControllerScrollDecelerateSignalInfo = EventControllerScrollDecelerateCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EventControllerScrollDecelerateCallback cb
cb'' <- mk_EventControllerScrollDecelerateCallback cb'
connectSignalFunPtr obj "decelerate" cb'' connectMode detail
#endif
type EventControllerScrollScrollCallback =
Double
-> Double
-> IO ()
noEventControllerScrollScrollCallback :: Maybe EventControllerScrollScrollCallback
noEventControllerScrollScrollCallback = Nothing
type C_EventControllerScrollScrollCallback =
Ptr () ->
CDouble ->
CDouble ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerScrollScrollCallback :: C_EventControllerScrollScrollCallback -> IO (FunPtr C_EventControllerScrollScrollCallback)
genClosure_EventControllerScrollScroll :: MonadIO m => EventControllerScrollScrollCallback -> m (GClosure C_EventControllerScrollScrollCallback)
genClosure_EventControllerScrollScroll cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollCallback cb
mk_EventControllerScrollScrollCallback cb' >>= B.GClosure.newGClosure
wrap_EventControllerScrollScrollCallback ::
EventControllerScrollScrollCallback ->
C_EventControllerScrollScrollCallback
wrap_EventControllerScrollScrollCallback _cb _ dx dy _ = do
let dx' = realToFrac dx
let dy' = realToFrac dy
_cb dx' dy'
onEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollCallback -> m SignalHandlerId
onEventControllerScrollScroll obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollCallback cb
cb'' <- mk_EventControllerScrollScrollCallback cb'
connectSignalFunPtr obj "scroll" cb'' SignalConnectBefore Nothing
afterEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollCallback -> m SignalHandlerId
afterEventControllerScrollScroll obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollCallback cb
cb'' <- mk_EventControllerScrollScrollCallback cb'
connectSignalFunPtr obj "scroll" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data EventControllerScrollScrollSignalInfo
instance SignalInfo EventControllerScrollScrollSignalInfo where
type HaskellCallbackType EventControllerScrollScrollSignalInfo = EventControllerScrollScrollCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EventControllerScrollScrollCallback cb
cb'' <- mk_EventControllerScrollScrollCallback cb'
connectSignalFunPtr obj "scroll" cb'' connectMode detail
#endif
type EventControllerScrollScrollBeginCallback =
IO ()
noEventControllerScrollScrollBeginCallback :: Maybe EventControllerScrollScrollBeginCallback
noEventControllerScrollScrollBeginCallback = Nothing
type C_EventControllerScrollScrollBeginCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerScrollScrollBeginCallback :: C_EventControllerScrollScrollBeginCallback -> IO (FunPtr C_EventControllerScrollScrollBeginCallback)
genClosure_EventControllerScrollScrollBegin :: MonadIO m => EventControllerScrollScrollBeginCallback -> m (GClosure C_EventControllerScrollScrollBeginCallback)
genClosure_EventControllerScrollScrollBegin cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollBeginCallback cb
mk_EventControllerScrollScrollBeginCallback cb' >>= B.GClosure.newGClosure
wrap_EventControllerScrollScrollBeginCallback ::
EventControllerScrollScrollBeginCallback ->
C_EventControllerScrollScrollBeginCallback
wrap_EventControllerScrollScrollBeginCallback _cb _ _ = do
_cb
onEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollBeginCallback -> m SignalHandlerId
onEventControllerScrollScrollBegin obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollBeginCallback cb
cb'' <- mk_EventControllerScrollScrollBeginCallback cb'
connectSignalFunPtr obj "scroll-begin" cb'' SignalConnectBefore Nothing
afterEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollBeginCallback -> m SignalHandlerId
afterEventControllerScrollScrollBegin obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollBeginCallback cb
cb'' <- mk_EventControllerScrollScrollBeginCallback cb'
connectSignalFunPtr obj "scroll-begin" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data EventControllerScrollScrollBeginSignalInfo
instance SignalInfo EventControllerScrollScrollBeginSignalInfo where
type HaskellCallbackType EventControllerScrollScrollBeginSignalInfo = EventControllerScrollScrollBeginCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EventControllerScrollScrollBeginCallback cb
cb'' <- mk_EventControllerScrollScrollBeginCallback cb'
connectSignalFunPtr obj "scroll-begin" cb'' connectMode detail
#endif
type EventControllerScrollScrollEndCallback =
IO ()
noEventControllerScrollScrollEndCallback :: Maybe EventControllerScrollScrollEndCallback
noEventControllerScrollScrollEndCallback = Nothing
type C_EventControllerScrollScrollEndCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EventControllerScrollScrollEndCallback :: C_EventControllerScrollScrollEndCallback -> IO (FunPtr C_EventControllerScrollScrollEndCallback)
genClosure_EventControllerScrollScrollEnd :: MonadIO m => EventControllerScrollScrollEndCallback -> m (GClosure C_EventControllerScrollScrollEndCallback)
genClosure_EventControllerScrollScrollEnd cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollEndCallback cb
mk_EventControllerScrollScrollEndCallback cb' >>= B.GClosure.newGClosure
wrap_EventControllerScrollScrollEndCallback ::
EventControllerScrollScrollEndCallback ->
C_EventControllerScrollScrollEndCallback
wrap_EventControllerScrollScrollEndCallback _cb _ _ = do
_cb
onEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollEndCallback -> m SignalHandlerId
onEventControllerScrollScrollEnd obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollEndCallback cb
cb'' <- mk_EventControllerScrollScrollEndCallback cb'
connectSignalFunPtr obj "scroll-end" cb'' SignalConnectBefore Nothing
afterEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> EventControllerScrollScrollEndCallback -> m SignalHandlerId
afterEventControllerScrollScrollEnd obj cb = liftIO $ do
let cb' = wrap_EventControllerScrollScrollEndCallback cb
cb'' <- mk_EventControllerScrollScrollEndCallback cb'
connectSignalFunPtr obj "scroll-end" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data EventControllerScrollScrollEndSignalInfo
instance SignalInfo EventControllerScrollScrollEndSignalInfo where
type HaskellCallbackType EventControllerScrollScrollEndSignalInfo = EventControllerScrollScrollEndCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EventControllerScrollScrollEndCallback cb
cb'' <- mk_EventControllerScrollScrollEndCallback cb'
connectSignalFunPtr obj "scroll-end" cb'' connectMode detail
#endif
getEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> m [Gtk.Flags.EventControllerScrollFlags]
getEventControllerScrollFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags"
setEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> [Gtk.Flags.EventControllerScrollFlags] -> m ()
setEventControllerScrollFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val
constructEventControllerScrollFlags :: (IsEventControllerScroll o) => [Gtk.Flags.EventControllerScrollFlags] -> IO (GValueConstruct o)
constructEventControllerScrollFlags val = B.Properties.constructObjectPropertyFlags "flags" val
#if defined(ENABLE_OVERLOADING)
data EventControllerScrollFlagsPropertyInfo
instance AttrInfo EventControllerScrollFlagsPropertyInfo where
type AttrAllowedOps EventControllerScrollFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint EventControllerScrollFlagsPropertyInfo = IsEventControllerScroll
type AttrSetTypeConstraint EventControllerScrollFlagsPropertyInfo = (~) [Gtk.Flags.EventControllerScrollFlags]
type AttrTransferTypeConstraint EventControllerScrollFlagsPropertyInfo = (~) [Gtk.Flags.EventControllerScrollFlags]
type AttrTransferType EventControllerScrollFlagsPropertyInfo = [Gtk.Flags.EventControllerScrollFlags]
type AttrGetType EventControllerScrollFlagsPropertyInfo = [Gtk.Flags.EventControllerScrollFlags]
type AttrLabel EventControllerScrollFlagsPropertyInfo = "flags"
type AttrOrigin EventControllerScrollFlagsPropertyInfo = EventControllerScroll
attrGet = getEventControllerScrollFlags
attrSet = setEventControllerScrollFlags
attrTransfer _ v = do
return v
attrConstruct = constructEventControllerScrollFlags
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventControllerScroll
type instance O.AttributeList EventControllerScroll = EventControllerScrollAttributeList
type EventControllerScrollAttributeList = ('[ '("flags", EventControllerScrollFlagsPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
eventControllerScrollFlags :: AttrLabelProxy "flags"
eventControllerScrollFlags = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList EventControllerScroll = EventControllerScrollSignalList
type EventControllerScrollSignalList = ('[ '("decelerate", EventControllerScrollDecelerateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("scroll", EventControllerScrollScrollSignalInfo), '("scrollBegin", EventControllerScrollScrollBeginSignalInfo), '("scrollEnd", EventControllerScrollScrollEndSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_event_controller_scroll_new" gtk_event_controller_scroll_new ::
Ptr Gtk.Widget.Widget ->
CUInt ->
IO (Ptr EventControllerScroll)
eventControllerScrollNew ::
(B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) =>
a
-> [Gtk.Flags.EventControllerScrollFlags]
-> m EventControllerScroll
eventControllerScrollNew widget flags = liftIO $ do
widget' <- unsafeManagedPtrCastPtr widget
let flags' = gflagsToWord flags
result <- gtk_event_controller_scroll_new widget' flags'
checkUnexpectedReturnNULL "eventControllerScrollNew" result
result' <- (wrapObject EventControllerScroll) result
touchManagedPtr widget
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_event_controller_scroll_get_flags" gtk_event_controller_scroll_get_flags ::
Ptr EventControllerScroll ->
IO CUInt
eventControllerScrollGetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerScroll a) =>
a
-> m [Gtk.Flags.EventControllerScrollFlags]
eventControllerScrollGetFlags controller = liftIO $ do
controller' <- unsafeManagedPtrCastPtr controller
result <- gtk_event_controller_scroll_get_flags controller'
let result' = wordToGFlags result
touchManagedPtr controller
return result'
#if defined(ENABLE_OVERLOADING)
data EventControllerScrollGetFlagsMethodInfo
instance (signature ~ (m [Gtk.Flags.EventControllerScrollFlags]), MonadIO m, IsEventControllerScroll a) => O.MethodInfo EventControllerScrollGetFlagsMethodInfo a signature where
overloadedMethod = eventControllerScrollGetFlags
#endif
foreign import ccall "gtk_event_controller_scroll_set_flags" gtk_event_controller_scroll_set_flags ::
Ptr EventControllerScroll ->
CUInt ->
IO ()
eventControllerScrollSetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsEventControllerScroll a) =>
a
-> [Gtk.Flags.EventControllerScrollFlags]
-> m ()
eventControllerScrollSetFlags controller flags = liftIO $ do
controller' <- unsafeManagedPtrCastPtr controller
let flags' = gflagsToWord flags
gtk_event_controller_scroll_set_flags controller' flags'
touchManagedPtr controller
return ()
#if defined(ENABLE_OVERLOADING)
data EventControllerScrollSetFlagsMethodInfo
instance (signature ~ ([Gtk.Flags.EventControllerScrollFlags] -> m ()), MonadIO m, IsEventControllerScroll a) => O.MethodInfo EventControllerScrollSetFlagsMethodInfo a signature where
overloadedMethod = eventControllerScrollSetFlags
#endif