gtkitemfactory

typedef struct _gtkitemfactory gtkitemfactory;

gtkprintfunc ()

void        (*gtkprintfunc)                 (gpointer func_data,
                                             const gchar *str);

gtktranslatefunc ()

gchar*      (*gtktranslatefunc)             (const gchar *path,
                                             gpointer func_data);

the function used to translate messages in e.g. gtkiconfactory and gtkactiongroup.

gtkitemfactorycallback ()

void        (*gtkitemfactorycallback)       ();

gtkitemfactorycallback1 ()

void        (*gtkitemfactorycallback1)      (gpointer callback_data,
                                             guint callback_action,
                                             gtkwidget *widget);

gtkitemfactorycallback2 ()

void        (*gtkitemfactorycallback2)      (gtkwidget *widget,
                                             gpointer callback_data,
                                             guint callback_action);

gtkitemfactoryentry

typedef struct {
  gchar *path;
  gchar *accelerator;

  gtkitemfactorycallback callback;
  guint			 callback_action;

  /* possible values:
   * null		-> "<item>"
   * ""			-> "<item>"
   * "<title>"		-> create a title item
   * "<item>"		-> create a simple item
   * "<imageitem>"	-> create an item holding an image
   * "<stockitem>"	-> create an item holding a stock image
   * "<checkitem>"	-> create a check item
   * "<toggleitem>"	-> create a toggle item
   * "<radioitem>"	-> create a radio item
   * <path>		-> path of a radio item to link against
   * "<separator>"	-> create a separator
   * "<tearoff>"	-> create a tearoff separator
   * "<branch>"		-> create an item to hold sub items
   * "<lastbranch>"	-> create a right justified item to hold sub items
   */
  gchar		 *item_type;

  /* extra data for some item types:
   *  imageitem  -> pointer to inlined pixbuf stream
   *  stockitem  -> name of stock item
   */
  gconstpointer extra_data;
} gtkitemfactoryentry;

gtkitemfactoryitem

typedef struct {
  gchar *path;
  gslist *widgets;
} gtkitemfactoryitem;

gtk_item_factory_new ()

gtkitemfactory* gtk_item_factory_new        (gtype container_type,
                                             const gchar *path,
                                             gtkaccelgroup *accel_group);

creates a new gtkitemfactory.

beware that the returned object does not have a floating reference.

gtk_item_factory_construct ()

void        gtk_item_factory_construct      (gtkitemfactory *ifactory,
                                             gtype container_type,
                                             const gchar *path,
                                             gtkaccelgroup *accel_group);

initializes an item factory.

gtk_item_factory_add_foreign ()

void        gtk_item_factory_add_foreign    (gtkwidget *accel_widget,
                                             const gchar *full_path,
                                             gtkaccelgroup *accel_group,
                                             guint keyval,
                                             gdkmodifiertype modifiers);

installs an accelerator for accel_widget in accel_group, that causes the ::activate signal to be emitted if the accelerator is activated.

this function can be used to make widgets participate in the accel saving/restoring functionality provided by gtk_accel_map_save() and gtk_accel_map_load(), even if they haven't been created by an item factory.

gtk_item_factory_from_widget ()

gtkitemfactory* gtk_item_factory_from_widget
                                            (gtkwidget *widget);

obtains the item factory from which a widget was created.

gtk_item_factory_path_from_widget ()

const gchar* gtk_item_factory_path_from_widget
                                            (gtkwidget *widget);

if widget has been created by an item factory, returns the full path to it. (the full path of a widget is the concatenation of the factory path specified in gtk_item_factory_new() with the path specified in the gtkitemfactoryentry from which the widget was created.)

gtk_item_factory_get_item ()

gtkwidget*  gtk_item_factory_get_item       (gtkitemfactory *ifactory,
                                             const gchar *path);

obtains the menu item which corresponds to path.

if the widget corresponding to path is a menu item which opens a submenu, then the item is returned. if you are interested in the submenu, use gtk_item_factory_get_widget() instead.

gtk_item_factory_get_widget ()

gtkwidget*  gtk_item_factory_get_widget     (gtkitemfactory *ifactory,
                                             const gchar *path);

obtains the widget which corresponds to path.

if the widget corresponding to path is a menu item which opens a submenu, then the submenu is returned. if you are interested in the menu item, use gtk_item_factory_get_item() instead.

gtk_item_factory_get_widget_by_action ()

gtkwidget*  gtk_item_factory_get_widget_by_action
                                            (gtkitemfactory *ifactory,
                                             guint action);

obtains the widget which was constructed from the gtkitemfactoryentry with the given action.

if there are multiple items with the same action, the result is undefined.

gtk_item_factory_get_item_by_action ()

