    {-# LINE 2 "./Graphics/UI/Gtk/Layout/Alignment.chs" #-}
    -- -*-haskell-*-
    -- GIMP Toolkit (GTK) Widget Alignment
    --
    -- Author : Axel Simon
    --
    -- Created: 15 May 2001
    --
    -- Copyright (C) 1999-2005 Axel Simon
    --
    -- This library is free software; you can redistribute it and/or
    -- modify it under the terms of the GNU Lesser General Public
    -- License as published by the Free Software Foundation; either
    -- version 2.1 of the License, or (at your option) any later version.
    --
    -- This library is distributed in the hope that it will be useful,
    -- but WITHOUT ANY WARRANTY; without even the implied warranty of
    -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    -- Lesser General Public License for more details.
    --
    -- |
    -- Maintainer : gtk2hs-users@lists.sourceforge.net
    -- Stability : provisional
    -- Portability : portable (depends on GHC)
    --
    -- A widget which controls the alignment and size of its child
    --
    module Graphics.UI.Gtk.Layout.Alignment (
    -- * Detail
    --
    -- | The 'Alignment' widget controls the alignment and size of its child
    -- widget. It has four settings: xscale, yscale, xalign, and yalign.
    --
    -- The scale settings are used to specify how much the child widget should
    -- expand to fill the space allocated to the 'Alignment'. The values can range
    -- from 0 (meaning the child doesn't expand at all) to 1 (meaning the child
    -- expands to fill all of the available space).
    --
    -- The align settings are used to place the child widget within the
    -- available area. The values range from 0 (top or left) to 1 (bottom or
    -- right). Of course, if the scale settings are both set to 1, the alignment
    -- settings have no effect.

    -- * Class Hierarchy
    -- |
    -- @
    -- | 'GObject'
    -- | +----'Object'
    -- | +----'Widget'
    -- | +----'Container'
    -- | +----'Bin'
    -- | +----Alignment
    -- @

    -- * Types
      Alignment,
      AlignmentClass,
      castToAlignment, gTypeAlignment,
      toAlignment,

    -- * Constructors
      alignmentNew,

    -- * Methods
      alignmentSet,

      alignmentSetPadding,
      alignmentGetPadding,

    -- * Attributes
      alignmentXAlign,
      alignmentYAlign,
      alignmentXScale,
      alignmentYScale,

      alignmentTopPadding,
      alignmentBottomPadding,
      alignmentLeftPadding,
      alignmentRightPadding,

      ) where

    import Control.Monad (liftM)

    import System.Glib.FFI
    import System.Glib.Attributes
    import System.Glib.Properties
    import Graphics.UI.Gtk.Abstract.Object (makeNewObject)
    import Graphics.UI.Gtk.Types
    {-# LINE 91 "./Graphics/UI/Gtk/Layout/Alignment.chs" #-}

    {-# LINE 93 "./Graphics/UI/Gtk/Layout/Alignment.chs" #-}

    --------------------
    -- Constructors

    -- | Creates a new 'Alignment'.
    --
    alignmentNew ::
        Float -- ^ @xalign@ - the horizontal alignment of the child widget,
                     -- from 0 (left) to 1 (right).
     -> Float -- ^ @yalign@ - the vertical alignment of the child widget,
                     -- from 0 (top) to 1 (bottom).
     -> Float -- ^ @xscale@ - the amount that the child widget expands
                     -- horizontally to fill up unused space, from 0 to 1. A value
                     -- of 0 indicates that the child widget should never expand. A
                     -- value of 1 indicates that the child widget will expand to
                     -- fill all of the space allocated for the 'Alignment'.
     -> Float -- ^ @yscale@ - the amount that the child widget expands
                     -- vertically to fill up unused space, from 0 to 1. The values
                     -- are similar to @xscale@.
     -> IO Alignment
    alignmentNew :: Float -> Float -> Float -> Float -> IO Alignment
    alignmentNew Float
    xalign Float
    yalign Float
    xscale Float
    yscale =
      (ForeignPtr Alignment -> Alignment, FinalizerPtr Alignment)
    -> IO (Ptr Alignment) -> IO Alignment
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Alignment -> Alignment, FinalizerPtr Alignment)
    forall {a}. (ForeignPtr Alignment -> Alignment, FinalizerPtr a)
    mkAlignment (IO (Ptr Alignment) -> IO Alignment)
    -> IO (Ptr Alignment) -> IO Alignment
    forall a b. (a -> b) -> a -> b
    $
      (Ptr Widget -> Ptr Alignment)
    -> IO (Ptr Widget) -> IO (Ptr Alignment)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Ptr Widget -> Ptr Alignment
    forall a b. Ptr a -> Ptr b
    castPtr :: Ptr Widget -> Ptr Alignment) (IO (Ptr Widget) -> IO (Ptr Alignment))
    -> IO (Ptr Widget) -> IO (Ptr Alignment)
    forall a b. (a -> b) -> a -> b
    $
      CFloat -> CFloat -> CFloat -> CFloat -> IO (Ptr Widget)
    gtk_alignment_new
    {-# LINE 117 "./Graphics/UI/Gtk/Layout/Alignment.chs" #-}
        (realToFrac xalign)
        (Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yalign)
        (Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xscale)
        (Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yscale)

    --------------------
    -- Methods

    -- | Sets the 'Alignment' values.
    --
    alignmentSet :: AlignmentClass self => self
     -> Float -- ^ @xalign@ - the horizontal alignment of the child widget, from 0
              -- (left) to 1 (right).
     -> Float -- ^ @yalign@ - the vertical alignment of the child widget, from 0
              -- (top) to 1 (bottom).
     -> Float -- ^ @xscale@ - the amount that the child widget expands
              -- horizontally to fill up unused space, from 0 to 1. A value of 0
              -- indicates that the child widget should never expand. A value of 1
              -- indicates that the child widget will expand to fill all of the
              -- space allocated for the 'Alignment'.
     -> Float -- ^ @yscale@ - the amount that the child widget expands vertically
              -- to fill up unused space, from 0 to 1. The values are similar to
              -- @xscale@.
     -> IO ()
    alignmentSet :: forall self.
    AlignmentClass self =>
    self -> Float -> Float -> Float -> Float -> IO ()
    alignmentSet self
    self Float
    xalign Float
    yalign Float
    xscale Float
    yscale =
      (\(Alignment ForeignPtr Alignment
    arg1) CFloat
    arg2 CFloat
    arg3 CFloat
    arg4 CFloat
    arg5 -> ForeignPtr Alignment -> (Ptr Alignment -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Alignment
    arg1 ((Ptr Alignment -> IO ()) -> IO ())
    -> (Ptr Alignment -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Alignment
    argPtr1 ->Ptr Alignment -> CFloat -> CFloat -> CFloat -> CFloat -> IO ()
    gtk_alignment_set Ptr Alignment
    argPtr1 CFloat
    arg2 CFloat
    arg3 CFloat
    arg4 CFloat
    arg5)
    {-# LINE 143 "./Graphics/UI/Gtk/Layout/Alignment.chs" #-}
        (toAlignment self)
        (Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xalign)
        (Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yalign)
        (Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xscale)
        (Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yscale)

    -- | Sets the padding on the different sides of the widget. The padding adds
    -- blank space to the sides of the widget. For instance, this can be used to
    -- indent the child widget towards the right by adding padding on the left.
    --
    -- * Available since Gtk+ version 2.4
    --
    alignmentSetPadding :: AlignmentClass self => self
     -> Int -- ^ @paddingTop@ - the padding at the top of the widget
     -> Int -- ^ @paddingBottom@ - the padding at the bottom of the widget
     -> Int -- ^ @paddingLeft@ - the padding at the left of the widget
     -> Int -- ^ @paddingRight@ - the padding at the right of the widget.
     -> IO ()
    alignmentSetPadding :: forall self.
    AlignmentClass self =>
    self -> Int -> Int -> Int -> Int -> IO ()
    alignmentSetPadding self
    self Int
    paddingTop Int
    paddingBottom Int
    paddingLeft Int
    paddingRight =
      (\(Alignment ForeignPtr Alignment
    arg1) CUInt
    arg2 CUInt
    arg3 CUInt
    arg4 CUInt
    arg5 -> ForeignPtr Alignment -> (Ptr Alignment -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Alignment
    arg1 ((Ptr Alignment -> IO ()) -> IO ())
    -> (Ptr Alignment -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Alignment
    argPtr1 ->Ptr Alignment -> CUInt -> CUInt -> CUInt -> CUInt -> IO ()
    gtk_alignment_set_padding Ptr Alignment
    argPtr1 CUInt
    arg2 CUInt
    arg3 CUInt
    arg4 CUInt
    arg5)
    {-# LINE 164 "./Graphics/UI/Gtk/Layout/Alignment.chs" #-}
        (toAlignment self)
        (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    paddingTop)
        (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    paddingBottom)
        (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    paddingLeft)
        (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    paddingRight)

    -- | Gets the padding on the different sides of the widget. See
    -- 'alignmentSetPadding'.
    --
    -- * Available since Gtk+ version 2.4
    --
    alignmentGetPadding :: AlignmentClass self => self
     -> IO (Int, Int, Int, Int) -- ^ @(paddingTop, paddingBottom, paddingLeft,
                                -- paddingRight)@ - the padding at the top,
                                -- bottom, left and right of the widget.
    alignmentGetPadding :: forall self. AlignmentClass self => self -> IO (Int, Int, Int, Int)
    alignmentGetPadding self
    self =
      (Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int))
    -> (Ptr CUInt -> IO (Int, Int, Int, Int))
    -> IO (Int, Int, Int, Int)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CUInt
    paddingTopPtr ->
      (Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int))
    -> (Ptr CUInt -> IO (Int, Int, Int, Int))
    -> IO (Int, Int, Int, Int)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CUInt
    paddingBottomPtr ->
      (Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int))
    -> (Ptr CUInt -> IO (Int, Int, Int, Int))
    -> IO (Int, Int, Int, Int)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CUInt
    paddingLeftPtr ->
      (Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CUInt -> IO (Int, Int, Int, Int)) -> IO (Int, Int, Int, Int))
    -> (Ptr CUInt -> IO (Int, Int, Int, Int))
    -> IO (Int, Int, Int, Int)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CUInt
    paddingRightPtr -> do
      (\(Alignment ForeignPtr Alignment
    arg1) Ptr CUInt
    arg2 Ptr CUInt
    arg3 Ptr CUInt
    arg4 Ptr CUInt
    arg5 -> ForeignPtr Alignment -> (Ptr Alignment -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Alignment
    arg1 ((Ptr Alignment -> IO ()) -> IO ())
    -> (Ptr Alignment -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Alignment
    argPtr1 ->Ptr Alignment
    -> Ptr CUInt -> Ptr CUInt -> Ptr CUInt -> Ptr CUInt -> IO ()
    gtk_alignment_get_padding Ptr Alignment
    argPtr1 Ptr CUInt
    arg2 Ptr CUInt
    arg3 Ptr CUInt
    arg4 Ptr CUInt
    arg5)
    {-# LINE 185 "./Graphics/UI/Gtk/Layout/Alignment.chs" #-}
        (toAlignment self)
        Ptr CUInt
    paddingTopPtr
        Ptr CUInt
    paddingBottomPtr
        Ptr CUInt
    paddingLeftPtr
        Ptr CUInt
    paddingRightPtr
      paddingTop <- Ptr CUInt -> IO CUInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CUInt
    paddingTopPtr
      paddingBottom <- peek paddingBottomPtr
      paddingLeft <- peek paddingLeftPtr
      paddingRight <- peek paddingRightPtr
      return (fromIntegral paddingTop, fromIntegral paddingBottom
             ,fromIntegral paddingLeft, fromIntegral paddingRight)

    --------------------
    -- Attributes

    -- | Horizontal position of child in available space. 0.0 is left aligned, 1.0
    -- is right aligned.
    --
    -- Allowed values: [0,1]
    --
    -- Default value: 0.5
    --
    alignmentXAlign :: AlignmentClass self => Attr self Float
    alignmentXAlign :: forall self. AlignmentClass self => Attr self Float
    alignmentXAlign = String -> Attr self Float
    forall gobj. GObjectClass gobj => String -> Attr gobj Float
    newAttrFromFloatProperty String
    "xalign"

    -- | Vertical position of child in available space. 0.0 is top aligned, 1.0 is
    -- bottom aligned.
    --
    -- Allowed values: [0,1]
    --
    -- Default value: 0.5
    --
    alignmentYAlign :: AlignmentClass self => Attr self Float
    alignmentYAlign :: forall self. AlignmentClass self => Attr self Float
    alignmentYAlign = String -> Attr self Float
    forall gobj. GObjectClass gobj => String -> Attr gobj Float
    newAttrFromFloatProperty String
    "yalign"

    -- | If available horizontal space is bigger than needed for the child, how
    -- much of it to use for the child. 0.0 means none, 1.0 means all.
    --
    -- Allowed values: [0,1]
    --
    -- Default value: 1
    --
    alignmentXScale :: AlignmentClass self => Attr self Float
    alignmentXScale :: forall self. AlignmentClass self => Attr self Float
    alignmentXScale = String -> Attr self Float
    forall gobj. GObjectClass gobj => String -> Attr gobj Float
    newAttrFromFloatProperty String
    "xscale"

    -- | If available vertical space is bigger than needed for the child, how much
    -- of it to use for the child. 0.0 means none, 1.0 means all.
    --
    -- Allowed values: [0,1]
    --
    -- Default value: 1
    --
    alignmentYScale :: AlignmentClass self => Attr self Float
    alignmentYScale :: forall self. AlignmentClass self => Attr self Float
    alignmentYScale = String -> Attr self Float
    forall gobj. GObjectClass gobj => String -> Attr gobj Float
    newAttrFromFloatProperty String
    "yscale"

    -- | The padding to insert at the top of the widget.
    --
    -- Allowed values: \<= @('maxBound' :: Int)@
    --
    -- Default value: 0
    --
    alignmentTopPadding :: AlignmentClass self => Attr self Int
    alignmentTopPadding :: forall self. AlignmentClass self => Attr self Int
    alignmentTopPadding = String -> Attr self Int
    forall gobj. GObjectClass gobj => String -> Attr gobj Int
    newAttrFromUIntProperty String
    "top-padding"

    -- | The padding to insert at the bottom of the widget.
    --
    -- Allowed values: \<= @('maxBound' :: Int)@
    --
    -- Default value: 0
    --
    alignmentBottomPadding :: AlignmentClass self => Attr self Int
    alignmentBottomPadding :: forall self. AlignmentClass self => Attr self Int
    alignmentBottomPadding = String -> Attr self Int
    forall gobj. GObjectClass gobj => String -> Attr gobj Int
    newAttrFromUIntProperty String
    "bottom-padding"

    -- | The padding to insert at the left of the widget.
    --
    -- Allowed values: \<= @('maxBound' :: Int)@
    --
    -- Default value: 0
    --
    alignmentLeftPadding :: AlignmentClass self => Attr self Int
    alignmentLeftPadding :: forall self. AlignmentClass self => Attr self Int
    alignmentLeftPadding = String -> Attr self Int
    forall gobj. GObjectClass gobj => String -> Attr gobj Int
    newAttrFromUIntProperty String
    "left-padding"

    -- | The padding to insert at the right of the widget.
    --
    -- Allowed values: \<= @('maxBound' :: Int)@
    --
    -- Default value: 0
    --
    alignmentRightPadding :: AlignmentClass self => Attr self Int
    alignmentRightPadding :: forall self. AlignmentClass self => Attr self Int
    alignmentRightPadding = String -> Attr self Int
    forall gobj. GObjectClass gobj => String -> Attr gobj Int
    newAttrFromUIntProperty String
    "right-padding"

    foreign import ccall unsafe "gtk_alignment_new"
      gtk_alignment_new :: (CFloat -> (CFloat -> (CFloat -> (CFloat -> (IO (Ptr Widget))))))

    foreign import ccall safe "gtk_alignment_set"
      gtk_alignment_set :: ((Ptr Alignment) -> (CFloat -> (CFloat -> (CFloat -> (CFloat -> (IO ()))))))

    foreign import ccall safe "gtk_alignment_set_padding"
      gtk_alignment_set_padding :: ((Ptr Alignment) -> (CUInt -> (CUInt -> (CUInt -> (CUInt -> (IO ()))))))

    foreign import ccall safe "gtk_alignment_get_padding"
      gtk_alignment_get_padding :: ((Ptr Alignment) -> ((Ptr CUInt) -> ((Ptr CUInt) -> ((Ptr CUInt) -> ((Ptr CUInt) -> (IO ()))))))