Exemple #1
0
    def connect(self, file):
        '''
        Loads an accessible tree from the given file.

        :param file: A name of the XML file to load
        :type file: string
        '''
        def setPath(acc, parentPath=None):
            if parentPath is None:
                acc.path = Path()
            else:
                acc.path = parentPath.child(acc.index)
            for child in acc.children():
                setPath(child, acc.path)

        try:
            element = etree.ElementTree(file=file).getroot()
            acc = Accessible.unmarshal(element)
            if not acc.path.tuple:
                self._root = acc
            else:
                self._root = Accessible(Path(), children=(acc, ))
            acc.index = 0
            setPath(self._root)
        except Exception, err:
            self.messages.put(Error(err))
Exemple #2
0
    def connect(self, file):
        '''
        Loads an accessible tree from the given file.

        :param file: A name of the XML file to load
        :type file: string
        '''
        def setPath(acc, parentPath=None):
            if parentPath is None:
                acc.path = Path()
            else:
                acc.path = parentPath.child(acc.index)
            for child in acc.children():
                setPath(child, acc.path)

        try:
            element = etree.ElementTree(file=file).getroot()
            acc = Accessible.unmarshal(element)
            if not acc.path.tuple:
                self._root = acc
            else:                
                self._root = Accessible(Path(), children=(acc,))
            acc.index = 0
            setPath(self._root)
        except Exception, err:
            self.messages.put(Error(err))
Exemple #3
0
 def testSearchA11yResponse(self):
     accessible = Accessible(Path(0, 1, 2, 3))
     res = protocol.create(protocol.MSG_TYPE_RESPONSE,
                           protocol.MSG_TARGET_ACCESSIBILITY,
                           protocol.MSG_NAME_SEARCH,
                           accessible=accessible,
                           status=True)
     self.failUnless(isinstance(res, message.Response))
     cls = type(res)
     res = protocol.parse(res.marshal())
     self.failUnless(isinstance(res, cls))
     self.failUnlessEqual(res.accessible.path, accessible.path)
     self.failUnlessEqual(res.status, True)
def accessibilitySearch(processor,
                        path,
                        method,
                        name=None,
                        description=None,
                        role=None,
                        index=None,
                        count=None,
                        action=None,
                        relation=None,
                        state=None,
                        text=None,
                        nth=0):
    '''
    Searches an accessible using the given method according to specified
    accessible parameters.

    :param processor: A processor object calling the function
    :type processor: Processor
    :param path: A path of a demanded accessible
    :type path: tadek.core.accessible.Path
    :param method: A search method of accessible
    :type method: string
    :param name: A name of searched accessible or None
    :type name: string or NoneType
    :param description: A description of searched accessible or None
    :type description: string or NoneType
    :param role: A role of searched accessible or None
    :type role: string or NoneType
    :param index: An index of searched accessible or None
    :type index: integer or NoneType
    :param count: A child count of searched accessible or None
    :type count: string or NoneType
    :param action: An action of searched accessible or None
    :type action: string or NoneType
    :param relation: A relation of searched accessible or None
    :type relation: string or NoneType
    :param state: A state of searched accessible or None
    :type state: string or NoneType
    :param text: Text of searched accessible or None
    :type text: string or NoneType
    :param nth: A nth matched accessible
    :type nth: integer
    :return: A searching accessible status and an accessible of the given path
    :rtype: tuple
    '''
    log.debug(str(locals()))

    def matchString(pattern, string):
        '''
        Checks if the give string matches the regular expression pattern.
        '''
        if string is None:
            return False
        match = pattern.match(string)
        return match is not None and match.span() == (0, len(string))

    try:
        # Get object from the processor cache or from the accessible provider
        if processor.cache and processor.cache[-1] == path:
            a11y, obj, path = processor.cache
        else:
            a11y, obj = providers.accessible(path)
        # Reset the processor cache
        processor.cache = None
        if a11y is None and path.tuple:
            log.info("Accessible of requested path not found: %s" % path)
            return False, Accessible(path)
        if method == protocol.MHD_SEARCH_SIMPLE:
            provider = providers.Children
        elif method == protocol.MHD_SEARCH_BACKWARDS:
            provider = providers.ChildrenBackwards
        elif method == protocol.MHD_SEARCH_DEEP:
            provider = providers.Descendants
        else:
            log.error("Unknown search method: %s" % method)
            return False, Accessible(Path())
        if name and name[0] == '&':
            name = re.compile(name[1:], re.DOTALL)
            cmpName = matchString
        else:
            cmpName = lambda pattern, string: pattern == string
        if description and description[0] == '&':
            description = re.compile(description[1:], re.DOTALL)
            cmpDesc = matchString
        else:
            cmpDesc = lambda pattern, string: pattern == string
        if text and text[0] == '&':
            text = re.compile(text[1:], re.DOTALL)
            cmpText = matchString
        else:
            cmpText = lambda pattern, string: pattern == string
        i = 0
        for a11y, obj, path in provider(a11y, obj, path):
            if index is not None and index != path.index():
                continue
            if obj is None:
                if name is not None and not cmpName(name, a11y.name):
                    continue
                if count is not None and a11y.countChildren() != count:
                    continue
            else:
                if name is not None and not cmpName(name, a11y.getName(obj)):
                    continue
                if (description is not None and
                        not cmpDesc(description, a11y.getDescription(obj))):
                    continue
                if role is not None and a11y.getRoleName(obj) != role:
                    continue
                if count is not None and a11y.countChildren(obj) != count:
                    continue
                if action is not None:
                    found = False
                    for act in a11y.actionNames(obj):
                        if action == act:
                            found = True
                            break
                    if not found:
                        continue
                if relation is not None:
                    found = False
                    for rel in a11y.relationNames(obj):
                        if relation == rel:
                            found = True
                            break
                    if not found:
                        continue
                if (state is not None and not a11y.inState(
                        obj, getattr(a11y.stateset, state, None))):
                    continue
                if text is not None and not cmpText(text, a11y.getText(obj)):
                    continue
            i += 1
            if nth < i:
                processor.cache = (a11y, obj, path)
                return True, dumpAccessible(a11y,
                                            obj,
                                            path,
                                            depth=0,
                                            name=True,
                                            description=True,
                                            role=True,
                                            count=True,
                                            position=True,
                                            size=True,
                                            text=True,
                                            value=True,
                                            actions=True,
                                            states=True,
                                            attributes=True,
                                            relations=True)
    except:
        log.exception("Search an accessible of specified parmaters error")
        # Reset the processor cache before leaving
        processor.cache = None
        return False, Accessible(path)
    log.info("Search an accessible of specified parmaters failure")
    return False, Accessible(path)
