{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A @GdkPixbufModule@ contains the necessary functions to load and save
-- images in a certain file format.
-- 
-- If @GdkPixbuf@ has been compiled with @GModule@ support, it can be extended
-- by modules which can load (and perhaps also save) new image and animation
-- formats.
-- 
-- == Implementing modules
-- 
-- The @GdkPixbuf@ interfaces needed for implementing modules are contained in
-- @gdk-pixbuf-io.h@ (and @gdk-pixbuf-animation.h@ if the module supports
-- animations). They are not covered by the same stability guarantees as the
-- regular GdkPixbuf API. To underline this fact, they are protected by the
-- @GDK_PIXBUF_ENABLE_BACKEND@ pre-processor symbol.
-- 
-- Each loadable module must contain a @GdkPixbufModuleFillVtableFunc@ function
-- named @fill_vtable@, which will get called when the module
-- is loaded and must set the function pointers of the @GdkPixbufModule@.
-- 
-- In order to make format-checking work before actually loading the modules
-- (which may require calling @dlopen@ to load image libraries), modules export
-- their signatures (and other information) via the @fill_info@ function. An
-- external utility, @gdk-pixbuf-query-loaders@, uses this to create a text
-- file containing a list of all available loaders and  their signatures.
-- This file is then read at runtime by @GdkPixbuf@ to obtain the list of
-- available loaders and their signatures.
-- 
-- Modules may only implement a subset of the functionality available via
-- @GdkPixbufModule@. If a particular functionality is not implemented, the
-- @fill_vtable@ function will simply not set the corresponding
-- function pointers of the @GdkPixbufModule@ structure. If a module supports
-- incremental loading (i.e. provides @begin_load@, @stop_load@ and
-- @load_increment@), it doesn\'t have to implement @load@, since @GdkPixbuf@
-- can supply a generic @load@ implementation wrapping the incremental loading.
-- 
-- == Installing modules
-- 
-- Installing a module is a two-step process:
-- 
--  - copy the module file(s) to the loader directory (normally
--    @$libdir\/gdk-pixbuf-2.0\/$version\/loaders@, unless overridden by the
--    environment variable @GDK_PIXBUF_MODULEDIR@)
--  - call @gdk-pixbuf-query-loaders@ to update the module file (normally
--    @$libdir\/gdk-pixbuf-2.0\/$version\/loaders.cache@, unless overridden
--    by the environment variable @GDK_PIXBUF_MODULE_FILE@)

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

module GI.GdkPixbuf.Structs.PixbufModule
    ( 

-- * Exported types
    PixbufModule(..)                        ,
    newZeroPixbufModule                     ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolvePixbufModuleMethod               ,
#endif



 -- * Properties


-- ** info #attr:info#
-- | a @GdkPixbufFormat@ holding information about the module.

    clearPixbufModuleInfo                   ,
    getPixbufModuleInfo                     ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_info                       ,
#endif
    setPixbufModuleInfo                     ,


-- ** isSaveOptionSupported #attr:isSaveOptionSupported#
-- | /No description available in the introspection data./

    clearPixbufModuleIsSaveOptionSupported  ,
    getPixbufModuleIsSaveOptionSupported    ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_isSaveOptionSupported      ,
#endif
    setPixbufModuleIsSaveOptionSupported    ,


-- ** loadIncrement #attr:loadIncrement#
-- | /No description available in the introspection data./

    clearPixbufModuleLoadIncrement          ,
    getPixbufModuleLoadIncrement            ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_loadIncrement              ,
#endif
    setPixbufModuleLoadIncrement            ,


-- ** module #attr:module#
-- | the loaded @GModule@.

    clearPixbufModuleModule                 ,
    getPixbufModuleModule                   ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_module                     ,
#endif
    setPixbufModuleModule                   ,


-- ** moduleName #attr:moduleName#
-- | the name of the module, usually the same as the
--  usual file extension for images of this type, eg. \"xpm\", \"jpeg\" or \"png\".

    clearPixbufModuleModuleName             ,
    getPixbufModuleModuleName               ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_moduleName                 ,
#endif
    setPixbufModuleModuleName               ,


-- ** modulePath #attr:modulePath#
-- | the path from which the module is loaded.

    clearPixbufModuleModulePath             ,
    getPixbufModuleModulePath               ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_modulePath                 ,
#endif
    setPixbufModuleModulePath               ,


-- ** save #attr:save#
-- | /No description available in the introspection data./

    clearPixbufModuleSave                   ,
    getPixbufModuleSave                     ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_save                       ,
#endif
    setPixbufModuleSave                     ,


-- ** stopLoad #attr:stopLoad#
-- | /No description available in the introspection data./

    clearPixbufModuleStopLoad               ,
    getPixbufModuleStopLoad                 ,
#if defined(ENABLE_OVERLOADING)
    pixbufModule_stopLoad                   ,
#endif
    setPixbufModuleStopLoad                 ,




    ) 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.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.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.GModule.Structs.Module as GModule.Module
import qualified GI.GdkPixbuf.Callbacks as GdkPixbuf.Callbacks
import {-# SOURCE #-} qualified GI.GdkPixbuf.Structs.PixbufFormat as GdkPixbuf.PixbufFormat

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

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

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


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

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


-- | Get the value of the “@module_name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pixbufModule #moduleName
-- @
getPixbufModuleModuleName :: MonadIO m => PixbufModule -> m (Maybe T.Text)
getPixbufModuleModuleName :: forall (m :: * -> *). MonadIO m => PixbufModule -> m (Maybe Text)
getPixbufModuleModuleName PixbufModule
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ PixbufModule
-> (Ptr PixbufModule -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr PixbufModule -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr PixbufModule
ptr Ptr PixbufModule -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

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

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

#if defined(ENABLE_OVERLOADING)
data PixbufModuleModuleNameFieldInfo
instance AttrInfo PixbufModuleModuleNameFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleModuleNameFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleModuleNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleModuleNameFieldInfo = (~) CString
    type AttrTransferTypeConstraint PixbufModuleModuleNameFieldInfo = (~)CString
    type AttrTransferType PixbufModuleModuleNameFieldInfo = CString
    type AttrGetType PixbufModuleModuleNameFieldInfo = Maybe T.Text
    type AttrLabel PixbufModuleModuleNameFieldInfo = "module_name"
    type AttrOrigin PixbufModuleModuleNameFieldInfo = PixbufModule
    attrGet = getPixbufModuleModuleName
    attrSet = setPixbufModuleModuleName
    attrConstruct = undefined
    attrClear = clearPixbufModuleModuleName
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.moduleName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:moduleName"
        })

pixbufModule_moduleName :: AttrLabelProxy "moduleName"
pixbufModule_moduleName = AttrLabelProxy

#endif


-- | Get the value of the “@module_path@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pixbufModule #modulePath
-- @
getPixbufModuleModulePath :: MonadIO m => PixbufModule -> m (Maybe T.Text)
getPixbufModuleModulePath :: forall (m :: * -> *). MonadIO m => PixbufModule -> m (Maybe Text)
getPixbufModuleModulePath PixbufModule
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ PixbufModule
-> (Ptr PixbufModule -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr PixbufModule -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr PixbufModule
ptr Ptr PixbufModule -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

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

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

#if defined(ENABLE_OVERLOADING)
data PixbufModuleModulePathFieldInfo
instance AttrInfo PixbufModuleModulePathFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleModulePathFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleModulePathFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleModulePathFieldInfo = (~) CString
    type AttrTransferTypeConstraint PixbufModuleModulePathFieldInfo = (~)CString
    type AttrTransferType PixbufModuleModulePathFieldInfo = CString
    type AttrGetType PixbufModuleModulePathFieldInfo = Maybe T.Text
    type AttrLabel PixbufModuleModulePathFieldInfo = "module_path"
    type AttrOrigin PixbufModuleModulePathFieldInfo = PixbufModule
    attrGet = getPixbufModuleModulePath
    attrSet = setPixbufModuleModulePath
    attrConstruct = undefined
    attrClear = clearPixbufModuleModulePath
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.modulePath"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:modulePath"
        })

