{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

@/GtkToolItems/@ are widgets that can appear on a toolbar. To
create a toolbar item that contain something else than a button, use
'GI.Gtk.Objects.ToolItem.toolItemNew'. Use 'GI.Gtk.Objects.Container.containerAdd' to add a child
widget to the tool item.

For toolbar items that contain buttons, see the 'GI.Gtk.Objects.ToolButton.ToolButton',
'GI.Gtk.Objects.ToggleToolButton.ToggleToolButton' and 'GI.Gtk.Objects.RadioToolButton.RadioToolButton' classes.

See the 'GI.Gtk.Objects.Toolbar.Toolbar' class for a description of the toolbar widget, and
'GI.Gtk.Interfaces.ToolShell.ToolShell' for a description of the tool shell interface.
-}

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

module GI.Gtk.Objects.ToolItem
    (

-- * Exported types
    ToolItem(..)                            ,
    IsToolItem                              ,
    toToolItem                              ,
    noToolItem                              ,


 -- * Methods
-- ** getEllipsizeMode #method:getEllipsizeMode#

#if ENABLE_OVERLOADING
    ToolItemGetEllipsizeModeMethodInfo      ,
#endif
    toolItemGetEllipsizeMode                ,


-- ** getExpand #method:getExpand#

#if ENABLE_OVERLOADING
    ToolItemGetExpandMethodInfo             ,
#endif
    toolItemGetExpand                       ,


-- ** getHomogeneous #method:getHomogeneous#

#if ENABLE_OVERLOADING
    ToolItemGetHomogeneousMethodInfo        ,
#endif
    toolItemGetHomogeneous                  ,


-- ** getIconSize #method:getIconSize#

#if ENABLE_OVERLOADING
    ToolItemGetIconSizeMethodInfo           ,
#endif
    toolItemGetIconSize                     ,


-- ** getIsImportant #method:getIsImportant#

#if ENABLE_OVERLOADING
    ToolItemGetIsImportantMethodInfo        ,
#endif
    toolItemGetIsImportant                  ,


-- ** getOrientation #method:getOrientation#

#if ENABLE_OVERLOADING
    ToolItemGetOrientationMethodInfo        ,
#endif
    toolItemGetOrientation                  ,


-- ** getProxyMenuItem #method:getProxyMenuItem#

#if ENABLE_OVERLOADING
    ToolItemGetProxyMenuItemMethodInfo      ,
#endif
    toolItemGetProxyMenuItem                ,


-- ** getReliefStyle #method:getReliefStyle#

#if ENABLE_OVERLOADING
    ToolItemGetReliefStyleMethodInfo        ,
#endif
    toolItemGetReliefStyle                  ,


-- ** getTextAlignment #method:getTextAlignment#

#if ENABLE_OVERLOADING
    ToolItemGetTextAlignmentMethodInfo      ,
#endif
    toolItemGetTextAlignment                ,


-- ** getTextOrientation #method:getTextOrientation#

#if ENABLE_OVERLOADING
    ToolItemGetTextOrientationMethodInfo    ,
#endif
    toolItemGetTextOrientation              ,


-- ** getTextSizeGroup #method:getTextSizeGroup#

#if ENABLE_OVERLOADING
    ToolItemGetTextSizeGroupMethodInfo      ,
#endif
    toolItemGetTextSizeGroup                ,


-- ** getToolbarStyle #method:getToolbarStyle#

#if ENABLE_OVERLOADING
    ToolItemGetToolbarStyleMethodInfo       ,
#endif
    toolItemGetToolbarStyle                 ,


-- ** getUseDragWindow #method:getUseDragWindow#

#if ENABLE_OVERLOADING
    ToolItemGetUseDragWindowMethodInfo      ,
#endif
    toolItemGetUseDragWindow                ,


-- ** getVisibleHorizontal #method:getVisibleHorizontal#

#if ENABLE_OVERLOADING
    ToolItemGetVisibleHorizontalMethodInfo  ,
#endif
    toolItemGetVisibleHorizontal            ,


-- ** getVisibleVertical #method:getVisibleVertical#

#if ENABLE_OVERLOADING
    ToolItemGetVisibleVerticalMethodInfo    ,
#endif
    toolItemGetVisibleVertical              ,


-- ** new #method:new#

    toolItemNew                             ,


-- ** rebuildMenu #method:rebuildMenu#

#if ENABLE_OVERLOADING
    ToolItemRebuildMenuMethodInfo           ,
#endif
    toolItemRebuildMenu                     ,


-- ** retrieveProxyMenuItem #method:retrieveProxyMenuItem#

#if ENABLE_OVERLOADING
    ToolItemRetrieveProxyMenuItemMethodInfo ,
#endif
    toolItemRetrieveProxyMenuItem           ,


-- ** setExpand #method:setExpand#

#if ENABLE_OVERLOADING
    ToolItemSetExpandMethodInfo             ,
#endif
    toolItemSetExpand                       ,


-- ** setHomogeneous #method:setHomogeneous#

#if ENABLE_OVERLOADING
    ToolItemSetHomogeneousMethodInfo        ,
#endif
    toolItemSetHomogeneous                  ,


-- ** setIsImportant #method:setIsImportant#

#if ENABLE_OVERLOADING
    ToolItemSetIsImportantMethodInfo        ,
#endif
    toolItemSetIsImportant                  ,


-- ** setProxyMenuItem #method:setProxyMenuItem#

#if ENABLE_OVERLOADING
    ToolItemSetProxyMenuItemMethodInfo      ,
#endif
    toolItemSetProxyMenuItem                ,


-- ** setTooltipMarkup #method:setTooltipMarkup#

#if ENABLE_OVERLOADING
    ToolItemSetTooltipMarkupMethodInfo      ,
#endif
    toolItemSetTooltipMarkup                ,


-- ** setTooltipText #method:setTooltipText#

#if ENABLE_OVERLOADING
    ToolItemSetTooltipTextMethodInfo        ,
#endif
    toolItemSetTooltipText                  ,


-- ** setUseDragWindow #method:setUseDragWindow#

#if ENABLE_OVERLOADING
    ToolItemSetUseDragWindowMethodInfo      ,
#endif
    toolItemSetUseDragWindow                ,


-- ** setVisibleHorizontal #method:setVisibleHorizontal#

#if ENABLE_OVERLOADING
    ToolItemSetVisibleHorizontalMethodInfo  ,
#endif
    toolItemSetVisibleHorizontal            ,


-- ** setVisibleVertical #method:setVisibleVertical#

#if ENABLE_OVERLOADING
    ToolItemSetVisibleVerticalMethodInfo    ,
#endif
    toolItemSetVisibleVertical              ,


-- ** toolbarReconfigured #method:toolbarReconfigured#

#if ENABLE_OVERLOADING
    ToolItemToolbarReconfiguredMethodInfo   ,
#endif
    toolItemToolbarReconfigured             ,




 -- * Properties
-- ** isImportant #attr:isImportant#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ToolItemIsImportantPropertyInfo         ,
#endif
    constructToolItemIsImportant            ,
    getToolItemIsImportant                  ,
    setToolItemIsImportant                  ,
#if ENABLE_OVERLOADING
    toolItemIsImportant                     ,
#endif


-- ** visibleHorizontal #attr:visibleHorizontal#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ToolItemVisibleHorizontalPropertyInfo   ,
#endif
    constructToolItemVisibleHorizontal      ,
    getToolItemVisibleHorizontal            ,
    setToolItemVisibleHorizontal            ,
#if ENABLE_OVERLOADING
    toolItemVisibleHorizontal               ,
#endif


-- ** visibleVertical #attr:visibleVertical#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ToolItemVisibleVerticalPropertyInfo     ,
#endif
    constructToolItemVisibleVertical        ,
    getToolItemVisibleVertical              ,
    setToolItemVisibleVertical              ,
#if ENABLE_OVERLOADING
    toolItemVisibleVertical                 ,
#endif




 -- * Signals
-- ** createMenuProxy #signal:createMenuProxy#

    C_ToolItemCreateMenuProxyCallback       ,
    ToolItemCreateMenuProxyCallback         ,
#if ENABLE_OVERLOADING
    ToolItemCreateMenuProxySignalInfo       ,
#endif
    afterToolItemCreateMenuProxy            ,
    genClosure_ToolItemCreateMenuProxy      ,
    mk_ToolItemCreateMenuProxyCallback      ,
    noToolItemCreateMenuProxyCallback       ,
    onToolItemCreateMenuProxy               ,
    wrap_ToolItemCreateMenuProxyCallback    ,


-- ** toolbarReconfigured #signal:toolbarReconfigured#

    C_ToolItemToolbarReconfiguredCallback   ,
    ToolItemToolbarReconfiguredCallback     ,
#if ENABLE_OVERLOADING
    ToolItemToolbarReconfiguredSignalInfo   ,
#endif
    afterToolItemToolbarReconfigured        ,
    genClosure_ToolItemToolbarReconfigured  ,
    mk_ToolItemToolbarReconfiguredCallback  ,
    noToolItemToolbarReconfiguredCallback   ,
    onToolItemToolbarReconfigured           ,
    wrap_ToolItemToolbarReconfiguredCallback,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Activatable as Gtk.Activatable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Bin as Gtk.Bin
import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
import {-# SOURCE #-} qualified GI.Gtk.Objects.SizeGroup as Gtk.SizeGroup
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Pango.Enums as Pango.Enums

-- | Memory-managed wrapper type.
newtype ToolItem = ToolItem (ManagedPtr ToolItem)
foreign import ccall "gtk_tool_item_get_type"
    c_gtk_tool_item_get_type :: IO GType

instance GObject ToolItem where
    gobjectType = c_gtk_tool_item_get_type


-- | Type class for types which can be safely cast to `ToolItem`, for instance with `toToolItem`.
class (GObject o, O.IsDescendantOf ToolItem o) => IsToolItem o
instance (GObject o, O.IsDescendantOf ToolItem o) => IsToolItem o

instance O.HasParentTypes ToolItem
type instance O.ParentTypes ToolItem = '[Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Activatable.Activatable, Gtk.Buildable.Buildable]

-- | Cast to `ToolItem`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toToolItem :: (MonadIO m, IsToolItem o) => o -> m ToolItem
toToolItem = liftIO . unsafeCastTo ToolItem

-- | A convenience alias for `Nothing` :: `Maybe` `ToolItem`.
noToolItem :: Maybe ToolItem
noToolItem = Nothing

#if ENABLE_OVERLOADING
type family ResolveToolItemMethod (t :: Symbol) (o :: *) :: * where
    ResolveToolItemMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveToolItemMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveToolItemMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveToolItemMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveToolItemMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveToolItemMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveToolItemMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveToolItemMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveToolItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveToolItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveToolItemMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveToolItemMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveToolItemMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveToolItemMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveToolItemMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveToolItemMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveToolItemMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveToolItemMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveToolItemMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveToolItemMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveToolItemMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveToolItemMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveToolItemMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveToolItemMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveToolItemMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveToolItemMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveToolItemMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveToolItemMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveToolItemMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveToolItemMethod "doSetRelatedAction" o = Gtk.Activatable.ActivatableDoSetRelatedActionMethodInfo
    ResolveToolItemMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveToolItemMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveToolItemMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveToolItemMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveToolItemMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveToolItemMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveToolItemMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveToolItemMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveToolItemMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveToolItemMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveToolItemMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveToolItemMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveToolItemMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveToolItemMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveToolItemMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveToolItemMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveToolItemMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveToolItemMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveToolItemMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveToolItemMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveToolItemMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveToolItemMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveToolItemMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveToolItemMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveToolItemMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveToolItemMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveToolItemMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveToolItemMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveToolItemMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveToolItemMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveToolItemMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveToolItemMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveToolItemMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveToolItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveToolItemMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveToolItemMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveToolItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveToolItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveToolItemMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveToolItemMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveToolItemMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveToolItemMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveToolItemMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveToolItemMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveToolItemMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveToolItemMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveToolItemMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveToolItemMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveToolItemMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveToolItemMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveToolItemMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveToolItemMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveToolItemMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveToolItemMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveToolItemMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveToolItemMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveToolItemMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveToolItemMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveToolItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveToolItemMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveToolItemMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveToolItemMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveToolItemMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveToolItemMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveToolItemMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveToolItemMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveToolItemMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveToolItemMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveToolItemMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveToolItemMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveToolItemMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveToolItemMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveToolItemMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveToolItemMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveToolItemMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveToolItemMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveToolItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveToolItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveToolItemMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveToolItemMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveToolItemMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveToolItemMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveToolItemMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveToolItemMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveToolItemMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveToolItemMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveToolItemMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveToolItemMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveToolItemMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveToolItemMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveToolItemMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveToolItemMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveToolItemMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveToolItemMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveToolItemMethod "rebuildMenu" o = ToolItemRebuildMenuMethodInfo
    ResolveToolItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveToolItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveToolItemMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveToolItemMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveToolItemMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveToolItemMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveToolItemMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveToolItemMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveToolItemMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveToolItemMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveToolItemMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveToolItemMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveToolItemMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveToolItemMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveToolItemMethod "retrieveProxyMenuItem" o = ToolItemRetrieveProxyMenuItemMethodInfo
    ResolveToolItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveToolItemMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveToolItemMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveToolItemMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveToolItemMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveToolItemMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveToolItemMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveToolItemMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveToolItemMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveToolItemMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveToolItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveToolItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveToolItemMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveToolItemMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveToolItemMethod "syncActionProperties" o = Gtk.Activatable.ActivatableSyncActionPropertiesMethodInfo
    ResolveToolItemMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveToolItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveToolItemMethod "toolbarReconfigured" o = ToolItemToolbarReconfiguredMethodInfo
    ResolveToolItemMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveToolItemMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveToolItemMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveToolItemMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveToolItemMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveToolItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveToolItemMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveToolItemMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveToolItemMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveToolItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveToolItemMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveToolItemMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveToolItemMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveToolItemMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveToolItemMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveToolItemMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveToolItemMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveToolItemMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveToolItemMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveToolItemMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveToolItemMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveToolItemMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveToolItemMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo
    ResolveToolItemMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveToolItemMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveToolItemMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveToolItemMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveToolItemMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveToolItemMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveToolItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveToolItemMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveToolItemMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveToolItemMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveToolItemMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveToolItemMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveToolItemMethod "getEllipsizeMode" o = ToolItemGetEllipsizeModeMethodInfo
    ResolveToolItemMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveToolItemMethod "getExpand" o = ToolItemGetExpandMethodInfo
    ResolveToolItemMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveToolItemMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveToolItemMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveToolItemMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveToolItemMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    ResolveToolItemMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveToolItemMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveToolItemMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveToolItemMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveToolItemMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveToolItemMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveToolItemMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveToolItemMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveToolItemMethod "getHomogeneous" o = ToolItemGetHomogeneousMethodInfo
    ResolveToolItemMethod "getIconSize" o = ToolItemGetIconSizeMethodInfo
    ResolveToolItemMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveToolItemMethod "getIsImportant" o = ToolItemGetIsImportantMethodInfo
    ResolveToolItemMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveToolItemMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveToolItemMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveToolItemMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveToolItemMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveToolItemMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveToolItemMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveToolItemMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveToolItemMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveToolItemMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveToolItemMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveToolItemMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveToolItemMethod "getOrientation" o = ToolItemGetOrientationMethodInfo
    ResolveToolItemMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveToolItemMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveToolItemMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveToolItemMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveToolItemMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveToolItemMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveToolItemMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveToolItemMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveToolItemMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveToolItemMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveToolItemMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveToolItemMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveToolItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveToolItemMethod "getProxyMenuItem" o = ToolItemGetProxyMenuItemMethodInfo
    ResolveToolItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveToolItemMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveToolItemMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveToolItemMethod "getRelatedAction" o = Gtk.Activatable.ActivatableGetRelatedActionMethodInfo
    ResolveToolItemMethod "getReliefStyle" o = ToolItemGetReliefStyleMethodInfo
    ResolveToolItemMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveToolItemMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveToolItemMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveToolItemMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveToolItemMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveToolItemMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveToolItemMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveToolItemMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveToolItemMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveToolItemMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveToolItemMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveToolItemMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveToolItemMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveToolItemMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveToolItemMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveToolItemMethod "getTextAlignment" o = ToolItemGetTextAlignmentMethodInfo
    ResolveToolItemMethod "getTextOrientation" o = ToolItemGetTextOrientationMethodInfo
    ResolveToolItemMethod "getTextSizeGroup" o = ToolItemGetTextSizeGroupMethodInfo
    ResolveToolItemMethod "getToolbarStyle" o = ToolItemGetToolbarStyleMethodInfo
    ResolveToolItemMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveToolItemMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveToolItemMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveToolItemMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveToolItemMethod "getUseActionAppearance" o = Gtk.Activatable.ActivatableGetUseActionAppearanceMethodInfo
    ResolveToolItemMethod "getUseDragWindow" o = ToolItemGetUseDragWindowMethodInfo
    ResolveToolItemMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveToolItemMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveToolItemMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveToolItemMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveToolItemMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveToolItemMethod "getVisibleHorizontal" o = ToolItemGetVisibleHorizontalMethodInfo
    ResolveToolItemMethod "getVisibleVertical" o = ToolItemGetVisibleVerticalMethodInfo
    ResolveToolItemMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveToolItemMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveToolItemMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveToolItemMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveToolItemMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveToolItemMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveToolItemMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveToolItemMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveToolItemMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveToolItemMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveToolItemMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveToolItemMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveToolItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveToolItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveToolItemMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveToolItemMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveToolItemMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveToolItemMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveToolItemMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveToolItemMethod "setExpand" o = ToolItemSetExpandMethodInfo
    ResolveToolItemMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveToolItemMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveToolItemMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveToolItemMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveToolItemMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    ResolveToolItemMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveToolItemMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveToolItemMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveToolItemMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveToolItemMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveToolItemMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveToolItemMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveToolItemMethod "setHomogeneous" o = ToolItemSetHomogeneousMethodInfo
    ResolveToolItemMethod "setIsImportant" o = ToolItemSetIsImportantMethodInfo
    ResolveToolItemMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveToolItemMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveToolItemMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveToolItemMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveToolItemMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveToolItemMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveToolItemMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveToolItemMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveToolItemMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveToolItemMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveToolItemMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveToolItemMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveToolItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveToolItemMethod "setProxyMenuItem" o = ToolItemSetProxyMenuItemMethodInfo
    ResolveToolItemMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveToolItemMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveToolItemMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveToolItemMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveToolItemMethod "setRelatedAction" o = Gtk.Activatable.ActivatableSetRelatedActionMethodInfo
    ResolveToolItemMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveToolItemMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveToolItemMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveToolItemMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveToolItemMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveToolItemMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveToolItemMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveToolItemMethod "setTooltipMarkup" o = ToolItemSetTooltipMarkupMethodInfo
    ResolveToolItemMethod "setTooltipText" o = ToolItemSetTooltipTextMethodInfo
    ResolveToolItemMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveToolItemMethod "setUseActionAppearance" o = Gtk.Activatable.ActivatableSetUseActionAppearanceMethodInfo
    ResolveToolItemMethod "setUseDragWindow" o = ToolItemSetUseDragWindowMethodInfo
    ResolveToolItemMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveToolItemMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveToolItemMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveToolItemMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveToolItemMethod "setVisibleHorizontal" o = ToolItemSetVisibleHorizontalMethodInfo
    ResolveToolItemMethod "setVisibleVertical" o = ToolItemSetVisibleVerticalMethodInfo
    ResolveToolItemMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveToolItemMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveToolItemMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveToolItemMethod t ToolItem, O.MethodInfo info ToolItem p) => OL.IsLabel t (ToolItem -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- signal ToolItem::create-menu-proxy
{- |
This signal is emitted when the toolbar needs information from /@toolItem@/
about whether the item should appear in the toolbar overflow menu. In
response the tool item should either

* call 'GI.Gtk.Objects.ToolItem.toolItemSetProxyMenuItem' with a 'Nothing'
pointer and return 'True' to indicate that the item should not appear
in the overflow menu
* call 'GI.Gtk.Objects.ToolItem.toolItemSetProxyMenuItem' with a new menu
item and return 'True', or
* return 'False' to indicate that the signal was not handled by the item.
This means that the item will not appear in the overflow menu unless
a later handler installs a menu item.


The toolbar may cache the result of this signal. When the tool item changes
how it will respond to this signal it must call 'GI.Gtk.Objects.ToolItem.toolItemRebuildMenu'
to invalidate the cache and ensure that the toolbar rebuilds its overflow
menu.
-}
type ToolItemCreateMenuProxyCallback =
    IO Bool
    {- ^ __Returns:__ 'True' if the signal was handled, 'False' if not -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `ToolItemCreateMenuProxyCallback`@.
noToolItemCreateMenuProxyCallback :: Maybe ToolItemCreateMenuProxyCallback
noToolItemCreateMenuProxyCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ToolItemCreateMenuProxyCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ToolItemCreateMenuProxyCallback`.
foreign import ccall "wrapper"
    mk_ToolItemCreateMenuProxyCallback :: C_ToolItemCreateMenuProxyCallback -> IO (FunPtr C_ToolItemCreateMenuProxyCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_ToolItemCreateMenuProxy :: MonadIO m => ToolItemCreateMenuProxyCallback -> m (GClosure C_ToolItemCreateMenuProxyCallback)
genClosure_ToolItemCreateMenuProxy cb = liftIO $ do
    let cb' = wrap_ToolItemCreateMenuProxyCallback cb
    mk_ToolItemCreateMenuProxyCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ToolItemCreateMenuProxyCallback` into a `C_ToolItemCreateMenuProxyCallback`.
wrap_ToolItemCreateMenuProxyCallback ::
    ToolItemCreateMenuProxyCallback ->
    C_ToolItemCreateMenuProxyCallback
wrap_ToolItemCreateMenuProxyCallback _cb _ _ = do
    result <- _cb
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@create-menu-proxy@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' toolItem #createMenuProxy callback
@
-}
onToolItemCreateMenuProxy :: (IsToolItem a, MonadIO m) => a -> ToolItemCreateMenuProxyCallback -> m SignalHandlerId
onToolItemCreateMenuProxy obj cb = liftIO $ do
    let cb' = wrap_ToolItemCreateMenuProxyCallback cb
    cb'' <- mk_ToolItemCreateMenuProxyCallback cb'
    connectSignalFunPtr obj "create-menu-proxy" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@create-menu-proxy@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' toolItem #createMenuProxy callback
@
-}
afterToolItemCreateMenuProxy :: (IsToolItem a, MonadIO m) => a -> ToolItemCreateMenuProxyCallback -> m SignalHandlerId
afterToolItemCreateMenuProxy obj cb = liftIO $ do
    let cb' = wrap_ToolItemCreateMenuProxyCallback cb
    cb'' <- mk_ToolItemCreateMenuProxyCallback cb'
    connectSignalFunPtr obj "create-menu-proxy" cb'' SignalConnectAfter


-- signal ToolItem::toolbar-reconfigured
{- |
This signal is emitted when some property of the toolbar that the
item is a child of changes. For custom subclasses of 'GI.Gtk.Objects.ToolItem.ToolItem',
the default handler of this signal use the functions

* 'GI.Gtk.Interfaces.ToolShell.toolShellGetOrientation'
* 'GI.Gtk.Interfaces.ToolShell.toolShellGetStyle'
* 'GI.Gtk.Interfaces.ToolShell.toolShellGetIconSize'
* 'GI.Gtk.Interfaces.ToolShell.toolShellGetReliefStyle'

to find out what the toolbar should look like and change
themselves accordingly.
-}
type ToolItemToolbarReconfiguredCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ToolItemToolbarReconfiguredCallback`@.
noToolItemToolbarReconfiguredCallback :: Maybe ToolItemToolbarReconfiguredCallback
noToolItemToolbarReconfiguredCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ToolItemToolbarReconfiguredCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ToolItemToolbarReconfiguredCallback`.
foreign import ccall "wrapper"
    mk_ToolItemToolbarReconfiguredCallback :: C_ToolItemToolbarReconfiguredCallback -> IO (FunPtr C_ToolItemToolbarReconfiguredCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_ToolItemToolbarReconfigured :: MonadIO m => ToolItemToolbarReconfiguredCallback -> m (GClosure C_ToolItemToolbarReconfiguredCallback)
genClosure_ToolItemToolbarReconfigured cb = liftIO $ do
    let cb' = wrap_ToolItemToolbarReconfiguredCallback cb
    mk_ToolItemToolbarReconfiguredCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ToolItemToolbarReconfiguredCallback` into a `C_ToolItemToolbarReconfiguredCallback`.
wrap_ToolItemToolbarReconfiguredCallback ::
    ToolItemToolbarReconfiguredCallback ->
    C_ToolItemToolbarReconfiguredCallback
wrap_ToolItemToolbarReconfiguredCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@toolbar-reconfigured@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' toolItem #toolbarReconfigured callback
@
-}
onToolItemToolbarReconfigured :: (IsToolItem a, MonadIO m) => a -> ToolItemToolbarReconfiguredCallback -> m SignalHandlerId
onToolItemToolbarReconfigured obj cb = liftIO $ do
    let cb' = wrap_ToolItemToolbarReconfiguredCallback cb
    cb'' <- mk_ToolItemToolbarReconfiguredCallback cb'
    connectSignalFunPtr obj "toolbar-reconfigured" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@toolbar-reconfigured@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' toolItem #toolbarReconfigured callback
@
-}
afterToolItemToolbarReconfigured :: (IsToolItem a, MonadIO m) => a -> ToolItemToolbarReconfiguredCallback -> m SignalHandlerId
afterToolItemToolbarReconfigured obj cb = liftIO $ do
    let cb' = wrap_ToolItemToolbarReconfiguredCallback cb
    cb'' <- mk_ToolItemToolbarReconfiguredCallback cb'
    connectSignalFunPtr obj "toolbar-reconfigured" cb'' SignalConnectAfter


-- VVV Prop "is-important"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

{- |
Get the value of the “@is-important@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' toolItem #isImportant
@
-}
getToolItemIsImportant :: (MonadIO m, IsToolItem o) => o -> m Bool
getToolItemIsImportant obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-important"

{- |
Set the value of the “@is-important@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' toolItem [ #isImportant 'Data.GI.Base.Attributes.:=' value ]
@
-}
setToolItemIsImportant :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()
setToolItemIsImportant obj val = liftIO $ B.Properties.setObjectPropertyBool obj "is-important" val

{- |
Construct a `GValueConstruct` with valid value for the “@is-important@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructToolItemIsImportant :: (IsToolItem o) => Bool -> IO (GValueConstruct o)
constructToolItemIsImportant val = B.Properties.constructObjectPropertyBool "is-important" val

#if ENABLE_OVERLOADING
data ToolItemIsImportantPropertyInfo
instance AttrInfo ToolItemIsImportantPropertyInfo where
    type AttrAllowedOps ToolItemIsImportantPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ToolItemIsImportantPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ToolItemIsImportantPropertyInfo = IsToolItem
    type AttrGetType ToolItemIsImportantPropertyInfo = Bool
    type AttrLabel ToolItemIsImportantPropertyInfo = "is-important"
    type AttrOrigin ToolItemIsImportantPropertyInfo = ToolItem
    attrGet _ = getToolItemIsImportant
    attrSet _ = setToolItemIsImportant
    attrConstruct _ = constructToolItemIsImportant
    attrClear _ = undefined
#endif

-- VVV Prop "visible-horizontal"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

{- |
Get the value of the “@visible-horizontal@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' toolItem #visibleHorizontal
@
-}
getToolItemVisibleHorizontal :: (MonadIO m, IsToolItem o) => o -> m Bool
getToolItemVisibleHorizontal obj = liftIO $ B.Properties.getObjectPropertyBool obj "visible-horizontal"

{- |
Set the value of the “@visible-horizontal@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' toolItem [ #visibleHorizontal 'Data.GI.Base.Attributes.:=' value ]
@
-}
setToolItemVisibleHorizontal :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()
setToolItemVisibleHorizontal obj val = liftIO $ B.Properties.setObjectPropertyBool obj "visible-horizontal" val

{- |
Construct a `GValueConstruct` with valid value for the “@visible-horizontal@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructToolItemVisibleHorizontal :: (IsToolItem o) => Bool -> IO (GValueConstruct o)
constructToolItemVisibleHorizontal val = B.Properties.constructObjectPropertyBool "visible-horizontal" val

#if ENABLE_OVERLOADING
data ToolItemVisibleHorizontalPropertyInfo
instance AttrInfo ToolItemVisibleHorizontalPropertyInfo where
    type AttrAllowedOps ToolItemVisibleHorizontalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ToolItemVisibleHorizontalPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ToolItemVisibleHorizontalPropertyInfo = IsToolItem
    type AttrGetType ToolItemVisibleHorizontalPropertyInfo = Bool
    type AttrLabel ToolItemVisibleHorizontalPropertyInfo = "visible-horizontal"
    type AttrOrigin ToolItemVisibleHorizontalPropertyInfo = ToolItem
    attrGet _ = getToolItemVisibleHorizontal
    attrSet _ = setToolItemVisibleHorizontal
    attrConstruct _ = constructToolItemVisibleHorizontal
    attrClear _ = undefined
#endif

-- VVV Prop "visible-vertical"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

{- |
Get the value of the “@visible-vertical@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' toolItem #visibleVertical
@
-}
getToolItemVisibleVertical :: (MonadIO m, IsToolItem o) => o -> m Bool
getToolItemVisibleVertical obj = liftIO $ B.Properties.getObjectPropertyBool obj "visible-vertical"

{- |
Set the value of the “@visible-vertical@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' toolItem [ #visibleVertical 'Data.GI.Base.Attributes.:=' value ]
@
-}
setToolItemVisibleVertical :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()
setToolItemVisibleVertical obj val = liftIO $ B.Properties.setObjectPropertyBool obj "visible-vertical" val

{- |
Construct a `GValueConstruct` with valid value for the “@visible-vertical@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructToolItemVisibleVertical :: (IsToolItem o) => Bool -> IO (GValueConstruct o)
constructToolItemVisibleVertical val = B.Properties.constructObjectPropertyBool "visible-vertical" val

#if ENABLE_OVERLOADING
data ToolItemVisibleVerticalPropertyInfo
instance AttrInfo ToolItemVisibleVerticalPropertyInfo where
    type AttrAllowedOps ToolItemVisibleVerticalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ToolItemVisibleVerticalPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ToolItemVisibleVerticalPropertyInfo = IsToolItem
    type AttrGetType ToolItemVisibleVerticalPropertyInfo = Bool
    type AttrLabel ToolItemVisibleVerticalPropertyInfo = "visible-vertical"
    type AttrOrigin ToolItemVisibleVerticalPropertyInfo = ToolItem
    attrGet _ = getToolItemVisibleVertical
    attrSet _ = setToolItemVisibleVertical
    attrConstruct _ = constructToolItemVisibleVertical
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList ToolItem
type instance O.AttributeList ToolItem = ToolItemAttributeList
type ToolItemAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("isImportant", ToolItemIsImportantPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedAction", Gtk.Activatable.ActivatableRelatedActionPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useActionAppearance", Gtk.Activatable.ActivatableUseActionAppearancePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("visibleHorizontal", ToolItemVisibleHorizontalPropertyInfo), '("visibleVertical", ToolItemVisibleVerticalPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
toolItemIsImportant :: AttrLabelProxy "isImportant"
toolItemIsImportant = AttrLabelProxy

toolItemVisibleHorizontal :: AttrLabelProxy "visibleHorizontal"
toolItemVisibleHorizontal = AttrLabelProxy

toolItemVisibleVertical :: AttrLabelProxy "visibleVertical"
toolItemVisibleVertical = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data ToolItemCreateMenuProxySignalInfo
instance SignalInfo ToolItemCreateMenuProxySignalInfo where
    type HaskellCallbackType ToolItemCreateMenuProxySignalInfo = ToolItemCreateMenuProxyCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ToolItemCreateMenuProxyCallback cb
        cb'' <- mk_ToolItemCreateMenuProxyCallback cb'
        connectSignalFunPtr obj "create-menu-proxy" cb'' connectMode

data ToolItemToolbarReconfiguredSignalInfo
instance SignalInfo ToolItemToolbarReconfiguredSignalInfo where
    type HaskellCallbackType ToolItemToolbarReconfiguredSignalInfo = ToolItemToolbarReconfiguredCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ToolItemToolbarReconfiguredCallback cb
        cb'' <- mk_ToolItemToolbarReconfiguredCallback cb'
        connectSignalFunPtr obj "toolbar-reconfigured" cb'' connectMode

type instance O.SignalList ToolItem = ToolItemSignalList
type ToolItemSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("createMenuProxy", ToolItemCreateMenuProxySignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("toolbarReconfigured", ToolItemToolbarReconfiguredSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

#endif

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

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

{- |
Creates a new 'GI.Gtk.Objects.ToolItem.ToolItem'

/Since: 2.4/
-}
toolItemNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ToolItem
    {- ^ __Returns:__ the new 'GI.Gtk.Objects.ToolItem.ToolItem' -}
toolItemNew  = liftIO $ do
    result <- gtk_tool_item_new
    checkUnexpectedReturnNULL "toolItemNew" result
    result' <- (newObject ToolItem) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method ToolItem::get_ellipsize_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "EllipsizeMode"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_ellipsize_mode" gtk_tool_item_get_ellipsize_mode ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CUInt

{- |
Returns the ellipsize mode used for /@toolItem@/. Custom subclasses of
'GI.Gtk.Objects.ToolItem.ToolItem' should call this function to find out how text should
be ellipsized.

/Since: 2.20/
-}
toolItemGetEllipsizeMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Pango.Enums.EllipsizeMode
    {- ^ __Returns:__ a 'GI.Pango.Enums.EllipsizeMode' indicating how text in /@toolItem@/
should be ellipsized. -}
toolItemGetEllipsizeMode toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_ellipsize_mode toolItem'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetEllipsizeModeMethodInfo
instance (signature ~ (m Pango.Enums.EllipsizeMode), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetEllipsizeModeMethodInfo a signature where
    overloadedMethod _ = toolItemGetEllipsizeMode

#endif

-- method ToolItem::get_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_expand" gtk_tool_item_get_expand ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CInt

{- |
Returns whether /@toolItem@/ is allocated extra space.
See 'GI.Gtk.Objects.ToolItem.toolItemSetExpand'.

/Since: 2.4/
-}
toolItemGetExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@toolItem@/ is allocated extra space. -}
toolItemGetExpand toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_expand toolItem'
    let result' = (/= 0) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetExpandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetExpandMethodInfo a signature where
    overloadedMethod _ = toolItemGetExpand

#endif

-- method ToolItem::get_homogeneous
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_homogeneous" gtk_tool_item_get_homogeneous ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CInt

{- |
Returns whether /@toolItem@/ is the same size as other homogeneous
items. See 'GI.Gtk.Objects.ToolItem.toolItemSetHomogeneous'.

/Since: 2.4/
-}
toolItemGetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the item is the same size as other homogeneous
items. -}
toolItemGetHomogeneous toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_homogeneous toolItem'
    let result' = (/= 0) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetHomogeneousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetHomogeneousMethodInfo a signature where
    overloadedMethod _ = toolItemGetHomogeneous

#endif

-- method ToolItem::get_icon_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_icon_size" gtk_tool_item_get_icon_size ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO Int32

{- |
Returns the icon size used for /@toolItem@/. Custom subclasses of
'GI.Gtk.Objects.ToolItem.ToolItem' should call this function to find out what size icons
they should use.

/Since: 2.4/
-}
toolItemGetIconSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Int32
    {- ^ __Returns:__ a 'GI.Gtk.Enums.IconSize' indicating the icon size
used for /@toolItem@/ -}
toolItemGetIconSize toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_icon_size toolItem'
    touchManagedPtr toolItem
    return result

#if ENABLE_OVERLOADING
data ToolItemGetIconSizeMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetIconSizeMethodInfo a signature where
    overloadedMethod _ = toolItemGetIconSize

#endif

-- method ToolItem::get_is_important
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_is_important" gtk_tool_item_get_is_important ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CInt

{- |
Returns whether /@toolItem@/ is considered important. See
'GI.Gtk.Objects.ToolItem.toolItemSetIsImportant'

/Since: 2.4/
-}
toolItemGetIsImportant ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@toolItem@/ is considered important. -}
toolItemGetIsImportant toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_is_important toolItem'
    let result' = (/= 0) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetIsImportantMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetIsImportantMethodInfo a signature where
    overloadedMethod _ = toolItemGetIsImportant

#endif

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

foreign import ccall "gtk_tool_item_get_orientation" gtk_tool_item_get_orientation ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CUInt

{- |
Returns the orientation used for /@toolItem@/. Custom subclasses of
'GI.Gtk.Objects.ToolItem.ToolItem' should call this function to find out what size icons
they should use.

/Since: 2.4/
-}
toolItemGetOrientation ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Gtk.Enums.Orientation
    {- ^ __Returns:__ a 'GI.Gtk.Enums.Orientation' indicating the orientation
used for /@toolItem@/ -}
toolItemGetOrientation toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_orientation toolItem'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetOrientationMethodInfo
instance (signature ~ (m Gtk.Enums.Orientation), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetOrientationMethodInfo a signature where
    overloadedMethod _ = toolItemGetOrientation

#endif

-- method ToolItem::get_proxy_menu_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "menu_item_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string used to identify the menu item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_proxy_menu_item" gtk_tool_item_get_proxy_menu_item ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CString ->                              -- menu_item_id : TBasicType TUTF8
    IO (Ptr Gtk.Widget.Widget)

{- |
If /@menuItemId@/ matches the string passed to
'GI.Gtk.Objects.ToolItem.toolItemSetProxyMenuItem' return the corresponding 'GI.Gtk.Objects.MenuItem.MenuItem'.

Custom subclasses of 'GI.Gtk.Objects.ToolItem.ToolItem' should use this function to
update their menu item when the 'GI.Gtk.Objects.ToolItem.ToolItem' changes. That the
/@menuItemIds@/ must match ensures that a 'GI.Gtk.Objects.ToolItem.ToolItem'
will not inadvertently change a menu item that they did not create.

/Since: 2.4/
-}
toolItemGetProxyMenuItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> T.Text
    {- ^ /@menuItemId@/: a string used to identify the menu item -}
    -> m (Maybe Gtk.Widget.Widget)
    {- ^ __Returns:__ The 'GI.Gtk.Objects.MenuItem.MenuItem' passed to
    'GI.Gtk.Objects.ToolItem.toolItemSetProxyMenuItem', if the /@menuItemIds@/
    match. -}
toolItemGetProxyMenuItem toolItem menuItemId = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    menuItemId' <- textToCString menuItemId
    result <- gtk_tool_item_get_proxy_menu_item toolItem' menuItemId'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.Widget.Widget) result'
        return result''
    touchManagedPtr toolItem
    freeMem menuItemId'
    return maybeResult

#if ENABLE_OVERLOADING
data ToolItemGetProxyMenuItemMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetProxyMenuItemMethodInfo a signature where
    overloadedMethod _ = toolItemGetProxyMenuItem

#endif

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

foreign import ccall "gtk_tool_item_get_relief_style" gtk_tool_item_get_relief_style ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CUInt

{- |
Returns the relief style of /@toolItem@/. See 'GI.Gtk.Objects.Button.buttonSetRelief'.
Custom subclasses of 'GI.Gtk.Objects.ToolItem.ToolItem' should call this function in the handler
of the 'GI.Gtk.Objects.ToolItem.ToolItem'::@/toolbar_reconfigured/@ signal to find out the
relief style of buttons.

/Since: 2.4/
-}
toolItemGetReliefStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Gtk.Enums.ReliefStyle
    {- ^ __Returns:__ a 'GI.Gtk.Enums.ReliefStyle' indicating the relief style used
for /@toolItem@/. -}
toolItemGetReliefStyle toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_relief_style toolItem'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetReliefStyleMethodInfo
instance (signature ~ (m Gtk.Enums.ReliefStyle), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetReliefStyleMethodInfo a signature where
    overloadedMethod _ = toolItemGetReliefStyle

#endif

-- method ToolItem::get_text_alignment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem:", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_text_alignment" gtk_tool_item_get_text_alignment ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CFloat

{- |
Returns the text alignment used for /@toolItem@/. Custom subclasses of
'GI.Gtk.Objects.ToolItem.ToolItem' should call this function to find out how text should
be aligned.

/Since: 2.20/
-}
toolItemGetTextAlignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem': -}
    -> m Float
    {- ^ __Returns:__ a @/gfloat/@ indicating the horizontal text alignment
used for /@toolItem@/ -}
toolItemGetTextAlignment toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_text_alignment toolItem'
    let result' = realToFrac result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetTextAlignmentMethodInfo
instance (signature ~ (m Float), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetTextAlignmentMethodInfo a signature where
    overloadedMethod _ = toolItemGetTextAlignment

#endif

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

foreign import ccall "gtk_tool_item_get_text_orientation" gtk_tool_item_get_text_orientation ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CUInt

{- |
Returns the text orientation used for /@toolItem@/. Custom subclasses of
'GI.Gtk.Objects.ToolItem.ToolItem' should call this function to find out how text should
be orientated.

/Since: 2.20/
-}
toolItemGetTextOrientation ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Gtk.Enums.Orientation
    {- ^ __Returns:__ a 'GI.Gtk.Enums.Orientation' indicating the text orientation
used for /@toolItem@/ -}
toolItemGetTextOrientation toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_text_orientation toolItem'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetTextOrientationMethodInfo
instance (signature ~ (m Gtk.Enums.Orientation), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetTextOrientationMethodInfo a signature where
    overloadedMethod _ = toolItemGetTextOrientation

#endif

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

foreign import ccall "gtk_tool_item_get_text_size_group" gtk_tool_item_get_text_size_group ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO (Ptr Gtk.SizeGroup.SizeGroup)

{- |
Returns the size group used for labels in /@toolItem@/.
Custom subclasses of 'GI.Gtk.Objects.ToolItem.ToolItem' should call this function
and use the size group for labels.

/Since: 2.20/
-}
toolItemGetTextSizeGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Gtk.SizeGroup.SizeGroup
    {- ^ __Returns:__ a 'GI.Gtk.Objects.SizeGroup.SizeGroup' -}
toolItemGetTextSizeGroup toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_text_size_group toolItem'
    checkUnexpectedReturnNULL "toolItemGetTextSizeGroup" result
    result' <- (newObject Gtk.SizeGroup.SizeGroup) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetTextSizeGroupMethodInfo
instance (signature ~ (m Gtk.SizeGroup.SizeGroup), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetTextSizeGroupMethodInfo a signature where
    overloadedMethod _ = toolItemGetTextSizeGroup

#endif

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

foreign import ccall "gtk_tool_item_get_toolbar_style" gtk_tool_item_get_toolbar_style ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CUInt

{- |
Returns the toolbar style used for /@toolItem@/. Custom subclasses of
'GI.Gtk.Objects.ToolItem.ToolItem' should call this function in the handler of the
GtkToolItem::toolbar_reconfigured signal to find out in what style
the toolbar is displayed and change themselves accordingly

Possibilities are:

* 'GI.Gtk.Enums.ToolbarStyleBoth', meaning the tool item should show
both an icon and a label, stacked vertically
* 'GI.Gtk.Enums.ToolbarStyleIcons', meaning the toolbar shows only icons
* 'GI.Gtk.Enums.ToolbarStyleText', meaning the tool item should only show text
* 'GI.Gtk.Enums.ToolbarStyleBothHoriz', meaning the tool item should show
both an icon and a label, arranged horizontally


/Since: 2.4/
-}
toolItemGetToolbarStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Gtk.Enums.ToolbarStyle
    {- ^ __Returns:__ A 'GI.Gtk.Enums.ToolbarStyle' indicating the toolbar style used
for /@toolItem@/. -}
toolItemGetToolbarStyle toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_toolbar_style toolItem'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetToolbarStyleMethodInfo
instance (signature ~ (m Gtk.Enums.ToolbarStyle), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetToolbarStyleMethodInfo a signature where
    overloadedMethod _ = toolItemGetToolbarStyle

#endif

-- method ToolItem::get_use_drag_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_use_drag_window" gtk_tool_item_get_use_drag_window ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CInt

{- |
Returns whether /@toolItem@/ has a drag window. See
'GI.Gtk.Objects.ToolItem.toolItemSetUseDragWindow'.

/Since: 2.4/
-}
toolItemGetUseDragWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@toolItem@/ uses a drag window. -}
toolItemGetUseDragWindow toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_use_drag_window toolItem'
    let result' = (/= 0) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetUseDragWindowMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetUseDragWindowMethodInfo a signature where
    overloadedMethod _ = toolItemGetUseDragWindow

#endif

-- method ToolItem::get_visible_horizontal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_visible_horizontal" gtk_tool_item_get_visible_horizontal ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CInt

{- |
Returns whether the /@toolItem@/ is visible on toolbars that are
docked horizontally.

/Since: 2.4/
-}
toolItemGetVisibleHorizontal ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@toolItem@/ is visible on toolbars that are
docked horizontally. -}
toolItemGetVisibleHorizontal toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_visible_horizontal toolItem'
    let result' = (/= 0) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetVisibleHorizontalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetVisibleHorizontalMethodInfo a signature where
    overloadedMethod _ = toolItemGetVisibleHorizontal

#endif

-- method ToolItem::get_visible_vertical
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_get_visible_vertical" gtk_tool_item_get_visible_vertical ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO CInt

{- |
Returns whether /@toolItem@/ is visible when the toolbar is docked vertically.
See 'GI.Gtk.Objects.ToolItem.toolItemSetVisibleVertical'.

/Since: 2.4/
-}
toolItemGetVisibleVertical ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Bool
    {- ^ __Returns:__ Whether /@toolItem@/ is visible when the toolbar is docked vertically -}
toolItemGetVisibleVertical toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_get_visible_vertical toolItem'
    let result' = (/= 0) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemGetVisibleVerticalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemGetVisibleVerticalMethodInfo a signature where
    overloadedMethod _ = toolItemGetVisibleVertical

#endif

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

foreign import ccall "gtk_tool_item_rebuild_menu" gtk_tool_item_rebuild_menu ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO ()

{- |
Calling this function signals to the toolbar that the
overflow menu item for /@toolItem@/ has changed. If the
overflow menu is visible when this function it called,
the menu will be rebuilt.

The function must be called when the tool item changes what it
will do in response to the 'GI.Gtk.Objects.ToolItem.ToolItem'::@/create-menu-proxy/@ signal.

/Since: 2.6/
-}
toolItemRebuildMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m ()
toolItemRebuildMenu toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    gtk_tool_item_rebuild_menu toolItem'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemRebuildMenuMethodInfo
instance (signature ~ (m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemRebuildMenuMethodInfo a signature where
    overloadedMethod _ = toolItemRebuildMenu

#endif

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

foreign import ccall "gtk_tool_item_retrieve_proxy_menu_item" gtk_tool_item_retrieve_proxy_menu_item ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Returns the 'GI.Gtk.Objects.MenuItem.MenuItem' that was last set by
'GI.Gtk.Objects.ToolItem.toolItemSetProxyMenuItem', ie. the 'GI.Gtk.Objects.MenuItem.MenuItem'
that is going to appear in the overflow menu.

/Since: 2.4/
-}
toolItemRetrieveProxyMenuItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ The 'GI.Gtk.Objects.MenuItem.MenuItem' that is going to appear in the
overflow menu for /@toolItem@/. -}
toolItemRetrieveProxyMenuItem toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    result <- gtk_tool_item_retrieve_proxy_menu_item toolItem'
    checkUnexpectedReturnNULL "toolItemRetrieveProxyMenuItem" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr toolItem
    return result'

#if ENABLE_OVERLOADING
data ToolItemRetrieveProxyMenuItemMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemRetrieveProxyMenuItemMethodInfo a signature where
    overloadedMethod _ = toolItemRetrieveProxyMenuItem

#endif

-- method ToolItem::set_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether @tool_item is allocated extra space", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_expand" gtk_tool_item_set_expand ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

{- |
Sets whether /@toolItem@/ 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.

/Since: 2.4/
-}
toolItemSetExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> Bool
    {- ^ /@expand@/: Whether /@toolItem@/ is allocated extra space -}
    -> m ()
toolItemSetExpand toolItem expand = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    let expand' = (fromIntegral . fromEnum) expand
    gtk_tool_item_set_expand toolItem' expand'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetExpandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetExpandMethodInfo a signature where
    overloadedMethod _ = toolItemSetExpand

#endif

-- method ToolItem::set_homogeneous
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @tool_item is the same size as other homogeneous items", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_homogeneous" gtk_tool_item_set_homogeneous ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CInt ->                                 -- homogeneous : TBasicType TBoolean
    IO ()

{- |
Sets whether /@toolItem@/ 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.

/Since: 2.4/
-}
toolItemSetHomogeneous ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> Bool
    {- ^ /@homogeneous@/: whether /@toolItem@/ is the same size as other homogeneous items -}
    -> m ()
toolItemSetHomogeneous toolItem homogeneous = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    let homogeneous' = (fromIntegral . fromEnum) homogeneous
    gtk_tool_item_set_homogeneous toolItem' homogeneous'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetHomogeneousMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetHomogeneousMethodInfo a signature where
    overloadedMethod _ = toolItemSetHomogeneous

#endif

-- method ToolItem::set_is_important
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_important", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the tool item should be considered important", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_is_important" gtk_tool_item_set_is_important ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CInt ->                                 -- is_important : TBasicType TBoolean
    IO ()

{- |
Sets whether /@toolItem@/ should be considered important. The 'GI.Gtk.Objects.ToolButton.ToolButton'
class uses this property to determine whether to show or hide its label
when the toolbar style is 'GI.Gtk.Enums.ToolbarStyleBothHoriz'. The result is that
only tool buttons with the “is_important” property set have labels, an
effect known as “priority text”

/Since: 2.4/
-}
toolItemSetIsImportant ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> Bool
    {- ^ /@isImportant@/: whether the tool item should be considered important -}
    -> m ()
toolItemSetIsImportant toolItem isImportant = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    let isImportant' = (fromIntegral . fromEnum) isImportant
    gtk_tool_item_set_is_important toolItem' isImportant'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetIsImportantMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetIsImportantMethodInfo a signature where
    overloadedMethod _ = toolItemSetIsImportant

#endif

-- method ToolItem::set_proxy_menu_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "menu_item_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string used to identify @menu_item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "menu_item", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkMenuItem to use in the overflow menu, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_proxy_menu_item" gtk_tool_item_set_proxy_menu_item ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CString ->                              -- menu_item_id : TBasicType TUTF8
    Ptr Gtk.Widget.Widget ->                -- menu_item : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Sets the 'GI.Gtk.Objects.MenuItem.MenuItem' used in the toolbar overflow menu. The
/@menuItemId@/ is used to identify the caller of this function and
should also be used with 'GI.Gtk.Objects.ToolItem.toolItemGetProxyMenuItem'.

See also 'GI.Gtk.Objects.ToolItem.ToolItem'::@/create-menu-proxy/@.

/Since: 2.4/
-}
toolItemSetProxyMenuItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> T.Text
    {- ^ /@menuItemId@/: a string used to identify /@menuItem@/ -}
    -> Maybe (b)
    {- ^ /@menuItem@/: a 'GI.Gtk.Objects.MenuItem.MenuItem' to use in the overflow menu, or 'Nothing' -}
    -> m ()
toolItemSetProxyMenuItem toolItem menuItemId menuItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    menuItemId' <- textToCString menuItemId
    maybeMenuItem <- case menuItem of
        Nothing -> return nullPtr
        Just jMenuItem -> do
            jMenuItem' <- unsafeManagedPtrCastPtr jMenuItem
            return jMenuItem'
    gtk_tool_item_set_proxy_menu_item toolItem' menuItemId' maybeMenuItem
    touchManagedPtr toolItem
    whenJust menuItem touchManagedPtr
    freeMem menuItemId'
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetProxyMenuItemMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsToolItem a, Gtk.Widget.IsWidget b) => O.MethodInfo ToolItemSetProxyMenuItemMethodInfo a signature where
    overloadedMethod _ = toolItemSetProxyMenuItem

#endif

-- method ToolItem::set_tooltip_markup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "markup text to be used as tooltip for @tool_item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_tooltip_markup" gtk_tool_item_set_tooltip_markup ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CString ->                              -- markup : TBasicType TUTF8
    IO ()

{- |
Sets the markup text to be displayed as tooltip on the item.
See 'GI.Gtk.Objects.Widget.widgetSetTooltipMarkup'.

/Since: 2.12/
-}
toolItemSetTooltipMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> T.Text
    {- ^ /@markup@/: markup text to be used as tooltip for /@toolItem@/ -}
    -> m ()
toolItemSetTooltipMarkup toolItem markup = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    markup' <- textToCString markup
    gtk_tool_item_set_tooltip_markup toolItem' markup'
    touchManagedPtr toolItem
    freeMem markup'
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetTooltipMarkupMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetTooltipMarkupMethodInfo a signature where
    overloadedMethod _ = toolItemSetTooltipMarkup

#endif

-- method ToolItem::set_tooltip_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "text to be used as tooltip for @tool_item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_tooltip_text" gtk_tool_item_set_tooltip_text ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CString ->                              -- text : TBasicType TUTF8
    IO ()

{- |
Sets the text to be displayed as tooltip on the item.
See 'GI.Gtk.Objects.Widget.widgetSetTooltipText'.

/Since: 2.12/
-}
toolItemSetTooltipText ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> T.Text
    {- ^ /@text@/: text to be used as tooltip for /@toolItem@/ -}
    -> m ()
toolItemSetTooltipText toolItem text = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    text' <- textToCString text
    gtk_tool_item_set_tooltip_text toolItem' text'
    touchManagedPtr toolItem
    freeMem text'
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetTooltipTextMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetTooltipTextMethodInfo a signature where
    overloadedMethod _ = toolItemSetTooltipText

#endif

-- method ToolItem::set_use_drag_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use_drag_window", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether @tool_item has a drag window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_use_drag_window" gtk_tool_item_set_use_drag_window ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CInt ->                                 -- use_drag_window : TBasicType TBoolean
    IO ()

{- |
Sets whether /@toolItem@/ has a drag window. When 'True' the
toolitem can be used as a drag source through 'GI.Gtk.Objects.Widget.widgetDragSourceSet'.
When /@toolItem@/ has a drag window it will intercept all events,
even those that would otherwise be sent to a child of /@toolItem@/.

/Since: 2.4/
-}
toolItemSetUseDragWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> Bool
    {- ^ /@useDragWindow@/: Whether /@toolItem@/ has a drag window. -}
    -> m ()
toolItemSetUseDragWindow toolItem useDragWindow = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    let useDragWindow' = (fromIntegral . fromEnum) useDragWindow
    gtk_tool_item_set_use_drag_window toolItem' useDragWindow'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetUseDragWindowMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetUseDragWindowMethodInfo a signature where
    overloadedMethod _ = toolItemSetUseDragWindow

#endif

-- method ToolItem::set_visible_horizontal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible_horizontal", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether @tool_item is visible when in horizontal mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_visible_horizontal" gtk_tool_item_set_visible_horizontal ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CInt ->                                 -- visible_horizontal : TBasicType TBoolean
    IO ()

{- |
Sets whether /@toolItem@/ is visible when the toolbar is docked horizontally.

/Since: 2.4/
-}
toolItemSetVisibleHorizontal ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> Bool
    {- ^ /@visibleHorizontal@/: Whether /@toolItem@/ is visible when in horizontal mode -}
    -> m ()
toolItemSetVisibleHorizontal toolItem visibleHorizontal = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    let visibleHorizontal' = (fromIntegral . fromEnum) visibleHorizontal
    gtk_tool_item_set_visible_horizontal toolItem' visibleHorizontal'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetVisibleHorizontalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetVisibleHorizontalMethodInfo a signature where
    overloadedMethod _ = toolItemSetVisibleHorizontal

#endif

-- method ToolItem::set_visible_vertical
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tool_item", argType = TInterface (Name {namespace = "Gtk", name = "ToolItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkToolItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible_vertical", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @tool_item is visible when the toolbar\nis in vertical mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tool_item_set_visible_vertical" gtk_tool_item_set_visible_vertical ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    CInt ->                                 -- visible_vertical : TBasicType TBoolean
    IO ()

{- |
Sets whether /@toolItem@/ 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 /@visibleVertical@/ is 'False'
/@toolItem@/ will not appear on toolbars that are docked vertically.

/Since: 2.4/
-}
toolItemSetVisibleVertical ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> Bool
    {- ^ /@visibleVertical@/: whether /@toolItem@/ is visible when the toolbar
is in vertical mode -}
    -> m ()
toolItemSetVisibleVertical toolItem visibleVertical = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    let visibleVertical' = (fromIntegral . fromEnum) visibleVertical
    gtk_tool_item_set_visible_vertical toolItem' visibleVertical'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemSetVisibleVerticalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemSetVisibleVerticalMethodInfo a signature where
    overloadedMethod _ = toolItemSetVisibleVertical

#endif

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

foreign import ccall "gtk_tool_item_toolbar_reconfigured" gtk_tool_item_toolbar_reconfigured ::
    Ptr ToolItem ->                         -- tool_item : TInterface (Name {namespace = "Gtk", name = "ToolItem"})
    IO ()

{- |
Emits the signal 'GI.Gtk.Objects.ToolItem.ToolItem'::@/toolbar_reconfigured/@ on /@toolItem@/.
'GI.Gtk.Objects.Toolbar.Toolbar' and other 'GI.Gtk.Interfaces.ToolShell.ToolShell' implementations use this function
to notify children, when some aspect of their configuration changes.

/Since: 2.14/
-}
toolItemToolbarReconfigured ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolItem a) =>
    a
    {- ^ /@toolItem@/: a 'GI.Gtk.Objects.ToolItem.ToolItem' -}
    -> m ()
toolItemToolbarReconfigured toolItem = liftIO $ do
    toolItem' <- unsafeManagedPtrCastPtr toolItem
    gtk_tool_item_toolbar_reconfigured toolItem'
    touchManagedPtr toolItem
    return ()

#if ENABLE_OVERLOADING
data ToolItemToolbarReconfiguredMethodInfo
instance (signature ~ (m ()), MonadIO m, IsToolItem a) => O.MethodInfo ToolItemToolbarReconfiguredMethodInfo a signature where
    overloadedMethod _ = toolItemToolbarReconfigured

#endif