gtk.ItemFactory
gtk.ItemFactory — creates menus, menubars and option menus from a data
description.
Description
The gtk.ItemFactory
provides a convenient way to create and manage menus, menubars and option
menus from a data description. The data description is a tuple or list
containing a list of entry tuples that each describe an individual menu,
menuitem, etc. Each entry tuple may contain the following entry fields
though only the path must be specified; the other fields are
optional:
- A path that defines the logical position of the menu or
menuitem in the menu hierarchy. a path is similar to a file path in that it
starts with a slash (/) character and all components are joined by a slash
(/) character. The last component may have an underscore that indicates that
the following character is to be used as the accelerator mnemonic.
- An accelerator that defines a key sequence that will
activate the menuitem. The key sequence is a set of zero or more modifiers
followed by a single key. The modifier keys are: | "<alt>" | Alt-Lor
Alt-R |  | "<ctl>", "<ctrl>", "<control>", | Ctrl-Lor
Ctrl-R |  | "<shift>", "<shft>", | Shift-Lor
Shift-R |  
 
- A callback function or method that will be invoked when the
menu item is activated or the accelerator key sequence is pressed. The
callback function is defined as either: | 
    def callback(callback_data, callback_action, widget)
    def callback(callback_action, widget)
 |  
 - where callback_action is the
callback action defined below, callback_data is the
data passed with the create_items() 
method and widget is the menuitem widget. The second
definition must be used if no callback_data argument
is specified by the call to create_items(). 
- A callback action that is an arbitrary integer
value.
- An item type is a string describing the type of the
item: | "None", "", "Item", | a simple menu item |  | "<Title>" | a title item |  | "<ImageItem>" | an image item |  | "<StockItem>" | an item holding a stock image |  | "<CheckItem>" | a check item |  | "<ToggleItem>" | a toggle item |  | "<RadioItem>" | a radio item |  | <path> | the path of a radio item group to add item
to |  | "<Separator>" | a separator |  | "<Tearoff>" | a tearoff separator |  | "<Branch>" | an item to hold sub items |  | "<LastBranch>" | a right justified item to hold sub items |  
 
- extra data that is either a gtk.gdk.Pixbuf or a
stock ID
Constructor
|     gtk.ItemFactory(container_type, path, accel_group=None)
 | 
Creates a new gtk.ItemFactory
object.
Methods
gtk.ItemFactory.construct
|     def construct(container_type, path, accel_group)
 | 
| container_type : | the kind of menu to create; one of: gtk.MenuBar, gtk.Menu or gtk.OptionMenu. | 
| path : | the path of the item factory, a string of the
form "<name>" | 
| accel_group : | a gtk.AccelGroup
to which the accelerators for the menu items will be added, or
None to create a new one | 
The construct() method initializes an
item factory.
gtk.ItemFactory.get_item
| path : | the path to the menu item | 
| Returns : | the menu item with the specified
path, or None if
path doesn't lead to a menu item | 
The get_item() method returns the menu
item that corresponds to path. If the widget
corresponding to path is a menu item that opens a
submenu, then the item is returned. If you are interested in the submenu,
use the get_widget() 
method instead.
gtk.ItemFactory.get_widget
| path : | the path to the widget | 
| Returns : | the widget associated with the specified
path, or None if
path doesn't lead to a widget | 
The get_widget() method returns the
widget that corresponds to path. If the widget
corresponding to path is a menu item that opens a
submenu, then the submenu is returned. If you are interested in the menu
item, use get_item() 
instead.
gtk.ItemFactory.get_widget_by_action
|     def get_widget_by_action(action)
 | 
| action : | a callback action value | 
| Returns : | the widget that corresponds to the given
action, or None if no widget was
found | 
The get_widget_by_action() method
returns the widget that is associated with the specified
action. If there are multiple items with the same
action, the result is undefined.
gtk.ItemFactory.get_item_by_action
|     def get_item_by_action(action)
 | 
| action : | a callback action value | 
| Returns : | the menu item that corresponds to the specified
action, or None if no menu item
was found | 
The get_item_by_action() returns the
menu item that is associated with the specified
action.
gtk.ItemFactory.create_items
|     def create_items(entries, callback_data=None)
 | 
| entries : | a tuple or list of item factory
entries | 
| callback_data : | optional data passed to the callback functions
of all entries | 
The create_items() method creates the
menu items from the specified item factory entries.
If no callback_data is specified it will not be
passed to the callback functions i.e the callback functions will be passed
one less argument.
gtk.ItemFactory.delete_item
The delete_item() method deletes the
menu item that was created with the specified
path.
gtk.ItemFactory.popup
|     def popup(x, y, mouse_button, time=0L)
 | 
| x : | the x position | 
| y : | the y position | 
| mouse_button : | the mouse button that was pressed to initiate
this action | 
| time : | an optional timestamp for this action; default
is 0L which means use the current time | 
The popup() method pops up the menu
constructed from the item factory at the specified location
(x, y). This method is
generally invoked in response to a "button_press_event" so the arguments are
retrieved from the event information.
Functions
gtk.item_factory_from_widget
|     def gtk.item_factory_from_widget(widget)
 | 
The gtk.item_factory_from_widget() function
returns the gtk.ItemFactory
object that created the gtk.Widget specified
by widget.
gtk.item_factory_path_from_widget
|     def gtk.item_factory_path_from_widget(widget)
 | 
The gtk.item_factory_path_from_widget()
function returns the full path to the gtk.ItemFactory
that created the gtk.Widget specified
by widget.