{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Generated when the window visibility status has changed.

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

module GI.Gdk.Structs.EventVisibility
    ( 

-- * Exported types
    EventVisibility(..)                     ,
    newZeroEventVisibility                  ,
    noEventVisibility                       ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveEventVisibilityMethod            ,
#endif




 -- * Properties
-- ** sendEvent #attr:sendEvent#
-- | 'P.True' if the event was sent explicitly.

#if defined(ENABLE_OVERLOADING)
    eventVisibility_sendEvent               ,
#endif
    getEventVisibilitySendEvent             ,
    setEventVisibilitySendEvent             ,


-- ** state #attr:state#
-- | the new visibility state ('GI.Gdk.Enums.VisibilityStateFullyObscured',
--   'GI.Gdk.Enums.VisibilityStatePartial' or 'GI.Gdk.Enums.VisibilityStateUnobscured').

#if defined(ENABLE_OVERLOADING)
    eventVisibility_state                   ,
#endif
    getEventVisibilityState                 ,
    setEventVisibilityState                 ,


-- ** type #attr:type#
-- | the type of the event ('GI.Gdk.Enums.EventTypeVisibilityNotify').

#if defined(ENABLE_OVERLOADING)
    eventVisibility_type                    ,
#endif
    getEventVisibilityType                  ,
    setEventVisibilityType                  ,


-- ** window #attr:window#
-- | the window which received the event.

    clearEventVisibilityWindow              ,
#if defined(ENABLE_OVERLOADING)
    eventVisibility_window                  ,
#endif
    getEventVisibilityWindow                ,
    setEventVisibilityWindow                ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window

-- | Memory-managed wrapper type.
newtype EventVisibility = EventVisibility (ManagedPtr EventVisibility)
    deriving (EventVisibility -> EventVisibility -> Bool
(EventVisibility -> EventVisibility -> Bool)
-> (EventVisibility -> EventVisibility -> Bool)
-> Eq EventVisibility
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventVisibility -> EventVisibility -> Bool
$c/= :: EventVisibility -> EventVisibility -> Bool
== :: EventVisibility -> EventVisibility -> Bool
$c== :: EventVisibility -> EventVisibility -> Bool
Eq)
instance WrappedPtr EventVisibility where
    wrappedPtrCalloc :: IO (Ptr EventVisibility)
wrappedPtrCalloc = Int -> IO (Ptr EventVisibility)
forall a. Int -> IO (Ptr a)
callocBytes 24
    wrappedPtrCopy :: EventVisibility -> IO EventVisibility
wrappedPtrCopy = \p :: EventVisibility
p -> EventVisibility
-> (Ptr EventVisibility -> IO EventVisibility)
-> IO EventVisibility
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventVisibility
p (Int -> Ptr EventVisibility -> IO (Ptr EventVisibility)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 24 (Ptr EventVisibility -> IO (Ptr EventVisibility))
-> (Ptr EventVisibility -> IO EventVisibility)
-> Ptr EventVisibility
-> IO EventVisibility
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr EventVisibility -> EventVisibility)
-> Ptr EventVisibility -> IO EventVisibility
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr EventVisibility -> EventVisibility
EventVisibility)
    wrappedPtrFree :: Maybe (GDestroyNotify EventVisibility)
wrappedPtrFree = GDestroyNotify EventVisibility
-> Maybe (GDestroyNotify EventVisibility)
forall a. a -> Maybe a
Just GDestroyNotify EventVisibility
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `EventVisibility` struct initialized to zero.
newZeroEventVisibility :: MonadIO m => m EventVisibility
newZeroEventVisibility :: m EventVisibility
newZeroEventVisibility = IO EventVisibility -> m EventVisibility
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EventVisibility -> m EventVisibility)
-> IO EventVisibility -> m EventVisibility
forall a b. (a -> b) -> a -> b
$ IO (Ptr EventVisibility)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr EventVisibility)
-> (Ptr EventVisibility -> IO EventVisibility)
-> IO EventVisibility
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr EventVisibility -> EventVisibility)
-> Ptr EventVisibility -> IO EventVisibility
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr EventVisibility -> EventVisibility
EventVisibility

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


-- | A convenience alias for `Nothing` :: `Maybe` `EventVisibility`.
noEventVisibility :: Maybe EventVisibility
noEventVisibility :: Maybe EventVisibility
noEventVisibility = Maybe EventVisibility
forall a. Maybe a
Nothing

-- | 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' eventVisibility #type
-- @
getEventVisibilityType :: MonadIO m => EventVisibility -> m Gdk.Enums.EventType
getEventVisibilityType :: EventVisibility -> m EventType
getEventVisibilityType s :: EventVisibility
s = IO EventType -> m EventType
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
$ EventVisibility
-> (Ptr EventVisibility -> IO EventType) -> IO EventType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventVisibility
s ((Ptr EventVisibility -> IO EventType) -> IO EventType)
-> (Ptr EventVisibility -> IO EventType) -> IO EventType
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr EventVisibility
ptr -> do
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr EventVisibility
ptr Ptr EventVisibility -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CInt
    let val' :: EventType
val' = (Int -> EventType
forall a. Enum a => Int -> a
toEnum (Int -> EventType) -> (CInt -> Int) -> CInt -> EventType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
val
    EventType -> IO EventType
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' eventVisibility [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventVisibilityType :: MonadIO m => EventVisibility -> Gdk.Enums.EventType -> m ()
setEventVisibilityType :: EventVisibility -> EventType -> m ()
setEventVisibilityType s :: EventVisibility
s val :: EventType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ EventVisibility -> (Ptr EventVisibility -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventVisibility
s ((Ptr EventVisibility -> IO ()) -> IO ())
-> (Ptr EventVisibility -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr EventVisibility
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (EventType -> Int) -> EventType -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EventType -> Int
forall a. Enum a => a -> Int
fromEnum) EventType
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventVisibility
ptr Ptr EventVisibility -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data EventVisibilityTypeFieldInfo
instance AttrInfo EventVisibilityTypeFieldInfo where
    type AttrBaseTypeConstraint EventVisibilityTypeFieldInfo = (~) EventVisibility
    type AttrAllowedOps EventVisibilityTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventVisibilityTypeFieldInfo = (~) Gdk.Enums.EventType
    type AttrTransferTypeConstraint EventVisibilityTypeFieldInfo = (~)Gdk.Enums.EventType
    type AttrTransferType EventVisibilityTypeFieldInfo = Gdk.Enums.EventType
    type AttrGetType EventVisibilityTypeFieldInfo = Gdk.Enums.EventType
    type AttrLabel EventVisibilityTypeFieldInfo = "type"
    type AttrOrigin EventVisibilityTypeFieldInfo = EventVisibility
    attrGet = getEventVisibilityType
    attrSet = setEventVisibilityType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

eventVisibility_type :: AttrLabelProxy "type"
eventVisibility_type = AttrLabelProxy

#endif


-- | Get the value of the “@window@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventVisibility #window
-- @
getEventVisibilityWindow :: MonadIO m => EventVisibility -> m (Maybe Gdk.Window.Window)
getEventVisibilityWindow :: EventVisibility -> m (Maybe Window)
getEventVisibilityWindow s :: EventVisibility
s = IO (Maybe Window) -> m (Maybe Window)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Window) -> m (Maybe Window))
-> IO (Maybe Window) -> m (Maybe Window)
forall a b. (a -> b) -> a -> b
$ EventVisibility
-> (Ptr EventVisibility -> IO (Maybe Window)) -> IO (Maybe Window)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventVisibility
s ((Ptr EventVisibility -> IO (Maybe Window)) -> IO (Maybe Window))
-> (Ptr EventVisibility -> IO (Maybe Window)) -> IO (Maybe Window)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr EventVisibility
ptr -> do
    Ptr Window
