    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Data type containing a set of virtual methods used for
    -- working on t'GI.HarfBuzz.Structs.FontT.FontT' font objects.
    --
    -- HarfBuzz provides a lightweight default function for each of
    -- the methods in t'GI.HarfBuzz.Structs.FontFuncsT.FontFuncsT'. Client programs can implement
    -- their own replacements for the individual font functions, as
    -- needed, and replace the default by calling the setter for a
    -- method.

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

    module GI.HarfBuzz.Structs.FontFuncsT
        (

    -- * Exported types
        FontFuncsT(..)                          ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveFontFuncsTMethod                 ,
    #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

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

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

    foreign import ccall "hb_gobject_font_funcs_get_type" c_hb_gobject_font_funcs_get_type ::
        IO GType

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

    instance B.Types.TypedObject FontFuncsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_font_funcs_get_type

    instance B.Types.GBoxed FontFuncsT

    -- | Convert 'FontFuncsT' 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 FontFuncsT) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_hb_gobject_font_funcs_get_type
        gvalueSet_ :: Ptr GValue -> Maybe FontFuncsT -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe FontFuncsT
    P.Nothing = Ptr GValue -> Ptr FontFuncsT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr FontFuncsT
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr FontFuncsT)
        gvalueSet_ Ptr GValue
    gv (P.Just FontFuncsT
    obj) = FontFuncsT -> (Ptr FontFuncsT -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr FontFuncsT
    obj (Ptr GValue -> Ptr FontFuncsT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe FontFuncsT)
    gvalueGet_ Ptr GValue
    gv = do
            Ptr FontFuncsT
    ptr <- Ptr GValue -> IO (Ptr FontFuncsT)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr FontFuncsT)
            if Ptr FontFuncsT
    ptr Ptr FontFuncsT -> Ptr FontFuncsT -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Ptr FontFuncsT
    forall a. Ptr a
    FP.nullPtr
            then FontFuncsT -> Maybe FontFuncsT
    forall a. a -> Maybe a
    P.Just (FontFuncsT -> Maybe FontFuncsT)
    -> IO FontFuncsT -> IO (Maybe FontFuncsT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ManagedPtr FontFuncsT -> FontFuncsT)
    -> Ptr FontFuncsT -> IO FontFuncsT
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.newBoxed ManagedPtr FontFuncsT -> FontFuncsT
    FontFuncsT Ptr FontFuncsT
    ptr
            else Maybe FontFuncsT -> IO (Maybe FontFuncsT)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe FontFuncsT
    forall a. Maybe a
    P.Nothing

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

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

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

    #endif

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

    #endif