def accessibilityGet(processor,
                     path,
                     depth,
                     name=False,
                     description=False,
                     role=False,
                     count=False,
                     position=False,
                     size=False,
                     text=False,
                     value=False,
                     actions=False,
                     states=False,
                     attributes=False,
                     relations=False):
    '''
    Gets an accessible of the given path and depth including specified
    accessible parameters.

    :param processor: A processor object calling the function
    :type processor: Processor
    :param path: A path of a demanded accessible
    :type path: tadek.core.accessible.Path
    :param depth: A depth of a demanded accessible tree
    :type depth: integer
    :param name: True if a demanded accessible should include name
    :type name: boolean
    :param description: True if a demanded accessible should include description
    :type description: boolean
    :param role: True if a demanded accessible should include role
    :type role: boolean
    :param count: True if a demanded accessible should include child count
    :type count: boolean
    :param position: True if a demanded accessible should include position
    :type position: boolean
    :param size: True if a demanded accessible should include size
    :type size: boolean
    :param text: True if a demanded accessible should include text
    :type text: boolean
    :param value: True if a demanded accessible should include value
    :type value: boolean
    :param actions: True if a demanded accessible should include actions
    :type actions: boolean
    :param states: True if a demanded accessible should include states
    :type states: boolean
    :param attributes: True if a demanded accessible should include attributes
    :type attributes: boolean
    :param relations: True if a demanded accessible should include relations
    :type relations: bool
    :return: A getting accessible status and an accessible of the given path
    :rtype: tuple
    '''
    log.debug(str(locals()))
    # Reset the processor cache
    processor.cache = None
    try:
        a11y, obj = providers.accessible(path)
        if a11y is None and path.tuple:
            log.info("Get accessible of requested path failure: %s" % path)
            return False, Accessible(path)
        processor.cache = (a11y, obj, path)
        return True, dumpAccessible(a11y,
                                    obj,
                                    path,
                                    depth=depth,
                                    name=name,
                                    description=description,
                                    role=role,
                                    count=count,
                                    position=position,
                                    size=size,
                                    text=text,
                                    value=value,
                                    actions=actions,
                                    states=states,
                                    attributes=attributes,
                                    relations=relations)
    except:
        log.exception("Get accessible of requested path error: %s" % path)
        return False, Accessible(path)
def dumpAccessible(a11y, obj, path, depth, name, description, role, count,
                   position, size, text, value, actions, states, attributes,
                   relations):
    '''
    Dumps the given accessible object and returns it as an Accessible instance.

    :param a11y: An accessibility releated to a given accessible object
    :type a11y: ModuleType
    :param obj: An accessible object to dump
    :type obj: accessible
    :param path: A path of a given accessible object
    :type path: tadek.core.accessible.Path
    :param depth: A depth of the dump
    :type depth: integer
    :param name: True if the dump should include accessible name
    :type name: boolean
    :param description: True if the dump should include accessible description
    :type description: boolean
    :param role: True if the dump should include accessible role
    :type role: boolean
    :param count: True if the dump should include number of accessible children
    :type count: boolean
    :param position: True if the dump should include accessible position
    :type position: boolean
    :param size: True if the dump should include accessible size
    :type size: boolean
    :param text: True if the dump should include accessible text
    :type text: boolean
    :param value: True if the dump should include accessible value
    :type value: boolean
    :param actions: True if the dump should include accessible actions
    :type actions: boolean
    :param states: True if the dump should include accessible states
    :type states: boolean
    :param attributes: True if the dump should include accessible attributes
    :type attributes: boolean
    :param relations: True if the dump should include accessible relations
    :type relations: bool
    :return: A dumped accessible object
    :rtype: tadek.core.accessible.Accessible
    '''
    log.debug(str(locals()))

    def getPath(a11y, obj, path):
        '''
        Gets a path of the given accessible object.
        '''
        # Insert indexes of accessibility and application of the object
        path = [path.tuple[0], path.tuple[1]]
        while obj is not None:
            path.insert(2, a11y.getIndex(obj))
            obj = a11y.getParent(obj)
        return path

    if obj is None and len(path.tuple) > 1:
        # Invalid accessible object
        return Accessible(path)
    try:
        children = []
        if depth != 0:
            for a, o, p in providers.Children(a11y, obj, path):
                children.append(
                    dumpAccessible(a, o, p, depth - 1, name, description, role,
                                   count, position, size, text, value, actions,
                                   states, attributes, relations))
        acc = Accessible(path, children)
        if a11y is None:
            if count:
                acc.count = providers.a11yCount
        elif obj is None:
            # Accessibility might have only name and numer of children
            if name:
                acc.name = a11y.name
            if count:
                acc.count = a11y.countChildren()
        else:
            if name:
                acc.name = a11y.getName(obj)
            if description:
                acc.description = a11y.getDescription(obj)
            if role:
                acc.role = a11y.getRoleName(obj)
            if count:
                acc.count = a11y.countChildren(obj)
            if position:
                acc.position = a11y.getPosition(obj)
            if size:
                acc.size = a11y.getSize(obj)
            if text:
                acc.text = a11y.getText(obj)
                acc.editable = a11y.inState(obj, a11y.stateset.EDITABLE)
            if value:
                acc.value = a11y.getValue(obj)
            if actions:
                acc.actions = [a for a in a11y.actionNames(obj)]
                if a11y.inState(obj, a11y.stateset.FOCUSABLE):
                    acc.actions.insert(0, A11Y_ACTION_FOCUS)
            if states:
                acc.states = [
                    a11y.stateset.name(s) for s in a11y.states(obj)
                    if a11y.stateset.name(s) is not None
                ]
            if attributes:
                acc.attributes = a11y.getAttributes(obj)
            if relations:
                for relation in a11y.relations(obj):
                    name = a11y.relationset.name(relation)
                    if name:
                        targets = [
                            Path(*getPath(a11y, t, path))
                            for t in a11y.relationTargets(obj, relation)
                        ]
                        acc.relations.append(Relation(name, targets))
    except:
        log.exception("Dumping accessible object error: %s" % path)
        acc = Accessible(path)
    return acc
