    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Pango.Callbacks
        (

     -- * Signals

    -- ** AttrClassCopyFieldCallback #signal:AttrClassCopyFieldCallback#

        AttrClassCopyFieldCallback              ,
        C_AttrClassCopyFieldCallback            ,
        dynamic_AttrClassCopyFieldCallback      ,
        genClosure_AttrClassCopyFieldCallback   ,
        mk_AttrClassCopyFieldCallback           ,
        noAttrClassCopyFieldCallback            ,
        wrap_AttrClassCopyFieldCallback         ,

    -- ** AttrClassDestroyFieldCallback #signal:AttrClassDestroyFieldCallback#

        AttrClassDestroyFieldCallback           ,
        C_AttrClassDestroyFieldCallback         ,
        dynamic_AttrClassDestroyFieldCallback   ,
        genClosure_AttrClassDestroyFieldCallback,
        mk_AttrClassDestroyFieldCallback        ,
        noAttrClassDestroyFieldCallback         ,
        wrap_AttrClassDestroyFieldCallback      ,

    -- ** AttrClassEqualFieldCallback #signal:AttrClassEqualFieldCallback#

        AttrClassEqualFieldCallback             ,
        C_AttrClassEqualFieldCallback           ,
        dynamic_AttrClassEqualFieldCallback     ,
        genClosure_AttrClassEqualFieldCallback  ,
        mk_AttrClassEqualFieldCallback          ,
        noAttrClassEqualFieldCallback           ,
        wrap_AttrClassEqualFieldCallback        ,

    -- ** AttrDataCopyFunc #signal:AttrDataCopyFunc#

        AttrDataCopyFunc                        ,
        AttrDataCopyFunc_WithClosures           ,
        C_AttrDataCopyFunc                      ,
        drop_closures_AttrDataCopyFunc          ,
        dynamic_AttrDataCopyFunc                ,
        genClosure_AttrDataCopyFunc             ,
        mk_AttrDataCopyFunc                     ,
        noAttrDataCopyFunc                      ,
        noAttrDataCopyFunc_WithClosures         ,
        wrap_AttrDataCopyFunc                   ,

    -- ** AttrFilterFunc #signal:AttrFilterFunc#

        AttrFilterFunc                          ,
        AttrFilterFunc_WithClosures             ,
        C_AttrFilterFunc                        ,
        drop_closures_AttrFilterFunc            ,
        dynamic_AttrFilterFunc                  ,
        genClosure_AttrFilterFunc               ,
        mk_AttrFilterFunc                       ,
        noAttrFilterFunc                        ,
        noAttrFilterFunc_WithClosures           ,
        wrap_AttrFilterFunc                     ,

    -- ** FontsetForeachFunc #signal:FontsetForeachFunc#

        C_FontsetForeachFunc                    ,
        FontsetForeachFunc                      ,
        FontsetForeachFunc_WithClosures         ,
        drop_closures_FontsetForeachFunc        ,
        dynamic_FontsetForeachFunc              ,
        genClosure_FontsetForeachFunc           ,
        mk_FontsetForeachFunc                   ,
        noFontsetForeachFunc                    ,
        noFontsetForeachFunc_WithClosures       ,
        wrap_FontsetForeachFunc                 ,

        ) where

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

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

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.HarfBuzz.Structs.FeatureT as HarfBuzz.FeatureT
    import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums
    import {-# SOURCE #-} qualified GI.Pango.Flags as Pango.Flags
    import {-# SOURCE #-} qualified GI.Pango.Objects.Context as Pango.Context
    import {-# SOURCE #-} qualified GI.Pango.Objects.Coverage as Pango.Coverage
    import {-# SOURCE #-} qualified GI.Pango.Objects.Font as Pango.Font
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontFace as Pango.FontFace
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontFamily as Pango.FontFamily
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import {-# SOURCE #-} qualified GI.Pango.Objects.Fontset as Pango.Fontset
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrClass as Pango.AttrClass
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrColor as Pango.AttrColor
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFloat as Pango.AttrFloat
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFontDesc as Pango.AttrFontDesc
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFontFeatures as Pango.AttrFontFeatures
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrInt as Pango.AttrInt
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrLanguage as Pango.AttrLanguage
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrShape as Pango.AttrShape
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrSize as Pango.AttrSize
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrString as Pango.AttrString
    import {-# SOURCE #-} qualified GI.Pango.Structs.Attribute as Pango.Attribute
    import {-# SOURCE #-} qualified GI.Pango.Structs.Color as Pango.Color
    import {-# SOURCE #-} qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
    import {-# SOURCE #-} qualified GI.Pango.Structs.FontMetrics as Pango.FontMetrics
    import {-# SOURCE #-} qualified GI.Pango.Structs.Language as Pango.Language
    import {-# SOURCE #-} qualified GI.Pango.Structs.Matrix as Pango.Matrix
    import {-# SOURCE #-} qualified GI.Pango.Structs.Rectangle as Pango.Rectangle

    #else
    import {-# SOURCE #-} qualified GI.Pango.Objects.Font as Pango.Font
    import {-# SOURCE #-} qualified GI.Pango.Objects.Fontset as Pango.Fontset
    import {-# SOURCE #-} qualified GI.Pango.Structs.Attribute as Pango.Attribute

    #endif

    -- callback FontsetForeachFunc
    {- Callable
      { returnType = Just (TBasicType TBoolean)
      , returnMayBeNull = False
      , returnTransfer = TransferNothing
      , returnDocumentation =
          Documentation
            { rawDocText =
                Just "if %TRUE, stop iteration and return immediately."
            , sinceVersion = Nothing
            }
      , args =
          [ Arg
              { argCName = "fontset"
              , argType =
                  TInterface Name { namespace = "Pango" , name = "Fontset" }
              , argCType = Just "PangoFontset*"
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation
                    { rawDocText = Just "a `PangoFontset`" , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "font"
              , argType = TInterface Name { namespace = "Pango" , name = "Font" }
              , argCType = Just "PangoFont*"
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation
                    { rawDocText = Just "a font from @fontset"
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "user_data"
              , argType = TBasicType TPtr
              , argCType = Just "gpointer"
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText = Just "callback data" , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = True
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation
            { rawDocText =
                Just
                  "Callback used when enumerating fonts in a fontset.\n\nSee [method@Pango.Fontset.foreach]."
            , sinceVersion = Just "1.4"
            }
      , callableResolvable = Nothing
      }
    -}
    -- | Type for the callback on the (unwrapped) C side.
    type C_FontsetForeachFunc =
        Ptr Pango.Fontset.Fontset ->
        Ptr Pango.Font.Font ->
        Ptr () ->
        IO CInt

    -- Args: [ Arg
    --           { argCName = "fontset"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Fontset" }
    --           , argCType = Just "PangoFontset*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoFontset`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "font"
    --           , argType = TInterface Name { namespace = "Pango" , name = "Font" }
    --           , argCType = Just "PangoFont*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a font from @fontset"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "callback data" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = True
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "dynamic" __dynamic_C_FontsetForeachFunc :: FunPtr C_FontsetForeachFunc -> C_FontsetForeachFunc

    -- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
    dynamic_FontsetForeachFunc ::
        (B.CallStack.HasCallStack, MonadIO m, Pango.Fontset.IsFontset a, Pango.Font.IsFont b) =>
        FunPtr C_FontsetForeachFunc
        -> a
        -- ^ /@fontset@/: a @PangoFontset@
        -> b
        -- ^ /@font@/: a font from /@fontset@/
        -> Ptr ()
        -- ^ /@userData@/: callback data
        -> m Bool
        -- ^ __Returns:__ if 'P.True', stop iteration and return immediately.
    dynamic_FontsetForeachFunc :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsFontset a, IsFont b) =>
    FunPtr C_FontsetForeachFunc -> a -> b -> Ptr () -> m Bool
    dynamic_FontsetForeachFunc FunPtr C_FontsetForeachFunc
    __funPtr a
    fontset b
    font Ptr ()
    userData = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        fontset' <- a -> IO (Ptr Fontset)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    fontset
        font' <- unsafeManagedPtrCastPtr font
        result <- (__dynamic_C_FontsetForeachFunc __funPtr) fontset' font' userData
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr fontset
        touchManagedPtr font
        return result'

    -- | Generate a function pointer callable from C code, from a `C_FontsetForeachFunc`.
    foreign import ccall "wrapper"
        mk_FontsetForeachFunc :: C_FontsetForeachFunc -> IO (FunPtr C_FontsetForeachFunc)

    -- | Callback used when enumerating fonts in a fontset.
    --
    -- See 'GI.Pango.Objects.Fontset.fontsetForeach'.
    --
    -- /Since: 1.4/
    type FontsetForeachFunc =
        Pango.Fontset.Fontset
        -- ^ /@fontset@/: a @PangoFontset@
        -> Pango.Font.Font
        -- ^ /@font@/: a font from /@fontset@/
        -> IO Bool
        -- ^ __Returns:__ if 'P.True', stop iteration and return immediately.

    -- | A convenience synonym for @`Nothing` :: `Maybe` `FontsetForeachFunc`@.
    noFontsetForeachFunc :: Maybe FontsetForeachFunc
    noFontsetForeachFunc :: Maybe FontsetForeachFunc
    noFontsetForeachFunc = Maybe FontsetForeachFunc
    forall a. Maybe a
    Nothing

    -- | Callback used when enumerating fonts in a fontset.
    --
    -- See 'GI.Pango.Objects.Fontset.fontsetForeach'.
    --
    -- /Since: 1.4/
    type FontsetForeachFunc_WithClosures =
        Pango.Fontset.Fontset
        -- ^ /@fontset@/: a @PangoFontset@
        -> Pango.Font.Font
        -- ^ /@font@/: a font from /@fontset@/
        -> Ptr ()
        -- ^ /@userData@/: callback data
        -> IO Bool
        -- ^ __Returns:__ if 'P.True', stop iteration and return immediately.

    -- | A convenience synonym for @`Nothing` :: `Maybe` `FontsetForeachFunc_WithClosures`@.
    noFontsetForeachFunc_WithClosures :: Maybe FontsetForeachFunc_WithClosures
    noFontsetForeachFunc_WithClosures :: Maybe FontsetForeachFunc_WithClosures
    noFontsetForeachFunc_WithClosures = Maybe FontsetForeachFunc_WithClosures
    forall a. Maybe a
    Nothing

    -- | A simple wrapper that ignores the closure arguments.
    drop_closures_FontsetForeachFunc :: FontsetForeachFunc -> FontsetForeachFunc_WithClosures
    drop_closures_FontsetForeachFunc :: FontsetForeachFunc -> FontsetForeachFunc_WithClosures
    drop_closures_FontsetForeachFunc FontsetForeachFunc
    _f Fontset
    fontset Font
    font Ptr ()
    _ = FontsetForeachFunc
    _f Fontset
    fontset Font
    font

    -- | Wrap the callback into a `GClosure`.
    genClosure_FontsetForeachFunc :: MonadIO m => FontsetForeachFunc -> m (GClosure C_FontsetForeachFunc)
    genClosure_FontsetForeachFunc :: forall (m :: * -> *).
    MonadIO m =>
    FontsetForeachFunc -> m (GClosure C_FontsetForeachFunc)
    genClosure_FontsetForeachFunc FontsetForeachFunc
    cb = IO (GClosure C_FontsetForeachFunc)
    -> m (GClosure C_FontsetForeachFunc)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_FontsetForeachFunc)
     -> m (GClosure C_FontsetForeachFunc))
    -> IO (GClosure C_FontsetForeachFunc)
    -> m (GClosure C_FontsetForeachFunc)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: FontsetForeachFunc_WithClosures
    cb' = FontsetForeachFunc -> FontsetForeachFunc_WithClosures
    drop_closures_FontsetForeachFunc FontsetForeachFunc
    cb
        let cb'' :: C_FontsetForeachFunc
    cb'' = Maybe (Ptr (FunPtr C_FontsetForeachFunc))
    -> FontsetForeachFunc_WithClosures -> C_FontsetForeachFunc
    wrap_FontsetForeachFunc Maybe (Ptr (FunPtr C_FontsetForeachFunc))
    forall a. Maybe a
    Nothing FontsetForeachFunc_WithClosures
    cb'
        C_FontsetForeachFunc -> IO (FunPtr C_FontsetForeachFunc)
    mk_FontsetForeachFunc C_FontsetForeachFunc
    cb'' IO (FunPtr C_FontsetForeachFunc)
    -> (FunPtr C_FontsetForeachFunc
        -> IO (GClosure C_FontsetForeachFunc))
    -> IO (GClosure C_FontsetForeachFunc)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_FontsetForeachFunc -> IO (GClosure C_FontsetForeachFunc)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `FontsetForeachFunc` into a `C_FontsetForeachFunc`.
    wrap_FontsetForeachFunc ::
        Maybe (Ptr (FunPtr C_FontsetForeachFunc)) ->
        FontsetForeachFunc_WithClosures ->
        C_FontsetForeachFunc
    wrap_FontsetForeachFunc :: Maybe (Ptr (FunPtr C_FontsetForeachFunc))
    -> FontsetForeachFunc_WithClosures -> C_FontsetForeachFunc
    wrap_FontsetForeachFunc Maybe (Ptr (FunPtr C_FontsetForeachFunc))
    gi'funptrptr FontsetForeachFunc_WithClosures
    gi'cb Ptr Fontset
    fontset Ptr Font
    font Ptr ()
    userData = do
        fontset' <- ((ManagedPtr Fontset -> Fontset) -> Ptr Fontset -> IO Fontset
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Fontset -> Fontset
    Pango.Fontset.Fontset) Ptr Fontset
    fontset
        font' <- (newObject Pango.Font.Font) font
        result <- gi'cb  fontset' font' userData
        maybeReleaseFunPtr gi'funptrptr
        let result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    result
        return result'

    -- callback AttrFilterFunc
    {- Callable
      { returnType = Just (TBasicType TBoolean)
      , returnMayBeNull = False
      , returnTransfer = TransferNothing
      , returnDocumentation =
          Documentation
            { rawDocText =
                Just
                  "%TRUE if the attribute should be selected for\n  filtering, %FALSE otherwise."
            , sinceVersion = Nothing
            }
      , args =
          [ Arg
              { argCName = "attribute"
              , argType =
                  TInterface Name { namespace = "Pango" , name = "Attribute" }
              , argCType = Just "PangoAttribute*"
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation
                    { rawDocText = Just "a Pango attribute" , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "user_data"
              , argType = TBasicType TPtr
              , argCType = Just "gpointer"
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText = Just "user data passed to the function"
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = True
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation
            { rawDocText =
                Just "Type of a function filtering a list of attributes."
            , sinceVersion = Nothing
            }
      , callableResolvable = Nothing
      }
    -}
    -- | Type for the callback on the (unwrapped) C side.
    type C_AttrFilterFunc =
        Ptr Pango.Attribute.Attribute ->
        Ptr () ->
        IO CInt

    -- Args: [ Arg
    --           { argCName = "attribute"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , argCType = Just "PangoAttribute*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a Pango attribute" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gpointer"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "user data passed to the function"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = True
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "dynamic" __dynamic_C_AttrFilterFunc :: FunPtr C_AttrFilterFunc -> C_AttrFilterFunc

    -- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
    dynamic_AttrFilterFunc ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FunPtr C_AttrFilterFunc
        -> Pango.Attribute.Attribute
        -- ^ /@attribute@/: a Pango attribute
        -> Ptr ()
        -- ^ /@userData@/: user data passed to the function
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the attribute should be selected for
        --   filtering, 'P.False' otherwise.
    dynamic_AttrFilterFunc :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr C_AttrFilterFunc -> Attribute -> Ptr () -> m Bool
    dynamic_AttrFilterFunc FunPtr C_AttrFilterFunc
    __funPtr Attribute
    attribute Ptr ()
    userData = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        attribute' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attribute
        result <- (__dynamic_C_AttrFilterFunc __funPtr) attribute' userData
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr attribute
        return result'

    -- | Generate a function pointer callable from C code, from a `C_AttrFilterFunc`.
    foreign import ccall "wrapper"
        mk_AttrFilterFunc :: C_AttrFilterFunc -> IO (FunPtr C_AttrFilterFunc)

    -- | Type of a function filtering a list of attributes.
    type AttrFilterFunc =
        Pango.Attribute.Attribute
        -- ^ /@attribute@/: a Pango attribute
        -> IO Bool
        -- ^ __Returns:__ 'P.True' if the attribute should be selected for
        --   filtering, 'P.False' otherwise.

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AttrFilterFunc`@.
    noAttrFilterFunc :: Maybe AttrFilterFunc
    noAttrFilterFunc :: Maybe AttrFilterFunc
    noAttrFilterFunc = Maybe AttrFilterFunc
    forall a. Maybe a
    Nothing

    -- | Type of a function filtering a list of attributes.
    type AttrFilterFunc_WithClosures =
        Pango.Attribute.Attribute
        -- ^ /@attribute@/: a Pango attribute
        -> Ptr ()
        -- ^ /@userData@/: user data passed to the function
        -> IO Bool
        -- ^ __Returns:__ 'P.True' if the attribute should be selected for
        --   filtering, 'P.False' otherwise.

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AttrFilterFunc_WithClosures`@.
    noAttrFilterFunc_WithClosures :: Maybe AttrFilterFunc_WithClosures
    noAttrFilterFunc_WithClosures :: Maybe AttrFilterFunc_WithClosures
    noAttrFilterFunc_WithClosures = Maybe AttrFilterFunc_WithClosures
    forall a. Maybe a
    Nothing

    -- | A simple wrapper that ignores the closure arguments.
    drop_closures_AttrFilterFunc :: AttrFilterFunc -> AttrFilterFunc_WithClosures
    drop_closures_AttrFilterFunc :: AttrFilterFunc -> AttrFilterFunc_WithClosures
    drop_closures_AttrFilterFunc AttrFilterFunc
    _f Attribute
    attribute Ptr ()
    _ = AttrFilterFunc
    _f Attribute
    attribute

    -- | Wrap the callback into a `GClosure`.
    genClosure_AttrFilterFunc :: MonadIO m => AttrFilterFunc -> m (GClosure C_AttrFilterFunc)
    genClosure_AttrFilterFunc :: forall (m :: * -> *).
    MonadIO m =>
    AttrFilterFunc -> m (GClosure C_AttrFilterFunc)
    genClosure_AttrFilterFunc AttrFilterFunc
    cb = IO (GClosure C_AttrFilterFunc) -> m (GClosure C_AttrFilterFunc)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_AttrFilterFunc) -> m (GClosure C_AttrFilterFunc))
    -> IO (GClosure C_AttrFilterFunc) -> m (GClosure C_AttrFilterFunc)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: AttrFilterFunc_WithClosures
    cb' = AttrFilterFunc -> AttrFilterFunc_WithClosures
    drop_closures_AttrFilterFunc AttrFilterFunc
    cb
        let cb'' :: C_AttrFilterFunc
    cb'' = Maybe (Ptr (FunPtr C_AttrFilterFunc))
    -> AttrFilterFunc_WithClosures -> C_AttrFilterFunc
    wrap_AttrFilterFunc Maybe (Ptr (FunPtr C_AttrFilterFunc))
    forall a. Maybe a
    Nothing AttrFilterFunc_WithClosures
    cb'
        C_AttrFilterFunc -> IO (FunPtr C_AttrFilterFunc)
    mk_AttrFilterFunc C_AttrFilterFunc
    cb'' IO (FunPtr C_AttrFilterFunc)
    -> (FunPtr C_AttrFilterFunc -> IO (GClosure C_AttrFilterFunc))
    -> IO (GClosure C_AttrFilterFunc)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_AttrFilterFunc -> IO (GClosure C_AttrFilterFunc)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `AttrFilterFunc` into a `C_AttrFilterFunc`.
    wrap_AttrFilterFunc ::
        Maybe (Ptr (FunPtr C_AttrFilterFunc)) ->
        AttrFilterFunc_WithClosures ->
        C_AttrFilterFunc
    wrap_AttrFilterFunc :: Maybe (Ptr (FunPtr C_AttrFilterFunc))
    -> AttrFilterFunc_WithClosures -> C_AttrFilterFunc
    wrap_AttrFilterFunc Maybe (Ptr (FunPtr C_AttrFilterFunc))
    gi'funptrptr AttrFilterFunc_WithClosures
    gi'cb Ptr Attribute
    attribute Ptr ()
    userData = do
        Ptr Attribute -> (Attribute -> IO CInt) -> IO CInt
    forall a b.
    (HasCallStack, ManagedPtrNewtype a) =>
    Ptr a -> (a -> IO b) -> IO b
    B.ManagedPtr.withTransient  Ptr Attribute
    attribute ((Attribute -> IO CInt) -> IO CInt)
    -> (Attribute -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Attribute
    attribute' -> do
            result <- AttrFilterFunc_WithClosures
    gi'cb  Attribute
    attribute' Ptr ()
    userData
            maybeReleaseFunPtr gi'funptrptr
            let result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    result
            return result'

    -- callback AttrDataCopyFunc
    {- Callable
      { returnType = Just (TBasicType TPtr)
      , returnMayBeNull = True
      , returnTransfer = TransferNothing
      , returnDocumentation =
          Documentation
            { rawDocText = Just "new copy of @user_data."
            , sinceVersion = Nothing
            }
      , args =
          [ Arg
              { argCName = "user_data"
              , argType = TBasicType TPtr
              , argCType = Just "gconstpointer"
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText = Just "user data to copy" , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = True
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation
            { rawDocText =
                Just
                  "Type of a function that can duplicate user data for an attribute."
            , sinceVersion = Nothing
            }
      , callableResolvable = Nothing
      }
    -}
    -- | Type for the callback on the (unwrapped) C side.
    type C_AttrDataCopyFunc =
        Ptr () ->
        IO (Ptr ())

    -- Args: [ Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , argCType = Just "gconstpointer"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "user data to copy" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = True
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "dynamic" __dynamic_C_AttrDataCopyFunc :: FunPtr C_AttrDataCopyFunc -> C_AttrDataCopyFunc

    -- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
    dynamic_AttrDataCopyFunc ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FunPtr C_AttrDataCopyFunc
        -> Ptr ()
        -- ^ /@userData@/: user data to copy
        -> m (Ptr ())
        -- ^ __Returns:__ new copy of /@userData@/.
    dynamic_AttrDataCopyFunc :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr C_AttrDataCopyFunc -> Ptr () -> m (Ptr ())
    dynamic_AttrDataCopyFunc FunPtr C_AttrDataCopyFunc
    __funPtr Ptr ()
    userData = IO (Ptr ()) -> m (Ptr ())
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
    forall a b. (a -> b) -> a -> b
    $ do
        result <- (FunPtr C_AttrDataCopyFunc -> C_AttrDataCopyFunc
    __dynamic_C_AttrDataCopyFunc FunPtr C_AttrDataCopyFunc
    __funPtr) Ptr ()
    userData
        return result

    -- | Generate a function pointer callable from C code, from a `C_AttrDataCopyFunc`.
    foreign import ccall "wrapper"
        mk_AttrDataCopyFunc :: C_AttrDataCopyFunc -> IO (FunPtr C_AttrDataCopyFunc)

    -- | Type of a function that can duplicate user data for an attribute.
    type AttrDataCopyFunc =
        IO (Ptr ())
        -- ^ __Returns:__ new copy of /@userData@/.

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AttrDataCopyFunc`@.
    noAttrDataCopyFunc :: Maybe AttrDataCopyFunc
    noAttrDataCopyFunc :: Maybe (IO (Ptr ()))
    noAttrDataCopyFunc = Maybe (IO (Ptr ()))
    forall a. Maybe a
    Nothing

    -- | Type of a function that can duplicate user data for an attribute.
    type AttrDataCopyFunc_WithClosures =
        Ptr ()
        -- ^ /@userData@/: user data to copy
        -> IO (Ptr ())
        -- ^ __Returns:__ new copy of /@userData@/.

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AttrDataCopyFunc_WithClosures`@.
    noAttrDataCopyFunc_WithClosures :: Maybe AttrDataCopyFunc_WithClosures
    noAttrDataCopyFunc_WithClosures :: Maybe C_AttrDataCopyFunc
    noAttrDataCopyFunc_WithClosures = Maybe C_AttrDataCopyFunc
    forall a. Maybe a
    Nothing

    -- | A simple wrapper that ignores the closure arguments.
    drop_closures_AttrDataCopyFunc :: AttrDataCopyFunc -> AttrDataCopyFunc_WithClosures
    drop_closures_AttrDataCopyFunc :: IO (Ptr ()) -> C_AttrDataCopyFunc
    drop_closures_AttrDataCopyFunc IO (Ptr ())
    _f Ptr ()
    _ = IO (Ptr ())
    _f

    -- | Wrap the callback into a `GClosure`.
    genClosure_AttrDataCopyFunc :: MonadIO m => AttrDataCopyFunc -> m (GClosure C_AttrDataCopyFunc)
    genClosure_AttrDataCopyFunc :: forall (m :: * -> *).
    MonadIO m =>
    IO (Ptr ()) -> m (GClosure C_AttrDataCopyFunc)
    genClosure_AttrDataCopyFunc IO (Ptr ())
    cb = IO (GClosure C_AttrDataCopyFunc) -> m (GClosure C_AttrDataCopyFunc)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_AttrDataCopyFunc)
     -> m (GClosure C_AttrDataCopyFunc))
    -> IO (GClosure C_AttrDataCopyFunc)
    -> m (GClosure C_AttrDataCopyFunc)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_AttrDataCopyFunc
    cb' = IO (Ptr ()) -> C_AttrDataCopyFunc
    drop_closures_AttrDataCopyFunc IO (Ptr ())
    cb
        let cb'' :: C_AttrDataCopyFunc
    cb'' = Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
    -> C_AttrDataCopyFunc -> C_AttrDataCopyFunc
    wrap_AttrDataCopyFunc Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
    forall a. Maybe a
    Nothing C_AttrDataCopyFunc
    cb'
        C_AttrDataCopyFunc -> IO (FunPtr C_AttrDataCopyFunc)
    mk_AttrDataCopyFunc C_AttrDataCopyFunc
    cb'' IO (FunPtr C_AttrDataCopyFunc)
    -> (FunPtr C_AttrDataCopyFunc -> IO (GClosure C_AttrDataCopyFunc))
    -> IO (GClosure C_AttrDataCopyFunc)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_AttrDataCopyFunc -> IO (GClosure C_AttrDataCopyFunc)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `AttrDataCopyFunc` into a `C_AttrDataCopyFunc`.
    wrap_AttrDataCopyFunc ::
        Maybe (Ptr (FunPtr C_AttrDataCopyFunc)) ->
        AttrDataCopyFunc_WithClosures ->
        C_AttrDataCopyFunc
    wrap_AttrDataCopyFunc :: Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
    -> C_AttrDataCopyFunc -> C_AttrDataCopyFunc
    wrap_AttrDataCopyFunc Maybe (Ptr (FunPtr C_AttrDataCopyFunc))
    gi'funptrptr C_AttrDataCopyFunc
    gi'cb Ptr ()
    userData = do
        result <- C_AttrDataCopyFunc
    gi'cb  Ptr ()
    userData
        maybeReleaseFunPtr gi'funptrptr
        return result

    -- callback AttrClassEqualFieldCallback
    {- Callable
      { returnType = Just (TBasicType TBoolean)
      , returnMayBeNull = False
      , returnTransfer = TransferNothing
      , returnDocumentation =
          Documentation { rawDocText = Nothing , sinceVersion = Nothing }
      , args =
          [ Arg
              { argCName = "attr1"
              , argType =
                  TInterface Name { namespace = "Pango" , name = "Attribute" }
              , argCType = Just "const PangoAttribute*"
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation { rawDocText = Nothing , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "attr2"
              , argType =
                  TInterface Name { namespace = "Pango" , name = "Attribute" }
              , argCType = Just "const PangoAttribute*"
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation { rawDocText = Nothing , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = False
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation { rawDocText = Nothing , sinceVersion = Nothing }
      , callableResolvable = Nothing
      }
    -}
    -- | Type for the callback on the (unwrapped) C side.
    type C_AttrClassEqualFieldCallback =
        Ptr Pango.Attribute.Attribute ->
        Ptr Pango.Attribute.Attribute ->
        IO CInt

    -- Args: [ Arg
    --           { argCName = "attr1"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , argCType = Just "const PangoAttribute*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attr2"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , argCType = Just "const PangoAttribute*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "dynamic" __dynamic_C_AttrClassEqualFieldCallback :: FunPtr C_AttrClassEqualFieldCallback -> C_AttrClassEqualFieldCallback

    -- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
    dynamic_AttrClassEqualFieldCallback ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FunPtr C_AttrClassEqualFieldCallback
        -> Pango.Attribute.Attribute
        -> Pango.Attribute.Attribute
        -> m Bool
    dynamic_AttrClassEqualFieldCallback :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr C_AttrClassEqualFieldCallback
    -> Attribute -> Attribute -> m Bool
    dynamic_AttrClassEqualFieldCallback FunPtr C_AttrClassEqualFieldCallback
    __funPtr Attribute
    attr1 Attribute
    attr2 = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        attr1' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr1
        attr2' <- unsafeManagedPtrGetPtr attr2
        result <- (__dynamic_C_AttrClassEqualFieldCallback __funPtr) attr1' attr2'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr attr1
        touchManagedPtr attr2
        return result'

    -- | Generate a function pointer callable from C code, from a `C_AttrClassEqualFieldCallback`.
    foreign import ccall "wrapper"
        mk_AttrClassEqualFieldCallback :: C_AttrClassEqualFieldCallback -> IO (FunPtr C_AttrClassEqualFieldCallback)

    -- | /No description available in the introspection data./
    type AttrClassEqualFieldCallback =
        Pango.Attribute.Attribute
        -> Pango.Attribute.Attribute
        -> IO Bool

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AttrClassEqualFieldCallback`@.
    noAttrClassEqualFieldCallback :: Maybe AttrClassEqualFieldCallback
    noAttrClassEqualFieldCallback :: Maybe AttrClassEqualFieldCallback
    noAttrClassEqualFieldCallback = Maybe AttrClassEqualFieldCallback
    forall a. Maybe a
    Nothing

    -- | Wrap the callback into a `GClosure`.
    genClosure_AttrClassEqualFieldCallback :: MonadIO m => AttrClassEqualFieldCallback -> m (GClosure C_AttrClassEqualFieldCallback)
    genClosure_AttrClassEqualFieldCallback :: forall (m :: * -> *).
    MonadIO m =>
    AttrClassEqualFieldCallback
    -> m (GClosure C_AttrClassEqualFieldCallback)
    genClosure_AttrClassEqualFieldCallback AttrClassEqualFieldCallback
    cb = IO (GClosure C_AttrClassEqualFieldCallback)
    -> m (GClosure C_AttrClassEqualFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_AttrClassEqualFieldCallback)
     -> m (GClosure C_AttrClassEqualFieldCallback))
    -> IO (GClosure C_AttrClassEqualFieldCallback)
    -> m (GClosure C_AttrClassEqualFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_AttrClassEqualFieldCallback
    cb' = Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
    -> AttrClassEqualFieldCallback -> C_AttrClassEqualFieldCallback
    wrap_AttrClassEqualFieldCallback Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
    forall a. Maybe a
    Nothing AttrClassEqualFieldCallback
    cb
        C_AttrClassEqualFieldCallback
    -> IO (FunPtr C_AttrClassEqualFieldCallback)
    mk_AttrClassEqualFieldCallback C_AttrClassEqualFieldCallback
    cb' IO (FunPtr C_AttrClassEqualFieldCallback)
    -> (FunPtr C_AttrClassEqualFieldCallback
        -> IO (GClosure C_AttrClassEqualFieldCallback))
    -> IO (GClosure C_AttrClassEqualFieldCallback)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_AttrClassEqualFieldCallback
    -> IO (GClosure C_AttrClassEqualFieldCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `AttrClassEqualFieldCallback` into a `C_AttrClassEqualFieldCallback`.
    wrap_AttrClassEqualFieldCallback ::
        Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback)) ->
        AttrClassEqualFieldCallback ->
        C_AttrClassEqualFieldCallback
    wrap_AttrClassEqualFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
    -> AttrClassEqualFieldCallback -> C_AttrClassEqualFieldCallback
    wrap_AttrClassEqualFieldCallback Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback))
    gi'funptrptr AttrClassEqualFieldCallback
    gi'cb Ptr Attribute
    attr1 Ptr Attribute
    attr2 = do
        Ptr Attribute -> (Attribute -> IO CInt) -> IO CInt
    forall a b.
    (HasCallStack, ManagedPtrNewtype a) =>
    Ptr a -> (a -> IO b) -> IO b
    B.ManagedPtr.withTransient  Ptr Attribute
    attr1 ((Attribute -> IO CInt) -> IO CInt)
    -> (Attribute -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Attribute
    attr1' -> do
            Ptr Attribute -> (Attribute -> IO CInt) -> IO CInt
    forall a b.
    (HasCallStack, ManagedPtrNewtype a) =>
    Ptr a -> (a -> IO b) -> IO b
    B.ManagedPtr.withTransient  Ptr Attribute
    attr2 ((Attribute -> IO CInt) -> IO CInt)
    -> (Attribute -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Attribute
    attr2' -> do
                result <- AttrClassEqualFieldCallback
    gi'cb  Attribute
    attr1' Attribute
    attr2'
                maybeReleaseFunPtr gi'funptrptr
                let result' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    result
                return result'

    -- callback AttrClassDestroyFieldCallback
    {- Callable
      { returnType = Nothing
      , returnMayBeNull = False
      , returnTransfer = TransferNothing
      , returnDocumentation =
          Documentation { rawDocText = Nothing , sinceVersion = Nothing }
      , args =
          [ Arg
              { argCName = "attr"
              , argType =
                  TInterface Name { namespace = "Pango" , name = "Attribute" }
              , argCType = Just "PangoAttribute*"
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation { rawDocText = Nothing , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = False
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation { rawDocText = Nothing , sinceVersion = Nothing }
      , callableResolvable = Nothing
      }
    -}
    -- | Type for the callback on the (unwrapped) C side.
    type C_AttrClassDestroyFieldCallback =
        Ptr Pango.Attribute.Attribute ->
        IO ()

    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , argCType = Just "PangoAttribute*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "dynamic" __dynamic_C_AttrClassDestroyFieldCallback :: FunPtr C_AttrClassDestroyFieldCallback -> C_AttrClassDestroyFieldCallback

    -- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
    dynamic_AttrClassDestroyFieldCallback ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FunPtr C_AttrClassDestroyFieldCallback
        -> Pango.Attribute.Attribute
        -> m ()
    dynamic_AttrClassDestroyFieldCallback :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr C_AttrClassDestroyFieldCallback -> Attribute -> m ()
    dynamic_AttrClassDestroyFieldCallback FunPtr C_AttrClassDestroyFieldCallback
    __funPtr Attribute
    attr = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        (__dynamic_C_AttrClassDestroyFieldCallback __funPtr) attr'
        touchManagedPtr attr
        return ()

    -- | Generate a function pointer callable from C code, from a `C_AttrClassDestroyFieldCallback`.
    foreign import ccall "wrapper"
        mk_AttrClassDestroyFieldCallback :: C_AttrClassDestroyFieldCallback -> IO (FunPtr C_AttrClassDestroyFieldCallback)

    -- | /No description available in the introspection data./
    type AttrClassDestroyFieldCallback =
        Pango.Attribute.Attribute
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AttrClassDestroyFieldCallback`@.
    noAttrClassDestroyFieldCallback :: Maybe AttrClassDestroyFieldCallback
    noAttrClassDestroyFieldCallback :: Maybe (Attribute -> IO ())
    noAttrClassDestroyFieldCallback = Maybe (Attribute -> IO ())
    forall a. Maybe a
    Nothing

    -- | Wrap the callback into a `GClosure`.
    genClosure_AttrClassDestroyFieldCallback :: MonadIO m => AttrClassDestroyFieldCallback -> m (GClosure C_AttrClassDestroyFieldCallback)
    genClosure_AttrClassDestroyFieldCallback :: forall (m :: * -> *).
    MonadIO m =>
    (Attribute -> IO ())
    -> m (GClosure C_AttrClassDestroyFieldCallback)
    genClosure_AttrClassDestroyFieldCallback Attribute -> IO ()
    cb = IO (GClosure C_AttrClassDestroyFieldCallback)
    -> m (GClosure C_AttrClassDestroyFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_AttrClassDestroyFieldCallback)
     -> m (GClosure C_AttrClassDestroyFieldCallback))
    -> IO (GClosure C_AttrClassDestroyFieldCallback)
    -> m (GClosure C_AttrClassDestroyFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_AttrClassDestroyFieldCallback
    cb' = Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
    -> (Attribute -> IO ()) -> C_AttrClassDestroyFieldCallback
    wrap_AttrClassDestroyFieldCallback Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
    forall a. Maybe a
    Nothing Attribute -> IO ()
    cb
        C_AttrClassDestroyFieldCallback
    -> IO (FunPtr C_AttrClassDestroyFieldCallback)
    mk_AttrClassDestroyFieldCallback C_AttrClassDestroyFieldCallback
    cb' IO (FunPtr C_AttrClassDestroyFieldCallback)
    -> (FunPtr C_AttrClassDestroyFieldCallback
        -> IO (GClosure C_AttrClassDestroyFieldCallback))
    -> IO (GClosure C_AttrClassDestroyFieldCallback)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_AttrClassDestroyFieldCallback
    -> IO (GClosure C_AttrClassDestroyFieldCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `AttrClassDestroyFieldCallback` into a `C_AttrClassDestroyFieldCallback`.
    wrap_AttrClassDestroyFieldCallback ::
        Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback)) ->
        AttrClassDestroyFieldCallback ->
        C_AttrClassDestroyFieldCallback
    wrap_AttrClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
    -> (Attribute -> IO ()) -> C_AttrClassDestroyFieldCallback
    wrap_AttrClassDestroyFieldCallback Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
    gi'funptrptr Attribute -> IO ()
    gi'cb Ptr Attribute
    attr = do
        Ptr Attribute -> (Attribute -> IO ()) -> IO ()
    forall a b.
    (HasCallStack, ManagedPtrNewtype a) =>
    Ptr a -> (a -> IO b) -> IO b
    B.ManagedPtr.withTransient  Ptr Attribute
    attr ((Attribute -> IO ()) -> IO ()) -> (Attribute -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Attribute
    attr' -> do
            Attribute -> IO ()
    gi'cb  Attribute
    attr'
            Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback)) -> IO ()
    forall a. Maybe (Ptr (FunPtr a)) -> IO ()
    maybeReleaseFunPtr Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback))
    gi'funptrptr

    -- callback AttrClassCopyFieldCallback
    {- Callable
      { returnType =
          Just (TInterface Name { namespace = "Pango" , name = "Attribute" })
      , returnMayBeNull = False
      , returnTransfer = TransferEverything
      , returnDocumentation =
          Documentation { rawDocText = Nothing , sinceVersion = Nothing }
      , args =
          [ Arg
              { argCName = "attr"
              , argType =
                  TInterface Name { namespace = "Pango" , name = "Attribute" }
              , argCType = Just "const PangoAttribute*"
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation { rawDocText = Nothing , sinceVersion = Nothing }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , argCallbackUserData = False
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation { rawDocText = Nothing , sinceVersion = Nothing }
      , callableResolvable = Nothing
      }
    -}
    -- | Type for the callback on the (unwrapped) C side.
    type C_AttrClassCopyFieldCallback =
        Ptr Pango.Attribute.Attribute ->
        IO (Ptr Pango.Attribute.Attribute)

    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , argCType = Just "const PangoAttribute*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Attribute" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "dynamic" __dynamic_C_AttrClassCopyFieldCallback :: FunPtr C_AttrClassCopyFieldCallback -> C_AttrClassCopyFieldCallback

    -- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
    dynamic_AttrClassCopyFieldCallback ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FunPtr C_AttrClassCopyFieldCallback
        -> Pango.Attribute.Attribute
        -> m Pango.Attribute.Attribute
    dynamic_AttrClassCopyFieldCallback :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    FunPtr C_AttrClassCopyFieldCallback -> Attribute -> m Attribute
    dynamic_AttrClassCopyFieldCallback FunPtr C_AttrClassCopyFieldCallback
    __funPtr Attribute
    attr = IO Attribute -> m Attribute
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Attribute -> m Attribute) -> IO Attribute -> m Attribute
    forall a b. (a -> b) -> a -> b
    $ do
        attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        result <- (__dynamic_C_AttrClassCopyFieldCallback __funPtr) attr'
        checkUnexpectedReturnNULL "attrClassCopyFieldCallback" result
        result' <- (wrapBoxed Pango.Attribute.Attribute) result
        touchManagedPtr attr
        return result'

    -- | Generate a function pointer callable from C code, from a `C_AttrClassCopyFieldCallback`.
    foreign import ccall "wrapper"
        mk_AttrClassCopyFieldCallback :: C_AttrClassCopyFieldCallback -> IO (FunPtr C_AttrClassCopyFieldCallback)

    -- | /No description available in the introspection data./
    type AttrClassCopyFieldCallback =
        Pango.Attribute.Attribute
        -> IO Pango.Attribute.Attribute

    -- | A convenience synonym for @`Nothing` :: `Maybe` `AttrClassCopyFieldCallback`@.
    noAttrClassCopyFieldCallback :: Maybe AttrClassCopyFieldCallback
    noAttrClassCopyFieldCallback :: Maybe (Attribute -> IO Attribute)
    noAttrClassCopyFieldCallback = Maybe (Attribute -> IO Attribute)
    forall a. Maybe a
    Nothing

    -- | Wrap the callback into a `GClosure`.
    genClosure_AttrClassCopyFieldCallback :: MonadIO m => AttrClassCopyFieldCallback -> m (GClosure C_AttrClassCopyFieldCallback)
    genClosure_AttrClassCopyFieldCallback :: forall (m :: * -> *).
    MonadIO m =>
    (Attribute -> IO Attribute)
    -> m (GClosure C_AttrClassCopyFieldCallback)
    genClosure_AttrClassCopyFieldCallback Attribute -> IO Attribute
    cb = IO (GClosure C_AttrClassCopyFieldCallback)
    -> m (GClosure C_AttrClassCopyFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_AttrClassCopyFieldCallback)
     -> m (GClosure C_AttrClassCopyFieldCallback))
    -> IO (GClosure C_AttrClassCopyFieldCallback)
    -> m (GClosure C_AttrClassCopyFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_AttrClassCopyFieldCallback
    cb' = Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
    -> (Attribute -> IO Attribute) -> C_AttrClassCopyFieldCallback
    wrap_AttrClassCopyFieldCallback Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
    forall a. Maybe a
    Nothing Attribute -> IO Attribute
    cb
        C_AttrClassCopyFieldCallback
    -> IO (FunPtr C_AttrClassCopyFieldCallback)
    mk_AttrClassCopyFieldCallback C_AttrClassCopyFieldCallback
    cb' IO (FunPtr C_AttrClassCopyFieldCallback)
    -> (FunPtr C_AttrClassCopyFieldCallback
        -> IO (GClosure C_AttrClassCopyFieldCallback))
    -> IO (GClosure C_AttrClassCopyFieldCallback)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_AttrClassCopyFieldCallback
    -> IO (GClosure C_AttrClassCopyFieldCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `AttrClassCopyFieldCallback` into a `C_AttrClassCopyFieldCallback`.
    wrap_AttrClassCopyFieldCallback ::
        Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback)) ->
        AttrClassCopyFieldCallback ->
        C_AttrClassCopyFieldCallback
    wrap_AttrClassCopyFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
    -> (Attribute -> IO Attribute) -> C_AttrClassCopyFieldCallback
    wrap_AttrClassCopyFieldCallback Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback))
    gi'funptrptr Attribute -> IO Attribute
    gi'cb Ptr Attribute
    attr = do
        Ptr Attribute
    -> (Attribute -> IO (Ptr Attribute)) -> IO (Ptr Attribute)
    forall a b.
    (HasCallStack, ManagedPtrNewtype a) =>
    Ptr a -> (a -> IO b) -> IO b
    B.ManagedPtr.withTransient  Ptr Attribute
    attr ((Attribute -> IO (Ptr Attribute)) -> IO (Ptr Attribute))
    -> (Attribute -> IO (Ptr Attribute)) -> IO (Ptr Attribute)
    forall a b. (a -> b) -> a -> b
    $ \Attribute
    attr' -> do
            result <- Attribute -> IO Attribute
    gi'cb  Attribute
    attr'
            maybeReleaseFunPtr gi'funptrptr
            result' <- B.ManagedPtr.disownBoxed result
            return result'