Python key.symbol_string函数代码示例

    def _key_callback(self, symbol, modifiers, event_time):
        # check the key and time (if this is needed)
        keys = val(self.keys)
        correct_resp = val(self.correct_resp)
        sym_str = key.symbol_string(symbol)
        if None in keys or sym_str in keys:
            # it's all good!, so save it
            self.pressed = sym_str
            self.press_time = event_time

            # fill the base time val
            self.base_time = val(self.base_time_src)
            if self.base_time is None:
                # set it to the state time
                self.base_time = self.state_time
            
            # calc RT if something pressed
            self.rt = event_time['time']-self.base_time

            if self.pressed in correct_resp:
                self.correct = True

            # let's leave b/c we're all done
            #self.interval = 0
            self.leave()

    def test_certain_modifier_key_presses_do_not_change_state(self):
        app = MockApp()
        state = dispatcher.init_state(dispatcher.default_state, app, None)
        state.send(NormalEvent(ON_KEY_PRESS, pkey.M))
        current_state = state.gi_frame.f_locals['current_state']
        self.assertEqual(current_state.__name__, 'marking')

        keys = [
            pkey.LSHIFT, pkey.RSHIFT,
            pkey.LCTRL, pkey.RCTRL,
            pkey.CAPSLOCK,
            pkey.LMETA, pkey.RMETA,
            pkey.LALT, pkey.RALT,
            pkey.LWINDOWS, pkey.RWINDOWS,
            pkey.LCOMMAND, pkey.RCOMMAND,
            pkey.LOPTION, pkey.ROPTION
        ]

        for key in keys:
            state.send(NormalEvent(ON_KEY_PRESS, key))
            current_state = state.gi_frame.f_locals['current_state']
            self.assertIsNotNone(current_state,
                    msg="{} has changed the state".format(pkey.symbol_string(key)))
            self.assertEqual(current_state.__name__, 'marking',
                    msg="current_state was changed by {}".format(pkey.symbol_string(key)))

 def on_key_release(self, inp, modifers):
     if symbol_string(inp) == "LEFT":
         self.sprite.dx = 0
         print("release left, dx:", self.sprite.dx)
     if symbol_string(inp) == "RIGHT":
         self.sprite.dx = 0
         print("release right, dx:", self.sprite.dx)