Exemple #7
0
                    if i != idx:
                        return None
            except Exception, err:
                self.messages.put(Error(err))
                acc = None
            return acc

        extras = {}
        if self._root is None:
            self.messages.put(Error("XML client is not connected"))
        elif request.target == protocol.MSG_TARGET_ACCESSIBILITY:
            if request.name == protocol.MSG_NAME_GET:
                accessible = getAccessible(request.path)
                extras = {
                    "status": accessible is not None,
                    "accessible": accessible or Accessible(Path())
                }
            elif request.name == protocol.MSG_NAME_SEARCH:
                acc = getAccessible(request.path)
                # TODO: Currently not used
            elif request.name == protocol.MSG_NAME_PUT:
                extras = {"status": False}
            elif request.name == protocol.MSG_NAME_EXEC:
                extras = {"status": False}
        elif request.target == protocol.MSG_TARGET_SYSTEM:
            if request.name == protocol.MSG_NAME_GET:
                extras = {"status": False, "data": ''}
            elif request.name == protocol.MSG_NAME_PUT:
                extras = {"status": False}
            elif request.name == protocol.MSG_NAME_EXEC:
                extras = {"status": False, "stdout": '', "stderr": ''}
Exemple #8
0
def dumpAccessible(a11y, obj, path, depth, name, description, role, count,
                                           position, size, text, value, actions,
                                           states, attributes, relations):
    '''
    Dumps the given accessible object and returns it as an Accessible instance.

    :param a11y: An accessibility releated to a given accessible object
    :type a11y: ModuleType
    :param obj: An accessible object to dump
    :type obj: accessible
    :param path: A path of a given accessible object
    :type path: tadek.core.accessible.Path
    :param depth: A depth of the dump
    :type depth: integer
    :param name: True if the dump should include accessible name
    :type name: boolean
    :param description: True if the dump should include accessible description
    :type description: boolean
    :param role: True if the dump should include accessible role
    :type role: boolean
    :param count: True if the dump should include number of accessible children
    :type count: boolean
    :param position: True if the dump should include accessible position
    :type position: boolean
    :param size: True if the dump should include accessible size
    :type size: boolean
    :param text: True if the dump should include accessible text
    :type text: boolean
    :param value: True if the dump should include accessible value
    :type value: boolean
    :param actions: True if the dump should include accessible actions
    :type actions: boolean
    :param states: True if the dump should include accessible states
    :type states: boolean
    :param attributes: True if the dump should include accessible attributes
    :type attributes: boolean
    :param relations: True if the dump should include accessible relations
    :type relations: bool
    :return: A dumped accessible object
    :rtype: tadek.core.accessible.Accessible
    '''
    log.debug(str(locals()))
    def getPath(a11y, obj, path):
        '''
        Gets a path of the given accessible object.
        '''
        # Insert indexes of accessibility and application of the object
        path = [path.tuple[0], path.tuple[1]]
        while obj is not None:
            path.insert(2, a11y.getIndex(obj))
            obj = a11y.getParent(obj)
        return path
    if obj is None and len(path.tuple) > 1:
        # Invalid accessible object
        return Accessible(path)
    try:
        children = []
        if depth != 0:
            for a, o, p in providers.Children(a11y, obj, path):
                children.append(dumpAccessible(a, o, p, depth-1, name,
                                description, role, count, position, size, text,
                                value, actions, states, attributes, relations))
        acc = Accessible(path, children)
        if a11y is None:
            if count:
                acc.count = providers.a11yCount
        elif obj is None:
            # Accessibility might have only name and numer of children
            if name:
                acc.name = a11y.name
            if count:
                acc.count = a11y.countChildren()
        else:
            if name:
                acc.name = a11y.getName(obj)
            if description:
                acc.description = a11y.getDescription(obj)
            if role:
                acc.role = a11y.getRoleName(obj)
            if count:
                acc.count = a11y.countChildren(obj)
            if position:
                acc.position = a11y.getPosition(obj)
            if size:
                acc.size = a11y.getSize(obj)
            if text:
                acc.text = a11y.getText(obj)
                acc.editable = a11y.inState(obj, a11y.stateset.EDITABLE)
            if value:
                acc.value = a11y.getValue(obj)
            if actions:
                acc.actions = [a for a in a11y.actionNames(obj)]
                if a11y.inState(obj, a11y.stateset.FOCUSABLE):
                    acc.actions.insert(0, A11Y_ACTION_FOCUS)
            if states:
                acc.states = [a11y.stateset.name(s)
                              for s in a11y.states(obj)
                              if a11y.stateset.name(s) is not None]
            if attributes:
                acc.attributes = a11y.getAttributes(obj)
            if relations:
                for relation in a11y.relations(obj):
                    name = a11y.relationset.name(relation)
                    if name:
                        targets = [Path(*getPath(a11y, t, path))
                                   for t in a11y.relationTargets(obj, relation)]
                        acc.relations.append(Relation(name, targets))
    except:
        log.exception("Dumping accessible object error: %s" % path)
        acc = Accessible(path)
    return acc