    {-# LINE 2 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
    -- -*-haskell-*-
    -- GIMP Toolkit (GTK) Widget ToolItem
    --
    -- Author : Duncan Coutts
    --
    -- Created: 1 August 2004
    --
    -- Copyright (C) 2004-2005 Duncan Coutts
    --
    -- 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)
    --
    -- The base class of widgets that can be added to 'Toolbar'
    --
    -- * Module available since Gtk+ version 2.4
    --
    module Graphics.UI.Gtk.MenuComboToolbar.ToolItem (
    -- * Detail
    --
    -- | 'ToolItem's are widgets that can appear on a toolbar. To create a toolbar
    -- item that contain something else than a button, use 'toolItemNew'. Use
    -- 'containerAdd' to add a child widget to the tool item.
    --
    -- For toolbar items that contain buttons, see the 'ToolButton',
    -- 'ToggleToolButton' and 'RadioToolButton' classes.

    -- * Class Hierarchy
    -- |
    -- @
    -- | 'GObject'
    -- | +----'Object'
    -- | +----'Widget'
    -- | +----'Container'
    -- | +----'Bin'
    -- | +----ToolItem
    -- | +----'ToolButton'
    -- | +----'SeparatorToolItem'
    -- @

    -- * Types
      ToolItem,
      ToolItemClass,
      castToToolItem, gTypeToolItem,
      toToolItem,

    -- * Constructors
      toolItemNew,

    -- * Methods
      toolItemSetHomogeneous,
      toolItemGetHomogeneous,
      toolItemSetExpand,
      toolItemGetExpand,

      toolItemSetUseDragWindow,
      toolItemGetUseDragWindow,
      toolItemSetVisibleHorizontal,
      toolItemGetVisibleHorizontal,
      toolItemSetVisibleVertical,
      toolItemGetVisibleVertical,
      toolItemSetIsImportant,
      toolItemGetIsImportant,
      IconSize,
      toolItemGetIconSize,
      Orientation(..),
      toolItemGetOrientation,
      ToolbarStyle(..),
      toolItemGetToolbarStyle,
      ReliefStyle(..),
      toolItemGetReliefStyle,
      toolItemRetrieveProxyMenuItem,
      toolItemGetProxyMenuItem,
      toolItemSetProxyMenuItem,

      toolItemGetEllipsizeMode,
      toolItemGetTextAlignment,
      toolItemGetTextOrientation,
      toolItemGetTextSizeGroup,

    -- * Attributes
      toolItemVisibleHorizontal,
      toolItemVisibleVertical,
      toolItemIsImportant,
      toolItemExpand,
      toolItemHomogeneous,
      toolItemUseDragWindow,

      ) where

    import Control.Monad (liftM)

    import System.Glib.FFI
    import System.Glib.UTFString
    import System.Glib.Attributes
    import Graphics.UI.Gtk.Abstract.Object (makeNewObject)
    import Graphics.Rendering.Pango.Enums (EllipsizeMode (..))
    import Graphics.UI.Gtk.Misc.SizeGroup
    import Graphics.UI.Gtk.Types
    {-# LINE 117 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
    import Graphics.UI.Gtk.General.Structs (IconSize)
    import Graphics.UI.Gtk.General.Enums (Orientation(..), ToolbarStyle(..), ReliefStyle(..))

    {-# LINE 121 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}

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

    -- | Creates a new 'ToolItem'
    --
    toolItemNew :: IO ToolItem
    toolItemNew :: IO ToolItem
    toolItemNew =
      (ForeignPtr ToolItem -> ToolItem, FinalizerPtr ToolItem)
    -> IO (Ptr ToolItem) -> IO ToolItem
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr ToolItem -> ToolItem, FinalizerPtr ToolItem)
    forall {a}. (ForeignPtr ToolItem -> ToolItem, FinalizerPtr a)
    mkToolItem (IO (Ptr ToolItem) -> IO ToolItem)
    -> IO (Ptr ToolItem) -> IO ToolItem
    forall a b. (a -> b) -> a -> b
    $
      IO (Ptr ToolItem)
    gtk_tool_item_new
    {-# LINE 132 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}

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

    -- | Sets whether the tool item is to be allocated the same size as other
    -- homogeneous items. The effect is that all homogeneous items will have the
    -- same width as the widest of the items.
    --
    toolItemSetHomogeneous :: ToolItemClass self => self
     -> Bool -- ^ @homogeneous@ - whether @toolItem@ is the same size as other
              -- homogeneous items
     -> IO ()
    toolItemSetHomogeneous :: forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetHomogeneous self
    self Bool
    homogeneous =
      (\(ToolItem ForeignPtr ToolItem
    arg1) CInt
    arg2 -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO ()) -> IO ())
    -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> CInt -> IO ()
    gtk_tool_item_set_homogeneous Ptr ToolItem
    argPtr1 CInt
    arg2)
    {-# LINE 146 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    homogeneous)

    -- | Returns whether the tool item is the same size as other homogeneous items.
    -- See 'toolItemSetHomogeneous'.
    --
    toolItemGetHomogeneous :: ToolItemClass self => self -> IO Bool
    toolItemGetHomogeneous :: forall self. ToolItemClass self => self -> IO Bool
    toolItemGetHomogeneous 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
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_homogeneous Ptr ToolItem
    argPtr1)
    {-# LINE 156 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Sets whether the tool item is allocated extra space when there is more room
    -- on the toolbar then needed for the items. The effect is that the item gets
    -- bigger when the toolbar gets bigger and smaller when the toolbar gets
    -- smaller.
    --
    toolItemSetExpand :: ToolItemClass self => self -> Bool -> IO ()
    toolItemSetExpand :: forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetExpand self
    self Bool
    expand =
      (\(ToolItem ForeignPtr ToolItem
    arg1) CInt
    arg2 -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO ()) -> IO ())
    -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> CInt -> IO ()
    gtk_tool_item_set_expand Ptr ToolItem
    argPtr1 CInt
    arg2)
    {-# LINE 166 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    expand)

    -- | Returns whether the tool item is allocated extra space. See
    -- 'toolItemSetExpand'.
    --
    toolItemGetExpand :: ToolItemClass self => self -> IO Bool
    toolItemGetExpand :: forall self. ToolItemClass self => self -> IO Bool
    toolItemGetExpand 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
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_expand Ptr ToolItem
    argPtr1)
    {-# LINE 176 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
    {-# LINE 199 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
    -- | Sets whether toolitem has a drag window. When @True@ the tool item can be
    -- used as a drag source through 'dragSourceSet'. When the tool item has a drag
    -- window it will intercept all events, even those that would otherwise be sent
    -- to a child widget.
    --
    toolItemSetUseDragWindow :: ToolItemClass self => self -> Bool -> IO ()
    toolItemSetUseDragWindow :: forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetUseDragWindow self
    self Bool
    useDragWindow =
      (\(ToolItem ForeignPtr ToolItem
    arg1) CInt
    arg2 -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO ()) -> IO ())
    -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> CInt -> IO ()
    gtk_tool_item_set_use_drag_window Ptr ToolItem
    argPtr1 CInt
    arg2)
    {-# LINE 207 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    useDragWindow)

    -- | Returns whether the tool item has a drag window. See
    -- 'toolItemSetUseDragWindow'.
    --
    toolItemGetUseDragWindow :: ToolItemClass self => self -> IO Bool
    toolItemGetUseDragWindow :: forall self. ToolItemClass self => self -> IO Bool
    toolItemGetUseDragWindow 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
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_use_drag_window Ptr ToolItem
    argPtr1)
    {-# LINE 217 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Sets whether the tool item is visible when the toolbar is docked
    -- horizontally.
    --
    toolItemSetVisibleHorizontal :: ToolItemClass self => self -> Bool -> IO ()
    toolItemSetVisibleHorizontal :: forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetVisibleHorizontal self
    self Bool
    visibleHorizontal =
      (\(ToolItem ForeignPtr ToolItem
    arg1) CInt
    arg2 -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO ()) -> IO ())
    -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> CInt -> IO ()
    gtk_tool_item_set_visible_horizontal Ptr ToolItem
    argPtr1 CInt
    arg2)
    {-# LINE 225 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    visibleHorizontal)

    -- | Returns whether the tool item is visible on toolbars that are docked
    -- horizontally.
    --
    toolItemGetVisibleHorizontal :: ToolItemClass self => self -> IO Bool
    toolItemGetVisibleHorizontal :: forall self. ToolItemClass self => self -> IO Bool
    toolItemGetVisibleHorizontal 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
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_visible_horizontal Ptr ToolItem
    argPtr1)
    {-# LINE 235 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Sets whether the tool item is visible when the toolbar is docked vertically.
    -- Some tool items, such as text entries, are too wide to be useful on a
    -- vertically docked toolbar. If @False@ the tool item will
    -- not appear on toolbars that are docked vertically.
    --
    toolItemSetVisibleVertical :: ToolItemClass self => self -> Bool -> IO ()
    toolItemSetVisibleVertical :: forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetVisibleVertical self
    self Bool
    visibleVertical =
      (\(ToolItem ForeignPtr ToolItem
    arg1) CInt
    arg2 -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO ()) -> IO ())
    -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> CInt -> IO ()
    gtk_tool_item_set_visible_vertical Ptr ToolItem
    argPtr1 CInt
    arg2)
    {-# LINE 245 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    visibleVertical)

    -- | Returns whether the tool item is visible when the toolbar is docked
    -- vertically. See 'toolItemSetVisibleVertical'.
    --
    toolItemGetVisibleVertical :: ToolItemClass self => self -> IO Bool
    toolItemGetVisibleVertical :: forall self. ToolItemClass self => self -> IO Bool
    toolItemGetVisibleVertical 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
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_visible_vertical Ptr ToolItem
    argPtr1)
    {-# LINE 255 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Sets whether the tool item should be considered important. The "ToolButton"
    -- class uses this property to determine whether to show or hide its label when
    -- the toolbar style is 'ToolbarBothHoriz'. The result is that only tool
    -- buttons with the \"is important\" property set have labels, an effect known
    -- as \"priority text\".
    --
    toolItemSetIsImportant :: ToolItemClass self => self -> Bool -> IO ()
    toolItemSetIsImportant :: forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetIsImportant self
    self Bool
    isImportant =
      (\(ToolItem ForeignPtr ToolItem
    arg1) CInt
    arg2 -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO ()) -> IO ())
    -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> CInt -> IO ()
    gtk_tool_item_set_is_important Ptr ToolItem
    argPtr1 CInt
    arg2)
    {-# LINE 266 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    isImportant)

    -- | Returns whether the tool item is considered important. See
    -- 'toolItemSetIsImportant'
    --
    toolItemGetIsImportant :: ToolItemClass self => self -> IO Bool
    toolItemGetIsImportant :: forall self. ToolItemClass self => self -> IO Bool
    toolItemGetIsImportant 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
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_is_important Ptr ToolItem
    argPtr1)
    {-# LINE 276 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Returns the icon size used for the tool item.
    --
    toolItemGetIconSize :: ToolItemClass self => self -> IO IconSize
    toolItemGetIconSize :: forall self. ToolItemClass self => self -> IO IconSize
    toolItemGetIconSize self
    self =
      (CInt -> IconSize) -> IO CInt -> IO IconSize
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> IconSize
    forall a. Enum a => Int -> a
    toEnum (Int -> IconSize) -> (CInt -> Int) -> CInt -> IconSize
    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 IconSize) -> IO CInt -> IO IconSize
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_icon_size Ptr ToolItem
    argPtr1)
    {-# LINE 284 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Returns the orientation used for the tool item.
    --
    toolItemGetOrientation :: ToolItemClass self => self -> IO Orientation
    toolItemGetOrientation :: forall self. ToolItemClass self => self -> IO Orientation
    toolItemGetOrientation self
    self =
      (CInt -> Orientation) -> IO CInt -> IO Orientation
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> Orientation
    forall a. Enum a => Int -> a
    toEnum (Int -> Orientation) -> (CInt -> Int) -> CInt -> Orientation
    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 Orientation) -> IO CInt -> IO Orientation
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_orientation Ptr ToolItem
    argPtr1)
    {-# LINE 292 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Returns the toolbar style used for the tool item.
    --
    -- Possibilities are:
    -- ['ToolbarBoth'] meaning the tool item should show both an icon and a label,
    -- stacked vertically
    -- ['ToolbarIcons'] meaning the toolbar shows only icons
    -- ['ToolbarText'] meaning the tool item should only show text
    -- ['ToolbarBothHoriz'] meaning the tool item should show both an icon and a
    -- label, arranged horizontally
    --
    toolItemGetToolbarStyle :: ToolItemClass self => self -> IO ToolbarStyle
    toolItemGetToolbarStyle :: forall self. ToolItemClass self => self -> IO ToolbarStyle
    toolItemGetToolbarStyle self
    self =
      (CInt -> ToolbarStyle) -> IO CInt -> IO ToolbarStyle
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> ToolbarStyle
    forall a. Enum a => Int -> a
    toEnum (Int -> ToolbarStyle) -> (CInt -> Int) -> CInt -> ToolbarStyle
    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 ToolbarStyle) -> IO CInt -> IO ToolbarStyle
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_toolbar_style Ptr ToolItem
    argPtr1)
    {-# LINE 308 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Returns the relief style of the tool item. See 'buttonSetReliefStyle'.
    --
    toolItemGetReliefStyle :: ToolItemClass self => self -> IO ReliefStyle
    toolItemGetReliefStyle :: forall self. ToolItemClass self => self -> IO ReliefStyle
    toolItemGetReliefStyle self
    self =
      (CInt -> ReliefStyle) -> IO CInt -> IO ReliefStyle
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> ReliefStyle
    forall a. Enum a => Int -> a
    toEnum (Int -> ReliefStyle) -> (CInt -> Int) -> CInt -> ReliefStyle
    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 ReliefStyle) -> IO CInt -> IO ReliefStyle
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_relief_style Ptr ToolItem
    argPtr1)
    {-# LINE 316 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | Returns the 'MenuItem' that was last set by 'toolItemSetProxyMenuItem',
    -- ie. the 'MenuItem' that is going to appear in the overflow menu.
    --
    toolItemRetrieveProxyMenuItem :: ToolItemClass self => self -> IO (Maybe Widget)
    toolItemRetrieveProxyMenuItem :: forall self. ToolItemClass self => self -> IO (Maybe Widget)
    toolItemRetrieveProxyMenuItem 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
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem
    -> (Ptr ToolItem -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr ToolItem -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO (Ptr Widget)
    gtk_tool_item_retrieve_proxy_menu_item Ptr ToolItem
    argPtr1)
    {-# LINE 325 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)

    -- | If @menuItemId@ matches the string passed to 'toolItemSetProxyMenuItem'
    -- return the corresponding 'MenuItem'.
    --
    toolItemGetProxyMenuItem :: (ToolItemClass self, GlibString string) => self
     -> string -- ^ @menuItemId@ - a string used to identify the menu
                          -- item
     -> IO (Maybe Widget) -- ^ returns The 'MenuItem' passed to
                          -- 'toolItemSetProxyMenuItem', if the @menuItemId@s
                          -- match.
    toolItemGetProxyMenuItem :: forall self string.
    (ToolItemClass self, GlibString string) =>
    self -> string -> IO (Maybe Widget)
    toolItemGetProxyMenuItem self
    self string
    menuItemId =
      (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
    $
      string -> (CString -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a. string -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString string
    menuItemId ((CString -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (CString -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \CString
    menuItemIdPtr ->
      (\(ToolItem ForeignPtr ToolItem
    arg1) CString
    arg2 -> ForeignPtr ToolItem
    -> (Ptr ToolItem -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr ToolItem -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> CString -> IO (Ptr Widget)
    gtk_tool_item_get_proxy_menu_item Ptr ToolItem
    argPtr1 CString
    arg2)
    {-# LINE 340 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        CString
    menuItemIdPtr

    -- | Sets the 'MenuItem' used in the toolbar overflow menu. The @menuItemId@
    -- is used to identify the caller of this function and should also be used with
    -- 'toolItemGetProxyMenuItem'.
    --
    toolItemSetProxyMenuItem :: (ToolItemClass self, MenuItemClass menuItem, GlibString string) => self
     -> string -- ^ @menuItemId@ - a string used to identify @menuItem@
     -> menuItem -- ^ @menuItem@ - a 'MenuItem' to be used in the overflow menu
     -> IO ()
    toolItemSetProxyMenuItem :: forall self menuItem string.
    (ToolItemClass self, MenuItemClass menuItem, GlibString string) =>
    self -> string -> menuItem -> IO ()
    toolItemSetProxyMenuItem self
    self string
    menuItemId menuItem
    menuItem =
      string -> (CString -> IO ()) -> IO ()
    forall a. string -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString string
    menuItemId ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \CString
    menuItemIdPtr ->
      (\(ToolItem ForeignPtr ToolItem
    arg1) CString
    arg2 (Widget ForeignPtr Widget
    arg3) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO ()) -> IO ())
    -> (Ptr ToolItem -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->ForeignPtr Widget -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Widget
    arg3 ((Ptr Widget -> IO ()) -> IO ()) -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Widget
    argPtr3 ->Ptr ToolItem -> CString -> Ptr Widget -> IO ()
    gtk_tool_item_set_proxy_menu_item Ptr ToolItem
    argPtr1 CString
    arg2 Ptr Widget
    argPtr3)
    {-# LINE 354 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem self)
        CString
    menuItemIdPtr
        (menuItem -> Widget
    forall o. WidgetClass o => o -> Widget
    toWidget menuItem
    menuItem)

    -- | Returns the ellipsize mode used for @toolItem@. Custom subclasses of 'ToolItem' should call this
    -- function to find out how text should be ellipsized.
    --
    -- * Available since Gtk+ version 2.20
    --
    toolItemGetEllipsizeMode :: ToolItemClass item => item
                             -> IO EllipsizeMode -- ^ returns a PangoEllipsizeMode indicating how text in @toolItem@ should be ellipsized.
    toolItemGetEllipsizeMode :: forall item. ToolItemClass item => item -> IO EllipsizeMode
    toolItemGetEllipsizeMode item
    item =
      (CInt -> EllipsizeMode) -> IO CInt -> IO EllipsizeMode
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> EllipsizeMode
    forall a. Enum a => Int -> a
    toEnum (Int -> EllipsizeMode) -> (CInt -> Int) -> CInt -> EllipsizeMode
    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 EllipsizeMode) -> IO CInt -> IO EllipsizeMode
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_ellipsize_mode Ptr ToolItem
    argPtr1)
    {-# LINE 369 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
        (toToolItem item)

    -- | Returns the text alignment used for @toolItem@. Custom subclasses of 'ToolItem' should call this
    -- function to find out how text should be aligned.
    toolItemGetTextAlignment :: ToolItemClass item => item
                             -> IO Double -- ^ returns a gfloat indicating the horizontal text alignment used for @toolItem@
    toolItemGetTextAlignment :: forall item. ToolItemClass item => item -> IO Double
    toolItemGetTextAlignment item
    item =
      (CFloat -> Double) -> IO CFloat -> IO Double
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CFloat -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac (IO CFloat -> IO Double) -> IO CFloat -> IO Double
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CFloat) -> IO CFloat
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CFloat) -> IO CFloat)
    -> (Ptr ToolItem -> IO CFloat) -> IO CFloat
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CFloat
    gtk_tool_item_get_text_alignment Ptr ToolItem
    argPtr1)
    {-# LINE 378 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
         (toToolItem item)

    -- | Returns the text orientation used for @toolItem@. Custom subclasses of 'ToolItem' should call this
    -- function to find out how text should be orientated.
    toolItemGetTextOrientation :: ToolItemClass item => item
                               -> IO Orientation -- ^ returns a 'Orientation' indicating the orientation used for @toolItem@
    toolItemGetTextOrientation :: forall self. ToolItemClass self => self -> IO Orientation
    toolItemGetTextOrientation item
    item =
      (CInt -> Orientation) -> IO CInt -> IO Orientation
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> Orientation
    forall a. Enum a => Int -> a
    toEnum (Int -> Orientation) -> (CInt -> Int) -> CInt -> Orientation
    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 Orientation) -> IO CInt -> IO Orientation
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO CInt) -> IO CInt)
    -> (Ptr ToolItem -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO CInt
    gtk_tool_item_get_text_orientation Ptr ToolItem
    argPtr1)
    {-# LINE 387 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
         (toToolItem item)

    -- | Returns the size group used for labels in @toolItem@. Custom subclasses of 'ToolItem' should call
    -- this function and use the size group for labels.
    toolItemGetTextSizeGroup :: ToolItemClass item => item
                             -> IO SizeGroup
    toolItemGetTextSizeGroup :: forall item. ToolItemClass item => item -> IO SizeGroup
    toolItemGetTextSizeGroup item
    item =
      (ForeignPtr SizeGroup -> SizeGroup, FinalizerPtr SizeGroup)
    -> IO (Ptr SizeGroup) -> IO SizeGroup
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewGObject (ForeignPtr SizeGroup -> SizeGroup, FinalizerPtr SizeGroup)
    forall {a}. (ForeignPtr SizeGroup -> SizeGroup, FinalizerPtr a)
    mkSizeGroup (IO (Ptr SizeGroup) -> IO SizeGroup)
    -> IO (Ptr SizeGroup) -> IO SizeGroup
    forall a b. (a -> b) -> a -> b
    $
      (\(ToolItem ForeignPtr ToolItem
    arg1) -> ForeignPtr ToolItem
    -> (Ptr ToolItem -> IO (Ptr SizeGroup)) -> IO (Ptr SizeGroup)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr ToolItem
    arg1 ((Ptr ToolItem -> IO (Ptr SizeGroup)) -> IO (Ptr SizeGroup))
    -> (Ptr ToolItem -> IO (Ptr SizeGroup)) -> IO (Ptr SizeGroup)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ToolItem
    argPtr1 ->Ptr ToolItem -> IO (Ptr SizeGroup)
    gtk_tool_item_get_text_size_group Ptr ToolItem
    argPtr1)
    {-# LINE 396 "./Graphics/UI/Gtk/MenuComboToolbar/ToolItem.chs" #-}
         (toToolItem item)

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

    -- | Whether the toolbar item is visible when the toolbar is in a horizontal
    -- orientation.
    --
    -- Default value: @True@
    --
    toolItemVisibleHorizontal :: ToolItemClass self => Attr self Bool
    toolItemVisibleHorizontal :: forall self. ToolItemClass self => Attr self Bool
    toolItemVisibleHorizontal = (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. ToolItemClass self => self -> IO Bool
    toolItemGetVisibleHorizontal
      self -> Bool -> IO ()
    forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetVisibleHorizontal

    -- | Whether the toolbar item is visible when the toolbar is in a vertical
    -- orientation.
    --
    -- Default value: @True@
    --
    toolItemVisibleVertical :: ToolItemClass self => Attr self Bool
    toolItemVisibleVertical :: forall self. ToolItemClass self => Attr self Bool
    toolItemVisibleVertical = (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. ToolItemClass self => self -> IO Bool
    toolItemGetVisibleVertical
      self -> Bool -> IO ()
    forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetVisibleVertical

    -- | Whether the toolbar item is considered important. When @True@, toolbar
    -- buttons show text in 'ToolbarBothHoriz' mode.
    --
    -- Default value: @False@
    --
    toolItemIsImportant :: ToolItemClass self => Attr self Bool
    toolItemIsImportant :: forall self. ToolItemClass self => Attr self Bool
    toolItemIsImportant = (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. ToolItemClass self => self -> IO Bool
    toolItemGetIsImportant
      self -> Bool -> IO ()
    forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetIsImportant

    -- | \'expand\' property. See 'toolItemGetExpand' and 'toolItemSetExpand'
    --
    toolItemExpand :: ToolItemClass self => Attr self Bool
    toolItemExpand :: forall self. ToolItemClass self => Attr self Bool
    toolItemExpand = (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. ToolItemClass self => self -> IO Bool
    toolItemGetExpand
      self -> Bool -> IO ()
    forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetExpand

    -- | \'homogeneous\' property. See 'toolItemGetHomogeneous' and
    -- 'toolItemSetHomogeneous'
    --
    toolItemHomogeneous :: ToolItemClass self => Attr self Bool
    toolItemHomogeneous :: forall self. ToolItemClass self => Attr self Bool
    toolItemHomogeneous = (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. ToolItemClass self => self -> IO Bool
    toolItemGetHomogeneous
      self -> Bool -> IO ()
    forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetHomogeneous

    -- | \'useDragWindow\' property. See 'toolItemGetUseDragWindow' and
    -- 'toolItemSetUseDragWindow'
    --
    toolItemUseDragWindow :: ToolItemClass self => Attr self Bool
    toolItemUseDragWindow :: forall self. ToolItemClass self => Attr self Bool
    toolItemUseDragWindow = (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. ToolItemClass self => self -> IO Bool
    toolItemGetUseDragWindow
      self -> Bool -> IO ()
    forall self. ToolItemClass self => self -> Bool -> IO ()
    toolItemSetUseDragWindow

    foreign import ccall unsafe "gtk_tool_item_new"
      gtk_tool_item_new :: (IO (Ptr ToolItem))

    foreign import ccall safe "gtk_tool_item_set_homogeneous"
      gtk_tool_item_set_homogeneous :: ((Ptr ToolItem) -> (CInt -> (IO ())))

    foreign import ccall unsafe "gtk_tool_item_get_homogeneous"
      gtk_tool_item_get_homogeneous :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall safe "gtk_tool_item_set_expand"
      gtk_tool_item_set_expand :: ((Ptr ToolItem) -> (CInt -> (IO ())))

    foreign import ccall unsafe "gtk_tool_item_get_expand"
      gtk_tool_item_get_expand :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall safe "gtk_tool_item_set_use_drag_window"
      gtk_tool_item_set_use_drag_window :: ((Ptr ToolItem) -> (CInt -> (IO ())))

    foreign import ccall unsafe "gtk_tool_item_get_use_drag_window"
      gtk_tool_item_get_use_drag_window :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall safe "gtk_tool_item_set_visible_horizontal"
      gtk_tool_item_set_visible_horizontal :: ((Ptr ToolItem) -> (CInt -> (IO ())))

    foreign import ccall unsafe "gtk_tool_item_get_visible_horizontal"
      gtk_tool_item_get_visible_horizontal :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall safe "gtk_tool_item_set_visible_vertical"
      gtk_tool_item_set_visible_vertical :: ((Ptr ToolItem) -> (CInt -> (IO ())))

    foreign import ccall unsafe "gtk_tool_item_get_visible_vertical"
      gtk_tool_item_get_visible_vertical :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall safe "gtk_tool_item_set_is_important"
      gtk_tool_item_set_is_important :: ((Ptr ToolItem) -> (CInt -> (IO ())))

    foreign import ccall unsafe "gtk_tool_item_get_is_important"
      gtk_tool_item_get_is_important :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall unsafe "gtk_tool_item_get_icon_size"
      gtk_tool_item_get_icon_size :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall unsafe "gtk_tool_item_get_orientation"
      gtk_tool_item_get_orientation :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall unsafe "gtk_tool_item_get_toolbar_style"
      gtk_tool_item_get_toolbar_style :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall unsafe "gtk_tool_item_get_relief_style"
      gtk_tool_item_get_relief_style :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall unsafe "gtk_tool_item_retrieve_proxy_menu_item"
      gtk_tool_item_retrieve_proxy_menu_item :: ((Ptr ToolItem) -> (IO (Ptr Widget)))

    foreign import ccall unsafe "gtk_tool_item_get_proxy_menu_item"
      gtk_tool_item_get_proxy_menu_item :: ((Ptr ToolItem) -> ((Ptr CChar) -> (IO (Ptr Widget))))

    foreign import ccall safe "gtk_tool_item_set_proxy_menu_item"
      gtk_tool_item_set_proxy_menu_item :: ((Ptr ToolItem) -> ((Ptr CChar) -> ((Ptr Widget) -> (IO ()))))

    foreign import ccall safe "gtk_tool_item_get_ellipsize_mode"
      gtk_tool_item_get_ellipsize_mode :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall safe "gtk_tool_item_get_text_alignment"
      gtk_tool_item_get_text_alignment :: ((Ptr ToolItem) -> (IO CFloat))

    foreign import ccall safe "gtk_tool_item_get_text_orientation"
      gtk_tool_item_get_text_orientation :: ((Ptr ToolItem) -> (IO CInt))

    foreign import ccall safe "gtk_tool_item_get_text_size_group"
      gtk_tool_item_get_text_size_group :: ((Ptr ToolItem) -> (IO (Ptr SizeGroup)))