    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Glyph draw callbacks.
    --
    -- t'GI.HarfBuzz.Callbacks.DrawMoveToFuncT', t'GI.HarfBuzz.Callbacks.DrawLineToFuncT' and
    -- t'GI.HarfBuzz.Callbacks.DrawCubicToFuncT' calls are necessary to be defined but we translate
    -- t'GI.HarfBuzz.Callbacks.DrawQuadraticToFuncT' calls to t'GI.HarfBuzz.Callbacks.DrawCubicToFuncT' if the
    -- callback isn\'t defined.
    --
    -- /Since: 4.0.0/

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

    module GI.HarfBuzz.Structs.DrawFuncsT
        (

    -- * Exported types
        DrawFuncsT(..)                          ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveDrawFuncsTMethod                 ,
    #endif

        ) 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)

    #else

    #endif

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

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

    foreign import ccall "hb_gobject_draw_funcs_get_type" c_hb_gobject_draw_funcs_get_type ::
        IO GType

    type instance O.ParentTypes DrawFuncsT = '[]
    instance O.HasParentTypes DrawFuncsT

    instance B.Types.TypedObject DrawFuncsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_draw_funcs_get_type

    instance B.Types.GBoxed DrawFuncsT

    -- | Convert 'DrawFuncsT' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe DrawFuncsT) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_hb_gobject_draw_funcs_get_type
        gvalueSet_ :: Ptr GValue -> Maybe DrawFuncsT -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe DrawFuncsT
    P.Nothing = Ptr GValue -> Ptr DrawFuncsT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr DrawFuncsT
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr DrawFuncsT)
        gvalueSet_ Ptr GValue
    gv (P.Just DrawFuncsT
    obj) = DrawFuncsT -> (Ptr DrawFuncsT -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr DrawFuncsT
    obj (Ptr GValue -> Ptr DrawFuncsT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe DrawFuncsT)
    gvalueGet_ Ptr GValue
    gv = do
            Ptr DrawFuncsT
    ptr <- Ptr GValue -> IO (Ptr DrawFuncsT)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr DrawFuncsT)
            if Ptr DrawFuncsT
    ptr Ptr DrawFuncsT -> Ptr DrawFuncsT -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Ptr DrawFuncsT
    forall a. Ptr a
    FP.nullPtr
            then DrawFuncsT -> Maybe DrawFuncsT
    forall a. a -> Maybe a
    P.Just (DrawFuncsT -> Maybe DrawFuncsT)
    -> IO DrawFuncsT -> IO (Maybe DrawFuncsT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ManagedPtr DrawFuncsT -> DrawFuncsT)
    -> Ptr DrawFuncsT -> IO DrawFuncsT
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.newBoxed ManagedPtr DrawFuncsT -> DrawFuncsT
    DrawFuncsT Ptr DrawFuncsT
    ptr
            else Maybe DrawFuncsT -> IO (Maybe DrawFuncsT)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe DrawFuncsT
    forall a. Maybe a
    P.Nothing

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList DrawFuncsT
    type instance O.AttributeList DrawFuncsT = DrawFuncsTAttributeList
    type DrawFuncsTAttributeList = ('[ ] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveDrawFuncsTMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveDrawFuncsTMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif