summaryrefslogtreecommitdiff
path: root/testing/python-pyspi/pyspi-build.patch
diff options
context:
space:
mode:
Diffstat (limited to 'testing/python-pyspi/pyspi-build.patch')
-rw-r--r--testing/python-pyspi/pyspi-build.patch1693
1 files changed, 1693 insertions, 0 deletions
diff --git a/testing/python-pyspi/pyspi-build.patch b/testing/python-pyspi/pyspi-build.patch
new file mode 100644
index 000000000..3d12c5ed5
--- /dev/null
+++ b/testing/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