gtkwidget*  gtk_item_factory_get_item_by_action
                                            (gtkitemfactory *ifactory,
                                             guint action);

obtains the menu item which was constructed from the first gtkitemfactoryentry with the given action.

gtk_item_factory_create_item ()

void        gtk_item_factory_create_item    (gtkitemfactory *ifactory,
                                             gtkitemfactoryentry *entry,
                                             gpointer callback_data,
                                             guint callback_type);

creates an item for entry.

gtk_item_factory_create_items ()

void        gtk_item_factory_create_items   (gtkitemfactory *ifactory,
                                             guint n_entries,
                                             gtkitemfactoryentry *entries,
                                             gpointer callback_data);

creates the menu items from the entries.

gtk_item_factory_create_items_ac ()

void        gtk_item_factory_create_items_ac
                                            (gtkitemfactory *ifactory,
                                             guint n_entries,
                                             gtkitemfactoryentry *entries,
                                             gpointer callback_data,
                                             guint callback_type);

creates the menu items from the entries.

gtk_item_factory_delete_item ()

void        gtk_item_factory_delete_item    (gtkitemfactory *ifactory,
                                             const gchar *path);

deletes the menu item which was created for path by the given item factory.

gtk_item_factory_delete_entry ()

void        gtk_item_factory_delete_entry   (gtkitemfactory *ifactory,
                                             gtkitemfactoryentry *entry);

deletes the menu item which was created from entry by the given item factory.

gtk_item_factory_delete_entries ()

void        gtk_item_factory_delete_entries (gtkitemfactory *ifactory,
                                             guint n_entries,
                                             gtkitemfactoryentry *entries);

deletes the menu items which were created from the entries by the given item factory.

gtk_item_factory_popup ()

void        gtk_item_factory_popup          (gtkitemfactory *ifactory,
                                             guint x,
                                             guint y,
                                             guint mouse_button,
                                             guint32 time_);

pops up the menu constructed from the item factory at (x, y).

the mouse_button parameter should be the mouse button pressed to initiate the menu popup. if the menu popup was initiated by something other than a mouse button press, such as a mouse button release or a keypress, mouse_button should be 0.

the time_ parameter should be the time stamp of the event that initiated the popup. if such an event is not available, use gtk_get_current_event_time() instead.

the operation of the mouse_button and the time_ parameter is the same as the button and activation_time parameters for gtk_menu_popup().

gtk_item_factory_popup_with_data ()

void        gtk_item_factory_popup_with_data
                                            (gtkitemfactory *ifactory,
                                             gpointer popup_data,
                                             gtkdestroynotify destroy,
                                             guint x,
                                             guint y,
                                             guint mouse_button,
                                             guint32 time_);

pops up the menu constructed from the item factory at (x, y). callbacks can access the popup_data while the menu is posted via gtk_item_factory_popup_data() and gtk_item_factory_popup_data_from_widget().

the mouse_button parameter should be the mouse button pressed to initiate the menu popup. if the menu popup was initiated by something other than a mouse button press, such as a mouse button release or a keypress, mouse_button should be 0.

the time_ parameter should be the time stamp of the event that initiated the popup. if such an event is not available, use gtk_get_current_event_time() instead.

the operation of the mouse_button and the time_ parameters is the same as the button and activation_time parameters for gtk_menu_popup().

gtk_item_factory_popup_data ()

gpointer    gtk_item_factory_popup_data     (gtkitemfactory *ifactory);

obtains the popup_data which was passed to gtk_item_factory_popup_with_data(). this data is available until the menu is popped down again.

gtk_item_factory_popup_data_from_widget ()

gpointer    gtk_item_factory_popup_data_from_widget
                                            (gtkwidget *widget);

obtains the popup_data which was passed to gtk_item_factory_popup_with_data(). this data is available until the menu is popped down again.

gtk_item_factory_from_path ()

gtkitemfactory* gtk_item_factory_from_path  (const gchar *path);

finds an item factory which has been constructed using the "<name>" prefix of path as the path argument for gtk_item_factory_new().

gtk_item_factory_create_menu_entries ()

void        gtk_item_factory_create_menu_entries
                                            (guint n_entries,
                                             gtkmenuentry *entries);

creates the menu items from the entries.

gtk_item_factories_path_delete ()

void        gtk_item_factories_path_delete  (const gchar *ifactory_path,
                                             const gchar *path);

deletes all widgets constructed from the specified path.

gtk_item_factory_set_translate_func ()

void        gtk_item_factory_set_translate_func
                                            (gtkitemfactory *ifactory,
                                             gtktranslatefunc func,
                                             gpointer data,
                                             gtkdestroynotify notify);

sets a function to be used for translating the path elements before they are displayed.