struct BonoboUIEngine

struct BonoboUIEngine;

bonobo_ui_engine_deregister_dead_components ()

void        bonobo_ui_engine_deregister_dead_components
                                            (BonoboUIEngine *engine);

Detect any components that have died and deregister them - unmerging their UI elements.

bonobo_ui_engine_deregister_component_by_ref ()

void        bonobo_ui_engine_deregister_component_by_ref
                                            (BonoboUIEngine *engine,
                                             Bonobo_Unknown ref);

Deregisters component with reference ref from engine.

bonobo_ui_engine_deregister_component ()

void        bonobo_ui_engine_deregister_component
                                            (BonoboUIEngine *engine,
                                             const char *name);

Deregisters component of name from engine.

bonobo_ui_engine_register_component ()

void        bonobo_ui_engine_register_component
                                            (BonoboUIEngine *engine,
                                             const char *name,
                                             Bonobo_Unknown component);

Registers component with engine by name.

bonobo_ui_engine_get_component_names ()

GList*      bonobo_ui_engine_get_component_names
                                            (BonoboUIEngine *engine);

bonobo_ui_engine_get_component ()

Bonobo_Unknown bonobo_ui_engine_get_component
                                            (BonoboUIEngine *engine,
                                             const char *name);

bonobo_ui_engine_config_set_path ()

void        bonobo_ui_engine_config_set_path
                                            (BonoboUIEngine *engine,
                                             const char *path);

bonobo_ui_engine_config_get_path ()

const char* bonobo_ui_engine_config_get_path
                                            (BonoboUIEngine *engine);

bonobo_ui_engine_set_ui_container ()

void        bonobo_ui_engine_set_ui_container
                                            (BonoboUIEngine *engine,
                                             BonoboUIContainer *ui_container);

Associates a given UI Container with this BonoboUIEngine.

bonobo_ui_engine_get_ui_container ()

BonoboUIContainer* bonobo_ui_engine_get_ui_container
                                            (BonoboUIEngine *engine);

Fetches the associated UI Container

bonobo_ui_engine_freeze ()

void        bonobo_ui_engine_freeze         (BonoboUIEngine *engine);

This increments the freeze count on the tree, while this count > 0 no syncronization between the internal XML model and the widget views occurs. This means that many simple merges can be glupped together with little performance impact and overhead.

bonobo_ui_engine_thaw ()

void        bonobo_ui_engine_thaw           (BonoboUIEngine *engine);

This decrements the freeze count and if it is 0 causes the UI widgets to be re-synched with the XML model, see also bonobo_ui_engine_freeze

bonobo_ui_engine_update ()

void        bonobo_ui_engine_update         (BonoboUIEngine *engine);

This function is called to update the entire UI model synchronizing any changes in it with the widget tree where neccessary

enum BonoboUIError

typedef enum {
	BONOBO_UI_ERROR_OK = 0,
	BONOBO_UI_ERROR_BAD_PARAM,
	BONOBO_UI_ERROR_INVALID_PATH,
	BONOBO_UI_ERROR_INVALID_XML
} BonoboUIError;

struct BonoboUIEnginePrivate

struct BonoboUIEnginePrivate;

struct BonoboUIEngineClass

struct BonoboUIEngineClass {

	GObjectClass parent_class;

	/* Signals */
	void (*add_hint)      (BonoboUIEngine *engine,
			       const char     *str);
	void (*remove_hint)   (BonoboUIEngine *engine);

	void (*emit_verb_on)  (BonoboUIEngine *engine,
			       BonoboUINode   *node);

	void (*emit_event_on) (BonoboUIEngine *engine,
			       BonoboUINode   *node,
			       const char     *state);

	void (*destroy)       (BonoboUIEngine *engine);

};

bonobo_ui_engine_construct ()

BonoboUIEngine* bonobo_ui_engine_construct  (BonoboUIEngine *engine,
                                             GObject *view);

Construct a new bonobo_ui_engine

bonobo_ui_engine_new ()

BonoboUIEngine* bonobo_ui_engine_new        (GObject *view);

Create a new BonoboUIEngine structure

bonobo_ui_engine_get_view ()

GObject*    bonobo_ui_engine_get_view       (BonoboUIEngine *engine);

This returns the associated view, often a BonoboWindow

bonobo_ui_engine_add_sync ()

void        bonobo_ui_engine_add_sync       (BonoboUIEngine *engine,
                                             BonoboUISync *sync);

Add a BonoboUISync synchronizer to the engine

bonobo_ui_engine_remove_sync ()

void        bonobo_ui_engine_remove_sync    (BonoboUIEngine *engine,
                                             BonoboUISync *sync);

Remove a specified BonoboUISync synchronizer from the engine

bonobo_ui_engine_get_syncs ()

GSList*     bonobo_ui_engine_get_syncs      (BonoboUIEngine *engine);

Retrieve a list of available synchronizers.

bonobo_ui_engine_update_node ()

void        bonobo_ui_engine_update_node    (BonoboUIEngine *engine,
                                             BonoboUISync *sync,
                                             BonoboUINode *node);

This function is used to write recursive synchronizers and is intended only for internal / privilaged use.

