{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DataKinds, TypeFamilies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
module Data.GI.Base.GValue
(
GValue(..)
, IsGValue(..)
, toGValue
, fromGValue
, GValueConstruct(..)
, ptr_to_gvalue_free
, newGValue
, buildGValue
, disownGValue
, noGValue
, newGValueFromPtr
, wrapGValuePtr
, unsetGValue
, gvalueType
, packGValueArray
, unpackGValueArrayWithLength
, mapGValueArrayWithLength
, set_object
, get_object
, set_boxed
, get_boxed
, set_variant
, get_variant
, set_enum
, get_enum
, set_flags
, get_flags
, set_stablePtr
, get_stablePtr
, take_stablePtr
) where
import Control.Monad.IO.Class (MonadIO, liftIO)
import Data.Coerce (coerce)
import Data.Word
import Data.Int
import Data.Text (Text, pack, unpack)
import Foreign.C.Types (CInt(..), CUInt(..), CFloat(..), CDouble(..),
CLong(..), CULong(..))
import Foreign.C.String (CString)
import Foreign.Ptr (Ptr, nullPtr, plusPtr, FunPtr)
import Foreign.StablePtr (StablePtr, castStablePtrToPtr, castPtrToStablePtr)
import Data.GI.Base.BasicTypes
import Data.GI.Base.BasicConversions (cstringToText, textToCString)
import Data.GI.Base.GType
import Data.GI.Base.ManagedPtr
import Data.GI.Base.Utils (callocBytes, freeMem)
import Data.GI.Base.Internal.CTypes (cgvalueSize)
import Data.GI.Base.Overloading (ParentTypes, HasParentTypes)
newtype GValue = GValue (ManagedPtr GValue)
foreign import ccall "&haskell_gi_gvalue_free" ptr_to_gvalue_free ::
FunPtr (Ptr GValue -> IO ())
type instance ParentTypes GValue = '[]
instance HasParentTypes GValue
foreign import ccall unsafe "g_value_get_type" c_g_value_get_type ::
IO GType
instance TypedObject GValue where
glibType :: IO GType
glibType = IO GType
c_g_value_get_type
instance GBoxed GValue
foreign import ccall "g_value_init" g_value_init ::
Ptr GValue -> CGType -> IO (Ptr GValue)
data GValueConstruct o = GValueConstruct String GValue
newGValue :: GType -> IO GValue
newGValue :: GType -> IO GValue
newGValue (GType CGType
gtype) = do
Ptr GValue
gvptr <- forall a. Int -> IO (Ptr a)
callocBytes Int
cgvalueSize
Ptr GValue
_ <- Ptr GValue -> CGType -> IO (Ptr GValue)
g_value_init Ptr GValue
gvptr CGType
gtype
GValue
gv <- forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr GValue -> GValue
GValue Ptr GValue
gvptr
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! GValue
gv
wrapGValuePtr :: Ptr GValue -> IO GValue
wrapGValuePtr :: Ptr GValue -> IO GValue
wrapGValuePtr Ptr GValue
ptr = forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr GValue -> GValue
GValue Ptr GValue
ptr
newGValueFromPtr :: Ptr GValue -> IO GValue
newGValueFromPtr :: Ptr GValue -> IO GValue
newGValueFromPtr Ptr GValue
ptr = forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GValue -> GValue
GValue Ptr GValue
ptr
buildGValue :: GType -> (Ptr GValue -> a -> IO ()) -> a -> IO GValue
buildGValue :: forall a. GType -> (Ptr GValue -> a -> IO ()) -> a -> IO GValue
buildGValue GType
gtype Ptr GValue -> a -> IO ()
setter a
val = do
GValue
gv <- GType -> IO GValue
newGValue GType
gtype
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GValue
gv forall a b. (a -> b) -> a -> b
$ \Ptr GValue
gvPtr -> Ptr GValue -> a -> IO ()
setter Ptr GValue
gvPtr a
val
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
gv
disownGValue :: GValue -> IO (Ptr GValue)
disownGValue :: GValue -> IO (Ptr GValue)
disownGValue = forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
disownManagedPtr
foreign import ccall "_haskell_gi_g_value_get_type" g_value_get_type :: Ptr GValue -> IO CGType
gvalueType :: GValue -> IO GType
gvalueType :: GValue -> IO GType
gvalueType GValue
gv = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GValue
gv forall a b. (a -> b) -> a -> b
$ \Ptr GValue
gvptr -> do
CGType
cgtype <- Ptr GValue -> IO CGType
g_value_get_type Ptr GValue
gvptr
forall (m :: * -> *) a. Monad m => a -> m a
return (CGType -> GType
GType CGType
cgtype)
foreign import ccall "g_value_unset" g_value_unset :: Ptr GValue -> IO ()
unsetGValue :: Ptr GValue -> IO ()
unsetGValue :: Ptr GValue -> IO ()
unsetGValue = Ptr GValue -> IO ()
g_value_unset
noGValue :: Maybe GValue
noGValue :: Maybe GValue
noGValue = forall a. Maybe a
Nothing
class IsGValue a where
gvalueGType_ :: IO GType
gvalueSet_ :: Ptr GValue -> a -> IO ()
gvalueGet_ :: Ptr GValue -> IO a
toGValue :: forall a m. (IsGValue a, MonadIO m) => a -> m GValue
toGValue :: forall a (m :: * -> *). (IsGValue a, MonadIO m) => a -> m GValue
toGValue a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
gvptr <- forall a. Int -> IO (Ptr a)
callocBytes Int
cgvalueSize
GType CGType
gtype <- forall a. IsGValue a => IO GType
gvalueGType_ @a
Ptr GValue
_ <- Ptr GValue -> CGType -> IO (Ptr GValue)
g_value_init Ptr GValue
gvptr CGType
gtype
forall a. IsGValue a => Ptr GValue -> a -> IO ()
gvalueSet_ Ptr GValue
gvptr a
val
GValue
gv <- forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr GValue -> GValue
GValue Ptr GValue
gvptr
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! GValue
gv
fromGValue :: (IsGValue a, MonadIO m) => GValue -> m a
fromGValue :: forall a (m :: * -> *). (IsGValue a, MonadIO m) => GValue -> m a
fromGValue GValue
gv = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GValue
gv forall a. IsGValue a => Ptr GValue -> IO a
gvalueGet_
instance IsGValue (Maybe String) where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeString
gvalueSet_ :: Ptr GValue -> Maybe String -> IO ()
gvalueSet_ Ptr GValue
gvPtr Maybe String
mstr = Ptr GValue -> Maybe Text -> IO ()
set_string Ptr GValue
gvPtr (String -> Text
pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe String
mstr)
gvalueGet_ :: Ptr GValue -> IO (Maybe String)
gvalueGet_ Ptr GValue
v = (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> String
unpack) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr GValue -> IO (Maybe Text)
get_string Ptr GValue
v
instance IsGValue (Maybe Text) where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeString
gvalueSet_ :: Ptr GValue -> Maybe Text -> IO ()
gvalueSet_ = Ptr GValue -> Maybe Text -> IO ()
set_string
gvalueGet_ :: Ptr GValue -> IO (Maybe Text)
gvalueGet_ = Ptr GValue -> IO (Maybe Text)
get_string
instance IsGValue (Ptr a) where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypePointer
gvalueSet_ :: Ptr GValue -> Ptr a -> IO ()
gvalueSet_ = forall a. Ptr GValue -> Ptr a -> IO ()
set_pointer
gvalueGet_ :: Ptr GValue -> IO (Ptr a)
gvalueGet_ = forall a. Ptr GValue -> IO (Ptr a)
get_pointer
instance IsGValue Int32 where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeInt
gvalueSet_ :: Ptr GValue -> Int32 -> IO ()
gvalueSet_ = Ptr GValue -> Int32 -> IO ()
set_int32
gvalueGet_ :: Ptr GValue -> IO Int32
gvalueGet_ = Ptr GValue -> IO Int32
get_int32
instance IsGValue Word32 where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeUInt
gvalueSet_ :: Ptr GValue -> Word32 -> IO ()
gvalueSet_ = Ptr GValue -> Word32 -> IO ()
set_uint32
gvalueGet_ :: Ptr GValue -> IO Word32
gvalueGet_ = Ptr GValue -> IO Word32
get_uint32
instance IsGValue CInt where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeInt
gvalueSet_ :: Ptr GValue -> CInt -> IO ()
gvalueSet_ = Ptr GValue -> CInt -> IO ()
set_int
gvalueGet_ :: Ptr GValue -> IO CInt
gvalueGet_ = Ptr GValue -> IO CInt
get_int
instance IsGValue CUInt where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeUInt
gvalueSet_ :: Ptr GValue -> CUInt -> IO ()
gvalueSet_ = Ptr GValue -> CUInt -> IO ()
set_uint
gvalueGet_ :: Ptr GValue -> IO CUInt
gvalueGet_ = Ptr GValue -> IO CUInt
get_uint
instance IsGValue CLong where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeLong
gvalueSet_ :: Ptr GValue -> CLong -> IO ()
gvalueSet_ = Ptr GValue -> CLong -> IO ()
set_long
gvalueGet_ :: Ptr GValue -> IO CLong
gvalueGet_ = Ptr GValue -> IO CLong
get_long
instance IsGValue CULong where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeULong
gvalueSet_ :: Ptr GValue -> CULong -> IO ()
gvalueSet_ = Ptr GValue -> CULong -> IO ()
set_ulong
gvalueGet_ :: Ptr GValue -> IO CULong
gvalueGet_ = Ptr GValue -> IO CULong
get_ulong
instance IsGValue Int64 where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeInt64
gvalueSet_ :: Ptr GValue -> Int64 -> IO ()
gvalueSet_ = Ptr GValue -> Int64 -> IO ()
set_int64
gvalueGet_ :: Ptr GValue -> IO Int64
gvalueGet_ = Ptr GValue -> IO Int64
get_int64
instance IsGValue Word64 where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeUInt64
gvalueSet_ :: Ptr GValue -> CGType -> IO ()
gvalueSet_ = Ptr GValue -> CGType -> IO ()
set_uint64
gvalueGet_ :: Ptr GValue -> IO CGType
gvalueGet_ = Ptr GValue -> IO CGType
get_uint64
instance IsGValue Float where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeFloat
gvalueSet_ :: Ptr GValue -> Float -> IO ()
gvalueSet_ = Ptr GValue -> Float -> IO ()
set_float
gvalueGet_ :: Ptr GValue -> IO Float
gvalueGet_ = Ptr GValue -> IO Float
get_float
instance IsGValue Double where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeDouble
gvalueSet_ :: Ptr GValue -> Double -> IO ()
gvalueSet_ = Ptr GValue -> Double -> IO ()
set_double
gvalueGet_ :: Ptr GValue -> IO Double
gvalueGet_ = Ptr GValue -> IO Double
get_double
instance IsGValue Bool where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeBoolean
gvalueSet_ :: Ptr GValue -> Bool -> IO ()
gvalueSet_ = Ptr GValue -> Bool -> IO ()
set_boolean
gvalueGet_ :: Ptr GValue -> IO Bool
gvalueGet_ = Ptr GValue -> IO Bool
get_boolean
instance IsGValue GType where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeGType
gvalueSet_ :: Ptr GValue -> GType -> IO ()
gvalueSet_ = Ptr GValue -> GType -> IO ()
set_gtype
gvalueGet_ :: Ptr GValue -> IO GType
gvalueGet_ = Ptr GValue -> IO GType
get_gtype
instance IsGValue (StablePtr a) where
gvalueGType_ :: IO GType
gvalueGType_ = forall (m :: * -> *) a. Monad m => a -> m a
return GType
gtypeStablePtr
gvalueSet_ :: Ptr GValue -> StablePtr a -> IO ()
gvalueSet_ = forall a. Ptr GValue -> StablePtr a -> IO ()
set_stablePtr
gvalueGet_ :: Ptr GValue -> IO (StablePtr a)
gvalueGet_ = forall a. Ptr GValue -> IO (StablePtr a)
get_stablePtr
foreign import ccall "g_value_set_string" _set_string ::
Ptr GValue -> CString -> IO ()
foreign import ccall "g_value_get_string" _get_string ::
Ptr GValue -> IO CString
set_string :: Ptr GValue -> Maybe Text -> IO ()
set_string :: Ptr GValue -> Maybe Text -> IO ()
set_string Ptr GValue
ptr Maybe Text
maybeStr = do
CString
cstr <- case Maybe Text
maybeStr of
Just Text
str -> Text -> IO CString
textToCString Text
str
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Ptr GValue -> CString -> IO ()
_set_string Ptr GValue
ptr CString
cstr
forall a. Ptr a -> IO ()
freeMem CString
cstr
get_string :: Ptr GValue -> IO (Maybe Text)
get_string :: Ptr GValue -> IO (Maybe Text)
get_string Ptr GValue
gvptr = do
CString
cstr <- Ptr GValue -> IO CString
_get_string Ptr GValue
gvptr
if CString
cstr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
nullPtr
then forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack => CString -> IO Text
cstringToText CString
cstr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
foreign import ccall unsafe "g_value_set_pointer" set_pointer ::
Ptr GValue -> Ptr a -> IO ()
foreign import ccall unsafe "g_value_get_pointer" get_pointer ::
Ptr GValue -> IO (Ptr b)
foreign import ccall unsafe "g_value_set_int" set_int ::
Ptr GValue -> CInt -> IO ()
foreign import ccall unsafe "g_value_get_int" get_int ::
Ptr GValue -> IO CInt
set_int32 :: Ptr GValue -> Int32 -> IO ()
set_int32 :: Ptr GValue -> Int32 -> IO ()
set_int32 Ptr GValue
gv Int32
n = Ptr GValue -> CInt -> IO ()
set_int Ptr GValue
gv (coerce :: forall a b. Coercible a b => a -> b
coerce Int32
n)
get_int32 :: Ptr GValue -> IO Int32
get_int32 :: Ptr GValue -> IO Int32
get_int32 Ptr GValue
gv = coerce :: forall a b. Coercible a b => a -> b
coerce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr GValue -> IO CInt
get_int Ptr GValue
gv
foreign import ccall unsafe "g_value_set_uint" set_uint ::
Ptr GValue -> CUInt -> IO ()
foreign import ccall unsafe "g_value_get_uint" get_uint ::
Ptr GValue -> IO CUInt
set_uint32 :: Ptr GValue -> Word32 -> IO ()
set_uint32 :: Ptr GValue -> Word32 -> IO ()
set_uint32 Ptr GValue
gv Word32
n = Ptr GValue -> CUInt -> IO ()
set_uint Ptr GValue
gv (coerce :: forall a b. Coercible a b => a -> b
coerce Word32
n)
get_uint32 :: Ptr GValue -> IO Word32
get_uint32 :: Ptr GValue -> IO Word32
get_uint32 Ptr GValue
gv = coerce :: forall a b. Coercible a b => a -> b
coerce forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr GValue -> IO CUInt
get_uint Ptr GValue
gv
foreign import ccall unsafe "g_value_set_long" set_long ::
Ptr GValue -> CLong -> IO ()
foreign import ccall unsafe "g_value_get_long" get_long ::
Ptr GValue -> IO CLong
foreign import ccall unsafe "g_value_set_ulong" set_ulong ::
Ptr GValue -> CULong -> IO ()
foreign import ccall unsafe "g_value_get_ulong" get_ulong ::
Ptr GValue -> IO CULong
foreign import ccall unsafe "g_value_set_int64" set_int64 ::
Ptr GValue -> Int64 -> IO ()
foreign import ccall unsafe "g_value_get_int64" get_int64 ::
Ptr GValue -> IO Int64
foreign import ccall unsafe "g_value_set_uint64" set_uint64 ::
Ptr GValue -> Word64 -> IO ()
foreign import ccall unsafe "g_value_get_uint64" get_uint64 ::
Ptr GValue -> IO Word64
foreign import ccall unsafe "g_value_set_float" _set_float ::
Ptr GValue -> CFloat -> IO ()
foreign import ccall unsafe "g_value_get_float" _get_float ::
Ptr GValue -> IO CFloat
set_float :: Ptr GValue -> Float -> IO ()
set_float :: Ptr GValue -> Float -> IO ()
set_float Ptr GValue
gv Float
f = Ptr GValue -> CFloat -> IO ()
_set_float Ptr GValue
gv (forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
f)
get_float :: Ptr GValue -> IO Float
get_float :: Ptr GValue -> IO Float
get_float Ptr GValue
gv = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr GValue -> IO CFloat
_get_float Ptr GValue
gv
foreign import ccall unsafe "g_value_set_double" _set_double ::
Ptr GValue -> CDouble -> IO ()
foreign import ccall unsafe "g_value_get_double" _get_double ::
Ptr GValue -> IO CDouble
set_double :: Ptr GValue -> Double -> IO ()
set_double :: Ptr GValue -> Double -> IO ()
set_double Ptr GValue
gv Double
d = Ptr GValue -> CDouble -> IO ()
_set_double Ptr GValue
gv (forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
d)
get_double :: Ptr GValue -> IO Double
get_double :: Ptr GValue -> IO Double
get_double Ptr GValue
gv = forall a b. (Real a, Fractional b) => a -> b
realToFrac forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr GValue -> IO CDouble
_get_double Ptr GValue
gv
foreign import ccall unsafe "g_value_set_boolean" _set_boolean ::
Ptr GValue -> CInt -> IO ()
foreign import ccall unsafe "g_value_get_boolean" _get_boolean ::
Ptr GValue -> IO CInt
set_boolean :: Ptr GValue -> Bool -> IO ()
set_boolean :: Ptr GValue -> Bool -> IO ()
set_boolean Ptr GValue
gv Bool
b = Ptr GValue -> CInt -> IO ()
_set_boolean Ptr GValue
gv (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> Int
fromEnum Bool
b)
get_boolean :: Ptr GValue -> IO Bool
get_boolean :: Ptr GValue -> IO Bool
get_boolean Ptr GValue
gv = (forall a. Eq a => a -> a -> Bool
/= CInt
0) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr GValue -> IO CInt
_get_boolean Ptr GValue
gv
foreign import ccall unsafe "g_value_set_gtype" _set_gtype ::
Ptr GValue -> CGType -> IO ()
foreign import ccall unsafe "g_value_get_gtype" _get_gtype ::
Ptr GValue -> IO CGType
set_gtype :: Ptr GValue -> GType -> IO ()
set_gtype :: Ptr GValue -> GType -> IO ()
set_gtype Ptr GValue
gv (GType CGType
g) = Ptr GValue -> CGType -> IO ()
_set_gtype Ptr GValue
gv CGType
g
get_gtype :: Ptr GValue -> IO GType
get_gtype :: Ptr GValue -> IO GType
get_gtype Ptr GValue
gv = CGType -> GType
GType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr GValue -> IO CGType
_get_gtype Ptr GValue
gv
foreign import ccall "g_value_set_object" _set_object ::
Ptr GValue -> Ptr a -> IO ()
foreign import ccall "g_value_get_object" _get_object ::
Ptr GValue -> IO (Ptr a)
set_object :: GObject a => Ptr GValue -> Ptr a -> IO ()
set_object :: forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
set_object = forall a. Ptr GValue -> Ptr a -> IO ()
_set_object
get_object :: GObject a => Ptr GValue -> IO (Ptr a)
get_object :: forall a. GObject a => Ptr GValue -> IO (Ptr a)
get_object = forall a. Ptr GValue -> IO (Ptr a)
_get_object
foreign import ccall "g_value_set_boxed" set_boxed ::
Ptr GValue -> Ptr a -> IO ()
foreign import ccall "g_value_get_boxed" get_boxed ::
Ptr GValue -> IO (Ptr b)
foreign import ccall "g_value_set_variant" set_variant ::
Ptr GValue -> Ptr GVariant -> IO ()
foreign import ccall "g_value_get_variant" get_variant ::
Ptr GValue -> IO (Ptr GVariant)
foreign import ccall unsafe "g_value_set_enum" set_enum ::
Ptr GValue -> CUInt -> IO ()
foreign import ccall unsafe "g_value_get_enum" get_enum ::
Ptr GValue -> IO CUInt
foreign import ccall unsafe "g_value_set_flags" set_flags ::
Ptr GValue -> CUInt -> IO ()
foreign import ccall unsafe "g_value_get_flags" get_flags ::
Ptr GValue -> IO CUInt
set_stablePtr :: Ptr GValue -> StablePtr a -> IO ()
set_stablePtr :: forall a. Ptr GValue -> StablePtr a -> IO ()
set_stablePtr Ptr GValue
gv StablePtr a
ptr = forall a. Ptr GValue -> Ptr a -> IO ()
set_boxed Ptr GValue
gv (forall a. StablePtr a -> Ptr ()
castStablePtrToPtr StablePtr a
ptr)
foreign import ccall g_value_take_boxed :: Ptr GValue -> StablePtr a -> IO ()
take_stablePtr :: Ptr GValue -> StablePtr a -> IO ()
take_stablePtr :: forall a. Ptr GValue -> StablePtr a -> IO ()
take_stablePtr = forall a. Ptr GValue -> StablePtr a -> IO ()
g_value_take_boxed
get_stablePtr :: Ptr GValue -> IO (StablePtr a)
get_stablePtr :: forall a. Ptr GValue -> IO (StablePtr a)
get_stablePtr Ptr GValue
gv = forall a. Ptr () -> StablePtr a
castPtrToStablePtr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Ptr GValue -> IO (Ptr a)
get_boxed Ptr GValue
gv
foreign import ccall g_value_copy :: Ptr GValue -> Ptr GValue -> IO ()
packGValueArray :: [GValue] -> IO (Ptr GValue)
packGValueArray :: [GValue] -> IO (Ptr GValue)
packGValueArray [GValue]
gvalues = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
[a] -> ([Ptr a] -> IO c) -> IO c
withManagedPtrList [GValue]
gvalues forall a b. (a -> b) -> a -> b
$ \[Ptr GValue]
ptrs -> do
let nitems :: Int
nitems = forall (t :: * -> *) a. Foldable t => t a -> Int
length [Ptr GValue]
ptrs
Ptr GValue
mem <- forall a. Int -> IO (Ptr a)
callocBytes forall a b. (a -> b) -> a -> b
$ Int
cgvalueSize forall a. Num a => a -> a -> a
* Int
nitems
Ptr GValue -> [Ptr GValue] -> IO ()
fill Ptr GValue
mem [Ptr GValue]
ptrs
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GValue
mem
where fill :: Ptr GValue -> [Ptr GValue] -> IO ()
fill :: Ptr GValue -> [Ptr GValue] -> IO ()
fill Ptr GValue
_ [] = forall (m :: * -> *) a. Monad m => a -> m a
return ()
fill Ptr GValue
ptr (Ptr GValue
x:[Ptr GValue]
xs) = do
CGType
gtype <- Ptr GValue -> IO CGType
g_value_get_type Ptr GValue
x
Ptr GValue
_ <- Ptr GValue -> CGType -> IO (Ptr GValue)
g_value_init Ptr GValue
ptr CGType
gtype
Ptr GValue -> Ptr GValue -> IO ()
g_value_copy Ptr GValue
x Ptr GValue
ptr
Ptr GValue -> [Ptr GValue] -> IO ()
fill (Ptr GValue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
cgvalueSize) [Ptr GValue]
xs
unpackGValueArrayWithLength :: Integral a =>
a -> Ptr GValue -> IO [GValue]
unpackGValueArrayWithLength :: forall a. Integral a => a -> Ptr GValue -> IO [GValue]
unpackGValueArrayWithLength a
nitems Ptr GValue
gvalues = Int -> Ptr GValue -> IO [GValue]
go (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
nitems) Ptr GValue
gvalues
where go :: Int -> Ptr GValue -> IO [GValue]
go :: Int -> Ptr GValue -> IO [GValue]
go Int
0 Ptr GValue
_ = forall (m :: * -> *) a. Monad m => a -> m a
return []
go Int
n Ptr GValue
ptr = do
Ptr GValue
gv <- forall a. Int -> IO (Ptr a)
callocBytes Int
cgvalueSize
CGType
gtype <- Ptr GValue -> IO CGType
g_value_get_type Ptr GValue
ptr
Ptr GValue
_ <- Ptr GValue -> CGType -> IO (Ptr GValue)
g_value_init Ptr GValue
gv CGType
gtype
Ptr GValue -> Ptr GValue -> IO ()
g_value_copy Ptr GValue
ptr Ptr GValue
gv
GValue
wrapped <- Ptr GValue -> IO GValue
wrapGValuePtr Ptr GValue
gv
(GValue
wrapped forall a. a -> [a] -> [a]
:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Ptr GValue -> IO [GValue]
go (Int
nforall a. Num a => a -> a -> a
-Int
1) (Ptr GValue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
cgvalueSize)
mapGValueArrayWithLength :: Integral a =>
a -> (Ptr GValue -> IO c) -> Ptr GValue -> IO ()
mapGValueArrayWithLength :: forall a c.
Integral a =>
a -> (Ptr GValue -> IO c) -> Ptr GValue -> IO ()
mapGValueArrayWithLength a
nvalues Ptr GValue -> IO c
f Ptr GValue
arrayPtr
| (Ptr GValue
arrayPtr forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) = forall (m :: * -> *) a. Monad m => a -> m a
return ()
| (a
nvalues forall a. Ord a => a -> a -> Bool
<= a
0) = forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Bool
otherwise = Int -> Ptr GValue -> IO ()
go (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
nvalues) Ptr GValue
arrayPtr
where go :: Int -> Ptr GValue -> IO ()
go :: Int -> Ptr GValue -> IO ()
go Int
0 Ptr GValue
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()
go Int
n Ptr GValue
ptr = do
c
_ <- Ptr GValue -> IO c
f Ptr GValue
ptr
Int -> Ptr GValue -> IO ()
go (Int
nforall a. Num a => a -> a -> a
-Int
1) (Ptr GValue
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
cgvalueSize)