{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Button event.
-- 
-- The event coordinates are relative to the stage that received the
-- event, and can be transformed into actor-relative coordinates by
-- using 'GI.Clutter.Objects.Actor.actorTransformStagePoint'.
-- 
-- /Since: 0.2/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Clutter.Structs.ButtonEvent
    ( 

-- * Exported types
    ButtonEvent(..)                         ,
    newZeroButtonEvent                      ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveButtonEventMethod                ,
#endif



 -- * Properties


-- ** axes #attr:axes#
-- | reserved for future use

#if defined(ENABLE_OVERLOADING)
    buttonEvent_axes                        ,
#endif
    getButtonEventAxes                      ,
    setButtonEventAxes                      ,


-- ** button #attr:button#
-- | event button

#if defined(ENABLE_OVERLOADING)
    buttonEvent_button                      ,
#endif
    getButtonEventButton                    ,
    setButtonEventButton                    ,


-- ** clickCount #attr:clickCount#
-- | number of button presses within the default time
--   and radius

#if defined(ENABLE_OVERLOADING)
    buttonEvent_clickCount                  ,
#endif
    getButtonEventClickCount                ,
    setButtonEventClickCount                ,


-- ** device #attr:device#
-- | the device that originated the event. If you want the physical
-- device the event originated from, use 'GI.Clutter.Unions.Event.eventGetSourceDevice'

#if defined(ENABLE_OVERLOADING)
    buttonEvent_device                      ,
#endif
    clearButtonEventDevice                  ,
    getButtonEventDevice                    ,
    setButtonEventDevice                    ,


-- ** flags #attr:flags#
-- | event flags

#if defined(ENABLE_OVERLOADING)
    buttonEvent_flags                       ,
#endif
    getButtonEventFlags                     ,
    setButtonEventFlags                     ,


-- ** modifierState #attr:modifierState#
-- | button modifiers

#if defined(ENABLE_OVERLOADING)
    buttonEvent_modifierState               ,
#endif
    getButtonEventModifierState             ,
    setButtonEventModifierState             ,


-- ** source #attr:source#
-- | event source actor

#if defined(ENABLE_OVERLOADING)
    buttonEvent_source                      ,
#endif
    clearButtonEventSource                  ,
    getButtonEventSource                    ,
    setButtonEventSource                    ,


-- ** stage #attr:stage#
-- | event source stage

#if defined(ENABLE_OVERLOADING)
    buttonEvent_stage                       ,
#endif
    clearButtonEventStage                   ,
    getButtonEventStage                     ,
    setButtonEventStage                     ,


-- ** time #attr:time#
-- | event time

#if defined(ENABLE_OVERLOADING)
    buttonEvent_time                        ,
#endif
    getButtonEventTime                      ,
    setButtonEventTime                      ,


-- ** type #attr:type#
-- | event type

#if defined(ENABLE_OVERLOADING)
    buttonEvent_type                        ,
#endif
    getButtonEventType                      ,
    setButtonEventType                      ,


-- ** x #attr:x#
-- | event X coordinate, relative to the stage

#if defined(ENABLE_OVERLOADING)
    buttonEvent_x                           ,
#endif
    getButtonEventX                         ,
    setButtonEventX                         ,


-- ** y #attr:y#
-- | event Y coordinate, relative to the stage

#if defined(ENABLE_OVERLOADING)
    buttonEvent_y                           ,
#endif
    getButtonEventY                         ,
    setButtonEventY                         ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.RectangleInt as Cairo.RectangleInt
import qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Animatable as Clutter.Animatable
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Container as Clutter.Container
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Content as Clutter.Content
import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Alpha as Clutter.Alpha
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animation as Clutter.Animation
import {-# SOURCE #-} qualified GI.Clutter.Objects.Animator as Clutter.Animator
import {-# SOURCE #-} qualified GI.Clutter.Objects.Backend as Clutter.Backend
import {-# SOURCE #-} qualified GI.Clutter.Objects.ChildMeta as Clutter.ChildMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Constraint as Clutter.Constraint
import {-# SOURCE #-} qualified GI.Clutter.Objects.DeviceManager as Clutter.DeviceManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.Effect as Clutter.Effect
import {-# SOURCE #-} qualified GI.Clutter.Objects.Group as Clutter.Group
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Interval as Clutter.Interval
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutManager as Clutter.LayoutManager
import {-# SOURCE #-} qualified GI.Clutter.Objects.LayoutMeta as Clutter.LayoutMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.Script as Clutter.Script
import {-# SOURCE #-} qualified GI.Clutter.Objects.Shader as Clutter.Shader
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Objects.State as Clutter.State
import {-# SOURCE #-} qualified GI.Clutter.Objects.Timeline as Clutter.Timeline
import {-# SOURCE #-} qualified GI.Clutter.Objects.Transition as Clutter.Transition
import {-# SOURCE #-} qualified GI.Clutter.Structs.ActorBox as Clutter.ActorBox
import {-# SOURCE #-} qualified GI.Clutter.Structs.AnimatorKey as Clutter.AnimatorKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.Color as Clutter.Color
import {-# SOURCE #-} qualified GI.Clutter.Structs.CrossingEvent as Clutter.CrossingEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.EventSequence as Clutter.EventSequence
import {-# SOURCE #-} qualified GI.Clutter.Structs.Fog as Clutter.Fog
import {-# SOURCE #-} qualified GI.Clutter.Structs.Geometry as Clutter.Geometry
import {-# SOURCE #-} qualified GI.Clutter.Structs.KeyEvent as Clutter.KeyEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Margin as Clutter.Margin
import {-# SOURCE #-} qualified GI.Clutter.Structs.Matrix as Clutter.Matrix
import {-# SOURCE #-} qualified GI.Clutter.Structs.MotionEvent as Clutter.MotionEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.PaintVolume as Clutter.PaintVolume
import {-# SOURCE #-} qualified GI.Clutter.Structs.Perspective as Clutter.Perspective
import {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import {-# SOURCE #-} qualified GI.Clutter.Structs.Rect as Clutter.Rect
import {-# SOURCE #-} qualified GI.Clutter.Structs.ScrollEvent as Clutter.ScrollEvent
import {-# SOURCE #-} qualified GI.Clutter.Structs.Size as Clutter.Size
import {-# SOURCE #-} qualified GI.Clutter.Structs.StateKey as Clutter.StateKey
import {-# SOURCE #-} qualified GI.Clutter.Structs.Vertex as Clutter.Vertex
import {-# SOURCE #-} qualified GI.Clutter.Unions.Event as Clutter.Event
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Json.Structs.Node as Json.Node
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.Layout as Pango.Layout

#else
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage

#endif

-- | Memory-managed wrapper type.
newtype ButtonEvent = ButtonEvent (SP.ManagedPtr ButtonEvent)
    deriving (ButtonEvent -> ButtonEvent -> Bool
(ButtonEvent -> ButtonEvent -> Bool)
-> (ButtonEvent -> ButtonEvent -> Bool) -> Eq ButtonEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ButtonEvent -> ButtonEvent -> Bool
== :: ButtonEvent -> ButtonEvent -> Bool
$c/= :: ButtonEvent -> ButtonEvent -> Bool
/= :: ButtonEvent -> ButtonEvent -> Bool
Eq)

instance SP.ManagedPtrNewtype ButtonEvent where
    toManagedPtr :: ButtonEvent -> ManagedPtr ButtonEvent
toManagedPtr (ButtonEvent ManagedPtr ButtonEvent
p) = ManagedPtr ButtonEvent
p

instance BoxedPtr ButtonEvent where
    boxedPtrCopy :: ButtonEvent -> IO ButtonEvent
boxedPtrCopy = \ButtonEvent
p -> ButtonEvent
-> (Ptr ButtonEvent -> IO ButtonEvent) -> IO ButtonEvent
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ButtonEvent
p (Int -> Ptr ButtonEvent -> IO (Ptr ButtonEvent)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
72 (Ptr ButtonEvent -> IO (Ptr ButtonEvent))
-> (Ptr ButtonEvent -> IO ButtonEvent)
-> Ptr ButtonEvent
-> IO ButtonEvent
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ButtonEvent -> ButtonEvent)
-> Ptr ButtonEvent -> IO ButtonEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ButtonEvent -> ButtonEvent
ButtonEvent)
    boxedPtrFree :: ButtonEvent -> IO ()
boxedPtrFree = \ButtonEvent
x -> ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ButtonEvent
x Ptr ButtonEvent -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ButtonEvent where
    boxedPtrCalloc :: IO (Ptr ButtonEvent)
boxedPtrCalloc = Int -> IO (Ptr ButtonEvent)
forall a. Int -> IO (Ptr a)
callocBytes Int
72


-- | Construct a `ButtonEvent` struct initialized to zero.
newZeroButtonEvent :: MonadIO m => m ButtonEvent
newZeroButtonEvent :: forall (m :: * -> *). MonadIO m => m ButtonEvent
newZeroButtonEvent = IO ButtonEvent -> m ButtonEvent
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ButtonEvent -> m ButtonEvent)
-> IO ButtonEvent -> m ButtonEvent
forall a b. (a -> b) -> a -> b
$ IO (Ptr ButtonEvent)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ButtonEvent)
-> (Ptr ButtonEvent -> IO ButtonEvent) -> IO ButtonEvent
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ButtonEvent -> ButtonEvent)
-> Ptr ButtonEvent -> IO ButtonEvent
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ButtonEvent -> ButtonEvent
ButtonEvent

instance tag ~ 'AttrSet => Constructible ButtonEvent tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ButtonEvent -> ButtonEvent)
-> [AttrOp ButtonEvent tag] -> m ButtonEvent
new ManagedPtr ButtonEvent -> ButtonEvent
_ [AttrOp ButtonEvent tag]
attrs = do
        ButtonEvent
o <- m ButtonEvent
forall (m :: * -> *). MonadIO m => m ButtonEvent
newZeroButtonEvent
        ButtonEvent -> [AttrOp ButtonEvent 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ButtonEvent
o [AttrOp ButtonEvent tag]
[AttrOp ButtonEvent 'AttrSet]
attrs
        ButtonEvent -> m ButtonEvent
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ButtonEvent
o


-- | Get the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #type
-- @
getButtonEventType :: MonadIO m => ButtonEvent -> m Clutter.Enums.EventType
getButtonEventType :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m EventType
getButtonEventType ButtonEvent
s = IO EventType -> m EventType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EventType -> m EventType) -> IO EventType -> m EventType
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO EventType) -> IO EventType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO EventType) -> IO EventType)
-> (Ptr ButtonEvent -> IO EventType) -> IO EventType
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CUInt
    let val' :: EventType
val' = (Int -> EventType
forall a. Enum a => Int -> a
toEnum (Int -> EventType) -> (CUInt -> Int) -> CUInt -> EventType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    EventType -> IO EventType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EventType
val'

-- | Set the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventType :: MonadIO m => ButtonEvent -> Clutter.Enums.EventType -> m ()
setButtonEventType :: forall (m :: * -> *). MonadIO m => ButtonEvent -> EventType -> m ()
setButtonEventType ButtonEvent
s EventType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EventType -> Int) -> EventType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EventType -> Int
forall a. Enum a => a -> Int
fromEnum) EventType
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data ButtonEventTypeFieldInfo
instance AttrInfo ButtonEventTypeFieldInfo where
    type AttrBaseTypeConstraint ButtonEventTypeFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventTypeFieldInfo = (~) Clutter.Enums.EventType
    type AttrTransferTypeConstraint ButtonEventTypeFieldInfo = (~)Clutter.Enums.EventType
    type AttrTransferType ButtonEventTypeFieldInfo = Clutter.Enums.EventType
    type AttrGetType ButtonEventTypeFieldInfo = Clutter.Enums.EventType
    type AttrLabel ButtonEventTypeFieldInfo = "type"
    type AttrOrigin ButtonEventTypeFieldInfo = ButtonEvent
    attrGet = getButtonEventType
    attrSet = setButtonEventType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.type"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:type"
        })

buttonEvent_type :: AttrLabelProxy "type"
buttonEvent_type = AttrLabelProxy

#endif


-- | Get the value of the “@time@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #time
-- @
getButtonEventTime :: MonadIO m => ButtonEvent -> m Word32
getButtonEventTime :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m Word32
getButtonEventTime ButtonEvent
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO Word32) -> IO Word32)
-> (Ptr ButtonEvent -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@time@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #time 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventTime :: MonadIO m => ButtonEvent -> Word32 -> m ()
setButtonEventTime :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Word32 -> m ()
setButtonEventTime ButtonEvent
s Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data ButtonEventTimeFieldInfo
instance AttrInfo ButtonEventTimeFieldInfo where
    type AttrBaseTypeConstraint ButtonEventTimeFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventTimeFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ButtonEventTimeFieldInfo = (~)Word32
    type AttrTransferType ButtonEventTimeFieldInfo = Word32
    type AttrGetType ButtonEventTimeFieldInfo = Word32
    type AttrLabel ButtonEventTimeFieldInfo = "time"
    type AttrOrigin ButtonEventTimeFieldInfo = ButtonEvent
    attrGet = getButtonEventTime
    attrSet = setButtonEventTime
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.time"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:time"
        })

buttonEvent_time :: AttrLabelProxy "time"
buttonEvent_time = AttrLabelProxy

#endif


-- | Get the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #flags
-- @
getButtonEventFlags :: MonadIO m => ButtonEvent -> m [Clutter.Flags.EventFlags]
getButtonEventFlags :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m [EventFlags]
getButtonEventFlags ButtonEvent
s = IO [EventFlags] -> m [EventFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [EventFlags] -> m [EventFlags])
-> IO [EventFlags] -> m [EventFlags]
forall a b. (a -> b) -> a -> b
$ ButtonEvent
-> (Ptr ButtonEvent -> IO [EventFlags]) -> IO [EventFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO [EventFlags]) -> IO [EventFlags])
-> (Ptr ButtonEvent -> IO [EventFlags]) -> IO [EventFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CUInt
    let val' :: [EventFlags]
val' = CUInt -> [EventFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [EventFlags] -> IO [EventFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [EventFlags]
val'

-- | Set the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventFlags :: MonadIO m => ButtonEvent -> [Clutter.Flags.EventFlags] -> m ()
setButtonEventFlags :: forall (m :: * -> *).
MonadIO m =>
ButtonEvent -> [EventFlags] -> m ()
setButtonEventFlags ButtonEvent
s [EventFlags]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    let val' :: CUInt
val' = [EventFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [EventFlags]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data ButtonEventFlagsFieldInfo
instance AttrInfo ButtonEventFlagsFieldInfo where
    type AttrBaseTypeConstraint ButtonEventFlagsFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventFlagsFieldInfo = (~) [Clutter.Flags.EventFlags]
    type AttrTransferTypeConstraint ButtonEventFlagsFieldInfo = (~)[Clutter.Flags.EventFlags]
    type AttrTransferType ButtonEventFlagsFieldInfo = [Clutter.Flags.EventFlags]
    type AttrGetType ButtonEventFlagsFieldInfo = [Clutter.Flags.EventFlags]
    type AttrLabel ButtonEventFlagsFieldInfo = "flags"
    type AttrOrigin ButtonEventFlagsFieldInfo = ButtonEvent
    attrGet = getButtonEventFlags
    attrSet = setButtonEventFlags
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.flags"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:flags"
        })

buttonEvent_flags :: AttrLabelProxy "flags"
buttonEvent_flags = AttrLabelProxy

#endif


-- | Get the value of the “@stage@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #stage
-- @
getButtonEventStage :: MonadIO m => ButtonEvent -> m (Maybe Clutter.Stage.Stage)
getButtonEventStage :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m (Maybe Stage)
getButtonEventStage ButtonEvent
s = IO (Maybe Stage) -> m (Maybe Stage)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Stage) -> m (Maybe Stage))
-> IO (Maybe Stage) -> m (Maybe Stage)
forall a b. (a -> b) -> a -> b
$ ButtonEvent
-> (Ptr ButtonEvent -> IO (Maybe Stage)) -> IO (Maybe Stage)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO (Maybe Stage)) -> IO (Maybe Stage))
-> (Ptr ButtonEvent -> IO (Maybe Stage)) -> IO (Maybe Stage)
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr Stage
val <- Ptr (Ptr Stage) -> IO (Ptr Stage)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr Stage)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Clutter.Stage.Stage)
    Maybe Stage
result <- Ptr Stage -> (Ptr Stage -> IO Stage) -> IO (Maybe Stage)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Stage
val ((Ptr Stage -> IO Stage) -> IO (Maybe Stage))
-> (Ptr Stage -> IO Stage) -> IO (Maybe Stage)
forall a b. (a -> b) -> a -> b
$ \Ptr Stage
val' -> do
        Stage
val'' <- ((ManagedPtr Stage -> Stage) -> Ptr Stage -> IO Stage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Stage -> Stage
Clutter.Stage.Stage) Ptr Stage
val'
        Stage -> IO Stage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Stage
val''
    Maybe Stage -> IO (Maybe Stage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Stage
result

-- | Set the value of the “@stage@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #stage 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventStage :: MonadIO m => ButtonEvent -> Ptr Clutter.Stage.Stage -> m ()
setButtonEventStage :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Ptr Stage -> m ()
setButtonEventStage ButtonEvent
s Ptr Stage
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr (Ptr Stage) -> Ptr Stage -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr Stage)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Stage
val :: Ptr Clutter.Stage.Stage)

-- | Set the value of the “@stage@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #stage
-- @
clearButtonEventStage :: MonadIO m => ButtonEvent -> m ()
clearButtonEventStage :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m ()
clearButtonEventStage ButtonEvent
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr (Ptr Stage) -> Ptr Stage -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr Stage)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Stage
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.Stage.Stage)

#if defined(ENABLE_OVERLOADING)
data ButtonEventStageFieldInfo
instance AttrInfo ButtonEventStageFieldInfo where
    type AttrBaseTypeConstraint ButtonEventStageFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventStageFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ButtonEventStageFieldInfo = (~) (Ptr Clutter.Stage.Stage)
    type AttrTransferTypeConstraint ButtonEventStageFieldInfo = (~)(Ptr Clutter.Stage.Stage)
    type AttrTransferType ButtonEventStageFieldInfo = (Ptr Clutter.Stage.Stage)
    type AttrGetType ButtonEventStageFieldInfo = Maybe Clutter.Stage.Stage
    type AttrLabel ButtonEventStageFieldInfo = "stage"
    type AttrOrigin ButtonEventStageFieldInfo = ButtonEvent
    attrGet = getButtonEventStage
    attrSet = setButtonEventStage
    attrConstruct = undefined
    attrClear = clearButtonEventStage
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.stage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:stage"
        })

buttonEvent_stage :: AttrLabelProxy "stage"
buttonEvent_stage = AttrLabelProxy

#endif


-- | Get the value of the “@source@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #source
-- @
getButtonEventSource :: MonadIO m => ButtonEvent -> m (Maybe Clutter.Actor.Actor)
getButtonEventSource :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m (Maybe Actor)
getButtonEventSource ButtonEvent
s = IO (Maybe Actor) -> m (Maybe Actor)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Actor) -> m (Maybe Actor))
-> IO (Maybe Actor) -> m (Maybe Actor)
forall a b. (a -> b) -> a -> b
$ ButtonEvent
-> (Ptr ButtonEvent -> IO (Maybe Actor)) -> IO (Maybe Actor)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO (Maybe Actor)) -> IO (Maybe Actor))
-> (Ptr ButtonEvent -> IO (Maybe Actor)) -> IO (Maybe Actor)
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr Actor
val <- Ptr (Ptr Actor) -> IO (Ptr Actor)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr Actor)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (Ptr Clutter.Actor.Actor)
    Maybe Actor