val <- Ptr (Ptr Window) -> IO (Ptr Window)
forall a. Storable a => Ptr a -> IO a
peek (Ptr EventVisibility
ptr Ptr EventVisibility -> Int -> Ptr (Ptr Window)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO (Ptr Gdk.Window.Window)
    Maybe Window
result <- Ptr Window -> (Ptr Window -> IO Window) -> IO (Maybe Window)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Window
val ((Ptr Window -> IO Window) -> IO (Maybe Window))
-> (Ptr Window -> IO Window) -> IO (Maybe Window)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr Window
val' -> do
        Window
val'' <- ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
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'
        Window -> IO Window
forall (m :: * -> *) a. Monad m => a -> m a
return Window
val''
    Maybe Window -> IO (Maybe Window)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Window
result

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

-- | Set the value of the “@window@” 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' #window
-- @
clearEventVisibilityWindow :: MonadIO m => EventVisibility -> m ()
clearEventVisibilityWindow :: EventVisibility -> m ()
clearEventVisibilityWindow s :: EventVisibility
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ EventVisibility -> (Ptr EventVisibility -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventVisibility
s ((Ptr EventVisibility -> IO ()) -> IO ())
-> (Ptr EventVisibility -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr EventVisibility
ptr -> do
    Ptr (Ptr Window) -> Ptr Window -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventVisibility
ptr Ptr EventVisibility -> Int -> Ptr (Ptr Window)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (Ptr Window
forall a. Ptr a
FP.nullPtr :: Ptr Gdk.Window.Window)

#if defined(ENABLE_OVERLOADING)
data EventVisibilityWindowFieldInfo
instance AttrInfo EventVisibilityWindowFieldInfo where
    type AttrBaseTypeConstraint EventVisibilityWindowFieldInfo = (~) EventVisibility
    type AttrAllowedOps EventVisibilityWindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint EventVisibilityWindowFieldInfo = (~) (Ptr Gdk.Window.Window)
    type AttrTransferTypeConstraint EventVisibilityWindowFieldInfo = (~)(Ptr Gdk.Window.Window)
    type AttrTransferType EventVisibilityWindowFieldInfo = (Ptr Gdk.Window.Window)
    type AttrGetType EventVisibilityWindowFieldInfo = Maybe Gdk.Window.Window
    type AttrLabel EventVisibilityWindowFieldInfo = "window"
    type AttrOrigin EventVisibilityWindowFieldInfo = EventVisibility
    attrGet = getEventVisibilityWindow
    attrSet = setEventVisibilityWindow
    attrConstruct = undefined
    attrClear = clearEventVisibilityWindow
    attrTransfer _ v = do
        return v

eventVisibility_window :: AttrLabelProxy "window"
eventVisibility_window = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data EventVisibilitySendEventFieldInfo
instance AttrInfo EventVisibilitySendEventFieldInfo where
    type AttrBaseTypeConstraint EventVisibilitySendEventFieldInfo = (~) EventVisibility
    type AttrAllowedOps EventVisibilitySendEventFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventVisibilitySendEventFieldInfo = (~) Int8
    type AttrTransferTypeConstraint EventVisibilitySendEventFieldInfo = (~)Int8
    type AttrTransferType EventVisibilitySendEventFieldInfo = Int8
    type AttrGetType EventVisibilitySendEventFieldInfo = Int8
    type AttrLabel EventVisibilitySendEventFieldInfo = "send_event"
    type AttrOrigin EventVisibilitySendEventFieldInfo = EventVisibility
    attrGet = getEventVisibilitySendEvent
    attrSet = setEventVisibilitySendEvent
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

eventVisibility_sendEvent :: AttrLabelProxy "sendEvent"
eventVisibility_sendEvent = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data EventVisibilityStateFieldInfo
instance AttrInfo EventVisibilityStateFieldInfo where
    type AttrBaseTypeConstraint EventVisibilityStateFieldInfo = (~) EventVisibility
    type AttrAllowedOps EventVisibilityStateFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventVisibilityStateFieldInfo = (~) Gdk.Enums.VisibilityState
    type AttrTransferTypeConstraint EventVisibilityStateFieldInfo = (~)Gdk.Enums.VisibilityState
    type AttrTransferType EventVisibilityStateFieldInfo = Gdk.Enums.VisibilityState
    type AttrGetType EventVisibilityStateFieldInfo = Gdk.Enums.VisibilityState
    type AttrLabel EventVisibilityStateFieldInfo = "state"
    type AttrOrigin EventVisibilityStateFieldInfo = EventVisibility
    attrGet = getEventVisibilityState
    attrSet = setEventVisibilityState
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

eventVisibility_state :: AttrLabelProxy "state"
eventVisibility_state = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventVisibility
type instance O.AttributeList EventVisibility = EventVisibilityAttributeList
type EventVisibilityAttributeList = ('[ '("type", EventVisibilityTypeFieldInfo), '("window", EventVisibilityWindowFieldInfo), '("sendEvent", EventVisibilitySendEventFieldInfo), '("state", EventVisibilityStateFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveEventVisibilityMethod (t :: Symbol) (o :: *) :: * where
    ResolveEventVisibilityMethod l o = O.MethodResolutionFailed l o

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

#endif