By the time this returns, due to re-enterancy, node points at undefined memory.

bonobo_ui_engine_queue_update ()

void        bonobo_ui_engine_queue_update   (BonoboUIEngine *engine,
                                             GtkWidget *widget,
                                             BonoboUINode *node,
                                             BonoboUINode *cmd_node);

This function is used to queue a state update on widget, essentialy transfering any state from the XML model into the widget view. This is queued to avoid re-enterancy problems.

bonobo_ui_engine_build_control ()

GtkWidget*  bonobo_ui_engine_build_control  (BonoboUIEngine *engine,
                                             BonoboUINode *node);

A helper function for synchronizers, this creates a control if possible from the node's associated object, stamps the node as containing a control and sets its widget.

bonobo_ui_engine_widget_get_node ()

BonoboUINode* bonobo_ui_engine_widget_get_node
                                            (GtkWidget *widget);

bonobo_ui_engine_widget_set_node ()

void        bonobo_ui_engine_widget_set_node
                                            (BonoboUIEngine *engine,
                                             GtkWidget *widget,
                                             BonoboUINode *node);

Used internaly to associate a widget with a node, some synchronisers need to be able to execute code on widget creation.

bonobo_ui_engine_xml_set_prop ()

BonoboUIError bonobo_ui_engine_xml_set_prop (BonoboUIEngine *engine,
                                             const char *path,
                                             const char *property,
                                             const char *value,
                                             const char *component);

This function sets the property of a node in the internal tree representation at path in engine.

bonobo_ui_engine_xml_get_prop ()

CORBA_char* bonobo_ui_engine_xml_get_prop   (BonoboUIEngine *engine,
                                             const char *path,
                                             const char *prop,
                                             gboolean *invalid_path);

This function fetches the property prop at node at path in the internal structure.

bonobo_ui_engine_prune_widget_info ()

void        bonobo_ui_engine_prune_widget_info
                                            (BonoboUIEngine *engine,
                                             BonoboUINode *node,
                                             gboolean save_custom);

This function destroys any widgets associated with node and all its children, if save_custom, any widget that is a custom widget ( such as a control ) will be preserved. All widgets flagged ROOT are preserved always.

bonobo_ui_engine_get_path ()

BonoboUINode* bonobo_ui_engine_get_path     (BonoboUIEngine *engine,
                                             const char *path);

This routine gets a node from the internal XML tree pointed at by path

bonobo_ui_engine_dirty_tree ()

void        bonobo_ui_engine_dirty_tree     (BonoboUIEngine *engine,
                                             BonoboUINode *node);

Mark all the node's children as being dirty and needing a re-synch with their widget views.

bonobo_ui_engine_clean_tree ()

void        bonobo_ui_engine_clean_tree     (BonoboUIEngine *engine,
                                             BonoboUINode *node);

This cleans the tree, marking the node and its children as not needing a re-synch with their widget views.

bonobo_ui_engine_dump ()

void        bonobo_ui_engine_dump           (BonoboUIEngine *engine,
                                             FILE *out,
                                             const char *msg);

This is a debugging function mostly for internal and testing use, it dumps the XML tree, including the assoicated, and overridden nodes in a wierd hackish format to the out stream with the helpful msg prepended.

bonobo_ui_engine_node_get_object ()

CORBA_Object bonobo_ui_engine_node_get_object
                                            (BonoboUIEngine *engine,
                                             BonoboUINode *node);

bonobo_ui_engine_node_is_dirty ()

gboolean    bonobo_ui_engine_node_is_dirty  (BonoboUIEngine *engine,
                                             BonoboUINode *node);

bonobo_ui_engine_node_get_widget ()

GtkWidget*  bonobo_ui_engine_node_get_widget
                                            (BonoboUIEngine *engine,
                                             BonoboUINode *node);

Gets the widget associated with node

bonobo_ui_engine_node_get_id ()

const char* bonobo_ui_engine_node_get_id    (BonoboUIEngine *engine,
                                             BonoboUINode *node);

Each component has an associated textual id or name - see bonobo_ui_engine_register_component

bonobo_ui_engine_get_cmd_node ()

BonoboUINode* bonobo_ui_engine_get_cmd_node (BonoboUIEngine *engine,
                                             BonoboUINode *from_node);

This function seeks the command node associated with from_node in engine 's internal tree.

bonobo_ui_engine_node_set_dirty ()

void        bonobo_ui_engine_node_set_dirty (BonoboUIEngine *engine,
                                             BonoboUINode *node,
                                             gboolean dirty);

Set node s dirty bit to dirty.

bonobo_ui_engine_stamp_custom ()

void        bonobo_ui_engine_stamp_custom   (BonoboUIEngine *engine,
                                             BonoboUINode *node);

Marks a node as containing a custom widget.

bonobo_ui_engine_widget_set ()

void        bonobo_ui_engine_widget_set     (BonoboUIEngine *engine,
                                             const char *path,
                                             GtkWidget *widget);

bonobo_ui_engine_stamp_root ()

void        bonobo_ui_engine_stamp_root     (BonoboUIEngine *engine,
                                             BonoboUINode *node,
                                             GtkWidget *widget);

