Commit 52968ad5 authored by Mike Gorse's avatar Mike Gorse

Remove idl directory

These files have never been used, are not actually written in a language
that can be automatically parsed, and have not been part of the tarball
for some time. Removing them to avoid confusion, since having them in the
repository makes it appear that they are used.
parent f39d1366
/*
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;
}
}
/*
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;
}
method GetLocalizedName {
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;
}
}
/*
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;
/* A string indicating the version of the AT-SPI specification
supported by the application */
read property string AtspiVersion;
/* Gets the locale in which the application is currently running. */
method GetLocale {
LocaleType locale_type;
} reply {
string locale;
}
}
interface org.freestandards.atspi.Cache {
struct CacheItem {
object path;
Reference parent;
int index_in_parent;
int child_count;
string[] interfaces;
string name;
Role role;
string description;
StateSet states;
}
method GetItems reply {
CacheItem[] items;
}
signal AddAccessible {
CacheItem item;
}
signal RemoveAccessible {
Reference item;
}
}
/* 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;
}
}
}
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
}
/*
Describes where the object should be placed on the window.
*/
enum uint32 ScrollType {
SCROLL_TOP_LEFT = 0,
SCROLL_BOTTOM_RIGHT,
SCROLL_TOP_EDGE,
SCROLL_BOTTOM_EDGE,
SCROLL_LEFT_EDGE,
SCROLL_RIGHT_EDGE,
SCROLL_ANYWHERE
}
/*
Specifies whether the coordinates are relative to the screen, to the
window, or to the parent object.
*/
enum uint32 CoordType {
COORD_TYPE_SCREEN = 0,
COORD_TYPE_WINDOW,
COORD_TYPE_PARENT
}
/*
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.
The returned values are meaningful only if the Component has both STATE_VISIBLE and STATE_SHOWING.
*/
method GetExtents {
CoordType cood_type;
} reply {
BoundingBox box;
}
/*
Obtain the position of the current component in the specified coordinate system.
The returned values are meaningful only if the Component has both STATE_VISIBLE and STATE_SHOWING.
*/
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.
The returned values are meaningful only if the Component has both STATE_VISIBLE and STATE_SHOWING.
*/
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;
}
/*
Scroll this object so it becomes visible on the screen.
*/
method ScrollTo {
ScrollType type;
}
/*
Scroll this object so it becomes visible on the screen at a given position.
*/
method ScrollToPoint {
CoordType type;
int32 x;
int32 y;
}
}
interface org.freestandards.atspi.DeviceEventController {
enum <uint32> KeySynthType {
KEY_PRESS=0,
KEY_RELEASE,
KEY_PRESSRELEASE,
KEY_SYM,
KEY_STRING,
KEY_LOCKMODIFIERS,
KEY_UNLOCKMODIFIERS
}
/*
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;
}
}
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;
}
}
/*
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;
}
}
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;}
}