gtk.ToolItem.set_homogeneous

    def set_homogeneous(homogeneous)

The set_homogeneous() method sets the homogeneous setting of the tool item to the value of homogeneous. If homogeneous is True the tool item is to be allocated the same size as other homogeneous items. The effect is that all homogeneous items will have the same width as the widest of the items.

gtk.ToolItem.get_homogeneous

    def get_homogeneous()

The get_homogeneous() method returns the setting of the homogeneous setting of the tool item. If True the tool item is the same size as other homogeneous items. See the set_homogeneous() method for more detail.

gtk.ToolItem.set_expand

    def set_expand(expand)

The set_expand() method sets the expand setting of the tool item to the value of expand. If expand is True the tool item is allocated extra space when there is more room on the toolbar than needed for the items. The effect is that the item gets bigger when the toolbar gets bigger and smaller when the toolbar gets smaller.

gtk.ToolItem.get_expand

    def get_expand()

The get_expand() method returns the value of the expand setting of the tool item. If True the tool item is allocated extra space. See the gtk.ToolItem.set_expand() method for more detail.

gtk.ToolItem.set_tooltip

    def set_tooltip(tooltips, tip_text=None, tip_private=None)

The set_tooltip() method sets the gtk.Tooltips object specified by tooltips to be used for the tool item with the tooltip text specified by tip_text and the private text specified by tip_private. See the gtk.Tooltips.set_tip() method for more information.

gtk.ToolItem.set_use_drag_window

    def set_use_drag_window(use_drag_window)

The set_use_drag_window() method determines whether the tool item has a drag window according to the value of use_drag_window. If use_drag_window is True the toolitem can be used as a drag source through the gtk.Widget.drag_source_set() method. When the tool item has a drag window it will intercept all events, even those that would otherwise be sent to a child of the tool item

gtk.ToolItem.get_use_drag_window

    def get_use_drag_window()

The get_use_drag_window() returns the setting that determines if the tool item has a drag window. See the set_use_drag_window() for more information.

gtk.ToolItem.set_visible_horizontal

    def set_visible_horizontal(visible_horizontal)

The set_visible_horizontal() method sets the "visible-horizontal" property to the value of visible_horizontal. If visible_horizontal is True, the tool item is visible when the toolbar is docked horizontally.

gtk.ToolItem.get_visible_horizontal

    def get_visible_horizontal()

The get_visible_horizontal() method returns the value of the "visible-horizontal" property. If "visible-horizontal" is True, the tool item is visible on toolbars that are docked horizontally.

gtk.ToolItem.set_visible_vertical

    def set_visible_vertical(visible_vertical)

The set_visible_vertical() method sets the "visible-vertical" property to the value of visible_vertical. If visible_vertical is True, the tool item is visible when the toolbar is docked vertically. Some tool items, such as text entries, are too wide to be useful on a vertically docked toolbar. If visible_vertical is False the tool item will not appear on toolbars that are docked vertically.

gtk.ToolItem.get_visible_vertical

    def get_visible_vertical()

The get_visible_vertical() method returns the value of the "visible-vertical" property. If "visible-vertical" is True, the tool item is visible when the toolbar is docked vertically. See the set_visible_vertical() method for more information.

gtk.ToolItem.set_is_important

    def set_is_important(is_important)

The set_is_important() method sets the "is-important" property to the value of is_important. If is_important is True the tool item should be considered important. The gtk.ToolButton class uses this property to determine whether to show its label when the toolbar style is gtk.TOOLBAR_BOTH_HORIZ. The result is that only tool buttons with the "is_important" property set have labels, an effect known as "priority text".

gtk.ToolItem.get_is_important

    def get_is_important()

The get_is_important() method returns the value of the "is-important" property. If "is-important" is True, the tool item is considered important. See the set_is_important() method for more information.

gtk.ToolItem.get_icon_size

    def get_icon_size()

The get_icon_size() method returns the icon size used for the tool item. Custom subclasses of gtk.ToolItem should call this method to find out what size icons they should use. The return value should be one of: gtk.ICON_SIZE_MENU, gtk.ICON_SIZE_SMALL_TOOLBAR, gtk.ICON_SIZE_LARGE_TOOLBAR, gtk.ICON_SIZE_BUTTON, gtk.ICON_SIZE_DND, gtk.ICON_SIZE_DIALOG or an integer value returned from the gtk.icon_size_register() function.

gtk.ToolItem.get_orientation

    def get_orientation()

The get_orientation() method returns the orientation used for the tool item. Custom subclasses of gtk.ToolItem should call this method to find out what size icons they should use. The return value should be either gtk.ORIENTATION_HORIZONTAL or gtk.ORIENTATION_VERTICAL.

gtk.ToolItem.get_toolbar_style

    def get_toolbar_style()

The get_toolbar_style() method returns the toolbar style used for the tool item. Custom subclasses of gtk.ToolItem should call this method in the "toolbar-reconfigured" signal handler to find out in what style the toolbar is displayed and change themselves accordingly.

Possibilities are:

gtk.ToolItem.get_relief_style

    def get_relief_style()

The get_relief_style() method returns the relief style of the tool item. See the gtk.Button.set_relief() method for more information. Custom subclasses of gtk.ToolItem should call this method in the handler of the gtk.ToolItem "toolbar-reconfigured" signal to find out the relief style of buttons.

The return value should be one of: gtk.RELIEF_NORMAL, gtk.RELIEF_HALF or gtk.RELIEF_NONE.

gtk.ToolItem.retrieve_proxy_menu_item

    def retrieve_proxy_menu_item()

The retrieve_proxy_menu_item() method returns the gtk.MenuItem that was last set by the set_proxy_menu_item() method, i.e. the gtk.MenuItem that is going to appear in the overflow menu.

gtk.ToolItem.set_proxy_menu_item

    def set_proxy_menu_item(menu_item_id, menu_item)

The set_proxy_menu_item() method sets the gtk.MenuItem specified by menu_item to be used in the toolbar overflow menu. menu_item_id is used to identify the caller of this method and should also be used with the get_proxy_menu_item() method. If menu_item is None the tool item will not appear in the overflow menu.

gtk.ToolItem.get_proxy_menu_item

    def get_proxy_menu_item(menu_item_id)

The get_proxy_menu_item() method returns the gtk.MenuItem corresponding to the string specified by menu_item_id as passed to the set_proxy_menu_item() method.

Custom subclasses of gtk.ToolItem should use this method to update their menu item when the gtk.ToolItem changes. Forcing a match with menu_item_id ensures that a gtk.ToolItem will not inadvertently change a menu item that they did not create.

gtk.ToolItem.rebuild_menu

    def rebuild_menu()

The rebuild_menu() method ignals to the toolbar that the overflow menu item has changed. If the overflow menu is visible when this method it called, the menu will be rebuilt. The method must be called when the tool item changes what it will do in response to the "create_menu_proxy" signal.

gtk.ToolItem.set_tooltip_markup

    def set_tooltip_markup(markup)

The set_tooltip_markup() method sets the markup text to be displayed as tooltip on the item. See gtk.Widget.set_tooltip_markup().

gtk.ToolItem.set_tooltip_text

    def set_tooltip_text(text)

The set_tooltip_text() method sets the text to be displayed as tooltip on the item. See gtk.Widget.set_tooltip_text().

gtk.ToolItem.toolbar_reconfigured

    def toolbar_reconfigured()

The toolbar_reconfigured() method emits the signal "toolbar-reconfigured" on tool_item. gtk.ToolBar and other gtk.ToolShell implementations use this function to notify children, when some aspect of their configuration changes.

The "create-menu-proxy" gtk.ToolItem Signal

    def callback(toolitem, user_param1, ...)

The "create-menu-proxy" signal is emitted when the toolbar is displaying an overflow menu and is trying to determine if toolitem should appear in the overflow menu. In response toolitem should either

The toolbar may cache the result of this signal. When the tool item changes how it will respond to this signal it must call the rebuild_menu()) method to invalidate the cache and ensure that the toolbar rebuilds its overflow menu.

The "set-tooltip" gtk.ToolItem Signal

    def callback(toolitem, tooltips, tip_text, tip_private, user_param1, ...)

The "set-tooltip" signal is emitted when the tool item's tooltip changes. Application developers can use the set_tooltip() method to set the item's tooltip.

The "toolbar-reconfigured" gtk.ToolItem Signal

    def callback(toolitem, user_param1, ...)

The "toolbar-reconfigured" signal is emitted when some property of the toolbar that the item is a child of changes. For custom subclasses of gtk.ToolItem, the default handler of this signal uses the methods:

to find out what the toolbar should look like and change themselves accordingly.