    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    The 'GI.Pango.Structs.AttrSize.AttrSize' structure is used to represent attributes which
    set font size.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Pango.Structs.AttrSize
        (

    -- * Exported types
        AttrSize(..)                            ,
        newZeroAttrSize                         ,
        noAttrSize                              ,

     -- * Methods
    -- ** new #method:new#

        attrSizeNew                             ,

     -- * Properties
    -- ** absolute #attr:absolute#
    {- | whether the font size is in device units or points.
    This field is only present for compatibility with Pango-1.8.0
    ('GI.Pango.Enums.AttrTypeAbsoluteSize' was added in 1.8.1); and always will
    be 'False' for 'GI.Pango.Enums.AttrTypeSize' and 'True' for 'GI.Pango.Enums.AttrTypeAbsoluteSize'.
    -}
    #if ENABLE_OVERLOADING
        attrSize_absolute                       ,
    #endif
        getAttrSizeAbsolute                     ,
        setAttrSizeAbsolute                     ,

    -- ** attr #attr:attr#
    {- | the common portion of the attribute
    -}
    #if ENABLE_OVERLOADING
        attrSize_attr                           ,
    #endif
        getAttrSizeAttr                         ,

    -- ** size #attr:size#
    {- | size of font, in units of 1\/'GI.Pango.Constants.SCALE' of a point (for
    'GI.Pango.Enums.AttrTypeSize') or of a device uni (for 'GI.Pango.Enums.AttrTypeAbsoluteSize')
    -}
    #if ENABLE_OVERLOADING
        attrSize_size                           ,
    #endif
        getAttrSizeSize                         ,
        setAttrSizeSize                         ,

        ) 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.ManagedPtr as B.ManagedPtr
    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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

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

    -- | Memory-managed wrapper type.
    newtype AttrSize = AttrSize (ManagedPtr AttrSize)
    instance WrappedPtr AttrSize where
        wrappedPtrCalloc = callocBytes 24
        wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr AttrSize)
        wrappedPtrFree = Just ptr_to_g_free

    -- | Construct a `AttrSize` struct initialized to zero.
    newZeroAttrSize :: MonadIO m => m AttrSize
    newZeroAttrSize = liftIO $ wrappedPtrCalloc >>= wrapPtr AttrSize

    instance tag ~ 'AttrSet => Constructible AttrSize tag where
        new _ attrs = do
            o <- newZeroAttrSize
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `AttrSize`.
    noAttrSize :: Maybe AttrSize
    noAttrSize = Nothing

    {- |
    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' attrSize #attr
    @
    -}
    getAttrSizeAttr :: MonadIO m => AttrSize -> m Pango.Attribute.Attribute
    getAttrSizeAttr s = liftIO $ withManagedPtr s $ \ptr -> do
        let val = ptr `plusPtr` 0 :: (Ptr Pango.Attribute.Attribute)
        val' <- (newPtr Pango.Attribute.Attribute) val
        return val'

    #if ENABLE_OVERLOADING
    data AttrSizeAttrFieldInfo
    instance AttrInfo AttrSizeAttrFieldInfo where
        type AttrAllowedOps AttrSizeAttrFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AttrSizeAttrFieldInfo = (~) (Ptr Pango.Attribute.Attribute)
        type AttrBaseTypeConstraint AttrSizeAttrFieldInfo = (~) AttrSize
        type AttrGetType AttrSizeAttrFieldInfo = Pango.Attribute.Attribute
        type AttrLabel AttrSizeAttrFieldInfo = "attr"
        type AttrOrigin AttrSizeAttrFieldInfo = AttrSize
        attrGet _ = getAttrSizeAttr
        attrSet _ = undefined
        attrConstruct = undefined
        attrClear _ = undefined

    attrSize_attr :: AttrLabelProxy "attr"
    attrSize_attr = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@size@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' attrSize #size
    @
    -}
    getAttrSizeSize :: MonadIO m => AttrSize -> m Int32
    getAttrSizeSize s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 16) :: IO Int32
        return val

    {- |
    Set the value of the “@size@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' attrSize [ #size 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setAttrSizeSize :: MonadIO m => AttrSize -> Int32 -> m ()
    setAttrSizeSize s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (val :: Int32)

    #if ENABLE_OVERLOADING
    data AttrSizeSizeFieldInfo
    instance AttrInfo AttrSizeSizeFieldInfo where
        type AttrAllowedOps AttrSizeSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint AttrSizeSizeFieldInfo = (~) Int32
        type AttrBaseTypeConstraint AttrSizeSizeFieldInfo = (~) AttrSize
        type AttrGetType AttrSizeSizeFieldInfo = Int32
        type AttrLabel AttrSizeSizeFieldInfo = "size"
        type AttrOrigin AttrSizeSizeFieldInfo = AttrSize
        attrGet _ = getAttrSizeSize
        attrSet _ = setAttrSizeSize
        attrConstruct = undefined
        attrClear _ = undefined

    attrSize_size :: AttrLabelProxy "size"
    attrSize_size = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@absolute@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' attrSize #absolute
    @
    -}
    getAttrSizeAbsolute :: MonadIO m => AttrSize -> m Word32
    getAttrSizeAbsolute s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 20) :: IO Word32
        return val

    {- |
    Set the value of the “@absolute@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' attrSize [ #absolute 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setAttrSizeAbsolute :: MonadIO m => AttrSize -> Word32 -> m ()
    setAttrSizeAbsolute s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 20) (val :: Word32)

    #if ENABLE_OVERLOADING
    data AttrSizeAbsoluteFieldInfo
    instance AttrInfo AttrSizeAbsoluteFieldInfo where
        type AttrAllowedOps AttrSizeAbsoluteFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint AttrSizeAbsoluteFieldInfo = (~) Word32
        type AttrBaseTypeConstraint AttrSizeAbsoluteFieldInfo = (~) AttrSize
        type AttrGetType AttrSizeAbsoluteFieldInfo = Word32
        type AttrLabel AttrSizeAbsoluteFieldInfo = "absolute"
        type AttrOrigin AttrSizeAbsoluteFieldInfo = AttrSize
        attrGet _ = getAttrSizeAbsolute
        attrSet _ = setAttrSizeAbsolute
        attrConstruct = undefined
        attrClear _ = undefined

    attrSize_absolute :: AttrLabelProxy "absolute"
    attrSize_absolute = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList AttrSize
    type instance O.AttributeList AttrSize = AttrSizeAttributeList
    type AttrSizeAttributeList = ('[ '("attr", AttrSizeAttrFieldInfo), '("size", AttrSizeSizeFieldInfo), '("absolute", AttrSizeAbsoluteFieldInfo)] :: [(Symbol, *)])
    #endif

    -- method AttrSize::new
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the font size, in %PANGO_SCALE<!-- -->ths of a point.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Pango", name = "Attribute"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attr_size_new" pango_attr_size_new ::
        Int32 ->                                -- size : TBasicType TInt
        IO (Ptr Pango.Attribute.Attribute)

    {- |
    Create a new font-size attribute in fractional points.
    -}
    attrSizeNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Int32
        {- ^ /@size@/: the font size, in 'GI.Pango.Constants.SCALE'\<!-- -->ths of a point. -}
        -> m Pango.Attribute.Attribute
        {- ^ __Returns:__ the newly allocated 'GI.Pango.Structs.Attribute.Attribute',
                  which should be freed with 'GI.Pango.Structs.Attribute.attributeDestroy'. -}
    attrSizeNew size = liftIO $ do
        result <- pango_attr_size_new size
        checkUnexpectedReturnNULL "attrSizeNew" result
        result' <- (wrapPtr Pango.Attribute.Attribute) result
        return result'

    #if ENABLE_OVERLOADING
    #endif

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

    instance (info ~ ResolveAttrSizeMethod t AttrSize, O.MethodInfo info AttrSize p) => O.IsLabelProxy t (AttrSize -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveAttrSizeMethod t AttrSize, O.MethodInfo info AttrSize p) => O.IsLabel t (AttrSize -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif