    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A struct that specifies a border around a rectangular area
    -- that can be of different width on each side.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gtk.Structs.Border
        (

    -- * Exported types
        Border(..)                              ,
        newZeroBorder                           ,

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

    #if defined(ENABLE_OVERLOADING)
        ResolveBorderMethod                     ,
    #endif

    -- ** copy #method:copy#

    #if defined(ENABLE_OVERLOADING)
        BorderCopyMethodInfo                    ,
    #endif
        borderCopy                              ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        BorderFreeMethodInfo                    ,
    #endif
        borderFree                              ,

    -- ** new #method:new#

        borderNew                               ,

     -- * Properties

    -- ** bottom #attr:bottom#
    -- | The width of the bottom border

    #if defined(ENABLE_OVERLOADING)
        border_bottom                           ,
    #endif
        getBorderBottom                         ,
        setBorderBottom                         ,

    -- ** left #attr:left#
    -- | The width of the left border

    #if defined(ENABLE_OVERLOADING)
        border_left                             ,
    #endif
        getBorderLeft                           ,
        setBorderLeft                           ,

    -- ** right #attr:right#
    -- | The width of the right border

    #if defined(ENABLE_OVERLOADING)
        border_right                            ,
    #endif
        getBorderRight                          ,
        setBorderRight                          ,

    -- ** top #attr:top#
    -- | The width of the top border

    #if defined(ENABLE_OVERLOADING)
        border_top                              ,
    #endif
        getBorderTop                            ,
        setBorderTop                            ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- | Memory-managed wrapper type.
    newtype Border = Border (SP.ManagedPtr Border)
        deriving (Border -> Border -> Bool
    (Border -> Border -> Bool)
    -> (Border -> Border -> Bool) -> Eq Border
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Border -> Border -> Bool
    == :: Border -> Border -> Bool
    $c/= :: Border -> Border -> Bool
    /= :: Border -> Border -> Bool
    Eq)

    instance SP.ManagedPtrNewtype Border where
        toManagedPtr :: Border -> ManagedPtr Border
    toManagedPtr (Border ManagedPtr Border
    p) = ManagedPtr Border
    p

    foreign import ccall "gtk_border_get_type" c_gtk_border_get_type ::
        IO GType

    type instance O.ParentTypes Border = '[]
    instance O.HasParentTypes Border

    instance B.Types.TypedObject Border where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_border_get_type

    instance B.Types.GBoxed Border

    -- | Convert t'Border' 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 Border) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_border_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Border -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Border
    P.Nothing = Ptr GValue -> Ptr Border -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr Border
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Border)
        gvalueSet_ Ptr GValue
    gv (P.Just Border
    obj) = Border -> (Ptr Border -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Border
    obj (Ptr GValue -> Ptr Border -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Border)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr Border)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr Border)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newBoxed Border ptr
            else return P.Nothing

    -- | Construct a t'Border' struct initialized to zero.
    newZeroBorder :: MonadIO m => m Border
    newZeroBorder :: forall (m :: * -> *). MonadIO m => m Border
    newZeroBorder = IO Border -> m Border
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Border -> m Border) -> IO Border -> m Border
    forall a b. (a -> b) -> a -> b
    $ Int -> IO (Ptr Border)
    forall a. GBoxed a => Int -> IO (Ptr a)
    callocBoxedBytes Int
    8 IO (Ptr Border) -> (Ptr Border -> IO Border) -> IO Border
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr Border -> Border) -> Ptr Border -> IO Border
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Border -> Border
    Border

    instance tag ~ 'AttrSet => Constructible Border tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr Border -> Border) -> [AttrOp Border tag] -> m Border
    new ManagedPtr Border -> Border
    _ [AttrOp Border tag]
    attrs = do
            o <- m Border
    forall (m :: * -> *). MonadIO m => m Border
    newZeroBorder
            GI.Attributes.set o attrs
            return 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' border #left
    -- @
    getBorderLeft :: MonadIO m => Border -> m Int16
    getBorderLeft :: forall (m :: * -> *). MonadIO m => Border -> m Int16
    getBorderLeft Border
    s = IO Int16 -> m Int16
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int16 -> m Int16) -> IO Int16 -> m Int16
    forall a b. (a -> b) -> a -> b
    $ Border -> (Ptr Border -> IO Int16) -> IO Int16
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO Int16) -> IO Int16)
    -> (Ptr Border -> IO Int16) -> IO Int16
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        val <- Ptr Int16 -> IO Int16
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO Int16
        return 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' border [ #left 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setBorderLeft :: MonadIO m => Border -> Int16 -> m ()
    setBorderLeft :: forall (m :: * -> *). MonadIO m => Border -> Int16 -> m ()
    setBorderLeft Border
    s Int16
    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
    $ Border -> (Ptr Border -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO ()) -> IO ()) -> (Ptr Border -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        Ptr Int16 -> Int16 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Int16
    val :: Int16)

    #if defined(ENABLE_OVERLOADING)
    data BorderLeftFieldInfo
    instance AttrInfo BorderLeftFieldInfo where
        type AttrBaseTypeConstraint BorderLeftFieldInfo = (~) Border
        type AttrAllowedOps BorderLeftFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint BorderLeftFieldInfo = (~) Int16
        type AttrTransferTypeConstraint BorderLeftFieldInfo = (~)Int16
        type AttrTransferType BorderLeftFieldInfo = Int16
        type AttrGetType BorderLeftFieldInfo = Int16
        type AttrLabel BorderLeftFieldInfo = "left"
        type AttrOrigin BorderLeftFieldInfo = Border
        attrGet = getBorderLeft
        attrSet = setBorderLeft
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.Border.left"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-Border.html#g:attr:left"
            })

    border_left :: AttrLabelProxy "left"
    border_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' border #right
    -- @
    getBorderRight :: MonadIO m => Border -> m Int16
    getBorderRight :: forall (m :: * -> *). MonadIO m => Border -> m Int16
    getBorderRight Border
    s = IO Int16 -> m Int16
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int16 -> m Int16) -> IO Int16 -> m Int16
    forall a b. (a -> b) -> a -> b
    $ Border -> (Ptr Border -> IO Int16) -> IO Int16
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO Int16) -> IO Int16)
    -> (Ptr Border -> IO Int16) -> IO Int16
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        val <- Ptr Int16 -> IO Int16
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    2) :: IO Int16
        return 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' border [ #right 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setBorderRight :: MonadIO m => Border -> Int16 -> m ()
    setBorderRight :: forall (m :: * -> *). MonadIO m => Border -> Int16 -> m ()
    setBorderRight Border
    s Int16
    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
    $ Border -> (Ptr Border -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO ()) -> IO ()) -> (Ptr Border -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        Ptr Int16 -> Int16 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    2) (Int16
    val :: Int16)

    #if defined(ENABLE_OVERLOADING)
    data BorderRightFieldInfo
    instance AttrInfo BorderRightFieldInfo where
        type AttrBaseTypeConstraint BorderRightFieldInfo = (~) Border
        type AttrAllowedOps BorderRightFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint BorderRightFieldInfo = (~) Int16
        type AttrTransferTypeConstraint BorderRightFieldInfo = (~)Int16
        type AttrTransferType BorderRightFieldInfo = Int16
        type AttrGetType BorderRightFieldInfo = Int16
        type AttrLabel BorderRightFieldInfo = "right"
        type AttrOrigin BorderRightFieldInfo = Border
        attrGet = getBorderRight
        attrSet = setBorderRight
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.Border.right"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-Border.html#g:attr:right"
            })

    border_right :: AttrLabelProxy "right"
    border_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' border #top
    -- @
    getBorderTop :: MonadIO m => Border -> m Int16
    getBorderTop :: forall (m :: * -> *). MonadIO m => Border -> m Int16
    getBorderTop Border
    s = IO Int16 -> m Int16
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int16 -> m Int16) -> IO Int16 -> m Int16
    forall a b. (a -> b) -> a -> b
    $ Border -> (Ptr Border -> IO Int16) -> IO Int16
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO Int16) -> IO Int16)
    -> (Ptr Border -> IO Int16) -> IO Int16
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        val <- Ptr Int16 -> IO Int16
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) :: IO Int16
        return 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' border [ #top 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setBorderTop :: MonadIO m => Border -> Int16 -> m ()
    setBorderTop :: forall (m :: * -> *). MonadIO m => Border -> Int16 -> m ()
    setBorderTop Border
    s Int16
    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
    $ Border -> (Ptr Border -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO ()) -> IO ()) -> (Ptr Border -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        Ptr Int16 -> Int16 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) (Int16
    val :: Int16)

    #if defined(ENABLE_OVERLOADING)
    data BorderTopFieldInfo
    instance AttrInfo BorderTopFieldInfo where
        type AttrBaseTypeConstraint BorderTopFieldInfo = (~) Border
        type AttrAllowedOps BorderTopFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint BorderTopFieldInfo = (~) Int16
        type AttrTransferTypeConstraint BorderTopFieldInfo = (~)Int16
        type AttrTransferType BorderTopFieldInfo = Int16
        type AttrGetType BorderTopFieldInfo = Int16
        type AttrLabel BorderTopFieldInfo = "top"
        type AttrOrigin BorderTopFieldInfo = Border
        attrGet = getBorderTop
        attrSet = setBorderTop
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.Border.top"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-Border.html#g:attr:top"
            })

    border_top :: AttrLabelProxy "top"
    border_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' border #bottom
    -- @
    getBorderBottom :: MonadIO m => Border -> m Int16
    getBorderBottom :: forall (m :: * -> *). MonadIO m => Border -> m Int16
    getBorderBottom Border
    s = IO Int16 -> m Int16
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int16 -> m Int16) -> IO Int16 -> m Int16
    forall a b. (a -> b) -> a -> b
    $ Border -> (Ptr Border -> IO Int16) -> IO Int16
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO Int16) -> IO Int16)
    -> (Ptr Border -> IO Int16) -> IO Int16
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        val <- Ptr Int16 -> IO Int16
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    6) :: IO Int16
        return 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' border [ #bottom 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setBorderBottom :: MonadIO m => Border -> Int16 -> m ()
    setBorderBottom :: forall (m :: * -> *). MonadIO m => Border -> Int16 -> m ()
    setBorderBottom Border
    s Int16
    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
    $ Border -> (Ptr Border -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Border
    s ((Ptr Border -> IO ()) -> IO ()) -> (Ptr Border -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Border
    ptr -> do
        Ptr Int16 -> Int16 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Border
    ptr Ptr Border -> Int -> Ptr Int16
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    6) (Int16
    val :: Int16)

    #if defined(ENABLE_OVERLOADING)
    data BorderBottomFieldInfo
    instance AttrInfo BorderBottomFieldInfo where
        type AttrBaseTypeConstraint BorderBottomFieldInfo = (~) Border
        type AttrAllowedOps BorderBottomFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint BorderBottomFieldInfo = (~) Int16
        type AttrTransferTypeConstraint BorderBottomFieldInfo = (~)Int16
        type AttrTransferType BorderBottomFieldInfo = Int16
        type AttrGetType BorderBottomFieldInfo = Int16
        type AttrLabel BorderBottomFieldInfo = "bottom"
        type AttrOrigin BorderBottomFieldInfo = Border
        attrGet = getBorderBottom
        attrSet = setBorderBottom
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.Border.bottom"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-Border.html#g:attr:bottom"
            })

    border_bottom :: AttrLabelProxy "bottom"
    border_bottom = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Border
    type instance O.AttributeList Border = BorderAttributeList
    type BorderAttributeList = ('[ '("left", BorderLeftFieldInfo), '("right", BorderRightFieldInfo), '("top", BorderTopFieldInfo), '("bottom", BorderBottomFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

    foreign import ccall "gtk_border_new" gtk_border_new ::
        IO (Ptr Border)

    -- | Allocates a new t'GI.Gtk.Structs.Border.Border'-struct and initializes its elements to zero.
    --
    -- /Since: 2.14/
    borderNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Border
        -- ^ __Returns:__ a newly allocated t'GI.Gtk.Structs.Border.Border'-struct.
        --  Free with 'GI.Gtk.Structs.Border.borderFree'
    borderNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Border
    borderNew  = IO Border -> m Border
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Border -> m Border) -> IO Border -> m Border
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Border)
    gtk_border_new
        checkUnexpectedReturnNULL "borderNew" result
        result' <- (wrapBoxed Border) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Border::copy
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "border_"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Border" }
    --           , argCType = Just "const GtkBorder*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkBorder-struct"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Border" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_border_copy" gtk_border_copy ::
        Ptr Border ->                           -- border_ : TInterface (Name {namespace = "Gtk", name = "Border"})
        IO (Ptr Border)

    -- | Copies a t'GI.Gtk.Structs.Border.Border'-struct.
    borderCopy ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Border
        -- ^ /@border_@/: a t'GI.Gtk.Structs.Border.Border'-struct
        -> m Border
        -- ^ __Returns:__ a copy of /@border_@/.
    borderCopy :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Border -> m Border
    borderCopy Border
    border_ = IO Border -> m Border
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Border -> m Border) -> IO Border -> m Border
    forall a b. (a -> b) -> a -> b
    $ do
        border_' <- Border -> IO (Ptr Border)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Border
    border_
        result <- gtk_border_copy border_'
        checkUnexpectedReturnNULL "borderCopy" result
        result' <- (wrapBoxed Border) result
        touchManagedPtr border_
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BorderCopyMethodInfo
    instance (signature ~ (m Border), MonadIO m) => O.OverloadedMethod BorderCopyMethodInfo Border signature where
        overloadedMethod = borderCopy

    instance O.OverloadedMethodInfo BorderCopyMethodInfo Border where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.Border.borderCopy",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-Border.html#v:borderCopy"
            })

    #endif

    -- method Border::free
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "border_"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Border" }
    --           , argCType = Just "GtkBorder*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GtkBorder-struct"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_border_free" gtk_border_free ::
        Ptr Border ->                           -- border_ : TInterface (Name {namespace = "Gtk", name = "Border"})
        IO ()

    -- | Frees a t'GI.Gtk.Structs.Border.Border'-struct.
    borderFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Border
        -- ^ /@border_@/: a t'GI.Gtk.Structs.Border.Border'-struct
        -> m ()
    borderFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Border -> m ()
    borderFree Border
    border_ = 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
        border_' <- Border -> IO (Ptr Border)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Border
    border_
        gtk_border_free border_'
        touchManagedPtr border_
        return ()

    #if defined(ENABLE_OVERLOADING)
    data BorderFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod BorderFreeMethodInfo Border signature where
        overloadedMethod = borderFree

    instance O.OverloadedMethodInfo BorderFreeMethodInfo Border where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.Border.borderFree",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-Border.html#v:borderFree"
            })

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveBorderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveBorderMethod "copy" o = BorderCopyMethodInfo
        ResolveBorderMethod "free" o = BorderFreeMethodInfo
        ResolveBorderMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveBorderMethod t Border, O.OverloadedMethod info Border p) => OL.IsLabel t (Border -> 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 ~ ResolveBorderMethod t Border, O.OverloadedMethod info Border p, R.HasField t Border p) => R.HasField t Border p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveBorderMethod t Border, O.OverloadedMethodInfo info Border) => OL.IsLabel t (O.MethodProxy info Border) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif