{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll' is an event controller meant to handle scroll events from mice and touchpads. It is capable of handling both discrete and continuous scroll events, abstracting them both on the 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'::@/scroll/@ signal (deltas in the discrete case are multiples of 1). In the case of continuous scroll events, 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll' encloses all 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'::@/scroll/@ events between two 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'::@/scroll-begin/@ and 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'::@/scroll-end/@ signals. The behavior of the event controller can be modified by the flags given at creation time, or modified at a later point through 'GI.Gtk.Objects.EventControllerScroll.eventControllerScrollSetFlags' (e.g. because the scrolling conditions of the widget changed). The controller can be set up to emit motion for either\/both vertical and horizontal scroll events through @/GTK_EVENT_CONTROLLER_SCROLL_VERTICAL/@, @/GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL/@ and @/GTK_EVENT_CONTROLLER_SCROLL_BOTH/@. If any axis is disabled, the respective 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'::@/scroll/@ delta will be 0. Vertical scroll events will be translated to horizontal motion for the devices incapable of horizontal scrolling. The event controller can also be forced to emit discrete events on all devices through @/GTK_EVENT_CONTROLLER_SCROLL_DISCRETE/@. This can be used to implement discrete actions triggered through scroll events (e.g. switching across combobox options). The @/GTK_EVENT_CONTROLLER_SCROLL_KINETIC/@ flag toggles the emission of the 'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'::@/decelerate/@ signal, emitted at the end of scrolling with two X\/Y velocity arguments that are consistent with the motion that was received. This object was added in 3.24. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Objects.EventControllerScroll ( -- * Exported types EventControllerScroll(..) , IsEventControllerScroll , toEventControllerScroll , noEventControllerScroll , -- * Methods -- ** getFlags #method:getFlags# #if ENABLE_OVERLOADING EventControllerScrollGetFlagsMethodInfo , #endif eventControllerScrollGetFlags , -- ** new #method:new# eventControllerScrollNew , -- ** setFlags #method:setFlags# #if ENABLE_OVERLOADING EventControllerScrollSetFlagsMethodInfo , #endif eventControllerScrollSetFlags , -- * Properties -- ** flags #attr:flags# {- | The flags affecting event controller behavior /Since: 3.24/ -} #if ENABLE_OVERLOADING EventControllerScrollFlagsPropertyInfo , #endif constructEventControllerScrollFlags , #if ENABLE_OVERLOADING eventControllerScrollFlags , #endif getEventControllerScrollFlags , setEventControllerScrollFlags , -- * Signals -- ** decelerate #signal:decelerate# C_EventControllerScrollDecelerateCallback, EventControllerScrollDecelerateCallback , #if ENABLE_OVERLOADING EventControllerScrollDecelerateSignalInfo, #endif afterEventControllerScrollDecelerate , genClosure_EventControllerScrollDecelerate, mk_EventControllerScrollDecelerateCallback, noEventControllerScrollDecelerateCallback, onEventControllerScrollDecelerate , wrap_EventControllerScrollDecelerateCallback, -- ** scroll #signal:scroll# C_EventControllerScrollScrollCallback , EventControllerScrollScrollCallback , #if ENABLE_OVERLOADING EventControllerScrollScrollSignalInfo , #endif afterEventControllerScrollScroll , genClosure_EventControllerScrollScroll , mk_EventControllerScrollScrollCallback , noEventControllerScrollScrollCallback , onEventControllerScrollScroll , wrap_EventControllerScrollScrollCallback, -- ** scrollBegin #signal:scrollBegin# C_EventControllerScrollScrollBeginCallback, EventControllerScrollScrollBeginCallback, #if ENABLE_OVERLOADING EventControllerScrollScrollBeginSignalInfo, #endif afterEventControllerScrollScrollBegin , genClosure_EventControllerScrollScrollBegin, mk_EventControllerScrollScrollBeginCallback, noEventControllerScrollScrollBeginCallback, onEventControllerScrollScrollBegin , wrap_EventControllerScrollScrollBeginCallback, -- ** scrollEnd #signal:scrollEnd# C_EventControllerScrollScrollEndCallback, EventControllerScrollScrollEndCallback , #if 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.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 -- | Memory-managed wrapper type. newtype EventControllerScroll = EventControllerScroll (ManagedPtr EventControllerScroll) 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 -- | Type class for types which can be safely cast to `EventControllerScroll`, for instance with `toEventControllerScroll`. 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] -- | Cast to `EventControllerScroll`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toEventControllerScroll :: (MonadIO m, IsEventControllerScroll o) => o -> m EventControllerScroll toEventControllerScroll = liftIO . unsafeCastTo EventControllerScroll -- | A convenience alias for `Nothing` :: `Maybe` `EventControllerScroll`. noEventControllerScroll :: Maybe EventControllerScroll noEventControllerScroll = Nothing #if 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 "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 (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal EventControllerScroll::decelerate {- | Emitted after scroll is finished if the @/GTK_EVENT_CONTROLLER_SCROLL_KINETIC/@ flag is set. /@velX@/ and /@velY@/ express the initial velocity that was imprinted by the scroll events. /@velX@/ and /@velY@/ are expressed in pixels\/ms. -} type EventControllerScrollDecelerateCallback = Double {- ^ /@velX@/: X velocity -} -> Double {- ^ /@velY@/: Y velocity -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerScrollDecelerateCallback`@. noEventControllerScrollDecelerateCallback :: Maybe EventControllerScrollDecelerateCallback noEventControllerScrollDecelerateCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_EventControllerScrollDecelerateCallback = Ptr () -> -- object CDouble -> CDouble -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_EventControllerScrollDecelerateCallback`. foreign import ccall "wrapper" mk_EventControllerScrollDecelerateCallback :: C_EventControllerScrollDecelerateCallback -> IO (FunPtr C_EventControllerScrollDecelerateCallback) -- | Wrap the callback into a `GClosure`. 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 a `EventControllerScrollDecelerateCallback` into a `C_EventControllerScrollDecelerateCallback`. wrap_EventControllerScrollDecelerateCallback :: EventControllerScrollDecelerateCallback -> C_EventControllerScrollDecelerateCallback wrap_EventControllerScrollDecelerateCallback _cb _ velX velY _ = do let velX' = realToFrac velX let velY' = realToFrac velY _cb velX' velY' {- | Connect a signal handler for the “@decelerate@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' eventControllerScroll #decelerate callback @ -} 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 {- | Connect a signal handler for the “@decelerate@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' eventControllerScroll #decelerate callback @ -} 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 -- signal EventControllerScroll::scroll {- | Signals that the widget should scroll by the amount specified by /@dx@/ and /@dy@/. -} type EventControllerScrollScrollCallback = Double {- ^ /@dx@/: X delta -} -> Double {- ^ /@dy@/: Y delta -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerScrollScrollCallback`@. noEventControllerScrollScrollCallback :: Maybe EventControllerScrollScrollCallback noEventControllerScrollScrollCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_EventControllerScrollScrollCallback = Ptr () -> -- object CDouble -> CDouble -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_EventControllerScrollScrollCallback`. foreign import ccall "wrapper" mk_EventControllerScrollScrollCallback :: C_EventControllerScrollScrollCallback -> IO (FunPtr C_EventControllerScrollScrollCallback) -- | Wrap the callback into a `GClosure`. 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 a `EventControllerScrollScrollCallback` into a `C_EventControllerScrollScrollCallback`. wrap_EventControllerScrollScrollCallback :: EventControllerScrollScrollCallback -> C_EventControllerScrollScrollCallback wrap_EventControllerScrollScrollCallback _cb _ dx dy _ = do let dx' = realToFrac dx let dy' = realToFrac dy _cb dx' dy' {- | Connect a signal handler for the “@scroll@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' eventControllerScroll #scroll callback @ -} 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 {- | Connect a signal handler for the “@scroll@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' eventControllerScroll #scroll callback @ -} 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 -- signal EventControllerScroll::scroll-begin {- | Signals that a new scrolling operation has begun. It will only be emitted on devices capable of it. -} type EventControllerScrollScrollBeginCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerScrollScrollBeginCallback`@. noEventControllerScrollScrollBeginCallback :: Maybe EventControllerScrollScrollBeginCallback noEventControllerScrollScrollBeginCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_EventControllerScrollScrollBeginCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_EventControllerScrollScrollBeginCallback`. foreign import ccall "wrapper" mk_EventControllerScrollScrollBeginCallback :: C_EventControllerScrollScrollBeginCallback -> IO (FunPtr C_EventControllerScrollScrollBeginCallback) -- | Wrap the callback into a `GClosure`. 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 a `EventControllerScrollScrollBeginCallback` into a `C_EventControllerScrollScrollBeginCallback`. wrap_EventControllerScrollScrollBeginCallback :: EventControllerScrollScrollBeginCallback -> C_EventControllerScrollScrollBeginCallback wrap_EventControllerScrollScrollBeginCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@scroll-begin@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' eventControllerScroll #scrollBegin callback @ -} 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 {- | Connect a signal handler for the “@scroll-begin@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' eventControllerScroll #scrollBegin callback @ -} 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 -- signal EventControllerScroll::scroll-end {- | Signals that a new scrolling operation has finished. It will only be emitted on devices capable of it. -} type EventControllerScrollScrollEndCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `EventControllerScrollScrollEndCallback`@. noEventControllerScrollScrollEndCallback :: Maybe EventControllerScrollScrollEndCallback noEventControllerScrollScrollEndCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_EventControllerScrollScrollEndCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_EventControllerScrollScrollEndCallback`. foreign import ccall "wrapper" mk_EventControllerScrollScrollEndCallback :: C_EventControllerScrollScrollEndCallback -> IO (FunPtr C_EventControllerScrollScrollEndCallback) -- | Wrap the callback into a `GClosure`. 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 a `EventControllerScrollScrollEndCallback` into a `C_EventControllerScrollScrollEndCallback`. wrap_EventControllerScrollScrollEndCallback :: EventControllerScrollScrollEndCallback -> C_EventControllerScrollScrollEndCallback wrap_EventControllerScrollScrollEndCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@scroll-end@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' eventControllerScroll #scrollEnd callback @ -} 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 {- | Connect a signal handler for the “@scroll-end@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' eventControllerScroll #scrollEnd callback @ -} 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 -- VVV Prop "flags" -- Type: TInterface (Name {namespace = "Gtk", name = "EventControllerScrollFlags"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@flags@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' eventControllerScroll #flags @ -} getEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> m [Gtk.Flags.EventControllerScrollFlags] getEventControllerScrollFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags" {- | Set the value of the “@flags@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' eventControllerScroll [ #flags 'Data.GI.Base.Attributes.:=' value ] @ -} setEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> [Gtk.Flags.EventControllerScrollFlags] -> m () setEventControllerScrollFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val {- | Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructEventControllerScrollFlags :: (IsEventControllerScroll o) => [Gtk.Flags.EventControllerScrollFlags] -> IO (GValueConstruct o) constructEventControllerScrollFlags val = B.Properties.constructObjectPropertyFlags "flags" val #if ENABLE_OVERLOADING data EventControllerScrollFlagsPropertyInfo instance AttrInfo EventControllerScrollFlagsPropertyInfo where type AttrAllowedOps EventControllerScrollFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint EventControllerScrollFlagsPropertyInfo = (~) [Gtk.Flags.EventControllerScrollFlags] type AttrBaseTypeConstraint EventControllerScrollFlagsPropertyInfo = IsEventControllerScroll type AttrGetType EventControllerScrollFlagsPropertyInfo = [Gtk.Flags.EventControllerScrollFlags] type AttrLabel EventControllerScrollFlagsPropertyInfo = "flags" type AttrOrigin EventControllerScrollFlagsPropertyInfo = EventControllerScroll attrGet _ = getEventControllerScrollFlags attrSet _ = setEventControllerScrollFlags attrConstruct _ = constructEventControllerScrollFlags attrClear _ = undefined #endif #if 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 ENABLE_OVERLOADING eventControllerScrollFlags :: AttrLabelProxy "flags" eventControllerScrollFlags = AttrLabelProxy #endif #if ENABLE_OVERLOADING data EventControllerScrollDecelerateSignalInfo instance SignalInfo EventControllerScrollDecelerateSignalInfo where type HaskellCallbackType EventControllerScrollDecelerateSignalInfo = EventControllerScrollDecelerateCallback connectSignal _ obj cb connectMode = do let cb' = wrap_EventControllerScrollDecelerateCallback cb cb'' <- mk_EventControllerScrollDecelerateCallback cb' connectSignalFunPtr obj "decelerate" cb'' connectMode data EventControllerScrollScrollSignalInfo instance SignalInfo EventControllerScrollScrollSignalInfo where type HaskellCallbackType EventControllerScrollScrollSignalInfo = EventControllerScrollScrollCallback connectSignal _ obj cb connectMode = do let cb' = wrap_EventControllerScrollScrollCallback cb cb'' <- mk_EventControllerScrollScrollCallback cb' connectSignalFunPtr obj "scroll" cb'' connectMode data EventControllerScrollScrollBeginSignalInfo instance SignalInfo EventControllerScrollScrollBeginSignalInfo where type HaskellCallbackType EventControllerScrollScrollBeginSignalInfo = EventControllerScrollScrollBeginCallback connectSignal _ obj cb connectMode = do let cb' = wrap_EventControllerScrollScrollBeginCallback cb cb'' <- mk_EventControllerScrollScrollBeginCallback cb' connectSignalFunPtr obj "scroll-begin" cb'' connectMode data EventControllerScrollScrollEndSignalInfo instance SignalInfo EventControllerScrollScrollEndSignalInfo where type HaskellCallbackType EventControllerScrollScrollEndSignalInfo = EventControllerScrollScrollEndCallback connectSignal _ obj cb connectMode = do let cb' = wrap_EventControllerScrollScrollEndCallback cb cb'' <- mk_EventControllerScrollScrollEndCallback cb' connectSignalFunPtr obj "scroll-end" cb'' connectMode type instance O.SignalList EventControllerScroll = EventControllerScrollSignalList type EventControllerScrollSignalList = ('[ '("decelerate", EventControllerScrollDecelerateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("scroll", EventControllerScrollScrollSignalInfo), '("scrollBegin", EventControllerScrollScrollBeginSignalInfo), '("scrollEnd", EventControllerScrollScrollEndSignalInfo)] :: [(Symbol, *)]) #endif -- method EventControllerScroll::new -- method type : Constructor -- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "EventControllerScrollFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "behavior flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "EventControllerScroll"})) -- throws : False -- Skip return : False foreign import ccall "gtk_event_controller_scroll_new" gtk_event_controller_scroll_new :: Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) CUInt -> -- flags : TInterface (Name {namespace = "Gtk", name = "EventControllerScrollFlags"}) IO (Ptr EventControllerScroll) {- | Creates a new event controller that will handle scroll events for the given /@widget@/. /Since: 3.24/ -} eventControllerScrollNew :: (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) => a {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -} -> [Gtk.Flags.EventControllerScrollFlags] {- ^ /@flags@/: behavior flags -} -> m EventControllerScroll {- ^ __Returns:__ a new 'GI.Gtk.Objects.EventControllerScroll.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 ENABLE_OVERLOADING #endif -- method EventControllerScroll::get_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "controller", argType = TInterface (Name {namespace = "Gtk", name = "EventControllerScroll"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "EventControllerScrollFlags"})) -- throws : False -- Skip return : False foreign import ccall "gtk_event_controller_scroll_get_flags" gtk_event_controller_scroll_get_flags :: Ptr EventControllerScroll -> -- controller : TInterface (Name {namespace = "Gtk", name = "EventControllerScroll"}) IO CUInt {- | Gets the flags conditioning the scroll controller behavior. /Since: 3.24/ -} eventControllerScrollGetFlags :: (B.CallStack.HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> m [Gtk.Flags.EventControllerScrollFlags] {- ^ __Returns:__ the controller flags. -} eventControllerScrollGetFlags controller = liftIO $ do controller' <- unsafeManagedPtrCastPtr controller result <- gtk_event_controller_scroll_get_flags controller' let result' = wordToGFlags result touchManagedPtr controller return result' #if ENABLE_OVERLOADING data EventControllerScrollGetFlagsMethodInfo instance (signature ~ (m [Gtk.Flags.EventControllerScrollFlags]), MonadIO m, IsEventControllerScroll a) => O.MethodInfo EventControllerScrollGetFlagsMethodInfo a signature where overloadedMethod _ = eventControllerScrollGetFlags #endif -- method EventControllerScroll::set_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "controller", argType = TInterface (Name {namespace = "Gtk", name = "EventControllerScroll"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "EventControllerScrollFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "behavior flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_event_controller_scroll_set_flags" gtk_event_controller_scroll_set_flags :: Ptr EventControllerScroll -> -- controller : TInterface (Name {namespace = "Gtk", name = "EventControllerScroll"}) CUInt -> -- flags : TInterface (Name {namespace = "Gtk", name = "EventControllerScrollFlags"}) IO () {- | Sets the flags conditioning scroll controller behavior. /Since: 3.24/ -} eventControllerScrollSetFlags :: (B.CallStack.HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> [Gtk.Flags.EventControllerScrollFlags] {- ^ /@flags@/: behavior flags -} -> 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 ENABLE_OVERLOADING data EventControllerScrollSetFlagsMethodInfo instance (signature ~ ([Gtk.Flags.EventControllerScrollFlags] -> m ()), MonadIO m, IsEventControllerScroll a) => O.MethodInfo EventControllerScrollSetFlagsMethodInfo a signature where overloadedMethod _ = eventControllerScrollSetFlags #endif