# Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

''' A module verifying whether X events satisfy specified criteria '''

import logging
import math
import os
import re
import time
import utils

import trackpad_device
import trackpad_util

from operator import le, ge, eq, lt, gt, ne, and_


class XButton:
    ''' Manipulation of X Button labels and values '''

    # Define some common X button values
    Left = 1
    Middle = 2
    Right = 3
    Wheel_Up = 4
    Wheel_Down = 5
    Wheel_Left = 6
    Wheel_Right = 7
    Mouse_Wheel_Up = 8
    Mouse_Wheel_Down = 9

    def __init__(self):
        self.display_environ = trackpad_util.Display().get_environ()
        self.xinput_list_cmd = ' '.join([self.display_environ, 'xinput --list'])
        self.xinput_dev_cmd = ' '.join([self.display_environ,
                                        'xinput --list --long %s'])
        self.trackpad_dev_id = self._get_trackpad_dev_id()

    def _get_trackpad_dev_id(self):
        trackpad_dev_id = None
        if os.system('which xinput') == 0:
            input_dev_str = utils.system_output(self.xinput_list_cmd)
            for dev_str in input_dev_str.splitlines():
                res = re.search(r'(t(ouch|rack)pad\s+id=)(\d+)', dev_str, re.I)
                if res is not None:
                    trackpad_dev_id = res.group(3)
                    break
        return trackpad_dev_id

    def get_supported_buttons(self):
        ''' Get supported button labels from xinput

        a device returned from 'xinput --list' looks like:
        |   SynPS/2 Synaptics TouchPad       id=11   [slave  pointer (2)]

        Button labels returned from 'xinput --list <device_id>' looks like:
        Button labels: Button Left Button Middle Button Right Button Wheel Up
        Button Wheel Down Button Horiz Wheel Left Button Horiz Wheel Right
        Button 0 Button 1 Button 2 Button 3 Button 4 Button 5 Button 6
        Button 7
        '''
        DEFAULT_BUTTON_LABELS = (
                'Button Left', 'Button Middle', 'Button Right',
                'Button Wheel Up', 'Button Wheel Down',
                'Button Horiz Wheel Left', 'Button Horiz Wheel Right',
                'Button 0', 'Button 1', 'Button 2', 'Button 3',
                'Button 4', 'Button 5', 'Button 6', 'Button 7')

        if self.trackpad_dev_id is not None:
            features = utils.system_output(self.xinput_dev_cmd %
                                           self.trackpad_dev_id)
            button_labels_str = [line for line in features.splitlines()
                                 if line.lstrip().startswith('Button labels:')]
            strip_str = button_labels_str[0].lstrip().lstrip('Button labels:')
            self.button_labels = tuple(['Button ' + b.strip() for b in
                                        strip_str.split('Button')
                                        if len(b) > 0])
        else:
            logging.warn('Cannot find trackpad device in xinput. '
                         'Using default Button Labels instead.')
            self.button_labels = DEFAULT_BUTTON_LABELS
        logging.info('Button Labels (%d) in the trackpad: %s' %
                     (len(self.button_labels), self.button_labels))

        return self.button_labels

    def get_value(self, button_label):
        ''' Mapping an X button label to an X button value

        For example, 'Button Left' returns 1
                     'Button Wheel Up' returns 4
                     'Button Wheel Down' returns 5
        '''
        return self.button_labels.index(button_label) + 1

    def get_label(self, button_value):
        ''' Mapping an X button value to an X button label

        For example, 1 returns 'Button Left'
                     4 returns 'Button Wheel Up'
                     5 returns 'Button Wheel Down'
        '''
        return self.button_labels[button_value - 1]

    def get_index(self, button_label):
        ''' Mapping an X button label to its index in a button tuple

        Generally, a button index is equal to its button value decreased by 1.
        For example, 'Button Left' returns 0
                     'Button Wheel Up' returns 3
                     'Button Wheel Down' returns 4
        '''
        return self.button_labels.index(button_label)

    def init_button_struct(self, value):
        ''' Initialize a button dictionary to the given values. '''
        return dict(map(lambda b: (self.get_value(b), value),
                                  self.button_labels))


class Xcheck:
    ''' Check whether X events observe test criteria '''
    RESULT_STR = {True : 'Pass', False : 'Fail'}

    def __init__(self, dev):
        self.dev = dev
        self.xevent_data = None
        self.xbutton = XButton()
        self.button_labels = self.xbutton.get_supported_buttons()
        # Create a dictionary to look up button label
        #        e.g., {1: 'Button Left', ...}
        self.button_dict = dict(map(lambda b:
                                    (self.xbutton.get_value(b), b),
                                    self.button_labels))
        self._get_boot_time()

    def _get_boot_time(self):
        ''' Get the system boot up time

        Boot time can be used to convert the elapsed time since booting up
        to that since Epoch.
        '''
        stat_cmd = 'cat /proc/stat'
        stat = utils.system_output(stat_cmd)
        boot_time_tuple = tuple(int(line.split()[1])
                                for line in stat.splitlines()
                                if line.startswith('btime'))
        if len(boot_time_tuple) == 0:
            raise error.TestError('Fail to extract boot time by "%s"' %
                                  stat_cmd)
        self.boot_time = boot_time_tuple[0]

    def _calc_distance(self, x0, y0, x1, y1):
        ''' A simple Manhattan distance '''
        delta_x = abs(x1 - x0)
        delta_y = abs(y1 - y0)
        dist = round(math.sqrt(delta_x * delta_x + delta_y * delta_y))
        return [dist, [delta_x, delta_y]]

    def _parse_button_and_motion(self):
        ''' Parse button events and motion events

        The variable seg_move accumulates the motions of the contiguous events
        segmented by some boundary events such as Button events and other
        NOP events.
        A NOP (no operation) event is a fake X event which is
        used to indicate the occurrence of some related device events.
        '''

        # Define some functions for seg_move
        def _reset_seg_move():
            return [0, [0, 0]]

        def _append_motion_event(seg_move):
            self.event_seq.append(('Motion', (seg_move[0],
                                              ('Motion_x', seg_move[1][0]),
                                              ('Motion_y', seg_move[1][1]))))

        def _add_seg_move(seg_move, move):
            list_add = lambda list1, list2: map(sum, zip(list1, list2))
            return [seg_move[0] + move[0], list_add(seg_move[1], move[1])]

        self.count_buttons = self.xbutton.init_button_struct(0)
        self.count_buttons_press = self.xbutton.init_button_struct(0)
        self.count_buttons_release = self.xbutton.init_button_struct(0)
        self.button_states = self.xbutton.init_button_struct('ButtonRelease')

        pre_xy = [None, None]
        self.event_seq = []
        seg_move = _reset_seg_move()
        self.sum_move = 0

        indent1 = ' ' * 8
        indent2 = ' ' * 14
        log_msg = {True:  indent2 + '{0}   (button %d)',
                   False: indent2 + '{0} mis-matched  (button %d)'}
        precede_state = {'ButtonPress': 'ButtonRelease',
                         'ButtonRelease': 'ButtonPress',}
        logging.info(indent1 + 'X button events detected:')

        for line in self.xevent_data:
            event_name = line[0]
            if event_name != 'NOP':
                event_dict = line[1]
                if event_dict.has_key('coord'):
                    event_coord = list(eval(event_dict['coord']))
                if event_dict.has_key('button'):
                    event_button = eval(event_dict['button'])

            if event_name == 'EnterNotify':
                if pre_xy == [None, None]:
                    pre_xy = event_coord
            elif event_name == 'MotionNotify':
                if pre_xy == [None, None]:
                    pre_xy = event_coord
                else:
                    cur_xy = event_coord
                    move = self._calc_distance(*(pre_xy + cur_xy))
                    pre_xy = cur_xy
                    seg_move = _add_seg_move(seg_move, move)
                    self.sum_move += move[0]
            elif event_name.startswith('Button'):
                _append_motion_event(seg_move)
                seg_move = _reset_seg_move()
                button_label = self.xbutton.get_label(event_button)
                self.event_seq.append((event_name, button_label))
                prev_button_state = self.button_states[event_button]
                self.button_states[event_button] = event_name
                # A ButtonRelease should precede ButtonPress
                # A ButtonPress should precede ButtonRelease
                precede_flag = prev_button_state == precede_state[event_name]
                if event_name == 'ButtonPress':
                    self.count_buttons_press[event_button] += 1
                elif event_name == 'ButtonRelease':
                    self.count_buttons_release[event_button] += 1
                    self.count_buttons[event_button] += precede_flag
                logging.info(log_msg[precede_flag].format(event_name) %
                             event_button)
            elif event_name == 'NOP':
                _append_motion_event(seg_move)
                seg_move = _reset_seg_move()
                self.event_seq.append(('NOP', line[1]))

        _append_motion_event(seg_move)

        # Convert dictionary to tuple
        self.button_states = tuple(self.button_states.values())
        self.count_buttons= tuple(self.count_buttons.values())

    def _set_flags(self):
        ''' Set all flags to True before invoking check function '''
        self.motion_flag = True
        self.button_flag = True
        self.seq_flag = True
        self.delay_flag = True

    def _get_result(self):
        ''' Get the final result from various check flags '''
        flags = (self.motion_flag, self.button_flag, self.seq_flag,
                 self.delay_flag)
        self.result = flags[0] if len(flags) == 1 else reduce(and_, flags)
        logging.info('    --> Result: %s' % Xcheck.RESULT_STR[self.result])

    def _compare(self, ops):
        ''' Compare function generator

        Generate a function to compare two sequences using the specified
        operators.
        '''
        return lambda seq1, seq2: reduce(and_, map(lambda op, s1, s2:
                                                   op(s1, s2), ops, seq1, seq2))

    def _button_criteria(self, button):
        ''' Convert the key of the button tuple from label to index '''
        crit_button_count = [0,] * len(self.button_labels)
        if button is not None:
            button_label, button_value = button
            button_index = self.xbutton.get_index(button_label)
            crit_button_count[button_index] = button_value
        return tuple(crit_button_count)

    def _insert_nop(self, nop_str):
        ''' Insert a 'NOP' fake event into the xevent_data

        NOP is not an X event. It is inserted to indicate the occurrence of
        related device events.
        '''
        lifted_time = self.dev.get_2nd_finger_lifted_time()
        if lifted_time is None:
            logging.warn('Cannot get time for %s.' % nop_str)
        else:
            for index, line in enumerate(self.xevent_data):
                event_name = line[0]
                event_dict = line[1]
                if event_name == 'MotionNotify':
                    event_time = float(event_dict['time'])
                    if event_time > lifted_time:
                        self.xevent_data.insert(index, ('NOP', nop_str))
                        break

    def _get_direction(self):
        directions = ['left', 'right', 'up', 'down']
        file_name = self.gesture_file_name.split('-')[self.func_name_pos]
        for d in directions:
            if d in file_name:
                return d
        return None

    ''' _verify_xxx()
    Generic verification methods for various functionalities / areas
    '''

    def _verify_motion(self, compare, crit_max_movement):
        ''' Verify if the observed motions satisfy the criteria '''
        self.motion_flag = compare(self.sum_move, crit_max_movement)
        logging.info('        Verify motion: (%s)' %
                     Xcheck.RESULT_STR[self.motion_flag])
        logging.info('              Total movement = %d' % self.sum_move)

    def _verify_button(self, compare, crit_button_count):
        ''' Verify if the observed buttons satisfy the criteria '''
        count_flag = compare(self.count_buttons, crit_button_count)
        state_flags = map(lambda s: s == 'ButtonRelease', self.button_states)
        state_flag = reduce(and_, state_flags)
        self.button_flag = state_flag and count_flag

        logging.info('        Verify button: (%s)' %
                     Xcheck.RESULT_STR[self.button_flag])
        button_msg_details = '              %s %d times'
        count_flag = False
        for idx, b in enumerate(self.button_labels):
            if self.count_buttons[idx] > 0:
                logging.info(button_msg_details % (b, self.count_buttons[idx]))
                count_flag = True
        if not count_flag:
            logging.info('              No Button events detected.')


    def _verify_select_delay(self, crit_delay):
        ''' Verify if the delay time satisfy the criteria

        The delay time is defined to be the time interval between the time
        the 2nd finger touching the trackpad and the time of the corresponding
        X Motion event.
        '''
        # Extract scroll direction, i.e., 'up' or 'down', from the file name
        # We do not support scrolling 'left' or 'right' at this time.
        pos = self.func_name_pos
        direction = self._get_direction()

        # Derive the device event playback time when the 2nd finger touches
        dev_event_time = self.dev.get_2nd_finger_touch_time(direction)

        # Derive the motion event time of the 2nd finger
        found_ButtonPress = False
        event_time = None
        for line in self.xevent_data:
            event_name = line[0]
            event_dict = line[1]
            if not found_ButtonPress and event_name == 'ButtonPress':
                found_ButtonPress = True
            elif found_ButtonPress and event_name == 'MotionNotify':
                event_time = float(event_dict['time'])
                break

        if dev_event_time is None or event_time is None:
            delay = 'Not found'
            self.delay_flag = False
        else:
            delay = (event_time - dev_event_time) * 0.001
            self.delay_flag = delay < crit_delay
        logging.info('        Verify delay: (%s)' %
                     Xcheck.RESULT_STR[self.delay_flag])
        logging.info('              Delay time = %s (criteria = %f)' %
                     (str(delay), crit_delay))

    def _verify_select_sequence(self, crit_sequence):
        ''' Verify event sequence against criteria sequence

        For example, the following event_sequence matches crit_sequence.
        event_sequence: [('ButtonPress', 'Button Left'),
                         ('Motion', 68),
                         ('ButtonRelease', 'Button Left')]
        crit_sequence:  (('ButtonPress', 'Button Left'),
                         ('Motion', '>=', 20),
                         ('ButtonRelease', 'Button Left'))
        '''
        op_dict = {'>=': ge, '<=': le, '==': eq, '=': eq, '>': gt, '<': lt,
                   '!=': ne, '~=': ne, 'not': ne, 'is not': ne}
        op_le = op_dict['<=']
        axis_dict = {'left': 'x', 'right': 'x', 'up': 'y', 'down': 'y',
                     None: ''}
        self.seq_flag = True
        crit_move_ratio = self.criteria.get('move_ratio', 0)
        index = -1
        for e in self.event_seq:
            e_type, e_value = e
            fail_msg = None
            index += 1
            if index >= len(crit_sequence):
                fail_msg = 'Event (%s, %s) is extra compared to the criteria.'
                fail_para = (e_type, str(e_value))
                break
            crit_e = crit_sequence[index]
            crit_e_type = crit_e[0]

            if e_type.startswith('Motion'):
                motion_val = e_value[0]
                motion_x_val = e_value[1][1]
                motion_y_val = e_value[2][1]
                if crit_e_type.startswith('Motion'):
                    crit_e_op = crit_e[1]
                    crit_e_val = crit_e[2]
                    op = op_dict[crit_e_op]
                    if crit_e_type == 'Motion':
                        crit_check = op(motion_val, crit_e_val)
                        if not crit_check:
                            fail_msg = '%s %s does not satisfy %s. '
                            fail_para = (crit_e_type, str(e_value), str(crit_e))
                            break
                    elif crit_e_type == 'Motion_x_or_y':
                        axis = axis_dict[self._get_direction()]
                        motion_axis_dict = {'x': {'this':  motion_x_val,
                                                  'other': motion_y_val},
                                            'y': {'this':  motion_y_val,
                                                  'other': motion_x_val}}
                        motion_axis_val = motion_axis_dict[axis]['this']
                        motion_other_val = motion_axis_dict[axis]['other']

                        check_this_axis = op(motion_axis_val, crit_e_val)
                        # If the criteria requests that one axis move more
                        # than a threshold value, the other axis should move
                        # much less. This is to confirm that the movement is
                        # in the right direction.
                        other_axis_cond = crit_e_op == '>=' or crit_e_op == '>'
                        bound_other_axis = motion_axis_val * crit_move_ratio
                        check_other_axis = (not other_axis_cond or
                                    op_le(motion_other_val, bound_other_axis))
                        crit_check = check_this_axis and check_other_axis
                        if not crit_check:
                            fail_msg = '%s %s does not satisfy %s. ' \
                                       'Check motion for this axis = %s. ' \
                                       'Check motion for the other axis = %s'
                            fail_para = (crit_e_type, str(e_value), str(crit_e),
                                         check_this_axis, check_other_axis)
                            break
                    else:
                        fail_msg = '%s does not conform to the format.'
                        fail_para = crit_e_type
                        break
                else:
                    # No motion allowed
                    if e_value > 0:
                        fail_msg = 'Motion %d is not allowed.'
                        fail_para = e_value
                        break
            elif e_type == crit_e_type == 'ButtonPress' or \
                 e_type == crit_e_type == 'ButtonRelease':
                # Check if the button label matches criteria
                if e_value != crit_e[1]:
                    fail_msg = 'Button %s does not match %s.'
                    fail_para = (e_value, crit_e[1])
                    break
            elif e_type == crit_e_type == 'NOP':
                pass
            else:
                fail_msg = 'Event %s does not match criteria %s.'
                fail_para = (e_type, crit_e_type)
                break

        # Check if the criteria has been fully matched
        if fail_msg is None and index < len(crit_sequence) - 1:
            fail_msg = 'Some events are missing compared to the criteria: %s.'
            fail_para = str(crit_sequence)

        if fail_msg is not None:
            self.seq_flag = False

        logging.info('        Verify select sequence: (%s)' %
                     Xcheck.RESULT_STR[self.seq_flag])
        logging.info('              Detected event sequence')
        for e in self.event_seq:
            logging.info('                      ' + str(e))
        if not self.seq_flag:
            logging.info('              ' + fail_msg % fail_para)

    ''' _verify_area_xxx()
    The following methods are generally used for the group of functionalities
    in the same area.
    '''

    def _verify_all_criteria(self):
        ''' A general verification method for all criteria '''
        self._parse_button_and_motion()
        if self.criteria.has_key('max_movement'):
            crit_max_movement = self.criteria['max_movement']
            self._verify_motion(le, crit_max_movement)
        if self.criteria.has_key('button'):
            crit_button_count = self._button_criteria(self.criteria['button'])
            self._verify_button(eq, crit_button_count)
        if self.criteria.has_key('delay'):
            crit_delay = self.criteria['delay']
            self._verify_select_delay(crit_delay)
        if self.criteria.has_key('sequence'):
            crit_sequence = self.criteria['sequence']
            self._verify_select_sequence(crit_sequence)
        self._get_result()

    ''' _check_xxx()
    For each functionality xxx, there is a corresponding _check_xxx() method
    which is executed by run() automatically.
    '''

    ''' area 0: 1 finger point & click '''

    def _check_any_finger_click(self):
        ''' Any finger, including thumb, can click '''
        self._verify_all_criteria()

    def _check_any_angle_click(self):
        ''' Finger can be oriented at any angle relative to trackpad '''
        self._verify_all_criteria()

    def _check_any_location_click(self):
        ''' Click can occur at any location on trackpad (no hot zones) '''
        self._verify_all_criteria()

    def _check_no_min_width_click(self):
        ''' First finger should not have any minimum width defined for it
        (i.e., point and/or click with finger tip. E.g., click with fingernail)
        '''
        self._verify_all_criteria()

    def _check_no_cursor_wobble(self):
        ''' No cursor wobble, creep, or jumping (or jump back) during clicking
        '''
        self._verify_all_criteria()

    def _check_drum_roll(self):
        ''' Drum roll: One finger (including thumb) touches trackpad followed
        shortly (<500ms) by a second finger touching trackpad should not result
        in cursor jumping
        '''
        self._verify_all_criteria()

    ''' area 1: Click & select/drag '''

    def _check_single_finger_select(self):
        ''' (Single finger) Finger physical click or tap & a half, then finger -
        remaining in contact with trackpad - drags along surface of trackpad
        '''
        self._verify_all_criteria()

    def _check_single_finger_lifted(self):
        ''' (Single finger) If finger leaves trackpad for only 800ms-1s
        (Synaptics UX should know value), select/drag should continue
        '''
        self._verify_all_criteria()

    def _check_two_fingers_select(self):
        ''' (Two fingers) 1st finger click or tap & a half, 2nd finger's
        movement selects/drags
        '''
        self._verify_all_criteria()

    def _check_two_fingers_lifted(self):
        ''' (Two fingers) Continues to drag when second finger is lifted then
        placed again
        '''
        self._insert_nop('2nd Finger Lifted')
        self._verify_all_criteria()

    def _check_two_fingers_no_delay(self):
        ''' (Two fingers) Drag should be immediate (no delay between movement
        of finger and movement of selection/drag)
        '''
        self._verify_all_criteria()

    ''' area 2: 2 finger alternate/right click '''

    def _check_x_seconds_interval(self):
        ''' 1st use case: 1st finger touches trackpad, X seconds pass, 2nd
        finger touches trackpad, physical click = right click, where X is any
        number of seconds
        '''
        self._verify_all_criteria()

    def _check_roll_case(self):
        ''' 2nd use case ("roll case"): If first finger generates a click and
        second finger "rolls on" within 300ms of first finger click (again,
        rely on Synaptics UX to know value), an alternate/right click results
        '''
        self._verify_all_criteria()

    def _check_one_finger_tracking(self):
        ''' 1 finger tracking, never leaves trackpad, 2f arrives and there is
        a click. right click results.
        '''
        self._verify_all_criteria()

    ''' area 3: 2 finger scroll '''

    def _check_two_finger_scroll(self):
        ''' Vertical scroll, reflecting movement of finger(s)

        Criteria:
        1. sum of movement is less than crit_max_movement
        2. if subname in the file name is up:
               A number of button 4 (Wheel Up) events should be observed
               without other button events.
           elif subname in the file name is down:
               A number of button 5 (Wheel Down) events should be observed
               without other button events.
        '''
        # Extract scroll direction, i.e., 'up' or 'down', from the file name
        pos = self.func_name_pos
        direction = self._get_direction()

        # Get criteria for max movement and wheel up/down
        crit_max_movement = self.criteria['max_movement']
        ops = [eq,] * len(self.button_labels)
        if direction == 'up':
            button_label = self.xbutton.get_label(self.xbutton.Wheel_Up)
            ops[self.xbutton.get_index(button_label)] = ge
            crit_up = self.criteria['button'][0]
            crit_button_count = self._button_criteria(crit_up)
        elif direction == 'down':
            button_label = self.xbutton.get_label(self.xbutton.Wheel_Down)
            ops[self.xbutton.get_index(button_label)] = ge
            crit_down = self.criteria['button'][1]
            crit_button_count = self._button_criteria(crit_down)
        else:
            msg = '      scroll direction in the file name is not correct: (%s)'
            logging.info(msg % direction)
            self.result = False
            return

        self._parse_button_and_motion()
        self._verify_motion(le, crit_max_movement)
        self._verify_button(self._compare(tuple(ops)), crit_button_count)
        self._get_result()

    ''' area 4: Palm/thumb detection '''

    ''' parse and run below '''

    def _extract_prop(self, event_name, line, prop_key):
        ''' Extract property from X events '''
        if line is None:
            logging.warn('      X event format may not be correct.')
            return None

        # Declare the format to extract information from X event structures
        format_dict = {
            'Motion_coord'  : '{6}',
            'Motion_time'   : '{5}',
            'Motion_tv'     : '{7}',
            'Button_coord'  : '{6}',
            'Button_button' : '{3}',
            'Button_time'   : '{5}',
            'Button_tv'     : '{7}',
        }
        event_format_str = format_dict[event_name]

        try:
            prop_val = event_format_str.format(*line.strip().split()).strip(',')
        except IndexError, err:
            logging.warn('      %s in X event data.' % str(err))
            return None
        return (prop_key, prop_val)

    def _parse(self, xevent_str):
        ''' Parse all X events

        The event information of a single X event may span across multiple
        lines. This function extracts the important event information of
        an event into a dictionary so that it is easier to process in
        subsequent stages.

        For example:
        A MotionNotify event looks like:
            MotionNotify event, serial 25, synthetic NO, window 0xa00001,
                root 0xab, subw 0x0, time 925196, (750,395), root:(750,395),
                state 0x0, is_hint 0, same_screen YES

        A ButtonPress event looks like:
            ButtonPress event, serial 25, synthetic NO, window 0xa00001,
                root 0xab, subw 0x0, time 1098904, (770,422), root:(770,422),
                state 0x0, button 1, same_screen YES

        The property extracted for the MotionNotify event looks like:
            ['MotionNotify', {'coord': (150,200), 'time': ...]

        The property extracted for the ButtonPress event looks like:
            ['ButtonPress', {'coord': (150,200), 'button': 5}, 'time': ...]
        '''

        if len(xevent_str) == 0:
            logging.warn('    No X events were captured.')
            return False

        xevent_iter = iter(xevent_str)
        self.xevent_data = []
        while True:
            line = next(xevent_iter, None)
            if line is None:
                break
            line_words = line.split()
            if len(line_words) > 0:
                event_name = line_words[0]
            else:
                continue

            # Extract event information for important event types
            if event_name == 'MotionNotify' or event_name == 'EnterNotify':
                line1 = next(xevent_iter, None)
                line2 = next(xevent_iter, None)
                prop_coord = self._extract_prop('Motion_coord', line1, 'coord')
                prop_time = self._extract_prop('Motion_time', line1, 'time')
                if prop_coord is not None and prop_time is not None:
                    event_dict = dict([prop_coord, prop_time])
                    self.xevent_data.append([event_name, event_dict])
            elif line.startswith('Button'):
                line1 = next(xevent_iter, None)
                line2 = next(xevent_iter, None)
                prop_coord = self._extract_prop('Button_coord', line1, 'coord')
                prop_time = self._extract_prop('Button_time', line1, 'time')
                prop_button = self._extract_prop('Button_button', line2,
                                                 'button')
                if (prop_coord is not None and prop_button is not None
                                           and prop_time is not None):
                    event_dict = dict([prop_coord, prop_button, prop_time])
                    self.xevent_data.append([event_name, event_dict])
        return True

    def run(self, tp_func, tp_data,  xevent_str):
        ''' Parse the x events and invoke a proper check function

        Invoke the corresponding check function based on its functionality name.
        For example, tp_func.name == 'no_cursor_wobble' will result in the
        invocation of self._check_no_cursor_wobble()
        '''
        parse_result = self._parse(xevent_str)
        self.gesture_file_name = tp_data.file_basename
        self.func_name_pos = 0 if tp_data.prefix is None else 1
        self.criteria = tp_func.criteria
        if parse_result:
            check_function = eval('self._check_' + tp_func.name)
            self._set_flags()
            check_function()
            return self.result
        else:
            return False