From 91308d34413609f0d82dd0e280d3ee76229bd555 Mon Sep 17 00:00:00 2001 From: Mark Doffman Date: Mon, 28 Jul 2008 15:57:08 +0100 Subject: [PATCH] 2008-07-28 Mark Doffman * pyatspi/ Add the beginnings of the pyatspi client bindings implementation * tests/pyatspi Add an (Untested) test framework for performing asyncronous system tests on the pyatspi interface. --- Makefile.am | 2 +- configure.ac | 2 + pyatspi/Makefile.am | 15 + pyatspi/__init__.py | 36 + pyatspi/accessible.py | 190 ++ pyatspi/base.py | 126 ++ pyatspi/cache.py | 187 ++ pyatspi/constants.py | 134 ++ pyatspi/factory.py | 66 + pyatspi/other.py | 3877 ++++++++++++++++++++++++++++++++++++ pyatspi/stateset.py | 232 +++ pyatspi/utils.py | 303 +++ tests/pyatspi/Makefile.am | 13 +- tests/pyatspi/__init__.py | 4 - tests/pyatspi/accessibletest.py | 28 +- tests/pyatspi/coretest.py | 57 - tests/pyatspi/pasytest/Events.py | 78 + tests/pyatspi/pasytest/Makefile.am | 6 + tests/pyatspi/pasytest/Pasy.py | 113 ++ tests/pyatspi/pasytest/__init__.py | 16 + tests/pyatspi/setvars.sh | 6 + tests/pyatspi/testrunner.py | 69 +- tests/pyatspi/testutil.py | 30 - 23 files changed, 5469 insertions(+), 121 deletions(-) create mode 100644 pyatspi/Makefile.am create mode 100644 pyatspi/__init__.py create mode 100644 pyatspi/accessible.py create mode 100644 pyatspi/base.py create mode 100644 pyatspi/cache.py create mode 100644 pyatspi/constants.py create mode 100644 pyatspi/factory.py create mode 100644 pyatspi/other.py create mode 100644 pyatspi/stateset.py create mode 100644 pyatspi/utils.py delete mode 100644 tests/pyatspi/__init__.py delete mode 100644 tests/pyatspi/coretest.py create mode 100644 tests/pyatspi/pasytest/Events.py create mode 100644 tests/pyatspi/pasytest/Makefile.am create mode 100644 tests/pyatspi/pasytest/Pasy.py create mode 100644 tests/pyatspi/pasytest/__init__.py create mode 100755 tests/pyatspi/setvars.sh delete mode 100644 tests/pyatspi/testutil.py diff --git a/Makefile.am b/Makefile.am index a6b9ea2..f485d5a 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,4 +1,4 @@ -SUBDIRS=xml tools droute spi-common atk-adaptor registryd dbind cspi login-helper tests +SUBDIRS=xml tools droute spi-common atk-adaptor registryd dbind cspi pyatspi login-helper tests pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = libspi-1.0.pc cspi-1.0.pc libloginhelper-1.0.pc diff --git a/configure.ac b/configure.ac index 857e2a9..f50d584 100644 --- a/configure.ac +++ b/configure.ac @@ -192,9 +192,11 @@ AC_CONFIG_FILES([Makefile tests/dummyatk/Makefile tests/cspi/Makefile tests/pyatspi/Makefile + tests/pyatspi/pasytest/Makefile tests/apps/Makefile dbind/Makefile cspi/Makefile + pyatspi/Makefile dbind-config.h]) AC_OUTPUT diff --git a/pyatspi/Makefile.am b/pyatspi/Makefile.am new file mode 100644 index 0000000..34fc8fc --- /dev/null +++ b/pyatspi/Makefile.am @@ -0,0 +1,15 @@ +pyatspi_PYTHON = \ + accessible.py \ + base.py \ + cache.py \ + constants.py \ + factory.py \ + __init__.py \ + Makefile.am \ + other.py \ + stateset.py \ + utils.py + +pyatspidir=$(pyexecdir)/pyatspi + +CLEANFILES = *.pyc diff --git a/pyatspi/__init__.py b/pyatspi/__init__.py new file mode 100644 index 0000000..2b916c9 --- /dev/null +++ b/pyatspi/__init__.py @@ -0,0 +1,36 @@ +#Copyright (C) 2008 Codethink Ltd + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +#import registry + +#Registry = registry.Registry(reg) +#registry.Registry = Registry +#del registry + +def setCacheLevel(level): + pass + +def getCacheLevel(): + return None + +def clearCache(): + pass + +def printCache(): + print "Print cache function is deprecated"; + +from constants import * +from other import * +from accessible import * +#from utils import * diff --git a/pyatspi/accessible.py b/pyatspi/accessible.py new file mode 100644 index 0000000..54be0cd --- /dev/null +++ b/pyatspi/accessible.py @@ -0,0 +1,190 @@ +#Copyright (C) 2008 Codethink Ltd + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +from base import BaseProxy + +class Accessible(BaseProxy): + """ + The base interface which is implemented by all accessible objects. + All objects support interfaces for querying their contained + 'children' and position in the accessible-object hierarchy, + whether or not they actually have children. + """ + + def getApplication(self, *args, **kwargs): + """ + Get the containing Application for this object. + @return the Application instance to which this object belongs. + """ + func = self.get_dbus_method("getApplication") + return func(*args, **kwargs) + + def getAttributes(self, *args, **kwargs): + """ + Get a list of properties applied to this object as a whole, as + an AttributeSet consisting of name-value pairs. As such these + attributes may be considered weakly-typed properties or annotations, + as distinct from the strongly-typed interface instance data declared + using the IDL "attribute" keyword. + Not all objects have explicit "name-value pair" AttributeSet + properties. + Attribute names and values may have any UTF-8 string value, however + where possible, in order to facilitate consistent use and exposure + of "attribute" properties by applications and AT clients, attribute + names and values should chosen from a publicly-specified namespace + where appropriate. + Where possible, the names and values in the name-value pairs + should be chosen from well-established attribute namespaces using + standard semantics. For example, attributes of Accessible objects + corresponding to XHTML content elements should correspond to + attribute names and values specified in the w3c XHTML specification, + at http://www.w3.org/TR/xhtml2, where such values are not already + exposed via a more strongly-typed aspect of the AT-SPI API. Metadata + names and values should be chosen from the 'Dublin Core' Metadata + namespace using Dublin Core semantics: http://dublincore.org/dcregistry/ + Similarly, relevant structural metadata should be exposed using + attribute names and values chosen from the CSS2 and WICD specification: + http://www.w3.org/TR/1998/REC-CSS2-19980512 WICD (http://www.w3.org/TR/2005/WD-WICD-20051121/). + @return : an AttributeSet encapsulating any "attribute values" + currently defined for the object. + """ + func = self.get_dbus_method("getAttributes") + return func(*args, **kwargs) + + def getChildAtIndex(self, *args, **kwargs): + """ + Get the accessible child of this object at index. + @param : index + an in parameter indicating which child is requested (zero-indexed). + @return : the 'nth' Accessible child of this object. + """ + func = self.get_dbus_method("getChildAtIndex") + return func(*args, **kwargs) + + def getIndexInParent(self, *args, **kwargs): + """ + Get the index of this object in its parent's child list. + @return : a long integer indicating this object's index in the + parent's list. + """ + func = self.get_dbus_method("getIndexInParent") + return func(*args, **kwargs) + + def getLocalizedRoleName(self, *args, **kwargs): + """ + Get a string indicating the type of UI role played by this object, + translated to the current locale. + @return : a UTF-8 string indicating the type of UI role played + by this object. + """ + func = self.get_dbus_method("getLocalizedRoleName") + return func(*args, **kwargs) + + def getRelationSet(self, *args, **kwargs): + """ + Get a set defining this object's relationship to other accessible + objects. + @return : a RelationSet defining this object's relationships. + """ + func = self.get_dbus_method("getRelationSet") + return func(*args, **kwargs) + + def getRole(self, *args, **kwargs): + """ + Get the Role indicating the type of UI role played by this object. + @return : a Role indicating the type of UI role played by this + object. + """ + func = self.get_dbus_method("getRole") + return func(*args, **kwargs) + + def getRoleName(self, *args, **kwargs): + """ + Get a string indicating the type of UI role played by this object. + @return : a UTF-8 string indicating the type of UI role played + by this object. + """ + func = self.get_dbus_method("getRoleName") + return func(*args, **kwargs) + + def getState(self, *args, **kwargs): + """ + Get the current state of the object as a StateSet. + @return : a StateSet encapsulating the currently true states + of the object. + """ + func = self.get_dbus_method("getState") + return func(*args, **kwargs) + + def isEqual(self, *args, **kwargs): + """ + Determine whether an Accessible refers to the same object as + another. This method should be used rather than brute-force comparison + of object references (i.e. "by-value" comparison), as two object + references may have different apparent values yet refer to the + same object. + @param : obj + an Accessible object reference to compare to + @return : a boolean indicating whether the two object references + point to the same object. + """ + func = self.get_dbus_method("isEqual") + return func(*args, **kwargs) + + def unimplemented(self, *args, **kwargs): + """ + /cond future expansion + """ + func = self.get_dbus_method("unimplemented") + return func(*args, **kwargs) + + def get_childCount(self): + self._pgetter(self._dbus_interface, "childCount") + def set_childCount(self, value): + self._psetter(self._dbus_interface, "childCount", value) + _childCountDoc = \ + """ + childCount: the number of children contained by this object. + """ + childCount = property(fget=get_childCount, fset=set_childCount, doc=_childCountDoc) + + def get_description(self): + self._pgetter(self._dbus_interface, "description") + def set_description(self, value): + self._psetter(self._dbus_interface, "description", value) + _descriptionDoc = \ + """ + a string describing the object in more detail than name. + """ + description = property(fget=get_description, fset=set_description, doc=_descriptionDoc) + + def get_name(self): + self._pgetter(self._dbus_interface, "name") + def set_name(self, value): + self._psetter(self._dbus_interface, "name", value) + _nameDoc = \ + """ + a (short) string representing the object's name. + """ + name = property(fget=get_name, fset=set_name, doc=_nameDoc) + + def get_parent(self): + self._pgetter(self._dbus_interface, "parent") + def set_parent(self, value): + self._psetter(self._dbus_interface, "parent", value) + _parentDoc = \ + """ + an Accessible object which is this object's containing object. + """ + parent = property(fget=get_parent, fset=set_parent, doc=_parentDoc) diff --git a/pyatspi/base.py b/pyatspi/base.py new file mode 100644 index 0000000..8f23713 --- /dev/null +++ b/pyatspi/base.py @@ -0,0 +1,126 @@ +#Copyright (C) 2008 Codethink Ltd + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +from weakref import ref + +from dbus.proxies import Interface, ProxyObject +from dbus.exceptions import * + +from factory import interfaceFactory + +class AccessibleObjectNoLongerExists(Exception): + pass + +#------------------------------------------------------------------------------ + +class Enum(object): + def __str__(self): + return self._enum_lookup(int(self)) + +#------------------------------------------------------------------------------ + +class BaseProxyMeta(type): + def __init__(cls): + type.__init__(cls) + + queryable_interfaces = { + 'Accessible':ATSPI_ACCESSIBLE, + 'Action':ATSPI_ACTION, + 'Application':ATSPI_APPLICATION, + 'Collection':ATSPI_COLLECTION, + 'Component':ATSPI_COMPONENT, + 'Desktop':ATSPI_DESKTOP, + 'Document':ATSPI_DOCUMENT, + 'EditableText':ATSPI_EDITABLE_TEXT, + 'Hypertext':ATSPI_HYPERTEXT, + 'Hyperlink':ATSPI_HYPERLINK, + 'Image':ATSPI_IMAGE, + 'Selection':ATSPI_SELECTION, + 'StreamableContent':ATSPI_STREAMABLE_CONTENT, + 'Table':ATSPI_TABLE, + 'Text':ATSPI_TEXT, + 'Value':ATSPI_VALUE, + } + + for interface in queryable_interfaces.keys(): + name = 'query%s' % interface + def new_query(self, object): + return self.queryInterface(object, queryable_interfaces[interface]) + setattr(cls, name, new_query) + +#------------------------------------------------------------------------------ + +class BaseProxy(Interface): + """ + A D-Bus proxy for a remote object that implements one or more of the AT-SPI + Accessibility interfaces. + """ + + __metaclass__ = BaseProxyMeta + + def __init__(self, busobject, cache, app, path, interface): + """ + Create a D-Bus Proxy for an ATSPI interface. + + busobject - The D-Bus proxy object this interface uses for D-Bus calls. + cache - The accessible cache that this object is owned by. + path - The object path of the remote object. + app - The bus name of the application this object belongs to. + interface - The name of the ATSPI interface that this proxy implements. + """ + Interface.__init__(self, busobject, interface) + + self._cache = cache + + self._path = path + self._app = app + + self._pgetter = self.get_dbus_method("Get", dbus_interface="org.freedesktop.DBus.Properties") + self._psetter = self.get_dbus_method("Set", dbus_interface="org.freedesktop.DBus.Properties") + + def __getattr__(self, *args, **kwargs): + """ + The __getattr__ function must return the D-Bus method wrapped in a + method to translate exceptions. + """ + # Need to throw an AccessibleObjectNoLongerExists exception + # on D-Bus error of the same type. + try: + return Interface.__getattr__(self, *args, **kwargs) + except UnknownMethodException, e: + raise NotImplementedError(e) + except DBusException, e: + raise LookupError(e) + + @property + def _data(self): + try: + data = self._cache._objects[self._path] + except KeyError: + raise AccessibleObjectNoLongerExists, 'Cache data cannot be found for path %s' % (self._path,) + return data + + @property + def interfaces(self): + return self._data.interfaces + + def queryInterface(self, interface): + if interface in self._data.interfaces: + return interfaceFactory(self._obj, self._cache, self._app, self._path, interface) + else: + raise NotImplementedError( + "%s not supported by accessible object at path %s" + % (interface, self.path)) + +#END---------------------------------------------------------------------------- diff --git a/pyatspi/cache.py b/pyatspi/cache.py new file mode 100644 index 0000000..a707ceb --- /dev/null +++ b/pyatspi/cache.py @@ -0,0 +1,187 @@ +#Copyright (C) 2008 Codethink Ltd + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +from base import AccessibleObjectNoLongerExists +from factory import interfaceFactory + +ATSPI_DEVICE_EVENT_CONTROLLER = 'org.freedesktop.atspi.DeviceEventController' +ATSPI_DEVICE_EVENT_LISTENER = 'org.freedesktop.atspi.DeviceEventListener' +ATSPI_REGISTRY = 'org.freedesktop.atspi.Registry' +ATSPI_TREE = 'org.freedesktop.atspi.Tree' + +#------------------------------------------------------------------------------ + +class _CacheData(object): + __slots__ = [ + 'parent', + 'interfaces', + 'children', + 'role', + 'name', + 'description', + ] + + def __init__(self, data): + self.update(data) + + def update(self, data): + #Don't cache the path here, used as lookup in cache object dict. + (path, + self.parent, + self.children, + self.interfaces, + self.name, + self.role, + self.description) = data + +#------------------------------------------------------------------------------ + +class ApplicationCache(object): + """ + Caches the bus names of all applications. + + Makes calls and recieves updates from the registry + daemon to keep the cache up to date. + """ + + _UPDATE_SIGNAL = 'updateApplications' + _REGISTRY_PATH = '/org/freedesktop/atspi/registry' + + def __init__(self, connection, busName): + """ + Create a cache for application caches. + BusName -> ApplicationCache + """ + self._connection = connection + self._busName = busName + + registryObject = connection.get_object(busName, self._REGISTRY_PATH) + registryInterface = dbus.Interface(registryObject, ATSPI_REGISTRY) + + self._applications = {} + + self._updateApplications(registryInterface.getApplications()) + + #Connect to update signal + self._signalMatch = self.registryInterface.connect_to_signal(self._UPDATE_SIGNAL, + self._updateHandler) + + def _updateApplications(self, names): + """ + Updates the application cache from an + array of dbus bus names. + """ + for name in names: + if name not in self._applications: + self._applications[name] = AccessibleCache(self._connection, + self._busName, + self._treePath) + + def _removeApplications(self, names): + """ + Removes application caches given by names. + """ + for name in names: + del(self._applications[name]) + + def _updateHandler(self, updates): + update, remove = updates + self._removeApplications(update) + self._updateApplications(remove) + +#------------------------------------------------------------------------------ + +class AccessibleCache(object): + """ + Caches data for a collection of accessible object proxies. + + Makes calls and recieves updates from applications + to update the cache of accessible object data. + """ + + _UPDATE_SIGNAL = 'updateTree' + _TREE_PATH = '/org/freedesktop/atspi/tree' + + + def __init__(self, connection, busName): + """ + Creates a cache for accessible object data. + + All accessible object proxies are created and accessed through this cache. + + connection - DBus connection. + busName - DBus bus name where accessible tree resides. + """ + self._connection = connection + self._busName = busName + + treeObject = connection.get_object(busName, self._TREE_PATH) + treeInterface = dbus.Interface(treeObject, ATSPI_TREE) + + self._objects = {} + + self._root = treeObject.getRoot() + self._updateObjects(treeInterface.getTree()) + + #Connect to update signal + self._signalMatch = treeInterface.connect_to_signal(self._UPDATE_SIGNAL, + self._updateHandler) + + def getRootAccessible(self): + """ + Gets the accessible object at the root of the tree. + """ + return self.getAccessible(self._root) + + def getAccessible(self, path): + """ + Gets a D-Bus proxy object for the given object path. + The object that is returned implements the accessible + interface. + + path - The D-Bus path of the remote object. + """ + if path in self._objects: + proxy = self._connection.get_object(self._busName, path, introspect=False) + return interfaceFactory(proxy, self, self._busName, path, ATSPI_ACCESSIBLE) + else: + raise AccessibleObjectNoLongerExists, "D-Bus reference not found in cache" + + def _updateObjects(self, objects): + """ + Updates the object cache from an + array of accessible object cache data. + """ + for data in objects: + #First element is the object path. + path = data[0] + if path in self._objects: + cachedata = self._objects[path] + cachedata.update(data) + else: + self._objects[path] = _CacheData(data) + + def _removeObjects(self, paths): + """ + Removes the object data from the cache. + """ + for path in paths: + del(self._objects[path]) + + def _updateHandler(self, updates): + update, remove = updates + self._removeObjects(update) + self._updateObjects(remove) + +#END--------------------------------------------------------------------------- diff --git a/pyatspi/constants.py b/pyatspi/constants.py new file mode 100644 index 0000000..430bcab --- /dev/null +++ b/pyatspi/constants.py @@ -0,0 +1,134 @@ +#Copyright (C) 2008 Codethink Ltd +#copyright: Copyright (c) 2005, 2007 IBM Corporation + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +#Portions of this code originally licensed and copyright (c) 2005, 2007 +#IBM Corporation under the BSD license, available at +#U{http://www.opensource.org/licenses/bsd-license.php} + +#authors: Peter Parente, Mark Doffman + +# Constants used in the Component interface to get screen coordinates +DESKTOP_COORDS = 0 +WINDOW_COORDS = 1 + +# Constants used to synthesize mouse events +MOUSE_B1P = 'b1p' +MOUSE_B1R = 'b1r' +MOUSE_B1C = 'b1c' +MOUSE_B1D = 'b1d' +MOUSE_B2P = 'b2p' +MOUSE_B2R = 'b2r' +MOUSE_B2C = 'b2c' +MOUSE_B2D = 'b2d' +MOUSE_B3P = 'b3p' +MOUSE_B3R = 'b3r' +MOUSE_B3C = 'b3c' +MOUSE_B3D = 'b3d' +MOUSE_ABS = 'abs' +MOUSE_REL = 'rel' + +# Dictionary used to correct the bug of not being able to register for all the +# subevents given only an AT-SPI event class (i.e. first part of the event +# name) keys are event names having subevents and values are the subevents +# under the key event; handlers *can* be registered for events not in this tree +EVENT_TREE = { + 'terminal': + ['terminal:line-changed', + 'terminal:columncount-changed', + 'terminal:linecount-changed', + 'terminal:application-changed', + 'terminal:charwidth-changed' + ], + 'document': + ['document:load-complete', + 'document:reload', + 'document:load-stopped', + 'document:content-changed', + 'document:attributes-changed' + ], + 'object': + ['object:property-change', + 'object:bounds-changed', + 'object:link-selected', + 'object:state-changed', + 'object:children-changed', + 'object:visible-data-changed', + 'object:selection-changed', + 'object:model-changed', + 'object:active-descendant-changed', + 'object:row-inserted', + 'object:row-reordered', + 'object:row-deleted', + 'object:column-inserted', + 'object:column-reordered', + 'object:column-deleted', + 'object:text-bounds-changed', + 'object:text-selection-changed', + 'object:text-changed', + 'object:text-attributes-changed', + 'object:text-caret-moved', + 'object:attributes-changed'], + 'object:text-changed' : + ['object:text-changed:insert', + 'object:text-changed:delete'], + 'object:property-change' : + ['object:property-change:accessible-parent', + 'object:property-change:accessible-name', + 'object:property-change:accessible-description', + 'object:property-change:accessible-value', + 'object:property-change:accessible-role', + 'object:property-change:accessible-table-caption', + 'object:property-change:accessible-table-column-description', + 'object:property-change:accessible-table-column-header', + 'object:property-change:accessible-table-row-description', + 'object:property-change:accessible-table-row-header', + 'object:property-change:accessible-table-summary'], + 'object:children-changed' : + ['object:children-changed:add', + 'object:children-changed:remove'], + 'object:state-changed' : + ['object:state-changed:'], + 'mouse' : + ['mouse:abs', + 'mouse:rel', + 'mouse:button'], + 'mouse:button' : + ['mouse:button:1p', + 'mouse:button:1r', + 'mouse:button:2p', + 'mouse:button:2r', + 'mouse:button:3p', + 'mouse:button:3r'], + 'window' : + ['window:minimize', + 'window:maximize', + 'window:restore', + 'window:close', + 'window:create', + 'window:reparent', + 'window:desktop-create', + 'window:desktop-destroy', + 'window:activate', + 'window:deactivate', + 'window:raise', + 'window:lower', + 'window:move', + 'window:resize', + 'window:shade', + 'window:unshade', + 'window:restyle'], + 'focus' : + ['focus:'] +} diff --git a/pyatspi/factory.py b/pyatspi/factory.py new file mode 100644 index 0000000..dfb33bd --- /dev/null +++ b/pyatspi/factory.py @@ -0,0 +1,66 @@ +#Copyright (C) 2008 Codethink Ltd + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +from base import * +from accessible import * + +ATSPI_ACCESSIBLE = 'org.freedesktop.atspi.Accessible' +ATSPI_ACTION = 'org.freedesktop.atspi.Action' +ATSPI_APPLICATION = 'org.freedesktop.atspi.Application' +ATSPI_COMPONENT = 'org.freedesktop.atspi.Component' +ATSPI_DOCUMENT = 'org.freedesktop.atspi.Document' +ATSPI_EDITABLE_TEXT = 'org.freedesktop.atspi.EditableText' +ATSPI_HYPERLINK = 'org.freedesktop.atspi.Hyperlink' +ATSPI_HYPERTEXT = 'org.freedesktop.atspi.Hypertext' +ATSPI_IMAGE = 'org.freedesktop.atspi.Image' +ATSPI_LOGIN_HELPER = 'org.freedesktop.atspi.LoginHelper' +ATSPI_SELECTION = 'org.freedesktop.atspi.Selection' +ATSPI_SELECTOR = 'org.freedesktop.atspi.Selector' +ATSPI_STREAMABLE_CONTENT = 'org.freedesktop.atspi.Content' +ATSPI_TABLE = 'org.freedesktop.atspi.Table' +ATSPI_TEXT = 'org.freedesktop.atspi.Text' +ATSPI_VALUE = 'org.freedesktop.atspi.Value' + +#------------------------------------------------------------------------------ + +_interfaces = { + ATSPI_ACCESSIBLE:Accessible, + #ATSPI_ACTION: + #ATSPI_APPLICATION: + #ATSPI_COMPONENT: + #ATSPI_DOCUMENT: + #ATSPI_EDITABLE_TEXT: + #ATSPI_HYPERLINK: + #ATSPI_HYPERTEXT: + #ATSPI_IMAGE: + #ATSPI_LOGIN_HELPER: + #ATSPI_SELECTION: + #ATSPI_SELECTOR: + #ATSPI_STREAMABLE_CONTENT: + #ATSPI_TABLE: + #ATSPI_TEXT: + #ATSPI_TREE: + #ATSPI_VALUE: +} + +def interfaceFactory(self, busobject, cache, app, path, interface): + """ + The queryInterfaces method needs to return + different atspi interfaces depending on the interface name. + This class registers names and ATSPI interface + classes to perform this task. + """ + return _interfaces[interface](object, cache, app, path, interface) + +#END---------------------------------------------------------------------------- diff --git a/pyatspi/other.py b/pyatspi/other.py new file mode 100644 index 0000000..46d0c90 --- /dev/null +++ b/pyatspi/other.py @@ -0,0 +1,3877 @@ +#Copyright (C) 2008 Codethink Ltd + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +from base import * + +BUTTON_PRESSED_EVENT = Accessibility.EventType(2) + +BUTTON_RELEASED_EVENT = Accessibility.EventType(3) + +KEY_PRESS = Accessibility.KeySynthType(0) + +KEY_PRESSED = Accessibility.KeyEventType(0) + +KEY_PRESSED_EVENT = Accessibility.EventType(0) + +KEY_PRESSRELEASE = Accessibility.KeySynthType(2) + +KEY_RELEASE = Accessibility.KeySynthType(1) + +KEY_RELEASED = Accessibility.KeyEventType(1) + +KEY_RELEASED_EVENT = Accessibility.EventType(1) + +KEY_STRING = Accessibility.KeySynthType(4) + +KEY_SYM = Accessibility.KeySynthType(3) + +LAYER_BACKGROUND = Accessibility.ComponentLayer(1) + +LAYER_CANVAS = Accessibility.ComponentLayer(2) + +LAYER_INVALID = Accessibility.ComponentLayer(0) + +LAYER_LAST_DEFINED = Accessibility.ComponentLayer(8) + +LAYER_MDI = Accessibility.ComponentLayer(4) + +LAYER_OVERLAY = Accessibility.ComponentLayer(6) + +LAYER_POPUP = Accessibility.ComponentLayer(5) + +LAYER_WIDGET = Accessibility.ComponentLayer(3) + +LAYER_WINDOW = Accessibility.ComponentLayer(7) + +LOCALE_TYPE_COLLATE = Accessibility.LOCALE_TYPE(1) + +LOCALE_TYPE_CTYPE = Accessibility.LOCALE_TYPE(2) + +LOCALE_TYPE_MESSAGES = Accessibility.LOCALE_TYPE(0) + +LOCALE_TYPE_MONETARY = Accessibility.LOCALE_TYPE(3) + +LOCALE_TYPE_NUMERIC = Accessibility.LOCALE_TYPE(4) + +LOCALE_TYPE_TIME = Accessibility.LOCALE_TYPE(5) + +MODIFIER_ALT = Accessibility.ModifierType(3) + +MODIFIER_CONTROL = Accessibility.ModifierType(2) + +MODIFIER_META = Accessibility.ModifierType(4) + +MODIFIER_META2 = Accessibility.ModifierType(5) + +MODIFIER_META3 = Accessibility.ModifierType(6) + +MODIFIER_NUMLOCK = Accessibility.ModifierType(7) + +MODIFIER_SHIFT = Accessibility.ModifierType(0) + +MODIFIER_SHIFTLOCK = Accessibility.ModifierType(1) + +RELATION_CONTROLLED_BY = Accessibility.RelationType(4) + +RELATION_CONTROLLER_FOR = Accessibility.RelationType(3) + +RELATION_DESCRIBED_BY = Accessibility.RelationType(17) + +RELATION_DESCRIPTION_FOR = Accessibility.RelationType(16) + +RELATION_EMBEDDED_BY = Accessibility.RelationType(13) + +RELATION_EMBEDS = Accessibility.RelationType(12) + +RELATION_EXTENDED = Accessibility.RelationType(8) + +RELATION_FLOWS_FROM = Accessibility.RelationType(10) + +RELATION_FLOWS_TO = Accessibility.RelationType(9) + +RELATION_LABELLED_BY = Accessibility.RelationType(2) + +RELATION_LABEL_FOR = Accessibility.RelationType(1) + +RELATION_LAST_DEFINED = Accessibility.RelationType(18) + +RELATION_MEMBER_OF = Accessibility.RelationType(5) + +RELATION_NODE_CHILD_OF = Accessibility.RelationType(7) + +RELATION_NULL = Accessibility.RelationType(0) + +RELATION_PARENT_WINDOW_OF = Accessibility.RelationType(15) + +RELATION_POPUP_FOR = Accessibility.RelationType(14) + +RELATION_SUBWINDOW_OF = Accessibility.RelationType(11) + +RELATION_TOOLTIP_FOR = Accessibility.RelationType(6) + +ROLE_ACCELERATOR_LABEL = Accessibility.Role(1) + +ROLE_ALERT = Accessibility.Role(2) + +ROLE_ANIMATION = Accessibility.Role(3) + +ROLE_APPLICATION = Accessibility.Role(75) + +ROLE_ARROW = Accessibility.Role(4) + +ROLE_AUTOCOMPLETE = Accessibility.Role(76) + +ROLE_CALENDAR = Accessibility.Role(5) + +ROLE_CANVAS = Accessibility.Role(6) + +ROLE_CAPTION = Accessibility.Role(81) + +ROLE_CHART = Accessibility.Role(80) + +ROLE_CHECK_BOX = Accessibility.Role(7) + +ROLE_CHECK_MENU_ITEM = Accessibility.Role(8) + +ROLE_COLOR_CHOOSER = Accessibility.Role(9) + +ROLE_COLUMN_HEADER = Accessibility.Role(10) + +ROLE_COMBO_BOX = Accessibility.Role(11) + +ROLE_DATE_EDITOR = Accessibility.Role(12) + +ROLE_DESKTOP_FRAME = Accessibility.Role(14) + +ROLE_DESKTOP_ICON = Accessibility.Role(13) + +ROLE_DIAL = Accessibility.Role(15) + +ROLE_DIALOG = Accessibility.Role(16) + +ROLE_DIRECTORY_PANE = Accessibility.Role(17) + +ROLE_DOCUMENT_FRAME = Accessibility.Role(82) + +ROLE_DRAWING_AREA = Accessibility.Role(18) + +ROLE_EDITBAR = Accessibility.Role(77) + +ROLE_EMBEDDED = Accessibility.Role(78) + +ROLE_ENTRY = Accessibility.Role(79) + +ROLE_EXTENDED = Accessibility.Role(70) + +ROLE_FILE_CHOOSER = Accessibility.Role(19) + +ROLE_FILLER = Accessibility.Role(20) + +ROLE_FOCUS_TRAVERSABLE = Accessibility.Role(21) + +ROLE_FONT_CHOOSER = Accessibility.Role(22) + +ROLE_FOOTER = Accessibility.Role(72) + +ROLE_FORM = Accessibility.Role(87) + +ROLE_FRAME = Accessibility.Role(23) + +ROLE_GLASS_PANE = Accessibility.Role(24) + +ROLE_HEADER = Accessibility.Role(71) + +ROLE_HEADING = Accessibility.Role(83) + +ROLE_HTML_CONTAINER = Accessibility.Role(25) + +ROLE_ICON = Accessibility.Role(26) + +ROLE_IMAGE = Accessibility.Role(27) + +ROLE_INPUT_METHOD_WINDOW = Accessibility.Role(89) + +ROLE_INTERNAL_FRAME = Accessibility.Role(28) + +ROLE_INVALID = Accessibility.Role(0) + +ROLE_LABEL = Accessibility.Role(29) + +ROLE_LAST_DEFINED = Accessibility.Role(90) + +ROLE_LAYERED_PANE = Accessibility.Role(30) + +ROLE_LINK = Accessibility.Role(88) + +ROLE_LIST = Accessibility.Role(31) + +ROLE_LIST_ITEM = Accessibility.Role(32) + +ROLE_MENU = Accessibility.Role(33) + +ROLE_MENU_BAR = Accessibility.Role(34) + +ROLE_MENU_ITEM = Accessibility.Role(35) + +ROLE_OPTION_PANE = Accessibility.Role(36) + +ROLE_PAGE = Accessibility.Role(84) + +ROLE_PAGE_TAB = Accessibility.Role(37) + +ROLE_PAGE_TAB_LIST = Accessibility.Role(38) + +ROLE_PANEL = Accessibility.Role(39) + +ROLE_PARAGRAPH = Accessibility.Role(73) + +ROLE_PASSWORD_TEXT = Accessibility.Role(40) + +ROLE_POPUP_MENU = Accessibility.Role(41) + +ROLE_PROGRESS_BAR = Accessibility.Role(42) + +ROLE_PUSH_BUTTON = Accessibility.Role(43) + +ROLE_RADIO_BUTTON = Accessibility.Role(44) + +ROLE_RADIO_MENU_ITEM = Accessibility.Role(45) + +ROLE_REDUNDANT_OBJECT = Accessibility.Role(86) + +ROLE_ROOT_PANE = Accessibility.Role(46) + +ROLE_ROW_HEADER = Accessibility.Role(47) + +ROLE_RULER = Accessibility.Role(74) + +ROLE_SCROLL_BAR = Accessibility.Role(48) + +ROLE_SCROLL_PANE = Accessibility.Role(49) + +ROLE_SECTION = Accessibility.Role(85) + +ROLE_SEPARATOR = Accessibility.Role(50) + +ROLE_SLIDER = Accessibility.Role(51) + +ROLE_SPIN_BUTTON = Accessibility.Role(52) + +ROLE_SPLIT_PANE = Accessibility.Role(53) + +ROLE_STATUS_BAR = Accessibility.Role(54) + +ROLE_TABLE = Accessibility.Role(55) + +ROLE_TABLE_CELL = Accessibility.Role(56) + +ROLE_TABLE_COLUMN_HEADER = Accessibility.Role(57) + +ROLE_TABLE_ROW_HEADER = Accessibility.Role(58) + +ROLE_TEAROFF_MENU_ITEM = Accessibility.Role(59) + +ROLE_TERMINAL = Accessibility.Role(60) + +ROLE_TEXT = Accessibility.Role(61) + +ROLE_TOGGLE_BUTTON = Accessibility.Role(62) + +ROLE_TOOL_BAR = Accessibility.Role(63) + +ROLE_TOOL_TIP = Accessibility.Role(64) + +ROLE_TREE = Accessibility.Role(65) + +ROLE_TREE_TABLE = Accessibility.Role(66) + +ROLE_UNKNOWN = Accessibility.Role(67) + +ROLE_VIEWPORT = Accessibility.Role(68) + +ROLE_WINDOW = Accessibility.Role(69) + +STATE_ACTIVE = Accessibility.StateType(1) + +STATE_ANIMATED = Accessibility.StateType(35) + +STATE_ARMED = Accessibility.StateType(2) + +STATE_BUSY = Accessibility.StateType(3) + +STATE_CHECKED = Accessibility.StateType(4) + +STATE_COLLAPSED = Accessibility.StateType(5) + +STATE_DEFUNCT = Accessibility.StateType(6) + +STATE_EDITABLE = Accessibility.StateType(7) + +STATE_ENABLED = Accessibility.StateType(8) + +STATE_EXPANDABLE = Accessibility.StateType(9) + +STATE_EXPANDED = Accessibility.StateType(10) + +STATE_FOCUSABLE = Accessibility.StateType(11) + +STATE_FOCUSED = Accessibility.StateType(12) + +STATE_HAS_TOOLTIP = Accessibility.StateType(13) + +STATE_HORIZONTAL = Accessibility.StateType(14) + +STATE_ICONIFIED = Accessibility.StateType(15) + +STATE_INDETERMINATE = Accessibility.StateType(32) + +STATE_INVALID = Accessibility.StateType(0) + +STATE_INVALID_ENTRY = Accessibility.StateType(36) + +STATE_IS_DEFAULT = Accessibility.StateType(39) + +STATE_LAST_DEFINED = Accessibility.StateType(41) + +STATE_MANAGES_DESCENDANTS = Accessibility.StateType(31) + +STATE_MODAL = Accessibility.StateType(16) + +STATE_MULTISELECTABLE = Accessibility.StateType(18) + +STATE_MULTI_LINE = Accessibility.StateType(17) + +STATE_OPAQUE = Accessibility.StateType(19) + +STATE_PRESSED = Accessibility.StateType(20) + +STATE_REQUIRED = Accessibility.StateType(33) + +STATE_RESIZABLE = Accessibility.StateType(21) + +STATE_SELECTABLE = Accessibility.StateType(22) + +STATE_SELECTABLE_TEXT = Accessibility.StateType(38) + +STATE_SELECTED = Accessibility.StateType(23) + +STATE_SENSITIVE = Accessibility.StateType(24) + +STATE_SHOWING = Accessibility.StateType(25) + +STATE_SINGLE_LINE = Accessibility.StateType(26) + +STATE_STALE = Accessibility.StateType(27) + +STATE_SUPPORTS_AUTOCOMPLETION = Accessibility.StateType(37) + +STATE_TRANSIENT = Accessibility.StateType(28) + +STATE_TRUNCATED = Accessibility.StateType(34) + +STATE_VERTICAL = Accessibility.StateType(29) + +STATE_VISIBLE = Accessibility.StateType(30) + +STATE_VISITED = Accessibility.StateType(40) + +TEXT_BOUNDARY_CHAR = Accessibility.TEXT_BOUNDARY_TYPE(0) + +TEXT_BOUNDARY_LINE_END = Accessibility.TEXT_BOUNDARY_TYPE(6) + +TEXT_BOUNDARY_LINE_START = Accessibility.TEXT_BOUNDARY_TYPE(5) + +TEXT_BOUNDARY_SENTENCE_END = Accessibility.TEXT_BOUNDARY_TYPE(4) + +TEXT_BOUNDARY_SENTENCE_START = Accessibility.TEXT_BOUNDARY_TYPE(3) + +TEXT_BOUNDARY_WORD_END = Accessibility.TEXT_BOUNDARY_TYPE(2) + +TEXT_BOUNDARY_WORD_START = Accessibility.TEXT_BOUNDARY_TYPE(1) + +TEXT_CLIP_BOTH = Accessibility.TEXT_CLIP_TYPE(3) + +TEXT_CLIP_MAX = Accessibility.TEXT_CLIP_TYPE(2) + +TEXT_CLIP_MIN = Accessibility.TEXT_CLIP_TYPE(1) + +TEXT_CLIP_NONE = Accessibility.TEXT_CLIP_TYPE(0) + + +class Action(BaseProxy): + + + """ + An interface through which a user-actionable user interface component + can be manipulated. Components which react to mouse or keyboard + input from the user, (with the exception of pure text entry fields + with no other function), should implement this interface. Typical + actions include "click", "press", "release" (for instance for + buttons), "menu" (for objects which have context menus invokable + from mouse or keyboard), "open" for icons representing files + folders, and others. + """ + + + def doAction(self, *args, **kwargs): + """ + doAction: + @param : index + the 0-based index of the action to perform. + Causes the object to perform the specified action. + @return : a boolean indicating success or failure. + """ + func = self.get_dbus_method("doAction") + return func(*args, **kwargs) + + def getDescription(self, *args, **kwargs): + """ + getDescription: + @param : index + the index of the action for which a description is desired. + Get the description of the specified action. The description + of an action may provide information about the result of action + invocation, unlike the action name. + @return : a string containing the description of the specified + action. + """ + func = self.get_dbus_method("getDescription") + return func(*args, **kwargs) + + def getKeyBinding(self, *args, **kwargs): + """ + getKeyBinding: + @param : index + the 0-based index of the action for which a key binding is requested. + Get the key binding associated with a specific action. + @return : a string containing the key binding for the specified + action, or an empty string ("") if none exists. + """ + func = self.get_dbus_method("getKeyBinding") + return func(*args, **kwargs) + + def getName(self, *args, **kwargs): + """ + getName: + @param : index + the index of the action whose name is requested. + Get the name of the specified action. Action names generally + describe the user action, i.e. "click" or "press", rather then + the result of invoking the action. + @return : a string containing the name of the specified action. + """ + func = self.get_dbus_method("getName") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + def get_nActions(self): + self._pgetter(self._dbus_interface, "nActions") + def set_nActions(self, value): + self._psetter(self._dbus_interface, "nActions", value) + _nActionsDoc = \ + """ + nActions: a long containing the number of actions this object + supports. + """ + nActions = property(fget=get_nActions, fset=set_nActions, doc=_nActionsDoc) + + +class Application(Accessible): + + + """ + An interface identifying an object which is the root of the user + interface Accessible hierarchy associated with a running application. + Children of Application are typically, but not exclusively, top-level + windows. + """ + + + def getLocale(self, *args, **kwargs): + """ + Gets the locale in which the application is currently operating. + For the current message locale, use lctype LOCALE_TYPE_MESSAGES. + @param : lctype + The LocaleType for which the locale is queried. + @return a string compliant with the POSIX standard for locale + description. + """ + func = self.get_dbus_method("getLocale") + return func(*args, **kwargs) + + def pause(self, *args, **kwargs): + """ + Request that the application temporarily stop sending events. + In most cases this should pause the application's main event + loop. + @return : true if the request succeeded, false otherwise. + """ + func = self.get_dbus_method("pause") + return func(*args, **kwargs) + + def registerObjectEventListener(self, *args, **kwargs): + """ + registerObjectEventListener: + @param : listener + an EventListener object which will receive the requested events + @param : eventName + a UTF-8 string indicating the type of (toolkit-specific) event + being requested. Register with this application toolkit for "Accessibility::Accessible" + event notifications. + """ + func = self.get_dbus_method("registerObjectEventListener") + return func(*args, **kwargs) + + def registerToolkitEventListener(self, *args, **kwargs): + """ + @param : listener + an EventListener object which will receive the requested events + from the application's toolkits via toolit 'bridges' + @param : eventName + a UTF-8 string indicating the type of (toolkit-specific) event + being requested. Not all applications can generate toolkit events + of a given type. + Register with this application's toolkit for "toolkit-specific" + event notifications. + """ + func = self.get_dbus_method("registerToolkitEventListener") + return func(*args, **kwargs) + + def resume(self, *args, **kwargs): + """ + Request that the application resume sending events. + @return : True if the request succeeded, False otherwise. + """ + func = self.get_dbus_method("resume") + return func(*args, **kwargs) + + def unImplemented2_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2_") + return func(*args, **kwargs) + + def unImplemented3_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3_") + return func(*args, **kwargs) + + def unImplemented_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_") + return func(*args, **kwargs) + + def get_id(self): + self._pgetter(self._dbus_interface, "id") + def set_id(self, value): + self._psetter(self._dbus_interface, "id", value) + _idDoc = \ + """ + The application instance's unique ID as assigned by the registry. + """ + id = property(fget=get_id, fset=set_id, doc=_idDoc) + + def get_toolkitName(self): + self._pgetter(self._dbus_interface, "toolkitName") + def set_toolkitName(self, value): + self._psetter(self._dbus_interface, "toolkitName", value) + _toolkitNameDoc = \ + """ + A string indicating the type of user interface toolkit which + is used by the application. + """ + toolkitName = property(fget=get_toolkitName, fset=set_toolkitName, doc=_toolkitNameDoc) + + def get_version(self): + self._pgetter(self._dbus_interface, "version") + def set_version(self, value): + self._psetter(self._dbus_interface, "version", value) + _versionDoc = \ + """ + A string indicating the version number of the application's accessibility + bridge implementation. + """ + version = property(fget=get_version, fset=set_version, doc=_versionDoc) + + +class BoundingBox(list): + def __new__(cls, x, y, width, height): + list.__new__(cls, (x, y, width, height) + def __init__(self, x, y, width, height): + list.__init__(self, (x, y, width, height)) + + x = property(fget=_get_x, fset=_set_x) + def _get_x(self): + return self[0] + def _set_x(self, val): + self[0] = val + y = property(fget=_get_y, fset=_set_y) + def _get_y(self): + return self[1] + def _set_y(self, val): + self[1] = val + width = property(fget=_get_width, fset=_set_width) + def _get_width(self): + return self[2] + def _set_width(self, val): + self[2] = val + height = property(fget=_get_height, fset=_set_height) + def _get_height(self): + return self[3] + def _set_height(self, val): + self[3] = val + + +class Collection(BaseProxy): + + + + + def createMatchRule(self, *args, **kwargs): + func = self.get_dbus_method("createMatchRule") + return func(*args, **kwargs) + + def freeMatchRule(self, *args, **kwargs): + func = self.get_dbus_method("freeMatchRule") + return func(*args, **kwargs) + + def getActiveDescendant(self, *args, **kwargs): + func = self.get_dbus_method("getActiveDescendant") + return func(*args, **kwargs) + + def getMatches(self, *args, **kwargs): + func = self.get_dbus_method("getMatches") + return func(*args, **kwargs) + + def getMatchesFrom(self, *args, **kwargs): + func = self.get_dbus_method("getMatchesFrom") + return func(*args, **kwargs) + + def getMatchesTo(self, *args, **kwargs): + func = self.get_dbus_method("getMatchesTo") + return func(*args, **kwargs) + + def isAncestorOf(self, *args, **kwargs): + func = self.get_dbus_method("isAncestorOf") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + MATCH_ALL = Accessibility.MatchType(1) + + MATCH_ANY = Accessibility.MatchType(2) + + MATCH_EMPTY = Accessibility.MatchType(4) + + MATCH_INVALID = Accessibility.MatchType(0) + + MATCH_LAST_DEFINED = Accessibility.MatchType(5) + + MATCH_NONE = Accessibility.MatchType(3) + + class MatchType(Enum): + _enum_lookup = { + 0:'MATCH_INVALID', + 1:'MATCH_ALL', + 2:'MATCH_ANY', + 3:'MATCH_NONE', + 4:'MATCH_EMPTY', + 5:'MATCH_LAST_DEFINED', + } + + + SORT_ORDER_CANONICAL = Accessibility.SortOrder(1) + + SORT_ORDER_FLOW = Accessibility.SortOrder(2) + + SORT_ORDER_INVALID = Accessibility.SortOrder(0) + + SORT_ORDER_LAST_DEFINED = Accessibility.SortOrder(7) + + SORT_ORDER_REVERSE_CANONICAL = Accessibility.SortOrder(4) + + SORT_ORDER_REVERSE_FLOW = Accessibility.SortOrder(5) + + SORT_ORDER_REVERSE_TAB = Accessibility.SortOrder(6) + + SORT_ORDER_TAB = Accessibility.SortOrder(3) + + class SortOrder(Enum): + _enum_lookup = { + 0:'SORT_ORDER_INVALID', + 1:'SORT_ORDER_CANONICAL', + 2:'SORT_ORDER_FLOW', + 3:'SORT_ORDER_TAB', + 4:'SORT_ORDER_REVERSE_CANONICAL', + 5:'SORT_ORDER_REVERSE_FLOW', + 6:'SORT_ORDER_REVERSE_TAB', + 7:'SORT_ORDER_LAST_DEFINED', + } + + + TREE_INORDER = Accessibility.TreeTraversalType(2) + + TREE_LAST_DEFINED = Accessibility.TreeTraversalType(3) + + TREE_RESTRICT_CHILDREN = Accessibility.TreeTraversalType(0) + + TREE_RESTRICT_SIBLING = Accessibility.TreeTraversalType(1) + + class TreeTraversalType(Enum): + _enum_lookup = { + 0:'TREE_RESTRICT_CHILDREN', + 1:'TREE_RESTRICT_SIBLING', + 2:'TREE_INORDER', + 3:'TREE_LAST_DEFINED', + } + + +class Command(list): + def __new__(cls, name, id): + list.__new__(cls, (name, id) + def __init__(self, name, id): + list.__init__(self, (name, id)) + + name = property(fget=_get_name, fset=_set_name) + def _get_name(self): + return self[0] + def _set_name(self, val): + self[0] = val + id = property(fget=_get_id, fset=_set_id) + def _get_id(self): + return self[1] + def _set_id(self, val): + self[1] = val + + +class CommandListener(BaseProxy): + + + """ + An interface which should be implemented by assistive technologies + or other clients of the Selector interface, over which notifications + to the list of available commands is made. The notifyCommands() + method of the client is then called by the Selector instance. + """ + + + def notifyCommands(self, *args, **kwargs): + """ + Notify the CommandListener instance of changes to the currently + available commands, by sending the current CommandList. + @param : commands + The newly-available list of Command objects which may be invoked + by the listener. + """ + func = self.get_dbus_method("notifyCommands") + return func(*args, **kwargs) + + +class Component(BaseProxy): + + + """ + The Component interface is implemented by objects which occupy + on-screen space, e.g. objects which have onscreen visual representations. + The methods in Component allow clients to identify where the + objects lie in the onscreen coordinate system, their relative + size, stacking order, and position. It also provides a mechanism + whereby keyboard focus may be transferred to specific user interface + elements programmatically. This is a 2D API, coordinates of 3D + objects are projected into the 2-dimensional screen view for + purposes of this interface. + """ + + + def contains(self, *args, **kwargs): + """ + @return True if the specified point lies within the Component's + bounding box, False otherwise. + """ + func = self.get_dbus_method("contains") + return func(*args, **kwargs) + + def deregisterFocusHandler(self, *args, **kwargs): + """ + Request that an EventListener registered via registerFocusHandler + no longer be notified when this object receives keyboard focus. + """ + func = self.get_dbus_method("deregisterFocusHandler") + return func(*args, **kwargs) + + def getAccessibleAtPoint(self, *args, **kwargs): + """ + @return the Accessible child whose bounding box contains the + specified point. + """ + func = self.get_dbus_method("getAccessibleAtPoint") + return func(*args, **kwargs) + + def getAlpha(self, *args, **kwargs): + """ + Obtain the alpha value of the component. An alpha value of 1.0 + or greater indicates that the object is fully opaque, and an + alpha value of 0.0 indicates that the object is fully transparent. + Negative alpha values have no defined meaning at this time. + """ + func = self.get_dbus_method("getAlpha") + return func(*args, **kwargs) + + def getExtents(self, *args, **kwargs): + """ + Obtain the Component's bounding box, in pixels, relative to the + specified coordinate system. + @return a BoundingBox which entirely contains the object's onscreen + visual representation. + """ + func = self.get_dbus_method("getExtents") + return func(*args, **kwargs) + + def getLayer(self, *args, **kwargs): + """ + @return the ComponentLayer in which this object resides. + """ + func = self.get_dbus_method("getLayer") + return func(*args, **kwargs) + + def getMDIZOrder(self, *args, **kwargs): + """ + Obtain the relative stacking order (i.e. 'Z' order) of an object. + Larger values indicate that an object is on "top" of the stack, + therefore objects with smaller MDIZOrder may be obscured by objects + with a larger MDIZOrder, but not vice-versa. + @return an integer indicating the object's place in the stacking + order. + """ + func = self.get_dbus_method("getMDIZOrder") + return func(*args, **kwargs) + + def getPosition(self, *args, **kwargs): + """ + Obtain the position of the current component in the coordinate + system specified by coord_type. + @param : coord_type + @param : x + an out parameter which will be back-filled with the returned + x coordinate. + @param : y + an out parameter which will be back-filled with the returned + y coordinate. + """ + func = self.get_dbus_method("getPosition") + return func(*args, **kwargs) + + def getSize(self, *args, **kwargs): + """ + Obtain the size, in the coordinate system specified by coord_type, + of the rectangular area which fully contains the object's visual + representation, without accounting for viewport clipping. + @param : width + the object's horizontal extents in the specified coordinate system. + @param : height + the object's vertical extents in the specified coordinate system. + """ + func = self.get_dbus_method("getSize") + return func(*args, **kwargs) + + def grabFocus(self, *args, **kwargs): + """ + Request that the object obtain keyboard focus. + @return True if keyboard focus was successfully transferred to + the Component. + """ + func = self.get_dbus_method("grabFocus") + return func(*args, **kwargs) + + def registerFocusHandler(self, *args, **kwargs): + """ + Register an EventListener for notification when this object receives + keyboard focus. + """ + func = self.get_dbus_method("registerFocusHandler") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + +class ComponentLayer(Enum): + _enum_lookup = { + 0:'LAYER_INVALID', + 1:'LAYER_BACKGROUND', + 2:'LAYER_CANVAS', + 3:'LAYER_WIDGET', + 4:'LAYER_MDI', + 5:'LAYER_POPUP', + 6:'LAYER_OVERLAY', + 7:'LAYER_WINDOW', + 8:'LAYER_LAST_DEFINED', + } + + +class ContentStream(BaseProxy): + + + """ + An interface by which the requested data from a StreamableContent + object may be read by the client. + """ + + + def close(self, *args, **kwargs): + """ + close the stream and release associated resources. A client should + not perform further operations on a StreamableContent::Stream + object after closing it. + """ + func = self.get_dbus_method("close") + return func(*args, **kwargs) + + def read(self, *args, **kwargs): + """ + Request/read a specified amount of data from a Stream. + @return the number of bytes actually read into the client buffer. + """ + func = self.get_dbus_method("read") + return func(*args, **kwargs) + + def seek(self, *args, **kwargs): + """ + Seek to a specified position in the Stream. + @param : offset + an offset specifying the requested position in the stream, relative + to the SeekType specified in whence. + @param : whence + a SeekType specifying the reference point from which the seek + offset is calculated. Some forms of seek are not supported by + certain implementations of Stream, in which case a NotSupported + exception will be raised. + @return the actual resulting offset, if no exception was raised. + """ + func = self.get_dbus_method("seek") + return func(*args, **kwargs) + + def unimplemented(self, *args, **kwargs): + """ + /cond + """ + func = self.get_dbus_method("unimplemented") + return func(*args, **kwargs) + + def unimplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unimplemented2") + return func(*args, **kwargs) + + class IOError(Exception): + pass + + class NoPermission(Exception): + pass + + class NotSupported(Exception): + pass + + SEEK_CURRENT = Accessibility.SeekType(1) + + SEEK_END = Accessibility.SeekType(2) + + SEEK_SET = Accessibility.SeekType(0) + + class SeekType(Enum): + """ + Specifies the meaning of a seek 'offset'. Not all SeekTypes are + supported by all StreamableContent data sources, for instance + some streams may not support seeking from the beginning or other + types of 'backwards' seeks. + """ + + _enum_lookup = { + 0:'SEEK_SET', + 1:'SEEK_CURRENT', + 2:'SEEK_END', + } + +class Desktop(Accessible): + + + """ + At the moment this is only a marker interface, it acts just like + any other Accessible. In all known implementations, the children + are all instances of Application, but this is not guaranteed + by this interface. + """ + + + def unImplemented2_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2_") + return func(*args, **kwargs) + + def unImplemented3_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3_") + return func(*args, **kwargs) + + def unImplemented4_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4_") + return func(*args, **kwargs) + + def unImplemented_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_") + return func(*args, **kwargs) + + +class DeviceEvent(list): + def __new__(cls, type, id, hw_code, modifiers, timestamp, event_string, is_text): + list.__new__(cls, (type, id, hw_code, modifiers, timestamp, event_string, is_text) + def __init__(self, type, id, hw_code, modifiers, timestamp, event_string, is_text): + list.__init__(self, (type, id, hw_code, modifiers, timestamp, event_string, is_text)) + + type = property(fget=_get_type, fset=_set_type) + def _get_type(self): + return self[0] + def _set_type(self, val): + self[0] = val + id = property(fget=_get_id, fset=_set_id) + def _get_id(self): + return self[1] + def _set_id(self, val): + self[1] = val + hw_code = property(fget=_get_hw_code, fset=_set_hw_code) + def _get_hw_code(self): + return self[2] + def _set_hw_code(self, val): + self[2] = val + modifiers = property(fget=_get_modifiers, fset=_set_modifiers) + def _get_modifiers(self): + return self[3] + def _set_modifiers(self, val): + self[3] = val + timestamp = property(fget=_get_timestamp, fset=_set_timestamp) + def _get_timestamp(self): + return self[4] + def _set_timestamp(self, val): + self[4] = val + event_string = property(fget=_get_event_string, fset=_set_event_string) + def _get_event_string(self): + return self[5] + def _set_event_string(self, val): + self[5] = val + is_text = property(fget=_get_is_text, fset=_set_is_text) + def _get_is_text(self): + return self[6] + def _set_is_text(self, val): + self[6] = val + + +class DeviceEventController(BaseProxy): + + + """ + The interface via which clients request notification of device + events, and through which device events may be simulated. + """ + + + def deregisterDeviceEventListener(self, *args, **kwargs): + """ + De-register a previously registered keyboard eventlistener. + @param : listener + a DeviceEventListener which will intercept events. + @param : typeseq + an EventTypeSeq indicating which event types to stop listening + for. + """ + func = self.get_dbus_method("deregisterDeviceEventListener") + return func(*args, **kwargs) + + def deregisterKeystrokeListener(self, *args, **kwargs): + """ + De-register a previously registered keyboard eventlistener. + @param : listener + a DeviceEventListener which will intercept key events. + @param : keys + a KeySet indicating which keys to intercept, or KEYSET_ALL_KEYS. + @param : mask + a ControllerEventMask filtering the intercepted key events. + @param : type + an EventType mask that may created by ORing event types together. + """ + func = self.get_dbus_method("deregisterKeystrokeListener") + return func(*args, **kwargs) + + def generateKeyboardEvent(self, *args, **kwargs): + """ + Synthesize a keyboard event. + @param : keycode + a long integer indicating the keycode of the keypress to be synthesized. + @param : keystring + an optional UTF-8 string indicating a complex keyboard input + event. + @param : type + a KeySynthType indicating the type of event(s) to be synthesized: + a key press, release, press-release pair, or a complex input + string (for instance from an internationalized or complex text + input method, or a composed character). + """ + func = self.get_dbus_method("generateKeyboardEvent") + return func(*args, **kwargs) + + def generateMouseEvent(self, *args, **kwargs): + """ + Synthesize a mouse event. + @param : x + a long integer indicating the screen x coord for the mouse event. + @param : y + a long integer indicating the screen y coord for the mouse event. + @param : eventName + a string indicating the type of mouse event, e.g. "button1up" + """ + func = self.get_dbus_method("generateMouseEvent") + return func(*args, **kwargs) + + def notifyListenersAsync(self, *args, **kwargs): + """ + Notify the Registry instance that a device event has taken place + in an asynchronous manner. This is the method used by accessibility + bridges to forward "toolkit dependent" device events to the Registry + from the application's process space. If the event in question + is potentially pre-emptible. notifyListenersSync should be used + instead. + """ + func = self.get_dbus_method("notifyListenersAsync") + return func(*args, **kwargs) + + def notifyListenersSync(self, *args, **kwargs): + """ + Notify the Registry instance that a device event has taken place, + and allow pre-emptive listeners the opportunity to 'consume' + the event and thus prevent its further issuance/forwarding. This + is the method used by accessibility bridges to forward "toolkit + dependent" device events to the Registry from the application's + process space. + @return True if the event was consumed by a (pre-emptive) listener, + False if not (in which case the device event will be forwarded + as normal to any application which would normally receive it, + e.g. the currently active application in the case of mouse or + keyboard events). + """ + func = self.get_dbus_method("notifyListenersSync") + return func(*args, **kwargs) + + def registerDeviceEventListener(self, *args, **kwargs): + """ + Register to intercept events, and either pass them on or consume + them. To listen to keyboard events use registerKeystrokeListener + instead. + @param : listener + a DeviceEventListener which will intercept events. + @param : typeseq + an EventTypeSeq indicating which event types to listen for. + @return True if successful, False if not + """ + func = self.get_dbus_method("registerDeviceEventListener") + return func(*args, **kwargs) + + def registerKeystrokeListener(self, *args, **kwargs): + """ + Register to intercept keyboard events, and either pass them on + or consume them. + @param : listener + a DeviceEventListener which will intercept key events. + @param : keys + a KeySet indicating which keys to intercept, or KEYSET_ALL_KEYS. + @param : mask + a ControllerEventMask filtering the intercepted key events. + @param : type + a KeyEventTypeSeq that may created by ORing event types together. + @param : mode + an EventListenerMode indicating whether the listener should receive + the events synchronously, potentially consuming them, or just + be notified asynchronously of those events that have been generated. + @return True if the DeviceEventListener was successfully registered + for the requested KeySet, ControllerEventMask, event types, and + EventListenerMode; otherwise returns False. + """ + func = self.get_dbus_method("registerKeystrokeListener") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + +class DeviceEventListener(BaseProxy): + + + """ + This interface should be implemented by AT-SPI clients who wish + to make use of the DeviceEventController to receive device event + notifications. DeviceEvents include keyboard events and mouse + button/motion events. + """ + + + def notifyEvent(self, *args, **kwargs): + """ + Notify an interested DeviceEventListener that a DeviceEvent has + occurred. + @return True if the recipient/consumer wishes to consume the + event, i.e. prevent it from being delivered to the desktop, False + if the event should continue to be delivered as normal. + """ + func = self.get_dbus_method("notifyEvent") + return func(*args, **kwargs) + + def unImplemented_2_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_2_") + return func(*args, **kwargs) + + def unImplemented_3_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_3_") + return func(*args, **kwargs) + + def unImplemented_4_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_4_") + return func(*args, **kwargs) + + def unImplemented_5_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_5_") + return func(*args, **kwargs) + + def unImplemented_6_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_6_") + return func(*args, **kwargs) + + def unImplemented__(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented__") + return func(*args, **kwargs) + + +class Document(BaseProxy): + + + """ + Primarily a 'tagging' interface which indicates the start of + document content in the Accessibility hierarchy. Accessible objects + below the node implementing Document are normally assumed to + be part of the document content. Attributes of Document are those + attributes associated with the document as a whole. Objects that + implement Document are normally expected to implement Collection + as well. + """ + + + def getAttributeValue(self, *args, **kwargs): + """ + Gets the value of a single attribute, if specified for the document + as a whole. + @param : attributename + a string indicating the name of a specific attribute (name-value + pair) being queried. + @return a string corresponding to the value of the specified + attribute, or an empty string if the attribute is unspecified + for the object. + """ + func = self.get_dbus_method("getAttributeValue") + return func(*args, **kwargs) + + def getAttributes(self, *args, **kwargs): + """ + Gets all attributes specified for a document as a whole. For + attributes which change within the document content, see Accessibility::Text::getAttributes + instead. + @return an AttributeSet containing the attributes of the document, + as name-value pairs. + """ + func = self.get_dbus_method("getAttributes") + return func(*args, **kwargs) + + def getLocale(self, *args, **kwargs): + """ + Gets the locale associated with the document's content. e.g. + the locale for LOCALE_TYPE_MESSAGES. + @return a string compliant with the POSIX standard for locale + description. + """ + func = self.get_dbus_method("getLocale") + return func(*args, **kwargs) + + def unImplemented2_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2_") + return func(*args, **kwargs) + + def unImplemented3_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3_") + return func(*args, **kwargs) + + def unImplemented4_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4_") + return func(*args, **kwargs) + + def unImplemented_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_") + return func(*args, **kwargs) + + +class EditableText(Text): + + + """ + Derived from interface Text, EditableText provides methods for + modifying textual content of components which support editing. + EditableText also interacts with the system clipboard via copyText, + cutText, and pasteText. + """ + + + def copyText(self, *args, **kwargs): + """ + Copy a range of text into the system clipboard. + @param : startPos + the character offset of the first character in the range of text + being copied. + @param : endPos + the offset of the first character past the end of the range of + text being copied. + """ + func = self.get_dbus_method("copyText") + return func(*args, **kwargs) + + def cutText(self, *args, **kwargs): + """ + Excise a range of text from a Text object, copying it into the + system clipboard. + @param : startPos + the character offset of the first character in the range of text + being cut. + @param : endPos + the offset of the first character past the end of the range of + text being cut. + @return True if the text was successfully cut, False otherwise. + """ + func = self.get_dbus_method("cutText") + return func(*args, **kwargs) + + def deleteText(self, *args, **kwargs): + """ + Excise a range of text from a Text object without copying it + into the system clipboard. + @param : startPos + the character offset of the first character in the range of text + being deleted. + @param : endPos + the offset of the first character past the end of the range of + text being deleted. + @return True if the text was successfully deleted, False otherwise. + """ + func = self.get_dbus_method("deleteText") + return func(*args, **kwargs) + + def insertText(self, *args, **kwargs): + """ + Insert new text contents into an existing text object at a given + location, while retaining the old contents. + @param : position + the character offset into the Text implementor's content at which + the new content will be inserted. + @param : text + a UTF-8 string of which length characters will be inserted into + the text object's text buffer. + @param : length + the number of characters of text to insert. If the character + count of text is less than or equal to length, the entire contents + of text will be inserted. + @return True if the text content was successfully inserted, False + otherwise. + """ + func = self.get_dbus_method("insertText") + return func(*args, **kwargs) + + def pasteText(self, *args, **kwargs): + """ + Copy the text contents of the system clipboard, if any, into + a Text object, inserting it at a particular character offset. + @param : position + the character offset before which the text will be inserted. + @return True if the text was successfully pasted into the Text + object, False otherwise. + """ + func = self.get_dbus_method("pasteText") + return func(*args, **kwargs) + + def setAttributes(self, *args, **kwargs): + """ + Apply a particular set of attributes to a range of text. + @return True if the text attributes were successfully modified, + False otherwise. + """ + func = self.get_dbus_method("setAttributes") + return func(*args, **kwargs) + + def setTextContents(self, *args, **kwargs): + """ + Replace the text contents with a new string, discarding the old + contents. + @param : newContents + a UTF-8 string with which the text object's contents will be + replaced. + @return True if the text content was successfully changed, False + otherwise. + """ + func = self.get_dbus_method("setTextContents") + return func(*args, **kwargs) + + def unImplemented10(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented10") + return func(*args, **kwargs) + + def unImplemented11(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented11") + return func(*args, **kwargs) + + def unImplemented12(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented12") + return func(*args, **kwargs) + + def unImplemented5(self, *args, **kwargs): + """ + unImplemented: + placeholders for future expansion. Note that these are named + 'unimplemented5 and unimplemented6' to avoid conflict with placeholders + from Accessibility::Text. + """ + func = self.get_dbus_method("unImplemented5") + return func(*args, **kwargs) + + def unImplemented6(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented6") + return func(*args, **kwargs) + + def unImplemented9(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented9") + return func(*args, **kwargs) + + +class Event(list): + def __new__(cls, type, source, detail1, detail2, any_data): + list.__new__(cls, (type, source, detail1, detail2, any_data) + def __init__(self, type, source, detail1, detail2, any_data): + list.__init__(self, (type, source, detail1, detail2, any_data)) + + type = property(fget=_get_type, fset=_set_type) + def _get_type(self): + return self[0] + def _set_type(self, val): + self[0] = val + source = property(fget=_get_source, fset=_set_source) + def _get_source(self): + return self[1] + def _set_source(self, val): + self[1] = val + detail1 = property(fget=_get_detail1, fset=_set_detail1) + def _get_detail1(self): + return self[2] + def _set_detail1(self, val): + self[2] = val + detail2 = property(fget=_get_detail2, fset=_set_detail2) + def _get_detail2(self): + return self[3] + def _set_detail2(self, val): + self[3] = val + any_data = property(fget=_get_any_data, fset=_set_any_data) + def _get_any_data(self): + return self[4] + def _set_any_data(self, val): + self[4] = val + + +class EventDetails(list): + def __new__(cls, host_application, source_role, source_name, any_data): + list.__new__(cls, (host_application, source_role, source_name, any_data) + def __init__(self, host_application, source_role, source_name, any_data): + list.__init__(self, (host_application, source_role, source_name, any_data)) + + host_application = property(fget=_get_host_application, fset=_set_host_application) + def _get_host_application(self): + return self[0] + def _set_host_application(self, val): + self[0] = val + source_role = property(fget=_get_source_role, fset=_set_source_role) + def _get_source_role(self): + return self[1] + def _set_source_role(self, val): + self[1] = val + source_name = property(fget=_get_source_name, fset=_set_source_name) + def _get_source_name(self): + return self[2] + def _set_source_name(self, val): + self[2] = val + any_data = property(fget=_get_any_data, fset=_set_any_data) + def _get_any_data(self): + return self[3] + def _set_any_data(self, val): + self[3] = val + + +class EventListener(BaseProxy): + + + """ + A generic interface implemented by objects for the receipt of + event notifications. EventListener is the interface from which + Accessibility::Registry is derived, and via which clients of + the Registry receive notification of changes to an application's + user interface and content. + """ + + + def notifyEvent(self, *args, **kwargs): + """ + Synchronously notify an EventListener that an event has occurred, + by passing it an Event struct. + @param : e + The Event about which the listener is being notified. + """ + func = self.get_dbus_method("notifyEvent") + return func(*args, **kwargs) + + def unImplemented2_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2_") + return func(*args, **kwargs) + + def unImplemented3_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3_") + return func(*args, **kwargs) + + def unImplemented4_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4_") + return func(*args, **kwargs) + + def unImplemented_(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented_") + return func(*args, **kwargs) + + +class EventListenerMode(list): + def __new__(cls, synchronous, preemptive, global): + list.__new__(cls, (synchronous, preemptive, global) + def __init__(self, synchronous, preemptive, global): + list.__init__(self, (synchronous, preemptive, global)) + + synchronous = property(fget=_get_synchronous, fset=_set_synchronous) + def _get_synchronous(self): + return self[0] + def _set_synchronous(self, val): + self[0] = val + preemptive = property(fget=_get_preemptive, fset=_set_preemptive) + def _get_preemptive(self): + return self[1] + def _set_preemptive(self, val): + self[1] = val + global = property(fget=_get_global, fset=_set_global) + def _get_global(self): + return self[2] + def _set_global(self, val): + self[2] = val + + +class EventType(Enum): + _enum_lookup = { + 0:'KEY_PRESSED_EVENT', + 1:'KEY_RELEASED_EVENT', + 2:'BUTTON_PRESSED_EVENT', + 3:'BUTTON_RELEASED_EVENT', + } + + +class Hyperlink(BaseProxy): + + + """ + Instances of Hyperlink are returned by Hypertext objects, and + are the means by which end users and clients interact with linked, + and in some cases embedded, content. Hyperlinks may have multiple + "anchors", where an anchor corresponds to a reference to a particular + resource with a corresponding resource identified (URI). Hyperlinks + may be queried for their URIs, or queried for the objects corresponding + to their anchors. The objects thus obtained are instances of + Accessible, and may be queried, and manipulated via the Action + interface. + """ + + + def getObject(self, *args, **kwargs): + """ + Gets the i'th object, (where i is an integer between 0 and Hyperlink::numAnchors + - 1, inclusive) associated with a Hyperlink. The objects returned + are usually actionable (i.e. they should implement Accessibility::Action), + and the available actions often include "open", "bookmark", "save + link as", etc. They may also implement Accessibility::StreamableContent, + although clients can normally use getURI to obtain a resource + locator via which the object's data may be accessed. + @return an Accessible object instance representing the Hyperlink's + ith anchor, or through which the content associated with the + ith anchor can be accessed. + """ + func = self.get_dbus_method("getObject") + return func(*args, **kwargs) + + def getURI(self, *args, **kwargs): + """ + Obtain a resource locator ('URI') which can be used to access + the content to which this link "points" or is connected. + @return a string corresponding to the URI of the Hyperlink's + 'ith' anchor, if one exists, or a NIL string otherwise. + """ + func = self.get_dbus_method("getURI") + return func(*args, **kwargs) + + def isValid(self, *args, **kwargs): + """ + Check the hyperlink to see if a connection to its backing content + can be established, or if its URI is valid. + @return True if the object's content is available, or False if + the hyperlink's URI is invalid, or a connection to the resource + can not be established. + """ + func = self.get_dbus_method("isValid") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + def get_endIndex(self): + self._pgetter(self._dbus_interface, "endIndex") + def set_endIndex(self, value): + self._psetter(self._dbus_interface, "endIndex", value) + _endIndexDoc = \ + """ + the ending offset within the containing Hypertext content with + which this Hyperlink is associated; that is, the offset of the + first element past the range within the Hypertext associated + with this Hyperlink. + """ + endIndex = property(fget=get_endIndex, fset=set_endIndex, doc=_endIndexDoc) + + def get_nAnchors(self): + self._pgetter(self._dbus_interface, "nAnchors") + def set_nAnchors(self, value): + self._psetter(self._dbus_interface, "nAnchors", value) + _nAnchorsDoc = \ + """ + the number of separate anchors associated with this Hyperlink + """ + nAnchors = property(fget=get_nAnchors, fset=set_nAnchors, doc=_nAnchorsDoc) + + def get_startIndex(self): + self._pgetter(self._dbus_interface, "startIndex") + def set_startIndex(self, value): + self._psetter(self._dbus_interface, "startIndex", value) + _startIndexDoc = \ + """ + the starting offset within the containing Hypertext content with + which this Hyperlink is associated + """ + startIndex = property(fget=get_startIndex, fset=set_startIndex, doc=_startIndexDoc) + + +class Hypertext(BaseProxy): + + + """ + An interface used for objects which implement linking between + multiple resource or content locations, or multiple 'markers' + within a single document. A Hypertext instance is associated + with one or more Hyperlinks, which are associated with particular + offsets within the Hypertext's included content. + """ + + + def getLink(self, *args, **kwargs): + """ + Get one of the Hyperlinks associated with this Hypertext object, + by index. + @param : linkIndex + an integer from 0 to getNLinks() - 1. + @return the Hyperlink in this Hypertext object. + """ + func = self.get_dbus_method("getLink") + return func(*args, **kwargs) + + def getLinkIndex(self, *args, **kwargs): + """ + Get the hyperlink index, if any, associated with a particular + character offset in the Hypertext object. For Hypertext implementors + without textual content, all hyperlinks are associated with character + offset '0'. + @return the index of the Hyperlink associated with character + offset characterIndex, or -1 if no Hyperlink is associated with + that character offset. + """ + func = self.get_dbus_method("getLinkIndex") + return func(*args, **kwargs) + + def getNLinks(self, *args, **kwargs): + """ + Query the hypertext object for the number of Hyperlinks it contains. + @return the number of Hyperlinks associated with this Hypertext + object, as a long integer. + """ + func = self.get_dbus_method("getNLinks") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + +class Image(BaseProxy): + + + """ + An interface implemented by objects which render image data or + pictorial information to the screen. When onscreen components + include graphical information that is not purely intended to + enhance "3d effect" or visual layout, but which conveys some + semantic or informational content to the sighted user, they should + implement Image, and that semantic content should be conveyed + textually to the extent possible via the image description, as + well as the Accessible::name and Accessible::description properties. + """ + + + def getImageExtents(self, *args, **kwargs): + """ + Obtain a bounding box which entirely contains the image contents, + as displayed on screen. The bounds returned do not account for + any viewport clipping or the fact that the image may be partially + or wholly obscured by other onscreen content. + @param : coordType + If 0, the returned bounding box position is returned relative + to the screen; if 1, the bounding box position is returned relative + to the containing window. + @return a BoundingBox enclosing the image's onscreen representation. + """ + func = self.get_dbus_method("getImageExtents") + return func(*args, **kwargs) + + def getImagePosition(self, *args, **kwargs): + """ + Get the coordinates of the current image position on screen. + @param : x + Back-filled with the x coordinate of the onscreen image (i.e. + the minimum x coordinate) + @param : y + Back-filled with the y coordinate of the onscreen image (i.e. + the minimum y coordinate) + @param : coordType + If 0, the returned x and y coordinates are returned relative + to the screen; if 1, they are returned relative to the containing + window. + """ + func = self.get_dbus_method("getImagePosition") + return func(*args, **kwargs) + + def getImageSize(self, *args, **kwargs): + """ + Obtain the width and height of the current onscreen view of the + image. The extents returned do not account for any viewport clipping + or the fact that the image may be partially or wholly obscured + by other onscreen content. + @param : width + Back-filled with the x extents of the onscreen image (i.e. the + image width in pixels) + @param : height + Back-filled with the y extents of the onscreen image (i.e. the + image height in pixels) + """ + func = self.get_dbus_method("getImageSize") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def get_imageDescription(self): + self._pgetter(self._dbus_interface, "imageDescription") + def set_imageDescription(self, value): + self._psetter(self._dbus_interface, "imageDescription", value) + _imageDescriptionDoc = \ + """ + A UTF-8 string providing a textual description of what is visually + depicted in the image. + """ + imageDescription = property(fget=get_imageDescription, fset=set_imageDescription, doc=_imageDescriptionDoc) + + def get_imageLocale(self): + self._pgetter(self._dbus_interface, "imageLocale") + def set_imageLocale(self, value): + self._psetter(self._dbus_interface, "imageLocale", value) + _imageLocaleDoc = \ + """ + A string corresponding to the POSIX LC_MESSAGES locale used by + the imageDescription. + """ + imageLocale = property(fget=get_imageLocale, fset=set_imageLocale, doc=_imageLocaleDoc) + + +class KeyDefinition(list): + def __new__(cls, keycode, keysym, keystring, unused): + list.__new__(cls, (keycode, keysym, keystring, unused) + def __init__(self, keycode, keysym, keystring, unused): + list.__init__(self, (keycode, keysym, keystring, unused)) + + keycode = property(fget=_get_keycode, fset=_set_keycode) + def _get_keycode(self): + return self[0] + def _set_keycode(self, val): + self[0] = val + keysym = property(fget=_get_keysym, fset=_set_keysym) + def _get_keysym(self): + return self[1] + def _set_keysym(self, val): + self[1] = val + keystring = property(fget=_get_keystring, fset=_set_keystring) + def _get_keystring(self): + return self[2] + def _set_keystring(self, val): + self[2] = val + unused = property(fget=_get_unused, fset=_set_unused) + def _get_unused(self): + return self[3] + def _set_unused(self, val): + self[3] = val + + +class KeyEventType(Enum): + _enum_lookup = { + 0:'KEY_PRESSED', + 1:'KEY_RELEASED', + } + + +class KeySynthType(Enum): + _enum_lookup = { + 0:'KEY_PRESS', + 1:'KEY_RELEASE', + 2:'KEY_PRESSRELEASE', + 3:'KEY_SYM', + 4:'KEY_STRING', + } + + +class LOCALE_TYPE(Enum): + _enum_lookup = { + 0:'LOCALE_TYPE_MESSAGES', + 1:'LOCALE_TYPE_COLLATE', + 2:'LOCALE_TYPE_CTYPE', + 3:'LOCALE_TYPE_MONETARY', + 4:'LOCALE_TYPE_NUMERIC', + 5:'LOCALE_TYPE_TIME', + } + + +class LoginHelper(BaseProxy): + + + """ + An interface for use by assistive technologies by which they + can access system information and services on a 'need to know' + basis while the screen is locked, during user authentication, + or during other sensitive operations. + This interface is intended for use by assistive technologies + and related user-enabling services, and by applications and utilities + which may wish to restrict access to certain system devices and + services during security-sensitive states, e.g. when the screen + is locked or during authentication into some secure service. + Such 'applications' (for instance, screen lock dialogs and security-enabled + web browsers) use the LoginHelper client interfaces, and the + bonobo-activation query service, to query for assistive technologies + which advertise the LoginHelper service. The client then queries + these assistive technologies for their device I/O requirements, + via the getDeviceReqs call. The client may then issue the advisory + request setSafe (TRUE), which requests that the LoginHelper -implementing + service make a best-effort attempt to make itself more secure + (for instance, an onscreen keyboard might turn off word prediction, + and a screenreader may turn off keyboard echo via speech). The + return value of setSafe is an advisory indication of whether + this attempt was successful (no specific guarantees are implied). + Once the 'security sensitive' state is exited, the client should + call setSafe (FALSE). + The return values from getDeviceReqs inform the client of which + services the LoginHelper service (e. g. assistive technology) + needs in order to do its job. The client may use this information + to loosen any restrictions on access which it may currently have + in place (for instance, keyboard grabs, etc.). If it does not + do so, the likely outcome is that the end-user will experience + loss of access to the system. + """ + + + def getDeviceReqs(self, *args, **kwargs): + """ + getDeviceReqs: + Query a LoginHelper for the types of device I/O it requires, + in order to do its job. For instance, a LoginHelper which needs + to receive keyboard events will include Accessibility_LoginHelper_CORE_KEYBOARD + in this list. + @return : A sequence of LoginHelper_DeviceReq indicating the + device I/O required in order to facilitate end-user access to + the system. + """ + func = self.get_dbus_method("getDeviceReqs") + return func(*args, **kwargs) + + def getRaiseWindows(self, *args, **kwargs): + """ + getRaiseWindows: + Get a list of window IDs that need raising on login. + @return : a sequence containing window IDS for toplevels which + need to be raised/made visible during user authentication, in + order for the LoginHelper to facilitate end-user access to the + system. + """ + func = self.get_dbus_method("getRaiseWindows") + return func(*args, **kwargs) + + def setSafe(self, *args, **kwargs): + """ + setSafe: + @param : safe_mode + TRUE if the client is requesting that 'safe mode' be initiated, + FALSE if the client is advising that 'safe mode' may be exited, + i.e. normal operation may be resumed. + Request a LoginHelper to enter "safe" mode, or inform LoginHelper + that "safe" mode may be exited. If safe_mode is TRUE, but the + return value is FALSE, the requesting client may wish to deny + services to the LoginHelper, for instance avoid raising its toplevels. + The return value is purely advisory, and no guarantees are intended + about what the implementing LoginHelper will do to improve security + when in "safe" mode. + @return : whether the LoginHelper is now "safe" or not. + """ + func = self.get_dbus_method("setSafe") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + AUDIO_IN = Accessibility.DeviceReq(6) + + AUDIO_OUT = Accessibility.DeviceReq(5) + + CORE_KEYBOARD = Accessibility.DeviceReq(1) + + CORE_POINTER = Accessibility.DeviceReq(2) + + class DeviceReq(Enum): + _enum_lookup = { + 0:'GUI_EVENTS', + 1:'CORE_KEYBOARD', + 2:'CORE_POINTER', + 3:'EXT_INPUT', + 4:'POST_WINDOWS', + 5:'AUDIO_OUT', + 6:'AUDIO_IN', + 7:'NETWORK', + 8:'LOCALHOST', + 9:'SERIAL_OUT', + 10:'SERIAL_IN', + } + + + EXT_INPUT = Accessibility.DeviceReq(3) + + GUI_EVENTS = Accessibility.DeviceReq(0) + + LOCALHOST = Accessibility.DeviceReq(8) + + NETWORK = Accessibility.DeviceReq(7) + + POST_WINDOWS = Accessibility.DeviceReq(4) + + SERIAL_IN = Accessibility.DeviceReq(10) + + SERIAL_OUT = Accessibility.DeviceReq(9) + + class WindowInfo(list): + def __new__(cls, winID): + list.__new__(cls, (winID) + def __init__(self, winID): + list.__init__(self, (winID)) + + winID = property(fget=_get_winID, fset=_set_winID) + def _get_winID(self): + return self[0] + def _set_winID(self, val): + self[0] = val + + +class ModifierType(Enum): + _enum_lookup = { + 0:'MODIFIER_SHIFT', + 1:'MODIFIER_SHIFTLOCK', + 2:'MODIFIER_CONTROL', + 3:'MODIFIER_ALT', + 4:'MODIFIER_META', + 5:'MODIFIER_META2', + 6:'MODIFIER_META3', + 7:'MODIFIER_NUMLOCK', + } + + +class Registry(EventListener): + + + """ + The Registry is a service through which applications providing + accessibility services (servers) can rendezvous with consumers + of those services (Assistive Technologies). The Registry is the + first "port of call" for accessible applications and for assistive + technologies wishing to query and interact with those applications. + The Registry service provides four basic functions to Assistive + Technology (AT) clients: + it provides a list of the applications who have registered with + the AT-SPI framework, thereby announcing their participation + in the AT-SPI framework; + it allows AT clients to register for notification of changes + in application state (at-spi Events); + it dispatches/relays said events from participating applications + to the registered listeners; + it gives access to system device events via the associated DeviceEventController + interface. + From the point of view of accessible applications (i.e. AT-SPI + service producers), the Registry is primarily a registration + and event delivery service. Applications normally only call the + registerApplication and deregisterApplication Registry methods, + and its inherited EventListener::notifyEvent method. + The Registry normally lives in its own process space; communication + via Registry and both application services and AT clients takes + place via IPC. A process space diagram illustrating the relationship + between applications, Registry, and AT is shown below. + """ + + + def deregisterApplication(self, *args, **kwargs): + """ + De-register an application previously registered with the broker. + deregisterApplication: + @param : app + a reference to the Application to be deregistered. + """ + func = self.get_dbus_method("deregisterApplication") + return func(*args, **kwargs) + + def deregisterGlobalEventListener(self, *args, **kwargs): + """ + deregisterGlobalEventListener: + @param : listener + the requesting EventListener + @param : eventName + a string indicating the type of events + Request that a previously registered client stop receiving global + notifications for events of a certain type. + """ + func = self.get_dbus_method("deregisterGlobalEventListener") + return func(*args, **kwargs) + + def deregisterGlobalEventListenerAll(self, *args, **kwargs): + """ + deregisterGlobalEventListenerAll: + @param : listener + the requesting EventListener + Request that a previously registered client stop receiving global + notifications for all events for which it was registered. + """ + func = self.get_dbus_method("deregisterGlobalEventListenerAll") + return func(*args, **kwargs) + + def getDesktop(self, *args, **kwargs): + """ + getDesktop: + : the index of the requested Desktop. + Get the nth accessible desktop. + @return a reference to the requested Desktop. + """ + func = self.get_dbus_method("getDesktop") + return func(*args, **kwargs) + + def getDesktopCount(self, *args, **kwargs): + """ + event types: "Window" "Desktop" "Window:Create" "Window:Destroy" + "Window:Iconify" "Window:Restore" "Window:Fullscreen" "Window:Resize" + "Desktop:Create" "Desktop:Destroy" "Desktop:Focus" "Desktop:Defocus" + "Desktop:Reorder" "Focus" "GtkWidget:show" "GObject:notify:" + ( not sure we should allow these last 2 forms, since they are + toolkit-specific, but they're powerful ) getDesktopCount: + Get the current number of desktops. + @return a short integer indicating the current number of Desktops. + """ + func = self.get_dbus_method("getDesktopCount") + return func(*args, **kwargs) + + def getDesktopList(self, *args, **kwargs): + """ + Get a list of accessible desktops. + @return : a sequence containing references to the Desktops. + """ + func = self.get_dbus_method("getDesktopList") + return func(*args, **kwargs) + + def getDeviceEventController(self, *args, **kwargs): + """ + Obtain an object which can be used to request device event notifications. + @return : an object implementing DeviceEventController + """ + func = self.get_dbus_method("getDeviceEventController") + return func(*args, **kwargs) + + def registerApplication(self, *args, **kwargs): + """ + Register a new application with the accessibility broker. + @param : app + a reference to the requesting Application + """ + func = self.get_dbus_method("registerApplication") + return func(*args, **kwargs) + + def registerGlobalEventListener(self, *args, **kwargs): + """ + Register a client's interest in (all) application events of a + certain type. + @param : listener + a reference to the requesting EventListener. + @param : eventName + a string which indicates the type of events about which the client + desires notification. + """ + func = self.get_dbus_method("registerGlobalEventListener") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + def unImplemented5(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented5") + return func(*args, **kwargs) + + def unImplemented6(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented6") + return func(*args, **kwargs) + + +class Relation(BaseProxy): + + + """ + An interface via which objects' non-hierarchical relationships + to one another are indicated. An instance of Relations represents + a "one-to-many" correspondance. + """ + + + def getNTargets(self, *args, **kwargs): + """ + @return the number of objects to which this relationship applies. + """ + func = self.get_dbus_method("getNTargets") + return func(*args, **kwargs) + + def getRelationType(self, *args, **kwargs): + """ + @return the RelationType of this Relation. + """ + func = self.get_dbus_method("getRelationType") + return func(*args, **kwargs) + + def getRelationTypeName(self, *args, **kwargs): + """ + @return an unlocalized string representing the relation type. + """ + func = self.get_dbus_method("getRelationTypeName") + return func(*args, **kwargs) + + def getTarget(self, *args, **kwargs): + """ + @return an Object which is the 'nth'target of this Relation, + e.g. the Object at index i in the list of Objects having the + specified relationship to this Accessible. + """ + func = self.get_dbus_method("getTarget") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + +class RelationType(Enum): + _enum_lookup = { + 0:'RELATION_NULL', + 1:'RELATION_LABEL_FOR', + 2:'RELATION_LABELLED_BY', + 3:'RELATION_CONTROLLER_FOR', + 4:'RELATION_CONTROLLED_BY', + 5:'RELATION_MEMBER_OF', + 6:'RELATION_TOOLTIP_FOR', + 7:'RELATION_NODE_CHILD_OF', + 8:'RELATION_EXTENDED', + 9:'RELATION_FLOWS_TO', + 10:'RELATION_FLOWS_FROM', + 11:'RELATION_SUBWINDOW_OF', + 12:'RELATION_EMBEDS', + 13:'RELATION_EMBEDDED_BY', + 14:'RELATION_POPUP_FOR', + 15:'RELATION_PARENT_WINDOW_OF', + 16:'RELATION_DESCRIPTION_FOR', + 17:'RELATION_DESCRIBED_BY', + 18:'RELATION_LAST_DEFINED', + } + + +class Role(Enum): + _enum_lookup = { + 0:'ROLE_INVALID', + 1:'ROLE_ACCELERATOR_LABEL', + 2:'ROLE_ALERT', + 3:'ROLE_ANIMATION', + 4:'ROLE_ARROW', + 5:'ROLE_CALENDAR', + 6:'ROLE_CANVAS', + 7:'ROLE_CHECK_BOX', + 8:'ROLE_CHECK_MENU_ITEM', + 9:'ROLE_COLOR_CHOOSER', + 10:'ROLE_COLUMN_HEADER', + 11:'ROLE_COMBO_BOX', + 12:'ROLE_DATE_EDITOR', + 13:'ROLE_DESKTOP_ICON', + 14:'ROLE_DESKTOP_FRAME', + 15:'ROLE_DIAL', + 16:'ROLE_DIALOG', + 17:'ROLE_DIRECTORY_PANE', + 18:'ROLE_DRAWING_AREA', + 19:'ROLE_FILE_CHOOSER', + 20:'ROLE_FILLER', + 21:'ROLE_FOCUS_TRAVERSABLE', + 22:'ROLE_FONT_CHOOSER', + 23:'ROLE_FRAME', + 24:'ROLE_GLASS_PANE', + 25:'ROLE_HTML_CONTAINER', + 26:'ROLE_ICON', + 27:'ROLE_IMAGE', + 28:'ROLE_INTERNAL_FRAME', + 29:'ROLE_LABEL', + 30:'ROLE_LAYERED_PANE', + 31:'ROLE_LIST', + 32:'ROLE_LIST_ITEM', + 33:'ROLE_MENU', + 34:'ROLE_MENU_BAR', + 35:'ROLE_MENU_ITEM', + 36:'ROLE_OPTION_PANE', + 37:'ROLE_PAGE_TAB', + 38:'ROLE_PAGE_TAB_LIST', + 39:'ROLE_PANEL', + 40:'ROLE_PASSWORD_TEXT', + 41:'ROLE_POPUP_MENU', + 42:'ROLE_PROGRESS_BAR', + 43:'ROLE_PUSH_BUTTON', + 44:'ROLE_RADIO_BUTTON', + 45:'ROLE_RADIO_MENU_ITEM', + 46:'ROLE_ROOT_PANE', + 47:'ROLE_ROW_HEADER', + 48:'ROLE_SCROLL_BAR', + 49:'ROLE_SCROLL_PANE', + 50:'ROLE_SEPARATOR', + 51:'ROLE_SLIDER', + 52:'ROLE_SPIN_BUTTON', + 53:'ROLE_SPLIT_PANE', + 54:'ROLE_STATUS_BAR', + 55:'ROLE_TABLE', + 56:'ROLE_TABLE_CELL', + 57:'ROLE_TABLE_COLUMN_HEADER', + 58:'ROLE_TABLE_ROW_HEADER', + 59:'ROLE_TEAROFF_MENU_ITEM', + 60:'ROLE_TERMINAL', + 61:'ROLE_TEXT', + 62:'ROLE_TOGGLE_BUTTON', + 63:'ROLE_TOOL_BAR', + 64:'ROLE_TOOL_TIP', + 65:'ROLE_TREE', + 66:'ROLE_TREE_TABLE', + 67:'ROLE_UNKNOWN', + 68:'ROLE_VIEWPORT', + 69:'ROLE_WINDOW', + 70:'ROLE_EXTENDED', + 71:'ROLE_HEADER', + 72:'ROLE_FOOTER', + 73:'ROLE_PARAGRAPH', + 74:'ROLE_RULER', + 75:'ROLE_APPLICATION', + 76:'ROLE_AUTOCOMPLETE', + 77:'ROLE_EDITBAR', + 78:'ROLE_EMBEDDED', + 79:'ROLE_ENTRY', + 80:'ROLE_CHART', + 81:'ROLE_CAPTION', + 82:'ROLE_DOCUMENT_FRAME', + 83:'ROLE_HEADING', + 84:'ROLE_PAGE', + 85:'ROLE_SECTION', + 86:'ROLE_REDUNDANT_OBJECT', + 87:'ROLE_FORM', + 88:'ROLE_LINK', + 89:'ROLE_INPUT_METHOD_WINDOW', + 90:'ROLE_LAST_DEFINED', + } + + +class Selection(BaseProxy): + + + """ + An interface which indicates that an object exposes a 'selection' + model, allowing the selection of one or more of its children. + Read-only Selection instances are possible, in which case the + interface is used to programmatically determine the selected-ness + of its children. A selected child has State::STATE_SELECTED, + and a child which may hypothetically be selected (though possibly + not programmatically selectable) has State::STATE_SELECTABLE. + """ + + + def clearSelection(self, *args, **kwargs): + """ + Attempt to clear all selections (i.e. deselect all children) + of a Selection. Not all Selection implementations allow the removal + of all selections. + @return True if the selections were successfully cleared, False + otherwise. + """ + func = self.get_dbus_method("clearSelection") + return func(*args, **kwargs) + + def deselectChild(self, *args, **kwargs): + """ + Remove a child from the selected children list of a Selection, + if the child is currently selected. + @param : childIndex + a long integer (the zero offset index into the Accessible object's + list of children) indicating which child of the Selection is + to be selected. + @return True if the child was successfully selected, False otherwise. + """ + func = self.get_dbus_method("deselectChild") + return func(*args, **kwargs) + + def deselectSelectedChild(self, *args, **kwargs): + """ + Remove a child to the selected children list of a Selection. + @param : selectedChildIndex + a long integer indicating which of the selected children of the + Selection is to be deselected. The index is a zero-offset index + into the 'selected child list', not a zero-offset index into + the list of all children of the Selection. + @return True if the child was successfully deselected, False + otherwise. + """ + func = self.get_dbus_method("deselectSelectedChild") + return func(*args, **kwargs) + + def getSelectedChild(self, *args, **kwargs): + """ + Get the i-th selected Accessible child of a Selection. + @param : selectedChildIndex + a long integer indicating which of the selected children of an + object is being requested. + @return a pointer to a selected Accessible child object, specified + by selectedChildIndex. + """ + func = self.get_dbus_method("getSelectedChild") + return func(*args, **kwargs) + + def isChildSelected(self, *args, **kwargs): + """ + Determine whether a particular child of an Selection implementor + is currently selected. Note that childIndex is the zero-offset + index into the standard Accessible container's list of children. + @param : childIndex + an index into the Selection's list of children. + @return True if the specified child is currently selected, False + otherwise. + """ + func = self.get_dbus_method("isChildSelected") + return func(*args, **kwargs) + + def selectAll(self, *args, **kwargs): + """ + Attempt to select all of the children of a Selection implementor. + Not all Selection implementors support this operation (for instance, + implementations which support only "single selection" do not + support this operation). + @return True if successful, False otherwise. + """ + func = self.get_dbus_method("selectAll") + return func(*args, **kwargs) + + def selectChild(self, *args, **kwargs): + """ + Add a child to the selected children list of a Selection. + @param : childIndex + a long integer indicating which child of the Selection is to + be selected. + @return True if the child was successfully selected, False otherwise. + """ + func = self.get_dbus_method("selectChild") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + """ + unImplemented: + placeholders for future expansion. + """ + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def get_nSelectedChildren(self): + self._pgetter(self._dbus_interface, "nSelectedChildren") + def set_nSelectedChildren(self, value): + self._psetter(self._dbus_interface, "nSelectedChildren", value) + _nSelectedChildrenDoc = \ + """ + The number of children of a Selection implementor which are currently + selected. + """ + nSelectedChildren = property(fget=get_nSelectedChildren, fset=set_nSelectedChildren, doc=_nSelectedChildrenDoc) + + +class Selector(BaseProxy): + + + """ + This interface is intended for use by assistive technologies + and related user-agents. Via this interface, an assistive technology + or user agent may expose a series of choices or selections in + textual form, which can be activated on demand by a client of + the Selector interface. + Examples of the use of this interface include voice-command and + remote-control applications, in which the user interaction is + wholly or partly delegated by the implementor to an external + agent. + """ + + + def activateCommand(self, *args, **kwargs): + """ + Request that the Selector invoke the specified Command. + @param : cmd + the Command to activate/invoke. + @return a CommandResult indicating whether the request was honored, + and the reason for failure if the Command could not be activated + or invoked. + """ + func = self.get_dbus_method("activateCommand") + return func(*args, **kwargs) + + def deregisterChangeListener(self, *args, **kwargs): + """ + Tell the Selector instance to cease notifying the specified CommandListener + of changes to the command list. + @param : listener + the CommandListener to remove from the notification list. + """ + func = self.get_dbus_method("deregisterChangeListener") + return func(*args, **kwargs) + + def getCommands(self, *args, **kwargs): + """ + Query the Selector for the current CommandList. + @return the currently available CommandList + """ + func = self.get_dbus_method("getCommands") + return func(*args, **kwargs) + + def refreshCommands(self, *args, **kwargs): + """ + Ask the Selector to re-calculate its CommandList. + @return TRUE if the CommandList changed. + """ + func = self.get_dbus_method("refreshCommands") + return func(*args, **kwargs) + + def registerChangeListener(self, *args, **kwargs): + """ + Register a :CommandListener instance for notification of changes + to the command set. + @param : listener + the CommandListener to be notified of changes. + """ + func = self.get_dbus_method("registerChangeListener") + return func(*args, **kwargs) + + def replaceCommands(self, *args, **kwargs): + """ + @return TRUE if the replacement request was successful, FALSE + if the request could not be honored. + """ + func = self.get_dbus_method("replaceCommands") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + def get_supportsReplace(self): + self._pgetter(self._dbus_interface, "supportsReplace") + def set_supportsReplace(self, value): + self._psetter(self._dbus_interface, "supportsReplace", value) + _supportsReplaceDoc = \ + """ + This attribute is TRUE if this Selector allows its CommandList + to be specified by the client + """ + supportsReplace = property(fget=get_supportsReplace, fset=set_supportsReplace, doc=_supportsReplaceDoc) + + COMMAND_RESULT_FAILED = Accessibility.CommandResult(2) + + COMMAND_RESULT_INVALID = Accessibility.CommandResult(0) + + COMMAND_RESULT_LAST_DEFINED = Accessibility.CommandResult(4) + + COMMAND_RESULT_OBSOLETE = Accessibility.CommandResult(3) + + COMMAND_RESULT_SUCCESS = Accessibility.CommandResult(1) + + class CommandResult(Enum): + """ + A code returned by a call to activateCommand, indicating the + result of the activation request. + """ + + _enum_lookup = { + 0:'COMMAND_RESULT_INVALID', + 1:'COMMAND_RESULT_SUCCESS', + 2:'COMMAND_RESULT_FAILED', + 3:'COMMAND_RESULT_OBSOLETE', + 4:'COMMAND_RESULT_LAST_DEFINED', + } + +class StateSet(BaseProxy): + """ + The StateSet interface encapsulates a collection of state information. + It allows comparison of state information between object instances, + and comparisons of an object's state with some hypothetical collection + of states. + """ + + def add(self, *args, **kwargs): + """ + Add a StateType to an existing StateSet, if not already present. + """ + func = self.get_dbus_method("add") + return func(*args, **kwargs) + + def compare(self, *args, **kwargs): + """ + Compare two StateSet instances and obtain their differences. + @return a 'difference set', i.e. a StateSet consisting of those + states not shared by the two sets being compared. + """ + func = self.get_dbus_method("compare") + return func(*args, **kwargs) + + def contains(self, *args, **kwargs): + """ + Query a StateSet for a specific StateType. + @param : state + the StateType being queried for. + @return TRUE if the StateSet contains StateType state. + """ + func = self.get_dbus_method("contains") + return func(*args, **kwargs) + + def equals(self, *args, **kwargs): + """ + Compare two statesets for equivalence. + @param : tarStateSet + the StateSet to be compared with this one. + @return TRUE if the two StateSet objects are composed of the + same StateTypes. + """ + func = self.get_dbus_method("equals") + return func(*args, **kwargs) + + def getStates(self, *args, **kwargs): + func = self.get_dbus_method("getStates") + return func(*args, **kwargs) + + def isEmpty(self, *args, **kwargs): + """ + @return TRUE if the StateSet contains no states. + """ + func = self.get_dbus_method("isEmpty") + return func(*args, **kwargs) + + def remove(self, *args, **kwargs): + """ + Remove a StateType to an existing StateSet, if it is present. + """ + func = self.get_dbus_method("remove") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + +class StateType(Enum): + _enum_lookup = { + 0:'STATE_INVALID', + 1:'STATE_ACTIVE', + 2:'STATE_ARMED', + 3:'STATE_BUSY', + 4:'STATE_CHECKED', + 5:'STATE_COLLAPSED', + 6:'STATE_DEFUNCT', + 7:'STATE_EDITABLE', + 8:'STATE_ENABLED', + 9:'STATE_EXPANDABLE', + 10:'STATE_EXPANDED', + 11:'STATE_FOCUSABLE', + 12:'STATE_FOCUSED', + 13:'STATE_HAS_TOOLTIP', + 14:'STATE_HORIZONTAL', + 15:'STATE_ICONIFIED', + 16:'STATE_MODAL', + 17:'STATE_MULTI_LINE', + 18:'STATE_MULTISELECTABLE', + 19:'STATE_OPAQUE', + 20:'STATE_PRESSED', + 21:'STATE_RESIZABLE', + 22:'STATE_SELECTABLE', + 23:'STATE_SELECTED', + 24:'STATE_SENSITIVE', + 25:'STATE_SHOWING', + 26:'STATE_SINGLE_LINE', + 27:'STATE_STALE', + 28:'STATE_TRANSIENT', + 29:'STATE_VERTICAL', + 30:'STATE_VISIBLE', + 31:'STATE_MANAGES_DESCENDANTS', + 32:'STATE_INDETERMINATE', + 33:'STATE_REQUIRED', + 34:'STATE_TRUNCATED', + 35:'STATE_ANIMATED', + 36:'STATE_INVALID_ENTRY', + 37:'STATE_SUPPORTS_AUTOCOMPLETION', + 38:'STATE_SELECTABLE_TEXT', + 39:'STATE_IS_DEFAULT', + 40:'STATE_VISITED', + 41:'STATE_LAST_DEFINED', + } + + +class StreamableContent(BaseProxy): + + + """ + An interface whereby an object allows its backing content to + be streamed to clients. Negotiation of content type is allowed. + Clients may examine the backing data and transform, convert, + or parse the content in order to present it in an alternate form + to end-users. + """ + + + def getContent(self, *args, **kwargs): + """ + DEPRECATED, use getStream instead. getContent: Retrieve this + object's content, in a format appropriate to a requested mimetype. + long Bonobo::Stream:seek (in long offset, in SeekType + whence) + raises (NoPermission, IOError) + void Bonobo::Stream:read (in long count, out iobuf buffer) + raises (NoPermission, IOError) + + @return a Bonobo::Stream whose mimetype matches contentType, + if available, or NIL. + """ + func = self.get_dbus_method("getContent") + return func(*args, **kwargs) + + def getContentTypes(self, *args, **kwargs): + """ + getContentTypes: + @return the list of available mimetypes for this object's content. + """ + func = self.get_dbus_method("getContentTypes") + return func(*args, **kwargs) + + def getStream(self, *args, **kwargs): + """ + Retrieve this object's content, in a format appropriate to a + requested mimetype, as a ContentStream instance. + @param : contentType + a string specifying the desired mimetype for the content stream. + @return a Stream whose mimetype matches contentType, if available, + or NIL. + """ + func = self.get_dbus_method("getStream") + return func(*args, **kwargs) + + def getURI(self, *args, **kwargs): + """ + Get a URI pointing to the content of the specified type, if such + a URI can be obtained. Not all streamable content providers have + URI representations. + @param : contentType + a string specifying the desired mimetype for the content stream. + If NULL, then a URI for the default content type will be returned, + if available. + @return a string which constitutes a URI for a stream of the + specified content type, or NULL if no such URI can be obtained. + """ + func = self.get_dbus_method("getURI") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + +class TEXT_BOUNDARY_TYPE(Enum): + _enum_lookup = { + 0:'TEXT_BOUNDARY_CHAR', + 1:'TEXT_BOUNDARY_WORD_START', + 2:'TEXT_BOUNDARY_WORD_END', + 3:'TEXT_BOUNDARY_SENTENCE_START', + 4:'TEXT_BOUNDARY_SENTENCE_END', + 5:'TEXT_BOUNDARY_LINE_START', + 6:'TEXT_BOUNDARY_LINE_END', + } + + +class TEXT_CLIP_TYPE(Enum): + _enum_lookup = { + 0:'TEXT_CLIP_NONE', + 1:'TEXT_CLIP_MIN', + 2:'TEXT_CLIP_MAX', + 3:'TEXT_CLIP_BOTH', + } + + +class Table(BaseProxy): + + + """ + An interface used by containers whose contained data is arranged + in a "tabular" (i.e. row-column) fashion. Tables may resemble + a two-dimensional grid, as in a spreadsheet, or may feature objects + which span multiple rows and/or columns, but whose bounds are + aligned on a row/column matrix. Thus, the Table interface may + be used to represent "spreadsheets" as well as "frames". + Objects within tables are children of the Table instance, and + they may be referenced either via a child index or via a row/column + pair. Their role may be ROLE_TABLE_CELL, but table 'cells' may + have other roles as well. These 'cells' may implement other interfaces, + such as Text, Action, Image, and Component, and should do so + as appropriate to their onscreen representation and/or behavior. + """ + + + def addColumnSelection(self, *args, **kwargs): + """ + Select the specified column, adding it to the current column + selection, if the table's selection model permits it. + @param : column + @return True if the specified column was successfully selected, + False if not. + """ + func = self.get_dbus_method("addColumnSelection") + return func(*args, **kwargs) + + def addRowSelection(self, *args, **kwargs): + """ + Select the specified row, adding it to the current row selection, + if the table's selection model permits it. + @param : row + @return True if the specified row was successfully selected, + False if not. + """ + func = self.get_dbus_method("addRowSelection") + return func(*args, **kwargs) + + def getAccessibleAt(self, *args, **kwargs): + """ + Get the table cell at the specified row and column indices. + @param : row + the specified table row, zero-indexed. + @param : column + the specified table column, zero-indexed. + @return an Accessible object representing the specified table + cell. + """ + func = self.get_dbus_method("getAccessibleAt") + return func(*args, **kwargs) + + def getColumnAtIndex(self, *args, **kwargs): + """ + Get the table column index occupied by the child at a particular + 1-D child index. + @param : index + the specified child index, zero-indexed. + @return a long integer indicating the first column spanned by + the child of a table, at the specified 1-D (zero-offset) index. + """ + func = self.get_dbus_method("getColumnAtIndex") + return func(*args, **kwargs) + + def getColumnDescription(self, *args, **kwargs): + """ + Get a text description of a particular table column. This differs + from AccessibleTable_getColumnHeader, which returns an Accessible. + @param : column + the specified table column, zero-indexed. + @return a UTF-8 string describing the specified table column, + if available. + """ + func = self.get_dbus_method("getColumnDescription") + return func(*args, **kwargs) + + def getColumnExtentAt(self, *args, **kwargs): + """ + Get the number of columns spanned by the table cell at the specific + row and column. (some tables can have cells which span multiple + rows and/or columns). + @param : row + the specified table row, zero-indexed. + @param : column + the specified table column, zero-indexed. + @return a long integer indicating the number of columns spanned + by the specified cell. + """ + func = self.get_dbus_method("getColumnExtentAt") + return func(*args, **kwargs) + + def getColumnHeader(self, *args, **kwargs): + """ + Get the header associated with a table column, if available, + as an instance of Accessible. This differs from getColumnDescription, + which returns a string. + @param : column + the specified table column, zero-indexed. + @return an Accessible representatin of the specified table column, + if available. + """ + func = self.get_dbus_method("getColumnHeader") + return func(*args, **kwargs) + + def getIndexAt(self, *args, **kwargs): + """ + Get the 1-D child index corresponding to the specified 2-D row + and column indices. + @param : row + the specified table row, zero-indexed. + @param : column + the specified table column, zero-indexed. + @return a long integer which serves as the index of a specified + cell in the table, in a form usable by Accessible::getChildAtIndex. + """ + func = self.get_dbus_method("getIndexAt") + return func(*args, **kwargs) + + def getRowAtIndex(self, *args, **kwargs): + """ + Get the table row index occupied by the child at a particular + 1-D child index. + @param : index + the specified child index, zero-indexed. + @return a long integer indicating the first row spanned by the + child of a table, at the specified 1-D (zero-offset) index. + """ + func = self.get_dbus_method("getRowAtIndex") + return func(*args, **kwargs) + + def getRowColumnExtentsAtIndex(self, *args, **kwargs): + """ + Given a child index, determine the row and column indices and + extents, and whether the cell is currently selected. If the child + at index is not a cell (for instance, if it is a summary, caption, + etc.), False is returned. + @param : index + the index of the Table child whose row/column extents are requested. + @param : row + back-filled with the first table row associated with the cell + with child index index. + @param : col + back-filled with the first table column associated with the cell + with child index index. + @param : row_extents + back-filled with the number of table rows across which child + i extends. + @param : col_extents + back-filled with the number of table columns across which child + i extends. + @param : is_selected + a boolean which is back-filled with True if the child at index + i corresponds to a selected table cell, False otherwise. + Example: If the Table child at index '6' extends across columns + 5 and 6 of row 2 of a Table instance, and is currently selected, + then retval=table::getRowColumnExtentsAtIndex(6,row,col, + row_extents, + col_extents, + is_selected); + will return True, and after the call row, col, row_extents, + col_extents, and is_selected will contain 2, 5, 1, 2, and True, + respectively. + @return True if the index is associated with a valid table cell, + False if the index does not correspond to a cell. If False is + returned, the values of the out parameters are undefined. + """ + func = self.get_dbus_method("getRowColumnExtentsAtIndex") + return func(*args, **kwargs) + + def getRowDescription(self, *args, **kwargs): + """ + Get a text description of a particular table row. This differs + from AccessibleTable_getRowHeader, which returns an Accessible. + @param : row + the specified table row, zero-indexed. + @return a UTF-8 string describing the specified table row, if + available. + """ + func = self.get_dbus_method("getRowDescription") + return func(*args, **kwargs) + + def getRowExtentAt(self, *args, **kwargs): + """ + Get the number of rows spanned by the table cell at the specific + row and column. (some tables can have cells which span multiple + rows and/or columns). + @param : row + the specified table row, zero-indexed. + @param : column + the specified table column, zero-indexed. + @return a long integer indicating the number of rows spanned + by the specified cell. + """ + func = self.get_dbus_method("getRowExtentAt") + return func(*args, **kwargs) + + def getRowHeader(self, *args, **kwargs): + """ + Get the header associated with a table row, if available. This + differs from getRowDescription, which returns a string. + @param : row + the specified table row, zero-indexed. + @return an Accessible representatin of the specified table row, + if available. + """ + func = self.get_dbus_method("getRowHeader") + return func(*args, **kwargs) + + def getSelectedColumns(self, *args, **kwargs): + """ + Obtain the indices of all columns which are currently selected. + @return a sequence of integers comprising the indices of columns + currently selected. + """ + func = self.get_dbus_method("getSelectedColumns") + return func(*args, **kwargs) + + def getSelectedRows(self, *args, **kwargs): + """ + Obtain the indices of all rows which are currently selected. + @return a sequence of integers comprising the indices of rows + currently selected. + """ + func = self.get_dbus_method("getSelectedRows") + return func(*args, **kwargs) + + def isColumnSelected(self, *args, **kwargs): + """ + Determine whether a table column is selected. + @param : column + the column being queried. + @return True if the specified column is currently selected, False + if not. + """ + func = self.get_dbus_method("isColumnSelected") + return func(*args, **kwargs) + + def isRowSelected(self, *args, **kwargs): + """ + Determine whether a table row is selected. + @param : row + the row being queried. + @return True if the specified row is currently selected, False + if not. + """ + func = self.get_dbus_method("isRowSelected") + return func(*args, **kwargs) + + def isSelected(self, *args, **kwargs): + """ + Determine whether the cell at a specific row and column is selected. + @param : row + a row occupied by the cell whose state is being queried. + @param : column + a column occupied by the cell whose state is being queried. + @return True if the specified cell is currently selected, False + if not. + """ + func = self.get_dbus_method("isSelected") + return func(*args, **kwargs) + + def removeColumnSelection(self, *args, **kwargs): + """ + Remove the specified column from current column selection, if + the table's selection model permits it. + @param : column + @return True if the specified column was successfully de-selected, + False if not. + """ + func = self.get_dbus_method("removeColumnSelection") + return func(*args, **kwargs) + + def removeRowSelection(self, *args, **kwargs): + """ + Remove the specified row from current row selection, if the table's + selection model permits it. + @param : row + @return True if the specified row was successfully de-selected, + False if not. + """ + func = self.get_dbus_method("removeRowSelection") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + def unImplemented5(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented5") + return func(*args, **kwargs) + + def unImplemented6(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented6") + return func(*args, **kwargs) + + def unImplemented7(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented7") + return func(*args, **kwargs) + + def get_caption(self): + self._pgetter(self._dbus_interface, "caption") + def set_caption(self, value): + self._psetter(self._dbus_interface, "caption", value) + _captionDoc = \ + """ + An Accessible which represents of a caption for a Table. + """ + caption = property(fget=get_caption, fset=set_caption, doc=_captionDoc) + + def get_nColumns(self): + self._pgetter(self._dbus_interface, "nColumns") + def set_nColumns(self, value): + self._psetter(self._dbus_interface, "nColumns", value) + _nColumnsDoc = \ + """ + The total number of columns in this table (including empty columns), + exclusive of columns which are programmatically hidden. Columns + which are scrolled out of view or clipped by the current viewport + are included. + """ + nColumns = property(fget=get_nColumns, fset=set_nColumns, doc=_nColumnsDoc) + + def get_nRows(self): + self._pgetter(self._dbus_interface, "nRows") + def set_nRows(self, value): + self._psetter(self._dbus_interface, "nRows", value) + _nRowsDoc = \ + """ + The total number of rows in this table (including empty rows), + exclusive of any rows which are programmatically hidden. Rows + which are merely scrolled out of view are included. + """ + nRows = property(fget=get_nRows, fset=set_nRows, doc=_nRowsDoc) + + def get_nSelectedColumns(self): + self._pgetter(self._dbus_interface, "nSelectedColumns") + def set_nSelectedColumns(self, value): + self._psetter(self._dbus_interface, "nSelectedColumns", value) + _nSelectedColumnsDoc = \ + """ + The number of columns currently selected. A selected column is + one in which all included cells are selected. + """ + nSelectedColumns = property(fget=get_nSelectedColumns, fset=set_nSelectedColumns, doc=_nSelectedColumnsDoc) + + def get_nSelectedRows(self): + self._pgetter(self._dbus_interface, "nSelectedRows") + def set_nSelectedRows(self, value): + self._psetter(self._dbus_interface, "nSelectedRows", value) + _nSelectedRowsDoc = \ + """ + The number of rows currently selected. A selected row is one + in which all included cells are selected. + """ + nSelectedRows = property(fget=get_nSelectedRows, fset=set_nSelectedRows, doc=_nSelectedRowsDoc) + + def get_summary(self): + self._pgetter(self._dbus_interface, "summary") + def set_summary(self, value): + self._psetter(self._dbus_interface, "summary", value) + _summaryDoc = \ + """ + An accessible object which summarizes the contents of a Table. + This object is frequently itself a Table instance, albeit a simplified + one. + """ + summary = property(fget=get_summary, fset=set_summary, doc=_summaryDoc) + + +class Text(BaseProxy): + + + """ + The text interface should be implemented by objects which place + textual information onscreen as character strings or glyphs. + The text interface allows access to textual content, including + display attributes and semantic hints associated with runs of + text, and access to bounding box information for glyphs and substrings. + It also allows portions of textual content to be selected, if + the object's StateSet includes STATE_SELECTABLE_TEXT. + In some cases a Text object may have, as its content, an empty + string. In particular this can occur in the case of Hypertext + objects which do not display explicitly textual information onscreen, + as Hypertext is derived from the Text interface. + Typographic and semantic attributes of onscreen textual content, + for instance typeface, weight, language, and such qualities as + 'emphasis' or 'blockquote', are represented as text attributes. + Contiguous sequences of characters over which these attributes + are unchanged are referred to as "attribute runs", and are available + via Text::getAttributeRun. Where possible, implementing clients + will report textual attributes which are the same over the entire + text object, for instance those inherited from a default or document-scope + style, via getDefaultAttributes instead of reporting them explicitly + for each character. Therefore, for any span of text, the attributes + in effect are the union of the set returned by Text::getDefaultAttributes, + and the set returned at a particular character offset via Text::getAttributeRun. + """ + + + def addSelection(self, *args, **kwargs): + """ + The result of calling addSelection on objects which already have + one selection present, and which do not include STATE_MULTISELECTABLE, + is undefined, other than the return value. + @return True of the selection was successfully added, False otherwise. + Selection may fail if the object does not support selection of + text (see STATE_SELECTABLE_TEXT), if the object does not support + multiple selections and a selection is already defined, or for + other reasons (for instance if the user does not have permission + to copy the text into the relevant selection buffer). + """ + func = self.get_dbus_method("addSelection") + return func(*args, **kwargs) + + def getAttributeRun(self, *args, **kwargs): + """ + Query a particular text object for the text attributes defined + at a given offset, obtaining the start and end of the "attribute + run" over which these attributes are currently invariant. Text + attributes are those presentational, typographic, or semantic + attributes or qualitites which apply to a range of text specifyable + by starting and ending offsets. Attributes relevant to localization + should be provided in accordance with the w3c "Internationalization + and Localization Markup Requirements", http://www.w3.org/TR/2005/WD-itsreq-20051122/ + Other text attributes should choose their names and value semantics + in accordance with relevant standards such as CSS level 2 (http://www.w3.org/TR/1998/REC-CSS2-19980512), + XHTML 1.0 (http://www.w3.org/TR/2002/REC-xhtml1-20020801), and + WICD (http://www.w3.org/TR/2005/WD-WICD-20051121/). Those attributes + from the aforementioned specifications and recommendations which + do not concern typographic, presentational, or semantic aspects + of text should be exposed via the more general Accessible::getAttributes() + API (if at all). + For example, CSS attributes which should be exposed on text (either + as default attributes, or as explicitly-set attributes when non-default + values are specified in the content view) include the Font attributes + (i.e. "css2:font-weight", "css2:font-style"), the "css2:color" + and "css2:background-color" attributes, and "css2:text-decoration" + attribute. + If includeDefaults is TRUE, then this AttributeSet should include + the default attributes as well as those which are explicitly + assigned to the attribute run in question. startOffset and endOffset + will be back-filled to indicate the start and end of the attribute + run which contains 'offset' - an attribute run is a contiguous + section of text whose attributes are homogeneous. + @param : offset + the offset of the character whose attributes will be reported. + @param : startOffset + backfilled with the starting offset of the character range over + which all text attributes match those of offset, i.e. the start + of the homogeneous attribute run including offset. + @param : endOffset + backfilled with the offset of the first character past the character + range over which all text attributes match those of offset, i.e. + the character immediately after the homogeneous attribute run + including offset. + @param : includeDefaults + if False, the call should only return those attributes which + are explicitly set on the current attribute run, omitting any + attributes which are inherited from the default values. See also + Text::getDefaultAttributes. + @return the AttributeSet defined at offset, optionally including + the 'default' attributes. + """ + func = self.get_dbus_method("getAttributeRun") + return func(*args, **kwargs) + + def getAttributeValue(self, *args, **kwargs): + """ + Get the string value of a named attribute at a given offset, + if defined. + @param : offset + the offset of the character for which the attribute run is to + be obtained. + @param : attributeName + the name of the attribute for which the value is to be returned, + if defined. + @param : startOffset + back-filled with the offset of the first character in the attribute + run containing the character at offset. + @param : endOffset + back-filled with the offset of the first character past the end + of the attribute run containing the character at offset. + @param : defined + back-filled with True if the attributeName has a defined value + at offset, False otherwise. + @return the value of attribute (name-value pair) corresponding + to "name", if defined. + """ + func = self.get_dbus_method("getAttributeValue") + return func(*args, **kwargs) + + def getAttributes(self, *args, **kwargs): + """ + getAttributes is deprecated in favor of getAttributeRun. + @return the attributes at offset, as a semicolon-delimited set + of colon-delimited name-value pairs. + """ + func = self.get_dbus_method("getAttributes") + return func(*args, **kwargs) + + def getBoundedRanges(self, *args, **kwargs): + """ + Return the text content within a bounding box, as a list of Range + structures. Depending on the TEXT_CLIP_TYPE parameters, glyphs + which are clipped by the bounding box (i.e. which lie partially + inside and partially outside it) may or may not be included in + the ranges returned. + @param : x + the minimum x ( i.e. leftmost) coordinate of the bounding box. + @param : y + the minimum y coordinate of the bounding box. + @param : width + the horizontal size of the bounding box. The rightmost bound + of the bounding box is (x + width); + @param : height + the vertical size of the bounding box. The maximum y value of + the bounding box is (y + height); + @param : coordType + If 0, the above coordinates are interpreted as pixels relative + to corner of the screen; if 1, the coordinates are interpreted + as pixels relative to the corner of the containing toplevel window. + @param : xClipType + determines whether text which intersects the bounding box in + the x direction is included. + @param : yClipType + determines whether text which intersects the bounding box in + the y direction is included. + """ + func = self.get_dbus_method("getBoundedRanges") + return func(*args, **kwargs) + + def getCharacterAtOffset(self, *args, **kwargs): + """ + @return an unsigned long integer whose value corresponds to the + UCS-4 representation of the character at the specified text offset, + or 0 if offset is out of range. + """ + func = self.get_dbus_method("getCharacterAtOffset") + return func(*args, **kwargs) + + def getCharacterExtents(self, *args, **kwargs): + """ + Obtain a the bounding box, as x, y, width, and height, of the + character or glyph at a particular character offset in this object's + text content. The coordinate system in which the results are + reported is specified by coordType. If an onscreen glyph corresponds + to multiple character offsets, for instance if the glyph is a + ligature, the bounding box reported will include the entire glyph + and therefore may apply to more than one character offset. + @param : offset + the character offset of the character or glyph being queried. + @param : x + the minimum horizontal coordinate of the bounding box of the + glyph representing the character at offset. + @param : y + the minimum vertical coordinate of the bounding box of the glyph + representing the character at offset. + @param : width + the horizontal extent of the bounding box of the glyph representing + the character at offset. + @param : height + the vertical extent of the bounding box of the glyph representing + the character at offset. + @param : coordType + If 0, the results will be reported in screen coordinates, i.e. + in pixels relative to the upper-left corner of the screen, with + the x axis pointing right and the y axis pointing down. If 1, + the results will be reported relative to the containing toplevel + window, with the x axis pointing right and the y axis pointing + down. + """ + func = self.get_dbus_method("getCharacterExtents") + return func(*args, **kwargs) + + def getDefaultAttributeSet(self, *args, **kwargs): + """ + Return an AttributeSet containing the text attributes which apply + to all text in the object by virtue of the default settings of + the document, view, or user agent; e.g. those attributes which + are implied rather than explicitly applied to the text object. + For instance, an object whose entire text content has been explicitly + marked as 'bold' will report the 'bold' attribute via getAttributeRun(), + whereas an object whose text weight is inspecified may report + the default or implied text weight in the default AttributeSet. + """ + func = self.get_dbus_method("getDefaultAttributeSet") + return func(*args, **kwargs) + + def getDefaultAttributes(self, *args, **kwargs): + """ + Deprecated in favor of getDefaultAttributeSet. + @return the attributes which apply to the entire text content, + but which were not explicitly specified by the content creator. + """ + func = self.get_dbus_method("getDefaultAttributes") + return func(*args, **kwargs) + + def getNSelections(self, *args, **kwargs): + """ + Obtain the number of separate, contiguous selections in the current + Text object. Text objects which do not implement selection of + discontiguous text regions will always return '0' or '1'. Note + that "contiguous" is defined by continuity of the offsets, i.e. + a text 'selection' is defined by a start/end offset pair. In + the case of bidirectional text, this means that a continguous + selection may appear visually discontiguous, and vice-versa. + @return the number of contiguous selections in the current Text + object. + """ + func = self.get_dbus_method("getNSelections") + return func(*args, **kwargs) + + def getOffsetAtPoint(self, *args, **kwargs): + """ + Get the offset of the character at a given onscreen coordinate. + The coordinate system used to interpret x and y is determined + by parameter coordType. + @param : x + @param : y + @param : coordType + if 0, the input coordinates are interpreted relative to the entire + screen, if 1, they are relative to the toplevel window containing + this Text object. + @return the text offset (as an offset into the character array) + of the glyph whose onscreen bounds contain the point x,y, or + -1 if the point is outside the bounds of any glyph. + """ + func = self.get_dbus_method("getOffsetAtPoint") + return func(*args, **kwargs) + + def getRangeExtents(self, *args, **kwargs): + """ + Obtain the bounding box which entirely contains a given text + range. Negative values may be returned for the bounding box parameters + in the event that all or part of the text range is offscreen + or not mapped to the screen. + @param : startOffset + the offset of the first character in the specified range. + @param : endOffset + the offset of the character immediately after the last character + in the specified range. + @param : x + an integer parameter which is back-filled with the minimum horizontal + coordinate of the resulting bounding box. + @param : y + an integer parameter which is back-filled with the minimum vertical + coordinate of the resulting bounding box. + @param : width + an integer parameter which is back-filled with the horizontal + extent of the bounding box. + @param : height + an integer parameter which is back-filled with the vertical extent + of the bounding box. + @param : coordType + If 0, the above coordinates are reported in pixels relative to + corner of the screen; if 1, the coordinates are reported relative + to the corner of the containing toplevel window. + """ + func = self.get_dbus_method("getRangeExtents") + return func(*args, **kwargs) + + def getSelection(self, *args, **kwargs): + """ + The result of calling getSelection with an out-of-range selectionNum + (i.e. for a selection which does not exist) is not strictly defined, + but should set endOffset equal to startOffset. + """ + func = self.get_dbus_method("getSelection") + return func(*args, **kwargs) + + def getText(self, *args, **kwargs): + """ + Obtain all or part of the onscreen textual content of a Text + object. If endOffset is specified as "-1", then this method will + return the entire onscreen textual contents of the Text object. + @return the textual content of the current Text object beginning + startOffset (inclusive) up to but not including the character + at endOffset. + """ + func = self.get_dbus_method("getText") + return func(*args, **kwargs) + + def getTextAfterOffset(self, *args, **kwargs): + """ + Obtain a subset of the text content of an object which entirely + follows offset, delimited by character, word, line, or sentence + boundaries as specified by type. The starting and ending offsets + of the resulting substring are returned in startOffset and endOffset. + By definition, if such a substring exists, startOffset must be + greater than offset. + @param : offset + the offset from which the substring search begins, and which + must lie before the returned substring. + @param : type + the text-boundary delimiter which determines whether the returned + text constitures a character, word, line, or sentence (and possibly + attendant whitespace), and whether the start or ending of such + a substring forms the boundary condition. + @param : startOffset + back-filled with the starting offset of the resulting substring, + if one exists. + @param : endOffset + back-filled with the offset of the character immediately following + the resulting substring, if one exists. + @return a string which is a substring of the text content of + the object, delimited by the specified boundary condition. + """ + func = self.get_dbus_method("getTextAfterOffset") + return func(*args, **kwargs) + + def getTextAtOffset(self, *args, **kwargs): + """ + Obtain a subset of the text content of an object which includes + the specified offset, delimited by character, word, line, or + sentence boundaries as specified by type. The starting and ending + offsets of the resulting substring are returned in startOffset + and endOffset. + @param : offset + the offset from which the substring search begins, and which + must lie within the returned substring. + @param : type + the text-boundary delimiter which determines whether the returned + text constitures a character, word, line, or sentence (and possibly + attendant whitespace), and whether the start or ending of such + a substring forms the boundary condition. + @param : startOffset + back-filled with the starting offset of the resulting substring, + if one exists. + @param : endOffset + back-filled with the offset of the character immediately following + the resulting substring, if one exists. + @return a string which is a substring of the text content of + the object, delimited by the specified boundary condition. + """ + func = self.get_dbus_method("getTextAtOffset") + return func(*args, **kwargs) + + def getTextBeforeOffset(self, *args, **kwargs): + """ + Obtain a subset of the text content of an object which entirely + precedes offset, delimited by character, word, line, or sentence + boundaries as specified by type. The starting and ending offsets + of the resulting substring are returned in startOffset and endOffset. + By definition, if such a substring exists, endOffset is less + than or equal to offset. + @param : offset + the offset from which the substring search begins. + @param : type + the text-boundary delimiter which determines whether the returned + text constitures a character, word, line, or sentence (and possibly + attendant whitespace), and whether the start or ending of such + a substring forms the boundary condition. + @param : startOffset + back-filled with the starting offset of the resulting substring, + if one exists. + @param : endOffset + back-filled with the offset of the character immediately following + the resulting substring, if one exists. + @return a string which is a substring of the text content of + the object, delimited by the specified boundary condition. + """ + func = self.get_dbus_method("getTextBeforeOffset") + return func(*args, **kwargs) + + def removeSelection(self, *args, **kwargs): + """ + Deselect the text contained in the specified selectionNum, if + such a selection exists, otherwise do nothing. Removal of a non-existant + selectionNum has no effect. + @return True if the selection was successfully removed, False + otherwise. + """ + func = self.get_dbus_method("removeSelection") + return func(*args, **kwargs) + + def setCaretOffset(self, *args, **kwargs): + """ + Programmatically move the text caret (visible or virtual, as + above) to a given position. + @param : offset + a long int indicating the desired character offset. Not all implementations + of Text will honor setCaretOffset requests, so the return value + below should be checked by the client. + @return TRUE if the request was carried out, or FALSE if the + caret could not be moved to the requested position. + """ + func = self.get_dbus_method("setCaretOffset") + return func(*args, **kwargs) + + def setSelection(self, *args, **kwargs): + """ + Modify an existing selection's start or ending offset. + Calling setSelection for a selectionNum that is not already defined + has no effect. The result of calling setSelection with a selectionNum + greater than 0 for objects that do not include STATE_MULTISELECTABLE + is undefined. + @param : selectionNum + indicates which of a set of non-contiguous selections to modify. + @param : startOffset + the new starting offset for the selection + @param : endOffset + the new ending offset for the selection + @return True if the selection corresponding to selectionNum is + successfully modified, False otherwise. + """ + func = self.get_dbus_method("setSelection") + return func(*args, **kwargs) + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def get_caretOffset(self): + self._pgetter(self._dbus_interface, "caretOffset") + def set_caretOffset(self, value): + self._psetter(self._dbus_interface, "caretOffset", value) + _caretOffsetDoc = \ + """ + The current offset of the text caret in the Text object. This + caret may be virtual, e.g. non-visual and notional-only, but + if an onscreen representation of the caret position is visible, + it will correspond to this offset. The caret offset is given + as a character offset, as opposed to a byte offset into a text + buffer or a column offset. + """ + caretOffset = property(fget=get_caretOffset, fset=set_caretOffset, doc=_caretOffsetDoc) + + def get_characterCount(self): + self._pgetter(self._dbus_interface, "characterCount") + def set_characterCount(self, value): + self._psetter(self._dbus_interface, "characterCount", value) + _characterCountDoc = \ + """ + The total current number of characters in the Text object, including + whitespace and non-spacing characters. + """ + characterCount = property(fget=get_characterCount, fset=set_characterCount, doc=_characterCountDoc) + + class Range(list): + def __new__(cls, startOffset, endOffset, content, data): + list.__new__(cls, (startOffset, endOffset, content, data) + def __init__(self, startOffset, endOffset, content, data): + list.__init__(self, (startOffset, endOffset, content, data)) + + startOffset = property(fget=_get_startOffset, fset=_set_startOffset) + def _get_startOffset(self): + return self[0] + def _set_startOffset(self, val): + self[0] = val + endOffset = property(fget=_get_endOffset, fset=_set_endOffset) + def _get_endOffset(self): + return self[1] + def _set_endOffset(self, val): + self[1] = val + content = property(fget=_get_content, fset=_set_content) + def _get_content(self): + return self[2] + def _set_content(self, val): + self[2] = val + data = property(fget=_get_data, fset=_set_data) + def _get_data(self): + return self[3] + def _set_data(self, val): + self[3] = val + + +class Value(BaseProxy): + + + """ + An interface supporting controls which allow a one-dimensional, + scalar quantity to be modified or which reflect a scalar quantity. + (If STATE_EDITABLE is not present, the valuator is treated as + "read only". + """ + + + def unImplemented(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented") + return func(*args, **kwargs) + + def unImplemented2(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented2") + return func(*args, **kwargs) + + def unImplemented3(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented3") + return func(*args, **kwargs) + + def unImplemented4(self, *args, **kwargs): + func = self.get_dbus_method("unImplemented4") + return func(*args, **kwargs) + + def get_currentValue(self): + self._pgetter(self._dbus_interface, "currentValue") + def set_currentValue(self, value): + self._psetter(self._dbus_interface, "currentValue", value) + _currentValueDoc = \ + """ + The current value of the valuator. + """ + currentValue = property(fget=get_currentValue, fset=set_currentValue, doc=_currentValueDoc) + + def get_maximumValue(self): + self._pgetter(self._dbus_interface, "maximumValue") + def set_maximumValue(self, value): + self._psetter(self._dbus_interface, "maximumValue", value) + _maximumValueDoc = \ + """ + The maximum value allowed by this valuator. + """ + maximumValue = property(fget=get_maximumValue, fset=set_maximumValue, doc=_maximumValueDoc) + + def get_minimumIncrement(self): + self._pgetter(self._dbus_interface, "minimumIncrement") + def set_minimumIncrement(self, value): + self._psetter(self._dbus_interface, "minimumIncrement", value) + _minimumIncrementDoc = \ + """ + The smallest incremental change which this valuator allows. If + 0, the incremental changes to the valuator are limited only by + the precision of a double precision value on the platform. + """ + minimumIncrement = property(fget=get_minimumIncrement, fset=set_minimumIncrement, doc=_minimumIncrementDoc) + + def get_minimumValue(self): + self._pgetter(self._dbus_interface, "minimumValue") + def set_minimumValue(self, value): + self._psetter(self._dbus_interface, "minimumValue", value) + _minimumValueDoc = \ + """ + The minimum value allowed by this valuator. + """ + minimumValue = property(fget=get_minimumValue, fset=set_minimumValue, doc=_minimumValueDoc) + diff --git a/pyatspi/stateset.py b/pyatspi/stateset.py new file mode 100644 index 0000000..e41306b --- /dev/null +++ b/pyatspi/stateset.py @@ -0,0 +1,232 @@ +#Copyright (C) 2008 Codethink Ltd +#copyright: Copyright (c) 2005, 2007 IBM Corporation + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +#Portions of this code originally licensed and copyright (c) 2005, 2007 +#IBM Corporation under the BSD license, available at +#U{http://www.opensource.org/licenses/bsd-license.php} + +#authors: Peter Parente, Mark Doffman + +class _StateSetImpl(Accessibility__POA.StateSet): + """ + Implementation of the StateSet interface. Clients should not use this class + directly, but rather the L{StateSet} proxy class. + + @param states: Set of states + @type states: set + """ + def __init__(self): + """Initializes the state set.""" + self.states = set() + + def contains(self, state): + """ + Checks if this StateSet contains the given state. + + @param state: State to check + @type state: Accessibility.StateType + @return: True if the set contains the given state + @rtype: boolean + """ + return state in self.states + + def add(self, state): + """ + Adds a state to this set. + + @param state: State to add + @type state: Accessibility.StateType + """ + self.states.add(state) + + def remove(self, state): + """ + Removes a state from this set. + + @param state: State to remove + @type state: Accessibility.StateType + """ + self.states.remove(state) + + def equals(self, state_set): + """ + Checks if this StateSet contains exactly the same members as the given + StateSet. + + @param state_set: Another set + @type state_set: Accessibility.StateSet + @return: Are the sets equivalent in terms of their contents? + @rtype: boolean + """ + # don't check private members, object might be from another process + # or implementation + return set(state_set.getStates()) == self.states + + def compare(self, state_set): + """ + Computes the symmetric differences of this L{StateSet} and the given + L{StateSet}. + + @note: This method is not currently implemented because of difficulties + with reference counting. This method needs to return a new + Accessibility.StateSet object, but the Python implementation for that + object needs to be kept alive. The problem is who will keep that + server implementation alive? As soon as it goes out of scope, it's + GC'ed. This object cannot keep it alive either as it may go out of + scope before the new object is ready to be finalized. With a global + cache of objects, we don't know when to invalidate. + + @param state_set: Another set + @type state_set: Accessibility.StateSet + @return: Elements in only one of the two sets + @rtype: Accessibility.StateSet + """ + raise ORBit.CORBA.NO_IMPLEMENT + + # don't check private members, object might be from another process + # or implementation + #states = set(state_set.getStates()) + #diff = self.states.symmetric_difference(states) + #new_ss = _StateSetImpl() + #map(new_ss._this().add, diff) + #return new_ss._this() + + def isEmpty(self): + """ + Checks if this L{StateSet} is empty. + + @return: Is it empty? + @rtype: boolean + """ + return len(self.states) == 0 + + def getStates(self): + """ + Gets the sequence of all states in this set. + + @return: List of states + @rtype: list + """ + return list(self.states) + +class StateSet(object): + """ + Python proxy for the L{_StateSetImpl} class. Use this to safely instantiate + new StateSet objects in Python. + + @param impl: State set implementation + @type impl: L{_StateSetImpl} + """ + def __init__(self, *states): + """ + Initializes the state set with the given states. + + @param states: States to add immediately + @type states: list + """ + self.impl = _StateSetImpl() + map(self.impl._this().add, states) + + def contains(self, state): + """ + Checks if this StateSet contains the given state. + + @param state: State to check + @type state: Accessibility.StateType + @return: True if the set contains the given state + @rtype: boolean + """ + return self.impl._this().contains(state) + + def add(self, *states): + """ + Adds states to this set. + + @param states: State(s) to add + @type states: Accessibility.StateType + """ + map(self.impl._this().add, states) + + def remove(self, state): + """ + Removes states from this set. + + @param states: State(s) to remove + @type states: Accessibility.StateType + """ + map(self.impl._this().remove, state) + + def equals(self, state_set): + """ + Checks if this StateSet contains exactly the same members as the given + StateSet. + + @param state_set: Another set + @type state_set: Accessibility.StateSet + @return: Are the sets equivalent in terms of their contents? + @rtype: boolean + """ + if isinstance(state_set, self.__class__): + # convenience if we're given a proxy + state_set = state_set.raw() + return self.impl._this().equals(state_set) + + def compare(self, state_set): + """ + Finds the symmetric difference between this state set andthe one provided, + and returns it as a new StateSet. + + @note: This does not use L{_StateSetImpl.compare} which cannot be + implemented at this time + @param state_set: Set to compare against + @type state_set: Accessibility.StateSet + @return: Proxy for the new set + @rtype: L{StateSet} + """ + if isinstance(state_set, self.__class__): + # shortcut if it's another one of our proxies + state_set = state_set.raw() + a = set(self.impl._this().getStates()) + b = set(state_set.getStates()) + diff = a.symmetric_difference(b) + return StateSet(*diff) + + def isEmpty(self): + """ + Checks if this StateSet is empty. + + @return: Is it empty? + @rtype: boolean + """ + return self.impl._this().isEmpty() + + def getStates(self): + """ + Gets the sequence of all states in this set. + + @return: List of states + @rtype: list + """ + return self.impl._this().getStates() + + def raw(self): + """ + Gets the Accessibility.StateSet object proxied for use in a remote + call. + + @return: State set + @rtype: Accessibility.StateSet + """ + return self.impl._this() diff --git a/pyatspi/utils.py b/pyatspi/utils.py new file mode 100644 index 0000000..5853b46 --- /dev/null +++ b/pyatspi/utils.py @@ -0,0 +1,303 @@ +#Copyright (C) 2008 Codethink Ltd +#copyright: Copyright (c) 2005, 2007 IBM Corporation + +#This library is free software; you can redistribute it and/or +#modify it under the terms of the GNU Lesser General Public +#License version 2 as published by the Free Software Foundation. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU Lesser General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +#Portions of this code originally licensed and copyright (c) 2005, 2007 +#IBM Corporation under the BSD license, available at +#U{http://www.opensource.org/licenses/bsd-license.php} + +#authors: Peter Parente, Mark Doffman + +#TODO Re-implement and import the stateset server + +def getInterfaceIID(obj): + """ + Gets the ID of an interface class or object in string format for use in + queryInterface. + + @param obj: Class representing an AT-SPI interface or instance + @type obj: object + @return: IID for the interface + @rtype: string + @raise AttributeError: When the parameter does not provide typecode info + + WARNING!! DEPRECATED!! + + In current D-Bus version of pyatspi this simply returns a null string. + """ + return "" + +def getInterfaceName(obj): + """ + Gets the human readable name of an interface class or object in string + format. + + @param obj: Class representing an AT-SPI interface or instance + @type obj: class + @return: Name of the interface + @rtype: string + @raise AttributeError: When the parameter does not provide typecode info + """ + return obj._dbus_interface.lstrip("org.freedesktop.atspi.") + +# we're importing here to avoid cyclic importants; constants relies on the +# two functions above +import constants + +def listInterfaces(obj): + """ + Gets a list of the names of all interfaces supported by this object. The + names are the short-hand interface names like "Accessible" and "Component", + not the full interface identifiers. + + @param obj: Arbitrary object to query for all accessibility related + interfaces. Must provide a queryInterface method. + @type obj: object + @return: Set of supported interface names + @rtype: set + @raise AttributeError: If the object provide does not implement + queryInterface + """ + return [itf.lstrip("org.freedesktop.atspi.") for itf in obj.interfaces] + +def stringToConst(prefix, suffix): + """ + Maps a string name to an AT-SPI constant. The rules for the mapping are as + follows: + - The prefix is captalized and has an _ appended to it. + - All spaces in the suffix are mapped to the _ character. + - All alpha characters in the suffix are mapped to their uppercase. + + The resulting name is used with getattr to look up a constant with that name + in the L{constants} module. If such a constant does not exist, the string + suffix is returned instead. + + This method allows strings to be used to refer to roles, relations, etc. + without direct access to the constants. It also supports the future expansion + of roles, relations, etc. by allowing arbitrary strings which may or may not + map to the current standard set of roles, relations, etc., but may still + match some non-standard role, relation, etc. being reported by an + application. + + @param prefix: Prefix of the constant name such as role, relation, state, + text, modifier, key + @type prefix: string + @param suffix: Name of the role, relation, etc. to use to lookup the constant + @type suffix: string + @return: The matching constant value + @rtype: object + """ + name = prefix.upper()+'_'+suffix.upper().replace(' ', '_') + return getattr(constants, name, suffix) + +def stateToString(value): + """ + Converts a state value to a string based on the name of the state constant in + the L{constants} module that has the given value. + + @param value: An AT-SPI state + @type value: Accessibility.StateType + @return: Human readable, untranslated name of the state + @rtype: string + """ + return constants.STATE_VALUE_TO_NAME.get(value) + +def relationToString(value): + """ + Converts a relation value to a string based on the name of the state constant + in the L{constants} module that has the given value. + + @param value: An AT-SPI relation + @type value: Accessibility.RelationType + @return: Human readable, untranslated name of the relation + @rtype: string + """ + return constants.RELATION_VALUE_TO_NAME.get(value) + +def allModifiers(): + """ + Generates all possible keyboard modifiers for use with + L{registry.Registry.registerKeystrokeListener}. + """ + mask = 0 + while mask <= (1 << constants.MODIFIER_NUMLOCK): + yield mask + mask += 1 + +def findDescendant(acc, pred, breadth_first=False): + """ + Searches for a descendant node satisfying the given predicate starting at + this node. The search is performed in depth-first order by default or + in breadth first order if breadth_first is True. For example, + + my_win = findDescendant(lambda x: x.name == 'My Window') + + will search all descendants of x until one is located with the name 'My + Window' or all nodes are exausted. Calls L{_findDescendantDepth} or + L{_findDescendantBreadth} to start the recursive search. + + @param acc: Root accessible of the search + @type acc: Accessibility.Accessible + @param pred: Search predicate returning True if accessible matches the + search criteria or False otherwise + @type pred: callable + @param breadth_first: Search breadth first (True) or depth first (False)? + @type breadth_first: boolean + @return: Accessible matching the criteria or None if not found + @rtype: Accessibility.Accessible or None + """ + if breadth_first: + return _findDescendantBreadth(acc, pred) + + for child in acc: + try: + ret = _findDescendantDepth(acc, pred) + except Exception: + ret = None + if ret is not None: return ret + +def _findDescendantBreadth(acc, pred): + """ + Internal function for locating one descendant. Called by L{findDescendant} to + start the search. + + @param acc: Root accessible of the search + @type acc: Accessibility.Accessible + @param pred: Search predicate returning True if accessible matches the + search criteria or False otherwise + @type pred: callable + @return: Matching node or None to keep searching + @rtype: Accessibility.Accessible or None + """ + for child in acc: + try: + if pred(child): return child + except Exception: + pass + for child in acc: + try: + ret = _findDescendantBreadth(child, pred) + except Exception: + ret = None + if ret is not None: return ret + +def _findDescendantDepth(acc, pred): + """ + Internal function for locating one descendant. Called by L{findDescendant} to + start the search. + + @param acc: Root accessible of the search + @type acc: Accessibility.Accessible + @param pred: Search predicate returning True if accessible matches the + search criteria or False otherwise + @type pred: callable + @return: Matching node or None to keep searching + @rtype: Accessibility.Accessible or None + """ + try: + if pred(acc): return acc + except Exception: + pass + for child in acc: + try: + ret = _findDescendantDepth(child, pred) + except Exception: + ret = None + if ret is not None: return ret + +def findAllDescendants(acc, pred): + """ + Searches for all descendant nodes satisfying the given predicate starting at + this node. Does an in-order traversal. For example, + + pred = lambda x: x.getRole() == pyatspi.ROLE_PUSH_BUTTON + buttons = pyatspi.findAllDescendants(node, pred) + + will locate all push button descendants of node. + + @param acc: Root accessible of the search + @type acc: Accessibility.Accessible + @param pred: Search predicate returning True if accessible matches the + search criteria or False otherwise + @type pred: callable + @return: All nodes matching the search criteria + @rtype: list + """ + matches = [] + _findAllDescendants(acc, pred, matches) + return matches + +def _findAllDescendants(acc, pred, matches): + """ + Internal method for collecting all descendants. Reuses the same matches + list so a new one does not need to be built on each recursive step. + """ + for child in acc: + try: + if pred(child): matches.append(child) + except Exception: + pass + _findAllDescendants(child, pred, matches) + +def findAncestor(acc, pred): + """ + Searches for an ancestor satisfying the given predicate. Note that the + AT-SPI hierarchy is not always doubly linked. Node A may consider node B its + child, but B is not guaranteed to have node A as its parent (i.e. its parent + may be set to None). This means some searches may never make it all the way + up the hierarchy to the desktop level. + + @param acc: Starting accessible object + @type acc: Accessibility.Accessible + @param pred: Search predicate returning True if accessible matches the + search criteria or False otherwise + @type pred: callable + @return: Node matching the criteria or None if not found + @rtype: Accessibility.Accessible + """ + if acc is None: + # guard against bad start condition + return None + while 1: + if acc.parent is None: + # stop if there is no parent and we haven't returned yet + return None + try: + if pred(acc.parent): return acc.parent + except Exception: + pass + # move to the parent + acc = acc.parent + +def getPath(acc): + """ + Gets the path from the application ancestor to the given accessible in + terms of its child index at each level. + + @param acc: Target accessible + @type acc: Accessibility.Accessible + @return: Path to the target + @rtype: list of integer + @raise LookupError: When the application accessible cannot be reached + """ + path = [] + while 1: + if acc.parent is None: + path.reverse() + return path + try: + path.append(acc.getIndexInParent()) + except Exception: + raise LookupError + acc = acc.parent diff --git a/tests/pyatspi/Makefile.am b/tests/pyatspi/Makefile.am index 44880dd..880fd7f 100644 --- a/tests/pyatspi/Makefile.am +++ b/tests/pyatspi/Makefile.am @@ -1,8 +1,11 @@ +SUBDIRS = pasytest + EXTRA_DIST = \ - __init__.py \ - accessibleobject.py \ - component.py \ - testrunner.py \ - testutil.py + accessibletest.py\ + componenttest.py\ + Makefile.am\ + Makefile.in\ + setvars.sh\ + testrunner.py CLEANFILES = *.pyc diff --git a/tests/pyatspi/__init__.py b/tests/pyatspi/__init__.py deleted file mode 100644 index 2b8731d..0000000 --- a/tests/pyatspi/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ - -from accessibletest import AccessibleTestCase -from componenttest import ComponentTestCase -import testutil diff --git a/tests/pyatspi/accessibletest.py b/tests/pyatspi/accessibletest.py index 63c8e22..8e10ef4 100644 --- a/tests/pyatspi/accessibletest.py +++ b/tests/pyatspi/accessibletest.py @@ -1,16 +1,12 @@ -import testutil - import dbus import gobject import os.path -import coretest -from dbus.mainloop.glib import DBusGMainLoop - -from accessible_cache import AccessibleCache from xml.dom import minidom import os +from pasytest import PasyTestSuite + def createNode(accessible, parentElement): e = minidom.Element("accessible") @@ -23,12 +19,15 @@ def createNode(accessible, parentElement): parentElement.appendChild(e) -class AccessibleTestCase(coretest.CoreTestCase): - def runTest(self): - self._app = testutil.runTestApp("libobjectapp.so", self._name) - self._loop.run() +class TreeTestSuite(PasyTestSuite): + + __tests__ = ["accessibleTree"] - def post_application_test(self): + def __init__(self, bus, name): + PasyTestSuite.__init__(self, "Tree") + self._cache = getAccessibleCache(bus, name) + + def accessibleTree(test): root = self._cache.getRootAccessible() doc = minidom.Document() @@ -40,7 +39,6 @@ class AccessibleTestCase(coretest.CoreTestCase): file = open(correct) cstring = file.read() - #import difflib - #print ''.join(difflib.unified_diff(answer.splitlines(), cstring.splitlines())) - - self.assertEqual(answer, cstring, "Object tree not passed correctly") + test.assertEqual(answer, cstring, "Object tree not passed correctly") + + test.win() diff --git a/tests/pyatspi/coretest.py b/tests/pyatspi/coretest.py deleted file mode 100644 index 53fc879..0000000 --- a/tests/pyatspi/coretest.py +++ /dev/null @@ -1,57 +0,0 @@ -import unittest -import testutil - -import dbus -import gobject -import os.path -from dbus.mainloop.glib import DBusGMainLoop - -from accessible_cache import AccessibleCache -from random import randint - - - -class CoreTestCase(unittest.TestCase): - def setUp(self): - DBusGMainLoop(set_as_default=True) - - self._bus = dbus.SessionBus() - self._loop = gobject.MainLoop() - self._name = "test.atspi.R" + str(randint(1, 1000)) - self._match = self._bus.add_signal_receiver(self.post_application_setup, - "started", - "org.codethink.atspi.test", - self._name) - self._started = False - - if "TEST_APP_WAIT_FOR_DEBUG" not in os.environ.keys(): - gobject.timeout_add(1000, self.application_check) - - def tearDown(self): - #Shut down the test application - self._test.finished() - - del(self._bus) - del(self._loop) - del(self._cache) - del(self._app) - del(self._test) - - def application_check(self): - if not self._started: - self.fail("Test application did not start") - - def post_application_setup(self): - self._started = True - - self._cache = AccessibleCache(self._bus, self._name, "/org/freedesktop/atspi/tree") - - test_object = self._bus.get_object(self._name, "/org/codethink/atspi/test") - self._test = dbus.Interface(test_object, "org.codethink.atspi.test") - - self.post_application_test() - - self._loop.quit() - - def post_application_test(self): - raise Exception, "No test has been defined" diff --git a/tests/pyatspi/pasytest/Events.py b/tests/pyatspi/pasytest/Events.py new file mode 100644 index 0000000..8e340ff --- /dev/null +++ b/tests/pyatspi/pasytest/Events.py @@ -0,0 +1,78 @@ +#C#-Style Events in Python +#Taken from http://code.activestate.com/recipes/410686/ +#By Zoran Isailovski + +class Events: + def __getattr__(self, name): + if hasattr(self.__class__, '__events__'): + assert name in self.__class__.__events__, \ + "Event '%s' is not declared" % name + self.__dict__[name] = ev = _EventSlot(name) + return ev + def __repr__(self): return 'Events' + str(list(self)) + __str__ = __repr__ + def __len__(self): return NotImplemented + def __iter__(self): + def gen(dictitems=self.__dict__.items()): + for attr, val in dictitems: + if isinstance(val, _EventSlot): + yield val + return gen() + +#------------------------------------------------------------------------------ + +class _EventSlot: + def __init__(self, name): + self.targets = [] + self.__name__ = name + def __repr__(self): + return 'event ' + self.__name__ + def __call__(self, *a, **kw): + for f in self.targets: f(*a, **kw) + def __iadd__(self, f): + self.targets.append(f) + return self + def __isub__(self, f): + while f in self.targets: self.targets.remove(f) + return self + +#------------------------------------------------------------------------------ + +if __name__ == '__main__': + + class MyEvents(Events): + __events__ = ('OnChange', ) + + class ValueModel(object): + def __init__(self): + self.events = MyEvents() + self.__value = None + def __set(self, value): + if (self.__value == value): return + self.__value = value + self.events.OnChange() + ##self.events.OnChange2() # would fail + def __get(self): + return self.__value + Value = property(__get, __set, None, 'The actual value') + + class SillyView(object): + def __init__(self, model): + self.model = model + model.events.OnChange += self.DisplayValue + ##model.events.OnChange2 += self.DisplayValue # would raise exeception + def DisplayValue(self): + print self.model.Value + + + model = ValueModel() + view = SillyView(model) + + print '\n--- Events Demo ---' + # Events in action + for i in range(5): + model.Value = 2*i + 1 + # Events introspection + print model.events + for event in model.events: + print event diff --git a/tests/pyatspi/pasytest/Makefile.am b/tests/pyatspi/pasytest/Makefile.am new file mode 100644 index 0000000..1fa89ed --- /dev/null +++ b/tests/pyatspi/pasytest/Makefile.am @@ -0,0 +1,6 @@ +EXTRA_DIST = \ + Events.py\ + Pasy.py\ + __init__.py + +CLEANFILES = *.pyc diff --git a/tests/pyatspi/pasytest/Pasy.py b/tests/pyatspi/pasytest/Pasy.py new file mode 100644 index 0000000..bb2651f --- /dev/null +++ b/tests/pyatspi/pasytest/Pasy.py @@ -0,0 +1,113 @@ +#Copyright (C) 2008 Codethink Ltd + +#his program is free software; you can redistribute it and/or modify +#it under the terms of the GNU General Public License as published by +#the Free Software Foundation; either version 2 of the License, or +#(at your option) any later version. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +from Events import Events + +PASY_TEST_NOT_STARTED = 0 +PASY_TEST_IN_PROGRESS = 1 +PASY_TEST_FAIL = 2 +PASY_TEST_WIN = 3 + +class PasyEvents(Events): + __events__ = ('finished', ) + +class PasyTestStep(object): + + def __init__(self, name): + self.events = PasyEvents() + self._state = PASY_TEST_NOT_STARTED + + self._name = name + self._test = test + + def win(self): + if self._state == PASY_TEST_IN_PROGRESS: + self._state = PASY_TEST_WIN + self.events.finished() + + def fail(self, msg): + if self._state == PASY_TEST_IN_PROGRESS: + self._state = PASY_TEST_FAIL + self.failMsg = msg + self.events.finished() + + def assertEqual(self, a, b, msg): + if a != b: + self.fail(msg) + + def run(self): + self._state = PASY_TEST_IN_PROGRESS + self.entry(self) + + @property + def state(self): + return self._state + +class PasyTestFunc(PasyTestStep): + + def __init__(self, name, func): + PasyTestStep.__init__(self, name) + self._func = func + + def entry(self): + self._func(self) + +class PasyTest(PasyTestStep): + + __tests__ = [] + + def __init__(self, name, cont): + PasyTest.__init__(self, name) + + self._cont = cont + self._tests = [] + + for name in __tests__: + func = self.__getattr__(name) + self._addfunc(func.func_name, func) + + def _addfunc(self, name, func): + functest = PasyTestFunc(self, func.func_name, func) + self.add(functest) + self._tests.append(functest) + + def entry(self): + self._iter = self._test_iterator + gobject.idle_add(self.idle_handler) + + def idle_handler(self): + try: + step = self._iter.next() + def finished_handler(): + if step.state == PASY_TEST_WIN or self._cont == True: + gobject.idle_add(self.idle_handler) + elif step.state == PASY_TEST_FAIL and self._cont == False: + self.fail() + step.events.failed += finished_handler + step.run() + except StopIteration: + # No More tests, check for success or fail + succeeded = True + for test in self._tests: + succeeded = succeeded and (test.state == PASY_TEST_WIN) + if succeeded: + self.win() + else: + self.fail() + return False + + def _test_iterator(self): + for test in self._tests: + yield test diff --git a/tests/pyatspi/pasytest/__init__.py b/tests/pyatspi/pasytest/__init__.py new file mode 100644 index 0000000..c54bff1 --- /dev/null +++ b/tests/pyatspi/pasytest/__init__.py @@ -0,0 +1,16 @@ +#Copyright (C) 2008 Codethink Ltd + +#his program is free software; you can redistribute it and/or modify +#it under the terms of the GNU General Public License as published by +#the Free Software Foundation; either version 2 of the License, or +#(at your option) any later version. + +#This program is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. +#You should have received a copy of the GNU General Public License +#along with this program; if not, write to the Free Software +#Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +from Pasy import PasyTestStep, PasyTestFunc, PasyTest diff --git a/tests/pyatspi/setvars.sh b/tests/pyatspi/setvars.sh new file mode 100755 index 0000000..17d1c48 --- /dev/null +++ b/tests/pyatspi/setvars.sh @@ -0,0 +1,6 @@ +export PYTHONPATH=../../../ + +export TEST_DATA_DIRECTORY=../data +export TEST_ATSPI_LIBRARY=../../atk-adaptor/.libs/libspiatk.so +export TEST_MODULES_DIRECTORY=../apps/.libs +export TEST_APPLICATION=../apps/test-application diff --git a/tests/pyatspi/testrunner.py b/tests/pyatspi/testrunner.py index 2b5be54..4a95f70 100755 --- a/tests/pyatspi/testrunner.py +++ b/tests/pyatspi/testrunner.py @@ -1,18 +1,69 @@ #!/usr/bin/python +import dbus import sys -import unittest -import clients +import time +from random import randint -def main(argv): - runner = unittest.TextTestRunner() - testsuite = unittest.defaultTestLoader.loadTestsFromModule(clients) - result = runner.run(testsuite) +def runTestApp(module_name, dbus_name=None): + import os + from subprocess import Popen + + test_data_directory = os.environ["TEST_DATA_DIRECTORY"] + test_modules_directory = os.environ["TEST_MODULES_DIRECTORY"] + test_atspi_library = os.environ["TEST_ATSPI_LIBRARY"] + test_application = os.environ["TEST_APPLICATION"] + + test_module = os.path.join(test_modules_directory, module_name) - if result.wasSuccessful(): - return 0 + if (dbus_name): + print " ".join([test_application, + "--atspi-dbus-name", dbus_name, + "--test-atspi-library", test_atspi_library, + "--test-module", test_module, + "--test-data-directory", test_data_directory,]) + pop = Popen([test_application, + "--atspi-dbus-name", dbus_name, + "--test-atspi-library", test_atspi_library, + "--test-module", test_module, + "--test-data-directory", test_data_directory,]) else: - return 1 + print " ".join([test_application, + "--test-atspi-library", test_atspi_library, + "--test-module", test_module, + "--test-data-directory", test_data_directory,]) + pop = Popen([test_application, + "--test-atspi-library", test_atspi_library, + "--test-module", test_module, + "--test-data-directory", test_data_directory,]) + + wait_message = """ + The test application %s has been started with PID %d. + + To continue the test press ENTER.\n\n + """ + if ("TEST_APP_WAIT_FOR_DEBUG" in os.environ.keys()): + raw_input(wait_message % (module_name, pop.pid)) + +def main(argv): + testModule = argv[1] + + # TODO Modify this function to add registryd as an option + bus = dbus.SessionBus() + name = "test.atspi.R" + str(randint(1, 1000)) + + app = runTestApp(testModule, name) + # Wait a little time for the app to start up + # TODO connect this up to the apps start signal + time.sleep(1) + + to = bus.get_object(name, "/org/codethink/atspi/test") + test = dbus.Interface(to, "org.codethink.atspi.test") + + # Run the test script here FIXME + + # Inform the test app it can shut down. + test.finish() if __name__=="__main__": sys.exit(main(sys.argv)) diff --git a/tests/pyatspi/testutil.py b/tests/pyatspi/testutil.py deleted file mode 100644 index e11302a..0000000 --- a/tests/pyatspi/testutil.py +++ /dev/null @@ -1,30 +0,0 @@ - -def runTestApp(module_name, dbus_name): - import os - from subprocess import Popen - - test_data_directory = os.environ["TEST_DATA_DIRECTORY"] - test_modules_directory = os.environ["TEST_MODULES_DIRECTORY"] - test_atspi_library = os.environ["TEST_ATSPI_LIBRARY"] - test_application = os.environ["TEST_APPLICATION"] - - test_module = os.path.join(test_modules_directory, module_name) - pop = Popen([test_application, - "--atspi-dbus-name", dbus_name, - "--test-atspi-library", test_atspi_library, - "--test-module", test_module, - "--test-data-directory", test_data_directory,]) - - print " ".join([test_application, - "--atspi-dbus-name", dbus_name, - "--test-atspi-library", test_atspi_library, - "--test-module", test_module, - "--test-data-directory", test_data_directory,]) - - wait_message = """ - The test application %s has been started with PID %d. - - To continue the test press ENTER.\n\n - """ - if ("TEST_APP_WAIT_FOR_DEBUG" in os.environ.keys()): - raw_input(wait_message % (module_name, pop.pid)) -- 2.7.4