← Back to branch summary

~ubuntu-branches/ubuntu/trusty/dogtail/trusty

« back to all changes in this revision

Viewing changes to dogtail/rawinput.py

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2006-12-21 13:33:47 UTC
  • mfrom: (1.1.2 upstream) (3.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20061221133347-ljwbyiu04qd6uzvz
Tags: 0.6.1-3ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: use dh_iconcache.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dogtail/rawinput.py
11
11
"""
12
12
 
13
13
import atspi
 
14
import gtk.keysyms
 
15
import gtk.gdk
 
16
from config import config
14
17
from utils import doDelay
15
18
from logging import debugLogger as logger
 
19
ev = atspi.EventGenerator()
 
20
 
 
21
def doTypingDelay():
 
22
    doDelay(config.typingDelay)
16
23
 
17
24
def click (x, y, button = 1):
18
 
        """
19
 
        Synthesize a mouse button click at (x,y)
20
 
        """
21
 
        logger.log("Mouse button %s click at (%s,%s)"%(button,x,y))
22
 
        ev = atspi.EventGenerator()
23
 
        ev.click(x, y, button)
24
 
        doDelay()
25
 
        
 
25
    """
 
26
    Synthesize a mouse button click at (x,y)
 
27
    """
 
28
    logger.log("Mouse button %s click at (%s,%s)"%(button,x,y))
 
29
    ev.click(x, y, button)
 
30
    doDelay()
 
31
 
26
32
def doubleClick (x, y, button = 1):
27
 
        """
28
 
        Synthesize a mouse button double-click at (x,y)
29
 
        """
30
 
        logger.log("Mouse button %s doubleclick at (%s,%s)"%(button,x,y))
31
 
        ev = atspi.EventGenerator()
32
 
        ev.doubleClick(x,y,button)
33
 
        doDelay()
 
33
    """
 
34
    Synthesize a mouse button double-click at (x,y)
 
35
    """
 
36
    logger.log("Mouse button %s doubleclick at (%s,%s)"%(button,x,y))
 
37
    ev.doubleClick(x,y,button)
 
38
    doDelay()
34
39
 
35
40
def press (x, y, button = 1):
36
 
        """
37
 
        Synthesize a mouse button press at (x,y)
38
 
        """
39
 
        logger.log("Mouse button %s press at (%s,%s)"%(button,x,y))
40
 
        ev = atspi.EventGenerator()
41
 
        ev.press(x,y, button)
42
 
        doDelay()
43
 
        
 
41
    """
 
42
    Synthesize a mouse button press at (x,y)
 
43
    """
 
44
    logger.log("Mouse button %s press at (%s,%s)"%(button,x,y))
 
45
    ev.press(x,y, button)
 
46
    doDelay()
 
47
 
44
48
def release (x, y, button = 1):
45
 
        """
46
 
        Synthesize a mouse button release at (x,y)
47
 
        """
48
 
        logger.log("Mouse button %s release at (%s,%s)"%(button,x,y))
49
 
        ev = atspi.EventGenerator()
50
 
        ev.release(x,y,button)
51
 
        doDelay()
 
49
    """
 
50
    Synthesize a mouse button release at (x,y)
 
51
    """
 
52
    logger.log("Mouse button %s release at (%s,%s)"%(button,x,y))
 
53
    ev.release(x,y,button)
 
54
    doDelay()
52
55
 
53
56
def absoluteMotion (x, y):
54
 
        """
55
 
        Synthesize mouse absolute motion to (x,y)
56
 
        """
57
 
        logger.log("Mouse absolute motion to (%s,%s)"%(x,y))
58
 
        ev = atspi.EventGenerator()
59
 
        ev.absoluteMotion(x,y)
60
 
        doDelay()
 
57
    """
 
58
    Synthesize mouse absolute motion to (x,y)
 
59
    """
 
60
    logger.log("Mouse absolute motion to (%s,%s)"%(x,y))
 
61
    ev.absoluteMotion(x,y)
 
62
    doDelay()
61
63
 
62
64
def relativeMotion (x, y):
63
 
        logger.log("Mouse relative motion of (%s,%s)"%(x,y))
64
 
        ev = atspi.EventGenerator()
65
 
        ev.relativeMotion(x,y)
66
 
        doDelay()
 
65
    logger.log("Mouse relative motion of (%s,%s)"%(x,y))
 
66
    ev.relativeMotion(x,y)
 
67
    doDelay()
67
68
 
68
69
def drag(fromXY, toXY, button = 1):
69
 
        """
70
 
        Synthesize a mouse press, drag, and release on the screen.
71
 
        Wraps atspi.EventGenerator.drag, but with logging and delays.
72
 
        """
73
 
        logger.log("Mouse button %s drag from %s to %s"%(button, fromXY, toXY))
74
 
        ev = atspi.EventGenerator()
75
 
 
76
 
        # A direct call to ev.drag doesn't work, delays seem to be needed
77
 
        # for nautilus icon view to work, at least:
78
 
                
79
 
        (x,y) = fromXY
80
 
        ev.press (x, y, button)
81
 
        #doDelay()
82
 
 
83
 
        (x,y) = toXY
84
 
        ev.absoluteMotion(x,y)
85
 
        doDelay()
86
 
        
87
 
        ev.release (x, y, button)
88
 
        doDelay()
 
70
    """
 
71
    Synthesize a mouse press, drag, and release on the screen.
 
72
    Wraps atspi.EventGenerator.drag, but with logging and delays.
 
73
    """
 
74
    logger.log("Mouse button %s drag from %s to %s"%(button, fromXY, toXY))
 
75
 
 
76
    # A direct call to ev.drag doesn't work, delays seem to be needed
 
77
    # for nautilus icon view to work, at least:
 
78
 
 
79
    (x,y) = fromXY
 
80
    ev.press (x, y, button)
 
81
    #doDelay()
 
82
 
 
83
    (x,y) = toXY
 
84
    ev.absoluteMotion(x,y)
 
85
    doDelay()
 
86
 
 
87
    ev.release (x, y, button)
 
88
    doDelay()
89
89
 
90
90
def typeText(string):
91
 
        """
92
 
        Types the specified string, one character at a time.
93
 
        """
94
 
        ev = atspi.EventGenerator()
95
 
        ev.injectKeyboardString(string)
96
 
 
97
 
keySyms = {
98
 
        'enter' : 0xff0d,
99
 
        'esc' : 0xff1b,
100
 
        'space' : 0x20
 
91
    """
 
92
    Types the specified string, one character at a time.
 
93
    """
 
94
    if not isinstance(string, unicode):
 
95
        string = string.decode('utf-8')
 
96
    for char in string:
 
97
        pressKey(char)
 
98
 
 
99
def __buildKeyStringsDict(keySymsDict):
 
100
    syms = {}
 
101
    keyStringsDict = {}
 
102
    iter = keySymsDict.iteritems()
 
103
    while True:
 
104
        try:
 
105
            item = iter.next()
 
106
            """
 
107
            if item[1] in syms.keys():
 
108
                syms[item[1]].append(item[0])
 
109
                print item[1], syms[item[1]]
 
110
            else: 
 
111
                try: syms[item[1]] = [item[0]]
 
112
                except TypeError: pass
 
113
            """
 
114
            try:
 
115
                if not keyStringsDict.has_key(item[1]):
 
116
                    keyStringsDict[item[1]] = item[0]
 
117
            except TypeError: pass
 
118
        except StopIteration:
 
119
            return keyStringsDict
 
120
 
 
121
keySyms = gtk.keysyms.__dict__
 
122
keyStrings = __buildKeyStringsDict(keySyms)
 
123
 
 
124
keySymAliases = {
 
125
    'enter' : 'Return',
 
126
    'esc' : 'Escape',
 
127
    'alt' : 'Alt_L',
 
128
    'control' : 'Control_L',
 
129
    'ctrl' : 'Control_L',
 
130
    'shift' : 'Shift_L',
 
131
    'del' : 'Delete',
 
132
    'ins' : 'Insert',
 
133
    'pageup' : 'Page_Up',
 
134
    'pagedown' : 'Page_Down',
 
135
    ' ' : 'space',
 
136
    '\t' : 'Tab',
 
137
    '\n' : 'Return'
101
138
}
102
139
 
 
140
def keySymToUniChar(keySym):
 
141
    i = gtk.gdk.keyval_to_unicode(keySym)
 
142
    if i: UniChar = unichr(i)
 
143
    else: UniChar = ''
 
144
    return UniChar
 
145
 
 
146
def uniCharToKeySym(uniChar):
 
147
    i = ord(uniChar)
 
148
    keySym = gtk.gdk.unicode_to_keyval(i)
 
149
    return keySym
 
150
 
103
151
def pressKey(keyName):
104
 
        """
105
 
        Presses (and releases) the key specified by keyName.
106
 
        keyName is the English name of the key as seen on the keyboard. Ex: 'enter'
107
 
        Names are looked up in the keySyms dict.
108
 
        """
109
 
        ev = atspi.EventGenerator()
110
 
        keySym = keySyms[keyName.lower()]
111
 
        ev.generateKeyboardEvent(keySym, "", atspi.SPI_KEY_SYM)
 
152
    """
 
153
    Presses (and releases) the key specified by keyName.
 
154
    keyName is the English name of the key as seen on the keyboard. Ex: 'enter'
 
155
    Names are looked up in the keySyms dict. If they are not found there, 
 
156
    they are looked up by uniCharToKeySym().
 
157
    """
 
158
    try:
 
159
        keyName = keySymAliases.get(keyName.lower(), keyName)
 
160
        keySym = keySyms[keyName]
 
161
    except KeyError:
 
162
        try: keySym = uniCharToKeySym(keyName)
 
163
        except TypeError: raise KeyError, keyName
 
164
    ev.generateKeyboardEvent(keySym, "", atspi.SPI_KEY_SYM)
 
165
    doTypingDelay()
 
166
 
 
167
def keyCombo(comboString):
 
168
    """
 
169
    Generates the appropriate keyboard events to simulate a user pressing the
 
170
    specified key combination.
 
171
 
 
172
    comboString is the representation of the key combo to be generated.
 
173
    e.g. '<Control><Alt>p' or '<Control><Shift>PageUp' or '<Control>q'
 
174
    """
 
175
    strings = []
 
176
    for s in comboString.split('<'):
 
177
        if s:
 
178
            for S in s.split('>'):
 
179
                if S:
 
180
                    S = keySymAliases.get(S.lower(), S)
 
181
                    strings.append(S)
 
182
    for s in strings:
 
183
        if not keySyms.has_key(s):
 
184
            raise ValueError, "Cannot find key %s" % s
 
185
 
 
186
    ev.generateKeyCombo(strings)
 
187
    doDelay()
 
188
 
112
189