{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gsk.Structs.Transform
(
Transform(..) ,
noTransform ,
#if defined(ENABLE_OVERLOADING)
ResolveTransformMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TransformEqualMethodInfo ,
#endif
transformEqual ,
#if defined(ENABLE_OVERLOADING)
TransformGetCategoryMethodInfo ,
#endif
transformGetCategory ,
#if defined(ENABLE_OVERLOADING)
TransformInvertMethodInfo ,
#endif
transformInvert ,
#if defined(ENABLE_OVERLOADING)
TransformMatrixMethodInfo ,
#endif
transformMatrix ,
transformNew ,
transformNodeGetChild ,
transformNodeGetTransform ,
transformNodeNew ,
transformParse ,
#if defined(ENABLE_OVERLOADING)
TransformPerspectiveMethodInfo ,
#endif
transformPerspective ,
#if defined(ENABLE_OVERLOADING)
TransformPrintMethodInfo ,
#endif
transformPrint ,
#if defined(ENABLE_OVERLOADING)
TransformRefMethodInfo ,
#endif
transformRef ,
#if defined(ENABLE_OVERLOADING)
TransformRotateMethodInfo ,
#endif
transformRotate ,
#if defined(ENABLE_OVERLOADING)
TransformRotate3dMethodInfo ,
#endif
transformRotate3d ,
#if defined(ENABLE_OVERLOADING)
TransformScaleMethodInfo ,
#endif
transformScale ,
#if defined(ENABLE_OVERLOADING)
TransformScale3dMethodInfo ,
#endif
transformScale3d ,
#if defined(ENABLE_OVERLOADING)
TransformTo2dMethodInfo ,
#endif
transformTo2d ,
#if defined(ENABLE_OVERLOADING)
TransformToAffineMethodInfo ,
#endif
transformToAffine ,
#if defined(ENABLE_OVERLOADING)
TransformToMatrixMethodInfo ,
#endif
transformToMatrix ,
#if defined(ENABLE_OVERLOADING)
TransformToStringMethodInfo ,
#endif
transformToString ,
#if defined(ENABLE_OVERLOADING)
TransformToTranslateMethodInfo ,
#endif
transformToTranslate ,
#if defined(ENABLE_OVERLOADING)
TransformTransformMethodInfo ,
#endif
transformTransform ,
#if defined(ENABLE_OVERLOADING)
TransformTransformBoundsMethodInfo ,
#endif
transformTransformBounds ,
#if defined(ENABLE_OVERLOADING)
TransformTranslateMethodInfo ,
#endif
transformTranslate ,
#if defined(ENABLE_OVERLOADING)
TransformTranslate3dMethodInfo ,
#endif
transformTranslate3d ,
#if defined(ENABLE_OVERLOADING)
TransformUnrefMethodInfo ,
#endif
transformUnref ,
) 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.GClosure as B.GClosure
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.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
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 GI.GLib.Structs.String as GLib.String
import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums
import {-# SOURCE #-} qualified GI.Gsk.Structs.RenderNode as Gsk.RenderNode
newtype Transform = Transform (ManagedPtr Transform)
deriving (Transform -> Transform -> Bool
(Transform -> Transform -> Bool)
-> (Transform -> Transform -> Bool) -> Eq Transform
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Transform -> Transform -> Bool
$c/= :: Transform -> Transform -> Bool
== :: Transform -> Transform -> Bool
$c== :: Transform -> Transform -> Bool
Eq)
foreign import ccall "gsk_transform_get_type" c_gsk_transform_get_type ::
IO GType
instance BoxedObject Transform where
boxedType :: Transform -> IO GType
boxedType _ = IO GType
c_gsk_transform_get_type
instance B.GValue.IsGValue Transform where
toGValue :: Transform -> IO GValue
toGValue o :: Transform
o = do
GType
gtype <- IO GType
c_gsk_transform_get_type
Transform -> (Ptr Transform -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Transform
o (GType
-> (GValue -> Ptr Transform -> IO ()) -> Ptr Transform -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Transform -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Transform
fromGValue gv :: GValue
gv = do
Ptr Transform
ptr <- GValue -> IO (Ptr Transform)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Transform)
(ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Transform -> Transform
Transform Ptr Transform
ptr
noTransform :: Maybe Transform
noTransform :: Maybe Transform
noTransform = Maybe Transform
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Transform
type instance O.AttributeList Transform = TransformAttributeList
type TransformAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gsk_transform_new" gsk_transform_new ::
IO (Ptr Transform)
transformNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Transform
transformNew :: m Transform
transformNew = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
result <- IO (Ptr Transform)
gsk_transform_new
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformNew" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gsk_transform_equal" gsk_transform_equal ::
Ptr Transform ->
Ptr Transform ->
IO CInt
transformEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Transform
-> m Bool
transformEqual :: Transform -> Transform -> m Bool
transformEqual first :: Transform
first second :: Transform
second = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
first' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
first
Ptr Transform
second' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
second
CInt
result <- Ptr Transform -> Ptr Transform -> IO CInt
gsk_transform_equal Ptr Transform
first' Ptr Transform
second'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
first
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
second
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TransformEqualMethodInfo
instance (signature ~ (Transform -> m Bool), MonadIO m) => O.MethodInfo TransformEqualMethodInfo Transform signature where
overloadedMethod = transformEqual
#endif
foreign import ccall "gsk_transform_get_category" gsk_transform_get_category ::
Ptr Transform ->
IO CUInt
transformGetCategory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m Gsk.Enums.TransformCategory
transformGetCategory :: Transform -> m TransformCategory
transformGetCategory self :: Transform
self = IO TransformCategory -> m TransformCategory
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TransformCategory -> m TransformCategory)
-> IO TransformCategory -> m TransformCategory
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
CUInt
result <- Ptr Transform -> IO CUInt
gsk_transform_get_category Ptr Transform
self'
let result' :: TransformCategory
result' = (Int -> TransformCategory
forall a. Enum a => Int -> a
toEnum (Int -> TransformCategory)
-> (CUInt -> Int) -> CUInt -> TransformCategory
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
TransformCategory -> IO TransformCategory
forall (m :: * -> *) a. Monad m => a -> m a
return TransformCategory
result'
#if defined(ENABLE_OVERLOADING)
data TransformGetCategoryMethodInfo
instance (signature ~ (m Gsk.Enums.TransformCategory), MonadIO m) => O.MethodInfo TransformGetCategoryMethodInfo Transform signature where
overloadedMethod = transformGetCategory
#endif
foreign import ccall "gsk_transform_invert" gsk_transform_invert ::
Ptr Transform ->
IO (Ptr Transform)
transformInvert ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m Transform
transformInvert :: Transform -> m Transform
transformInvert self :: Transform
self = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Transform
self
Ptr Transform
result <- Ptr Transform -> IO (Ptr Transform)
gsk_transform_invert Ptr Transform
self'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformInvert" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformInvertMethodInfo
instance (signature ~ (m Transform), MonadIO m) => O.MethodInfo TransformInvertMethodInfo Transform signature where
overloadedMethod = transformInvert
#endif
foreign import ccall "gsk_transform_matrix" gsk_transform_matrix ::
Ptr Transform ->
Ptr Graphene.Matrix.Matrix ->
IO (Ptr Transform)
transformMatrix ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Graphene.Matrix.Matrix
-> m Transform
transformMatrix :: Transform -> Matrix -> m Transform
transformMatrix next :: Transform
next matrix :: Matrix
matrix = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
Ptr Matrix
matrix' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
matrix
Ptr Transform
result <- Ptr Transform -> Ptr Matrix -> IO (Ptr Transform)
gsk_transform_matrix Ptr Transform
next' Ptr Matrix
matrix'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformMatrix" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Matrix -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Matrix
matrix
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformMatrixMethodInfo
instance (signature ~ (Graphene.Matrix.Matrix -> m Transform), MonadIO m) => O.MethodInfo TransformMatrixMethodInfo Transform signature where
overloadedMethod = transformMatrix
#endif
foreign import ccall "gsk_transform_perspective" gsk_transform_perspective ::
Ptr Transform ->
CFloat ->
IO (Ptr Transform)
transformPerspective ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Float
-> m Transform
transformPerspective :: Transform -> Float -> m Transform
transformPerspective next :: Transform
next depth :: Float
depth = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
let depth' :: CFloat
depth' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
depth
Ptr Transform
result <- Ptr Transform -> CFloat -> IO (Ptr Transform)
gsk_transform_perspective Ptr Transform
next' CFloat
depth'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformPerspective" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformPerspectiveMethodInfo
instance (signature ~ (Float -> m Transform), MonadIO m) => O.MethodInfo TransformPerspectiveMethodInfo Transform signature where
overloadedMethod = transformPerspective
#endif
foreign import ccall "gsk_transform_print" gsk_transform_print ::
Ptr Transform ->
Ptr GLib.String.String ->
IO ()
transformPrint ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> GLib.String.String
-> m ()
transformPrint :: Transform -> String -> m ()
transformPrint self :: Transform
self string :: String
string = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr String
string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr Transform -> Ptr String -> IO ()
gsk_transform_print Ptr Transform
self' Ptr String
string'
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TransformPrintMethodInfo
instance (signature ~ (GLib.String.String -> m ()), MonadIO m) => O.MethodInfo TransformPrintMethodInfo Transform signature where
overloadedMethod = transformPrint
#endif
foreign import ccall "gsk_transform_ref" gsk_transform_ref ::
Ptr Transform ->
IO (Ptr Transform)
transformRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m Transform
transformRef :: Transform -> m Transform
transformRef self :: Transform
self = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr Transform
result <- Ptr Transform -> IO (Ptr Transform)
gsk_transform_ref Ptr Transform
self'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformRef" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformRefMethodInfo
instance (signature ~ (m Transform), MonadIO m) => O.MethodInfo TransformRefMethodInfo Transform signature where
overloadedMethod = transformRef
#endif
foreign import ccall "gsk_transform_rotate" gsk_transform_rotate ::
Ptr Transform ->
CFloat ->
IO (Ptr Transform)
transformRotate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Float
-> m Transform
transformRotate :: Transform -> Float -> m Transform
transformRotate next :: Transform
next angle :: Float
angle = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
let angle' :: CFloat
angle' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
angle
Ptr Transform
result <- Ptr Transform -> CFloat -> IO (Ptr Transform)
gsk_transform_rotate Ptr Transform
next' CFloat
angle'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformRotate" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformRotateMethodInfo
instance (signature ~ (Float -> m Transform), MonadIO m) => O.MethodInfo TransformRotateMethodInfo Transform signature where
overloadedMethod = transformRotate
#endif
foreign import ccall "gsk_transform_rotate_3d" gsk_transform_rotate_3d ::
Ptr Transform ->
CFloat ->
Ptr Graphene.Vec3.Vec3 ->
IO (Ptr Transform)
transformRotate3d ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Float
-> Graphene.Vec3.Vec3
-> m Transform
transformRotate3d :: Transform -> Float -> Vec3 -> m Transform
transformRotate3d next :: Transform
next angle :: Float
angle axis :: Vec3
axis = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
let angle' :: CFloat
angle' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
angle
Ptr Vec3
axis' <- Vec3 -> IO (Ptr Vec3)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec3
axis
Ptr Transform
result <- Ptr Transform -> CFloat -> Ptr Vec3 -> IO (Ptr Transform)
gsk_transform_rotate_3d Ptr Transform
next' CFloat
angle' Ptr Vec3
axis'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformRotate3d" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Vec3 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Vec3
axis
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformRotate3dMethodInfo
instance (signature ~ (Float -> Graphene.Vec3.Vec3 -> m Transform), MonadIO m) => O.MethodInfo TransformRotate3dMethodInfo Transform signature where
overloadedMethod = transformRotate3d
#endif
foreign import ccall "gsk_transform_scale" gsk_transform_scale ::
Ptr Transform ->
CFloat ->
CFloat ->
IO (Ptr Transform)
transformScale ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Float
-> Float
-> m Transform
transformScale :: Transform -> Float -> Float -> m Transform
transformScale next :: Transform
next factorX :: Float
factorX factorY :: Float
factorY = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
let factorX' :: CFloat
factorX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorX
let factorY' :: CFloat
factorY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorY
Ptr Transform
result <- Ptr Transform -> CFloat -> CFloat -> IO (Ptr Transform)
gsk_transform_scale Ptr Transform
next' CFloat
factorX' CFloat
factorY'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformScale" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformScaleMethodInfo
instance (signature ~ (Float -> Float -> m Transform), MonadIO m) => O.MethodInfo TransformScaleMethodInfo Transform signature where
overloadedMethod = transformScale
#endif
foreign import ccall "gsk_transform_scale_3d" gsk_transform_scale_3d ::
Ptr Transform ->
CFloat ->
CFloat ->
CFloat ->
IO (Ptr Transform)
transformScale3d ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Float
-> Float
-> Float
-> m Transform
transformScale3d :: Transform -> Float -> Float -> Float -> m Transform
transformScale3d next :: Transform
next factorX :: Float
factorX factorY :: Float
factorY factorZ :: Float
factorZ = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
let factorX' :: CFloat
factorX' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorX
let factorY' :: CFloat
factorY' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorY
let factorZ' :: CFloat
factorZ' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
factorZ
Ptr Transform
result <- Ptr Transform -> CFloat -> CFloat -> CFloat -> IO (Ptr Transform)
gsk_transform_scale_3d Ptr Transform
next' CFloat
factorX' CFloat
factorY' CFloat
factorZ'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformScale3d" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformScale3dMethodInfo
instance (signature ~ (Float -> Float -> Float -> m Transform), MonadIO m) => O.MethodInfo TransformScale3dMethodInfo Transform signature where
overloadedMethod = transformScale3d
#endif
foreign import ccall "gsk_transform_to_2d" gsk_transform_to_2d ::
Ptr Transform ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
IO ()
transformTo2d ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m ((Float, Float, Float, Float, Float, Float))
transformTo2d :: Transform -> m (Float, Float, Float, Float, Float, Float)
transformTo2d self :: Transform
self = IO (Float, Float, Float, Float, Float, Float)
-> m (Float, Float, Float, Float, Float, Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float, Float, Float, Float)
-> m (Float, Float, Float, Float, Float, Float))
-> IO (Float, Float, Float, Float, Float, Float)
-> m (Float, Float, Float, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr CFloat
outXx <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outYx <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outXy <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outYy <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outDx <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outDy <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr Transform
-> Ptr CFloat
-> Ptr CFloat
-> Ptr CFloat
-> Ptr CFloat
-> Ptr CFloat
-> Ptr CFloat
-> IO ()
gsk_transform_to_2d Ptr Transform
self' Ptr CFloat
outXx Ptr CFloat
outYx Ptr CFloat
outXy Ptr CFloat
outYy Ptr CFloat
outDx Ptr CFloat
outDy
CFloat
outXx' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outXx
let outXx'' :: Float
outXx'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outXx'
CFloat
outYx' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outYx
let outYx'' :: Float
outYx'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outYx'
CFloat
outXy' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outXy
let outXy'' :: Float
outXy'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outXy'
CFloat
outYy' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outYy
let outYy'' :: Float
outYy'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outYy'
CFloat
outDx' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outDx
let outDx'' :: Float
outDx'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outDx'
CFloat
outDy' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outDy
let outDy'' :: Float
outDy'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outDy'
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outXx
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outYx
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outXy
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outYy
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outDx
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outDy
(Float, Float, Float, Float, Float, Float)
-> IO (Float, Float, Float, Float, Float, Float)
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
outXx'', Float
outYx'', Float
outXy'', Float
outYy'', Float
outDx'', Float
outDy'')
#if defined(ENABLE_OVERLOADING)
data TransformTo2dMethodInfo
instance (signature ~ (m ((Float, Float, Float, Float, Float, Float))), MonadIO m) => O.MethodInfo TransformTo2dMethodInfo Transform signature where
overloadedMethod = transformTo2d
#endif
foreign import ccall "gsk_transform_to_affine" gsk_transform_to_affine ::
Ptr Transform ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
IO ()
transformToAffine ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m ((Float, Float, Float, Float))
transformToAffine :: Transform -> m (Float, Float, Float, Float)
transformToAffine self :: Transform
self = IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float))
-> IO (Float, Float, Float, Float)
-> m (Float, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr CFloat
outScaleX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outScaleY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outDx <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outDy <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr Transform
-> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
gsk_transform_to_affine Ptr Transform
self' Ptr CFloat
outScaleX Ptr CFloat
outScaleY Ptr CFloat
outDx Ptr CFloat
outDy
CFloat
outScaleX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outScaleX
let outScaleX'' :: Float
outScaleX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outScaleX'
CFloat
outScaleY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outScaleY
let outScaleY'' :: Float
outScaleY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outScaleY'
CFloat
outDx' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outDx
let outDx'' :: Float
outDx'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outDx'
CFloat
outDy' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outDy
let outDy'' :: Float
outDy'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outDy'
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outScaleX
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outScaleY
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outDx
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outDy
(Float, Float, Float, Float) -> IO (Float, Float, Float, Float)
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
outScaleX'', Float
outScaleY'', Float
outDx'', Float
outDy'')
#if defined(ENABLE_OVERLOADING)
data TransformToAffineMethodInfo
instance (signature ~ (m ((Float, Float, Float, Float))), MonadIO m) => O.MethodInfo TransformToAffineMethodInfo Transform signature where
overloadedMethod = transformToAffine
#endif
foreign import ccall "gsk_transform_to_matrix" gsk_transform_to_matrix ::
Ptr Transform ->
Ptr Graphene.Matrix.Matrix ->
IO ()
transformToMatrix ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m (Graphene.Matrix.Matrix)
transformToMatrix :: Transform -> m Matrix
transformToMatrix self :: Transform
self = IO Matrix -> m Matrix
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr Matrix
outMatrix <- Int -> IO (Ptr Matrix)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 64 :: IO (Ptr Graphene.Matrix.Matrix)
Ptr Transform -> Ptr Matrix -> IO ()
gsk_transform_to_matrix Ptr Transform
self' Ptr Matrix
outMatrix
Matrix
outMatrix' <- ((ManagedPtr Matrix -> Matrix) -> Ptr Matrix -> IO Matrix
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Matrix -> Matrix
Graphene.Matrix.Matrix) Ptr Matrix
outMatrix
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Matrix -> IO Matrix
forall (m :: * -> *) a. Monad m => a -> m a
return Matrix
outMatrix'
#if defined(ENABLE_OVERLOADING)
data TransformToMatrixMethodInfo
instance (signature ~ (m (Graphene.Matrix.Matrix)), MonadIO m) => O.MethodInfo TransformToMatrixMethodInfo Transform signature where
overloadedMethod = transformToMatrix
#endif
foreign import ccall "gsk_transform_to_string" gsk_transform_to_string ::
Ptr Transform ->
IO CString
transformToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m T.Text
transformToString :: Transform -> m Text
transformToString self :: Transform
self = IO Text -> m Text
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 Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
CString
result <- Ptr Transform -> IO CString
gsk_transform_to_string Ptr Transform
self'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data TransformToStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo TransformToStringMethodInfo Transform signature where
overloadedMethod = transformToString
#endif
foreign import ccall "gsk_transform_to_translate" gsk_transform_to_translate ::
Ptr Transform ->
Ptr CFloat ->
Ptr CFloat ->
IO ()
transformToTranslate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m ((Float, Float))
transformToTranslate :: Transform -> m (Float, Float)
transformToTranslate self :: Transform
self = IO (Float, Float) -> m (Float, Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr CFloat
outDx <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
outDy <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr Transform -> Ptr CFloat -> Ptr CFloat -> IO ()
gsk_transform_to_translate Ptr Transform
self' Ptr CFloat
outDx Ptr CFloat
outDy
CFloat
outDx' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outDx
let outDx'' :: Float
outDx'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outDx'
CFloat
outDy' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
outDy
let outDy'' :: Float
outDy'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
outDy'
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outDx
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
outDy
(Float, Float) -> IO (Float, Float)
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
outDx'', Float
outDy'')
#if defined(ENABLE_OVERLOADING)
data TransformToTranslateMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m) => O.MethodInfo TransformToTranslateMethodInfo Transform signature where
overloadedMethod = transformToTranslate
#endif
foreign import ccall "gsk_transform_transform" gsk_transform_transform ::
Ptr Transform ->
Ptr Transform ->
IO (Ptr Transform)
transformTransform ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Maybe (Transform)
-> m Transform
transformTransform :: Transform -> Maybe Transform -> m Transform
transformTransform next :: Transform
next other :: Maybe Transform
other = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Transform
next
Ptr Transform
maybeOther <- case Maybe Transform
other of
Nothing -> Ptr Transform -> IO (Ptr Transform)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Transform
forall a. Ptr a
nullPtr
Just jOther :: Transform
jOther -> do
Ptr Transform
jOther' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
jOther
Ptr Transform -> IO (Ptr Transform)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Transform
jOther'
Ptr Transform
result <- Ptr Transform -> Ptr Transform -> IO (Ptr Transform)
gsk_transform_transform Ptr Transform
next' Ptr Transform
maybeOther
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformTransform" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Maybe Transform -> (Transform -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Transform
other Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformTransformMethodInfo
instance (signature ~ (Maybe (Transform) -> m Transform), MonadIO m) => O.MethodInfo TransformTransformMethodInfo Transform signature where
overloadedMethod = transformTransform
#endif
foreign import ccall "gsk_transform_transform_bounds" gsk_transform_transform_bounds ::
Ptr Transform ->
Ptr Graphene.Rect.Rect ->
Ptr Graphene.Rect.Rect ->
IO ()
transformTransformBounds ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Graphene.Rect.Rect
-> m (Graphene.Rect.Rect)
transformTransformBounds :: Transform -> Rect -> m Rect
transformTransformBounds self :: Transform
self rect :: Rect
rect = IO Rect -> m Rect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr Rect
rect' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
rect
Ptr Rect
outRect <- Int -> IO (Ptr Rect)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
Ptr Transform -> Ptr Rect -> Ptr Rect -> IO ()
gsk_transform_transform_bounds Ptr Transform
self' Ptr Rect
rect' Ptr Rect
outRect
Rect
outRect' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Graphene.Rect.Rect) Ptr Rect
outRect
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
rect
Rect -> IO Rect
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
outRect'
#if defined(ENABLE_OVERLOADING)
data TransformTransformBoundsMethodInfo
instance (signature ~ (Graphene.Rect.Rect -> m (Graphene.Rect.Rect)), MonadIO m) => O.MethodInfo TransformTransformBoundsMethodInfo Transform signature where
overloadedMethod = transformTransformBounds
#endif
foreign import ccall "gsk_transform_translate" gsk_transform_translate ::
Ptr Transform ->
Ptr Graphene.Point.Point ->
IO (Ptr Transform)
transformTranslate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Graphene.Point.Point
-> m Transform
transformTranslate :: Transform -> Point -> m Transform
transformTranslate next :: Transform
next point :: Point
point = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
Ptr Point
point' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
point
Ptr Transform
result <- Ptr Transform -> Ptr Point -> IO (Ptr Transform)
gsk_transform_translate Ptr Transform
next' Ptr Point
point'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformTranslate" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
point
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformTranslateMethodInfo
instance (signature ~ (Graphene.Point.Point -> m Transform), MonadIO m) => O.MethodInfo TransformTranslateMethodInfo Transform signature where
overloadedMethod = transformTranslate
#endif
foreign import ccall "gsk_transform_translate_3d" gsk_transform_translate_3d ::
Ptr Transform ->
Ptr Graphene.Point3D.Point3D ->
IO (Ptr Transform)
transformTranslate3d ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> Graphene.Point3D.Point3D
-> m Transform
transformTranslate3d :: Transform -> Point3D -> m Transform
transformTranslate3d next :: Transform
next point :: Point3D
point = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
next' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
next
Ptr Point3D
point' <- Point3D -> IO (Ptr Point3D)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point3D
point
Ptr Transform
result <- Ptr Transform -> Ptr Point3D -> IO (Ptr Transform)
gsk_transform_translate_3d Ptr Transform
next' Ptr Point3D
point'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformTranslate3d" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
next
Point3D -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point3D
point
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
data TransformTranslate3dMethodInfo
instance (signature ~ (Graphene.Point3D.Point3D -> m Transform), MonadIO m) => O.MethodInfo TransformTranslate3dMethodInfo Transform signature where
overloadedMethod = transformTranslate3d
#endif
foreign import ccall "gsk_transform_unref" gsk_transform_unref ::
Ptr Transform ->
IO ()
transformUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Transform
-> m ()
transformUnref :: Transform -> m ()
transformUnref self :: Transform
self = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Transform
self' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
self
Ptr Transform -> IO ()
gsk_transform_unref Ptr Transform
self'
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
self
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TransformUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TransformUnrefMethodInfo Transform signature where
overloadedMethod = transformUnref
#endif
foreign import ccall "gsk_transform_node_get_child" gsk_transform_node_get_child ::
Ptr Gsk.RenderNode.RenderNode ->
IO (Ptr Gsk.RenderNode.RenderNode)
transformNodeGetChild ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gsk.RenderNode.RenderNode
-> m Gsk.RenderNode.RenderNode
transformNodeGetChild :: RenderNode -> m RenderNode
transformNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_transform_node_get_child Ptr RenderNode
node'
Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformNodeGetChild" Ptr RenderNode
result
RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gsk_transform_node_get_transform" gsk_transform_node_get_transform ::
Ptr Gsk.RenderNode.RenderNode ->
IO (Ptr Transform)
transformNodeGetTransform ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gsk.RenderNode.RenderNode
-> m Transform
transformNodeGetTransform :: RenderNode -> m Transform
transformNodeGetTransform node :: RenderNode
node = IO Transform -> m Transform
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
forall a b. (a -> b) -> a -> b
$ do
Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
Ptr Transform
result <- Ptr RenderNode -> IO (Ptr Transform)
gsk_transform_node_get_transform Ptr RenderNode
node'
Text -> Ptr Transform -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformNodeGetTransform" Ptr Transform
result
Transform
result' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
result
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
Transform -> IO Transform
forall (m :: * -> *) a. Monad m => a -> m a
return Transform
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gsk_transform_node_new" gsk_transform_node_new ::
Ptr Gsk.RenderNode.RenderNode ->
Ptr Transform ->
IO (Ptr Gsk.RenderNode.RenderNode)
transformNodeNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gsk.RenderNode.RenderNode
-> Transform
-> m Gsk.RenderNode.RenderNode
transformNodeNew :: RenderNode -> Transform -> m RenderNode
transformNodeNew child :: RenderNode
child transform :: Transform
transform = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
Ptr Transform
transform' <- Transform -> IO (Ptr Transform)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Transform
transform
Ptr RenderNode
result <- Ptr RenderNode -> Ptr Transform -> IO (Ptr RenderNode)
gsk_transform_node_new Ptr RenderNode
child' Ptr Transform
transform'
Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "transformNodeNew" Ptr RenderNode
result
RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
Transform -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Transform
transform
RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gsk_transform_parse" gsk_transform_parse ::
CString ->
Ptr (Ptr Transform) ->
IO CInt
transformParse ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((Bool, Transform))
transformParse :: Text -> m (Bool, Transform)
transformParse string :: Text
string = IO (Bool, Transform) -> m (Bool, Transform)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Transform) -> m (Bool, Transform))
-> IO (Bool, Transform) -> m (Bool, Transform)
forall a b. (a -> b) -> a -> b
$ do
CString
string' <- Text -> IO CString
textToCString Text
string
Ptr (Ptr Transform)
outTransform <- IO (Ptr (Ptr Transform))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Transform))
CInt
result <- CString -> Ptr (Ptr Transform) -> IO CInt
gsk_transform_parse CString
string' Ptr (Ptr Transform)
outTransform
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Ptr Transform
outTransform' <- Ptr (Ptr Transform) -> IO (Ptr Transform)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Transform)
outTransform
Transform
outTransform'' <- ((ManagedPtr Transform -> Transform)
-> Ptr Transform -> IO Transform
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Transform -> Transform
Transform) Ptr Transform
outTransform'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
string'
Ptr (Ptr Transform) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Transform)
outTransform
(Bool, Transform) -> IO (Bool, Transform)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Transform
outTransform'')
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTransformMethod (t :: Symbol) (o :: *) :: * where
ResolveTransformMethod "equal" o = TransformEqualMethodInfo
ResolveTransformMethod "invert" o = TransformInvertMethodInfo
ResolveTransformMethod "matrix" o = TransformMatrixMethodInfo
ResolveTransformMethod "perspective" o = TransformPerspectiveMethodInfo
ResolveTransformMethod "print" o = TransformPrintMethodInfo
ResolveTransformMethod "ref" o = TransformRefMethodInfo
ResolveTransformMethod "rotate" o = TransformRotateMethodInfo
ResolveTransformMethod "rotate3d" o = TransformRotate3dMethodInfo
ResolveTransformMethod "scale" o = TransformScaleMethodInfo
ResolveTransformMethod "scale3d" o = TransformScale3dMethodInfo
ResolveTransformMethod "to2d" o = TransformTo2dMethodInfo
ResolveTransformMethod "toAffine" o = TransformToAffineMethodInfo
ResolveTransformMethod "toMatrix" o = TransformToMatrixMethodInfo
ResolveTransformMethod "toString" o = TransformToStringMethodInfo
ResolveTransformMethod "toTranslate" o = TransformToTranslateMethodInfo
ResolveTransformMethod "transform" o = TransformTransformMethodInfo
ResolveTransformMethod "transformBounds" o = TransformTransformBoundsMethodInfo
ResolveTransformMethod "translate" o = TransformTranslateMethodInfo
ResolveTransformMethod "translate3d" o = TransformTranslate3dMethodInfo
ResolveTransformMethod "unref" o = TransformUnrefMethodInfo
ResolveTransformMethod "getCategory" o = TransformGetCategoryMethodInfo
ResolveTransformMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTransformMethod t Transform, O.MethodInfo info Transform p) => OL.IsLabel t (Transform -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif