{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A representation of the components of a margin.
-- 
-- /Since: 1.10/

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

module GI.Clutter.Structs.Margin
    ( 

-- * Exported types
    Margin(..)                              ,
    newZeroMargin                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Clutter.Structs.Margin#g:method:copy"), [free]("GI.Clutter.Structs.Margin#g:method:free").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveMarginMethod                     ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    MarginCopyMethodInfo                    ,
#endif
    marginCopy                              ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    MarginFreeMethodInfo                    ,
#endif
    marginFree                              ,


-- ** new #method:new#

    marginNew                               ,




 -- * Properties


-- ** bottom #attr:bottom#
-- | the margin from the bottom

    getMarginBottom                         ,
#if defined(ENABLE_OVERLOADING)
    margin_bottom                           ,
#endif
    setMarginBottom                         ,


-- ** left #attr:left#
-- | the margin from the left

    getMarginLeft                           ,
#if defined(ENABLE_OVERLOADING)
    margin_left                             ,
#endif
    setMarginLeft                           ,


-- ** right #attr:right#
-- | the margin from the right

    getMarginRight                          ,
#if defined(ENABLE_OVERLOADING)
    margin_right                            ,
#endif
    setMarginRight                          ,


-- ** top #attr:top#
-- | the margin from the top

    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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- | Memory-managed wrapper type.
newtype 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
/= :: Margin -> Margin -> Bool
$c/= :: Margin -> Margin -> Bool
== :: Margin -> Margin -> Bool
$c== :: 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

-- | Convert 'Margin' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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 (m :: * -> *) a. Monad m => a -> m a
return Maybe Margin
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `Margin` struct initialized to zero.
newZeroMargin :: MonadIO m => m Margin
newZeroMargin :: forall (m :: * -> *). MonadIO m => m Margin
newZeroMargin = IO Margin -> m Margin
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 (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 (m :: * -> *) a. Monad m => a -> m a
return Margin
o


-- | Get the value of the “@left@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' margin #left
-- @
getMarginLeft :: MonadIO m => Margin -> m Float
getMarginLeft :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginLeft Margin
s = IO Float -> m Float
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 (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@left@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' margin [ #left 'Data.GI.Base.Attributes.:=' value ]
-- @
setMarginLeft :: MonadIO m => Margin -> Float -> m ()
setMarginLeft :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginLeft Margin
s Float
val = IO () -> m ()
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.2/docs/GI-Clutter-Structs-Margin.html#g:attr:left"
        })

margin_left :: AttrLabelProxy "left"
margin_left = AttrLabelProxy

#endif


-- | Get the value of the “@right@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' margin #right
-- @
getMarginRight :: MonadIO m => Margin -> m Float
getMarginRight :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginRight Margin
s = IO Float -> m Float
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 (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@right@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' margin [ #right 'Data.GI.Base.Attributes.:=' value ]
-- @
setMarginRight :: MonadIO m => Margin -> Float -> m ()
setMarginRight :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginRight Margin
s Float
val = IO () -> m ()
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.2/docs/GI-Clutter-Structs-Margin.html#g:attr:right"
        })

margin_right :: AttrLabelProxy "right"
margin_right = AttrLabelProxy

#endif


-- | Get the value of the “@top@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' margin #top
-- @
getMarginTop :: MonadIO m => Margin -> m Float
getMarginTop :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginTop Margin
s = IO Float -> m Float
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 (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@top@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' margin [ #top 'Data.GI.Base.Attributes.:=' value ]
-- @
setMarginTop :: MonadIO m => Margin -> Float -> m ()
setMarginTop :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginTop Margin
s Float
val = IO () -> m ()
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.2/docs/GI-Clutter-Structs-Margin.html#g:attr:top"
        })

margin_top :: AttrLabelProxy "top"
margin_top = AttrLabelProxy

#endif


-- | Get the value of the “@bottom@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' margin #bottom
-- @
getMarginBottom :: MonadIO m => Margin -> m Float
getMarginBottom :: forall (m :: * -> *). MonadIO m => Margin -> m Float
getMarginBottom Margin
s = IO Float -> m Float
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 (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@bottom@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' margin [ #bottom 'Data.GI.Base.Attributes.:=' value ]
-- @
setMarginBottom :: MonadIO m => Margin -> Float -> m ()
setMarginBottom :: forall (m :: * -> *). MonadIO m => Margin -> Float -> m ()
setMarginBottom Margin
s Float
val = IO () -> m ()
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.2/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, *)])
#endif

-- method Margin::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Margin" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_margin_new" clutter_margin_new :: 
    IO (Ptr Margin)

-- | Creates a new t'GI.Clutter.Structs.Margin.Margin'.
-- 
-- /Since: 1.10/
marginNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Margin
    -- ^ __Returns:__ a newly allocated t'GI.Clutter.Structs.Margin.Margin'. Use
    --   'GI.Clutter.Structs.Margin.marginFree' to free the resources associated with it when
    --   done.
marginNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Margin
marginNew  = IO Margin -> m Margin
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 (m :: * -> *) a. Monad m => a -> m a
return Margin
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Margin::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "margin_"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Margin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterMargin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Margin" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_margin_copy" clutter_margin_copy :: 
    Ptr Margin ->                           -- margin_ : TInterface (Name {namespace = "Clutter", name = "Margin"})
    IO (Ptr Margin)

-- | Creates a new t'GI.Clutter.Structs.Margin.Margin' and copies the contents of /@margin_@/ into
-- the newly created structure.
-- 
-- /Since: 1.10/
marginCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Margin
    -- ^ /@margin_@/: a t'GI.Clutter.Structs.Margin.Margin'
    -> m Margin
    -- ^ __Returns:__ a copy of the t'GI.Clutter.Structs.Margin.Margin'.
marginCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Margin -> m Margin
marginCopy Margin
margin_ = IO Margin -> m Margin
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 (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.2/docs/GI-Clutter-Structs-Margin.html#v:marginCopy"
        })


#endif

-- method Margin::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "margin_"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Margin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterMargin" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_margin_free" clutter_margin_free :: 
    Ptr Margin ->                           -- margin_ : TInterface (Name {namespace = "Clutter", name = "Margin"})
    IO ()

-- | Frees the resources allocated by 'GI.Clutter.Structs.Margin.marginNew' and
-- 'GI.Clutter.Structs.Margin.marginCopy'.
-- 
-- /Since: 1.10/
marginFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Margin
    -- ^ /@margin_@/: a t'GI.Clutter.Structs.Margin.Margin'
    -> m ()
marginFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Margin -> m ()
marginFree Margin
margin_ = 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 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 (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.2/docs/GI-Clutter-Structs-Margin.html#v:marginFree"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveMarginMethod (t :: Symbol) (o :: *) :: * 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