Python event.post函数代码示例

    def get(self):
        events.pump()
        notmine = []
        inp = NOOP
        for event in events.get():
            if event.type == QUIT:
                inp = QUITCOMMAND
            if ((event.type == KEYDOWN or event.type == KEYUP)
                and self.keyDict.has_key(event.key)):
                if event.type == KEYDOWN:
                    inp = self.keyDict[event.key]
                elif event.type == KEYUP:
                    keyDown = key.get_pressed()
                    if(keyDown[self.commandDict[UP]]):
                        inp = UP
                    elif(keyDown[self.commandDict[DOWN]]):
                        inp = DOWN
                    elif(keyDown[self.commandDict[LEFT]]):
                        inp = LEFT
                    elif(keyDown[self.commandDict[RIGHT]]):
                        inp = RIGHT
                    else:
                        inp = STOP
                else:
                    raise UnexpectedInput
            else:
                notmine.append(event)

        for yours in notmine:
            events.post(yours)

        return inp

    def exchangeInput(self):
        """Exchange a round of inputs in a network-safe
           manner.
        """
        inputs = []
        for player in self.playerList:
            inp = self.getPlayerInput(player)
            debug("Player " + str(player.name) +\
                  " input: " + inp + "\n")
            if self.record and inp != NOOP:
                self.playerInputFileList[int(player.name)].write( \
                  str(self.totalGameLoops) +\
                  ',' + inp + '\n')

            # Check players input
            if len(inp) != len(UP):
                print "Bad input from player",player.getHandle()
                inp = DISCONNECT

            # Can quit the game from end splash screen
            if inp == QUITCOMMAND:
                sys.exit()

            inputs.append((player.name,inp))
            for netplayer in self.playerList:
                netplayer.sendCommand(player.getBroadcastable())

        self.totalGameLoops += 1
        # Clear all useless events
        eventsWeWant = events.get([KEYDOWN, KEYUP, JOYBUTTONDOWN,\
                                   JOYAXISMOTION])
        events.clear()
        for event in eventsWeWant:
            events.post(event)
        return inputs

 def _end(self):
     """
     Reset the timer and post self.event to the queue. Called when time reaches
     self._endTime.
     """
     self.reset()
     pgevent.post(pgevent.Event(self.event))

 def check_died(self, scene):
     """
     Check whether this enemy has died.
     """
     if self.hp <= 0:
         scene.enemyGroup.remove(self)
         event.post(event.Event(USEREVENT, code=CAESARDEAD))

    def unlaunch(self, what):
        ev = event.Event(constants.THORPY_EVENT, id=constants.EVENT_UNLAUNCH,
                        launcher=self, what=what)
        event.post(ev)
##        print(ev, "posted")
        self.remove_from_current_menu()
        self.postlaunch()

 def _press(self):
     state_ok = self.current_state == self._states[STATE_NORMAL]
     if state_ok:
         self.change_state(STATE_PRESSED)
         self._hover()
         ev_press = Event(THORPY_EVENT, id=EVENT_PRESS, el=self)
         post(ev_press)
         self._remove_help()

 def _reaction_drag(self, event):
     if self.current_state_key == constants.STATE_PRESSED:
         if self.will_be_inside(event.rel[0]):
             self.dragmove(event.rel[0])
             drag_event = pygevent.Event(constants.THORPY_EVENT,
                                         id=constants.EVENT_SLIDE,
                                         el=self.father.father)
             pygevent.post(drag_event)

 def _press(self):
     Clickable._press(self)
     self._count += 1
     if not self.toggled:
         ev_tog = Event(constants.THORPY_EVENT, id=constants.EVENT_TOGGLE,
                         el=self)
         post(ev_tog)
         self.toggled = True

    def _force_unpress(self):
        self._count = 0
        Clickable._unpress(self)
##        self._unhover_noblit()
        ev_untog = Event(constants.THORPY_EVENT,
                        id=constants.EVENT_UNTOGGLE, el=self)
        post(ev_untog)
        self.toggled = False

 def _unpress(self):
     state_ok = (self.current_state_key == constants.STATE_PRESSED)
     if state_ok:
         self.unblit()
         self.change_state(constants.STATE_NORMAL)
         self.blit()
         self.update()
         ev_unpress = Event(constants.THORPY_EVENT, id=constants.EVENT_UNPRESS, el=self)
         post(ev_unpress)

 def _press(self):
     self.unblit()
     self.change_state(constants.STATE_PRESSED)
     self.blit()
     self.update()
     ev_press = Event(constants.THORPY_EVENT,
                      id=constants.EVENT_PRESS,
                      el=self)
     post(ev_press)

 def _press(self):
     state_ok = self.current_state == self._states[constants.STATE_NORMAL]
     if state_ok:
         self.unblit()
         self.change_state(constants.STATE_PRESSED)
         self.blit()
         self.update()
         ev_press = Event(constants.THORPY_EVENT,
                          id=constants.EVENT_PRESS,
                          el=self)
         post(ev_press)

 def quit_save(self):
     ev = Event(constants.THORPY_EVENT,
                name=constants.EVENT_DONE,
                el=self)
     post(ev)
     for (varset, varname), handler in iter(self.handlers.items()):
         # si varset
         self.varsets[varset].set_value(varname, handler.get_value())
         # sinon si link
         # sinon si fonction
     functions.quit_menu_func()

    def shutdown_gate(self):

        if self.gate_active:
            print "Shutting gate down"
            self.gate_active = False
            self.dialed_symbols = []
            event.post(Event(EventType.SOUND_STOP, {
                "value": "gate-loop"
            }))
            event.post(Event(EventType.SOUND_PLAY, {
                "value": "gate-close"
            }))

    def __init__(self, tube, is_initiator, tube_id):
        super(PygameTube, self).__init__(tube, DBUS_PATH)
        log.info( 'PygameTube init' )
        self.tube = tube
        self.is_initiator = is_initiator
        self.entered = False
        self.ordered_bus_names = []
        PEvent.post(PEvent.Event(CONNECT, id=tube_id))

        if not self.is_initiator:
            self.tube.add_signal_receiver(self.new_participant_cb, 'NewParticipants', DBUS_IFACE, path=DBUS_PATH)
        self.tube.watch_participants(self.participant_change_cb)
        self.tube.add_signal_receiver(self.broadcast_cb, 'Broadcast', DBUS_IFACE, path=DBUS_PATH, sender_keyword='sender')