gtk.Action.block_activate

    def block_activate()

The block_activate() method disable activation signals from the action

This is needed when updating the state of your proxy gtk.Activatable widget could result in calling gtk.Action.activate(), this is a convenience function to avoid recursing in those cases (updating toggle state for instance).

gtk.Action.get_gicon

    def get_gicon()

The get_gicon() method gets the gio.Icon of action.

gtk.Action.get_icon_name

    def get_icon_name()

The get_icon_name() method gets the icon name of action.

gtk.Action.get_is_important

    def get_is_important()

The get_is_important() method checks whether action is important or not.

gtk.Action.get_label

    def get_label()

The get_label() method gets the label text of action.

gtk.Action.get_name

    def get_name()

The get_name() method returns the value of the "name" property containing the name of the action.

gtk.Action.get_short_label

    def get_short_label()

The get_short_label() method gets the short label text of action.

gtk.Action.get_tooltip

    def get_tooltip()

The get_tooltip() method gets the tooltip text of action.

gtk.Action.get_visible_horizontal

    def get_visible_horizontal()

The get_visible_horizontal() method gets whether action is visible when horizontal

gtk.Action.get_visible_vertical

    def get_visible_vertical()

The get_visible_vertical() method gets whether action is visible when vertical.

gtk.Action.get_stock_id

    def get_stock_id()

The get_stock_id() method gets the stock id of action.

gtk.Action.is_sensitive

    def is_sensitive()

The is_sensitive() method returns True if the action is effectively sensitive i.e. both the gtk.Action and its associated gtk.ActionGroup are sensitive.

gtk.Action.get_sensitive

    def get_sensitive()

The get_sensitive() method returns the value of the "sensitive" property. If "sensitive" is True the action itself is sensitive. Note that this doesn't necessarily mean effective sensitivity. See the is_sensitive() method for more information.

gtk.Action.is_visible

    def is_visible()

The is_visible() method returns True if the action is effectively visible i.e. both the gtk.Action and its associated gtk.ActionGroup as visible.

gtk.Action.get_visible

    def get_visible()

The get_visible() method returns the value of the "visible" property. If "visible" is True the gtk.Action itself is visible. Note that this doesn't necessarily mean effective visibility. See the is_visible() method for more information.

gtk.Action.activate

    def activate()

The activate() method emits the "activate" signal on the gtk.Action, if it isn't insensitive. This gets called by the proxy widgets when they get activated. It can also be used to manually activate an action.

gtk.Action.create_icon

    def create_icon(icon_size)

The create_icon() method creates and returns a gtk.Image with the size specified by size from the icon contained in the "stock-id" property if it exists. The value of size must be one of:

This method is intended for use by gtk.Action implementations to create icons displayed in the proxy widgets.

gtk.Action.create_menu

    def create_menu()

If action provides a gtk.Menu. widget as a submenu for the menu item or the toolbar item it creates, create_menu() method returns an instance of that menu.

gtk.Action.create_menu_item

    def create_menu_item()

The create_menu_item() method creates and returns a menu item widget that proxies for the gtk.Action.

gtk.Action.create_tool_item

    def create_tool_item()

The create_tool_item() method creates and returns a tool item widget that proxies for the gtk.Action.

gtk.Action.connect_proxy

    def connect_proxy(proxy)

The connect_proxy() method connects the widget specified by proxy to the gtk.Action object as a proxy. This method synchronizes various properties of the gtk.Action with the widget (such as label text, icon, tooltip, etc), and attaches a callback so that the gtk.Action is activated when proxy is.

If proxy is already connected to another gtk.Action, it is disconnected first. The gtk.Action should be added to a gtk.ActionGroup before calling this method.

gtk.Action.disconnect_proxy

    def disconnect_proxy(proxy)

The disconnect_proxy() method disconnects the widget specified by proxy from the gtk.Action. This method does not destroy the widget. The gtk.Action should be added to a gtk.ActionGroup before calling this method.

gtk.Action.get_proxies

    def get_proxies()

The get_proxies() method returns a list containing the proxy widgets associated with the gtk.Action.

gtk.Action.connect_accelerator

    def connect_accelerator()

The connect_accelerator() method installs the accelerator for the gtk.Action if it has an associated accel path and gtk.AccelGroup. See the set_accel_path() and the set_accel_group() methods.

Since multiple proxies may independently trigger the installation of the accelerator, the gtk.Action counts the number of times this method has been called and doesn't remove the accelerator until disconnect_accelerator() has been called as many times.

gtk.Action.disconnect_accelerator

    def disconnect_accelerator()

The disconnect_accelerator() method undoes the effect of one call to the connect_accelerator() method.

gtk.Action.block_activate_from

    def block_activate_from(proxy)

The block_activate_from() method disables calls to the activate() method by signals on the widget specified by proxy. This is used to break notification loops for things like check or radio actions.

This method is intended for use by gtk.Action implementations.

gtk.Action.unblock_activate_from

    def unblock_activate_from(proxy)

The unblock_activate_from() method re-enables calls to the activate() method by signals on the widget specified by proxy. This undoes the blocking done by the block_activate_from() method.

This method is intended for use by gtk.Action implementations.

gtk.Action.get_accel_path

    def get_accel_path()

The get_accel_path() method returns the accel path for the action or None if no accel path is set.

gtk.Action.set_accel_path

    def set_accel_path(accel_path)

The set_accel_path() method sets the accel path for the action to the value of accel_path. All proxy widgets associated with the action will have this accel path, so that their accelerators are consistent.

gtk.Action.set_accel_group

    def set_accel_group(accel_group)

The set_accel_group() method sets the gtk.AccelGroup specified by accel_group as the accelerator group for the gtk.Action.

gtk.Action.set_gicon

    def set_gicon(icon)

The set_gicon() method sets the icon of action.

gtk.Action.set_icon_name

    def set_icon_name(icon_name)

The set_icon_name() method sets the icon name on action.

gtk.Action.set_is_important

    def set_is_important(is_important)

The set_is_important() method sets whether the action is important, this attribute is used primarily by toolbar items to decide whether to show a label or not.

gtk.Action.set_label

    def set_label(label)

The set_is_important() method sets the label of action.

gtk.Action.set_short_label

    def set_short_label(short_label)

The set_short_label() method sets the short label of action.

gtk.Action.set_sensitive

    def set_sensitive(sensitive)

The set_sensitive() method sets the "sensitive" property to the value of sensitive. Note that this doesn't necessarily set the effective sensitivity. See the is_sensitive() method for more information.

gtk.Action.set_stock_id

    def set_stock_id(stock_id)

The set_stock_id() method sets the stock id on action

gtk.Action.set_tooltip

    def set_tooltip(tooltip)

The set_tooltip() method sets the tooltip text on action.

gtk.Action.set_visible

    def set_visible(visible)

The set_visible() method sets the "visible" property to the value of visible. Note that this doesn't necessarily set the effective visibility. See the is_visible() method for more information.

gtk.Action.set_visible_horizontal

    def set_visible_horizontal(visible_horizontal)

The set_visible_horizontal() method sets whether action is visible when horizontal

gtk.Action.set_visible_vertical

    def set_visible_vertical(visible_vertical)

The set_visible_vertical() method sets whether action is visible when vertical

gtk.Action.set_menu_item_type

    def set_menu_item_type(visible)

The set_menu_item_type() method is a classmethod that sets the type of menuitem to be created for the action to that specified by type. This is useful when using the gtk.UIManager and you would like to use something other than a gtk.ImageMenuItem (gtk.Action) or a gtk.CheckMenuItem (gtk.ToogleAction or gtk.RadioAction).

gtk.Action.set_tool_item_type

    def set_tool_item_type(visible)

The set_tool_item_type() method is a classmethod that sets the type of toolitem to be created for the action to that specified by type. This is useful when using the gtk.UIManager and you would like to use something other than a gtk.ToolButton (gtk.Action) or a gtk.ToggleToolButton (gtk.ToogleAction or gtk.RadioAction).

For example, to use a gtk.MenuToolButton in a toolbar you would subclass gtk.Action:

    class MenuToolAction(gtk.Action):
        __gtype_name__ = "MenuToolAction"

    gobject.type_register(MenuToolAction)
      

and then call set_tool_item_type():

    MenuToolAction.set_tool_item_type(gtk.MenuToolButton)
      

You have to create, name and add an instance of MenuToolAction to your gtk.ActionGroup:

    actiongroup.add_action(MenuToolAction("my_menutoolaction", "_MTB_label",
                                          "do something", None))
      

The ui description should reference the MenuToolAction like:

    <toolitem action="my_menutoolaction"/>
      

After the gtk.UIManager creates the toolbar including the gtk.MenuToolButton proxy for the MenuToolAction, you would have to create and add a menu to the gtk.MenuToolButton instance.

This technique can be extended by subclassing gtk.ToolItem and adding custom widgets to it.

gtk.Action.unblock_activate

    def unblock_activate()

The unblock_activate() method reenables activation signals from the action.

The "activate" gtk.Action Signal

    def callback(action, user_param1, ...)

The "activate" signal is emitted when action is activated.