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