{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @RsvgLength@ values are used in 'GI.Rsvg.Objects.Handle.handleGetIntrinsicDimensions', for
-- example, to return the CSS length values of the @width@ and
-- @height@ attributes of an @\<svg>@ element.
-- 
-- This is equivalent to <https://www.w3.org/TR/CSS21/syndata.html#length-units CSS lengths>.
-- 
-- It is up to the calling application to convert lengths in non-pixel units
-- (i.e. those where the /@unit@/ field is not @RSVG_UNIT_PX@) into something
-- meaningful to the application.  For example, if your application knows the
-- dots-per-inch (DPI) it is using, it can convert lengths with /@unit@/ in
-- @RSVG_UNIT_IN@ or other physical units.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Rsvg.Structs.Length
    ( 

-- * Exported types
    Length(..)                              ,
    newZeroLength                           ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveLengthMethod                     ,
#endif



 -- * Properties


-- ** length #attr:length#
-- | numeric part of the length

    getLengthLength                         ,
#if defined(ENABLE_OVERLOADING)
    length_length                           ,
#endif
    setLengthLength                         ,


-- ** unit #attr:unit#
-- | unit part of the length

    getLengthUnit                           ,
#if defined(ENABLE_OVERLOADING)
    length_unit                             ,
#endif
    setLengthUnit                           ,




    ) 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.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 {-# SOURCE #-} qualified GI.Rsvg.Enums as Rsvg.Enums

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

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

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


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

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


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

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

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

length_length :: AttrLabelProxy "length"
length_length = AttrLabelProxy

#endif


-- | Get the value of the “@unit@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' length #unit
-- @
getLengthUnit :: MonadIO m => Length -> m Rsvg.Enums.Unit
getLengthUnit :: forall (m :: * -> *). MonadIO m => Length -> m Unit
getLengthUnit Length
s = IO Unit -> m Unit
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Unit -> m Unit) -> IO Unit -> m Unit
forall a b. (a -> b) -> a -> b
$ Length -> (Ptr Length -> IO Unit) -> IO Unit
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Length
s ((Ptr Length -> IO Unit) -> IO Unit)
-> (Ptr Length -> IO Unit) -> IO Unit
forall a b. (a -> b) -> a -> b
$ \Ptr Length
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Length
ptr Ptr Length -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CUInt
    let val' :: Unit
val' = (Int -> Unit
forall a. Enum a => Int -> a
toEnum (Int -> Unit) -> (CUInt -> Int) -> CUInt -> Unit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    Unit -> IO Unit
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Unit
val'

-- | Set the value of the “@unit@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' length [ #unit 'Data.GI.Base.Attributes.:=' value ]
-- @
setLengthUnit :: MonadIO m => Length -> Rsvg.Enums.Unit -> m ()
setLengthUnit :: forall (m :: * -> *). MonadIO m => Length -> Unit -> m ()
setLengthUnit Length
s Unit
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
$ Length -> (Ptr Length -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Length
s ((Ptr Length -> IO ()) -> IO ()) -> (Ptr Length -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Length
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Unit -> Int) -> Unit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> Int
forall a. Enum a => a -> Int
fromEnum) Unit
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Length
ptr Ptr Length -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data LengthUnitFieldInfo
instance AttrInfo LengthUnitFieldInfo where
    type AttrBaseTypeConstraint LengthUnitFieldInfo = (~) Length
    type AttrAllowedOps LengthUnitFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LengthUnitFieldInfo = (~) Rsvg.Enums.Unit
    type AttrTransferTypeConstraint LengthUnitFieldInfo = (~)Rsvg.Enums.Unit
    type AttrTransferType LengthUnitFieldInfo = Rsvg.Enums.Unit
    type AttrGetType LengthUnitFieldInfo = Rsvg.Enums.Unit
    type AttrLabel LengthUnitFieldInfo = "unit"
    type AttrOrigin LengthUnitFieldInfo = Length
    attrGet = getLengthUnit
    attrSet = setLengthUnit
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Rsvg.Structs.Length.unit"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-rsvg-2.0.3/docs/GI-Rsvg-Structs-Length.html#g:attr:unit"
        })

length_unit :: AttrLabelProxy "unit"
length_unit = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Length
type instance O.AttributeList Length = LengthAttributeList
type LengthAttributeList = ('[ '("length", LengthLengthFieldInfo), '("unit", LengthUnitFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif

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

#endif