This stamps node with widget which is marked as being a ROOT node, so the engine will never destroy it.

bonobo_ui_engine_add_hint ()

void        bonobo_ui_engine_add_hint       (BonoboUIEngine *engine,
                                             const char *str);

This fires the 'add_hint' signal.

bonobo_ui_engine_remove_hint ()

void        bonobo_ui_engine_remove_hint    (BonoboUIEngine *engine);

This fires the 'remove_hint' signal

bonobo_ui_engine_emit_verb_on ()

void        bonobo_ui_engine_emit_verb_on   (BonoboUIEngine *engine,
                                             BonoboUINode *node);

This fires the 'emit_verb' signal

bonobo_ui_engine_emit_event_on ()

void        bonobo_ui_engine_emit_event_on  (BonoboUIEngine *engine,
                                             BonoboUINode *node,
                                             const char *state);

This fires the 'emit_event_on' signal

bonobo_ui_engine_emit_verb_on_w ()

void        bonobo_ui_engine_emit_verb_on_w (BonoboUIEngine *engine,
                                             GtkWidget *widget);

This function looks up the node from widget and emits the 'emit_verb_on' signal on that node.

bonobo_ui_engine_emit_event_on_w ()

void        bonobo_ui_engine_emit_event_on_w
                                            (BonoboUIEngine *engine,
                                             GtkWidget *widget,
                                             const char *state);

This function looks up the node from widget and emits the 'emit_event_on' signal on that node passint state as the new state.

bonobo_ui_engine_get_attr ()

char*       bonobo_ui_engine_get_attr       (BonoboUINode *node,
                                             BonoboUINode *cmd_node,
                                             const char *attr);

This function is used to get node attributes in many UI synchronizers, it first attempts to get the attribute from node, and if this fails falls back to cmd_node.

bonobo_ui_engine_widget_attach_node ()

void        bonobo_ui_engine_widget_attach_node
                                            (GtkWidget *widget,
                                             BonoboUINode *node);

Associate node with widget

bonobo_ui_engine_xml_get ()

CORBA_char* bonobo_ui_engine_xml_get        (BonoboUIEngine *engine,
                                             const char *path,
                                             gboolean node_only);

This function fetches the node at path in the internal structure, and if node_only dumps the node to an XML string, otherwise it dumps it and its children.

bonobo_ui_engine_xml_node_exists ()

gboolean    bonobo_ui_engine_xml_node_exists
                                            (BonoboUIEngine *engine,
                                             const char *path);

bonobo_ui_engine_xml_merge_tree ()

BonoboUIError bonobo_ui_engine_xml_merge_tree
                                            (BonoboUIEngine *engine,
                                             const char *path,
                                             BonoboUINode *tree,
                                             const char *component);

This function merges the XML tree into the internal tree representation as children of the node at path in engine.

bonobo_ui_engine_xml_rm ()

BonoboUIError bonobo_ui_engine_xml_rm       (BonoboUIEngine *engine,
                                             const char *path,
                                             const char *by_component);

Remove a chunk of the xml tree pointed at by path in engine, if by_component then only remove items associated with that component - possibly revealing other overridden items.

bonobo_ui_engine_object_set ()

BonoboUIError bonobo_ui_engine_object_set   (BonoboUIEngine *engine,
                                             const char *path,
                                             Bonobo_Unknown object,
                                             CORBA_Environment *ev);

This associates a CORBA Object reference with a node in the tree, most often this is done to insert a Control's reference into a 'control' element.

bonobo_ui_engine_object_get ()

BonoboUIError bonobo_ui_engine_object_get   (BonoboUIEngine *engine,
                                             const char *path,
                                             Bonobo_Unknown *object,
                                             CORBA_Environment *ev);

This extracts a CORBA object reference associated with the node at path in engine, and returns it in the reference pointed to by object.

bonobo_ui_engine_exec_verb ()

void        bonobo_ui_engine_exec_verb      (BonoboUIEngine *engine,
                                             const CORBA_char *cname,
                                             CORBA_Environment *ev);

bonobo_ui_engine_ui_event ()

void        bonobo_ui_engine_ui_event       (BonoboUIEngine *engine,
                                             const CORBA_char *id,
                                             const Bonobo_UIComponent_EventType type,
                                             const CORBA_char *state,
                                             CORBA_Environment *ev);

The "add-hint" signal

void        user_function                  (BonoboUIEngine *bonobouiengine,
                                            gchar *arg1,
                                            gpointer user_data);

The "destroy" signal

void        user_function                  (BonoboUIEngine *bonobouiengine,
                                            gpointer user_data);

The "emit-event-on" signal

void        user_function                  (BonoboUIEngine *bonobouiengine,
                                            gpointer arg1,
                                            gchar *arg2,
                                            gpointer user_data);

The "emit-verb-on" signal

void        user_function                  (BonoboUIEngine *bonobouiengine,
                                            gpointer arg1,
                                            gpointer user_data);

The "remove-hint" signal

void        user_function                  (BonoboUIEngine *bonobouiengine,
                                            gpointer user_data);