Tue Apr 5 14:26:38 UTC 2011

2 files changed, 1720 insertions, 0 deletions

diff --git a/extra/python-pyspi/PKGBUILD b/extra/python-pyspi/PKGBUILD
new file mode 100644
index 000000000..ef5c18be6
--- /dev/null
+++ b/extra/python-pyspi/PKGBUILD
@@ -0,0 +1,27 @@
+# $Id: PKGBUILD 89911 2010-09-04 17:41:32Z remy $
+# Maintainer: Jan de Groot <jgc@archlinux.org>
+# Contributor: William Rea <sillywilly@gmail.com>
+pkgname=python-pyspi
+pkgver=0.6.1
+pkgrel=4
+pkgdesc="Python AT-SPI bindings"
+arch=('i686' 'x86_64')
+url="http://people.redhat.com/zcerza/dogtail"
+license=('LGPL')
+depends=('python2' 'at-spi>=1.7.12')
+makedepends=('pyrex')
+conflicts=('pyspi')
+provides=('pyspi')
+replaces=('pyspi')
+source=(http://dlc.sun.com/osol/jds/downloads/sources/pyspi-${pkgver}.tar.gz
+        pyspi-build.patch)
+md5sums=('def336bd566ea688a06ec03db7ccf1f4'
+         '721f74cbae653a258c00b83acf7dd1da')
+
+build() {
+  cd ${srcdir}/pyspi-${pkgver}
+  patch -Np1 -i ${srcdir}/pyspi-build.patch
+  # Pyrex tells us to use __cinit__ instead of __new__
+  sed -i 's/__new__/__cinit__/' pyspi.pyx
+  python2 setup.py install --root=${pkgdir}
+}
diff --git a/extra/python-pyspi/pyspi-build.patch b/extra/python-pyspi/pyspi-build.patch
new file mode 100644
index 000000000..3d12c5ed5
--- /dev/null
+++ b/extra/python-pyspi/pyspi-build.patch
@@ -0,0 +1,1693 @@
+diff -Naur pyspi-0.6.1-old/cspi.pxd pyspi-0.6.1/cspi.pxd
+--- pyspi-0.6.1-old/cspi.pxd	2006-08-04 06:27:10.000000000 +1000
++++ pyspi-0.6.1/cspi.pxd	2009-05-09 15:24:31.000000000 +1000
+@@ -14,9 +14,7 @@
+ 
+ 	ctypedef struct AccessibleTextRange
+ 	ctypedef struct AccessibleKeySet
+-	ctypedef enum SPIBoolean:
+-		FALSE = 0,
+-		TRUE
++	ctypedef unsigned int SPIBoolean
+ 
+ 	ctypedef struct AccessibleEvent:
+ 		char  *type
+diff -Naur pyspi-0.6.1-old/pyspi.pyx pyspi-0.6.1/pyspi.pyx
+--- pyspi-0.6.1-old/pyspi.pyx	2006-10-03 02:46:41.000000000 +1000
++++ pyspi-0.6.1/pyspi.pyx	2009-05-09 15:24:31.000000000 +1000
+@@ -25,9 +25,15 @@
+ cdef class Event (EventBase)
+ cdef class DeviceEvent
+ 
+-ctypedef enum bool:
++ctypedef unsigned int bool
++
++import __builtin__
++try:
++	False = __builtin__.False
++	True = __builtin__.True
++except AttributeError:
+ 	False = 0
+-	True
++	True = 1
+ 
+ # SPIExceptionCode values:
+ (SPI_EXCEPTION_UNSPECIFIED, SPI_EXCEPTION_DISCONNECT, SPI_EXCEPTION_NO_IMPL, SPI_EXCEPTION_IO, SPI_EXCEPTION_BAD_DATA)=range(5) 
+@@ -731,7 +737,7 @@
+ 	Wrapper around the low-level cspi.AccessibleComponent_ functions,
+ 	giving an OO-style API.
+ 	"""
+-	def getExtents (self, type=0):
++	def getExtents (self, key_type=0):
+ 		"""
+ 		Wraps cspi.AccessibleComponent_getExtents, returning an
+ 		(x,y,w,h) tuple.
+@@ -741,7 +747,7 @@
+ 		cspi.AccessibleComponent_getExtents (self.__item, &x, &y, &w, &h, type)
+ 		return (x, y, w, h)
+ 
+-	def getPosition (self, type = 0):
++	def getPosition (self, key_type = 0):
+ 		"""
+ 		Wraps cspi.AccessibleComponent_getPosition, returning an
+ 		(x,y) tuple.
+@@ -991,11 +997,11 @@
+ 		Wraps cspi.AccessibleHyperlink_getObject
+ 		"""
+ 		self.__checkSelf ()
+-		cdef Accessible object
+-		object = Accessible ()
+-		object.__setItem (cspi.AccessibleHyperlink_getObject (self.__item, i))
+-		object.__checkSelf ()
+-		return object
++		cdef Accessible obj
++		obj = Accessible ()
++		obj.__setItem (cspi.AccessibleHyperlink_getObject (self.__item, i))
++		obj.__checkSelf ()
++		return obj
+ 
+ 	def getURI (self, i):
+ 		"""
+@@ -1032,7 +1038,7 @@
+ 		cspi.AccessibleImage_getImageSize(self.__item, &w, &h);
+ 		return [w, h]
+ 
+-	def getImagePosition (self, type=0):
++	def getImagePosition (self, key_type=0):
+ 		"""
+ 		Wraps cspi.AccessibleImage_getImagePosition, returning a (x,y)
+ 		pair
+@@ -1042,7 +1048,7 @@
+ 		cspi.AccessibleImage_getImagePosition(self.__item, &x, &y, type)
+ 		return [x, y]
+ 
+-	def getImageExtents (self, type=0):
++	def getImageExtents (self, key_type=0):
+ 		"""
+ 		Wraps cspi.AccessibleImage_getImageExtents, returning a
+ 		(x,y,w,h) tuple
+@@ -1551,7 +1557,7 @@
+ 	cdef cspi.AccessibleDeviceListener *__item
+ 	cdef public object modMasks
+ 
+-	def __init__ (self, callback, eventMask = cspi.SPI_KEY_PRESSED | cspi.SPI_KEY_RELEASED):
++	def __init__ (self, callback, eventMask = <int> cspi.SPI_KEY_PRESSED | <int> cspi.SPI_KEY_RELEASED):
+ 		"""
+ 		Registers a python callback function to be called.
+ 
+diff -Naur pyspi-0.6.1-old/pyspi.pyx.orig pyspi-0.6.1/pyspi.pyx.orig
+--- pyspi-0.6.1-old/pyspi.pyx.orig	1970-01-01 10:00:00.000000000 +1000
++++ pyspi-0.6.1/pyspi.pyx.orig	2006-10-03 02:46:41.000000000 +1000
+@@ -0,0 +1,1592 @@
++# Authors:
++#          Zack Cerza <zcerza@redhat.com>
++#          Chris Lee <clee@redhat.com>
++#          Lawrence Lim <llim@redhat.com>
++#          David Malcolm <dmalcolm@redhat.com>
++
++cdef class Registry
++
++cdef class Base
++cdef class EventBase
++cdef class StateSet
++cdef class Accessible (Base)
++cdef class Desktop (Accessible)
++cdef class Application (Accessible)
++cdef class Component (Accessible)
++cdef class Action (Base)
++cdef class Text (Base)
++cdef class EditableText (Text)
++cdef class Hypertext (Text)
++cdef class Hyperlink (Base)
++cdef class Image (Base)
++cdef class Value (Base)
++cdef class Selection (Base)
++cdef class Table (Base)
++cdef class Event (EventBase)
++cdef class DeviceEvent
++
++ctypedef enum bool:
++	False = 0
++	True
++
++# SPIExceptionCode values:
++(SPI_EXCEPTION_UNSPECIFIED, SPI_EXCEPTION_DISCONNECT, SPI_EXCEPTION_NO_IMPL, SPI_EXCEPTION_IO, SPI_EXCEPTION_BAD_DATA)=range(5) 
++
++# SPIExceptionType values:
++(SPI_EXCEPTION_SOURCE_UNSPECIFIED, SPI_EXCEPTION_SOURCE_ACCESSIBLE, SPI_EXCEPTION_SOURCE_REGISTRY, SPI_EXCEPTION_SOURCE_DEVICE)=range(4)
++
++# Accessible roles
++(SPI_ROLE_INVALID, SPI_ROLE_ACCEL_LABEL, SPI_ROLE_ALERT, SPI_ROLE_ANIMATION, SPI_ROLE_ARROW, SPI_ROLE_CALENDAR, SPI_ROLE_CANVAS, SPI_ROLE_CHECK_BOX, SPI_ROLE_CHECK_MENU_ITEM, SPI_ROLE_COLOR_CHOOSER, SPI_ROLE_COLUMN_HEADER, SPI_ROLE_COMBO_BOX, SPI_ROLE_DATE_EDITOR, SPI_ROLE_DESKTOP_ICON, SPI_ROLE_DESKTOP_FRAME, SPI_ROLE_DIAL, SPI_ROLE_DIALOG, SPI_ROLE_DIRECTORY_PANE, SPI_ROLE_DRAWING_AREA, SPI_ROLE_FILE_CHOOSER, SPI_ROLE_FILLER, SPI_ROLE_FONT_CHOOSER, SPI_ROLE_FRAME, SPI_ROLE_GLASS_PANE, SPI_ROLE_HTML_CONTAINER, SPI_ROLE_ICON, SPI_ROLE_IMAGE, SPI_ROLE_INTERNAL_FRAME, SPI_ROLE_LABEL, SPI_ROLE_LAYERED_PANE, SPI_ROLE_LIST, SPI_ROLE_LIST_ITEM, SPI_ROLE_MENU, SPI_ROLE_MENU_BAR, SPI_ROLE_MENU_ITEM, SPI_ROLE_OPTION_PANE, SPI_ROLE_PAGE_TAB, SPI_ROLE_PAGE_TAB_LIST, SPI_ROLE_PANEL, SPI_ROLE_PASSWORD_TEXT, SPI_ROLE_POPUP_MENU, SPI_ROLE_PROGRESS_BAR, SPI_ROLE_PUSH_BUTTON, SPI_ROLE_RADIO_BUTTON, SPI_ROLE_RADIO_MENU_ITEM, SPI_ROLE_ROOT_PANE, SPI_ROLE_ROW_HEADER, SPI_ROLE_SCROLL_BAR, SPI_ROLE_SCROLL_PANE, SPI_ROLE_SEPARATOR, SPI_ROLE_SLIDER, SPI_ROLE_SPIN_BUTTON, SPI_ROLE_SPLIT_PANE, SPI_ROLE_STATUS_BAR, SPI_ROLE_TABLE, SPI_ROLE_TABLE_CELL, SPI_ROLE_TABLE_COLUMN_HEADER, SPI_ROLE_TABLE_ROW_HEADER, SPI_ROLE_TEAROFF_MENU_ITEM, SPI_ROLE_TERMINAL, SPI_ROLE_TEXT, SPI_ROLE_TOGGLE_BUTTON, SPI_ROLE_TOOL_BAR, SPI_ROLE_TOOL_TIP, SPI_ROLE_TREE, SPI_ROLE_TREE_TABLE, SPI_ROLE_UNKNOWN, SPI_ROLE_VIEWPORT, SPI_ROLE_WINDOW, SPI_ROLE_EXTENDED, SPI_ROLE_HEADER, SPI_ROLE_FOOTER, SPI_ROLE_PARAGRAPH, SPI_ROLE_RULER, SPI_ROLE_APPLICATION, SPI_ROLE_AUTOCOMPLETE, SPI_ROLE_EDITBAR, SPI_ROLE_EMBEDDED, SPI_ROLE_LAST_DEFINED)=range(79)
++
++# Accessible states
++(SPI_STATE_INVALID, SPI_STATE_ACTIVE, SPI_STATE_ARMED, SPI_STATE_BUSY, SPI_STATE_CHECKED, SPI_STATE_COLLAPSED, SPI_STATE_DEFUNCT, SPI_STATE_EDITABLE, SPI_STATE_ENABLED, SPI_STATE_EXPANDABLE, SPI_STATE_EXPANDED, SPI_STATE_FOCUSABLE, SPI_STATE_FOCUSED, SPI_STATE_HORIZONTAL, SPI_STATE_ICONIFIED, SPI_STATE_MODAL, SPI_STATE_MULTI_LINE, SPI_STATE_MULTISELECTABLE, SPI_STATE_OPAQUE, SPI_STATE_PRESSED, SPI_STATE_RESIZABLE, SPI_STATE_SELECTABLE, SPI_STATE_SELECTED, SPI_STATE_SENSITIVE, SPI_STATE_SHOWING, SPI_STATE_SINGLE_LINE, SPI_STATE_STALE, SPI_STATE_TRANSIENT, SPI_STATE_VERTICAL, SPI_STATE_VISIBLE, SPI_STATE_MANAGES_DESCENDANTS, SPI_STATE_INDETERMINATE) = range(32);
++
++# Accessible relation types
++(SPI_RELATION_NULL, SPI_RELATION_LABEL_FOR, SPI_RELATION_LABELED_BY, SPI_RELATION_CONTROLLER_FOR, SPI_RELATION_CONTROLLED_BY, SPI_RELATION_MEMBER_OF, SPI_RELATION_NODE_CHILD_OF, SPI_RELATION_EXTENDED, SPI_RELATION_FLOWS_TO, SPI_RELATION_FLOWS_FROM, SPI_RELATION_SUBWINDOW_OF, SPI_RELATION_EMBEDS, SPI_RELATION_EMBEDDED_BY, SPI_RELATION_POPUP_FOR, SPI_RELATION_LAST_DEFINED) = range (15);
++
++# AccessibleComponent layers
++(SPI_LAYER_INVALID, SPI_LAYER_BACKGROUND, SPI_LAYER_CANVAS, SPI_LAYER_WIDGET, SPI_LAYER_MDI, SPI_LAYER_POPUP, SPI_LAYER_OVERLAY, SPI_LAYER_WINDOW, SPI_LAYER_LAST_DEFINED) = range(9)
++
++#AccessibleKeySynthType
++(SPI_KEY_PRESS, SPI_KEY_RELEASE, SPI_KEY_PRESSRELEASE, SPI_KEY_SYM, SPI_KEY_STRING) = range(5)
++
++# AccessibleKeyListenerSyncType
++(SPI_KEYLISTENER_NOSYNC, SPI_KEYLISTENER_SYNCHRONOUS, SPI_KEYLISTENER_CANCONSUME, SPI_KEYLISTENER_ALL_WINDOWS) = range(4)
++
++# AccessibleDeviceEventType
++SPI_KEY_PRESSED  = 1<<0
++SPI_KEY_RELEASED = 1<<1
++SPI_BUTTON_PRESSED = 1<<2
++SPI_BUTTON_RELEASED = 1<<3
++
++cdef cspi.AccessibleKeySet *SPI_KEYSET_ALL_KEYS
++SPI_KEYSET_ALL_KEYS = NULL
++
++Accessibility_MODIFIER_SHIFT = 1 << 0
++Accessibility_MODIFIER_SHIFTLOCK = 1 << 1
++Accessibility_MODIFIER_CONTROL = 1 << 2
++Accessibility_MODIFIER_ALT = 1 << 3
++Accessibility_MODIFIER_META = 1 << 4
++Accessibility_MODIFIER_META2 = 1 << 5
++Accessibility_MODIFIER_META3 = 1 << 6
++Accessibility_MODIFIER_NUMLOCK = 1 << 7
++
++
++cdef object string(char * string):
++	cdef object pyString
++	pyString = string
++	cspi.SPI_freeString(string)
++	return pyString
++
++import os
++class X11Exception(Exception):
++	def __init__(self, display = os.environ.get('DISPLAY', None)):
++		self.display = display
++	def __str__(self):
++		msg = "Cannot open display"
++		if self.display: return msg + ': ' + self.display
++		else: return msg
++
++class AtspiException(Exception):
++	"""
++	Exceptions raised when calls to the AT-SPI C bindings return FALSE to
++	indicate failure.
++	"""
++	def __init__(self, message):
++		self.message = message
++
++	def __str__(self):
++		return "AtspiException: %s"%self.message
++
++class SpiException(Exception):
++	"""
++	Exceptions to be raised in response to an installed
++	SPIExceptionHandler, corresponding to a SPIException.  These appear to
++	be short-lived structs, so we gather all applicable data immediately
++	"""
++	def __init__(self, is_fatal, sourceType, exceptionCode, description):
++		# print "got to __init__"
++		self.fatal = is_fatal
++		self.sourceType = sourceType
++		self.exceptionCode = exceptionCode
++		self.description = description
++		
++		# print "leaving __init__"
++		# print self.fatal
++		# print self.sourceType
++		# print self.exceptionCode
++		# print self.description
++
++	def __str__(self):
++		if self.fatal:
++			fatalStr = "Fatal"
++		else:
++			fatalStr = "Non-fatal"
++		result = '%s SPIException: type:%s source:%s "%s"'%(fatalStr, self.sourceType, self.exceptionCode, self.description)
++		return result
++
++cdef make_exception(cspi.SPIException *err, cspi.SPIBoolean is_fatal):
++	# Don't attempt to use SPIAccessibleException_getSource; this is error
++	# handling code, we don't want to introduce further complications
++	return SpiException(is_fatal,
++			    cspi.SPIException_getSourceType (err),
++			    cspi.SPIException_getExceptionCode (err),
++			    cspi.SPIException_getDescription (err))
++
++	
++def event_main():
++	cspi.SPI_event_main()
++
++def event_quit():
++	cspi.SPI_event_quit()
++
++cdef cspi.SPIBoolean exception_handler (cspi.SPIException *err, cspi.SPIBoolean is_fatal) except *:
++	# print "got exception!!!"
++	e = make_exception(err, is_fatal)
++	raise e
++
++# at-spi-<version>/cpsi.h contains:
++#   typedef SPIBoolean (*SPIExceptionHandler) (SPIException *err, SPIBoolean is_fatal);
++# and
++#   SPIBoolean SPI_exceptionHandlerPush (SPIExceptionHandler *handler);
++# There's thus an extra unnecessary level of indirection.
++# We have to jump through the following hoops to get pyrex to deal with this:
++cdef cspi.SPIExceptionHandler exception_handler_as_type
++cdef cspi.SPIExceptionHandler* exception_handler_ptr
++exception_handler_as_type = exception_handler
++exception_handler_ptr = &exception_handler_as_type
++
++global_exception = None
++
++cdef class Registry:
++	def __init__ (self):
++		cdef Xlib.Display *display
++		display = Xlib.XOpenDisplay(NULL)
++		if display == NULL:
++			raise X11Exception
++		else:
++			Xlib.XCloseDisplay(display)
++
++		result = cspi.SPI_init ()
++		#if result!=0:
++		#	raise AtspiException("SPI_init: exit code %s" % str(result))
++
++		result = cspi.SPI_exceptionHandlerPush (exception_handler_ptr)
++		if not result:
++			raise AtspiException("Unable to install SPI exception handler")
++
++	def __dealloc (self):
++		result = cspi.SPI_exit ()
++		if result!=0:
++			raise AtspiException("SPI_init: exit code %s" % str(result))
++
++	def getDesktopCount (self):
++		return cspi.SPI_getDesktopCount()
++
++	def getDesktop (self, index = 0):
++		cdef Desktop desktop
++		desktop = Desktop ()
++		if not desktop.__setItem (cspi.SPI_getDesktop (index)):
++			return False
++		return desktop
++
++	def getDesktopList (self):
++		# Using the bonobo.activation bindings, getDesktopList() returns a 
++		# Python list of Desktop objects. The C bindings seem to do it differently,
++		# and Pyrex doesn't like that method. So we're re-implementing the function
++		# using getDesktopCount() and getDesktop() to work around that.
++		# Yay for Zack!
++		#
++		#	-Zack
++		cdef Desktop desktop
++		desktops = []
++		desktop = Desktop ()
++		for i in xrange (cspi.SPI_getDesktopCount ()):
++			desktop.__setItem (cspi.SPI_getDesktop (i))
++			desktops = desktops + [desktop]
++		return desktops
++
++registry = Registry()
++
++cdef class Base:
++	"""
++	Wrapper around a cspi.Accessible
++	"""
++	
++	cdef cspi.Accessible *__item
++	
++	def __new__ (self):
++		self.__item = NULL
++	
++	def __dealloc__ (self):
++		if self.__item != NULL:
++			cspi.Accessible_unref (self.__item)
++
++	cdef bool __setItem (self, cspi.Accessible *obj):
++		if self.__item != NULL:
++			cspi.Accessible_unref (self.__item)
++		if obj != NULL:
++			self.__item = obj
++			cspi.Accessible_ref (self.__item)
++			return True
++		else:
++			return False
++	
++	def __checkSelf (self):
++		assert self.__item != NULL
++
++# WHY OH WHY won't this work? :(
++# I need to be able to find out of two Accessible classes contain
++# the same cspi.Accessible objects.
++#
++#	def isSameAs (self, base):
++#		cdef bool foo
++#		foo = self.__item == base.__item
++#		return foo
++
++cdef class EventBase:
++	"""
++	Wrapper around a cspi.AccessibleEvent
++	"""
++	cdef cspi.AccessibleEvent *__item
++
++	def __new__ (self):
++		self.__item = NULL
++
++	def __dealloc__ (self):
++		if self.__item != NULL:
++			cspi.AccessibleEvent_unref (self.__item)
++
++	cdef bool __setItem (self, cspi.AccessibleEvent *obj):
++		if self.__item != NULL: 
++			cspi.AccessibleEvent_unref (self.__item)
++		if obj != NULL:
++			self.__item = obj
++			cspi.AccessibleEvent_ref (self.__item)
++			return True
++		else:
++			return False
++
++	def __checkSelf (self):
++		if self.__item == NULL:
++			raise AttributeError, "__item must not be NULL"
++
++	def __getattr__ (self, attrName):
++		cdef cspi.Accessible* acc
++		cdef Accessible result
++		if attrName == "source":
++			acc = self.__item.source
++			if acc!=NULL:
++				result = Accessible ()
++				result.__setItem (acc)
++				return result
++		elif attrName == "detail1":
++			detail1 = self.__item.detail1
++			return detail1
++		elif attrName == "detail2":
++			detail1 = self.__item.detail2
++			return detail1
++		elif attrName == "type":
++			return self.__item.type
++
++cdef class StateSet:
++	"""
++	Wrapper around a cspi.AccessibleStateSet
++	"""
++	cdef cspi.AccessibleStateSet *__item
++
++	def __new__ (self):
++		self.__item = NULL
++
++	def __dealloc__ (self):
++		if self.__item != NULL:
++			cspi.AccessibleStateSet_unref (self.__item)
++
++	def __checkSelf (self):
++		if self.__item == NULL:
++			raise AttributeError, "__item must not be NULL"
++
++	cdef bool __setItem (self, cspi.AccessibleStateSet *obj):
++		if self.__item != NULL:
++			cspi.AccessibleStateSet_unref (self.__item)
++		if obj != NULL:
++			self.__item = obj
++			cspi.AccessibleStateSet_ref (self.__item)
++			return True
++		else:
++			return False
++
++	cdef bool __contains (self, cspi.AccessibleState s):
++		self.__checkSelf ()
++		return cspi.AccessibleStateSet_contains (self.__item, s)
++
++	def contains (self, state):
++		self.__checkSelf ()
++		return self.__contains(state)
++
++	cdef void __add (self, cspi.AccessibleState s):
++		self.__checkSelf ()
++		cspi.AccessibleStateSet_add(self.__item, s)
++
++	def add (self, state):
++		self.__checkSelf ()
++		self.__add (state)
++
++	cdef void __remove (self, cspi.AccessibleState s):
++		self.__checkSelf ()
++		cspi.AccessibleStateSet_remove (self.__item, s)
++
++	def remove (self, state):
++		self.__checkSelf ()
++		self.__remove (state)
++		
++	def __str__ (self):
++		self.__checkSelf ()
++		return str(self.states)
++
++	def __getattr__(self, name):
++		if name == "states":
++			result = []
++			for state in range(SPI_STATE_INVALID, SPI_STATE_INDETERMINATE):
++				if self.contains(state):
++					result.append(state)
++			return result
++		else:
++			raise AttributeError, name
++
++cdef class Relation:
++	"""
++	Wrapper around a cspi.AccessibleRelation
++	"""
++	cdef cspi.AccessibleRelation *__item
++
++	def __new__ (self):
++		self.__item = NULL
++
++	def __dealloc__ (self):
++		if self.__item != NULL:
++			cspi.AccessibleRelation_unref (self.__item)
++
++	def __checkSelf (self):
++		if self.__item == NULL:
++			raise AttributeError, "__item must not be NULL"
++
++	def __str__ (self):
++		self.__checkSelf ()
++		return "relation %s -> %s"%(self.getRelationType (), self.getTargets())
++
++	def __repr__ (self):
++		self.__checkSelf ()
++		return "relation %s -> %s"%(self.getRelationType (), self.getTargets())
++
++	cdef bool __setItem (self, cspi.AccessibleRelation *obj):
++		if self.__item != NULL:
++			cspi.AccessibleRelation_unref (self.__item)
++		if obj != NULL:
++			self.__item = obj
++			cspi.AccessibleRelation_ref (self.__item)
++			return True
++		else:
++			return False
++
++	def getNTargets (self):
++		"""
++		Wrapper around cspi.AccessibleRelation_getNTargets
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleRelation_getNTargets (self.__item)
++
++	def getTarget (self, i):
++		"""
++		Wrapper around cspi.AccessibleRelation_getTarget
++		"""
++		self.__checkSelf ()
++		cdef Accessible target
++		target = Accessible ()
++		target.__setItem (cspi.AccessibleRelation_getTarget (self.__item, i))
++		target.__checkSelf ()
++		return target
++
++	def getTargets (self):
++		"""
++		Gets the targets of this AccessibleRelation as a list of atspi.Accessible
++		"""
++		self.__checkSelf ()
++		result = []
++		count = self.getNTargets()
++		for i in range(count):
++			result.append(self.getTarget(i))
++		return result
++
++	def getRelationType (self):
++		"""
++		Wrapper around cspi.AccessibleRelation_getRelationType
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleRelation_getRelationType (self.__item)
++
++cdef class Accessible (Base):
++	"""
++	Wrapper around cspi.Accessible
++	"""
++	def __getattr__ (self, name):
++		if name == "name":
++			return self.getName ()
++		elif name == "role":
++			return self.getRole ()
++		elif name == "roleName":
++			return self.getRoleName ()
++		elif name == "description":
++			return self.getDescription ()
++		elif name == "parent":
++			return self.getParent ()
++		elif name == "childCount":
++			return self.getChildCount ()
++		elif name == "indexInParent":
++			return self.getIndexInParent ()
++		elif name == "stateSet":
++			return self.getStateSet ()
++		else:
++			raise AttributeError, name
++
++	def getName (self):
++		"""
++		Wrapper around cspi.Accessible_getName
++		"""
++		self.__checkSelf()
++		return string(cspi.Accessible_getName(self.__item))
++
++	def getDescription (self):
++		"""
++		Wrapper around cspi.Accessible_getDescription
++		"""
++		self.__checkSelf()
++		return string(cspi.Accessible_getDescription(self.__item))
++
++	def getParent (self):
++		"""
++		Wrapper around cspi.Accessible_getParent, returning an
++		atspi.Accessible or None
++		"""
++		self.__checkSelf()
++		cdef Accessible parent
++		cdef cspi.Accessible* spiParent
++		
++		spiParent = cspi.Accessible_getParent (self.__item)
++		if spiParent!=NULL:
++			parent = Accessible ()
++			parent.__setItem (spiParent)
++			parent.__checkSelf ()
++			return parent
++		else:
++			return None
++
++	def getChildAtIndex (self, index):
++		"""
++		Wrapper around cspi.Accessible_getChildAtIndex, returning an
++		atspi.Accessible, atspi.Application, or None
++		"""
++		self.__checkSelf()
++		cdef int i
++		i = index
++		
++		# This hairiness is due to the fact that Pyrex doesn't allow cdefs 
++		# inside if blocks.
++		
++		cdef cspi.Accessible* spiChild
++		spiChild = cspi.Accessible_getChildAtIndex (self.__item, i)
++		# Workaround for GNOME bug #321273
++		# http://bugzilla.gnome.org/show_bug.cgi?id=321273
++		if spiChild == NULL: return None
++		
++		cdef object child
++		cdef Application app
++		cdef Accessible acc
++		cdef Text text
++		
++		if cspi.Accessible_isApplication (spiChild):
++			app = Application ()
++			app.__setItem (spiChild)
++			child = app
++		else:
++			acc = Accessible ()
++			acc.__setItem (spiChild)
++			child = acc
++
++		return child
++
++	def getIndexInParent (self):
++		"""
++		Wrapper around cspi.Accessible_getIndexInParent
++		"""
++		self.__checkSelf()
++		return cspi.Accessible_getIndexInParent (self.__item)
++
++	def getRole (self):
++		"""
++		Wrapper around cspi.Accessible_getRole
++		"""
++		self.__checkSelf()
++		return cspi.Accessible_getRole (self.__item)
++
++	def getRoleName (self):
++		"""
++		Wrapper around cspi.Accessible_getRoleName
++		"""
++		self.__checkSelf()
++		return string(cspi.Accessible_getRoleName (self.__item))
++
++	def getChildCount (self):
++		"""
++		Wrapper around cspi.Accessible_getChildCount
++		"""
++		self.__checkSelf()
++		return cspi.Accessible_getChildCount (self.__item)
++
++	def getStateSet (self):
++		"""
++		Wrapper around cspi.Accessible_getStateSet, returning an
++		atspi.StateSet
++		"""
++		self.__checkSelf()
++		cdef StateSet set
++		set = StateSet()
++		set.__setItem (cspi.Accessible_getStateSet (self.__item))
++		return set
++
++	def getInterface (self, interface):
++		"""
++		This is NOT part of cspi, it is just for compatibility with
++		the bonobo bindings and will probably go away soon.
++		"""
++		self.__checkSelf()
++		return getattr(self, "get%s" % interface) ()
++
++	def getAction (self):
++		"""
++		Wrapper around cspi.Accessible_getAction, returning
++		an atspi.Action or None
++		"""
++		self.__checkSelf()
++		cdef Action action
++		action = Action ()
++		action.__setItem (cspi.Accessible_getAction (self.__item))
++		if action.__item != NULL:
++			return action
++
++	def getText (self):
++		"""
++		Wrapper around cspi.Accessible_getText, returning an atspi.Text
++		or None
++		"""
++		self.__checkSelf ()
++		cdef Text text
++		text = Text ()
++		text.__setItem (cspi.Accessible_getText (self.__item))
++		if text.__item != NULL:
++			return text
++			
++	def getEditableText (self):
++		"""
++		Wrapper around cspi.Accessible_getText, returning an
++		atspi.EditableText or None
++		"""
++		self.__checkSelf ()
++		cdef EditableText etext
++		etext = EditableText ()
++		etext.__setItem (cspi.Accessible_getEditableText (self.__item))
++		if etext.__item != NULL:
++			return etext
++
++	def getHypertext (self):
++		"""
++		Wrapper around cspi.Accessible_getHypertext, returning an
++		atspi.Hypertext or None
++		"""
++		self.__checkSelf ()
++		cdef Hypertext hypertext
++		hypertext = Hypertext ()
++		hypertext.__setItem (cspi.Accessible_getHypertext (self.__item))
++		if hypertext.__item != NULL:
++			return hypertext
++
++	def getImage (self):
++		"""
++		Wrapper around cspi.Accessible_getImage, returning an
++		atspi.Image or None
++		"""
++		self.__checkSelf ()
++		cdef Image image
++		image = Image ()
++		image.__setItem (cspi.Accessible_getImage (self.__item))
++		if image.__item != NULL:
++			return image
++
++	def getValue (self):
++		"""
++		Wrapper around cspi.Accessible_getValue, returning an
++		atspi.Value or None
++		"""
++		self.__checkSelf ()
++		cdef Value value
++		value = Value ()
++		value.__setItem (cspi.Accessible_getValue (self.__item))
++		if value.__item != NULL:
++			return value
++
++	def getSelection (self):
++		"""
++		Wrapper around cspi.Accessible_getSelection, returning an
++		atspi.Selection or None
++		"""
++		self.__checkSelf ()
++		cdef Selection selection
++		selection = Selection ()
++		selection.__setItem (cspi.Accessible_getSelection (self.__item))
++		if selection.__item != NULL:
++			return selection 
++
++	def getComponent (self):
++		"""
++		Wrapper around cspi.Accessible_getComponent, returning an
++		atspi.Component or None
++		"""
++		self.__checkSelf ()
++		cdef Component component
++		component = Component ()
++		component.__setItem (cspi.Accessible_getComponent (self.__item))
++		if component.__item != NULL:
++			return component
++
++	def getRelationSet (self):
++		"""
++		Wraps Accessible_getRelationSet, returning a list
++		of atspi.Relation
++		"""
++		# looking at at-poke, result from C API appears to be a NULL-terminated list of pointers, and that we should free the buffer
++		self.__checkSelf ()
++		cdef Relation relation
++
++		relations = []
++		cdef cspi.AccessibleRelation **relationSet
++		relationSet = cspi.Accessible_getRelationSet (self.__item)
++
++		i=0
++		while relationSet[i]:
++			relation = Relation ()
++			relation.__setItem (relationSet[i])
++			relations.append(relation)
++			i=i+1
++		cspi.free (relationSet)
++
++		return relations
++
++
++cdef class Desktop (Accessible):
++	pass
++
++
++cdef class Application (Accessible):
++	"""
++	Wrapper around the low-level cspi.AccessibleApplication_ functions,
++	giving an OO-style API.
++	"""
++	def getToolkit (self):
++		"""
++		Wraps AccessibleApplication_getToolkitName, returning a string
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleApplication_getToolkitName (self.__item)
++
++	def getVersion (self):
++		"""
++		Wraps AccessibleApplication_getVersion, returning a string
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleApplication_getVersion(self.__item)
++
++	def getID (self):
++		"""
++		Wraps AccessibleApplication_getID, returning a string
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleApplication_getID (self.__item)
++
++	def pause (self):
++		"""
++		Wraps AccessibleApplication_pause
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleApplication_pause (self.__item)
++
++	def resume (self):
++		"""
++		Wraps AccessibleApplication_resume
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleApplication_resume (self.__item)
++
++cdef class Component (Accessible):
++	"""
++	Wrapper around the low-level cspi.AccessibleComponent_ functions,
++	giving an OO-style API.
++	"""
++	def getExtents (self, type=0):
++		"""
++		Wraps cspi.AccessibleComponent_getExtents, returning an
++		(x,y,w,h) tuple.
++		"""
++		self.__checkSelf ()
++		cdef long x, y, w, h
++		cspi.AccessibleComponent_getExtents (self.__item, &x, &y, &w, &h, type)
++		return (x, y, w, h)
++
++	def getPosition (self, type = 0):
++		"""
++		Wraps cspi.AccessibleComponent_getPosition, returning an
++		(x,y) tuple.
++		"""
++		self.__checkSelf ()
++		cdef long x, y
++		cspi.AccessibleComponent_getPosition (self.__item, &x, &y, type)
++		return (x, y)
++
++	def getSize (self):
++		"""
++		Wraps cspi.AccessibleComponent_getSize, returning a
++		(w,h) tuple.
++		"""
++		self.__checkSelf ()
++		cdef long w, h
++		cspi.AccessibleComponent_getSize (self.__item, &w, &h)
++		return (w, h)
++
++	def getLayer (self):
++		"""
++		Wraps cspi.AccessibleComponent_getLayer, returning an 
++		AccessibleComponentLayer.
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleComponent_getLayer (self.__item)
++
++	def grabFocus (self):
++		"""
++		Wraps cspi.AccessibleComponent_grabFocus, raising AtspiException
++		if it fails
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleComponent_grabFocus (self.__item):
++			raise AtspiException("AccessibleComponent_grabFocus")
++	
++	def getMDIZOrder (self):
++		"""
++		Wraps cspi.AccessibleComponent_getMDIZOrder, returning an integer.
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleComponent_getMDIZOrder(self.__item)
++
++cdef class Action (Base):
++	"""
++	Wrapper around the low-level cspi.AccessibleAction_ functions,
++	giving an OO-style API.
++	"""
++	def __getattr__ (self, name):
++		if name == "nActions":
++			return self.getNActions ()
++		else:
++			raise AttributeError, name
++
++	def getNActions (self):
++		"""
++		Wraps cspi.AccessibleAction_getNActions
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleAction_getNActions (self.__item)
++
++	def doAction (self, index):
++		"""
++		Wraps cspi.AccessibleAction_doAction
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleAction_doAction (self.__item, index)
++
++	def getKeyBinding (self, index):
++		"""
++		Wraps cspi.AccessibleAction_getKeyBinding
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleAction_getKeyBinding (self.__item, index)
++
++	def getName (self, index):
++		"""
++		Wraps cspi.AccessibleAction_getName
++		"""
++		self.__checkSelf ()
++		return string(cspi.AccessibleAction_getName (self.__item, index))
++
++	def getDescription (self, index):
++		"""
++		Wraps cspi.AccessibleAction_getDescription
++		"""
++		self.__checkSelf ()
++		return string(cspi.AccessibleAction_getDescription (self.__item, index))
++
++
++cdef class Text (Base):
++	"""
++	Wrapper around the low-level cspi.AccessibleText_ functions,
++	giving an OO-style API.
++	"""
++	def addSelection (self, startOffset, endOffset):
++		"""
++		Wraps cspi.AccessibleText_addSelection
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleText_addSelection (self.__item, startOffset, endOffset):
++			raise AtspiException("AccessibleText_addSelection")
++			
++
++	#def getAttributes (self, offset, startOffset, endOffset):
++	#	self.__checkSelf ()
++	#	return cspi.AccessibleText_getAttributes (self.__item, offset, startOffset, endOffset)
++	def getCaretOffset (self):
++		"""
++		Wraps cspi.AccessibleText_getCaretOffset
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleText_getCaretOffset (self.__item)
++
++	def getCharacterCount (self):
++		"""
++		Wraps cspi.AccessibleText_getCharacterCount
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleText_getCharacterCount (self.__item)
++
++	def getNSelections (self):
++		"""
++		Wraps cspi.AccessibleText_getNSelections
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleText_getNSelections (self.__item)
++
++	#def getSelection (self, selectionNum, startOffset, endOffset):
++	#	self.__checkSelf ()
++	#	return cspi.AccessibleText_getSelection (self.__item, selectionNum, startOffset, endOffset)
++
++	def getText (self, startOffset, endOffset):
++		"""
++		Wraps cspi.AccessibleText_getText
++		"""
++		self.__checkSelf ()
++		return string(cspi.AccessibleText_getText (self.__item, startOffset, endOffset))
++
++	def removeSelection (self, selectionNum):
++		"""
++		Wraps cspi.AccessibleText_removeSelection, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleText_removeSelection (self.__item, selectionNum):
++			raise AtspiException("AccessibleText_removeSelection")
++
++	def setSelection (self, selectionNum, startOffset, endOffset):
++		"""
++		Wraps cspi.AccessibleText_setSelection, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleText_setSelection (self.__item, selectionNum, startOffset, endOffset):
++			raise AtspiException("AccessibleText_setSelection")
++
++	def setCaretOffset (self, position):
++		"""
++		Wraps cspi.AccessibleText_setCaretOffset, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleText_setCaretOffset (self.__item, position):
++			raise AtspiException("AccessibleText_setCaretOffset")
++
++cdef class EditableText (Text):
++	"""
++	Wrapper around the low-level cspi.AccessibleEditableText_ functions,
++	giving an OO-style API.
++	"""
++	def setTextContents (self, newContents):
++		"""
++		Wraps cspi.AccessibleEditableText_setTextContents, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleEditableText_setTextContents (self.__item, newContents):
++			raise AtspiException("AccessibleEditableText_setTextContents")
++
++	def setAttributes (self, attributes, startOffset, endOffset):
++		"""
++		Wraps cspi.AccessibleEditableText_setAttributes, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleEditableText_setAttributes (self.__item, attributes, startOffset, endOffset):
++			raise AtspiException("AccessibleEditableText_setAttributes")
++
++	def insertText (self, position, text):
++		"""
++		Wraps cspi.AccessibleEditableText_insertText, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleEditableText_insertText (self.__item, position, text, cspi.strlen(text)):
++			raise AtspiException("AccessibleEditableText_insertText")
++
++cdef class Hypertext (Text):
++	"""
++	Wrapper around the low-level cspi.AccessibleHypertext_ functions,
++	giving an OO-style API.
++	"""
++	def getNLinks (self):
++		"""
++		Wraps cspi.AccessibleHypertext_getNLinks, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleHypertext_getNLinks (self.__item)
++
++	def getLink (self, linkIndex):
++		"""
++		Wraps cspi.AccessibleHypertext_getLink, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		cdef Hyperlink hyperlink
++		hyperlink = Hyperlink ()
++		hyperlink.__setItem (cspi.AccessibleHypertext_getLink (self.__item, linkIndex))
++		if hyperlink.__item != NULL:
++			return hyperlink
++
++	def getLinkIndex (self, characterOffset):
++		"""
++		Wraps cspi.AccessibleHypertext_getLinkIndex, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleHypertext_getLinkIndex (self.__item, characterOffset)
++
++cdef class Hyperlink (Base):
++	"""
++	Wrapper around the low-level cspi.AccessibleHyperlink_ functions,
++	giving an OO-style API.
++	"""
++	def getNAnchors (self):
++		"""
++		Wraps cspi.AccessibleHyperlink_getNAnchors, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleHyperlink_getNAnchors (self.__item)
++
++	def getIndexRange (self):
++		"""
++		Wraps cspi.AccessibleHyperlink_getIndexRange, returning [startIndex, endIndex] pair
++		"""
++		self.__checkSelf ()
++		cdef long startIndex, endIndex
++		cspi.AccessibleHyperlink_getIndexRange(self.__item, &startIndex, &endIndex)
++		return [startIndex, endIndex]
++
++
++	def getObject (self, i):
++		"""
++		Wraps cspi.AccessibleHyperlink_getObject
++		"""
++		self.__checkSelf ()
++		cdef Accessible object
++		object = Accessible ()
++		object.__setItem (cspi.AccessibleHyperlink_getObject (self.__item, i))
++		object.__checkSelf ()
++		return object
++
++	def getURI (self, i):
++		"""
++		Wraps cspi.AccessibleHyperlink_getURI, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleHyperlink_getURI (self.__item, i)
++
++	def isValid (self):
++		"""
++		Wraps cspi.AccessibleHyperlink_isValid, raising AtspiException if it fails
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleHyperlink_isValid (self.__item)
++
++cdef class Image (Base):
++	"""
++	Wrapper around the low-level cspi.AccessibleImage_ functions,
++	giving an OO-style API.
++	"""
++	def getImageDescription (self):
++		"""
++		Wraps cspi.AccessibleImage_getImageDescription
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleImage_getImageDescription (self.__item)
++
++	def getImageSize (self):
++		"""
++		Wraps cspi.AccessibleImage_getImageSize, returning a (w,h) pair
++		"""
++		self.__checkSelf ()
++		cdef long w, h
++		cspi.AccessibleImage_getImageSize(self.__item, &w, &h);
++		return [w, h]
++
++	def getImagePosition (self, type=0):
++		"""
++		Wraps cspi.AccessibleImage_getImagePosition, returning a (x,y)
++		pair
++		"""
++		self.__checkSelf ()
++		cdef long x, y
++		cspi.AccessibleImage_getImagePosition(self.__item, &x, &y, type)
++		return [x, y]
++
++	def getImageExtents (self, type=0):
++		"""
++		Wraps cspi.AccessibleImage_getImageExtents, returning a
++		(x,y,w,h) tuple
++		"""
++		self.__checkSelf ()
++		cdef long x, y, w, h
++		cspi.AccessibleImage_getImageExtents(self.__item, &x, &y, &w, &h, type)
++		return [x, y, w, h]
++
++cdef class Value (Base):
++	"""
++	Wrapper around the low-level cspi.AccessibleValue_ functions,
++	giving an OO-style API.
++	"""
++	def getMinimumValue (self):
++		"""
++		Wraps cspi.AccessibleValue_getMinimumValue
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleValue_getMinimumValue(self.__item)
++
++	def getCurrentValue (self):
++		"""
++		Wraps cspi.AccessibleValue_getMinimumValue
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleValue_getCurrentValue(self.__item)
++
++	def getMaximumValue (self):
++		"""
++		Wraps cspi.AccessibleValue_getMinimumValue
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleValue_getMaximumValue(self.__item)
++
++	def setCurrentValue (self, newValue):
++		"""
++		Wraps cspi.AccessibleValue_setCurrentValue
++		"""
++		self.__checkSelf ()
++		if not cspi.AccessibleValue_setCurrentValue (self.__item, newValue):
++			raise AtspiException("AccessibleValue_setCurrentValue")
++
++cdef class Selection (Base):
++	"""
++	Wrapper around the low-level cspi.AccessibleSelection_ functions,
++	giving an OO-style API.
++	"""
++
++	def getNSelectedChildren (self):
++		"""
++		Wraps cspi.AccessibleSelection_getNSelectedChildren
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleSelection_getNSelectedChildren (self.__item)
++
++	def getSelectedChild (self, index):
++		"""
++		Wraps cspi.AccessibleSelection_getSelectedChild
++		"""
++		self.__checkSelf ()
++
++		cdef cspi.Accessible* spiChild
++		spiChild = cspi.AccessibleSelection_getSelectedChild (self.__item, index)
++
++		assert spiChild != NULL
++		
++		cdef object child
++		cdef Application app
++		cdef Accessible acc
++		cdef Text text
++		
++		if cspi.Accessible_isApplication (spiChild):
++			app = Application ()
++			app.__setItem (spiChild)
++			child = app
++		else:
++			acc = Accessible ()
++			acc.__setItem (spiChild)
++			child = acc
++
++		return child
++
++	def selectChild (self, index):
++		"""
++		Wraps cspi.AccessibleSelection_selectChild
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleSelection_selectChild (self.__item, index)
++	
++	def deselectSelectedChild (self, index):
++		"""
++		Wraps cspi.AccessibleSelection_deselectSelectedChild
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleSelection_deselectSelectedChild (self.__item, index)
++	
++	def isChildSelected (self, index):
++		"""
++		Wraps cspi.AccessibleSelection_isChildSelected
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleSelection_isChildSelected (self.__item, index)
++
++	def selectAll (self):
++		"""
++		Wraps cspi.AccessibleSelection_selectAll
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleSelection_selectAll( self.__item)
++
++	def clearSelection (self):
++		"""
++		Wraps cspi.AccessibleSelection_clearSelection
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleSelection_clearSelection (self.__item)
++	
++cdef class Table (Base):
++	"""
++	Wrapper around the low-level cspi.AccessibleTable_ functions,
++	giving an OO-style API.
++	"""
++
++	# def getTableAccessibleAt (self, row, column):
++	# def getTableCaption (self):
++
++	def getTableColumnAtIndex (self, index):
++		"""
++		Wraps cspi.AccessibleTable_getColumnAtIndex
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getColumnAtIndex(self.__item, index)
++					
++	def getTableColumnDescription (self, column):
++		"""
++		Wraps cspi.AccessibleTable_getColumnDescription
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getColumnDescription(self.__item, column)
++
++	def getTableColumnExtentAt (self, row, column):
++		"""
++		Wraps cspi.AccessibleTable_getColumnExtentAt
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getColumnExtentAt(self.__item, row, column)
++
++	# def getTableColumnHeader (self, column):
++
++	def getTableIndexAt (self, row, column):
++		"""
++		Wraps cspi.AccessibleTable_getIndexAt
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getIndexAt(self.__item, row, column)
++
++	def getTableNColumns (self):
++		"""
++		Wraps cspi.AccessibleTable_getNColumns
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getNColumns(self.__item)
++
++	def getTableNRows (self):
++		"""
++		Wraps cspi.AccessibleTable_getNRows
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getNRows(self.__item)
++
++	def getTableNSelectedColumns (self):
++		"""
++		Wraps cspi.AccessibleTable_getNSelectedColumns
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getNSelectedColumns(self.__item)
++
++	def getTableNSelectedRows (self):
++		"""
++x		Wraps cspi.AccessibleTable_getNSelectedRows
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getNSelectedRows(self.__item)
++
++	def getTableRowAtIndex (self, index):
++		"""
++		Wraps cspi.AccessibleTable_getRowAtIndex
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getRowAtIndex(self.__item, index)
++
++	def getTableRowDescription (self, row):
++		"""
++		Wraps cspi.AccessibleTable_getRowDescription
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getRowDescription(self.__item, row)
++
++	def getTableRowExtentAt (self, row, column):
++		"""
++		Wraps cspi.AccessibleTable_getRowExtentAt
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_getRowExtentAt(self.__item, row, column)
++
++	# def getTableRowHeader (self, row):
++ 	# def getTableSelectedRows (self, **selectedRows): - Not sure if the variable which is a pointer to a pointer is acceptable
++	# def getTableSelectedColumns (self, **selectedColumns): - Same issue as above
++	# def getTableSummary (self):
++
++	def isTableColumnSelected (self, column):
++		"""
++		Wraps cspi.AccessibleTable_isColumnSelected
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_isColumnSelected(self.__item, column)
++
++	def isTableRowSelected (self, row):
++		"""
++		Wraps cspi.AccessibleTable_isRowSelected
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_isRowSelected(self.__item, row)
++
++	def isTableSelected (self, row, column):
++		"""
++		Wraps cspi.AccessibleTable_isSelected
++		"""
++		self.__checkSelf ()
++		return cspi.AccessibleTable_isSelected(self.__item, row, column)
++
++
++cdef class Event (EventBase):
++	#def AccessibleEventListener* SPI_createAccessibleEventListener (AccessibleEventListenerCB callback, void *user_data)
++	#void AccessibleEventListener_unref (AccessibleEventListener *listener)
++	#SPIBoolean AccessibleEventListener_addCallback (AccessibleEventListener *listener, AccessibleEventListenerCB callback, void *user_data)
++	#SPIBoolean AccessibleEventListener_removeCallback (AccessibleEventListener *listener, AccessibleEventListenerCB callback)
++
++	#Accessible* AccessibleActiveDescendantChangedEvent_getActiveDescendant (AccessibleEvent *event)
++	#Accessible* AccessibleChildChangedEvent_getChildAccessible (AccessibleEvent *event)
++	
++	def getDescriptionChangedEventDescriptionString (self):
++		self.__checkSelf()
++		return string(cspi.AccessibleDescriptionChangedEvent_getDescriptionString(self.__item))
++
++	def getNameChangedEventNameString (self):
++		self.__checkSelf()
++		return string(cspi.AccessibleNameChangedEvent_getNameString(self.__item))
++
++	# Accessible* AccessibleParentChangedEvent_getParentAccessible (AccessibleEvent *event)
++
++	def getTableCaptionChangedEventCaptionString(self):
++		self.__checkSelf()
++		return string(cspi.AccessibleTableCaptionChangedEvent_getCaptionString(self.__item))
++
++	def getTableColumnDescriptionChangedEventDescriptionString(self):
++		self.__checkSelf ()
++		return string(cspi.AccessibleTableColumnDescriptionChangedEvent_getDescriptionString(self.__item))
++
++	# Accessible* AccessibleTableHeaderChangedEvent_getHeaderAccessible (AccessibleEvent *event)
++
++	def getTableRowDescriptionChangedEventDescriptionString(self):
++		self.__checkSelf ()
++		return string(cspi.AccessibleTableRowDescriptionChangedEvent_getDescriptionString(self.__item))
++	
++	#Accessible* AccessibleTableSummaryChangedEvent_getSummaryAccessible (AccessibleEvent *event)
++
++	def getTextChangedEventChangeString (self):
++		self.__checkSelf ()
++		return string(cspi.AccessibleTextChangedEvent_getChangeString(self.__item))
++
++	def getTextSelectionChangedEventSelectionString (self):
++		self.__checkSelf ()
++		return string(cspi.AccessibleTextSelectionChangedEvent_getSelectionString(self.__item))
++
++	def getWindowEventTitleString (self):
++		self.__checkSelf ()
++		return string(cspi.AccessibleWindowEvent_getTitleString(self.__item))
++
++class EventGenerator:
++	"""
++	Wrapper layer around SPI_generateKeyboardEvent and
++	SPI_generateMouseEvent, used for generating input events.
++
++	Use AccessibleAction in preference to this.
++	"""
++	def injectKeyboardString (self, string):
++		"""
++		Inject a string as if it had been typed using an input method.
++		"""
++		# Seems to only work if you do it one character at a time...
++		for char in string:
++			self.__generateKeystringEvent (str(char), cspi.SPI_KEY_STRING)
++
++	def __keyStringToKeyCode(self, keyString):
++		cdef Xlib.Display *display
++		display = Xlib.XOpenDisplay(NULL)
++
++		cdef Xlib.KeySym sym
++		sym = Xlib.XStringToKeysym(keyString)
++		cdef Xlib.KeyCode code
++		code = Xlib.XKeysymToKeycode(display, sym)
++
++		#print str(keyString), str(int(sym)), code
++
++		Xlib.XCloseDisplay(display)
++		return int(code)
++	
++	def generateKeyCombo (self, keyStrings):
++		modifiers = keyStrings[:-1]
++		finalKey = keyStrings[-1]
++
++		for modifier in modifiers:
++			code = self.__keyStringToKeyCode(modifier)
++			self.generateKeyboardEvent(code, '', cspi.SPI_KEY_PRESS)
++
++		code = self.__keyStringToKeyCode(finalKey)
++		self.generateKeyboardEvent(code, '', cspi.SPI_KEY_PRESSRELEASE)
++
++		for modifier in modifiers:
++			code = self.__keyStringToKeyCode(modifier)
++			self.generateKeyboardEvent(code, '', cspi.SPI_KEY_RELEASE)
++
++		
++	def __generateKeyvalEvent (self, keyval, synthType):
++		self.generateKeyboardEvent (keyval, None, synthType)
++
++	def __generateKeystringEvent (self, keystring, synthType):
++		self.generateKeyboardEvent (0, keystring, synthType)
++	
++	def generateKeyboardEvent (self, keyval, keystring, synthType):
++		if not cspi.SPI_generateKeyboardEvent (keyval, keystring, synthType):
++			raise AtspiException("SPI_generateKeyboardEvent")
++
++	def click (self, x, y, button):
++		"""
++		Synthesize a mouse button click at (x,y)
++		"""
++		self.__generateButtonEvent (x, y, button, "c")
++
++	def doubleClick (self, x, y, button):
++		"""
++		Synthesize a mouse button double-click at (x,y)
++		"""
++		self.__generateButtonEvent (x, y, button, "d")
++
++	def press (self, x, y, button):
++		"""
++		Synthesize a mouse button press at (x,y)
++		"""
++		self.__generateButtonEvent (x, y, button, "p")
++
++	def release (self, x, y, button):
++		"""
++		Synthesize a mouse button release at (x,y)
++		"""
++		self.__generateButtonEvent (x, y, button, "r")
++
++	def absoluteMotion (self, x, y):
++		"""
++		Synthesize mouse absolute motion to (x,y)
++		"""
++		self.__generateEvent (x, y, "abs")
++
++	def relativeMotion (self, x, y):
++		"""
++		Synthesize mouse relative motion of (x,y)
++		"""
++		self.__generateEvent (x, y, "rel")
++
++	def drag (self, fromXY, toXY, button):
++		"""
++		Synthesize a drag (press, move and release) from (x,y) to (x,y).
++
++		These are absolute screen coordinates
++		"""
++		(x,y) = fromXY
++		self.press (x, y, button)
++
++		(x,y) = toXY
++		self.absoluteMotion(x,y)
++
++		self.release (x, y, button)
++
++	def __generateEvent (self, x, y, name):
++		"""
++		Thin wrapper around SPI_generateMouseEvent.
++
++		Event names: b1p = button 1 press; b2r = button 2 release;
++		b3c = button 3 click; b2d = button 2 double-click;
++		abs = absolute motion; rel = relative motion.
++		"""
++		if not cspi.SPI_generateMouseEvent (x, y, name):
++			raise AtspiException("Error generating mouse event")
++
++	def __generateButtonEvent (self, x, y, button, suffix):
++		self.__generateEvent (x, y, self.__generateButtonName(button)+suffix)
++
++	def __generateButtonName(self, button):
++		if button==1:
++			return "b1"
++		elif button==2:
++			return "b2"
++		elif button==3:
++			return "b3"
++		else: raise ValueError, "Unknown button"
++
++# We use this C function to marshal a call to a python function.  The Python callback
++# function is installed as the userdata of this C callback function.  See the
++# "cheesefinder" demo in the Pyrex sources.
++# We ignore the "const"ness of the AccessibleEvent
++cdef void marshalAccessibleEventCallback (cspi.AccessibleEvent *event, void *python_fn) except *:
++	e = Event()
++	EventBase.__setItem(e, event)
++	(<object>python_fn) (e)
++
++cdef class EventListener:
++	"""
++	Wrapper around the low-level cspi.AccessibleEventListener_ functions,
++	giving an OO-style API.
++	"""
++	cdef cspi.AccessibleEventListener *__item
++	cdef public object eventTypes
++
++	def __init__ (self, callback, eventTypes):
++		"""
++		Registers a python callback function to be called.
++		The callback is expected to have one input, of type atspi.Event, and no return value.
++		See documentation of SPI_registerGlobalEventListener for the event names
++		"""
++		self.eventTypes = eventTypes
++		self.__item = cspi.SPI_createAccessibleEventListener (marshalAccessibleEventCallback, <void*>callback)
++		for eventType in self.eventTypes:
++			#char *e
++			e = eventType
++			if not cspi.SPI_registerGlobalEventListener (self.__item, e):
++				raise AtspiException("Unable to register event listener")
++
++	def deregister(self):
++		for eventType in self.eventTypes:
++			cspi.SPI_deregisterGlobalEventListener(self.__item, eventType)
++
++	def __dealloc__ (self):
++		if self.__item != NULL:
++			self.deregister()
++			cspi.AccessibleEventListener_unref (self.__item)
++
++	def __checkSelf (self):
++		if self.__item == NULL:
++			raise AttributeError, "__item must not be NULL"
++
++cdef class DeviceEvent:
++	"""
++	Wrapper around a cspi.AccessibleDeviceEvent
++	"""
++	cdef cspi.AccessibleDeviceEvent *__item
++	cdef public object keyID
++	cdef public object keyCode
++	cdef public object keyString
++	cdef public object timeStamp
++	cdef public object type
++	cdef public object modifiers
++	cdef public object isText
++
++	def __new__ (self):
++			self.__item = NULL
++
++	cdef bool __setItem (self, cspi.AccessibleDeviceEvent *obj):
++			if obj != NULL:
++					self.__item = obj
++					self.keyID = self.__item.keyID
++					self.keyCode = self.__item.keycode
++					self.keyString = self.__item.keystring
++					self.timeStamp = self.__item.timestamp
++					self.type = self.__item.type
++					self.modifiers = self.__item.modifiers
++					if self.__item.is_text: self.isText = True
++					else: self.isText = False
++					return True
++			else:
++					return False
++
++	def __checkSelf (self):
++			if self.__item == NULL:
++					raise AttributeError, "__item must not be NULL"
++
++#	def __dealloc__ (self):
++#			if self.__item != NULL:
++#					cspi.AccessibleDeviceEvent_unref (self.__item)
++
++
++cdef cspi.SPIBoolean marshalAccessibleDeviceEventCallback (cspi.AccessibleDeviceEvent *event, void *python_fn) except 1:
++	k = DeviceEvent()
++	#k.__setItem(event)
++	DeviceEvent.__setItem(k, event)
++	k.__checkSelf()
++	(<object>python_fn) (k)
++	return False
++
++cdef class DeviceListener:
++	"""
++	Wrapper around the low-level cspi.AccessibleDeviceListener_ functions,
++	giving an OO-style API.
++	"""
++	cdef cspi.AccessibleDeviceListener *__item
++	cdef public object modMasks
++
++	def __init__ (self, callback, eventMask = cspi.SPI_KEY_PRESSED | cspi.SPI_KEY_RELEASED):
++		"""
++		Registers a python callback function to be called.
++
++		eventMask may be one of the following:
++        key pressed: 1
++		key released: 2
++		key pressed or released (default): 3
++		"""
++		self.__item = cspi.SPI_createAccessibleDeviceListener (marshalAccessibleDeviceEventCallback, <void*>callback)
++		cdef cspi.AccessibleKeySet *keySet
++		keySet = SPI_KEYSET_ALL_KEYS
++		self.modMasks = []
++		cdef short int modMask
++		syncType = SPI_KEYLISTENER_SYNCHRONOUS | SPI_KEYLISTENER_CANCONSUME
++		#syncType = SPI_KEYLISTENER_NOSYNC
++		for modMask from 0 <= modMask < (1 << 8):
++			self.modMasks.append(modMask)
++			desc = "keySet "+str(<int> keySet)+" modMask "+str(modMask)+" eventMask "+str(eventMask)+" syncType "+str(syncType)
++			desc = str(desc)
++			if not cspi.SPI_registerAccessibleKeystrokeListener (self.__item, keySet, modMask, eventMask, syncType):
++				raise AtspiException("Unable to register keystroke listener", desc)
++
++	def deregister(self):
++		if self.__item != NULL:
++			for modMask in self.modMasks:
++				cspi.SPI_deregisterAccessibleKeystrokeListener(self.__item, modMask)
++
++	def __dealloc__ (self):
++		if self.__item != NULL:
++			self.deregister()
++			cspi.AccessibleDeviceListener_unref (self.__item)
++
++	def __checkSelf (self):
++		if self.__item == NULL:
++			raise AttributeError, "__item must not be NULL"
++
++
++# vim: sw=4 ts=4 sts=4 noet ai