    {-# LINE 2 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
    -- -*-haskell-*-
    -- GIMP Toolkit (GTK) Widgets Stack
    --
    -- Author : Moritz Schulte
    --
    -- Created: 27 April 2016
    --
    -- Copyright (C) 2015 Moritz Schulte
    --
    -- 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.Stack (
    -- * Detail
    --
    -- The 'Stack' widget is a container which only shows one of its
    -- children at a time. In contrast to 'Notebook', 'Stack' does not
    -- provide a means for users to change the visible child. Instead, the
    -- 'StackSwitcher' widget can be used with 'Stack' to provide this
    -- functionality.
    --
    -- Transitions between pages can be animated as slides or fades. This
    -- can be controlled with 'stackSetTransitionType'. These
    -- animations respect the 'gtk-enable-animations' setting.
    --
    -- The GtkStack widget was added in GTK+ 3.10.
    --
    -- * Class Hierarchy
    -- |
    -- @
    -- | 'GObject'
    -- | +----'Object'
    -- | +----'Widget'
    -- | +----'Container'
    -- | +----'Stack'
    -- @

    -- * Types

             Stack
           , castToStack
           , gTypeStack
           , toStack
           , StackTransitionType(..)
    -- * Constructors
           , stackNew

    -- * Methods
           , stackAddNamed
           , stackAddTitled
           , stackGetTransitionType
           , stackSetTransitionType
           , stackSetTransitionDuration
           , stackGetTransitionDuration
           , stackGetChildByName
           , stackSetVisibleChild
           , stackSetVisibleChildName
           , stackGetVisibleChildName
           , stackSetVisibleChildFull

           , stackSetHomogeneous
           , stackGetHomogeneous
           , stackSetHhomogeneous
           , stackGetHhomogeneous
           , stackSetVhomogeneous
           , stackGetVhomogeneous

           , stackGetTransitionRunning

           , stackSetInterpolateSize
           , stackGetInterpolateSize

    -- * Attributes

           , stackHhomogeneous
           , stackHomogeneous

           , stackInterpolateSize

           , stackTransitionDuration
           , stackTransitionRunning
           , stackTransitionType

           , stackVhomogeneous

           , stackVisibleChild
           , stackVisibleChildName

    ) where

    import Control.Monad (liftM)

    import System.Glib.FFI
    import System.Glib.UTFString
    import System.Glib.Attributes
    import System.Glib.Properties
    import Graphics.UI.Gtk.Abstract.Object (makeNewObject)
    import Graphics.UI.Gtk.General.Enums (StackTransitionType(..))
    import Graphics.UI.Gtk.Types
    {-# LINE 119 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}

    {-# LINE 121 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}

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

    -- | Creates a new 'Stack' container.
    --
    stackNew :: IO Stack
    stackNew :: IO Stack
    stackNew =
      (ForeignPtr Stack -> Stack, FinalizerPtr Stack)
    -> IO (Ptr Stack) -> IO Stack
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Stack -> Stack, FinalizerPtr Stack)
    forall {a}. (ForeignPtr Stack -> Stack, FinalizerPtr a)
    mkStack (IO (Ptr Stack) -> IO Stack) -> IO (Ptr Stack) -> IO Stack
    forall a b. (a -> b) -> a -> b
    $
      (Ptr Widget -> Ptr Stack) -> IO (Ptr Widget) -> IO (Ptr Stack)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Ptr Widget -> Ptr Stack
    forall a b. Ptr a -> Ptr b
    castPtr :: Ptr Widget -> Ptr Stack) (IO (Ptr Widget) -> IO (Ptr Stack))
    -> IO (Ptr Widget) -> IO (Ptr Stack)
    forall a b. (a -> b) -> a -> b
    $
      IO (Ptr Widget)
    gtk_stack_new
    {-# LINE 132 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}

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

    -- | Adds a child to stack . The child is identified by the name.
    stackAddNamed :: (StackClass self, WidgetClass child, GlibString name) => self
     -> child
     -> name
     -> IO ()
    stackAddNamed :: forall self child name.
    (StackClass self, WidgetClass child, GlibString name) =>
    self -> child -> name -> IO ()
    stackAddNamed self
    self child
    child name
    name =
      name -> (CString -> IO ()) -> IO ()
    forall a. name -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString name
    name ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CString
    namePtr ->
        (\(Stack ForeignPtr Stack
    arg1) (Widget ForeignPtr Widget
    arg2) CString
    arg3 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->ForeignPtr Widget -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Widget
    arg2 ((Ptr Widget -> IO ()) -> IO ()) -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Widget
    argPtr2 ->Ptr Stack -> Ptr Widget -> CString -> IO ()
    gtk_stack_add_named Ptr Stack
    argPtr1 Ptr Widget
    argPtr2 CString
    arg3)
    {-# LINE 144 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
          (toStack self)
          (child -> Widget
    forall o. WidgetClass o => o -> Widget
    toWidget child
    child)
          CString
    namePtr

    -- | Adds a child to stack. The child is identified by the name. The
    -- title will be used by 'StackSwitcher' to represent child in a tab
    -- bar, so it should be short.
    stackAddTitled :: (StackClass self, WidgetClass child,
                       GlibString name, GlibString title) => self
     -> child
     -> name
     -> title
     -> IO ()
    stackAddTitled :: forall self child name title.
    (StackClass self, WidgetClass child, GlibString name,
     GlibString title) =>
    self -> child -> name -> title -> IO ()
    stackAddTitled self
    self child
    child name
    name title
    title =
      name -> (CString -> IO ()) -> IO ()
    forall a. name -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString name
    name ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CString
    namePtr ->
        title -> (CString -> IO ()) -> IO ()
    forall a. title -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString title
    title ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CString
    titlePtr ->
          (\(Stack ForeignPtr Stack
    arg1) (Widget ForeignPtr Widget
    arg2) CString
    arg3 CString
    arg4 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->ForeignPtr Widget -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Widget
    arg2 ((Ptr Widget -> IO ()) -> IO ()) -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Widget
    argPtr2 ->Ptr Stack -> Ptr Widget -> CString -> CString -> IO ()
    gtk_stack_add_titled Ptr Stack
    argPtr1 Ptr Widget
    argPtr2 CString
    arg3 CString
    arg4)
    {-# LINE 161 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
            (self -> Stack
    forall o. StackClass o => o -> Stack
    toStack self
    self)
            (child -> Widget
    forall o. WidgetClass o => o -> Widget
    toWidget child
    child)
            CString
    namePtr
            CString
    titlePtr

    -- | Sets the type of animation that will be used for transitions
    -- between pages in stack . Available types include various kinds of
    -- fades and slides. The transition type can be changed without
    -- problems at runtime, so it is possible to change the animation
    -- based on the page that is about to become current.
    stackSetTransitionType :: StackClass self => self
     -> StackTransitionType
     -> IO ()
    stackSetTransitionType :: forall self.
    StackClass self =>
    self -> StackTransitionType -> IO ()
    stackSetTransitionType self
    self StackTransitionType
    transitionType =
      (\(Stack ForeignPtr Stack
    arg1) CInt
    arg2 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CInt -> IO ()
    gtk_stack_set_transition_type Ptr Stack
    argPtr1 CInt
    arg2)
    {-# LINE 176 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> Int -> CInt
    forall a b. (a -> b) -> a -> b
    $ StackTransitionType -> Int
    forall a. Enum a => a -> Int
    fromEnum StackTransitionType
    transitionType)

    -- | Gets the type of animation that will be used for transitions
    -- between pages in stack.
    stackGetTransitionType :: StackClass self => self
     -> IO StackTransitionType
    stackGetTransitionType :: forall self. StackClass self => self -> IO StackTransitionType
    stackGetTransitionType self
    self =
      (CInt -> StackTransitionType) -> IO CInt -> IO StackTransitionType
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> StackTransitionType
    forall a. Enum a => Int -> a
    toEnum (Int -> StackTransitionType)
    -> (CInt -> Int) -> CInt -> StackTransitionType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) (IO CInt -> IO StackTransitionType)
    -> IO CInt -> IO StackTransitionType
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CInt) -> IO CInt)
    -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CInt
    gtk_stack_get_transition_type Ptr Stack
    argPtr1)
    {-# LINE 186 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Sets the duration that transitions between pages in stack will
    -- take.
    stackSetTransitionDuration :: StackClass self => self
     -> Int
     -> IO ()
    stackSetTransitionDuration :: forall self. StackClass self => self -> Int -> IO ()
    stackSetTransitionDuration self
    self Int
    duration =
      (\(Stack ForeignPtr Stack
    arg1) CUInt
    arg2 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CUInt -> IO ()
    gtk_stack_set_transition_duration Ptr Stack
    argPtr1 CUInt
    arg2)
    {-# LINE 195 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)
        (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    duration)

    -- | Returns the amount of time (in milliseconds) that transitions
    -- between pages in stack will take.
    stackGetTransitionDuration :: StackClass self => self
     -> IO Int
    stackGetTransitionDuration :: forall self. StackClass self => self -> IO Int
    stackGetTransitionDuration self
    self =
      (CUInt -> Int) -> IO CUInt -> IO Int
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (IO CUInt -> IO Int) -> IO CUInt -> IO Int
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CUInt) -> IO CUInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CUInt) -> IO CUInt)
    -> (Ptr Stack -> IO CUInt) -> IO CUInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CUInt
    gtk_stack_get_transition_duration Ptr Stack
    argPtr1)
    {-# LINE 205 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Finds the child of the GtkStack with the name given as the
    -- argument. Returns Nothing if there is no child with this name.
    stackGetChildByName :: (StackClass self, GlibString name) => self
     -> name
     -> IO Widget
    stackGetChildByName :: forall self name.
    (StackClass self, GlibString name) =>
    self -> name -> IO Widget
    stackGetChildByName self
    self name
    name =
      name -> (CString -> IO Widget) -> IO Widget
    forall a. name -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString name
    name ((CString -> IO Widget) -> IO Widget)
    -> (CString -> IO Widget) -> IO Widget
    forall a b. (a -> b) -> a -> b
    $ \CString
    namePtr ->
        (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    -> IO (Ptr Widget) -> IO Widget
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    forall {a}. (ForeignPtr Widget -> Widget, FinalizerPtr a)
    mkWidget (IO (Ptr Widget) -> IO Widget) -> IO (Ptr Widget) -> IO Widget
    forall a b. (a -> b) -> a -> b
    $
        (\(Stack ForeignPtr Stack
    arg1) CString
    arg2 -> ForeignPtr Stack
    -> (Ptr Stack -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr Stack -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CString -> IO (Ptr Widget)
    gtk_stack_get_child_by_name Ptr Stack
    argPtr1 CString
    arg2)
    {-# LINE 216 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
          (toStack self)
          CString
    namePtr

    -- | Gets Just the currently visible child of stack, or Nothing if
    -- there are no visible children.
    stackGetVisibleChild :: StackClass self => self
     -> IO (Maybe Widget)
    stackGetVisibleChild :: forall self. StackClass self => self -> IO (Maybe Widget)
    stackGetVisibleChild self
    self =
      (IO (Ptr Widget) -> IO Widget)
    -> IO (Ptr Widget) -> IO (Maybe Widget)
    forall a. (IO (Ptr a) -> IO a) -> IO (Ptr a) -> IO (Maybe a)
    maybeNull ((ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    -> IO (Ptr Widget) -> IO Widget
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    forall {a}. (ForeignPtr Widget -> Widget, FinalizerPtr a)
    mkWidget) (IO (Ptr Widget) -> IO (Maybe Widget))
    -> IO (Ptr Widget) -> IO (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack
    -> (Ptr Stack -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr Stack -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO (Ptr Widget)
    gtk_stack_get_visible_child Ptr Stack
    argPtr1)
    {-# LINE 226 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Makes child the visible child of stack. If child is different
    -- from the currently visible child, the transition between the two
    -- will be animated with the current transition type of stack. Note
    -- that the child widget has to be visible itself (see 'widgetShow')
    -- in order to become the visible child of stack.
    stackSetVisibleChild :: (StackClass self, WidgetClass child) => self
     -> child
     -> IO ()
    stackSetVisibleChild :: forall self child.
    (StackClass self, WidgetClass child) =>
    self -> child -> IO ()
    stackSetVisibleChild self
    self child
    child =
        (\(Stack ForeignPtr Stack
    arg1) (Widget ForeignPtr Widget
    arg2) -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->ForeignPtr Widget -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Widget
    arg2 ((Ptr Widget -> IO ()) -> IO ()) -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Widget
    argPtr2 ->Ptr Stack -> Ptr Widget -> IO ()
    gtk_stack_set_visible_child Ptr Stack
    argPtr1 Ptr Widget
    argPtr2)
    {-# LINE 238 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
          (toStack self)
          (child -> Widget
    forall o. WidgetClass o => o -> Widget
    toWidget child
    child)

    -- | Makes the child with the given name visible. If child is
    -- different from the currently visible child, the transition between
    -- the two will be animated with the current transition type of stack.
    -- Note that the child widget has to be visible itself (see
    -- `widgetShow') in order to become the visible child of stack.
    stackSetVisibleChildName :: (StackClass self, GlibString name) => self
     -> name
     -> IO ()
    stackSetVisibleChildName :: forall self name.
    (StackClass self, GlibString name) =>
    self -> name -> IO ()
    stackSetVisibleChildName self
    self name
    name =
      name -> (CString -> IO ()) -> IO ()
    forall a. name -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString name
    name ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CString
    namePtr ->
        (\(Stack ForeignPtr Stack
    arg1) CString
    arg2 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CString -> IO ()
    gtk_stack_set_visible_child_name Ptr Stack
    argPtr1 CString
    arg2)
    {-# LINE 252 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
          (toStack self)
          CString
    namePtr

    -- | Returns the name of the currently visible child of stack, or
    -- Nothing if there is no visible child.
    stackGetVisibleChildName :: (StackClass self, GlibString name) => self
     -> IO (Maybe name)
    stackGetVisibleChildName :: forall self name.
    (StackClass self, GlibString name) =>
    self -> IO (Maybe name)
    stackGetVisibleChildName self
    self =
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CString) -> IO CString
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CString) -> IO CString)
    -> (Ptr Stack -> IO CString) -> IO CString
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CString
    gtk_stack_get_visible_child_name Ptr Stack
    argPtr1)
    {-# LINE 261 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
          (toStack self)
      IO CString -> (CString -> IO (Maybe name)) -> IO (Maybe name)
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= CString -> IO (Maybe name)
    forall s. GlibString s => CString -> IO (Maybe s)
    maybePeekUTFString

    -- | Makes the child with the given name visible. Note that the child
    -- widget has to be visible itself (see 'widgetShow') in order to
    -- become the visible child of stack .
    stackSetVisibleChildFull :: (StackClass self, GlibString name) => self
     -> name
     -> StackTransitionType
     -> IO ()
    stackSetVisibleChildFull :: forall self name.
    (StackClass self, GlibString name) =>
    self -> name -> StackTransitionType -> IO ()
    stackSetVisibleChildFull self
    self name
    name StackTransitionType
    transitionType =
      name -> (CString -> IO ()) -> IO ()
    forall a. name -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString name
    name ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CString
    namePtr ->
        (\(Stack ForeignPtr Stack
    arg1) CString
    arg2 CInt
    arg3 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CString -> CInt -> IO ()
    gtk_stack_set_visible_child_full Ptr Stack
    argPtr1 CString
    arg2 CInt
    arg3)
    {-# LINE 274 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
          (toStack self)
          CString
    namePtr
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> Int -> CInt
    forall a b. (a -> b) -> a -> b
    $ StackTransitionType -> Int
    forall a. Enum a => a -> Int
    fromEnum StackTransitionType
    transitionType)

    -- | Sets the stack to be homogeneous or not. If it is homogeneous,
    -- the stack will request the same size for all its children. If it
    -- isn't, the stack may change size when a different child becomes
    -- visible.
    stackSetHomogeneous :: StackClass self => self -> Bool -> IO ()
    stackSetHomogeneous :: forall self. StackClass self => self -> Bool -> IO ()
    stackSetHomogeneous self
    self Bool
    homogeneous =
      (\(Stack ForeignPtr Stack
    arg1) CInt
    arg2 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CInt -> IO ()
    gtk_stack_set_homogeneous Ptr Stack
    argPtr1 CInt
    arg2)
    {-# LINE 286 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    homogeneous)

    -- | Gets whether stack is homogeneous. See 'stackSetHomogeneous'.
    stackGetHomogeneous :: StackClass self => self -> IO Bool
    stackGetHomogeneous :: forall self. StackClass self => self -> IO Bool
    stackGetHomogeneous self
    self =
      (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CInt) -> IO CInt)
    -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CInt
    gtk_stack_get_homogeneous Ptr Stack
    argPtr1)
    {-# LINE 294 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Sets the stack to be horizontally homogeneous or not. If it is
    -- homogeneous, the stack will request the same width for all its
    -- children. If it isn't, the stack may change width when a different
    -- child becomes visible.
    stackSetHhomogeneous :: StackClass self => self -> Bool -> IO ()
    stackSetHhomogeneous :: forall self. StackClass self => self -> Bool -> IO ()
    stackSetHhomogeneous self
    self Bool
    hhomogeneous =
      (\(Stack ForeignPtr Stack
    arg1) CInt
    arg2 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CInt -> IO ()
    gtk_stack_set_hhomogeneous Ptr Stack
    argPtr1 CInt
    arg2)
    {-# LINE 303 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    hhomogeneous)

    -- | Gets whether stack is horizontally homogeneous. See
    -- 'stackSetHhomogeneous'.
    stackGetHhomogeneous :: StackClass self => self -> IO Bool
    stackGetHhomogeneous :: forall self. StackClass self => self -> IO Bool
    stackGetHhomogeneous self
    self =
      (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CInt) -> IO CInt)
    -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CInt
    gtk_stack_get_hhomogeneous Ptr Stack
    argPtr1)
    {-# LINE 312 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Sets the stack to be vertically homogeneous or not. If it is
    -- homogeneous, the stack will request the same height for all its
    -- children. If it isn't, the stack may change height when a different
    -- child becomes visible.
    stackSetVhomogeneous :: StackClass self => self -> Bool -> IO ()
    stackSetVhomogeneous :: forall self. StackClass self => self -> Bool -> IO ()
    stackSetVhomogeneous self
    self Bool
    vhomogeneous =
      (\(Stack ForeignPtr Stack
    arg1) CInt
    arg2 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CInt -> IO ()
    gtk_stack_set_vhomogeneous Ptr Stack
    argPtr1 CInt
    arg2)
    {-# LINE 321 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    vhomogeneous)

    -- | Gets whether stack is vertically homogeneous. See
    -- 'stackSetVhomogeneous'.
    stackGetVhomogeneous :: StackClass self => self -> IO Bool
    stackGetVhomogeneous :: forall self. StackClass self => self -> IO Bool
    stackGetVhomogeneous self
    self =
      (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CInt) -> IO CInt)
    -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CInt
    gtk_stack_get_vhomogeneous Ptr Stack
    argPtr1)
    {-# LINE 330 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Returns whether the stack is currently in a transition from one
    -- page to another.
    stackGetTransitionRunning :: StackClass self => self -> IO Bool
    stackGetTransitionRunning :: forall self. StackClass self => self -> IO Bool
    stackGetTransitionRunning self
    self =
      (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CInt) -> IO CInt)
    -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CInt
    gtk_stack_get_transition_running Ptr Stack
    argPtr1)
    {-# LINE 339 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Returns whether the stack is set up to interpolate between the
    -- sizes of children on page switch.
    stackGetInterpolateSize :: StackClass self => self -> IO Bool
    stackGetInterpolateSize :: forall self. StackClass self => self -> IO Bool
    stackGetInterpolateSize self
    self =
      (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $
      (\(Stack ForeignPtr Stack
    arg1) -> ForeignPtr Stack -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO CInt) -> IO CInt)
    -> (Ptr Stack -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> IO CInt
    gtk_stack_get_interpolate_size Ptr Stack
    argPtr1)
    {-# LINE 348 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)

    -- | Sets whether or not the stack will interpolate its size when
    -- changing the visible child. If the 'interpolate-size' property is
    -- set to True, stack will interpolate its size between the current
    -- one and the one it'll take after changing the visible child,
    -- according to the set transition duration.
    stackSetInterpolateSize :: StackClass self => self -> Bool -> IO ()
    stackSetInterpolateSize :: forall self. StackClass self => self -> Bool -> IO ()
    stackSetInterpolateSize self
    self Bool
    interpolateSize =
      (\(Stack ForeignPtr Stack
    arg1) CInt
    arg2 -> ForeignPtr Stack -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Stack
    arg1 ((Ptr Stack -> IO ()) -> IO ()) -> (Ptr Stack -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Stack
    argPtr1 ->Ptr Stack -> CInt -> IO ()
    gtk_stack_set_interpolate_size Ptr Stack
    argPtr1 CInt
    arg2)
    {-# LINE 358 "./Graphics/UI/Gtk/Layout/Stack.chs" #-}
        (toStack self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    interpolateSize)

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

    -- | True if the stack allocates the same width for all children.
    stackHhomogeneous :: StackClass self => Attr self Bool
    stackHhomogeneous :: forall self. StackClass self => Attr self Bool
    stackHhomogeneous = (self -> IO Bool)
    -> (self -> Bool -> IO ()) -> ReadWriteAttr self Bool Bool
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO Bool
    forall self. StackClass self => self -> IO Bool
    stackGetHhomogeneous
      self -> Bool -> IO ()
    forall self. StackClass self => self -> Bool -> IO ()
    stackSetHhomogeneous

    -- | Homogeneous sizing.
    stackHomogeneous :: StackClass self => Attr self Bool
    stackHomogeneous :: forall self. StackClass self => Attr self Bool
    stackHomogeneous = (self -> IO Bool)
    -> (self -> Bool -> IO ()) -> ReadWriteAttr self Bool Bool
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO Bool
    forall self. StackClass self => self -> IO Bool
    stackGetHomogeneous
      self -> Bool -> IO ()
    forall self. StackClass self => self -> Bool -> IO ()
    stackSetHomogeneous

    -- | Whether or not the size should smoothly change when changing
    -- between differently sized children.
    stackInterpolateSize :: StackClass self => Attr self Bool
    stackInterpolateSize :: forall self. StackClass self => Attr self Bool
    stackInterpolateSize = (self -> IO Bool)
    -> (self -> Bool -> IO ()) -> ReadWriteAttr self Bool Bool
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO Bool
    forall self. StackClass self => self -> IO Bool
    stackGetInterpolateSize
      self -> Bool -> IO ()
    forall self. StackClass self => self -> Bool -> IO ()
    stackSetInterpolateSize

    -- | The animation duration, in milliseconds.
    stackTransitionDuration :: StackClass self => Attr self Int
    stackTransitionDuration :: forall self. StackClass self => Attr self Int
    stackTransitionDuration = (self -> IO Int)
    -> (self -> Int -> IO ()) -> ReadWriteAttr self Int Int
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO Int
    forall self. StackClass self => self -> IO Int
    stackGetTransitionDuration
      self -> Int -> IO ()
    forall self. StackClass self => self -> Int -> IO ()
    stackSetTransitionDuration

    -- | Whether or not the transition is currently running.
    stackTransitionRunning :: StackClass self => ReadAttr self Bool
    stackTransitionRunning :: forall self. StackClass self => ReadAttr self Bool
    stackTransitionRunning = (self -> IO Bool) -> ReadAttr self Bool
    forall o a. (o -> IO a) -> ReadAttr o a
    readAttr
      self -> IO Bool
    forall self. StackClass self => self -> IO Bool
    stackGetTransitionRunning

    -- | The type of animation used to transition.
    stackTransitionType :: StackClass self => Attr self StackTransitionType
    stackTransitionType :: forall self. StackClass self => Attr self StackTransitionType
    stackTransitionType = (self -> IO StackTransitionType)
    -> (self -> StackTransitionType -> IO ())
    -> ReadWriteAttr self StackTransitionType StackTransitionType
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO StackTransitionType
    forall self. StackClass self => self -> IO StackTransitionType
    stackGetTransitionType
      self -> StackTransitionType -> IO ()
    forall self.
    StackClass self =>
    self -> StackTransitionType -> IO ()
    stackSetTransitionType

    -- | True if the stack allocates the same height for all children.
    stackVhomogeneous :: StackClass self => Attr self Bool
    stackVhomogeneous :: forall self. StackClass self => Attr self Bool
    stackVhomogeneous = (self -> IO Bool)
    -> (self -> Bool -> IO ()) -> ReadWriteAttr self Bool Bool
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO Bool
    forall self. StackClass self => self -> IO Bool
    stackGetVhomogeneous
      self -> Bool -> IO ()
    forall self. StackClass self => self -> Bool -> IO ()
    stackSetVhomogeneous

    -- | The widget currently visible in the stack.
    stackVisibleChild :: StackClass self =>
      ReadWriteAttr self (Maybe Widget) Widget
    stackVisibleChild :: forall self.
    StackClass self =>
    ReadWriteAttr self (Maybe Widget) Widget
    stackVisibleChild = (self -> IO (Maybe Widget))
    -> (self -> Widget -> IO ())
    -> ReadWriteAttr self (Maybe Widget) Widget
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO (Maybe Widget)
    forall self. StackClass self => self -> IO (Maybe Widget)
    stackGetVisibleChild
      self -> Widget -> IO ()
    forall self child.
    (StackClass self, WidgetClass child) =>
    self -> child -> IO ()
    stackSetVisibleChild

    -- | The name of the widget currently visible in the stack.
    stackVisibleChildName :: StackClass self => ReadWriteAttr self (Maybe String) String
    stackVisibleChildName :: forall self.
    StackClass self =>
    ReadWriteAttr self (Maybe String) String
    stackVisibleChildName = (self -> IO (Maybe String))
    -> (self -> String -> IO ())
    -> ReadWriteAttr self (Maybe String) String
    forall o a b.
    (o -> IO a) -> (o -> b -> IO ()) -> ReadWriteAttr o a b
    newAttr
      self -> IO (Maybe String)
    forall self name.
    (StackClass self, GlibString name) =>
    self -> IO (Maybe name)
    stackGetVisibleChildName
      self -> String -> IO ()
    forall self name.
    (StackClass self, GlibString name) =>
    self -> name -> IO ()
    stackSetVisibleChildName

    foreign import ccall unsafe "gtk_stack_new"
      gtk_stack_new :: (IO (Ptr Widget))

    foreign import ccall safe "gtk_stack_add_named"
      gtk_stack_add_named :: ((Ptr Stack) -> ((Ptr Widget) -> ((Ptr CChar) -> (IO ()))))

    foreign import ccall safe "gtk_stack_add_titled"
      gtk_stack_add_titled :: ((Ptr Stack) -> ((Ptr Widget) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ())))))

    foreign import ccall unsafe "gtk_stack_set_transition_type"
      gtk_stack_set_transition_type :: ((Ptr Stack) -> (CInt -> (IO ())))

    foreign import ccall unsafe "gtk_stack_get_transition_type"
      gtk_stack_get_transition_type :: ((Ptr Stack) -> (IO CInt))

    foreign import ccall unsafe "gtk_stack_set_transition_duration"
      gtk_stack_set_transition_duration :: ((Ptr Stack) -> (CUInt -> (IO ())))

    foreign import ccall unsafe "gtk_stack_get_transition_duration"
      gtk_stack_get_transition_duration :: ((Ptr Stack) -> (IO CUInt))

    foreign import ccall unsafe "gtk_stack_get_child_by_name"
      gtk_stack_get_child_by_name :: ((Ptr Stack) -> ((Ptr CChar) -> (IO (Ptr Widget))))

    foreign import ccall unsafe "gtk_stack_get_visible_child"
      gtk_stack_get_visible_child :: ((Ptr Stack) -> (IO (Ptr Widget)))

    foreign import ccall unsafe "gtk_stack_set_visible_child"
      gtk_stack_set_visible_child :: ((Ptr Stack) -> ((Ptr Widget) -> (IO ())))

    foreign import ccall unsafe "gtk_stack_set_visible_child_name"
      gtk_stack_set_visible_child_name :: ((Ptr Stack) -> ((Ptr CChar) -> (IO ())))

    foreign import ccall unsafe "gtk_stack_get_visible_child_name"
      gtk_stack_get_visible_child_name :: ((Ptr Stack) -> (IO (Ptr CChar)))

    foreign import ccall unsafe "gtk_stack_set_visible_child_full"
      gtk_stack_set_visible_child_full :: ((Ptr Stack) -> ((Ptr CChar) -> (CInt -> (IO ()))))

    foreign import ccall safe "gtk_stack_set_homogeneous"
      gtk_stack_set_homogeneous :: ((Ptr Stack) -> (CInt -> (IO ())))

    foreign import ccall safe "gtk_stack_get_homogeneous"
      gtk_stack_get_homogeneous :: ((Ptr Stack) -> (IO CInt))

    foreign import ccall safe "gtk_stack_set_hhomogeneous"
      gtk_stack_set_hhomogeneous :: ((Ptr Stack) -> (CInt -> (IO ())))

    foreign import ccall safe "gtk_stack_get_hhomogeneous"
      gtk_stack_get_hhomogeneous :: ((Ptr Stack) -> (IO CInt))

    foreign import ccall safe "gtk_stack_set_vhomogeneous"
      gtk_stack_set_vhomogeneous :: ((Ptr Stack) -> (CInt -> (IO ())))

    foreign import ccall safe "gtk_stack_get_vhomogeneous"
      gtk_stack_get_vhomogeneous :: ((Ptr Stack) -> (IO CInt))

    foreign import ccall safe "gtk_stack_get_transition_running"
      gtk_stack_get_transition_running :: ((Ptr Stack) -> (IO CInt))

    foreign import ccall safe "gtk_stack_get_interpolate_size"
      gtk_stack_get_interpolate_size :: ((Ptr Stack) -> (IO CInt))

    foreign import ccall safe "gtk_stack_set_interpolate_size"
      gtk_stack_set_interpolate_size :: ((Ptr Stack) -> (CInt -> (IO ())))