{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Structs.Units
(
Units(..) ,
newZeroUnits ,
#if defined(ENABLE_OVERLOADING)
ResolveUnitsMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
UnitsCopyMethodInfo ,
#endif
unitsCopy ,
#if defined(ENABLE_OVERLOADING)
UnitsFreeMethodInfo ,
#endif
unitsFree ,
unitsFromCm ,
unitsFromEm ,
unitsFromEmForFont ,
unitsFromMm ,
unitsFromPixels ,
unitsFromPt ,
unitsFromString ,
#if defined(ENABLE_OVERLOADING)
UnitsGetUnitTypeMethodInfo ,
#endif
unitsGetUnitType ,
#if defined(ENABLE_OVERLOADING)
UnitsGetUnitValueMethodInfo ,
#endif
unitsGetUnitValue ,
#if defined(ENABLE_OVERLOADING)
UnitsToPixelsMethodInfo ,
#endif
unitsToPixels ,
#if defined(ENABLE_OVERLOADING)
UnitsToStringMethodInfo ,
#endif
unitsToString ,
) 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 {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
newtype Units = Units (SP.ManagedPtr Units)
deriving (Units -> Units -> Bool
(Units -> Units -> Bool) -> (Units -> Units -> Bool) -> Eq Units
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Units -> Units -> Bool
== :: Units -> Units -> Bool
$c/= :: Units -> Units -> Bool
/= :: Units -> Units -> Bool
Eq)
instance SP.ManagedPtrNewtype Units where
toManagedPtr :: Units -> ManagedPtr Units
toManagedPtr (Units ManagedPtr Units
p) = ManagedPtr Units
p
foreign import ccall "clutter_units_get_type" c_clutter_units_get_type ::
IO GType
type instance O.ParentTypes Units = '[]
instance O.HasParentTypes Units
instance B.Types.TypedObject Units where
glibType :: IO GType
glibType = IO GType
c_clutter_units_get_type
instance B.Types.GBoxed Units
instance B.GValue.IsGValue (Maybe Units) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_units_get_type
gvalueSet_ :: Ptr GValue -> Maybe Units -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Units
P.Nothing = Ptr GValue -> Ptr Units -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Units
forall a. Ptr a
FP.nullPtr :: FP.Ptr Units)
gvalueSet_ Ptr GValue
gv (P.Just Units
obj) = Units -> (Ptr Units -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Units
obj (Ptr GValue -> Ptr Units -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Units)
gvalueGet_ Ptr GValue
gv = do
Ptr Units
ptr <- Ptr GValue -> IO (Ptr Units)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Units)
if Ptr Units
ptr Ptr Units -> Ptr Units -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Units
forall a. Ptr a
FP.nullPtr
then Units -> Maybe Units
forall a. a -> Maybe a
P.Just (Units -> Maybe Units) -> IO Units -> IO (Maybe Units)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Units -> Units
Units Ptr Units
ptr
else Maybe Units -> IO (Maybe Units)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Units
forall a. Maybe a
P.Nothing
newZeroUnits :: MonadIO m => m Units
newZeroUnits :: forall (m :: * -> *). MonadIO m => m Units
newZeroUnits = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
32 IO (Ptr Units) -> (Ptr Units -> IO Units) -> IO Units
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units
instance tag ~ 'AttrSet => Constructible Units tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Units -> Units) -> [AttrOp Units tag] -> m Units
new ManagedPtr Units -> Units
_ [AttrOp Units tag]
attrs = do
Units
o <- m Units
forall (m :: * -> *). MonadIO m => m Units
newZeroUnits
Units -> [AttrOp Units 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Units
o [AttrOp Units tag]
[AttrOp Units 'AttrSet]
attrs
Units -> m Units
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Units
type instance O.AttributeList Units = UnitsAttributeList
type UnitsAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_units_copy" clutter_units_copy ::
Ptr Units ->
IO (Ptr Units)
unitsCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Units
-> m Units
unitsCopy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Units -> m Units
unitsCopy Units
units = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units' <- Units -> IO (Ptr Units)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Units
units
Ptr Units
result <- Ptr Units -> IO (Ptr Units)
clutter_units_copy Ptr Units
units'
Text -> Ptr Units -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unitsCopy" Ptr Units
result
Units
result' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
result
Units -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Units
units
Units -> IO Units
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
result'
#if defined(ENABLE_OVERLOADING)
data UnitsCopyMethodInfo
instance (signature ~ (m Units), MonadIO m) => O.OverloadedMethod UnitsCopyMethodInfo Units signature where
overloadedMethod = unitsCopy
instance O.OverloadedMethodInfo UnitsCopyMethodInfo Units where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Units.unitsCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Units.html#v:unitsCopy"
})
#endif
foreign import ccall "clutter_units_free" clutter_units_free ::
Ptr Units ->
IO ()
unitsFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Units
-> m ()
unitsFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Units -> m ()
unitsFree Units
units = 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
$ do
Ptr Units
units' <- Units -> IO (Ptr Units)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Units
units
Ptr Units -> IO ()
clutter_units_free Ptr Units
units'
Units -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Units
units
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UnitsFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod UnitsFreeMethodInfo Units signature where
overloadedMethod = unitsFree
instance O.OverloadedMethodInfo UnitsFreeMethodInfo Units where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Units.unitsFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Units.html#v:unitsFree"
})
#endif
foreign import ccall "clutter_units_get_unit_type" clutter_units_get_unit_type ::
Ptr Units ->
IO CUInt
unitsGetUnitType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Units
-> m Clutter.Enums.UnitType
unitsGetUnitType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Units -> m UnitType
unitsGetUnitType Units
units = IO UnitType -> m UnitType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UnitType -> m UnitType) -> IO UnitType -> m UnitType
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units' <- Units -> IO (Ptr Units)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Units
units
CUInt
result <- Ptr Units -> IO CUInt
clutter_units_get_unit_type Ptr Units
units'
let result' :: UnitType
result' = (Int -> UnitType
forall a. Enum a => Int -> a
toEnum (Int -> UnitType) -> (CUInt -> Int) -> CUInt -> UnitType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Units -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Units
units
UnitType -> IO UnitType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return UnitType
result'
#if defined(ENABLE_OVERLOADING)
data UnitsGetUnitTypeMethodInfo
instance (signature ~ (m Clutter.Enums.UnitType), MonadIO m) => O.OverloadedMethod UnitsGetUnitTypeMethodInfo Units signature where
overloadedMethod = unitsGetUnitType
instance O.OverloadedMethodInfo UnitsGetUnitTypeMethodInfo Units where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Units.unitsGetUnitType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Units.html#v:unitsGetUnitType"
})
#endif
foreign import ccall "clutter_units_get_unit_value" clutter_units_get_unit_value ::
Ptr Units ->
IO CFloat
unitsGetUnitValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
Units
-> m Float
unitsGetUnitValue :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Units -> m Float
unitsGetUnitValue Units
units = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units' <- Units -> IO (Ptr Units)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Units
units
CFloat
result <- Ptr Units -> IO CFloat
clutter_units_get_unit_value Ptr Units
units'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Units -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Units
units
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data UnitsGetUnitValueMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod UnitsGetUnitValueMethodInfo Units signature where
overloadedMethod = unitsGetUnitValue
instance O.OverloadedMethodInfo UnitsGetUnitValueMethodInfo Units where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Units.unitsGetUnitValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Units.html#v:unitsGetUnitValue"
})
#endif
foreign import ccall "clutter_units_to_pixels" clutter_units_to_pixels ::
Ptr Units ->
IO CFloat
unitsToPixels ::
(B.CallStack.HasCallStack, MonadIO m) =>
Units
-> m Float
unitsToPixels :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Units -> m Float
unitsToPixels Units
units = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units' <- Units -> IO (Ptr Units)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Units
units
CFloat
result <- Ptr Units -> IO CFloat
clutter_units_to_pixels Ptr Units
units'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Units -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Units
units
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data UnitsToPixelsMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod UnitsToPixelsMethodInfo Units signature where
overloadedMethod = unitsToPixels
instance O.OverloadedMethodInfo UnitsToPixelsMethodInfo Units where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Units.unitsToPixels",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Units.html#v:unitsToPixels"
})
#endif
foreign import ccall "clutter_units_to_string" clutter_units_to_string ::
Ptr Units ->
IO CString
unitsToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Units
-> m T.Text
unitsToString :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Units -> m Text
unitsToString Units
units = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units' <- Units -> IO (Ptr Units)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Units
units
CString
result <- Ptr Units -> IO CString
clutter_units_to_string Ptr Units
units'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unitsToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Units -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Units
units
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data UnitsToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod UnitsToStringMethodInfo Units signature where
overloadedMethod = unitsToString
instance O.OverloadedMethodInfo UnitsToStringMethodInfo Units where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Units.unitsToString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Units.html#v:unitsToString"
})
#endif
foreign import ccall "clutter_units_from_cm" clutter_units_from_cm ::
Ptr Units ->
CFloat ->
IO ()
unitsFromCm ::
(B.CallStack.HasCallStack, MonadIO m) =>
Float
-> m (Units)
unitsFromCm :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Float -> m Units
unitsFromCm Float
cm = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units <- Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Units)
let cm' :: CFloat
cm' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
cm
Ptr Units -> CFloat -> IO ()
clutter_units_from_cm Ptr Units
units CFloat
cm'
Units
units' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
units
Units -> IO Units
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
units'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_units_from_em" clutter_units_from_em ::
Ptr Units ->
CFloat ->
IO ()
unitsFromEm ::
(B.CallStack.HasCallStack, MonadIO m) =>
Float
-> m (Units)
unitsFromEm :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Float -> m Units
unitsFromEm Float
em = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units <- Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Units)
let em' :: CFloat
em' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
em
Ptr Units -> CFloat -> IO ()
clutter_units_from_em Ptr Units
units CFloat
em'
Units
units' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
units
Units -> IO Units
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
units'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_units_from_em_for_font" clutter_units_from_em_for_font ::
Ptr Units ->
CString ->
CFloat ->
IO ()
unitsFromEmForFont ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> Float
-> m (Units)
unitsFromEmForFont :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> Float -> m Units
unitsFromEmForFont Maybe Text
fontName Float
em = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units <- Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Units)
CString
maybeFontName <- case Maybe Text
fontName of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jFontName -> do
CString
jFontName' <- Text -> IO CString
textToCString Text
jFontName
CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontName'
let em' :: CFloat
em' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
em
Ptr Units -> CString -> CFloat -> IO ()
clutter_units_from_em_for_font Ptr Units
units CString
maybeFontName CFloat
em'
Units
units' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
units
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontName
Units -> IO Units
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
units'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_units_from_mm" clutter_units_from_mm ::
Ptr Units ->
CFloat ->
IO ()
unitsFromMm ::
(B.CallStack.HasCallStack, MonadIO m) =>
Float
-> m (Units)
unitsFromMm :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Float -> m Units
unitsFromMm Float
mm = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units <- Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Units)
let mm' :: CFloat
mm' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
mm
Ptr Units -> CFloat -> IO ()
clutter_units_from_mm Ptr Units
units CFloat
mm'
Units
units' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
units
Units -> IO Units
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
units'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_units_from_pixels" clutter_units_from_pixels ::
Ptr Units ->
Int32 ->
IO ()
unitsFromPixels ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> m (Units)
unitsFromPixels :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Int32 -> m Units
unitsFromPixels Int32
px = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units <- Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Units)
Ptr Units -> Int32 -> IO ()
clutter_units_from_pixels Ptr Units
units Int32
px
Units
units' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
units
Units -> IO Units
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
units'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_units_from_pt" clutter_units_from_pt ::
Ptr Units ->
CFloat ->
IO ()
unitsFromPt ::
(B.CallStack.HasCallStack, MonadIO m) =>
Float
-> m (Units)
unitsFromPt :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Float -> m Units
unitsFromPt Float
pt = IO Units -> m Units
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Units -> m Units) -> IO Units -> m Units
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units <- Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Units)
let pt' :: CFloat
pt' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
pt
Ptr Units -> CFloat -> IO ()
clutter_units_from_pt Ptr Units
units CFloat
pt'
Units
units' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
units
Units -> IO Units
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Units
units'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_units_from_string" clutter_units_from_string ::
Ptr Units ->
CString ->
IO CInt
unitsFromString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((Bool, Units))
unitsFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Bool, Units)
unitsFromString Text
str = IO (Bool, Units) -> m (Bool, Units)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Units) -> m (Bool, Units))
-> IO (Bool, Units) -> m (Bool, Units)
forall a b. (a -> b) -> a -> b
$ do
Ptr Units
units <- Int -> IO (Ptr Units)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Units)
CString
str' <- Text -> IO CString
textToCString Text
str
CInt
result <- Ptr Units -> CString -> IO CInt
clutter_units_from_string Ptr Units
units CString
str'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Units
units' <- ((ManagedPtr Units -> Units) -> Ptr Units -> IO Units
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Units -> Units
Units) Ptr Units
units
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
(Bool, Units) -> IO (Bool, Units)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Units
units')
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveUnitsMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveUnitsMethod "copy" o = UnitsCopyMethodInfo
ResolveUnitsMethod "free" o = UnitsFreeMethodInfo
ResolveUnitsMethod "toPixels" o = UnitsToPixelsMethodInfo
ResolveUnitsMethod "toString" o = UnitsToStringMethodInfo
ResolveUnitsMethod "getUnitType" o = UnitsGetUnitTypeMethodInfo
ResolveUnitsMethod "getUnitValue" o = UnitsGetUnitValueMethodInfo
ResolveUnitsMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveUnitsMethod t Units, O.OverloadedMethod info Units p) => OL.IsLabel t (Units -> 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 ~ ResolveUnitsMethod t Units, O.OverloadedMethod info Units p, R.HasField t Units p) => R.HasField t Units p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveUnitsMethod t Units, O.OverloadedMethodInfo info Units) => OL.IsLabel t (O.MethodProxy info Units) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif