root/projects/WinDictator/trunk/windictator/linux/keycodes.py

# WinDictator:
# Dictate in Windows, have the text typed in Linux via X faked keystroke events
#
# Copyright (C) 2005-2006 by Edwin A. Suominen, http://www.eepatents.com
#
# This 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 file COPYING 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., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA


"""
Conversions to and from keycodes
"""

import re
from os import environ
from twisted.internet import utils


class KeyCoder:
    """
    I take care of conversions from text to sequences of fake keystrokes.
    """
    def __init__(self):
        self.specialSingles = {
            ' '  : ('space',),
            '.'  : ('period',),
            '!'  : ('Shift_L', '1'),
            '@'  : ('Shift_L', '2'),
            '#'  : ('Shift_L', '3'),
            '$'  : ('Shift_L', '4'),
            '%'  : ('Shift_L', '5'),
            '^'  : ('Shift_L', '6'),
            '&'  : ('Shift_L', '7'),
            '('  : ('Shift_L', '9'),
            ')'  : ('Shift_L', '0'),
            '*'  : ('Shift_L', '8'),
            '+'  : ('Shift_L', 'plus'),
            ','  : ('comma',),
            '-'  : ('minus',),
            "'"  : ('apostrophe',),
            '"'  : ('Shift_L', 'apostrophe'),
            '/'  : ('slash',),
            '='  : ('plus',),
            '`'  : ('grave',),
            '~'  : ('Shift_L', 'grave'),
            ';'  : ('semicolon',),
            ':'  : ('Shift_L', 'semicolon'),
            '?'  : ('Shift_L', 'slash'),
            '['  : ('bracketleft',),
            ']'  : ('bracketright',),
            '_'  : ('Shift_L', 'minus'),
            '|'  : ('Shift_L', 'backslash'),
            '<'  : ('Shift_L', 'comma'),
            '>'  : ('Shift_L', 'period'),
            '{'  : ('Shift_L', 'bracketleft'),
            '}'  : ('Shift_L', 'bracketright'),

            '\n' : ('Return',),
            '\t' : ('Tab',),
            '\\' : ('backslash',)
            }
        upperCases = {}
        for char in 'abcdefghijklmnopqrstuvwxyz':
            upperCases[char.capitalize()] = ('Shift_L', char)
        self.upperCases = upperCases

    def textToKeys(self, text):
        """
        Consumes text from left to right, converting each matching character
        pair or single character to a sequence of keycode strings and returning
        a list of all such sequences in the order they are to be entered as
        faked keystrokes.
        """
        k = 0
        keyList = []
        while k < len(text):
            singleCandidate = text[k]
            k += 1
            if singleCandidate in self.specialSingles:
                keyList.append(self.specialSingles[singleCandidate])
            elif singleCandidate in self.upperCases:
                keyList.append(self.upperCases[singleCandidate])
            else:
                keyList.append((singleCandidate,))
        return keyList


class KeyDecoder:
    """
    I take care of conversions from combinations of keycodes to text.
    """
    reLine = re.compile(r'keycode\s+(\d+)\s*\=\s*(\w+)\s+(\w+)')
    keycodes = {}
    specialSingles = {
        'exclam':                   '!',
        'at':                       '@',
        'numbersign':               '#',
        'dollar':                   '$',
        'percent':                  '%',
        'asciicircum':              '%',
        'ampersand':                '&',
        'asterisk':                 '*',
        'parenleft':                '(',
        'parenright':               ')',
        'minus':                    '-',
        'underscore':               '_',
        'equal':                    '=',
        'plus':                     '+',
        'Tab':                      chr(9),
        'bracketleft':              chr(91),
        'braceleft':                chr(123),
        'bracketright':             chr(93),
        'braceright':               chr(125),
        'Return':                   chr(10),
        'semicolon':                ';',
        'colon':                    ':',
        'apostrophe':               chr(39),
        'quotedbl':                 chr(34),
        'grave':                    '`',
        'asciitilde':               '~',
        'backslash':                chr(92),
        'bar':                      '|',
        'comma':                    ',',
        'less':                     '<',
        'period':                   '.',
        'greater':                  '>',
        'slash':                    '/',
        'question':                 '?',
        'space':                    chr(32)
        }

    def startup(self):
        """
        """
        d = utils.getProcessOutputAndValue(
            '/usr/bin/xmodmap', args=("-pke",), env=environ)
        d.addCallback(self._parse)
        return d

    def _parse(self, lines):
        """
        Parses the output of I{xmodmap} to build up a keycode dictionary
        """
        self.table = {}
        for line in lines:
            match = self.reLine.search(line)
            if match:
                keycode, keyLower, keyUpper = match.groups()
                self.keycodes[keycode] = (keyLower, keyUpper)
    
    def decode(self, *keycodeList):
        """
        Converts the combination of I{keycodeList} supplied as one or more
        arguments into a text character.

        Currently the args can only be a single keycode, with or without the
        code for the left or right shift key. There's probably no need to go
        beyond that.
        """
        shiftKeys = [x for x in (50, 62) if x in keycodeList]
        if shiftKeys:
            keycodeList.remove(shiftKeys[0])
            k = 1
        else:
            k = 0
        symTuple = self.keycodes.get(keycodeList[0], ('',''))
        keySym = symTuple[k]
        return self.specialSingles.get(keySym, keySym)