pixbufModule_modulePath :: AttrLabelProxy "modulePath"
pixbufModule_modulePath = AttrLabelProxy

#endif


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

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

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

#if defined(ENABLE_OVERLOADING)
data PixbufModuleModuleFieldInfo
instance AttrInfo PixbufModuleModuleFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleModuleFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleModuleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleModuleFieldInfo = (~) (Ptr GModule.Module.Module)
    type AttrTransferTypeConstraint PixbufModuleModuleFieldInfo = (~)(Ptr GModule.Module.Module)
    type AttrTransferType PixbufModuleModuleFieldInfo = (Ptr GModule.Module.Module)
    type AttrGetType PixbufModuleModuleFieldInfo = Maybe GModule.Module.Module
    type AttrLabel PixbufModuleModuleFieldInfo = "module"
    type AttrOrigin PixbufModuleModuleFieldInfo = PixbufModule
    attrGet = getPixbufModuleModule
    attrSet = setPixbufModuleModule
    attrConstruct = undefined
    attrClear = clearPixbufModuleModule
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.module"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:module"
        })

pixbufModule_module :: AttrLabelProxy "module"
pixbufModule_module = AttrLabelProxy

#endif


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

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

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

#if defined(ENABLE_OVERLOADING)
data PixbufModuleInfoFieldInfo
instance AttrInfo PixbufModuleInfoFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleInfoFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleInfoFieldInfo = (~) (Ptr GdkPixbuf.PixbufFormat.PixbufFormat)
    type AttrTransferTypeConstraint PixbufModuleInfoFieldInfo = (~)(Ptr GdkPixbuf.PixbufFormat.PixbufFormat)
    type AttrTransferType PixbufModuleInfoFieldInfo = (Ptr GdkPixbuf.PixbufFormat.PixbufFormat)
    type AttrGetType PixbufModuleInfoFieldInfo = Maybe GdkPixbuf.PixbufFormat.PixbufFormat
    type AttrLabel PixbufModuleInfoFieldInfo = "info"
    type AttrOrigin PixbufModuleInfoFieldInfo = PixbufModule
    attrGet = getPixbufModuleInfo
    attrSet = setPixbufModuleInfo
    attrConstruct = undefined
    attrClear = clearPixbufModuleInfo
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.info"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:info"
        })

