{- | 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.GestureMultiPress.GestureMultiPress' is a 'GI.Gtk.Objects.Gesture.Gesture' implementation able to recognize multiple clicks on a nearby zone, which can be listened for through the 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'::@/pressed/@ signal. Whenever time or distance between clicks exceed the GTK+ defaults, 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'::@/stopped/@ is emitted, and the click counter is reset. Callers may also restrict the area that is considered valid for a >1 touch\/button press through 'GI.Gtk.Objects.GestureMultiPress.gestureMultiPressSetArea', so any click happening outside that area is considered to be a first click of its own. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Objects.GestureMultiPress ( -- * Exported types GestureMultiPress(..) , IsGestureMultiPress , toGestureMultiPress , noGestureMultiPress , -- * Methods -- ** getArea #method:getArea# #if ENABLE_OVERLOADING GestureMultiPressGetAreaMethodInfo , #endif gestureMultiPressGetArea , -- ** new #method:new# gestureMultiPressNew , -- ** setArea #method:setArea# #if ENABLE_OVERLOADING GestureMultiPressSetAreaMethodInfo , #endif gestureMultiPressSetArea , -- * Signals -- ** pressed #signal:pressed# C_GestureMultiPressPressedCallback , GestureMultiPressPressedCallback , #if ENABLE_OVERLOADING GestureMultiPressPressedSignalInfo , #endif afterGestureMultiPressPressed , genClosure_GestureMultiPressPressed , mk_GestureMultiPressPressedCallback , noGestureMultiPressPressedCallback , onGestureMultiPressPressed , wrap_GestureMultiPressPressedCallback , -- ** released #signal:released# C_GestureMultiPressReleasedCallback , GestureMultiPressReleasedCallback , #if ENABLE_OVERLOADING GestureMultiPressReleasedSignalInfo , #endif afterGestureMultiPressReleased , genClosure_GestureMultiPressReleased , mk_GestureMultiPressReleasedCallback , noGestureMultiPressReleasedCallback , onGestureMultiPressReleased , wrap_GestureMultiPressReleasedCallback , -- ** stopped #signal:stopped# C_GestureMultiPressStoppedCallback , GestureMultiPressStoppedCallback , #if ENABLE_OVERLOADING GestureMultiPressStoppedSignalInfo , #endif afterGestureMultiPressStopped , genClosure_GestureMultiPressStopped , mk_GestureMultiPressStoppedCallback , noGestureMultiPressStoppedCallback , onGestureMultiPressStopped , wrap_GestureMultiPressStoppedCallback , ) 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 qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController import {-# SOURCE #-} qualified GI.Gtk.Objects.Gesture as Gtk.Gesture import {-# SOURCE #-} qualified GI.Gtk.Objects.GestureSingle as Gtk.GestureSingle import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget -- | Memory-managed wrapper type. newtype GestureMultiPress = GestureMultiPress (ManagedPtr GestureMultiPress) foreign import ccall "gtk_gesture_multi_press_get_type" c_gtk_gesture_multi_press_get_type :: IO GType instance GObject GestureMultiPress where gobjectType = c_gtk_gesture_multi_press_get_type -- | Type class for types which can be safely cast to `GestureMultiPress`, for instance with `toGestureMultiPress`. class (GObject o, O.IsDescendantOf GestureMultiPress o) => IsGestureMultiPress o instance (GObject o, O.IsDescendantOf GestureMultiPress o) => IsGestureMultiPress o instance O.HasParentTypes GestureMultiPress type instance O.ParentTypes GestureMultiPress = '[Gtk.GestureSingle.GestureSingle, Gtk.Gesture.Gesture, Gtk.EventController.EventController, GObject.Object.Object] -- | Cast to `GestureMultiPress`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toGestureMultiPress :: (MonadIO m, IsGestureMultiPress o) => o -> m GestureMultiPress toGestureMultiPress = liftIO . unsafeCastTo GestureMultiPress -- | A convenience alias for `Nothing` :: `Maybe` `GestureMultiPress`. noGestureMultiPress :: Maybe GestureMultiPress noGestureMultiPress = Nothing #if ENABLE_OVERLOADING type family ResolveGestureMultiPressMethod (t :: Symbol) (o :: *) :: * where ResolveGestureMultiPressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveGestureMultiPressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveGestureMultiPressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveGestureMultiPressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveGestureMultiPressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveGestureMultiPressMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo ResolveGestureMultiPressMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo ResolveGestureMultiPressMethod "handlesSequence" o = Gtk.Gesture.GestureHandlesSequenceMethodInfo ResolveGestureMultiPressMethod "isActive" o = Gtk.Gesture.GestureIsActiveMethodInfo ResolveGestureMultiPressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveGestureMultiPressMethod "isGroupedWith" o = Gtk.Gesture.GestureIsGroupedWithMethodInfo ResolveGestureMultiPressMethod "isRecognized" o = Gtk.Gesture.GestureIsRecognizedMethodInfo ResolveGestureMultiPressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveGestureMultiPressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveGestureMultiPressMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveGestureMultiPressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveGestureMultiPressMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo ResolveGestureMultiPressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveGestureMultiPressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveGestureMultiPressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveGestureMultiPressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveGestureMultiPressMethod "ungroup" o = Gtk.Gesture.GestureUngroupMethodInfo ResolveGestureMultiPressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveGestureMultiPressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveGestureMultiPressMethod "getArea" o = GestureMultiPressGetAreaMethodInfo ResolveGestureMultiPressMethod "getBoundingBox" o = Gtk.Gesture.GestureGetBoundingBoxMethodInfo ResolveGestureMultiPressMethod "getBoundingBoxCenter" o = Gtk.Gesture.GestureGetBoundingBoxCenterMethodInfo ResolveGestureMultiPressMethod "getButton" o = Gtk.GestureSingle.GestureSingleGetButtonMethodInfo ResolveGestureMultiPressMethod "getCurrentButton" o = Gtk.GestureSingle.GestureSingleGetCurrentButtonMethodInfo ResolveGestureMultiPressMethod "getCurrentSequence" o = Gtk.GestureSingle.GestureSingleGetCurrentSequenceMethodInfo ResolveGestureMultiPressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveGestureMultiPressMethod "getDevice" o = Gtk.Gesture.GestureGetDeviceMethodInfo ResolveGestureMultiPressMethod "getExclusive" o = Gtk.GestureSingle.GestureSingleGetExclusiveMethodInfo ResolveGestureMultiPressMethod "getGroup" o = Gtk.Gesture.GestureGetGroupMethodInfo ResolveGestureMultiPressMethod "getLastEvent" o = Gtk.Gesture.GestureGetLastEventMethodInfo ResolveGestureMultiPressMethod "getLastUpdatedSequence" o = Gtk.Gesture.GestureGetLastUpdatedSequenceMethodInfo ResolveGestureMultiPressMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo ResolveGestureMultiPressMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo ResolveGestureMultiPressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveGestureMultiPressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveGestureMultiPressMethod "getSequenceState" o = Gtk.Gesture.GestureGetSequenceStateMethodInfo ResolveGestureMultiPressMethod "getSequences" o = Gtk.Gesture.GestureGetSequencesMethodInfo ResolveGestureMultiPressMethod "getTouchOnly" o = Gtk.GestureSingle.GestureSingleGetTouchOnlyMethodInfo ResolveGestureMultiPressMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo ResolveGestureMultiPressMethod "getWindow" o = Gtk.Gesture.GestureGetWindowMethodInfo ResolveGestureMultiPressMethod "setArea" o = GestureMultiPressSetAreaMethodInfo ResolveGestureMultiPressMethod "setButton" o = Gtk.GestureSingle.GestureSingleSetButtonMethodInfo ResolveGestureMultiPressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveGestureMultiPressMethod "setExclusive" o = Gtk.GestureSingle.GestureSingleSetExclusiveMethodInfo ResolveGestureMultiPressMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo ResolveGestureMultiPressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveGestureMultiPressMethod "setSequenceState" o = Gtk.Gesture.GestureSetSequenceStateMethodInfo ResolveGestureMultiPressMethod "setState" o = Gtk.Gesture.GestureSetStateMethodInfo ResolveGestureMultiPressMethod "setTouchOnly" o = Gtk.GestureSingle.GestureSingleSetTouchOnlyMethodInfo ResolveGestureMultiPressMethod "setWindow" o = Gtk.Gesture.GestureSetWindowMethodInfo ResolveGestureMultiPressMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveGestureMultiPressMethod t GestureMultiPress, O.MethodInfo info GestureMultiPress p) => OL.IsLabel t (GestureMultiPress -> 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 GestureMultiPress::pressed {- | This signal is emitted whenever a button or touch press happens. /Since: 3.14/ -} type GestureMultiPressPressedCallback = Int32 {- ^ /@nPress@/: how many touch\/button presses happened with this one -} -> Double {- ^ /@x@/: The X coordinate, in widget allocation coordinates -} -> Double {- ^ /@y@/: The Y coordinate, in widget allocation coordinates -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `GestureMultiPressPressedCallback`@. noGestureMultiPressPressedCallback :: Maybe GestureMultiPressPressedCallback noGestureMultiPressPressedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_GestureMultiPressPressedCallback = Ptr () -> -- object Int32 -> CDouble -> CDouble -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_GestureMultiPressPressedCallback`. foreign import ccall "wrapper" mk_GestureMultiPressPressedCallback :: C_GestureMultiPressPressedCallback -> IO (FunPtr C_GestureMultiPressPressedCallback) -- | Wrap the callback into a `GClosure`. genClosure_GestureMultiPressPressed :: MonadIO m => GestureMultiPressPressedCallback -> m (GClosure C_GestureMultiPressPressedCallback) genClosure_GestureMultiPressPressed cb = liftIO $ do let cb' = wrap_GestureMultiPressPressedCallback cb mk_GestureMultiPressPressedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `GestureMultiPressPressedCallback` into a `C_GestureMultiPressPressedCallback`. wrap_GestureMultiPressPressedCallback :: GestureMultiPressPressedCallback -> C_GestureMultiPressPressedCallback wrap_GestureMultiPressPressedCallback _cb _ nPress x y _ = do let x' = realToFrac x let y' = realToFrac y _cb nPress x' y' {- | Connect a signal handler for the “@pressed@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' gestureMultiPress #pressed callback @ -} onGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId onGestureMultiPressPressed obj cb = liftIO $ do let cb' = wrap_GestureMultiPressPressedCallback cb cb'' <- mk_GestureMultiPressPressedCallback cb' connectSignalFunPtr obj "pressed" cb'' SignalConnectBefore {- | Connect a signal handler for the “@pressed@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' gestureMultiPress #pressed callback @ -} afterGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId afterGestureMultiPressPressed obj cb = liftIO $ do let cb' = wrap_GestureMultiPressPressedCallback cb cb'' <- mk_GestureMultiPressPressedCallback cb' connectSignalFunPtr obj "pressed" cb'' SignalConnectAfter -- signal GestureMultiPress::released {- | This signal is emitted when a button or touch is released. /@nPress@/ will report the number of press that is paired to this event, note that 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress'::@/stopped/@ may have been emitted between the press and its release, /@nPress@/ will only start over at the next press. /Since: 3.14/ -} type GestureMultiPressReleasedCallback = Int32 {- ^ /@nPress@/: number of press that is paired with this release -} -> Double {- ^ /@x@/: The X coordinate, in widget allocation coordinates -} -> Double {- ^ /@y@/: The Y coordinate, in widget allocation coordinates -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `GestureMultiPressReleasedCallback`@. noGestureMultiPressReleasedCallback :: Maybe GestureMultiPressReleasedCallback noGestureMultiPressReleasedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_GestureMultiPressReleasedCallback = Ptr () -> -- object Int32 -> CDouble -> CDouble -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_GestureMultiPressReleasedCallback`. foreign import ccall "wrapper" mk_GestureMultiPressReleasedCallback :: C_GestureMultiPressReleasedCallback -> IO (FunPtr C_GestureMultiPressReleasedCallback) -- | Wrap the callback into a `GClosure`. genClosure_GestureMultiPressReleased :: MonadIO m => GestureMultiPressReleasedCallback -> m (GClosure C_GestureMultiPressReleasedCallback) genClosure_GestureMultiPressReleased cb = liftIO $ do let cb' = wrap_GestureMultiPressReleasedCallback cb mk_GestureMultiPressReleasedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `GestureMultiPressReleasedCallback` into a `C_GestureMultiPressReleasedCallback`. wrap_GestureMultiPressReleasedCallback :: GestureMultiPressReleasedCallback -> C_GestureMultiPressReleasedCallback wrap_GestureMultiPressReleasedCallback _cb _ nPress x y _ = do let x' = realToFrac x let y' = realToFrac y _cb nPress x' y' {- | Connect a signal handler for the “@released@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' gestureMultiPress #released callback @ -} onGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId onGestureMultiPressReleased obj cb = liftIO $ do let cb' = wrap_GestureMultiPressReleasedCallback cb cb'' <- mk_GestureMultiPressReleasedCallback cb' connectSignalFunPtr obj "released" cb'' SignalConnectBefore {- | Connect a signal handler for the “@released@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' gestureMultiPress #released callback @ -} afterGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId afterGestureMultiPressReleased obj cb = liftIO $ do let cb' = wrap_GestureMultiPressReleasedCallback cb cb'' <- mk_GestureMultiPressReleasedCallback cb' connectSignalFunPtr obj "released" cb'' SignalConnectAfter -- signal GestureMultiPress::stopped {- | This signal is emitted whenever any time\/distance threshold has been exceeded. /Since: 3.14/ -} type GestureMultiPressStoppedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `GestureMultiPressStoppedCallback`@. noGestureMultiPressStoppedCallback :: Maybe GestureMultiPressStoppedCallback noGestureMultiPressStoppedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_GestureMultiPressStoppedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_GestureMultiPressStoppedCallback`. foreign import ccall "wrapper" mk_GestureMultiPressStoppedCallback :: C_GestureMultiPressStoppedCallback -> IO (FunPtr C_GestureMultiPressStoppedCallback) -- | Wrap the callback into a `GClosure`. genClosure_GestureMultiPressStopped :: MonadIO m => GestureMultiPressStoppedCallback -> m (GClosure C_GestureMultiPressStoppedCallback) genClosure_GestureMultiPressStopped cb = liftIO $ do let cb' = wrap_GestureMultiPressStoppedCallback cb mk_GestureMultiPressStoppedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `GestureMultiPressStoppedCallback` into a `C_GestureMultiPressStoppedCallback`. wrap_GestureMultiPressStoppedCallback :: GestureMultiPressStoppedCallback -> C_GestureMultiPressStoppedCallback wrap_GestureMultiPressStoppedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@stopped@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' gestureMultiPress #stopped callback @ -} onGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId onGestureMultiPressStopped obj cb = liftIO $ do let cb' = wrap_GestureMultiPressStoppedCallback cb cb'' <- mk_GestureMultiPressStoppedCallback cb' connectSignalFunPtr obj "stopped" cb'' SignalConnectBefore {- | Connect a signal handler for the “@stopped@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' gestureMultiPress #stopped callback @ -} afterGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId afterGestureMultiPressStopped obj cb = liftIO $ do let cb' = wrap_GestureMultiPressStoppedCallback cb cb'' <- mk_GestureMultiPressStoppedCallback cb' connectSignalFunPtr obj "stopped" cb'' SignalConnectAfter #if ENABLE_OVERLOADING instance O.HasAttributeList GestureMultiPress type instance O.AttributeList GestureMultiPress = GestureMultiPressAttributeList type GestureMultiPressAttributeList = ('[ '("button", Gtk.GestureSingle.GestureSingleButtonPropertyInfo), '("exclusive", Gtk.GestureSingle.GestureSingleExclusivePropertyInfo), '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("touchOnly", Gtk.GestureSingle.GestureSingleTouchOnlyPropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo), '("window", Gtk.Gesture.GestureWindowPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING data GestureMultiPressPressedSignalInfo instance SignalInfo GestureMultiPressPressedSignalInfo where type HaskellCallbackType GestureMultiPressPressedSignalInfo = GestureMultiPressPressedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_GestureMultiPressPressedCallback cb cb'' <- mk_GestureMultiPressPressedCallback cb' connectSignalFunPtr obj "pressed" cb'' connectMode data GestureMultiPressReleasedSignalInfo instance SignalInfo GestureMultiPressReleasedSignalInfo where type HaskellCallbackType GestureMultiPressReleasedSignalInfo = GestureMultiPressReleasedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_GestureMultiPressReleasedCallback cb cb'' <- mk_GestureMultiPressReleasedCallback cb' connectSignalFunPtr obj "released" cb'' connectMode data GestureMultiPressStoppedSignalInfo instance SignalInfo GestureMultiPressStoppedSignalInfo where type HaskellCallbackType GestureMultiPressStoppedSignalInfo = GestureMultiPressStoppedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_GestureMultiPressStoppedCallback cb cb'' <- mk_GestureMultiPressStoppedCallback cb' connectSignalFunPtr obj "stopped" cb'' connectMode type instance O.SignalList GestureMultiPress = GestureMultiPressSignalList type GestureMultiPressSignalList = ('[ '("begin", Gtk.Gesture.GestureBeginSignalInfo), '("cancel", Gtk.Gesture.GestureCancelSignalInfo), '("end", Gtk.Gesture.GestureEndSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pressed", GestureMultiPressPressedSignalInfo), '("released", GestureMultiPressReleasedSignalInfo), '("sequenceStateChanged", Gtk.Gesture.GestureSequenceStateChangedSignalInfo), '("stopped", GestureMultiPressStoppedSignalInfo), '("update", Gtk.Gesture.GestureUpdateSignalInfo)] :: [(Symbol, *)]) #endif -- method GestureMultiPress::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}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "GestureMultiPress"})) -- throws : False -- Skip return : False foreign import ccall "gtk_gesture_multi_press_new" gtk_gesture_multi_press_new :: Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) IO (Ptr GestureMultiPress) {- | Returns a newly created 'GI.Gtk.Objects.Gesture.Gesture' that recognizes single and multiple presses. /Since: 3.14/ -} gestureMultiPressNew :: (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) => a {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -} -> m GestureMultiPress {- ^ __Returns:__ a newly created 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress' -} gestureMultiPressNew widget = liftIO $ do widget' <- unsafeManagedPtrCastPtr widget result <- gtk_gesture_multi_press_new widget' checkUnexpectedReturnNULL "gestureMultiPressNew" result result' <- (wrapObject GestureMultiPress) result touchManagedPtr widget return result' #if ENABLE_OVERLOADING #endif -- method GestureMultiPress::get_area -- method type : OrdinaryMethod -- Args : [Arg {argCName = "gesture", argType = TInterface (Name {namespace = "Gtk", name = "GestureMultiPress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkGestureMultiPress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the press area", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_gesture_multi_press_get_area" gtk_gesture_multi_press_get_area :: Ptr GestureMultiPress -> -- gesture : TInterface (Name {namespace = "Gtk", name = "GestureMultiPress"}) Ptr Gdk.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) IO CInt {- | If an area was set through 'GI.Gtk.Objects.GestureMultiPress.gestureMultiPressSetArea', this function will return 'True' and fill in /@rect@/ with the press area. See 'GI.Gtk.Objects.GestureMultiPress.gestureMultiPressSetArea' for more details on what the press area represents. /Since: 3.14/ -} gestureMultiPressGetArea :: (B.CallStack.HasCallStack, MonadIO m, IsGestureMultiPress a) => a {- ^ /@gesture@/: a 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress' -} -> m ((Bool, Gdk.Rectangle.Rectangle)) {- ^ __Returns:__ 'True' if /@rect@/ was filled with the press area -} gestureMultiPressGetArea gesture = liftIO $ do gesture' <- unsafeManagedPtrCastPtr gesture rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle) result <- gtk_gesture_multi_press_get_area gesture' rect let result' = (/= 0) result rect' <- (wrapBoxed Gdk.Rectangle.Rectangle) rect touchManagedPtr gesture return (result', rect') #if ENABLE_OVERLOADING data GestureMultiPressGetAreaMethodInfo instance (signature ~ (m ((Bool, Gdk.Rectangle.Rectangle))), MonadIO m, IsGestureMultiPress a) => O.MethodInfo GestureMultiPressGetAreaMethodInfo a signature where overloadedMethod _ = gestureMultiPressGetArea #endif -- method GestureMultiPress::set_area -- method type : OrdinaryMethod -- Args : [Arg {argCName = "gesture", argType = TInterface (Name {namespace = "Gtk", name = "GestureMultiPress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkGestureMultiPress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "rectangle to receive coordinates on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_gesture_multi_press_set_area" gtk_gesture_multi_press_set_area :: Ptr GestureMultiPress -> -- gesture : TInterface (Name {namespace = "Gtk", name = "GestureMultiPress"}) Ptr Gdk.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) IO () {- | If /@rect@/ is non-'Nothing', the press area will be checked to be confined within the rectangle, otherwise the button count will be reset so the press is seen as being the first one. If /@rect@/ is 'Nothing', the area will be reset to an unrestricted state. Note: The rectangle is only used to determine whether any non-first click falls within the expected area. This is not akin to an input shape. /Since: 3.14/ -} gestureMultiPressSetArea :: (B.CallStack.HasCallStack, MonadIO m, IsGestureMultiPress a) => a {- ^ /@gesture@/: a 'GI.Gtk.Objects.GestureMultiPress.GestureMultiPress' -} -> Maybe (Gdk.Rectangle.Rectangle) {- ^ /@rect@/: rectangle to receive coordinates on -} -> m () gestureMultiPressSetArea gesture rect = liftIO $ do gesture' <- unsafeManagedPtrCastPtr gesture maybeRect <- case rect of Nothing -> return nullPtr Just jRect -> do jRect' <- unsafeManagedPtrGetPtr jRect return jRect' gtk_gesture_multi_press_set_area gesture' maybeRect touchManagedPtr gesture whenJust rect touchManagedPtr return () #if ENABLE_OVERLOADING data GestureMultiPressSetAreaMethodInfo instance (signature ~ (Maybe (Gdk.Rectangle.Rectangle) -> m ()), MonadIO m, IsGestureMultiPress a) => O.MethodInfo GestureMultiPressSetAreaMethodInfo a signature where overloadedMethod _ = gestureMultiPressSetArea #endif