result <- Ptr Actor -> (Ptr Actor -> IO Actor) -> IO (Maybe Actor)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Actor
val ((Ptr Actor -> IO Actor) -> IO (Maybe Actor))
-> (Ptr Actor -> IO Actor) -> IO (Maybe Actor)
forall a b. (a -> b) -> a -> b
$ \Ptr Actor
val' -> do
        Actor
val'' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Clutter.Actor.Actor) Ptr Actor
val'
        Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
val''
    Maybe Actor -> IO (Maybe Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Actor
result

-- | Set the value of the “@source@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #source 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventSource :: MonadIO m => ButtonEvent -> Ptr Clutter.Actor.Actor -> m ()
setButtonEventSource :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Ptr Actor -> m ()
setButtonEventSource ButtonEvent
s Ptr Actor
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr (Ptr Actor) -> Ptr Actor -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr Actor)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr Actor
val :: Ptr Clutter.Actor.Actor)

-- | Set the value of the “@source@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #source
-- @
clearButtonEventSource :: MonadIO m => ButtonEvent -> m ()
clearButtonEventSource :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m ()
clearButtonEventSource ButtonEvent
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr (Ptr Actor) -> Ptr Actor -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr Actor)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr Actor
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.Actor.Actor)

#if defined(ENABLE_OVERLOADING)
data ButtonEventSourceFieldInfo
instance AttrInfo ButtonEventSourceFieldInfo where
    type AttrBaseTypeConstraint ButtonEventSourceFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventSourceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ButtonEventSourceFieldInfo = (~) (Ptr Clutter.Actor.Actor)
    type AttrTransferTypeConstraint ButtonEventSourceFieldInfo = (~)(Ptr Clutter.Actor.Actor)
    type AttrTransferType ButtonEventSourceFieldInfo = (Ptr Clutter.Actor.Actor)
    type AttrGetType ButtonEventSourceFieldInfo = Maybe Clutter.Actor.Actor
    type AttrLabel ButtonEventSourceFieldInfo = "source"
    type AttrOrigin ButtonEventSourceFieldInfo = ButtonEvent
    attrGet = getButtonEventSource
    attrSet = setButtonEventSource
    attrConstruct = undefined
    attrClear = clearButtonEventSource
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.source"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:source"
        })

