Python keyboard.Keyboard类代码示例

 def test_key_prox_keys(self):
     kb = Keyboard('US')
     for inp, res in [('a', 'aqwsxz'),
                      ('t', 'tr456yhgf'),
                      (';', ";lop['/.")]:
         ret = kb.keyboard_prox_key(inp)
         assert set(ret) == set(res)

 def test_part_key_presses(self, inp, res):
     res = res.format(**key)
     kb = Keyboard('US')
     i = random.randint(0, len(res))
     pre_word, shift, caps = kb.part_key_press_string(res[:i])
     post_word, shift, caps = kb.part_key_press_string(res[i:], shift, caps)
     assert inp == pre_word + post_word

 def dispense_and_scan(self, author_selection):
     j = 0
     #f = open(self.dispenserDevices[0], "wb")
     f = open("/dev/ttyUSB0", "wb")
     f.write("020180000380".decode("hex"))
     f.flush()
     f.close()
     #k = Keyboard(self.scannerKeyDev[0])
     k = Keyboard("/dev/input/event0")
     k.flush()
     code = ""
     i = 0
     #return code
     start_time = time.time()
     while i < 8:
         key = k.readKey()
         #print key
         if key is not None:
             code += key
             i += 1
         end_time = time.time() - start_time 
         #self.write_log("end time = "+str(end_time))
         if(end_time > 4):
             self.write_log("reader time out!!")
             break;
     self.write_log("Dispensing from card dispenser " + str(0))
     self.write_log("device = "+str(self.dispenserDevices[0]))
     self.write_log("scanner device = "+str(self.scannerKeyDev[0]))
     return code

 def test_word_to_key_press(self, inp, res):
     key = {'c': CAPS_KEY,
            's': SHIFT_KEY}
     KB = Keyboard('US')
     t1 = KB.word_to_key_presses(inp)
     t2 = res.format(**key)
     assert t1 == t2, "{!r} <--> {!r}".format(t1, t2)

 def test_other_key_presses_to_word(self, inp, res):
     key = {'c': CAPS_KEY,
            's': SHIFT_KEY}
     KB = Keyboard('US')
     kw = KB.key_presses_to_word('{c}asdf{s}1{c}sdf'.format(**key))
     assert 'ASDFasdf' == KB.key_presses_to_word('{c}asdf{s}a{c}sdf'.format(**key))
     assert 'ASDF!sdf' == KB.key_presses_to_word('{c}asdf{s}1{c}sdf'.format(**key))
     assert KB.key_presses_to_word('{s}apa'.format(**key)) == 'Apa'

    def setup_network_connection(self):
        Keyboard.show(layout=[])

        from subprocess import Popen
        if self.wicd is not None:
            if self.wicd.poll() is None:
                return
        self.wicd = Popen(['xterm', '-maximized', '-e', 'wicd-curses'])

 def test_loc(self):
     inp_res_map = [(('t'), (1,5,0)),
                   (('T'), (1,5,1)),
                   (('a'), (2,1,0)),
                   (('('), (0,9,1)),
                   (('M'), (3,7,1))]
     kb = Keyboard('US')
     for q, r in inp_res_map:
         assert kb.loc(*q) == r

 def volume_down():
     """
     Decrease system volume
     Done by triggering a fake VK_VOLUME_DOWN key event
     :return: void
     """
     Sound.__track()
     Sound.__set_current_volume(Sound.current_volume() - 2)
     Keyboard.key(Keyboard.VK_VOLUME_DOWN)

 def volume_up():
     """
     Increase system volume
     Done by triggering a fake VK_VOLUME_UP key event
     :return: void
     """
     Sound.__track()
     Sound.__set_current_volume(Sound.current_volume() + 2)
     Keyboard.key(Keyboard.VK_VOLUME_UP)

 def mute():
     """
     Mute or un-mute the system sounds
     Done by triggering a fake VK_VOLUME_MUTE key event
     :return: void
     """
     Sound.__track()
     Sound.__is_muted = (not Sound.__is_muted)
     Keyboard.key(Keyboard.VK_VOLUME_MUTE)

 def test_sub_word_table(self, inp, res):
     kb = Keyboard('US')
     res = res.format(**key)
     A = kb.sub_word_table(res)
     print '\n'.join(str(x) for x in A)
     for i in xrange(len(res)):
         pre_w, shift, caps = A[i][0]
         post_w = A[i][2*shift + caps + 1][0]
         assert pre_w + post_w == inp

 def test_keyboard_dist(self):
     inp_res_map = [(('t', 't'), (0)),
                    (('t', 'T'), (0.8)),
                    (('a', 'S'), (1.8)),
                    (('a', 'w'), (2)),
                    (('w', '$'), (3.8)),
                    (('<', '>'), (1))
                ]
     kb = Keyboard('US')
     for q, r in inp_res_map:
         assert kb.keyboard_dist(*q) == r

 def test_key_press_insert_edits(self, inp, res):
     inp_res_map = [(('{s}pa'.format(**key), [CAPS_KEY, SHIFT_KEY, 'a'], [CAPS_KEY, 't']),
                     ('pA', 'Pa', 'aPa', 'pa', 'PA', 'tpa', # j=0
                      'pA', 'Pa', 'Apa', 'A', 'a', 'Ta',   # j=1
                      'PA', 'PA', 'Paa', 'P', 'P', 'Pt',   # j=2
                      'Paa'))
     ]
     kb = Keyboard('US')
     for inp, res in inp_res_map:
         for i,r in enumerate(kb.key_press_insert_edits(*inp)):
             print i,r,res[i]
             assert r == res[i]

class Gui:
    def __init__(self, navdb):
        splash.show()
        self.keyb = Keyboard()                                # processes input from keyboard & mouse
        self.scr  = Screen()                                  # screen output object

    def update(self, sim):
        self.keyb.update(sim, sim.stack, self.scr, sim.traf)  # Check for keys & mouse
        self.scr.update(sim, sim.traf)                        # GUI update

    def reset(self):
        self.scr.objdel()                                     # Delete user defined objects

    def close(self):
        pg.quit()

def main():
    win = Window(fullscreen=True, visible=False)
    camera = Camera(win.width, win.height, (0, 0), 100)
    renderer = Renderer()
    maze = Maze()
    maze.create(50, 30, 300)
    keyboard = Keyboard()
    keyboard.key_handlers[key.ESCAPE] = win.close
    keyboard.key_handlers.update(camera.key_handlers)
    clock.schedule(maze.update)
    win.on_draw = lambda: renderer.on_draw(maze, camera, win.width, win.height)
    win.on_key_press = keyboard.on_key_press
    keyboard.print_handlers()
    win.set_visible()
    app.run()