pixbufModule_info :: AttrLabelProxy "info"
pixbufModule_info = AttrLabelProxy

#endif


-- | Get the value of the “@stop_load@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pixbufModule #stopLoad
-- @
getPixbufModuleStopLoad :: MonadIO m => PixbufModule -> m (Maybe GdkPixbuf.Callbacks.PixbufModuleStopLoadFieldCallback)
getPixbufModuleStopLoad :: forall (m :: * -> *).
MonadIO m =>
PixbufModule -> m (Maybe PixbufModuleStopLoadFieldCallback)
getPixbufModuleStopLoad PixbufModule
s = IO (Maybe PixbufModuleStopLoadFieldCallback)
-> m (Maybe PixbufModuleStopLoadFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PixbufModuleStopLoadFieldCallback)
 -> m (Maybe PixbufModuleStopLoadFieldCallback))
-> IO (Maybe PixbufModuleStopLoadFieldCallback)
-> m (Maybe PixbufModuleStopLoadFieldCallback)
forall a b. (a -> b) -> a -> b
$ PixbufModule
-> (Ptr PixbufModule
    -> IO (Maybe PixbufModuleStopLoadFieldCallback))
-> IO (Maybe PixbufModuleStopLoadFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO (Maybe PixbufModuleStopLoadFieldCallback))
 -> IO (Maybe PixbufModuleStopLoadFieldCallback))
-> (Ptr PixbufModule
    -> IO (Maybe PixbufModuleStopLoadFieldCallback))