buttonEvent_source :: AttrLabelProxy "source"
buttonEvent_source = AttrLabelProxy

#endif


-- | Get the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #x
-- @
getButtonEventX :: MonadIO m => ButtonEvent -> m Float
getButtonEventX :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m Float
getButtonEventX ButtonEvent
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO Float) -> IO Float)
-> (Ptr ButtonEvent -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #x 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventX :: MonadIO m => ButtonEvent -> Float -> m ()
setButtonEventX :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Float -> m ()
setButtonEventX ButtonEvent
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data ButtonEventXFieldInfo
instance AttrInfo ButtonEventXFieldInfo where
    type AttrBaseTypeConstraint ButtonEventXFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventXFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventXFieldInfo = (~) Float
    type AttrTransferTypeConstraint ButtonEventXFieldInfo = (~)Float
    type AttrTransferType ButtonEventXFieldInfo = Float
    type AttrGetType ButtonEventXFieldInfo = Float
    type AttrLabel ButtonEventXFieldInfo = "x"
    type AttrOrigin ButtonEventXFieldInfo = ButtonEvent
    attrGet = getButtonEventX
    attrSet = setButtonEventX
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.x"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:x"
        })

buttonEvent_x :: AttrLabelProxy "x"
buttonEvent_x = AttrLabelProxy

#endif


-- | Get the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #y
-- @
getButtonEventY :: MonadIO m => ButtonEvent -> m Float
getButtonEventY :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m Float
getButtonEventY ButtonEvent
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO Float) -> IO Float)
-> (Ptr ButtonEvent -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #y 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventY :: MonadIO m => ButtonEvent -> Float -> m ()
setButtonEventY :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Float -> m ()
setButtonEventY ButtonEvent
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data ButtonEventYFieldInfo
instance AttrInfo ButtonEventYFieldInfo where
    type AttrBaseTypeConstraint ButtonEventYFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventYFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventYFieldInfo = (~) Float
    type AttrTransferTypeConstraint ButtonEventYFieldInfo = (~)Float
    type AttrTransferType ButtonEventYFieldInfo = Float
    type AttrGetType ButtonEventYFieldInfo = Float
    type AttrLabel ButtonEventYFieldInfo = "y"
    type AttrOrigin ButtonEventYFieldInfo = ButtonEvent
    attrGet = getButtonEventY
    attrSet = setButtonEventY
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.y"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:y"
        })

buttonEvent_y :: AttrLabelProxy "y"
buttonEvent_y = AttrLabelProxy

#endif


-- | Get the value of the “@modifier_state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #modifierState
-- @
getButtonEventModifierState :: MonadIO m => ButtonEvent -> m [Clutter.Flags.ModifierType]
getButtonEventModifierState :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m [ModifierType]
getButtonEventModifierState ButtonEvent
s = IO [ModifierType] -> m [ModifierType]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ModifierType] -> m [ModifierType])
-> IO [ModifierType] -> m [ModifierType]
forall a b. (a -> b) -> a -> b
$ ButtonEvent
-> (Ptr ButtonEvent -> IO [ModifierType]) -> IO [ModifierType]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO [ModifierType]) -> IO [ModifierType])
-> (Ptr ButtonEvent -> IO [ModifierType]) -> IO [ModifierType]
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO CUInt
    let val' :: [ModifierType]
val' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [ModifierType] -> IO [ModifierType]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ModifierType]
val'

-- | Set the value of the “@modifier_state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #modifierState 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventModifierState :: MonadIO m => ButtonEvent -> [Clutter.Flags.ModifierType] -> m ()
setButtonEventModifierState :: forall (m :: * -> *).
MonadIO m =>
ButtonEvent -> [ModifierType] -> m ()
setButtonEventModifierState ButtonEvent
s [ModifierType]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    let val' :: CUInt
val' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data ButtonEventModifierStateFieldInfo
instance AttrInfo ButtonEventModifierStateFieldInfo where
    type AttrBaseTypeConstraint ButtonEventModifierStateFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventModifierStateFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventModifierStateFieldInfo = (~) [Clutter.Flags.ModifierType]
    type AttrTransferTypeConstraint ButtonEventModifierStateFieldInfo = (~)[Clutter.Flags.ModifierType]
    type AttrTransferType ButtonEventModifierStateFieldInfo = [Clutter.Flags.ModifierType]
    type AttrGetType ButtonEventModifierStateFieldInfo = [Clutter.Flags.ModifierType]
    type AttrLabel ButtonEventModifierStateFieldInfo = "modifier_state"
    type AttrOrigin ButtonEventModifierStateFieldInfo = ButtonEvent
    attrGet = getButtonEventModifierState
    attrSet = setButtonEventModifierState
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.modifierState"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:modifierState"
        })

buttonEvent_modifierState :: AttrLabelProxy "modifierState"
buttonEvent_modifierState = AttrLabelProxy

#endif


-- | Get the value of the “@button@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #button
-- @
getButtonEventButton :: MonadIO m => ButtonEvent -> m Word32
getButtonEventButton :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m Word32
getButtonEventButton ButtonEvent
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO Word32) -> IO Word32)
-> (Ptr ButtonEvent -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@button@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #button 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventButton :: MonadIO m => ButtonEvent -> Word32 -> m ()
setButtonEventButton :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Word32 -> m ()
setButtonEventButton ButtonEvent
s Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data ButtonEventButtonFieldInfo
instance AttrInfo ButtonEventButtonFieldInfo where
    type AttrBaseTypeConstraint ButtonEventButtonFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventButtonFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventButtonFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ButtonEventButtonFieldInfo = (~)Word32
    type AttrTransferType ButtonEventButtonFieldInfo = Word32
    type AttrGetType ButtonEventButtonFieldInfo = Word32
    type AttrLabel ButtonEventButtonFieldInfo = "button"
    type AttrOrigin ButtonEventButtonFieldInfo = ButtonEvent
    attrGet = getButtonEventButton
    attrSet = setButtonEventButton
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.button"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:button"
        })

