{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Structs.EventExpose
(
EventExpose(..) ,
newZeroEventExpose ,
#if defined(ENABLE_OVERLOADING)
ResolveEventExposeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
eventExpose_area ,
#endif
getEventExposeArea ,
#if defined(ENABLE_OVERLOADING)
eventExpose_count ,
#endif
getEventExposeCount ,
setEventExposeCount ,
clearEventExposeRegion ,
#if defined(ENABLE_OVERLOADING)
eventExpose_region ,
#endif
getEventExposeRegion ,
setEventExposeRegion ,
#if defined(ENABLE_OVERLOADING)
eventExpose_sendEvent ,
#endif
getEventExposeSendEvent ,
setEventExposeSendEvent ,
#if defined(ENABLE_OVERLOADING)
eventExpose_type ,
#endif
getEventExposeType ,
setEventExposeType ,
clearEventExposeWindow ,
#if defined(ENABLE_OVERLOADING)
eventExpose_window ,
#endif
getEventExposeWindow ,
setEventExposeWindow ,
) 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 GI.Cairo.Structs.Region as Cairo.Region
import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
import {-# SOURCE #-} qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
newtype EventExpose = EventExpose (SP.ManagedPtr EventExpose)
deriving (EventExpose -> EventExpose -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventExpose -> EventExpose -> Bool
$c/= :: EventExpose -> EventExpose -> Bool
== :: EventExpose -> EventExpose -> Bool
$c== :: EventExpose -> EventExpose -> Bool
Eq)
instance SP.ManagedPtrNewtype EventExpose where
toManagedPtr :: EventExpose -> ManagedPtr EventExpose
toManagedPtr (EventExpose ManagedPtr EventExpose
p) = ManagedPtr EventExpose
p
instance BoxedPtr EventExpose where
boxedPtrCopy :: EventExpose -> IO EventExpose
boxedPtrCopy = \EventExpose
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EventExpose
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
36 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr EventExpose -> EventExpose
EventExpose)
boxedPtrFree :: EventExpose -> IO ()
boxedPtrFree = \EventExpose
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr EventExpose
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr EventExpose where
boxedPtrCalloc :: IO (Ptr EventExpose)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
36
newZeroEventExpose :: MonadIO m => m EventExpose
newZeroEventExpose :: forall (m :: * -> *). MonadIO m => m EventExpose
newZeroEventExpose = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr EventExpose -> EventExpose
EventExpose
instance tag ~ 'AttrSet => Constructible EventExpose tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr EventExpose -> EventExpose)
-> [AttrOp EventExpose tag] -> m EventExpose
new ManagedPtr EventExpose -> EventExpose
_ [AttrOp EventExpose tag]
attrs = do
EventExpose
o <- forall (m :: * -> *). MonadIO m => m EventExpose
newZeroEventExpose
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set EventExpose
o [AttrOp EventExpose tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return EventExpose
o
getEventExposeType :: MonadIO m => EventExpose -> m Gdk.Enums.EventType
getEventExposeType :: forall (m :: * -> *). MonadIO m => EventExpose -> m EventType
getEventExposeType EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CInt
let val' :: EventType
val' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
val
forall (m :: * -> *) a. Monad m => a -> m a
return EventType
val'
setEventExposeType :: MonadIO m => EventExpose -> Gdk.Enums.EventType -> m ()
setEventExposeType :: forall (m :: * -> *). MonadIO m => EventExpose -> EventType -> m ()
setEventExposeType EventExpose
s EventType
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
let val' :: CInt
val' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) EventType
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data EventExposeTypeFieldInfo
instance AttrInfo EventExposeTypeFieldInfo where
type AttrBaseTypeConstraint EventExposeTypeFieldInfo = (~) EventExpose
type AttrAllowedOps EventExposeTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventExposeTypeFieldInfo = (~) Gdk.Enums.EventType
type AttrTransferTypeConstraint EventExposeTypeFieldInfo = (~)Gdk.Enums.EventType
type AttrTransferType EventExposeTypeFieldInfo = Gdk.Enums.EventType
type AttrGetType EventExposeTypeFieldInfo = Gdk.Enums.EventType
type AttrLabel EventExposeTypeFieldInfo = "type"
type AttrOrigin EventExposeTypeFieldInfo = EventExpose
attrGet = getEventExposeType
attrSet = setEventExposeType
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventExpose.type"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventExpose.html#g:attr:type"
})
eventExpose_type :: AttrLabelProxy "type"
eventExpose_type = AttrLabelProxy
#endif
getEventExposeWindow :: MonadIO m => EventExpose -> m (Maybe Gdk.Window.Window)
getEventExposeWindow :: forall (m :: * -> *). MonadIO m => EventExpose -> m (Maybe Window)
getEventExposeWindow EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
Ptr Window
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (Ptr Gdk.Window.Window)
Maybe Window
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Window
val forall a b. (a -> b) -> a -> b
$ \Ptr Window
val' -> do
Window
val'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Gdk.Window.Window) Ptr Window
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Window
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Window
result
setEventExposeWindow :: MonadIO m => EventExpose -> Ptr Gdk.Window.Window -> m ()
setEventExposeWindow :: forall (m :: * -> *).
MonadIO m =>
EventExpose -> Ptr Window -> m ()
setEventExposeWindow EventExpose
s Ptr Window
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr Window
val :: Ptr Gdk.Window.Window)
clearEventExposeWindow :: MonadIO m => EventExpose -> m ()
clearEventExposeWindow :: forall (m :: * -> *). MonadIO m => EventExpose -> m ()
clearEventExposeWindow EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: Ptr Gdk.Window.Window)
#if defined(ENABLE_OVERLOADING)
data EventExposeWindowFieldInfo
instance AttrInfo EventExposeWindowFieldInfo where
type AttrBaseTypeConstraint EventExposeWindowFieldInfo = (~) EventExpose
type AttrAllowedOps EventExposeWindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint EventExposeWindowFieldInfo = (~) (Ptr Gdk.Window.Window)
type AttrTransferTypeConstraint EventExposeWindowFieldInfo = (~)(Ptr Gdk.Window.Window)
type AttrTransferType EventExposeWindowFieldInfo = (Ptr Gdk.Window.Window)
type AttrGetType EventExposeWindowFieldInfo = Maybe Gdk.Window.Window
type AttrLabel EventExposeWindowFieldInfo = "window"
type AttrOrigin EventExposeWindowFieldInfo = EventExpose
attrGet = getEventExposeWindow
attrSet = setEventExposeWindow
attrConstruct = undefined
attrClear = clearEventExposeWindow
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventExpose.window"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventExpose.html#g:attr:window"
})
eventExpose_window :: AttrLabelProxy "window"
eventExpose_window = AttrLabelProxy
#endif
getEventExposeSendEvent :: MonadIO m => EventExpose -> m Int8
getEventExposeSendEvent :: forall (m :: * -> *). MonadIO m => EventExpose -> m Int8
getEventExposeSendEvent EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
Int8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int8
forall (m :: * -> *) a. Monad m => a -> m a
return Int8
val
setEventExposeSendEvent :: MonadIO m => EventExpose -> Int8 -> m ()
setEventExposeSendEvent :: forall (m :: * -> *). MonadIO m => EventExpose -> Int8 -> m ()
setEventExposeSendEvent EventExpose
s Int8
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int8
val :: Int8)
#if defined(ENABLE_OVERLOADING)
data EventExposeSendEventFieldInfo
instance AttrInfo EventExposeSendEventFieldInfo where
type AttrBaseTypeConstraint EventExposeSendEventFieldInfo = (~) EventExpose
type AttrAllowedOps EventExposeSendEventFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventExposeSendEventFieldInfo = (~) Int8
type AttrTransferTypeConstraint EventExposeSendEventFieldInfo = (~)Int8
type AttrTransferType EventExposeSendEventFieldInfo = Int8
type AttrGetType EventExposeSendEventFieldInfo = Int8
type AttrLabel EventExposeSendEventFieldInfo = "send_event"
type AttrOrigin EventExposeSendEventFieldInfo = EventExpose
attrGet = getEventExposeSendEvent
attrSet = setEventExposeSendEvent
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventExpose.sendEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventExpose.html#g:attr:sendEvent"
})
eventExpose_sendEvent :: AttrLabelProxy "sendEvent"
eventExpose_sendEvent = AttrLabelProxy
#endif
getEventExposeArea :: MonadIO m => EventExpose -> m Gdk.Rectangle.Rectangle
getEventExposeArea :: forall (m :: * -> *). MonadIO m => EventExpose -> m Rectangle
getEventExposeArea EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
let val :: Ptr Rectangle
val = Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12 :: (Ptr Gdk.Rectangle.Rectangle)
Rectangle
val' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Rectangle -> Rectangle
Gdk.Rectangle.Rectangle) Ptr Rectangle
val
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
val'
#if defined(ENABLE_OVERLOADING)
data EventExposeAreaFieldInfo
instance AttrInfo EventExposeAreaFieldInfo where
type AttrBaseTypeConstraint EventExposeAreaFieldInfo = (~) EventExpose
type AttrAllowedOps EventExposeAreaFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint EventExposeAreaFieldInfo = (~) (Ptr Gdk.Rectangle.Rectangle)
type AttrTransferTypeConstraint EventExposeAreaFieldInfo = (~)(Ptr Gdk.Rectangle.Rectangle)
type AttrTransferType EventExposeAreaFieldInfo = (Ptr Gdk.Rectangle.Rectangle)
type AttrGetType EventExposeAreaFieldInfo = Gdk.Rectangle.Rectangle
type AttrLabel EventExposeAreaFieldInfo = "area"
type AttrOrigin EventExposeAreaFieldInfo = EventExpose
attrGet = getEventExposeArea
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventExpose.area"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventExpose.html#g:attr:area"
})
eventExpose_area :: AttrLabelProxy "area"
eventExpose_area = AttrLabelProxy
#endif
getEventExposeRegion :: MonadIO m => EventExpose -> m (Maybe Cairo.Region.Region)
getEventExposeRegion :: forall (m :: * -> *). MonadIO m => EventExpose -> m (Maybe Region)
getEventExposeRegion EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
Ptr Region
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO (Ptr Cairo.Region.Region)
Maybe Region
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Region
val forall a b. (a -> b) -> a -> b
$ \Ptr Region
val' -> do
Region
val'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Region -> Region
Cairo.Region.Region) Ptr Region
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Region
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Region
result
setEventExposeRegion :: MonadIO m => EventExpose -> Ptr Cairo.Region.Region -> m ()
setEventExposeRegion :: forall (m :: * -> *).
MonadIO m =>
EventExpose -> Ptr Region -> m ()
setEventExposeRegion EventExpose
s Ptr Region
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (Ptr Region
val :: Ptr Cairo.Region.Region)
clearEventExposeRegion :: MonadIO m => EventExpose -> m ()
clearEventExposeRegion :: forall (m :: * -> *). MonadIO m => EventExpose -> m ()
clearEventExposeRegion EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (forall a. Ptr a
FP.nullPtr :: Ptr Cairo.Region.Region)
#if defined(ENABLE_OVERLOADING)
data EventExposeRegionFieldInfo
instance AttrInfo EventExposeRegionFieldInfo where
type AttrBaseTypeConstraint EventExposeRegionFieldInfo = (~) EventExpose
type AttrAllowedOps EventExposeRegionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint EventExposeRegionFieldInfo = (~) (Ptr Cairo.Region.Region)
type AttrTransferTypeConstraint EventExposeRegionFieldInfo = (~)(Ptr Cairo.Region.Region)
type AttrTransferType EventExposeRegionFieldInfo = (Ptr Cairo.Region.Region)
type AttrGetType EventExposeRegionFieldInfo = Maybe Cairo.Region.Region
type AttrLabel EventExposeRegionFieldInfo = "region"
type AttrOrigin EventExposeRegionFieldInfo = EventExpose
attrGet = getEventExposeRegion
attrSet = setEventExposeRegion
attrConstruct = undefined
attrClear = clearEventExposeRegion
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventExpose.region"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventExpose.html#g:attr:region"
})
eventExpose_region :: AttrLabelProxy "region"
eventExpose_region = AttrLabelProxy
#endif
getEventExposeCount :: MonadIO m => EventExpose -> m Int32
getEventExposeCount :: forall (m :: * -> *). MonadIO m => EventExpose -> m Int32
getEventExposeCount EventExpose
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setEventExposeCount :: MonadIO m => EventExpose -> Int32 -> m ()
setEventExposeCount :: forall (m :: * -> *). MonadIO m => EventExpose -> Int32 -> m ()
setEventExposeCount EventExpose
s Int32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventExpose
s forall a b. (a -> b) -> a -> b
$ \Ptr EventExpose
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventExpose
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data EventExposeCountFieldInfo
instance AttrInfo EventExposeCountFieldInfo where
type AttrBaseTypeConstraint EventExposeCountFieldInfo = (~) EventExpose
type AttrAllowedOps EventExposeCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventExposeCountFieldInfo = (~) Int32
type AttrTransferTypeConstraint EventExposeCountFieldInfo = (~)Int32
type AttrTransferType EventExposeCountFieldInfo = Int32
type AttrGetType EventExposeCountFieldInfo = Int32
type AttrLabel EventExposeCountFieldInfo = "count"
type AttrOrigin EventExposeCountFieldInfo = EventExpose
attrGet = getEventExposeCount
attrSet = setEventExposeCount
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventExpose.count"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventExpose.html#g:attr:count"
})
eventExpose_count :: AttrLabelProxy "count"
eventExpose_count = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventExpose
type instance O.AttributeList EventExpose = EventExposeAttributeList
type EventExposeAttributeList = ('[ '("type", EventExposeTypeFieldInfo), '("window", EventExposeWindowFieldInfo), '("sendEvent", EventExposeSendEventFieldInfo), '("area", EventExposeAreaFieldInfo), '("region", EventExposeRegionFieldInfo), '("count", EventExposeCountFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveEventExposeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveEventExposeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEventExposeMethod t EventExpose, O.OverloadedMethod info EventExpose p) => OL.IsLabel t (EventExpose -> 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 ~ ResolveEventExposeMethod t EventExpose, O.OverloadedMethod info EventExpose p, R.HasField t EventExpose p) => R.HasField t EventExpose p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEventExposeMethod t EventExpose, O.OverloadedMethodInfo info EventExpose) => OL.IsLabel t (O.MethodProxy info EventExpose) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif