{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Position of an SVG fragment from 'GI.Rsvg.Objects.Handle.handleGetPositionSub'.  Please
-- the deprecation documentation for that function.

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

module GI.Rsvg.Structs.PositionData
    ( 

-- * Exported types
    PositionData(..)                        ,
    newZeroPositionData                     ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolvePositionDataMethod               ,
#endif



 -- * Properties


-- ** x #attr:x#
-- | position on the x axis

    getPositionDataX                        ,
#if defined(ENABLE_OVERLOADING)
    positionData_x                          ,
#endif
    setPositionDataX                        ,


-- ** y #attr:y#
-- | position on the y axis

    getPositionDataY                        ,
#if defined(ENABLE_OVERLOADING)
    positionData_y                          ,
#endif
    setPositionDataY                        ,




    ) 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


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

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

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


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

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


-- | Get the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' positionData #x
-- @
getPositionDataX :: MonadIO m => PositionData -> m Int32
getPositionDataX :: forall (m :: * -> *). MonadIO m => PositionData -> m Int32
getPositionDataX PositionData
s = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ PositionData -> (Ptr PositionData -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PositionData
s ((Ptr PositionData -> IO Int32) -> IO Int32)
-> (Ptr PositionData -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr PositionData
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr PositionData
ptr Ptr PositionData -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Int32
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

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

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

positionData_x :: AttrLabelProxy "x"
positionData_x = AttrLabelProxy

#endif


-- | Get the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' positionData #y
-- @
getPositionDataY :: MonadIO m => PositionData -> m Int32
getPositionDataY :: forall (m :: * -> *). MonadIO m => PositionData -> m Int32
getPositionDataY PositionData
s = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ PositionData -> (Ptr PositionData -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PositionData
s ((Ptr PositionData -> IO Int32) -> IO Int32)
-> (Ptr PositionData -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr PositionData
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr PositionData
ptr Ptr PositionData -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Int32
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

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

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

positionData_y :: AttrLabelProxy "y"
positionData_y = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PositionData
type instance O.AttributeList PositionData = PositionDataAttributeList
type PositionDataAttributeList = ('[ '("x", PositionDataXFieldInfo), '("y", PositionDataYFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif

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

#endif