    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The @PangoAttrFloat@ structure is used to represent attributes with
    -- a float or double value.

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

    module GI.Pango.Structs.AttrFloat
        (

    -- * Exported types
        AttrFloat(..)                           ,
        newZeroAttrFloat                        ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveAttrFloatMethod                  ,
    #endif

     -- * Properties

    -- ** attr #attr:attr#
    -- | the common portion of the attribute

    #if defined(ENABLE_OVERLOADING)
        attrFloat_attr                          ,
    #endif
        getAttrFloatAttr                        ,

    -- ** value #attr:value#
    -- | the value of the attribute

    #if defined(ENABLE_OVERLOADING)
        attrFloat_value                         ,
    #endif
        getAttrFloatValue                       ,
        setAttrFloatValue                       ,

        ) 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.Pango.Callbacks as Pango.Callbacks
    import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums
    import {-# SOURCE #-} qualified GI.Pango.Flags as Pango.Flags
    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.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.Language as Pango.Language
    import {-# SOURCE #-} qualified GI.Pango.Structs.Rectangle as Pango.Rectangle

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

    #endif

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

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

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

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

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

    -- | Get the value of the “@attr@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrFloat #attr
    -- @
    getAttrFloatAttr :: MonadIO m => AttrFloat -> m Pango.Attribute.Attribute
    getAttrFloatAttr :: forall (m :: * -> *). MonadIO m => AttrFloat -> m Attribute
    getAttrFloatAttr AttrFloat
    s = 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
    $ AttrFloat -> (Ptr AttrFloat -> IO Attribute) -> IO Attribute
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrFloat
    s ((Ptr AttrFloat -> IO Attribute) -> IO Attribute)
    -> (Ptr AttrFloat -> IO Attribute) -> IO Attribute
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrFloat
    ptr -> do
        let val :: Ptr Attribute
    val = Ptr AttrFloat
    ptr Ptr AttrFloat -> Int -> Ptr Attribute
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0 :: (Ptr Pango.Attribute.Attribute)
        val' <- ((ManagedPtr Attribute -> Attribute)
    -> Ptr Attribute -> IO Attribute
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr Attribute -> Attribute
    Pango.Attribute.Attribute) Ptr Attribute
    val
        return val'

    #if defined(ENABLE_OVERLOADING)
    data AttrFloatAttrFieldInfo
    instance AttrInfo AttrFloatAttrFieldInfo where
        type AttrBaseTypeConstraint AttrFloatAttrFieldInfo = (~) AttrFloat
        type AttrAllowedOps AttrFloatAttrFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrFloatAttrFieldInfo = (~) (Ptr Pango.Attribute.Attribute)
        type AttrTransferTypeConstraint AttrFloatAttrFieldInfo = (~)(Ptr Pango.Attribute.Attribute)
        type AttrTransferType AttrFloatAttrFieldInfo = (Ptr Pango.Attribute.Attribute)
        type AttrGetType AttrFloatAttrFieldInfo = Pango.Attribute.Attribute
        type AttrLabel AttrFloatAttrFieldInfo = "attr"
        type AttrOrigin AttrFloatAttrFieldInfo = AttrFloat
        attrGet = getAttrFloatAttr
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.AttrFloat.attr"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Structs-AttrFloat.html#g:attr:attr"
            })

    attrFloat_attr :: AttrLabelProxy "attr"
    attrFloat_attr = AttrLabelProxy

    #endif

    -- | Get the value of the “@value@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attrFloat #value
    -- @
    getAttrFloatValue :: MonadIO m => AttrFloat -> m Double
    getAttrFloatValue :: forall (m :: * -> *). MonadIO m => AttrFloat -> m Double
    getAttrFloatValue AttrFloat
    s = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ AttrFloat -> (Ptr AttrFloat -> IO Double) -> IO Double
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrFloat
    s ((Ptr AttrFloat -> IO Double) -> IO Double)
    -> (Ptr AttrFloat -> IO Double) -> IO Double
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrFloat
    ptr -> do
        val <- Ptr CDouble -> IO CDouble
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr AttrFloat
    ptr Ptr AttrFloat -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) :: IO CDouble
        let val' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    val
        return val'

    -- | Set the value of the “@value@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' attrFloat [ #value 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAttrFloatValue :: MonadIO m => AttrFloat -> Double -> m ()
    setAttrFloatValue :: forall (m :: * -> *). MonadIO m => AttrFloat -> Double -> m ()
    setAttrFloatValue AttrFloat
    s Double
    val = 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
    $ AttrFloat -> (Ptr AttrFloat -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AttrFloat
    s ((Ptr AttrFloat -> IO ()) -> IO ())
    -> (Ptr AttrFloat -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrFloat
    ptr -> do
        let val' :: CDouble
    val' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    val
        Ptr CDouble -> CDouble -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AttrFloat
    ptr Ptr AttrFloat -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) (CDouble
    val' :: CDouble)

    #if defined(ENABLE_OVERLOADING)
    data AttrFloatValueFieldInfo
    instance AttrInfo AttrFloatValueFieldInfo where
        type AttrBaseTypeConstraint AttrFloatValueFieldInfo = (~) AttrFloat
        type AttrAllowedOps AttrFloatValueFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint AttrFloatValueFieldInfo = (~) Double
        type AttrTransferTypeConstraint AttrFloatValueFieldInfo = (~)Double
        type AttrTransferType AttrFloatValueFieldInfo = Double
        type AttrGetType AttrFloatValueFieldInfo = Double
        type AttrLabel AttrFloatValueFieldInfo = "value"
        type AttrOrigin AttrFloatValueFieldInfo = AttrFloat
        attrGet = getAttrFloatValue
        attrSet = setAttrFloatValue
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.AttrFloat.value"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Structs-AttrFloat.html#g:attr:value"
            })

    attrFloat_value :: AttrLabelProxy "value"
    attrFloat_value = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList AttrFloat
    type instance O.AttributeList AttrFloat = AttrFloatAttributeList
    type AttrFloatAttributeList = ('[ '("attr", AttrFloatAttrFieldInfo), '("value", AttrFloatValueFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

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

    #endif

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

    #endif