-> IO (Maybe PixbufModuleStopLoadFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    FunPtr C_PixbufModuleStopLoadFieldCallback
val <- Ptr (FunPtr C_PixbufModuleStopLoadFieldCallback)
-> IO (FunPtr C_PixbufModuleStopLoadFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int -> Ptr (FunPtr C_PixbufModuleStopLoadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleStopLoadFieldCallback)
    Maybe PixbufModuleStopLoadFieldCallback
result <- FunPtr C_PixbufModuleStopLoadFieldCallback
-> (FunPtr C_PixbufModuleStopLoadFieldCallback
    -> IO PixbufModuleStopLoadFieldCallback)
-> IO (Maybe PixbufModuleStopLoadFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_PixbufModuleStopLoadFieldCallback
val ((FunPtr C_PixbufModuleStopLoadFieldCallback
  -> IO PixbufModuleStopLoadFieldCallback)
 -> IO (Maybe PixbufModuleStopLoadFieldCallback))
-> (FunPtr C_PixbufModuleStopLoadFieldCallback
    -> IO PixbufModuleStopLoadFieldCallback)
-> IO (Maybe PixbufModuleStopLoadFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_PixbufModuleStopLoadFieldCallback
val' -> do
        let val'' :: PixbufModuleStopLoadFieldCallback
val'' = FunPtr C_PixbufModuleStopLoadFieldCallback
-> PixbufModuleStopLoadFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_PixbufModuleStopLoadFieldCallback -> Ptr () -> m ()
GdkPixbuf.Callbacks.dynamic_PixbufModuleStopLoadFieldCallback FunPtr C_PixbufModuleStopLoadFieldCallback
val'
        PixbufModuleStopLoadFieldCallback
-> IO PixbufModuleStopLoadFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufModuleStopLoadFieldCallback
val''
    Maybe PixbufModuleStopLoadFieldCallback
-> IO (Maybe PixbufModuleStopLoadFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufModuleStopLoadFieldCallback
result

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

-- | Set the value of the “@stop_load@” 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' #stopLoad
-- @
clearPixbufModuleStopLoad :: MonadIO m => PixbufModule -> m ()
clearPixbufModuleStopLoad :: forall (m :: * -> *). MonadIO m => PixbufModule -> m ()
clearPixbufModuleStopLoad PixbufModule
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PixbufModule -> (Ptr PixbufModule -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO ()) -> IO ())
-> (Ptr PixbufModule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    Ptr (FunPtr C_PixbufModuleStopLoadFieldCallback)
-> FunPtr C_PixbufModuleStopLoadFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int -> Ptr (FunPtr C_PixbufModuleStopLoadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (FunPtr C_PixbufModuleStopLoadFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GdkPixbuf.Callbacks.C_PixbufModuleStopLoadFieldCallback)

#if defined(ENABLE_OVERLOADING)
data PixbufModuleStopLoadFieldInfo
instance AttrInfo PixbufModuleStopLoadFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleStopLoadFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleStopLoadFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleStopLoadFieldInfo = (~) (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleStopLoadFieldCallback)
    type AttrTransferTypeConstraint PixbufModuleStopLoadFieldInfo = (~)(FunPtr GdkPixbuf.Callbacks.C_PixbufModuleStopLoadFieldCallback)
    type AttrTransferType PixbufModuleStopLoadFieldInfo = (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleStopLoadFieldCallback)
    type AttrGetType PixbufModuleStopLoadFieldInfo = Maybe GdkPixbuf.Callbacks.PixbufModuleStopLoadFieldCallback
    type AttrLabel PixbufModuleStopLoadFieldInfo = "stop_load"
    type AttrOrigin PixbufModuleStopLoadFieldInfo = PixbufModule
    attrGet = getPixbufModuleStopLoad
    attrSet = setPixbufModuleStopLoad
    attrConstruct = undefined
    attrClear = clearPixbufModuleStopLoad
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.stopLoad"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:stopLoad"
        })

pixbufModule_stopLoad :: AttrLabelProxy "stopLoad"
pixbufModule_stopLoad = AttrLabelProxy

#endif


-- | Get the value of the “@load_increment@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pixbufModule #loadIncrement
-- @
getPixbufModuleLoadIncrement :: MonadIO m => PixbufModule -> m (Maybe GdkPixbuf.Callbacks.PixbufModuleLoadIncrementFieldCallback)
getPixbufModuleLoadIncrement :: forall (m :: * -> *).
MonadIO m =>
PixbufModule -> m (Maybe PixbufModuleLoadIncrementFieldCallback)
getPixbufModuleLoadIncrement PixbufModule
s = IO (Maybe PixbufModuleLoadIncrementFieldCallback)
-> m (Maybe PixbufModuleLoadIncrementFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PixbufModuleLoadIncrementFieldCallback)
 -> m (Maybe PixbufModuleLoadIncrementFieldCallback))
-> IO (Maybe PixbufModuleLoadIncrementFieldCallback)
-> m (Maybe PixbufModuleLoadIncrementFieldCallback)
forall a b. (a -> b) -> a -> b
$ PixbufModule
-> (Ptr PixbufModule
    -> IO (Maybe PixbufModuleLoadIncrementFieldCallback))
-> IO (Maybe PixbufModuleLoadIncrementFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule
  -> IO (Maybe PixbufModuleLoadIncrementFieldCallback))
 -> IO (Maybe PixbufModuleLoadIncrementFieldCallback))
-> (Ptr PixbufModule
    -> IO (Maybe PixbufModuleLoadIncrementFieldCallback))
-> IO (Maybe PixbufModuleLoadIncrementFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    FunPtr C_PixbufModuleLoadIncrementFieldCallback
val <- Ptr (FunPtr C_PixbufModuleLoadIncrementFieldCallback)
-> IO (FunPtr C_PixbufModuleLoadIncrementFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int -> Ptr (FunPtr C_PixbufModuleLoadIncrementFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleLoadIncrementFieldCallback)
    Maybe PixbufModuleLoadIncrementFieldCallback
result <- FunPtr C_PixbufModuleLoadIncrementFieldCallback
-> (FunPtr C_PixbufModuleLoadIncrementFieldCallback
    -> IO PixbufModuleLoadIncrementFieldCallback)
-> IO (Maybe PixbufModuleLoadIncrementFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_PixbufModuleLoadIncrementFieldCallback
val ((FunPtr C_PixbufModuleLoadIncrementFieldCallback
  -> IO PixbufModuleLoadIncrementFieldCallback)
 -> IO (Maybe PixbufModuleLoadIncrementFieldCallback))
-> (FunPtr C_PixbufModuleLoadIncrementFieldCallback
    -> IO PixbufModuleLoadIncrementFieldCallback)
-> IO (Maybe PixbufModuleLoadIncrementFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_PixbufModuleLoadIncrementFieldCallback
val' -> do
        let val'' :: PixbufModuleLoadIncrementFieldCallback
val'' = FunPtr C_PixbufModuleLoadIncrementFieldCallback
-> PixbufModuleLoadIncrementFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_PixbufModuleLoadIncrementFieldCallback
-> Ptr () -> Word8 -> Word32 -> m ()
GdkPixbuf.Callbacks.dynamic_PixbufModuleLoadIncrementFieldCallback FunPtr C_PixbufModuleLoadIncrementFieldCallback
val'
        PixbufModuleLoadIncrementFieldCallback
-> IO PixbufModuleLoadIncrementFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufModuleLoadIncrementFieldCallback
val''
    Maybe PixbufModuleLoadIncrementFieldCallback
-> IO (Maybe PixbufModuleLoadIncrementFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufModuleLoadIncrementFieldCallback
result

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

-- | Set the value of the “@load_increment@” 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' #loadIncrement
-- @
clearPixbufModuleLoadIncrement :: MonadIO m => PixbufModule -> m ()
clearPixbufModuleLoadIncrement :: forall (m :: * -> *). MonadIO m => PixbufModule -> m ()
clearPixbufModuleLoadIncrement PixbufModule
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PixbufModule -> (Ptr PixbufModule -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO ()) -> IO ())
-> (Ptr PixbufModule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    Ptr (FunPtr C_PixbufModuleLoadIncrementFieldCallback)
-> FunPtr C_PixbufModuleLoadIncrementFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int -> Ptr (FunPtr C_PixbufModuleLoadIncrementFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (FunPtr C_PixbufModuleLoadIncrementFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GdkPixbuf.Callbacks.C_PixbufModuleLoadIncrementFieldCallback)

#if defined(ENABLE_OVERLOADING)
data PixbufModuleLoadIncrementFieldInfo
instance AttrInfo PixbufModuleLoadIncrementFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleLoadIncrementFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleLoadIncrementFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleLoadIncrementFieldInfo = (~) (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleLoadIncrementFieldCallback)
    type AttrTransferTypeConstraint PixbufModuleLoadIncrementFieldInfo = (~)(FunPtr GdkPixbuf.Callbacks.C_PixbufModuleLoadIncrementFieldCallback)
    type AttrTransferType PixbufModuleLoadIncrementFieldInfo = (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleLoadIncrementFieldCallback)
    type AttrGetType PixbufModuleLoadIncrementFieldInfo = Maybe GdkPixbuf.Callbacks.PixbufModuleLoadIncrementFieldCallback
    type AttrLabel PixbufModuleLoadIncrementFieldInfo = "load_increment"
    type AttrOrigin PixbufModuleLoadIncrementFieldInfo = PixbufModule
    attrGet = getPixbufModuleLoadIncrement
    attrSet = setPixbufModuleLoadIncrement
    attrConstruct = undefined
    attrClear = clearPixbufModuleLoadIncrement
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.loadIncrement"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:loadIncrement"
        })

pixbufModule_loadIncrement :: AttrLabelProxy "loadIncrement"
pixbufModule_loadIncrement = AttrLabelProxy

#endif


-- | Get the value of the “@save@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pixbufModule #save
-- @
getPixbufModuleSave :: MonadIO m => PixbufModule -> m (Maybe GdkPixbuf.Callbacks.PixbufModuleSaveFieldCallback)
getPixbufModuleSave :: forall (m :: * -> *).
MonadIO m =>
PixbufModule -> m (Maybe PixbufModuleSaveFieldCallback)
getPixbufModuleSave PixbufModule
s = IO (Maybe PixbufModuleSaveFieldCallback)
-> m (Maybe PixbufModuleSaveFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PixbufModuleSaveFieldCallback)
 -> m (Maybe PixbufModuleSaveFieldCallback))
-> IO (Maybe PixbufModuleSaveFieldCallback)
-> m (Maybe PixbufModuleSaveFieldCallback)
forall a b. (a -> b) -> a -> b
$ PixbufModule
-> (Ptr PixbufModule -> IO (Maybe PixbufModuleSaveFieldCallback))
-> IO (Maybe PixbufModuleSaveFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO (Maybe PixbufModuleSaveFieldCallback))
 -> IO (Maybe PixbufModuleSaveFieldCallback))
-> (Ptr PixbufModule -> IO (Maybe PixbufModuleSaveFieldCallback))
-> IO (Maybe PixbufModuleSaveFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    FunPtr C_PixbufModuleSaveFieldCallback
val <- Ptr (FunPtr C_PixbufModuleSaveFieldCallback)
-> IO (FunPtr C_PixbufModuleSaveFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int -> Ptr (FunPtr C_PixbufModuleSaveFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) :: IO (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleSaveFieldCallback)
    Maybe PixbufModuleSaveFieldCallback
result <- FunPtr C_PixbufModuleSaveFieldCallback
-> (FunPtr C_PixbufModuleSaveFieldCallback
    -> IO PixbufModuleSaveFieldCallback)
-> IO (Maybe PixbufModuleSaveFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_PixbufModuleSaveFieldCallback
val ((FunPtr C_PixbufModuleSaveFieldCallback
  -> IO PixbufModuleSaveFieldCallback)
 -> IO (Maybe PixbufModuleSaveFieldCallback))
-> (FunPtr C_PixbufModuleSaveFieldCallback
    -> IO PixbufModuleSaveFieldCallback)
-> IO (Maybe PixbufModuleSaveFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_PixbufModuleSaveFieldCallback
val' -> do
        let val'' :: PixbufModuleSaveFieldCallback
val'' = FunPtr C_PixbufModuleSaveFieldCallback
-> PixbufModuleSaveFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPixbuf a) =>
FunPtr C_PixbufModuleSaveFieldCallback
-> Ptr () -> a -> Text -> Text -> m ()
GdkPixbuf.Callbacks.dynamic_PixbufModuleSaveFieldCallback FunPtr C_PixbufModuleSaveFieldCallback
val'
        PixbufModuleSaveFieldCallback -> IO PixbufModuleSaveFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufModuleSaveFieldCallback
val''
    Maybe PixbufModuleSaveFieldCallback
-> IO (Maybe PixbufModuleSaveFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufModuleSaveFieldCallback
result

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

-- | Set the value of the “@save@” 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' #save
-- @
clearPixbufModuleSave :: MonadIO m => PixbufModule -> m ()
clearPixbufModuleSave :: forall (m :: * -> *). MonadIO m => PixbufModule -> m ()
clearPixbufModuleSave PixbufModule
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PixbufModule -> (Ptr PixbufModule -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO ()) -> IO ())
-> (Ptr PixbufModule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    Ptr (FunPtr C_PixbufModuleSaveFieldCallback)
-> FunPtr C_PixbufModuleSaveFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int -> Ptr (FunPtr C_PixbufModuleSaveFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (FunPtr C_PixbufModuleSaveFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GdkPixbuf.Callbacks.C_PixbufModuleSaveFieldCallback)

#if defined(ENABLE_OVERLOADING)
data PixbufModuleSaveFieldInfo
instance AttrInfo PixbufModuleSaveFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleSaveFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleSaveFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleSaveFieldInfo = (~) (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleSaveFieldCallback)
    type AttrTransferTypeConstraint PixbufModuleSaveFieldInfo = (~)(FunPtr GdkPixbuf.Callbacks.C_PixbufModuleSaveFieldCallback)
    type AttrTransferType PixbufModuleSaveFieldInfo = (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleSaveFieldCallback)
    type AttrGetType PixbufModuleSaveFieldInfo = Maybe GdkPixbuf.Callbacks.PixbufModuleSaveFieldCallback
    type AttrLabel PixbufModuleSaveFieldInfo = "save"
    type AttrOrigin PixbufModuleSaveFieldInfo = PixbufModule
    attrGet = getPixbufModuleSave
    attrSet = setPixbufModuleSave
    attrConstruct = undefined
    attrClear = clearPixbufModuleSave
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.save"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:save"
        })

pixbufModule_save :: AttrLabelProxy "save"
pixbufModule_save = AttrLabelProxy

#endif


-- | Get the value of the “@is_save_option_supported@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pixbufModule #isSaveOptionSupported
-- @
getPixbufModuleIsSaveOptionSupported :: MonadIO m => PixbufModule -> m (Maybe GdkPixbuf.Callbacks.PixbufModuleIsSaveOptionSupportedFieldCallback)
getPixbufModuleIsSaveOptionSupported :: forall (m :: * -> *).
MonadIO m =>
PixbufModule
-> m (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
getPixbufModuleIsSaveOptionSupported PixbufModule
s = IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
-> m (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
 -> m (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback))
-> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
-> m (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a b. (a -> b) -> a -> b
$ PixbufModule
-> (Ptr PixbufModule
    -> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback))
-> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule
  -> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback))
 -> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback))
-> (Ptr PixbufModule
    -> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback))
-> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
val <- Ptr (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback)
-> IO (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int
-> Ptr (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96) :: IO (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleIsSaveOptionSupportedFieldCallback)
    Maybe PixbufModuleIsSaveOptionSupportedFieldCallback
result <- FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
-> (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
    -> IO PixbufModuleIsSaveOptionSupportedFieldCallback)
-> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
val ((FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
  -> IO PixbufModuleIsSaveOptionSupportedFieldCallback)
 -> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback))
-> (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
    -> IO PixbufModuleIsSaveOptionSupportedFieldCallback)
-> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
val' -> do
        let val'' :: PixbufModuleIsSaveOptionSupportedFieldCallback
val'' = FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
-> PixbufModuleIsSaveOptionSupportedFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
-> Text -> m Bool
GdkPixbuf.Callbacks.dynamic_PixbufModuleIsSaveOptionSupportedFieldCallback FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
val'
        PixbufModuleIsSaveOptionSupportedFieldCallback
-> IO PixbufModuleIsSaveOptionSupportedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufModuleIsSaveOptionSupportedFieldCallback
val''
    Maybe PixbufModuleIsSaveOptionSupportedFieldCallback
-> IO (Maybe PixbufModuleIsSaveOptionSupportedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufModuleIsSaveOptionSupportedFieldCallback
result

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

-- | Set the value of the “@is_save_option_supported@” 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' #isSaveOptionSupported
-- @
clearPixbufModuleIsSaveOptionSupported :: MonadIO m => PixbufModule -> m ()
clearPixbufModuleIsSaveOptionSupported :: forall (m :: * -> *). MonadIO m => PixbufModule -> m ()
clearPixbufModuleIsSaveOptionSupported PixbufModule
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PixbufModule -> (Ptr PixbufModule -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PixbufModule
s ((Ptr PixbufModule -> IO ()) -> IO ())
-> (Ptr PixbufModule -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr PixbufModule
ptr -> do
    Ptr (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback)
-> FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PixbufModule
ptr Ptr PixbufModule
-> Int
-> Ptr (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96) (FunPtr C_PixbufModuleIsSaveOptionSupportedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GdkPixbuf.Callbacks.C_PixbufModuleIsSaveOptionSupportedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data PixbufModuleIsSaveOptionSupportedFieldInfo
instance AttrInfo PixbufModuleIsSaveOptionSupportedFieldInfo where
    type AttrBaseTypeConstraint PixbufModuleIsSaveOptionSupportedFieldInfo = (~) PixbufModule
    type AttrAllowedOps PixbufModuleIsSaveOptionSupportedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PixbufModuleIsSaveOptionSupportedFieldInfo = (~) (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleIsSaveOptionSupportedFieldCallback)
    type AttrTransferTypeConstraint PixbufModuleIsSaveOptionSupportedFieldInfo = (~)GdkPixbuf.Callbacks.PixbufModuleIsSaveOptionSupportedFieldCallback
    type AttrTransferType PixbufModuleIsSaveOptionSupportedFieldInfo = (FunPtr GdkPixbuf.Callbacks.C_PixbufModuleIsSaveOptionSupportedFieldCallback)
    type AttrGetType PixbufModuleIsSaveOptionSupportedFieldInfo = Maybe GdkPixbuf.Callbacks.PixbufModuleIsSaveOptionSupportedFieldCallback
    type AttrLabel PixbufModuleIsSaveOptionSupportedFieldInfo = "is_save_option_supported"
    type AttrOrigin PixbufModuleIsSaveOptionSupportedFieldInfo = PixbufModule
    attrGet = getPixbufModuleIsSaveOptionSupported
    attrSet = setPixbufModuleIsSaveOptionSupported
    attrConstruct = undefined
    attrClear = clearPixbufModuleIsSaveOptionSupported
    attrTransfer _ v = do
        GdkPixbuf.Callbacks.mk_PixbufModuleIsSaveOptionSupportedFieldCallback (GdkPixbuf.Callbacks.wrap_PixbufModuleIsSaveOptionSupportedFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GdkPixbuf.Structs.PixbufModule.isSaveOptionSupported"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.28/docs/GI-GdkPixbuf-Structs-PixbufModule.html#g:attr:isSaveOptionSupported"
        })

pixbufModule_isSaveOptionSupported :: AttrLabelProxy "isSaveOptionSupported"
pixbufModule_isSaveOptionSupported = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PixbufModule
type instance O.AttributeList PixbufModule = PixbufModuleAttributeList
type PixbufModuleAttributeList = ('[ '("moduleName", PixbufModuleModuleNameFieldInfo), '("modulePath", PixbufModuleModulePathFieldInfo), '("module", PixbufModuleModuleFieldInfo), '("info", PixbufModuleInfoFieldInfo), '("stopLoad", PixbufModuleStopLoadFieldInfo), '("loadIncrement", PixbufModuleLoadIncrementFieldInfo), '("save", PixbufModuleSaveFieldInfo), '("isSaveOptionSupported", PixbufModuleIsSaveOptionSupportedFieldInfo)] :: [(Symbol, *)])
#endif

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

instance (info ~ ResolvePixbufModuleMethod t PixbufModule, O.OverloadedMethod info PixbufModule p) => OL.IsLabel t (PixbufModule -> 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 ~ ResolvePixbufModuleMethod t PixbufModule, O.OverloadedMethod info PixbufModule p, R.HasField t PixbufModule p) => R.HasField t PixbufModule p where
    getField = O.overloadedMethod @info

#endif

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

#endif