BonoboUIEngine

typedef struct _BonoboUIEngine 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;

BonoboUIEnginePrivate

typedef struct _BonoboUIEnginePrivate BonoboUIEnginePrivate;

BonoboUIEngineClass

typedef struct {
	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);
} BonoboUIEngineClass;

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 associated, 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)           : Run Last

The "destroy" signal

void                user_function                      (BonoboUIEngine *bonobouiengine,
                                                        gpointer        user_data)           : Run Last

The "emit-event-on" signal

void                user_function                      (BonoboUIEngine *bonobouiengine,
                                                        gpointer        arg1,
                                                        gchar          *arg2,
                                                        gpointer        user_data)           : Run Last

The "emit-verb-on" signal

void                user_function                      (BonoboUIEngine *bonobouiengine,
                                                        gpointer        arg1,
                                                        gpointer        user_data)           : Run Last

The "remove-hint" signal

void                user_function                      (BonoboUIEngine *bonobouiengine,
                                                        gpointer        user_data)           : Run Last