buttonEvent_button :: AttrLabelProxy "button"
buttonEvent_button = AttrLabelProxy

#endif


-- | Get the value of the “@click_count@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #clickCount
-- @
getButtonEventClickCount :: MonadIO m => ButtonEvent -> m Word32
getButtonEventClickCount :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m Word32
getButtonEventClickCount ButtonEvent
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO Word32) -> IO Word32)
-> (Ptr ButtonEvent -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@click_count@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #clickCount 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventClickCount :: MonadIO m => ButtonEvent -> Word32 -> m ()
setButtonEventClickCount :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Word32 -> m ()
setButtonEventClickCount ButtonEvent
s Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data ButtonEventClickCountFieldInfo
instance AttrInfo ButtonEventClickCountFieldInfo where
    type AttrBaseTypeConstraint ButtonEventClickCountFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventClickCountFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventClickCountFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ButtonEventClickCountFieldInfo = (~)Word32
    type AttrTransferType ButtonEventClickCountFieldInfo = Word32
    type AttrGetType ButtonEventClickCountFieldInfo = Word32
    type AttrLabel ButtonEventClickCountFieldInfo = "click_count"
    type AttrOrigin ButtonEventClickCountFieldInfo = ButtonEvent
    attrGet = getButtonEventClickCount
    attrSet = setButtonEventClickCount
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.clickCount"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:clickCount"
        })

buttonEvent_clickCount :: AttrLabelProxy "clickCount"
buttonEvent_clickCount = AttrLabelProxy

#endif


-- | Get the value of the “@axes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #axes
-- @
getButtonEventAxes :: MonadIO m => ButtonEvent -> m Double
getButtonEventAxes :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m Double
getButtonEventAxes ButtonEvent
s = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO Double) -> IO Double)
-> (Ptr ButtonEvent -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@axes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #axes 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventAxes :: MonadIO m => ButtonEvent -> Double -> m ()
setButtonEventAxes :: forall (m :: * -> *). MonadIO m => ButtonEvent -> Double -> m ()
setButtonEventAxes ButtonEvent
s Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data ButtonEventAxesFieldInfo
instance AttrInfo ButtonEventAxesFieldInfo where
    type AttrBaseTypeConstraint ButtonEventAxesFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventAxesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ButtonEventAxesFieldInfo = (~) Double
    type AttrTransferTypeConstraint ButtonEventAxesFieldInfo = (~)Double
    type AttrTransferType ButtonEventAxesFieldInfo = Double
    type AttrGetType ButtonEventAxesFieldInfo = Double
    type AttrLabel ButtonEventAxesFieldInfo = "axes"
    type AttrOrigin ButtonEventAxesFieldInfo = ButtonEvent
    attrGet = getButtonEventAxes
    attrSet = setButtonEventAxes
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.axes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:axes"
        })

buttonEvent_axes :: AttrLabelProxy "axes"
buttonEvent_axes = AttrLabelProxy

#endif


-- | Get the value of the “@device@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' buttonEvent #device
-- @
getButtonEventDevice :: MonadIO m => ButtonEvent -> m (Maybe Clutter.InputDevice.InputDevice)
getButtonEventDevice :: forall (m :: * -> *).
MonadIO m =>
ButtonEvent -> m (Maybe InputDevice)
getButtonEventDevice ButtonEvent
s = IO (Maybe InputDevice) -> m (Maybe InputDevice)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputDevice) -> m (Maybe InputDevice))
-> IO (Maybe InputDevice) -> m (Maybe InputDevice)
forall a b. (a -> b) -> a -> b
$ ButtonEvent
-> (Ptr ButtonEvent -> IO (Maybe InputDevice))
-> IO (Maybe InputDevice)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO (Maybe InputDevice))
 -> IO (Maybe InputDevice))
-> (Ptr ButtonEvent -> IO (Maybe InputDevice))
-> IO (Maybe InputDevice)
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr InputDevice
val <- Ptr (Ptr InputDevice) -> IO (Ptr InputDevice)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO (Ptr Clutter.InputDevice.InputDevice)
    Maybe InputDevice
