{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.GestureSingle
(
GestureSingle(..) ,
IsGestureSingle ,
toGestureSingle ,
noGestureSingle ,
#if defined(ENABLE_OVERLOADING)
ResolveGestureSingleMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
GestureSingleGetButtonMethodInfo ,
#endif
gestureSingleGetButton ,
#if defined(ENABLE_OVERLOADING)
GestureSingleGetCurrentButtonMethodInfo ,
#endif
gestureSingleGetCurrentButton ,
#if defined(ENABLE_OVERLOADING)
GestureSingleGetCurrentSequenceMethodInfo,
#endif
gestureSingleGetCurrentSequence ,
#if defined(ENABLE_OVERLOADING)
GestureSingleGetExclusiveMethodInfo ,
#endif
gestureSingleGetExclusive ,
#if defined(ENABLE_OVERLOADING)
GestureSingleGetTouchOnlyMethodInfo ,
#endif
gestureSingleGetTouchOnly ,
#if defined(ENABLE_OVERLOADING)
GestureSingleSetButtonMethodInfo ,
#endif
gestureSingleSetButton ,
#if defined(ENABLE_OVERLOADING)
GestureSingleSetExclusiveMethodInfo ,
#endif
gestureSingleSetExclusive ,
#if defined(ENABLE_OVERLOADING)
GestureSingleSetTouchOnlyMethodInfo ,
#endif
gestureSingleSetTouchOnly ,
#if defined(ENABLE_OVERLOADING)
GestureSingleButtonPropertyInfo ,
#endif
constructGestureSingleButton ,
#if defined(ENABLE_OVERLOADING)
gestureSingleButton ,
#endif
getGestureSingleButton ,
setGestureSingleButton ,
#if defined(ENABLE_OVERLOADING)
GestureSingleExclusivePropertyInfo ,
#endif
constructGestureSingleExclusive ,
#if defined(ENABLE_OVERLOADING)
gestureSingleExclusive ,
#endif
getGestureSingleExclusive ,
setGestureSingleExclusive ,
#if defined(ENABLE_OVERLOADING)
GestureSingleTouchOnlyPropertyInfo ,
#endif
constructGestureSingleTouchOnly ,
#if defined(ENABLE_OVERLOADING)
gestureSingleTouchOnly ,
#endif
getGestureSingleTouchOnly ,
setGestureSingleTouchOnly ,
) 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 qualified GI.Gdk.Structs.EventSequence as Gdk.EventSequence
import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController
import {-# SOURCE #-} qualified GI.Gtk.Objects.Gesture as Gtk.Gesture
newtype GestureSingle = GestureSingle (ManagedPtr GestureSingle)
deriving (Eq)
foreign import ccall "gtk_gesture_single_get_type"
c_gtk_gesture_single_get_type :: IO GType
instance GObject GestureSingle where
gobjectType = c_gtk_gesture_single_get_type
instance B.GValue.IsGValue GestureSingle where
toGValue o = do
gtype <- c_gtk_gesture_single_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 GestureSingle)
B.ManagedPtr.newObject GestureSingle ptr
class (GObject o, O.IsDescendantOf GestureSingle o) => IsGestureSingle o
instance (GObject o, O.IsDescendantOf GestureSingle o) => IsGestureSingle o
instance O.HasParentTypes GestureSingle
type instance O.ParentTypes GestureSingle = '[Gtk.Gesture.Gesture, Gtk.EventController.EventController, GObject.Object.Object]
toGestureSingle :: (MonadIO m, IsGestureSingle o) => o -> m GestureSingle
toGestureSingle = liftIO . unsafeCastTo GestureSingle
noGestureSingle :: Maybe GestureSingle
noGestureSingle = Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveGestureSingleMethod (t :: Symbol) (o :: *) :: * where
ResolveGestureSingleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveGestureSingleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveGestureSingleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveGestureSingleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveGestureSingleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveGestureSingleMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo
ResolveGestureSingleMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo
ResolveGestureSingleMethod "handlesSequence" o = Gtk.Gesture.GestureHandlesSequenceMethodInfo
ResolveGestureSingleMethod "isActive" o = Gtk.Gesture.GestureIsActiveMethodInfo
ResolveGestureSingleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveGestureSingleMethod "isGroupedWith" o = Gtk.Gesture.GestureIsGroupedWithMethodInfo
ResolveGestureSingleMethod "isRecognized" o = Gtk.Gesture.GestureIsRecognizedMethodInfo
ResolveGestureSingleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveGestureSingleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveGestureSingleMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveGestureSingleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveGestureSingleMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
ResolveGestureSingleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveGestureSingleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveGestureSingleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveGestureSingleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveGestureSingleMethod "ungroup" o = Gtk.Gesture.GestureUngroupMethodInfo
ResolveGestureSingleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveGestureSingleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveGestureSingleMethod "getBoundingBox" o = Gtk.Gesture.GestureGetBoundingBoxMethodInfo
ResolveGestureSingleMethod "getBoundingBoxCenter" o = Gtk.Gesture.GestureGetBoundingBoxCenterMethodInfo
ResolveGestureSingleMethod "getButton" o = GestureSingleGetButtonMethodInfo
ResolveGestureSingleMethod "getCurrentButton" o = GestureSingleGetCurrentButtonMethodInfo
ResolveGestureSingleMethod "getCurrentSequence" o = GestureSingleGetCurrentSequenceMethodInfo
ResolveGestureSingleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveGestureSingleMethod "getDevice" o = Gtk.Gesture.GestureGetDeviceMethodInfo
ResolveGestureSingleMethod "getExclusive" o = GestureSingleGetExclusiveMethodInfo
ResolveGestureSingleMethod "getGroup" o = Gtk.Gesture.GestureGetGroupMethodInfo
ResolveGestureSingleMethod "getLastEvent" o = Gtk.Gesture.GestureGetLastEventMethodInfo
ResolveGestureSingleMethod "getLastUpdatedSequence" o = Gtk.Gesture.GestureGetLastUpdatedSequenceMethodInfo
ResolveGestureSingleMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo
ResolveGestureSingleMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
ResolveGestureSingleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveGestureSingleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveGestureSingleMethod "getSequenceState" o = Gtk.Gesture.GestureGetSequenceStateMethodInfo
ResolveGestureSingleMethod "getSequences" o = Gtk.Gesture.GestureGetSequencesMethodInfo
ResolveGestureSingleMethod "getTouchOnly" o = GestureSingleGetTouchOnlyMethodInfo
ResolveGestureSingleMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
ResolveGestureSingleMethod "getWindow" o = Gtk.Gesture.GestureGetWindowMethodInfo
ResolveGestureSingleMethod "setButton" o = GestureSingleSetButtonMethodInfo
ResolveGestureSingleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveGestureSingleMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveGestureSingleMethod "setExclusive" o = GestureSingleSetExclusiveMethodInfo
ResolveGestureSingleMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
ResolveGestureSingleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveGestureSingleMethod "setSequenceState" o = Gtk.Gesture.GestureSetSequenceStateMethodInfo
ResolveGestureSingleMethod "setState" o = Gtk.Gesture.GestureSetStateMethodInfo
ResolveGestureSingleMethod "setTouchOnly" o = GestureSingleSetTouchOnlyMethodInfo
ResolveGestureSingleMethod "setWindow" o = Gtk.Gesture.GestureSetWindowMethodInfo
ResolveGestureSingleMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveGestureSingleMethod t GestureSingle, O.MethodInfo info GestureSingle p) => OL.IsLabel t (GestureSingle -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
getGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> m Word32
getGestureSingleButton obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "button"
setGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> Word32 -> m ()
setGestureSingleButton obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "button" val
constructGestureSingleButton :: (IsGestureSingle o) => Word32 -> IO (GValueConstruct o)
constructGestureSingleButton val = B.Properties.constructObjectPropertyUInt32 "button" val
#if defined(ENABLE_OVERLOADING)
data GestureSingleButtonPropertyInfo
instance AttrInfo GestureSingleButtonPropertyInfo where
type AttrAllowedOps GestureSingleButtonPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint GestureSingleButtonPropertyInfo = IsGestureSingle
type AttrSetTypeConstraint GestureSingleButtonPropertyInfo = (~) Word32
type AttrTransferTypeConstraint GestureSingleButtonPropertyInfo = (~) Word32
type AttrTransferType GestureSingleButtonPropertyInfo = Word32
type AttrGetType GestureSingleButtonPropertyInfo = Word32
type AttrLabel GestureSingleButtonPropertyInfo = "button"
type AttrOrigin GestureSingleButtonPropertyInfo = GestureSingle
attrGet = getGestureSingleButton
attrSet = setGestureSingleButton
attrTransfer _ v = do
return v
attrConstruct = constructGestureSingleButton
attrClear = undefined
#endif
getGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> m Bool
getGestureSingleExclusive obj = liftIO $ B.Properties.getObjectPropertyBool obj "exclusive"
setGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()
setGestureSingleExclusive obj val = liftIO $ B.Properties.setObjectPropertyBool obj "exclusive" val
constructGestureSingleExclusive :: (IsGestureSingle o) => Bool -> IO (GValueConstruct o)
constructGestureSingleExclusive val = B.Properties.constructObjectPropertyBool "exclusive" val
#if defined(ENABLE_OVERLOADING)
data GestureSingleExclusivePropertyInfo
instance AttrInfo GestureSingleExclusivePropertyInfo where
type AttrAllowedOps GestureSingleExclusivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint GestureSingleExclusivePropertyInfo = IsGestureSingle
type AttrSetTypeConstraint GestureSingleExclusivePropertyInfo = (~) Bool
type AttrTransferTypeConstraint GestureSingleExclusivePropertyInfo = (~) Bool
type AttrTransferType GestureSingleExclusivePropertyInfo = Bool
type AttrGetType GestureSingleExclusivePropertyInfo = Bool
type AttrLabel GestureSingleExclusivePropertyInfo = "exclusive"
type AttrOrigin GestureSingleExclusivePropertyInfo = GestureSingle
attrGet = getGestureSingleExclusive
attrSet = setGestureSingleExclusive
attrTransfer _ v = do
return v
attrConstruct = constructGestureSingleExclusive
attrClear = undefined
#endif
getGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> m Bool
getGestureSingleTouchOnly obj = liftIO $ B.Properties.getObjectPropertyBool obj "touch-only"
setGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()
setGestureSingleTouchOnly obj val = liftIO $ B.Properties.setObjectPropertyBool obj "touch-only" val
constructGestureSingleTouchOnly :: (IsGestureSingle o) => Bool -> IO (GValueConstruct o)
constructGestureSingleTouchOnly val = B.Properties.constructObjectPropertyBool "touch-only" val
#if defined(ENABLE_OVERLOADING)
data GestureSingleTouchOnlyPropertyInfo
instance AttrInfo GestureSingleTouchOnlyPropertyInfo where
type AttrAllowedOps GestureSingleTouchOnlyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint GestureSingleTouchOnlyPropertyInfo = IsGestureSingle
type AttrSetTypeConstraint GestureSingleTouchOnlyPropertyInfo = (~) Bool
type AttrTransferTypeConstraint GestureSingleTouchOnlyPropertyInfo = (~) Bool
type AttrTransferType GestureSingleTouchOnlyPropertyInfo = Bool
type AttrGetType GestureSingleTouchOnlyPropertyInfo = Bool
type AttrLabel GestureSingleTouchOnlyPropertyInfo = "touch-only"
type AttrOrigin GestureSingleTouchOnlyPropertyInfo = GestureSingle
attrGet = getGestureSingleTouchOnly
attrSet = setGestureSingleTouchOnly
attrTransfer _ v = do
return v
attrConstruct = constructGestureSingleTouchOnly
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList GestureSingle
type instance O.AttributeList GestureSingle = GestureSingleAttributeList
type GestureSingleAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("touchOnly", GestureSingleTouchOnlyPropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo), '("window", Gtk.Gesture.GestureWindowPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
gestureSingleButton :: AttrLabelProxy "button"
gestureSingleButton = AttrLabelProxy
gestureSingleExclusive :: AttrLabelProxy "exclusive"
gestureSingleExclusive = AttrLabelProxy
gestureSingleTouchOnly :: AttrLabelProxy "touchOnly"
gestureSingleTouchOnly = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList GestureSingle = GestureSingleSignalList
type GestureSingleSignalList = ('[ '("begin", Gtk.Gesture.GestureBeginSignalInfo), '("cancel", Gtk.Gesture.GestureCancelSignalInfo), '("end", Gtk.Gesture.GestureEndSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sequenceStateChanged", Gtk.Gesture.GestureSequenceStateChangedSignalInfo), '("update", Gtk.Gesture.GestureUpdateSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_gesture_single_get_button" gtk_gesture_single_get_button ::
Ptr GestureSingle ->
IO Word32
gestureSingleGetButton ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> m Word32
gestureSingleGetButton gesture = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
result <- gtk_gesture_single_get_button gesture'
touchManagedPtr gesture
return result
#if defined(ENABLE_OVERLOADING)
data GestureSingleGetButtonMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleGetButtonMethodInfo a signature where
overloadedMethod = gestureSingleGetButton
#endif
foreign import ccall "gtk_gesture_single_get_current_button" gtk_gesture_single_get_current_button ::
Ptr GestureSingle ->
IO Word32
gestureSingleGetCurrentButton ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> m Word32
gestureSingleGetCurrentButton gesture = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
result <- gtk_gesture_single_get_current_button gesture'
touchManagedPtr gesture
return result
#if defined(ENABLE_OVERLOADING)
data GestureSingleGetCurrentButtonMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleGetCurrentButtonMethodInfo a signature where
overloadedMethod = gestureSingleGetCurrentButton
#endif
foreign import ccall "gtk_gesture_single_get_current_sequence" gtk_gesture_single_get_current_sequence ::
Ptr GestureSingle ->
IO (Ptr Gdk.EventSequence.EventSequence)
gestureSingleGetCurrentSequence ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> m (Maybe Gdk.EventSequence.EventSequence)
gestureSingleGetCurrentSequence gesture = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
result <- gtk_gesture_single_get_current_sequence gesture'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gdk.EventSequence.EventSequence) result'
return result''
touchManagedPtr gesture
return maybeResult
#if defined(ENABLE_OVERLOADING)
data GestureSingleGetCurrentSequenceMethodInfo
instance (signature ~ (m (Maybe Gdk.EventSequence.EventSequence)), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleGetCurrentSequenceMethodInfo a signature where
overloadedMethod = gestureSingleGetCurrentSequence
#endif
foreign import ccall "gtk_gesture_single_get_exclusive" gtk_gesture_single_get_exclusive ::
Ptr GestureSingle ->
IO CInt
gestureSingleGetExclusive ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> m Bool
gestureSingleGetExclusive gesture = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
result <- gtk_gesture_single_get_exclusive gesture'
let result' = (/= 0) result
touchManagedPtr gesture
return result'
#if defined(ENABLE_OVERLOADING)
data GestureSingleGetExclusiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleGetExclusiveMethodInfo a signature where
overloadedMethod = gestureSingleGetExclusive
#endif
foreign import ccall "gtk_gesture_single_get_touch_only" gtk_gesture_single_get_touch_only ::
Ptr GestureSingle ->
IO CInt
gestureSingleGetTouchOnly ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> m Bool
gestureSingleGetTouchOnly gesture = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
result <- gtk_gesture_single_get_touch_only gesture'
let result' = (/= 0) result
touchManagedPtr gesture
return result'
#if defined(ENABLE_OVERLOADING)
data GestureSingleGetTouchOnlyMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleGetTouchOnlyMethodInfo a signature where
overloadedMethod = gestureSingleGetTouchOnly
#endif
foreign import ccall "gtk_gesture_single_set_button" gtk_gesture_single_set_button ::
Ptr GestureSingle ->
Word32 ->
IO ()
gestureSingleSetButton ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> Word32
-> m ()
gestureSingleSetButton gesture button = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
gtk_gesture_single_set_button gesture' button
touchManagedPtr gesture
return ()
#if defined(ENABLE_OVERLOADING)
data GestureSingleSetButtonMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleSetButtonMethodInfo a signature where
overloadedMethod = gestureSingleSetButton
#endif
foreign import ccall "gtk_gesture_single_set_exclusive" gtk_gesture_single_set_exclusive ::
Ptr GestureSingle ->
CInt ->
IO ()
gestureSingleSetExclusive ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> Bool
-> m ()
gestureSingleSetExclusive gesture exclusive = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
let exclusive' = (fromIntegral . fromEnum) exclusive
gtk_gesture_single_set_exclusive gesture' exclusive'
touchManagedPtr gesture
return ()
#if defined(ENABLE_OVERLOADING)
data GestureSingleSetExclusiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleSetExclusiveMethodInfo a signature where
overloadedMethod = gestureSingleSetExclusive
#endif
foreign import ccall "gtk_gesture_single_set_touch_only" gtk_gesture_single_set_touch_only ::
Ptr GestureSingle ->
CInt ->
IO ()
gestureSingleSetTouchOnly ::
(B.CallStack.HasCallStack, MonadIO m, IsGestureSingle a) =>
a
-> Bool
-> m ()
gestureSingleSetTouchOnly gesture touchOnly = liftIO $ do
gesture' <- unsafeManagedPtrCastPtr gesture
let touchOnly' = (fromIntegral . fromEnum) touchOnly
gtk_gesture_single_set_touch_only gesture' touchOnly'
touchManagedPtr gesture
return ()
#if defined(ENABLE_OVERLOADING)
data GestureSingleSetTouchOnlyMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsGestureSingle a) => O.MethodInfo GestureSingleSetTouchOnlyMethodInfo a signature where
overloadedMethod = gestureSingleSetTouchOnly
#endif