BonoboUISyncStateFn ()

void
(*BonoboUISyncStateFn) (BonoboUISync *sync,
                        BonoboUINode *node,
                        BonoboUINode *cmd_node,
                        GtkWidget *widget,
                        GtkWidget *parent);

BonoboUISyncBuildFn ()

GtkWidget *
(*BonoboUISyncBuildFn) (BonoboUISync *sync,
                        BonoboUINode *node,
                        BonoboUINode *cmd_node,
                        int *pos,
                        GtkWidget *parent);

bonobo_ui_sync_construct ()

BonoboUISync *
bonobo_ui_sync_construct (BonoboUISync *sync,
                          BonoboUIEngine *engine,
                          gboolean is_recursive,
                          gboolean has_widgets);

Used to construct a new synchronizer object

bonobo_ui_sync_is_recursive ()

gboolean
bonobo_ui_sync_is_recursive (BonoboUISync *sync);

bonobo_ui_sync_has_widgets ()

gboolean
bonobo_ui_sync_has_widgets (BonoboUISync *sync);

bonobo_ui_sync_remove_root ()

void
bonobo_ui_sync_remove_root (BonoboUISync *sync,
                            BonoboUINode *root);

This is called when a 'root' or toplevel node is removed that this synchronizer deals with. eg. in the toolbar case, this might trigger hiding an associated dock item.

bonobo_ui_sync_update_root ()

void
bonobo_ui_sync_update_root (BonoboUISync *sync,
                            BonoboUINode *root);

This flags the fact that a toplevel node has changed and is used primarily by non-recursive handlers, such as the keybinding sync method.

bonobo_ui_sync_state ()

void
bonobo_ui_sync_state (BonoboUISync *sync,
                      BonoboUINode *node,
                      BonoboUINode *cmd_node,
                      GtkWidget *widget,
                      GtkWidget *parent);

This method is used to synchronize the state of a node with that of a widget , by ensuring the pertainant attributes are reflected in the widget view.

bonobo_ui_sync_state_placeholder ()

void
bonobo_ui_sync_state_placeholder (BonoboUISync *sync,
                                  BonoboUINode *node,
                                  BonoboUINode *cmd_node,
                                  GtkWidget *widget,
                                  GtkWidget *parent);

This synchronizes the state of a placeholder, there is a default implementation for this method.

bonobo_ui_sync_build ()

GtkWidget *
bonobo_ui_sync_build (BonoboUISync *sync,
                      BonoboUINode *node,
                      BonoboUINode *cmd_node,
                      int *pos,
                      GtkWidget *parent);

This function causes a child widget to be build that matches node 's attributes. This should then be inserted by into parent 's associated widget at position pos in the container.

bonobo_ui_sync_build_placeholder ()

GtkWidget *
bonobo_ui_sync_build_placeholder (BonoboUISync *sync,
                                  BonoboUINode *node,
                                  BonoboUINode *cmd_node,
                                  int *pos,
                                  GtkWidget *parent);

As for bonobo_ui_sync_build but for placeholders

bonobo_ui_sync_ignore_widget ()

gboolean
bonobo_ui_sync_ignore_widget (BonoboUISync *sync,
                              GtkWidget *widget);

bonobo_ui_sync_get_widgets ()

GList *
bonobo_ui_sync_get_widgets (BonoboUISync *sync,
                            BonoboUINode *node);

This method is used to obtain a sensibly ordered list of child widgets of the container associated with node . Essentialy this does something like gtk_container_children but preserving the visible order of the widgets in the list.

bonobo_ui_sync_stamp_root ()

void
bonobo_ui_sync_stamp_root (BonoboUISync *sync);

This asks the synchronizer to stamp all its associated root widget containers into the XML tree.

bonobo_ui_sync_can_handle ()

gboolean
bonobo_ui_sync_can_handle (BonoboUISync *sync,
                           BonoboUINode *node);

This is used to determine which, of multiple synchronizers can be used to deal with a specific node type. Each synchronizer deals with different types of node.

bonobo_ui_sync_get_attached ()

GtkWidget *
bonobo_ui_sync_get_attached (BonoboUISync *sync,
                             GtkWidget *widget,
                             BonoboUINode *node);

This is used to get an 'attached' widget - some widgets have associated widgets that are coupled in strange ways - eg. GtkMenuItem <-> GtkMenuShell It is neccessary to store the GtkContainer item of these couples in the XML tree, since then we can do things more genericaly and cleanly.

bonobo_ui_sync_state_update ()

void
bonobo_ui_sync_state_update (BonoboUISync *sync,
                             GtkWidget *widget,
                             const char *new_state);

This is used to synchronize state with a stateful widget, eg. when a "state" attribute is set, this is not reflected in the normal 'state-sync' process, but occurs later with a set of state_updates to avoid re-enterancy problems.

bonobo_ui_sync_do_show_hide ()

gboolean
bonobo_ui_sync_do_show_hide (BonoboUISync *sync,
                             BonoboUINode *node,
                             BonoboUINode *cmd_node,
                             GtkWidget *widget);

This is a helper function that applies the hidden attribute from either the node or fallback to the cmd_node to the widget .

bonobo_ui_sync_wrap_widget ()

GtkWidget *
bonobo_ui_sync_wrap_widget (BonoboUISync *sync,
                            GtkWidget *custom_widget);

bonobo_ui_sync_keys_get_type ()

GType
bonobo_ui_sync_keys_get_type (void);

bonobo_ui_sync_menu_get_type ()

GType
bonobo_ui_sync_menu_get_type (void);

bonobo_ui_sync_status_get_type ()

GType
bonobo_ui_sync_status_get_type (void);

bonobo_ui_sync_toolbar_get_type ()

GType
bonobo_ui_sync_toolbar_get_type (void);

struct BonoboUISync

struct BonoboUISync;

BonoboUISyncPrivate

typedef struct _BonoboUISyncPrivate BonoboUISyncPrivate;

BonoboUISyncClass

typedef struct {
	GObjectClass parent_class;

	BonoboUISyncStateFn sync_state;
	BonoboUISyncStateFn sync_state_placeholder;
	BonoboUISyncBuildFn build;
	BonoboUISyncBuildFn build_placeholder;

	void          (*update_root)     (BonoboUISync     *sync,
					  BonoboUINode     *root);

	void          (*remove_root)     (BonoboUISync     *sync,
					  BonoboUINode     *root);

	GList        *(*get_widgets)     (BonoboUISync     *sync,
					  BonoboUINode     *node);

	void          (*state_update)    (BonoboUISync     *sync,
					  GtkWidget        *widget,
					  const char       *new_state);

	gboolean      (*ignore_widget)   (BonoboUISync     *sync,
					  GtkWidget        *widget);

	gboolean      (*can_handle)      (BonoboUISync     *sync,
					  BonoboUINode     *node);

        void          (*stamp_root)      (BonoboUISync     *sync);

	GtkWidget    *(*get_attached)    (BonoboUISync     *sync,
					  GtkWidget        *widget,
					  BonoboUINode     *node);

	GtkWidget    *(*wrap_widget)     (BonoboUISync     *sync,
					  GtkWidget        *custom_widget);
} BonoboUISyncClass;