def on_key_press(symbol, modifiers):
    if key.symbol_string(symbol) == 'SPACE':
        environment.active = not environment.active
    if key.symbol_string(symbol) == 'S':
        environment.mode = 'S'
    if key.symbol_string(symbol) == 'C':
        environment.mode = 'C'

    def save_exp(self, rest_time=1):
        name = inspect.getouterframes(inspect.currentframe())[1][1] #get the file path that called save_exp
        name = name.rsplit('/')[-1].rsplit('.')[0]                  #get its name without '.py'
        self.names.append(name)

        # experiment class
        self.curr_experiment.name = name

        # there is at least one test, so
        # this is not a rest file, so assign a key
        if self.curr_experiment.tests != []: 
            self.experiments.append(self.curr_experiment)
            ind = len(self.experiments)-1
            curr_key = [key._1, key._2, key._3, key._4, key._5,
                        key._6, key._7, key._8, key._9][ind]
            if ind<=8:
                self.window.add_key_action(curr_key, self.begin_experiment, ind)
            if ind==0: print '\nScheduler key assignments:'
            print key.symbol_string(curr_key) + ' - ' + name

        # since this is not a test file and there is at least one
        # rest, add it to rests and make it the default rest
        elif self.curr_experiment.rest != []:
            self.rests.append(self.curr_experiment)
            print 'rest - ' + name

        self.curr_experiment = None #clear it for the next save

    def on_key_press(self, key, modifiers):
        if symbol_string(key) == "T":
            self.do(Twirl(amplitude=5, duration=2))

        elif symbol_string(key) == "W":
            self.do(Reverse(Waves(duration=2)))

        elif symbol_string(key) == "F":
            self.do(FlipX3D(duration=1) + FlipY3D(duration=1) + Reverse(FlipY3D(duration=1)))

 def on_key_release(self, symbol, modifiers):
     letter = key.symbol_string(symbol)
     if self.verbose: print("release:",letter,key.modifiers_string(modifiers))
     
     _keyboard.remove(key.symbol_string(symbol))
     if self.keyrelease is not None:
         kwargs = {
         "window":self,
         "symbol":key.symbol_string(symbol),
         "modifiers":key.modifiers_string(modifiers)
         }
         self.keyrelease(**kwargs)

 def on_key_press(self, symbol, modifiers):
     letter = key.symbol_string(symbol)
     if self.verbose:
         print("press:",letter,key.modifiers_string(modifiers))
     _keyboard.add(key.symbol_string(symbol))
     if self.keypress is not None:
         kwargs = {
         "window":self,
         "symbol":key.symbol_string(symbol),
         "modifiers":key.modifiers_string(modifiers)
         }
         self.keypress(**kwargs)

    def on_key_press(self, key, modifiers):
        # First I create a move action because we programmers are lazy and hate having to retype code!
        move_left = MoveBy((-50, 0), .5)

        # Here's where that Pyglet symbol_string() function comes in handy
        # Rather than having to interpret an inconsistent code, I can simply interpret the word LEFT and RIGHT
        if symbol_string(key) == "LEFT":
            self.sprite.do(move_left)

        # Now I need to tell the layer what to do if the user inputs RIGHT
        if symbol_string(key) == "RIGHT":
            # This is a pretty awesome feature built into Cocos
            # I only wrote code for moving left, but I can use the Reverse() function instead of rewriting code
            # Reverse() simply tells Cocos to do the reverse action of whatever you pass into it.
            self.sprite.do(Reverse(move_left))

 def get_key_string(self, value):
     value = key.symbol_string(value)
     if value.startswith('_'):
         value = value[1:]
     if value == 'LCTRLREAL':
         return 'LCTRL'
     return value

 def on_key_release(self, key, modifiers):
     k = symbol_string(key)
     status = False
     if k == "LEFT":
         self.key_pressed_left = status
     elif k == "RIGHT":
         self.key_pressed_right = status

 def on_key_press(self, key, modifiers):
     k = symbol_string(key)
     status = True
     if k == "LEFT":
         self.key_pressed_left = status
     elif k == "RIGHT":
         self.key_pressed_right = status
     elif k == "SPACE" and self.life == 1:
         if self.jump_count > 0:
             x, y = self.sprite.position
             try:
                 self.remove(self.jump1)
             except:
                 pass
             # jump效果图
             self.jump1 = Sprite("images/jump.png")
             self.jump1.opacity = 250
             self.jump1.position = (x, y-100)
             self.add(self.jump1)
             self.jump_speed = 20
             self.jump_y = y
             self.key_pressed_up = True
             self.jump_count -= 1
     elif k == "DOWN":
         self.key_pressed_down = status
     elif k == "SPACE" and self.life == 0:
         scene = Scene(GameLayer())
         director.replace(SplitColsTransition(scene))

    def on_key_press(self, symbol, modifiers):
        if pymterm.debug_log:
            LOGGER.debug('on_key_press:{}, {}'.format(
                key.symbol_string(symbol),
                key.modifiers_string(modifiers)))

        key_state = KeyState(symbol, modifiers)

        if symbol == key.Q and \
           (modifiers == key.MOD_COMMAND or modifiers == key.MOD_CTRL):
            self.close()
            return

        if self.session.terminal.process_key(key_state):
            if pymterm.debug_log:
                LOGGER.debug(' processed by pyterm')
            return

        v, handled = term.term_keyboard.translate_key(self.session.terminal,
                                                      key_state)

        if len(v) > 0:
            self.session.send(v)

        self._key_first_down = True

 def key(self, symbol, modifiers):
     """ Key pressed event handler.
     """
     if symbol == key.F1:
         self.mode = 1
         self.default()
         print "Projection: Pyglet default"
     if symbol == key.NUM_0:
         global correction_rmatrix1, zero_rmatrix, rmatrix1
         correction_rmatrix1 = np.dot(zero_rmatrix, np.linalg.inv(rmatrix1))
     elif symbol == key.F2:
         print "Projection: 3D Isometric"
         self.mode = 2
         self.isometric()
     elif symbol == key.F3:
         print "Projection: 3D Perspective"
         self.mode = 3
         self.perspective()
     elif self.mode == 3 and symbol == key.NUM_SUBTRACT:
         self.fov -= 1
         self.perspective()
     elif self.mode == 3 and symbol == key.NUM_ADD:
         self.fov += 1
         self.perspective()
     else:
         print "KEY " + key.symbol_string(symbol)

 def print_keypress_actions(self):
     items = sorted(self.keypress_actions.items())
     for keypress, action in items:
         keysymbol = key.symbol_string(keypress[0]).lstrip(' _')
         modifiers = key.modifiers_string(keypress[1]).replace('MOD_', '').replace('|', ' ').lstrip(' ')
         func, args, kwargs = action[0].__name__, action[1], action[2]
         print('{:<10} {:<6} --- {:<30}({}, {})'.format(modifiers, keysymbol, func, args, kwargs))