Completely re-work the protocol definitions.

The XML has been re-done without the telepathy extensions.
An 'idl' has been added. This is NOT currently the canonical
protocol definition. It has more information than the XML
spec but is written in a pseudo idl for which there is no
parser. In the future the protocol should be defined to a similar
standard. The requirements for moving to canonical IDL
are that it is useful for generating Qt / GBus bindings.

Add a script to create c literals of introspection
data out of the introspection XML.

19 files changed, 1523 insertions, 0 deletions

diff --git a/idl/accessible.didl b/idl/accessible.didl
new file mode 100644
index 00000000..eee462f8
--- /dev/null
+++ b/idl/accessible.didl
@@ -0,0 +1,234 @@
+
+/*
+  The base interface which is implemented by all accessible objects.
+ */
+
+interface org.freestandards.atspi.Accessible {
+
+	enum <uint32> Role {
+		ROLE_INVALID = 0,
+		ROLE_ACCELERATOR_LABEL,
+		ROLE_ALERT,
+		ROLE_ANIMATION,
+		ROLE_ARROW,
+		ROLE_CALENDAR,
+		ROLE_CANVAS,
+		ROLE_CHECK_BOX,
+		ROLE_CHECK_MENU_ITEM,
+		ROLE_COLOR_CHOOSER,
+		ROLE_COLUMN_HEADER,
+		ROLE_COMBO_BOX,
+		ROLE_DATE_EDITOR,
+		ROLE_DESKTOP_ICON,
+		ROLE_DESKTOP_FRAME,
+		ROLE_DIAL,
+		ROLE_DIALOG,
+		ROLE_DIRECTORY_PANE,
+		ROLE_DRAWING_AREA,
+		ROLE_FILE_CHOOSER,
+		ROLE_FILLER,
+		ROLE_FOCUS_TRAVERSABLE,
+		ROLE_FONT_CHOOSER,
+		ROLE_FRAME,
+		ROLE_GLASS_PANE,
+		ROLE_HTML_CONTAINER,
+		ROLE_ICON,
+		ROLE_IMAGE,
+		ROLE_INTERNAL_FRAME,
+		ROLE_LABEL,
+		ROLE_LAYERED_PANE,
+		ROLE_LIST,
+		ROLE_LIST_ITEM,
+		ROLE_MENU,
+		ROLE_MENU_BAR,
+		ROLE_MENU_ITEM,
+		ROLE_OPTION_PANE,
+		ROLE_PAGE_TAB,
+		ROLE_PAGE_TAB_LIST,
+		ROLE_PANEL,
+		ROLE_PASSWORD_TEXT,
+		ROLE_POPUP_MENU,
+		ROLE_PROGRESS_BAR,
+		ROLE_PUSH_BUTTON,
+		ROLE_RADIO_BUTTON,
+		ROLE_RADIO_MENU_ITEM,
+		ROLE_ROOT_PANE,
+		ROLE_ROW_HEADER,
+		ROLE_SCROLL_BAR,
+		ROLE_SCROLL_PANE,
+		ROLE_SEPARATOR,
+		ROLE_SLIDER,
+		ROLE_SPIN_BUTTON,
+		ROLE_SPLIT_PANE,
+		ROLE_STATUS_BAR,
+		ROLE_TABLE,
+		ROLE_TABLE_CELL,
+		ROLE_TABLE_COLUMN_HEADER,
+		ROLE_TABLE_ROW_HEADER,
+		ROLE_TEAROFF_MENU_ITEM,
+		ROLE_TERMINAL,
+		ROLE_TEXT,
+		ROLE_TOGGLE_BUTTON,
+		ROLE_TOOL_BAR,
+		ROLE_TOOL_TIP,
+		ROLE_TREE,
+		ROLE_TREE_TABLE,
+		ROLE_UNKNOWN
+	}
+
+        /*
+          RelationType specifies a relationship between objects outside of the normal
+          parent/child hierarchical relationship. It allows better semantic
+          identification of how objects are associated with one another.
+         */
+        enum <uint32> RelationType {
+		RELATION_NULL = 0,
+		RELATION_LABEL_FOR,
+		RELATION_LABELLED_BY,
+		RELATION_CONTROLLER_FOR,
+		RELATION_CONTROLLED_BY,
+		RELATION_MEMBER_OF,
+		RELATION_TOOLTIP_FOR,
+		RELATION_NODE_CHILD_OF,
+		RELATION_NODE_PARENT_OF,
+		RELATION_EXTENDED,
+		RELATION_FLOWS_TO,
+		RELATION_FLOWS_FROM,
+		RELATION_SUBWINDOW_OF,
+		RELATION_EMBEDS,
+		RELATION_EMBEDDED_BY,
+		RELATION_POPUP_FOR,
+		RELATION_PARENT_WINDOW_OF,
+		RELATION_DESCRIPTION_FOR,
+		RELATION_DESCRIBED_BY,
+		RELATION_LAST_DEFINED
+	}
+
+	/*
+	  Describes a one-to-many relationship between accessible objects.
+         */
+	struct Relation {
+		RelationType type;
+		Reference    objects [];	
+	}
+
+	enum uint32 StateType {
+		STATE_INVALID = 0,
+		STATE_ACTIVE,
+		STATE_ARMED,
+		STATE_BUSY,
+		STATE_CHECKED,
+		STATE_COLLAPSED,
+		STATE_DEFUNCT,
+		STATE_EDITABLE,
+		STATE_ENABLED,
+		STATE_EXPANDABLE,
+		STATE_EXPANDED,
+		STATE_FOCUSABLE,
+		STATE_FOCUSED,
+		STATE_HAS_TOOLTIP,
+		STATE_HORIZONTAL,
+		STATE_ICONIFIED,
+		STATE_MODAL,
+		STATE_MULTI_LINE,
+		STATE_MULTISELECTABLE,
+		STATE_OPAQUE,
+		STATE_PRESSED,
+		STATE_RESIZABLE,
+		STATE_SELECTABLE,
+		STATE_SELECTED,
+		STATE_SENSITIVE,
+		STATE_SHOWING,
+		STATE_SINGLE_LINE,
+		STATE_STALE,
+		STATE_TRANSIENT,
+		STATE_VERTICAL,
+		STATE_VISIBLE,
+		STATE_MANAGES_DESCENDANTS,
+		STATE_INDETERMINATE,
+		STATE_REQUIRED,
+		STATE_TRUNCATED,
+		STATE_ANIMATED,
+		STATE_INVALID_ENTRY,
+		STATE_SUPPORTS_AUTOCOMPLETION,
+		STATE_SELECTABLE_TEXT,
+		STATE_IS_DEFAULT,
+		STATE_VISITED,
+		STATE_LAST_DEFINED
+	} 
+
+        /* 
+	  A two integer array representing a bit-field of currently held states.
+	 */
+	typedef State uint32 [];
+
+	/* A short string representing the object's name. */
+	read property string Name;
+
+	/* A string describing the object in more detail. */
+	read property string Description;
+
+	/* The accessible object which is this objects containing parent */
+	read property Reference Parent;
+
+	/* The number of children contained by this object */
+	read property int32 ChildCount;
+
+        /* Get the accessible child of this object at the given index */
+	method GetChildAtIndex {
+		int32 index;
+	} reply {
+		Reference child;
+	}
+
+	/* Get the index of this accessible object within its containing objects child list. */ 
+	method GetIndexInParent reply {
+		int32 index;
+	}
+
+	/* Access this objects non-hierarchical relationships to other accessible objects */
+	method GetRelationSet reply {
+		RelationSet relations;
+	}
+
+	/* Get the Role indicating the type of UI role played by this object. */
+	method GetRole reply {
+		Role role;
+	}
+
+	/* Get a string indicating the type of UI role played by this object */	
+	method GetRoleName reply {
+		string role;
+	}
+
+	/* 
+          Get a string indicating the type of UI role played by this object,
+          transalted to the current locale.
+         */
+	method GetLocalizedRoleName {
+		string role;
+	}
+
+	/* Access the states currently held by this object. */
+	method GetState reply {
+		State state;
+	}
+
+	/*
+	  Get a properties applied to this object as a whole, as an
+          set name-value pairs. As such these attributes may be considered
+          weakly-typed properties or annotations, as distinct
+          from the strongly-typed interface instance data.
+	*/
+	method GetAttributes reply {
+		Attributes attributes;
+	}
+
+	/*
+	  Get the containing Application for this object.
+	 */
+	method GetApplication reply {
+		Reference application;
+	}
+}
+
diff --git a/idl/action.didl b/idl/action.didl
new file mode 100644
index 00000000..afc22e89
--- /dev/null
+++ b/idl/action.didl
@@ -0,0 +1,54 @@
+
+/*
+  An interface through which a user-actionable UI component can be manipulated.
+  
+  Typical actions include "click", "press", "release" or "open".
+*/
+interface org.freestandards.atspi.Action {
+	/*
+	  Represents a single action.
+	*/
+	struct Action {
+		/* String containing short description of action. */
+		string name;
+		/* The description of an action may provide information about the result. */
+		string description;
+		/* A string containing the key-binding or "" if none exists */
+		string key_binding;
+	}
+
+	property read int32 NActions;
+
+	/* Get the description for the specified action. */
+	method GetDescription {
+		int32 index;
+	} reply {
+		string description
+	}
+
+	/* Get the name of the specified action */
+	method GetName {
+		int32 index;
+	} reply {
+		string name;
+	}
+
+	/* Get the key-binding for the specified action. */
+	method GetKeyBinding {
+		int32 index;
+	} reply {
+		string key_binding;
+	}
+
+	/* Retrieves the actions associated with the object. */
+	method GetActions reply {
+		Action actions [];
+	}
+
+	/* Causes the object to perform the specified action. */
+	method GetActions {
+		int32 index;
+	} reply {
+		boolean success;
+	}	
+}
diff --git a/idl/application.didl b/idl/application.didl
new file mode 100644
index 00000000..19383f6b
--- /dev/null
+++ b/idl/application.didl
@@ -0,0 +1,20 @@
+
+/*
+  An interface identifying an object which is the root of the
+  hierarchy associated with a running application.
+*/
+interface org.freestandards.atspi.Application {
+
+	/* A string indicating the type of user interface toolkit used by the application. */
+	read property string ToolkitName;
+
+	/* A string indicating the version of the applications accessibility bridge. */
+	read property string Version;
+
+	/* Gets the locale in which the application is currently running. */
+	method GetLocale {
+		LocaleType locale_type;
+	} reply {
+		string locale;
+	}
+}
diff --git a/idl/cache.didl b/idl/cache.didl
new file mode 100644
index 00000000..8cb96939
--- /dev/null
+++ b/idl/cache.didl
@@ -0,0 +1,26 @@
+
+interface org.freestandards.atspi.Cache {
+	
+	struct CacheItem {
+		object      path;
+		Reference   parent;
+		Reference[] children;
+		string[]    interfaces;
+		string      name;
+		Role        role;
+		string      description;
+		StateSet    states;
+	}
+
+	method GetItems reply {
+		CacheItem[] items;
+	}
+
+	signal AddAccessible {
+		CacheItem item;
+	}
+
+	signal RemoveAccessible {
+		Reference item;
+	}
+}	
diff --git a/idl/collection.didl b/idl/collection.didl
new file mode 100644
index 00000000..f3eee6ef
--- /dev/null
+++ b/idl/collection.didl
@@ -0,0 +1,69 @@
+
+/* TODO - Need to define the 'MatchRule' struct. */
+
+namespace org.freestandards.atspi {
+	interface Collection {
+		enum <uint32> SortOrder {
+			SORT_ORDER_INVALID = 0,
+			SORT_ORDER_CANONICAL,
+			SORT_ORDER_FLOW,
+			SORT_ORDER_TAB,
+			SORT_ORDER_REVERSE_CANONICAL,
+			SORT_ORDER_REVERSE_FLOW,
+			SORT_ORDER_REVERSE_TAB,
+			SORT_ORDER_LAST_DEFINED
+		}
+
+		enum <uint32> MatchType {
+			MATCH_INVALID = 0,
+			MATCH_ALL,
+			MATCH_ANY,
+			MATCH_NONE,
+			MATCH_EMPTY,
+			MATCH_LAST_DEFINED
+		}
+
+		enum <uint32> TreeTraversalType {
+			TREE_RESTRICT_CHILDREN,
+			TREE_RESTRICT_SIBLING,
+			TREE_INORDER,
+			TREE_LAST_DEFINED
+		}
+
+		method GetMatches {
+			MatchRule rule;
+			SortOrder sort_by;
+			int32     count;
+			boolean   traverse;
+		} reply {
+			Reference matches [];
+		}
+
+		method GetMatchesTo {
+			object    current_object;
+			MatchRule rule;
+			SortOrder sort_by;
+			TreeTraversalType type;
+			boolean   recurse;
+			int32     count;
+			boolean   traverse;
+		} reply {
+			Reference matches [];
+		}
+
+		method GetMatchesFrom {
+			object    current_object;
+			MatchRule rule;
+			SortOrder sort_by;
+			TreeTraversalType type;
+			int32     count;
+			boolean   traverse;
+		} reply {
+			Reference matches [];	
+		}
+
+		method GetActiveDescendent reply {
+			Reference descendent;
+		}
+	}
+}
diff --git a/idl/component.didl b/idl/component.didl
new file mode 100644
index 00000000..aa40e78f
--- /dev/null
+++ b/idl/component.didl
@@ -0,0 +1,139 @@
+
+using org.freestandards.atspi.Accessible.Reference = Reference;
+
+/*
+  The Component interface is implemented by objects which occupy on-screen space, e.g. objects
+  which have onscreen visual representations. The methods in Component allow clients to identify
+  where the objects lie in the onscreen coordinate system, their relative size, stacking order, and
+  position.  It also provides a mechanism whereby keyboard focus may be transferred to specific
+  user interface elements programmatically.  This is a 2D API, coordinates of 3D objects are projected into the
+  2-dimensional screen view for purposes of this interface.
+*/
+interface org.freestandards.atspi.Component {
+
+	/* 
+           Used by Component, Image and Text interfaces to specify whether coordinates are
+           relative to the window or screen.
+        */
+	enum <uint32> CoordType {
+		COORD_TYPE_SCREEN = 0,
+		COORD_TYPE_WINDOW = 1
+	}
+
+	/*
+	  Used by Component and Text interfaces, a struct defining a bounding rectange.
+	  The coordinate system is determined by the context of the API call.
+	*/
+	struct BoundingBox {
+		int32 x;
+		int32 y;
+		int32 width;
+		int32 height;
+	}
+
+	/*
+	  Indicates the relative stacking order with respect to the onscreen visual representation.
+
+	  The order of layers, from bottom to top is:
+		LAYER_BACKGROUND
+		LAYER_WINDOW
+		LAYER_MDI
+		LAYER_CANVAS
+		LAYER_WIDGET
+		LAYER_POPUP
+		LAYER_OVERLAY
+	*/
+	enum <uint32> ComponentLayer {
+		LAYER_INVALID,
+		LAYER_BACKGROUND,
+		LAYER_CANVAS,
+		LAYER_WIDGET,
+		LAYER_MDI,
+		LAYER_POPUP,
+		LAYER_OVERLAY,
+		LAYER_WINDOW,
+		LAYER_LAST_DEFINED
+	}
+	
+	/*
+	  True if the specified point lies within the components bounding box.
+         */ 
+	method Contains {
+		int32 x;
+		int32 y;
+		CoordType coord_type;
+	} reply {
+		boolean within;
+	}
+
+	/*
+	  Return the accessible child whose bounding box contains the specified point.
+         */
+	method GetAccessibleAtPoint {
+		int32 x;
+		int32 y;
+		CoordType coord_type;
+	} reply {
+		Reference child;
+	}
+
+	/*
+	  Obtain the components bounding box, in pixels, relative to the specified coordinate system.
+	*/
+	method GetExtents {
+		CoordType cood_type;
+	} reply {
+		BoundingBox box;
+	}
+
+	/*
+	  Obtain the position of the current component in the specified coordinate system.
+	*/
+	method GetPosition {
+		CoordType coord_type;
+	} reply {
+		int32 x;
+		int32 y;
+	}
+
+	/*
+	  Obtain the size in the specified coordinate system.
+          Fully contains teh object's visual representation without accounting for viewport clipping.
+        */
+	method GetSize reply {
+		int32 width;
+		int32 height;
+	}
+
+	/*
+	  The component layer in which this object resides.
+        */
+	method GetLayer reply {
+		ComponentLayer layer;
+	}
+
+	/*
+          Obtain the relative stacking order (i.e 'Z' order) of an object.
+	  Larger values indicate that an object is on 'top' of the stack.
+	  Only relevenat for objects in LAYER_MDI or LAYER_WINDOW.
+	*/
+	method GetMDIZOrder reply {
+		int16 order;
+	}
+
+	/*
+	  Request that an object obtain keyboard focus.
+        */
+	method GrabFocus reply {
+		boolean success;
+	}
+
+	/*
+	  Obtain the alpha value of the component.
+	  Alpha values are used with Z-Order to determine whether an obeject obscures
+	  anothers visual representation.
+	*/
+	method GetAlpha reply {
+		double alpha;
+	}
+}
diff --git a/idl/controller.didl b/idl/controller.didl
new file mode 100644
index 00000000..53b5f71a
--- /dev/null
+++ b/idl/controller.didl
@@ -0,0 +1,95 @@
+
+interface org.freestandards.atspi.DeviceEventController {
+
+	enum <uint32> KeySynthType {
+		KEY_PRESS=0,
+		KEY_RELEASE,
+		KEY_PRESSRELEASE,
+		KEY_SYM,
+		KEY_STRING
+	}
+
+        /*
+	  Consumption of events and syncronous event delivery is a sore-thumb.
+
+	  The client should really have no say over what the DeviceEventController
+          does with regards to event delivery as such the 'syncronous' flag is redundant.
+
+	  The 'global' flag is now useless as XEVIE is no longer maintained. As such
+	  the DeviceEventController will not recieve any device events from applications
+	  not participating.
+
+	  The only possibly useful flag is 'preemptive'. However all keyboard events are
+	  sent as pre-emptive from gail so its debateable whether even this flag is really
+	  in-use.
+	 */
+	struct EventListenerMode {
+		/* Controller should block while delivering this event. */
+		boolean syncronous;
+		/* Clients are allowed to consume this event. */
+		boolean preemptive;
+		/* 
+		 Event notifications should be sent regardless of whether 
+                 focused application participates in AT-SPI accessibility.
+                 */
+		boolean global;
+	}
+
+	struct KeyDefinition {
+		int32  keycode;
+		int32  keysym;
+		string keystring;
+		int32  unused;
+	}
+
+	method RegisterKeystrokeListener {
+		object            listener;
+		KeyDefinition[]   keys;
+		uint32            mask;
+		EventType[]       type;		
+		EventListenerMode mode;
+	} reply {
+		boolean           success;
+	}
+
+	method DeregisterKeystrokeListener {
+		object            listener;
+		KeyDefinition[]   keys;	
+		uint32            mask;
+		EventType[]       type;		
+	}
+
+	method RegisterDeviceEventListener {
+		object      listener;
+		EventType[] type;
+	} reply {
+		boolean     success;
+	}
+
+	method DeregisterDeviceEventListener {
+		object      listener;
+		EventType[] type;
+	}
+
+	method NotifyListenersSync {
+		DeviceEvent event;
+	} reply {
+		boolean     consumed;
+	}
+
+	method NotifyListenersAsync {
+		DeviceEvent event;
+	}
+
+	method GenerateKeyboardEvent {
+		int32        keycode;
+		string       keystring;
+		KeySynthType type;
+	}
+
+	method GenerateMouseEvent {
+		int32  x;
+		int32  y;
+		string event_name;
+	}
+}
diff --git a/idl/device.didl b/idl/device.didl
new file mode 100644
index 00000000..78bdd126
--- /dev/null
+++ b/idl/device.didl
@@ -0,0 +1,33 @@
+
+namespace org.freestandards.atspi {
+
+	enum <uint32> EventType {
+		KEY_PRESSED_EVENT=0,
+		KEY_RELEASED_EVENT,
+		BUTTON_PRESSED_EVENT,
+		BUTTON_RELEASED_EVENT
+	}
+
+	enum <uint32> ModifierType {
+		MODIFIER_SHIFT=0,
+		MODIFIER_SHIFTLOCK,
+		MODIFIER_CONTROL,
+		MODIFIER_ALT,
+		MODIFIER_META,
+		MODIFIER_META2,
+		MODIFIER_META3,
+		MODIFIER_NUMLOCK
+	}
+
+	struct DeviceEvent {
+		EventType    type;
+		/* An identifier for the event, corresponds to XEvent serial number. */
+		int32        stream_id;
+		/* A numeric code identifying the hardware or button on which the event occured. */
+		int16        hw_code;	
+		ModifierType modifiers;
+		int32        timestamp;
+		string       event_string;
+		boolean      is_text;
+	}
+}
diff --git a/idl/document.didl b/idl/document.didl
new file mode 100644
index 00000000..ce2a4f09
--- /dev/null
+++ b/idl/document.didl
@@ -0,0 +1,25 @@
+
+/*
+  Indicates the start of a document.
+
+  Children are part of the document content.
+*/
+interface org.freestandards.atspi.Document {
+
+	/* Gets the locale associated with the documents content. */
+	method GetLocale reply {
+		string locale;
+	}
+
+	/* Gets the value of a single attribute. */
+	method GetAttributeValue {
+		string key;
+	} reply {
+		string value;
+	}
+
+	/* Gets all attributes for the document as a whole. These are constant for all elements within the document.*/
+	method GetAttributes reply {
+		Attributes attributes;
+	}
+}
diff --git a/idl/event.didl b/idl/event.didl
new file mode 100644
index 00000000..d4c75cc7
--- /dev/null
+++ b/idl/event.didl
@@ -0,0 +1,79 @@
+
+namespace org.freestandards.atspi.Event {
+
+	struct Event {
+		string    minor;
+		int32     detail1;
+		int32     detail2;
+		variant   val;
+		Reference application;
+	}
+
+	interface Object {
+		signal PropertyChange {Event event;}
+		signal BoundsChanged {Event event;}
+		signal LinkSelected {Event event;}
+		signal StateChanged {Event event;}
+		signal ChildrenChanged {Event event;}
+		signal VisibleDataChanged {Event event;}
+		signal SelectionChanged {Event event;}
+		signal ModelChanged {Event event;}
+		signal ActiveDescendantChanged {Event event;}
+		signal RowInserted {Event event;}
+		signal RowDeleted {Event event;}
+		signal RowReordered {Event event;}
+		signal ColumnInserted {Event event;}
+		signal ColumnDeleted {Event event;}
+		signal ColumnReordered {Event event;}
+		signal TextBoundsChanged {Event event;}
+		signal TextSelectionChanged {Event event;}
+		signal TextChanged {Event event;}
+		signal TextAttributesChanged {Event event;}
+		signal TextCaretMoved {Event event;}
+		signal AttributesChanged {Event event;}
+	}
+
+	interface Window {
+		signal PropertyChange {Event event;}
+		signal Minimize {Event event;}
+		signal Maximize {Event event;}
+		signal Restore {Event event;}
+		signal Close {Event event;}
+		signal Create {Event event;}
+		signal Reparent {Event event;}
+		signal DesktopCreate {Event event;}
+		signal DesktopDestroy {Event event;}
+		signal Destroy {Event event;}
+		signal Activate {Event event;}
+		signal Deactivate {Event event;}
+		signal Raise {Event event;}
+		signal Lower {Event event;}
+		signal Move {Event event;}
+		signal Resize {Event event;}
+		signal Shade {Event event;}
+		signal Ushade {Event event;}
+		signal Restyle {Event event;}
+	}
+
+	interface Mouse {
+		signal Abs {Event event;}
+		signal Rel {Event event;}
+		signal Button {Event event;}
+	}
+
+	interface Keyboard {
+		signal Modifiers {Event event;}
+	}
+
+	interface Document {
+		signal LoadComplete {Event event;}
+		signal Reload {Event event;}
+		signal LoadStopped {Event event;}
+		signal ContentChanged {Event event;}
+		signal AttributesChanged {Event event;}
+	}
+
+	interface Focus {
+		signal Focus {Event event;}
+	}
+}
diff --git a/idl/hypertext.didl b/idl/hypertext.didl
new file mode 100644
index 00000000..334dafdd
--- /dev/null
+++ b/idl/hypertext.didl
@@ -0,0 +1,82 @@
+
+namespace org.freestandards.atspi {
+	/*
+	  Instances of Hyperlink are returned by Hypertext object and
+	  are the means by which end users and clients interact with linked
+	  content.
+
+	  Hyperlink instances DO NOT neccessarily implement the Accessible interface.
+	 */
+	interface HyperLink {
+		/* The number of separate anchors associated with this Hyperlink. */
+		read property int32 NAnchors;
+
+		/* 
+		  The starting offset within the contianing Hypertext,
+		  with which this Hyperlink is associated.	
+		 */
+		read property int32 StartIndex;
+
+		/*
+		  The ending offset within the containing Hypertext with which
+		  this Hyperlink is associated.
+		 */
+		read property int32 EndIndex;
+
+		/*
+		  Gets the i'th object associated with a Hyperlink.
+		  Objects returned should implement the Action interface.
+		 */ 
+		method GetObject {
+			int32 index;
+		} reply {
+			Reference anchor;
+		}
+
+		/*
+		  Obtain a resource locator, URI, which can be used to access the content
+		  which this link points to.
+		 */
+		method GetUri {
+			int32 index;
+		} reply {
+			string uri;
+		}
+
+		/*
+		  Check the hyperlink to see if a connection to its backing content can be
+		  established or if its URI is valid.
+		 */
+		method IsValid reply {
+			boolean valid;
+		}
+	}
+
+	/*
+	  An interface used for objects which implement linking between multiple resource locations.
+	  A hypertext instance is associated with one or more hyperlinks which are associated with
+	  particular offests within the text.
+	 */
+	interface Hypertext {
+
+		method GetNLinks reply {
+			int32 n_links;
+		}
+
+		method GetLink {
+			int32 index;
+		} reply {
+			Reference hyperlink;
+		}
+
+		/*
+		  Get the hyperlink index, if any, associated with a particular text offset.
+		 */
+		method GetLinkIndex {
+			int32 offset;
+		} reply {
+			/* -1 if no hyperlink is associated. */
+			int32 index;
+		}	
+	}
+}
diff --git a/idl/image.didl b/idl/image.didl
new file mode 100644
index 00000000..9dee626b
--- /dev/null
+++ b/idl/image.didl
@@ -0,0 +1,33 @@
+
+/*
+  An interface implemented by objects which render image data or
+  pictoral information on to the screen.
+*/
+interface org.freestandards.atspi.Image {
+	/* A textual description of what is visually depicted on the screen. */
+	read property string ImageDescription;
+
+	/* A string corresponding to the local used by the image description. */
+	read property string ImageLocale;
+
+	/* Obtain a bounding box which entirely contains the image contents. */
+	method GetImageExtents {
+		CoordType coord_type;
+	} reply {
+		BoundingBox;
+	}
+
+	/* Get the coordinates of the image on the screen */
+	method GetImagePosition {
+		CoordType coord_type;
+	} reply {
+		int32 x;
+		int32 y;
+	}
+
+	/* Get the size of the current on-screen view of the image. */
+	method GetImageSize reply {
+		int32 width;
+		int32 height;
+	}
+}
diff --git a/idl/listener.didl b/idl/listener.didl
new file mode 100644
index 00000000..7e3f6a1f
--- /dev/null
+++ b/idl/listener.didl
@@ -0,0 +1,9 @@
+
+interface org.freestandards.atspi.DeviceEventListener {
+
+	method NotifyEvent {
+		DeviceEvent event;
+	} reply {
+		boolean success;
+	}
+}
diff --git a/idl/selection.didl b/idl/selection.didl
new file mode 100644
index 00000000..66fbef76
--- /dev/null
+++ b/idl/selection.didl
@@ -0,0 +1,54 @@
+
+/*
+  An interface which indicates that an object exposes a 'selection' model,
+  allowing the 'selection' of one or more of its children.
+*/
+interface org.freestandards.atspi.Selection {
+	/* The number of children that are currently selected. */
+	read property int32 NSelectedChildren;
+
+	/* Gets the ith SELECTED child. This is different to the index of all children. */
+	method GetSelectedChild {
+		int32 index;
+	} reply {
+		Reference child;
+	}
+
+	/* Select the child, add it to the list of selected children. */ 
+	method SelectChild {
+		int32 index;
+	} reply {
+		boolean success;
+	}
+
+	/* Deselect a child. The index refers to the index into the list of selected children. */
+	method DeselectSelectedChild {
+		int32 index;
+	} reply {
+		boolean success;
+	}
+
+	/* Determine whether a particular child is currently selected. */
+	method IsChildSelected {
+		int32 index;
+	} reply {
+		boolean selected;
+	}
+
+	/* Apptemt to select all of the containers children. */
+	method SelectAll reply {
+		boolean success;
+	}
+
+	/* Attempt to deselect all selected children. */
+	method ClearSelection reply {
+		boolean success;
+	}
+
+	/* Deselect a child. The index refers to the index into the list of all children. */
+	method DeselectChild {
+		int32 index;
+	} reply {
+		boolean success;
+	}
+}
diff --git a/idl/socket.didl b/idl/socket.didl
new file mode 100644
index 00000000..336ca6cf
--- /dev/null
+++ b/idl/socket.didl
@@ -0,0 +1,31 @@
+
+namespace org.freestandards.atspi {
+        /*
+	  Accessible objects with the socket interface are capable of embeding other
+          accessible heirarchies as one of their children. This allows
+          applications to embed themselves in the heirarchy of the desktop object.
+         */
+	interface Socket {
+		method Embed {
+			Reference plug;
+		} reply {
+			Reference socket;
+		}
+
+		method Unembed {
+			Reference plug;
+		}
+
+		/*
+		  The available signal indicates that a socket has been
+		  made available, it is for discovering new sockets.
+                  This is used for when the process containing the desktop
+                  object is re-started.
+
+		  D-Bus bus name must have been granted by the D-Bus bus.
+                  It is used to identify the new socket.
+                 */
+		signal Available {
+			Reference socket;
+		}
+}
diff --git a/idl/table.didl b/idl/table.didl
new file mode 100644
index 00000000..ae1b8f00
--- /dev/null
+++ b/idl/table.didl
@@ -0,0 +1,186 @@
+
+namespace org.freestandards.atspi {
+
+	/*
+	  An interface used by containers whose data is arranged in a tabular form.
+	  Objects within tables are always children of the table object.
+	 */
+	interface Table {
+		read property int32 NRows;
+
+		read property int32 NColumns;
+		
+		read property Reference caption;
+
+		read property Reference summary;
+
+		/* Number of rows where all cells are selected. */
+		read property int32 NSelectedRows;
+
+		/* Number of columns where all cells are selected. */
+		read property int32 NSelectedColumns;
+
+		method GetAccessibleAt {
+			int32 row;
+			int32 column;
+		} reply {
+			Reference cell;
+		}
+
+		/*
+		  Cells in a table are also children of the table in the standard heirarchy.
+		  This method gets the child index of the given cell.
+		 */
+		method GetIndexAt {
+			int32 row;
+			int32 column;
+		} reply {
+			int32 index;
+		}
+
+		/*
+		  Indicates which row the child specified by index is on.
+		 */
+		method GetRowAtIndex {
+			int32 index;
+		} reply {
+			int32 row;
+		}	
+
+		/*
+		  Indicates which column the child specified by index is on.
+		 */
+		method GetColumnAtIndex {
+			int32 index;
+		} reply {
+			int32 column;
+		}
+
+		/*
+		  Get a textual description of a row.
+		 */ 
+		method GetRowDescription {
+			int32 row;
+		} reply {
+			string description;
+		}
+
+		/*
+		  Get a textual description of a particular column.
+		 */
+		method GetColumnDescription {
+			int32 column;
+		} reply {
+			string description;
+		}
+
+		/*
+		  Get the number of rows spanned by the table cell at the specific row and column.
+		method GetRowExtentAt {
+			int32 row;
+			int32 column;
+		} reply {
+			int32 rowspan;
+		}
+
+		/*
+		  Get the number of columns spanned by the table cell at the specific row and column.
+		 */
+		method GetColumnExtentAt {
+			int32 row;
+			int32 column;
+		} reply {
+			int32 column_span;
+		}
+
+		/*
+		  Get the header object associated with a particular table row.
+		 */
+		method GetRowHeader {	
+			int32 row;
+		} reply {
+			Reference header;
+		}
+
+		/*
+		  Get the header object associated with a particular table column.
+		 */
+		method GetColumnHeader {
+			int32 column;
+		} reply {
+			Reference header;
+		}
+
+		/*
+		  Obtain the indicies of all rows which are currently selected.
+		 */
+		method GetSelectedRows reply {
+			int32 indicies [];
+		}
+
+		/*
+		  Obtain the indicies of all columns which are currently selected.
+		 */
+		method GetSelectedColumns reply {
+			int32 indicies [];
+		}
+
+		method IsRowSelected {
+			int32 row;
+		} reply {
+			boolean selected;
+		}
+
+		method IsColumnSelected {
+			int32 column;
+		} reply {
+			boolean selected;
+		}
+
+		method IsSelected {
+			int32 row;
+			int32 column;
+		} reply {
+			boolean selected;
+		}
+
+		method AddRowSelection {
+			int32 row;
+		} reply {
+			boolean success;
+		}
+
+		method AddColumnSelection {
+			int32 column;
+		} reply {
+			boolean success;
+		}
+
+		method RemoveRowSelection {
+			int32 row;
+		} reply {
+			boolean success;
+		}
+
+		method RemoveColumnSelection {
+			int32 column;
+		} reply {
+			boolean success;
+		}
+
+		/*
+		  Given a child index determine the row and column indicies and extents
+		  and whether the cell is currently selected.
+		 */
+		method GetRowColumnExtentsAtIndex {
+			int32 index;
+		} reply {
+			boolean valid;
+			int32 row;
+			int32 column;
+			int32 row_span;
+			int32 column_span;
+			boolean selected;
+		}
+	}
+}
diff --git a/idl/text.didl b/idl/text.didl
new file mode 100644
index 00000000..0796dcb9
--- /dev/null
+++ b/idl/text.didl
@@ -0,0 +1,314 @@
+
+namespace org.freestandards.atspi {
+	/* 
+	   The text interface should be implemented by objects which place textual information onscreen
+	   as character strings or glyphs. The text interface allows access to textual content including
+	   display attributes and semantic hints associated with runs of text, and to bounding boc information
+	   for glyphs and substrings. It also alows portions of text to be selected, if the objects StateSet
+	   includes STATE_SELECTABLE_TEXT.
+         */
+	interface Text {
+		/*
+		  Specified the boundary conditions determining a run of text
+		  as returned from:
+		  	GetTextAtOffset
+			GetTextAfterOffset
+			GetTextBeforeOffset
+		 */ 
+		enum <uint32> TextBoundaryType {
+			TEXT_BOUNDARY_CHAR,
+			TEXT_BOUNDARY_WORD_START,
+			TEXT_BOUNDARY_WORD_END,
+			TEXT_BOUNDARY_SENTENCE_START,
+			TEXT_BOUNDARY_SENTENCE_END,
+			TEXT_BOUNDARY_LINE_START,
+			TEXT_BOUNDARY_LINE_END
+		}			
+
+		enum <uint32> TextClipType {
+			TEXT_CLIP_NONE,
+			TEXT_CLIP_MIN,
+			TEXT_CLIP_MAX,
+			TEXT_CLIP_BOTH
+		}
+
+		/*
+		  A structure used to define a contiguous range of text, including
+		  its (unattributed) textual content.
+		 */
+		struct Range {
+			int32   start_offset;
+			int32   end_offset;
+			int32   content;
+			variant data;				
+		}
+		
+		/* The total number of character in the text object including whitespace. */
+		read property int32 CharacterCount;
+
+		/* The current offset of the text caret in the Text object. */
+		read property int32 CaretOffset;
+
+		/* Move the text caret to a given position. */
+		method SetCaretOffset {
+			int32 offset;		
+		} reply {
+			boolean success;
+		}	
+		
+		/* 
+		  Obtain the subset of text content that entirely precedes the given offset,
+		  delimited by character word, line or sentente boundaries.
+		 */
+		method GetTextBeforeOffset {
+			int32 offset;
+			TextBoundaryType type;
+		} reply {
+			string s;
+			int32  start_offset;
+			int32  end_offset;
+		}
+
+		/* 
+		  Obtain the subset of text content that includes the given offset,
+		  delimited by character word, line or sentente boundaries.
+		 */
+		method GetTextAtOffset {
+			int32 offset;
+			TextBoundaryType type;
+		} reply {
+			string s;
+			int32  start_offset;
+			int32  end_offset;
+		}
+
+		/* 
+		  Obtain the subset of text content that entirely follows the given offset,
+		  delimited by character word, line or sentente boundaries.
+		 */
+		method GetTextAfterOffset {
+			int32 offset;
+			TextBoundaryType type;
+		} reply {
+			string s;
+			int32  start_offset;
+			int32  end_offset;
+		}
+
+		method GetCharacterAtOffset {
+			int32 offset;
+		} reply {
+			/* UCS-4 representation of the character or 0 if offset out-of-range. */
+			int32 c;
+		}
+
+		/*
+		  Get the value of a named attribute at a given offset.
+		 */
+		method GetAttributeValue {
+			int32   offset;
+			string  attribute_key;
+		} reply {
+			string  attribute_value;
+			int32   start_offset;
+			int32   end_offset;
+			boolean defined;
+		}	
+
+		/* Deprecated in favor of GetAttributeRun. */
+		method GetAttributes {
+			int32 offset;
+		} reply {
+			Attributes attributes;
+			int32 start_offset;
+			int32 end_offset;
+		}
+
+		/* Deprecated in facor of GetDefaultAttributeSet. */
+		method GetDefaultAttributes reply {
+			Attributes attributes;
+		}
+
+		/*
+		  Obtain a bounding box of the character glyph at a particular character offset,
+		  in the given coordinate system.
+		 */
+		method GetCharacterExtents {
+			int32     offset;
+			CoordType coord;
+		} reply {
+			int32 x;
+			int32 y;
+			int32 width;
+			int32 height;
+		}
+
+		/*
+		  Get the offset of the character at a given on-screen coordinate. The coordinate
+		  system used is determined by the give coordinate type.
+		 */
+		method GetOffsetAtPoint {
+			int32 x;
+			int32 y;
+			CoordType coord;
+		} reply {
+			/* -1 if the point is outside the bounds of any glyph. */
+			int32 offset;
+		}	
+
+		/*
+		  Obtain the number of separate, contiguous selections in the current Text object. 
+		 */
+		method GetNSelections reply {
+			int32 n_selections;
+		}
+
+		method GetSelection {
+			int32 selection_index;
+		} reply {
+			int32 start_offset;
+			int32 end_offset;
+		}
+
+		method AddSelection {
+			int32 start_offset;
+			int32 end_offset;
+		} reply {
+			boolean success;
+		}
+
+		method RemoveSelection {
+			int32 selection_index;
+		} reply {
+			boolean success;
+		}
+
+		method SetSelection {
+			int32 selection_index;
+			int32 start_offset;
+			int32 end_offset;
+		} reply {
+			boolean success;
+		}	
+
+		/*
+		  Obtain the bounding box which entirely contains the given text range.
+		  Negative values may be obtained in the event that part of the text range is
+		  off-screen.
+		 */
+		method GetRangeExtents {
+			int32 start_offset;
+			int32 end_offset;
+			CoordType coord;
+		} reply {
+			int32 x;
+			int32 y;
+			int32 width;
+			int32 height;
+		}
+
+		/*
+		  Return the text content within a bounding box.
+
+		  Depending on the clip type glyphs which are clipped by the bounding box
+		  may, or may not be inclide in the ranges returned.
+		 */
+		method GetBoundedRanges {
+			int32 x;
+			int32 y;
+			int32 width;
+			int32 height;
+			CoordType coord;
+			ClipType  x_clip;
+			ClipType  y_clip;
+		} reply {
+			RangeType ranges [];
+		}
+
+		/*
+		  Gets the attributes of a particular text objects defined at a given offset.
+		  The attributes are invariant over the offsets returned.
+		 */
+		method GetAttributeRun {
+			int32   offset;
+			boolean include_defaults;
+		} reply {
+			Attributes attributes;
+			int32 start_offset;
+			int32 end_offset;
+		}
+		
+		/*
+		  Gets the default attributes that apply to the entire text.
+		 */
+		method GetAttributeSet reply {
+			Attributes attributes'
+		}
+	}
+
+	/*
+	  All objects supporting EditableText should also support the
+	  Text interface.
+	
+	  Provides methods for modifying textual content of components which support editing.
+	  EditableText also interacts with the system clipboard.
+	 */
+	interface EditableText {
+		/*
+		  Replace the text contents with a new string, discarding the old contents.
+		 */
+		method SetTextContents {
+			string new_contents;
+		} reply {
+			boolean success;
+		}
+
+		/*
+		  Insert new text contents into a given location.
+		 */
+		method InsertText {
+			int32  position;
+			string text;
+			int32  length;
+		} reply {
+			boolean success;
+		}
+
+		/*
+		  Copy a range of text in to the system clipboard.
+		 */
+		method CopyText {
+			int32 start_pos;
+			int32 end_pos;
+		}
+
+		/*
+		  Excise a range of text, copying it to the system clipboard.
+		 */
+		method CutText {
+			int32 start_pos;
+			int32 end_pos;
+		} reply {
+			boolean success;
+		} 
+
+		/* 
+		  Excise a range of text from the object without copying to the system clipboard.
+		 */
+		method DeleteText {
+			int32 start_pos;
+			int32 end_pos;
+		} reply {
+			boolean success;
+		}
+
+		/*
+		  Copy the contents of the system clip-board in to the text object.
+		 */
+		method PasteText {
+			int32 position;
+		} reply {
+			boolean success;
+		}	
+	}
+}
diff --git a/idl/types.didl b/idl/types.didl
new file mode 100644
index 00000000..b8c41293
--- /dev/null
+++ b/idl/types.didl
@@ -0,0 +1,25 @@
+/*
+  Type definitions needed by multiple interfaces.
+*/
+
+namespace org.freestandards.atspi {
+
+	/*
+	  A connection independent reference to a D-Bus object. 
+
+	  The D-Bus object that is referenced will support at-least
+	  the org.freestandards.atspi.Accessible interface.
+	 */
+	struct Reference {
+		/* The D-Bus connection name where the object resides. */
+		string name;
+		/* The D-Bus path of the object. */
+		object path;
+	}
+
+	/*
+	  Attributes are weakly typed properties of an object  consisting of string-string
+          key-value pairs.
+         */
+	typedef Attributes dict <string, string>;
+}
diff --git a/idl/value.didl b/idl/value.didl
new file mode 100644
index 00000000..476cb431
--- /dev/null
+++ b/idl/value.didl
@@ -0,0 +1,15 @@
+
+/* 
+  An interface supporting a one-dimensional scalar quantity
+  to be modified, or which reflects a scalar value.
+ */
+interface org.freestandards.atspi.Value {
+	
+	read property double MinimumValue;
+	
+	read property double MaximumValue;
+
+	read property double MinimumIncrement;
+
+	read property double currentValue;
+}