result <- Ptr InputDevice
-> (Ptr InputDevice -> IO InputDevice) -> IO (Maybe InputDevice)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr InputDevice
val ((Ptr InputDevice -> IO InputDevice) -> IO (Maybe InputDevice))
-> (Ptr InputDevice -> IO InputDevice) -> IO (Maybe InputDevice)
forall a b. (a -> b) -> a -> b
$ \Ptr InputDevice
val' -> do
        InputDevice
val'' <- ((ManagedPtr InputDevice -> InputDevice)
-> Ptr InputDevice -> IO InputDevice
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr InputDevice -> InputDevice
Clutter.InputDevice.InputDevice) Ptr InputDevice
val'
        InputDevice -> IO InputDevice
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputDevice
val''
    Maybe InputDevice -> IO (Maybe InputDevice)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputDevice
result

-- | Set the value of the “@device@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' buttonEvent [ #device 'Data.GI.Base.Attributes.:=' value ]
-- @
setButtonEventDevice :: MonadIO m => ButtonEvent -> Ptr Clutter.InputDevice.InputDevice -> m ()
setButtonEventDevice :: forall (m :: * -> *).
MonadIO m =>
ButtonEvent -> Ptr InputDevice -> m ()
setButtonEventDevice ButtonEvent
s Ptr InputDevice
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr (Ptr InputDevice) -> Ptr InputDevice -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr InputDevice
val :: Ptr Clutter.InputDevice.InputDevice)

-- | Set the value of the “@device@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #device
-- @
clearButtonEventDevice :: MonadIO m => ButtonEvent -> m ()
clearButtonEventDevice :: forall (m :: * -> *). MonadIO m => ButtonEvent -> m ()
clearButtonEventDevice ButtonEvent
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ButtonEvent -> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ButtonEvent
s ((Ptr ButtonEvent -> IO ()) -> IO ())
-> (Ptr ButtonEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ButtonEvent
ptr -> do
    Ptr (Ptr InputDevice) -> Ptr InputDevice -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ButtonEvent
ptr Ptr ButtonEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr InputDevice
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.InputDevice.InputDevice)

#if defined(ENABLE_OVERLOADING)
data ButtonEventDeviceFieldInfo
instance AttrInfo ButtonEventDeviceFieldInfo where
    type AttrBaseTypeConstraint ButtonEventDeviceFieldInfo = (~) ButtonEvent
    type AttrAllowedOps ButtonEventDeviceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ButtonEventDeviceFieldInfo = (~) (Ptr Clutter.InputDevice.InputDevice)
    type AttrTransferTypeConstraint ButtonEventDeviceFieldInfo = (~)(Ptr Clutter.InputDevice.InputDevice)
    type AttrTransferType ButtonEventDeviceFieldInfo = (Ptr Clutter.InputDevice.InputDevice)
    type AttrGetType ButtonEventDeviceFieldInfo = Maybe Clutter.InputDevice.InputDevice
    type AttrLabel ButtonEventDeviceFieldInfo = "device"
    type AttrOrigin ButtonEventDeviceFieldInfo = ButtonEvent
    attrGet = getButtonEventDevice
    attrSet = setButtonEventDevice
    attrConstruct = undefined
    attrClear = clearButtonEventDevice
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ButtonEvent.device"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.6/docs/GI-Clutter-Structs-ButtonEvent.html#g:attr:device"
        })

buttonEvent_device :: AttrLabelProxy "device"
buttonEvent_device = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ButtonEvent
type instance O.AttributeList ButtonEvent = ButtonEventAttributeList
type ButtonEventAttributeList = ('[ '("type", ButtonEventTypeFieldInfo), '("time", ButtonEventTimeFieldInfo), '("flags", ButtonEventFlagsFieldInfo), '("stage", ButtonEventStageFieldInfo), '("source", ButtonEventSourceFieldInfo), '("x", ButtonEventXFieldInfo), '("y", ButtonEventYFieldInfo), '("modifierState", ButtonEventModifierStateFieldInfo), '("button", ButtonEventButtonFieldInfo), '("clickCount", ButtonEventClickCountFieldInfo), '("axes", ButtonEventAxesFieldInfo), '("device", ButtonEventDeviceFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveButtonEventMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveButtonEventMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveButtonEventMethod t ButtonEvent, O.OverloadedMethod info ButtonEvent p) => OL.IsLabel t (ButtonEvent -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveButtonEventMethod t ButtonEvent, O.OverloadedMethod info ButtonEvent p, R.HasField t ButtonEvent p) => R.HasField t ButtonEvent p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveButtonEventMethod t ButtonEvent, O.OverloadedMethodInfo info ButtonEvent) => OL.IsLabel t (O.MethodProxy info ButtonEvent) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif