gtk.ItemFactory — creates menus, menubars and option menus from a data description.
| class gtk.ItemFactory(gtk.Object): | 
Functionsdef gtk.item_factory_from_widget(widget)def gtk.item_factory_path_from_widget(widget)
gtk.ItemFactory
is deprecated in PyGTK 2.4 and above. The gtk.UIManager
should be used instead.
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:
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().
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 | 
gtk.gdk.Pixbuf or a
stock ID    gtk.ItemFactory(container_type, path, accel_group=None)| 
 | the kind of menu to create; one of: gtk.MenuBar,gtk.Menuorgtk.OptionMenu. | 
| 
 | the path of the new item factory, a string of the
form "<name>" | 
| 
 | a gtk.AccelGroupto which the accelerators for the menu items will be added, orNoneto create a new one | 
| Returns : | a new gtk.ItemFactory | 
Creates a new gtk.ItemFactory
object.
    def construct(container_type, path, accel_group)| 
 | the kind of menu to create; one of: gtk.MenuBar,gtk.Menuorgtk.OptionMenu. | 
| 
 | the path of the item factory, a string of the
form "<name>" | 
| 
 | a gtk.AccelGroupto which the accelerators for the menu items will be added, orNoneto create a new one | 
The construct() method initializes an
item factory.
    def get_item(path)| 
 | the path to the menu item | 
| Returns : | the menu item with the specified path, orNoneifpathdoesn'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.
    def get_widget(path)| 
 | the path to the widget | 
| Returns : | the widget associated with the specified path, orNoneifpathdoesn'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.
    def get_widget_by_action(action)| 
 | a callback action value | 
| Returns : | the widget that corresponds to the given
action, or Noneif 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.
    def get_item_by_action(action)| 
 | a callback action value | 
| Returns : | the menu item that corresponds to the specified action, orNoneif no menu item
was found | 
The get_item_by_action() returns the
menu item that is associated with the specified
action.
    def create_items(entries, callback_data=None)| 
 | a tuple or list of item factory entries | 
| 
 | 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.
    def delete_item(path)| 
 | a path | 
The delete_item() method deletes the
menu item that was created with the specified
path.
    def popup(x, y, mouse_button, time=0L)| 
 | the x position | 
| 
 | the y position | 
| 
 | the mouse button that was pressed to initiate this action | 
| 
 | 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.
    def gtk.item_factory_from_widget(widget)| 
 | a gtk.Widgetobject | 
| Returns : | the gtk.ItemFactorythat createdwidget | 
The gtk.item_factory_from_widget() function
returns the gtk.ItemFactory
object that created the gtk.Widget specified
by widget.
    def gtk.item_factory_path_from_widget(widget)| 
 | a gtk.Widgetobject | 
| Returns : | the full path to the gtk.ItemFactorythat createdwidget | 
The gtk.item_factory_path_from_widget()
function returns the full path to the gtk.ItemFactory
that created the gtk.Widget specified
by widget.