{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Wnck.Structs.ResourceUsage.ResourceUsage' struct contains information about the total resource
-- usage of an X client, and the number of resources allocated for each
-- resource type.
-- 
-- /Since: 2.6/

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

module GI.Wnck.Structs.ResourceUsage
    ( 

-- * Exported types
    ResourceUsage(..)                       ,
    newZeroResourceUsage                    ,
    noResourceUsage                         ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveResourceUsageMethod              ,
#endif




 -- * Properties
-- ** nColormapEntries #attr:nColormapEntries#
-- | number of Colormap resources allocated.

    getResourceUsageNColormapEntries        ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nColormapEntries          ,
#endif
    setResourceUsageNColormapEntries        ,


-- ** nCursors #attr:nCursors#
-- | number of Cursor resources allocated.

    getResourceUsageNCursors                ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nCursors                  ,
#endif
    setResourceUsageNCursors                ,


-- ** nFonts #attr:nFonts#
-- | number of Font resources allocated.

    getResourceUsageNFonts                  ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nFonts                    ,
#endif
    setResourceUsageNFonts                  ,


-- ** nGcs #attr:nGcs#
-- | number of GContext resources allocated.

    getResourceUsageNGcs                    ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nGcs                      ,
#endif
    setResourceUsageNGcs                    ,


-- ** nGlyphsets #attr:nGlyphsets#
-- | number of Glyphset resources allocated.

    getResourceUsageNGlyphsets              ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nGlyphsets                ,
#endif
    setResourceUsageNGlyphsets              ,


-- ** nOther #attr:nOther#
-- | number of other resources allocated.

    getResourceUsageNOther                  ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nOther                    ,
#endif
    setResourceUsageNOther                  ,


-- ** nPassiveGrabs #attr:nPassiveGrabs#
-- | number of PassiveGrab resources allocated.

    getResourceUsageNPassiveGrabs           ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nPassiveGrabs             ,
#endif
    setResourceUsageNPassiveGrabs           ,


-- ** nPictures #attr:nPictures#
-- | number of Picture resources allocated.

    getResourceUsageNPictures               ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nPictures                 ,
#endif
    setResourceUsageNPictures               ,


-- ** nPixmaps #attr:nPixmaps#
-- | number of Pixmap resources allocated.

    getResourceUsageNPixmaps                ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nPixmaps                  ,
#endif
    setResourceUsageNPixmaps                ,


-- ** nWindows #attr:nWindows#
-- | number of Window resources allocated.

    getResourceUsageNWindows                ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_nWindows                  ,
#endif
    setResourceUsageNWindows                ,


-- ** pixmapBytes #attr:pixmapBytes#
-- | number of bytes allocated in the X server for resources of
-- type Pixmap.

    getResourceUsagePixmapBytes             ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_pixmapBytes               ,
#endif
    setResourceUsagePixmapBytes             ,


-- ** totalBytesEstimate #attr:totalBytesEstimate#
-- | estimation of the total number of bytes allocated in
-- the X server.

    getResourceUsageTotalBytesEstimate      ,
#if defined(ENABLE_OVERLOADING)
    resourceUsage_totalBytesEstimate        ,
#endif
    setResourceUsageTotalBytesEstimate      ,




    ) 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


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

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

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


-- | A convenience alias for `Nothing` :: `Maybe` `ResourceUsage`.
noResourceUsage :: Maybe ResourceUsage
noResourceUsage :: Maybe ResourceUsage
noResourceUsage = Maybe ResourceUsage
forall a. Maybe a
Nothing

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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageTotalBytesEstimateFieldInfo
instance AttrInfo ResourceUsageTotalBytesEstimateFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageTotalBytesEstimateFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageTotalBytesEstimateFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageTotalBytesEstimateFieldInfo = (~) CULong
    type AttrTransferTypeConstraint ResourceUsageTotalBytesEstimateFieldInfo = (~)CULong
    type AttrTransferType ResourceUsageTotalBytesEstimateFieldInfo = CULong
    type AttrGetType ResourceUsageTotalBytesEstimateFieldInfo = CULong
    type AttrLabel ResourceUsageTotalBytesEstimateFieldInfo = "total_bytes_estimate"
    type AttrOrigin ResourceUsageTotalBytesEstimateFieldInfo = ResourceUsage
    attrGet = getResourceUsageTotalBytesEstimate
    attrSet = setResourceUsageTotalBytesEstimate
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_totalBytesEstimate :: AttrLabelProxy "totalBytesEstimate"
resourceUsage_totalBytesEstimate = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsagePixmapBytesFieldInfo
instance AttrInfo ResourceUsagePixmapBytesFieldInfo where
    type AttrBaseTypeConstraint ResourceUsagePixmapBytesFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsagePixmapBytesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsagePixmapBytesFieldInfo = (~) CULong
    type AttrTransferTypeConstraint ResourceUsagePixmapBytesFieldInfo = (~)CULong
    type AttrTransferType ResourceUsagePixmapBytesFieldInfo = CULong
    type AttrGetType ResourceUsagePixmapBytesFieldInfo = CULong
    type AttrLabel ResourceUsagePixmapBytesFieldInfo = "pixmap_bytes"
    type AttrOrigin ResourceUsagePixmapBytesFieldInfo = ResourceUsage
    attrGet = getResourceUsagePixmapBytes
    attrSet = setResourceUsagePixmapBytes
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_pixmapBytes :: AttrLabelProxy "pixmapBytes"
resourceUsage_pixmapBytes = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNPixmapsFieldInfo
instance AttrInfo ResourceUsageNPixmapsFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNPixmapsFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNPixmapsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNPixmapsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNPixmapsFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNPixmapsFieldInfo = Word32
    type AttrGetType ResourceUsageNPixmapsFieldInfo = Word32
    type AttrLabel ResourceUsageNPixmapsFieldInfo = "n_pixmaps"
    type AttrOrigin ResourceUsageNPixmapsFieldInfo = ResourceUsage
    attrGet = getResourceUsageNPixmaps
    attrSet = setResourceUsageNPixmaps
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nPixmaps :: AttrLabelProxy "nPixmaps"
resourceUsage_nPixmaps = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNWindowsFieldInfo
instance AttrInfo ResourceUsageNWindowsFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNWindowsFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNWindowsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNWindowsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNWindowsFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNWindowsFieldInfo = Word32
    type AttrGetType ResourceUsageNWindowsFieldInfo = Word32
    type AttrLabel ResourceUsageNWindowsFieldInfo = "n_windows"
    type AttrOrigin ResourceUsageNWindowsFieldInfo = ResourceUsage
    attrGet = getResourceUsageNWindows
    attrSet = setResourceUsageNWindows
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nWindows :: AttrLabelProxy "nWindows"
resourceUsage_nWindows = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNGcsFieldInfo
instance AttrInfo ResourceUsageNGcsFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNGcsFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNGcsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNGcsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNGcsFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNGcsFieldInfo = Word32
    type AttrGetType ResourceUsageNGcsFieldInfo = Word32
    type AttrLabel ResourceUsageNGcsFieldInfo = "n_gcs"
    type AttrOrigin ResourceUsageNGcsFieldInfo = ResourceUsage
    attrGet = getResourceUsageNGcs
    attrSet = setResourceUsageNGcs
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nGcs :: AttrLabelProxy "nGcs"
resourceUsage_nGcs = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNPicturesFieldInfo
instance AttrInfo ResourceUsageNPicturesFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNPicturesFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNPicturesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNPicturesFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNPicturesFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNPicturesFieldInfo = Word32
    type AttrGetType ResourceUsageNPicturesFieldInfo = Word32
    type AttrLabel ResourceUsageNPicturesFieldInfo = "n_pictures"
    type AttrOrigin ResourceUsageNPicturesFieldInfo = ResourceUsage
    attrGet = getResourceUsageNPictures
    attrSet = setResourceUsageNPictures
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nPictures :: AttrLabelProxy "nPictures"
resourceUsage_nPictures = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNGlyphsetsFieldInfo
instance AttrInfo ResourceUsageNGlyphsetsFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNGlyphsetsFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNGlyphsetsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNGlyphsetsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNGlyphsetsFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNGlyphsetsFieldInfo = Word32
    type AttrGetType ResourceUsageNGlyphsetsFieldInfo = Word32
    type AttrLabel ResourceUsageNGlyphsetsFieldInfo = "n_glyphsets"
    type AttrOrigin ResourceUsageNGlyphsetsFieldInfo = ResourceUsage
    attrGet = getResourceUsageNGlyphsets
    attrSet = setResourceUsageNGlyphsets
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nGlyphsets :: AttrLabelProxy "nGlyphsets"
resourceUsage_nGlyphsets = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNFontsFieldInfo
instance AttrInfo ResourceUsageNFontsFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNFontsFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNFontsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNFontsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNFontsFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNFontsFieldInfo = Word32
    type AttrGetType ResourceUsageNFontsFieldInfo = Word32
    type AttrLabel ResourceUsageNFontsFieldInfo = "n_fonts"
    type AttrOrigin ResourceUsageNFontsFieldInfo = ResourceUsage
    attrGet = getResourceUsageNFonts
    attrSet = setResourceUsageNFonts
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nFonts :: AttrLabelProxy "nFonts"
resourceUsage_nFonts = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNColormapEntriesFieldInfo
instance AttrInfo ResourceUsageNColormapEntriesFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNColormapEntriesFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNColormapEntriesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNColormapEntriesFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNColormapEntriesFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNColormapEntriesFieldInfo = Word32
    type AttrGetType ResourceUsageNColormapEntriesFieldInfo = Word32
    type AttrLabel ResourceUsageNColormapEntriesFieldInfo = "n_colormap_entries"
    type AttrOrigin ResourceUsageNColormapEntriesFieldInfo = ResourceUsage
    attrGet = getResourceUsageNColormapEntries
    attrSet = setResourceUsageNColormapEntries
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nColormapEntries :: AttrLabelProxy "nColormapEntries"
resourceUsage_nColormapEntries = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNPassiveGrabsFieldInfo
instance AttrInfo ResourceUsageNPassiveGrabsFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNPassiveGrabsFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNPassiveGrabsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNPassiveGrabsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNPassiveGrabsFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNPassiveGrabsFieldInfo = Word32
    type AttrGetType ResourceUsageNPassiveGrabsFieldInfo = Word32
    type AttrLabel ResourceUsageNPassiveGrabsFieldInfo = "n_passive_grabs"
    type AttrOrigin ResourceUsageNPassiveGrabsFieldInfo = ResourceUsage
    attrGet = getResourceUsageNPassiveGrabs
    attrSet = setResourceUsageNPassiveGrabs
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nPassiveGrabs :: AttrLabelProxy "nPassiveGrabs"
resourceUsage_nPassiveGrabs = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNCursorsFieldInfo
instance AttrInfo ResourceUsageNCursorsFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNCursorsFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNCursorsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNCursorsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNCursorsFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNCursorsFieldInfo = Word32
    type AttrGetType ResourceUsageNCursorsFieldInfo = Word32
    type AttrLabel ResourceUsageNCursorsFieldInfo = "n_cursors"
    type AttrOrigin ResourceUsageNCursorsFieldInfo = ResourceUsage
    attrGet = getResourceUsageNCursors
    attrSet = setResourceUsageNCursors
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nCursors :: AttrLabelProxy "nCursors"
resourceUsage_nCursors = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ResourceUsageNOtherFieldInfo
instance AttrInfo ResourceUsageNOtherFieldInfo where
    type AttrBaseTypeConstraint ResourceUsageNOtherFieldInfo = (~) ResourceUsage
    type AttrAllowedOps ResourceUsageNOtherFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ResourceUsageNOtherFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ResourceUsageNOtherFieldInfo = (~)Word32
    type AttrTransferType ResourceUsageNOtherFieldInfo = Word32
    type AttrGetType ResourceUsageNOtherFieldInfo = Word32
    type AttrLabel ResourceUsageNOtherFieldInfo = "n_other"
    type AttrOrigin ResourceUsageNOtherFieldInfo = ResourceUsage
    attrGet = getResourceUsageNOther
    attrSet = setResourceUsageNOther
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

resourceUsage_nOther :: AttrLabelProxy "nOther"
resourceUsage_nOther = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ResourceUsage
type instance O.AttributeList ResourceUsage = ResourceUsageAttributeList
type ResourceUsageAttributeList = ('[ '("totalBytesEstimate", ResourceUsageTotalBytesEstimateFieldInfo), '("pixmapBytes", ResourceUsagePixmapBytesFieldInfo), '("nPixmaps", ResourceUsageNPixmapsFieldInfo), '("nWindows", ResourceUsageNWindowsFieldInfo), '("nGcs", ResourceUsageNGcsFieldInfo), '("nPictures", ResourceUsageNPicturesFieldInfo), '("nGlyphsets", ResourceUsageNGlyphsetsFieldInfo), '("nFonts", ResourceUsageNFontsFieldInfo), '("nColormapEntries", ResourceUsageNColormapEntriesFieldInfo), '("nPassiveGrabs", ResourceUsageNPassiveGrabsFieldInfo), '("nCursors", ResourceUsageNCursorsFieldInfo), '("nOther", ResourceUsageNOtherFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif