{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Structs.Margin
(
Margin(..) ,
newZeroMargin ,
#if defined(ENABLE_OVERLOADING)
ResolveMarginMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MarginCopyMethodInfo ,
#endif
marginCopy ,
#if defined(ENABLE_OVERLOADING)
MarginFreeMethodInfo ,
#endif
marginFree ,
marginNew ,
getMarginBottom ,
#if defined(ENABLE_OVERLOADING)
margin_bottom ,
#endif
setMarginBottom ,
getMarginLeft ,
#if defined(ENABLE_OVERLOADING)
margin_left ,
#endif
setMarginLeft ,
getMarginRight ,
#if defined(ENABLE_OVERLOADING)
margin_right ,
#endif
setMarginRight ,
getMarginTop ,
#if defined(ENABLE_OVERLOADING)
margin_top ,
#endif
setMarginTop ,
) 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
newtype Margin = Margin (SP.ManagedPtr Margin)
deriving (Margin -> Margin -> Bool
(Margin -> Margin -> Bool)
-> (Margin -> Margin -> Bool) -> Eq Margin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Margin -> Margin -> Bool
== :: Margin -> Margin -> Bool
$c/= :: Margin -> Margin -> Bool
/= :: Margin -> Margin -> Bool
Eq)
instance SP.ManagedPtrNewtype Margin where
toManagedPtr :: Margin -> ManagedPtr Margin
toManagedPtr (Margin ManagedPtr Margin
p) = ManagedPtr Margin
p
foreign import ccall "clutter_margin_get_type" c_clutter_margin_get_type ::
IO GType
type instance O.ParentTypes Margin = '[]
instance O.HasParentTypes Margin
instance B.Types.TypedObject Margin where
glibType :: IO GType
glibType = IO GType
c_clutter_margin_get_type
instance B.Types.GBoxed Margin
instance B.GValue.IsGValue (Maybe Margin) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_margin_get_type
gvalueSet_ :: Ptr GValue -> Maybe Margin -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Margin
P.Nothing = Ptr GValue -> Ptr Margin -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Margin
forall a. Ptr a
FP.nullPtr :: FP.Ptr Margin)
gvalueSet_ Ptr GValue
gv (P.Just Margin
obj) = Margin -> (Ptr Margin -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Margin
obj (Ptr GValue -> Ptr Margin -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Margin)
gvalueGet_ Ptr GValue
gv = do
Ptr Margin
ptr <- Ptr GValue -> IO (Ptr Margin)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Margin)
if Ptr Margin
ptr Ptr Margin -> Ptr Margin -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Margin
forall a. Ptr a
FP.nullPtr
then Margin -> Maybe Margin
forall a. a -> Maybe a
P.Just (Margin -> Maybe Margin) -> IO Margin -> IO (Maybe Margin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Margin -> Margin) -> Ptr Margin -> IO Margin
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Margin -> Margin
Margin Ptr Margin
ptr
else Maybe Margin -> IO (Maybe Margin)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Margin
forall a. Maybe a
P.Nothing
newZeroMargin :: MonadIO m => m Margin
newZeroMargin :: forall (m :: * -> *). MonadIO m => m Margin
newZeroMargin = IO Margin -> m Margin
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Margin -> m Margin) -> IO Margin -> m Margin
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Margin)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 IO (Ptr Margin) -> (Ptr Margin -> IO Margin) -> IO Margin
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Margin -> Margin) -> Ptr Margin -> IO Margin
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Margin -> Margin
Margin
instance tag ~ 'AttrSet => Constructible Margin tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Margin -> Margin) -> [AttrOp Margin tag] -> m Margin
new ManagedPtr Margin -> Margin
_ [AttrOp Margin tag]
attrs = do
Margin
o <- m Margin
forall (m :: * -> *). MonadIO m => m Margin
newZeroMargin
Margin -> [AttrOp Margin 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Margin
o [AttrOp Margin tag]
[AttrOp Margin 'AttrSet]
attrs
Margin -> m Margin
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Margin
o
getMarginLeft :: MonadIO m => Margin -> m Float
getMarginLeft :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginLeft Margin
s = 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
$ Margin -> (Ptr Margin -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO Float) -> IO Float)
-> (Ptr Margin -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CFloat
let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'
setMarginLeft :: MonadIO m => Margin -> Float -> m ()
setMarginLeft :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginLeft Margin
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Margin -> (Ptr Margin -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO ()) -> IO ()) -> (Ptr Margin -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CFloat
val' :: CFloat)
#if defined(ENABLE_OVERLOADING)
data MarginLeftFieldInfo
instance AttrInfo MarginLeftFieldInfo where
type AttrBaseTypeConstraint MarginLeftFieldInfo = (~) Margin
type AttrAllowedOps MarginLeftFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MarginLeftFieldInfo = (~) Float
type AttrTransferTypeConstraint MarginLeftFieldInfo = (~)Float
type AttrTransferType MarginLeftFieldInfo = Float
type AttrGetType MarginLeftFieldInfo = Float
type AttrLabel MarginLeftFieldInfo = "left"
type AttrOrigin MarginLeftFieldInfo = Margin
attrGet = getMarginLeft
attrSet = setMarginLeft
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Margin.left"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Margin.html#g:attr:left"
})
margin_left :: AttrLabelProxy "left"
margin_left = AttrLabelProxy
#endif
getMarginRight :: MonadIO m => Margin -> m Float
getMarginRight :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginRight Margin
s = 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
$ Margin -> (Ptr Margin -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO Float) -> IO Float)
-> (Ptr Margin -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CFloat
let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'
setMarginRight :: MonadIO m => Margin -> Float -> m ()
setMarginRight :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginRight Margin
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Margin -> (Ptr Margin -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO ()) -> IO ()) -> (Ptr Margin -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CFloat
val' :: CFloat)
#if defined(ENABLE_OVERLOADING)
data MarginRightFieldInfo
instance AttrInfo MarginRightFieldInfo where
type AttrBaseTypeConstraint MarginRightFieldInfo = (~) Margin
type AttrAllowedOps MarginRightFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MarginRightFieldInfo = (~) Float
type AttrTransferTypeConstraint MarginRightFieldInfo = (~)Float
type AttrTransferType MarginRightFieldInfo = Float
type AttrGetType MarginRightFieldInfo = Float
type AttrLabel MarginRightFieldInfo = "right"
type AttrOrigin MarginRightFieldInfo = Margin
attrGet = getMarginRight
attrSet = setMarginRight
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Margin.right"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Margin.html#g:attr:right"
})
margin_right :: AttrLabelProxy "right"
margin_right = AttrLabelProxy
#endif
getMarginTop :: MonadIO m => Margin -> m Float
getMarginTop :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginTop Margin
s = 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
$ Margin -> (Ptr Margin -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO Float) -> IO Float)
-> (Ptr Margin -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CFloat
let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'
setMarginTop :: MonadIO m => Margin -> Float -> m ()
setMarginTop :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginTop Margin
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Margin -> (Ptr Margin -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO ()) -> IO ()) -> (Ptr Margin -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CFloat
val' :: CFloat)
#if defined(ENABLE_OVERLOADING)
data MarginTopFieldInfo
instance AttrInfo MarginTopFieldInfo where
type AttrBaseTypeConstraint MarginTopFieldInfo = (~) Margin
type AttrAllowedOps MarginTopFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MarginTopFieldInfo = (~) Float
type AttrTransferTypeConstraint MarginTopFieldInfo = (~)Float
type AttrTransferType MarginTopFieldInfo = Float
type AttrGetType MarginTopFieldInfo = Float
type AttrLabel MarginTopFieldInfo = "top"
type AttrOrigin MarginTopFieldInfo = Margin
attrGet = getMarginTop
attrSet = setMarginTop
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Margin.top"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Margin.html#g:attr:top"
})
margin_top :: AttrLabelProxy "top"
margin_top = AttrLabelProxy
#endif
getMarginBottom :: MonadIO m => Margin -> m Float
getMarginBottom :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginBottom Margin
s = 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
$ Margin -> (Ptr Margin -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO Float) -> IO Float)
-> (Ptr Margin -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO CFloat
let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'
setMarginBottom :: MonadIO m => Margin -> Float -> m ()
setMarginBottom :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginBottom Margin
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Margin -> (Ptr Margin -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Margin
s ((Ptr Margin -> IO ()) -> IO ()) -> (Ptr Margin -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Margin
ptr -> do
let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Margin
ptr Ptr Margin -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CFloat
val' :: CFloat)
#if defined(ENABLE_OVERLOADING)
data MarginBottomFieldInfo
instance AttrInfo MarginBottomFieldInfo where
type AttrBaseTypeConstraint MarginBottomFieldInfo = (~) Margin
type AttrAllowedOps MarginBottomFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MarginBottomFieldInfo = (~) Float
type AttrTransferTypeConstraint MarginBottomFieldInfo = (~)Float
type AttrTransferType MarginBottomFieldInfo = Float
type AttrGetType MarginBottomFieldInfo = Float
type AttrLabel MarginBottomFieldInfo = "bottom"
type AttrOrigin MarginBottomFieldInfo = Margin
attrGet = getMarginBottom
attrSet = setMarginBottom
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Margin.bottom"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Margin.html#g:attr:bottom"
})
margin_bottom :: AttrLabelProxy "bottom"
margin_bottom = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Margin
type instance O.AttributeList Margin = MarginAttributeList
type MarginAttributeList = ('[ '("left", MarginLeftFieldInfo), '("right", MarginRightFieldInfo), '("top", MarginTopFieldInfo), '("bottom", MarginBottomFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "clutter_margin_new" clutter_margin_new ::
IO (Ptr Margin)
marginNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Margin
marginNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Margin
marginNew = IO Margin -> m Margin
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Margin -> m Margin) -> IO Margin -> m Margin
forall a b. (a -> b) -> a -> b
$ do
Ptr Margin
result <- IO (Ptr Margin)
clutter_margin_new
Text -> Ptr Margin -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"marginNew" Ptr Margin
result
Margin
result' <- ((ManagedPtr Margin -> Margin) -> Ptr Margin -> IO Margin
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Margin -> Margin
Margin) Ptr Margin
result
Margin -> IO Margin
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Margin
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_margin_copy" clutter_margin_copy ::
Ptr Margin ->
IO (Ptr Margin)
marginCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Margin
-> m Margin
marginCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Margin -> m Margin
marginCopy Margin
margin_ = IO Margin -> m Margin
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Margin -> m Margin) -> IO Margin -> m Margin
forall a b. (a -> b) -> a -> b
$ do
Ptr Margin
margin_' <- Margin -> IO (Ptr Margin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Margin
margin_
Ptr Margin
result <- Ptr Margin -> IO (Ptr Margin)
clutter_margin_copy Ptr Margin
margin_'
Text -> Ptr Margin -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"marginCopy" Ptr Margin
result
Margin
result' <- ((ManagedPtr Margin -> Margin) -> Ptr Margin -> IO Margin
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Margin -> Margin
Margin) Ptr Margin
result
Margin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Margin
margin_
Margin -> IO Margin
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Margin
result'
#if defined(ENABLE_OVERLOADING)
data MarginCopyMethodInfo
instance (signature ~ (m Margin), MonadIO m) => O.OverloadedMethod MarginCopyMethodInfo Margin signature where
overloadedMethod = marginCopy
instance O.OverloadedMethodInfo MarginCopyMethodInfo Margin where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Margin.marginCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Margin.html#v:marginCopy"
})
#endif
foreign import ccall "clutter_margin_free" clutter_margin_free ::
Ptr Margin ->
IO ()
marginFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Margin
-> m ()
marginFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Margin -> m ()
marginFree Margin
margin_ = 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 Margin
margin_' <- Margin -> IO (Ptr Margin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Margin
margin_
Ptr Margin -> IO ()
clutter_margin_free Ptr Margin
margin_'
Margin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Margin
margin_
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MarginFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MarginFreeMethodInfo Margin signature where
overloadedMethod = marginFree
instance O.OverloadedMethodInfo MarginFreeMethodInfo Margin where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Structs.Margin.marginFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.5/docs/GI-Clutter-Structs-Margin.html#v:marginFree"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveMarginMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveMarginMethod "copy" o = MarginCopyMethodInfo
ResolveMarginMethod "free" o = MarginFreeMethodInfo
ResolveMarginMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMarginMethod t Margin, O.OverloadedMethod info Margin p) => OL.IsLabel t (Margin -> 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 ~ ResolveMarginMethod t Margin, O.OverloadedMethod info Margin p, R.HasField t Margin p) => R.HasField t Margin p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMarginMethod t Margin, O.OverloadedMethodInfo info Margin) => OL.IsLabel t (O.MethodProxy info Margin) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif