Python Rect.collidepoint方法代码示例

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
    def backup_attack_loop(self):
        g = self.g
        self.image = self.orginalImage.subsurface((160, 0, 32, 32))

        speed = self.walktimer
        self.walktimer += 1
        if self.walktimer > 6:
            self.walktimer = 6


        self.timer += 1
        timergate = self.timer % 100
        if timergate >= 80:
            if timergate == 80:
                self.face_the_player()
            if timergate == 85:
                Shot(g, self.direction, (self.rect.x + 16, self.rect.y + 8), 'shot8', 'enemy')
            self.walking = 0
        else:
            self.walking = 1
        if timergate % 100 == 0:
            self.face_the_player()

        dx = self.rect.x - g.player.rect.x
        if dx <40 and dx > -40:
            if self.dy == 10.0:
                self.dy = -10.0

        if self.walking:
            self.rect.x += (1 - (self.direction * 2)) * speed
            framen = self.timer / 2  % 3
            self.image = self.orginalImage.subsurface((32 + framen * 32, 0, 32, 32))
        else:
            self.walktimer = 0

        self.dy += .5
        if self.dy > 10.0:
            self.dy = 10.0
        self.rect.y += self.dy

        if self.rect.x < 416:
            self.direction = 0

        
        self.image = pygame.transform.flip(self.image, self.direction, 0)
        # hitting the bullets and player
        s = Rect(self.rect)
        if s.colliderect (g.player.rect):
            g.player.touch(self)
        for b in g.bullets:
            if b.owner == 'player':
                drect = (b.rect.x + 30, b.rect.y )
                if s.collidepoint(drect):
                    b.destroy()
                    self.health -= b.get_damage()
                    e = Effect(self.g, 'health', (self.rect.x, self.rect.y))
                    e.healthchange = -b.get_damage()
                    self.image = g.make_image_white(self.image)

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
class Button(GameSprite):
    def __init__(self, x, y, kind, resourcemgr):
        super(Button, self).__init__(x, y, kind, resourcemgr)
        set_button_stats(self)
        self.rect = Rect(x, y, self.w, self.h)
        self.was_hit = False
        self.set_areas()
        self.area = self.areas[MOUSE_POS.OUT]

    def set_areas(self):
        self.areas = {}
        self.areas[MOUSE_POS.OVER] = pygame.Rect(0, 0, self.rect.w,
            self.rect.h)
        self.areas[MOUSE_POS.OUT] = pygame.Rect(self.rect.w, 0, self.rect.w,
            self.rect.h)
        self.areas[MOUSE_POS.DOWN] = pygame.Rect(0, self.rect.h, self.rect.w,
            self.rect.h)
        self.areas[MOUSE_POS.UP] = pygame.Rect(self.rect.w, self.rect.h,
            self.rect.w, self.rect.h)

    def input(self, event):
        x, y = pygame.mouse.get_pos()

        if event.type == MOUSEMOTION:
            if self.rect.collidepoint(x, y):
                self.area = self.areas[MOUSE_POS.OVER]
            else:
                self.area = self.areas[MOUSE_POS.OUT]

        if event.type == MOUSEBUTTONDOWN and \
            event.button == MOUSE.LEFT and self.rect.collidepoint(x, y):
            self.area = self.areas[MOUSE_POS.DOWN]
        if event.type == MOUSEBUTTONUP and event.button == MOUSE.LEFT \
            and self.rect.collidepoint(x, y):
            self.area = self.areas[MOUSE_POS.UP]
            self.was_hit = True

    def render(self):
        self.resourcemgr.screen.blit(self.image, self.rect, self.area)

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
    def draw_board(self):

        image_indexes = {
            None: 0,
            O: 1,
            X: 2
        }

        for row in range(3):
            for col in range(3):

                board_index = row * 3 + col

                # Cell rectangle
                cell = Rect(TILE_WIDTH * col, TILE_HEIGHT * row, TILE_WIDTH, TILE_HEIGHT)

                # Check if mouse is over a cell
                mouse_over = self.mouse_pos is not None and cell.collidepoint(self.mouse_pos)

                # Winner movement
                if self.game.winner and board_index in self.game.winner_movement:
                    fill_index = image_indexes[self.game.board[board_index]]
                    state_index = 3
                    self.screen.blit(self.tileset[fill_index][state_index], cell)

                # Mouse interaction
                elif mouse_over and self.is_human_turn():
                    if self.game.board[board_index] == None:
                        fill_index = image_indexes[self.game.turn]
                        state_index = 1
                    else:
                        fill_index = image_indexes[self.game.board[board_index]]
                        state_index = 2
                    self.screen.blit(self.tileset[fill_index][state_index], cell)

                # Normal rendering
                else:
                    fill_index = image_indexes[self.game.board[board_index]]
                    if self.game.winner == False: # Draw
                        state_index = 2
                    else:
                        state_index = 0
                    self.screen.blit(self.tileset[fill_index][state_index], cell)

        pygame.display.flip()

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
    def selectatmouse(self):
        # User has touched the screen - is it inside the textbox, or inside a key rect?
        self.unselectall()
        pos = pygame.mouse.get_pos()
#        print 'touch {}'.format(pos)
        if self.input.rect.collidepoint(pos):
#            print 'input {}'.format(pos)
            self.input.setcursor(pos)
        else:
            for key in self.keys:
                keyrect = Rect(key.x, key.y, key.w, key.h)
                if keyrect.collidepoint(pos):
                    key.selected = True
                    key.dirty = True
                    self.paintkeys()
                    return

        self.paintkeys()        

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
    def check_input_line_collision(self, pos):
        for p in self.inputs:
            if self.inputs[p]:
                obj, pin = self.inputs[p]
                if isinstance(obj, Invisible):
                    continue

                start = self.input_xy[p]
                end = obj.output_xy[pin]
                #basic rect TODO
                offset = self.parent.canvas.style["d_line_col"]
                
                x = min((start[0], end[0])) - offset
                y = min((start[1], end[1])) - offset
                w = abs(start[0] - end[0]) + offset * 2
                h = abs(start[1] - end[1]) + offset * 2
                
                basic = Rect(x, y, w, h)
                
                if basic.collidepoint(pos):
                
                    dx = end[0] - start[0]
                    dy = end[1] - start[1]
                    
                    if dx == 0 and dy == 0:
                        return False
                    
                    if abs(dx) < abs(dy):
                        k = float(dx) / float(dy)
                        x = start[0] + k * (pos[1] - start[1])
                
                        if abs(x - pos[0]) < offset:
                            return self, p, obj, pin                      
                    else:
                        k = float(dy) / float(dx)
                        y = start[1] + k * (pos[0] - start[0])
                        
                        if abs(y - pos[1]) < offset:
                            return self, p, obj, pin
        return False 

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
    def clickatmouse(self):
        ''' Check to see if the user is pressing down on a key and draw it selected '''
        self.unselectall()
        for key in self.keys:
            keyrect = Rect(key.x, key.y, key.w, key.h)
            if keyrect.collidepoint(pygame.mouse.get_pos()):
                key.dirty = True
                if key.bskey:
                    # Backspace
                    self.input.backspace()
                    self.paintkeys() 
                    return False
                if key.fskey:
                    self.input.inccursor()
                    self.paintkeys() 
                    return False
                if key.spacekey:                    
                    self.input.addcharatcursor(' ')
                    self.paintkeys() 
                    return False
                if key.shiftkey:
                    self.togglecaps()
                    self.paintkeys() 
                    return False
                if key.escape:
                    self.input.text = ''  # clear input
                    return True
                if key.enter:
                    return True
                if self.caps:
                    keycap = key.caption.translate(Uppercase)
                else:
                    keycap = key.caption
                self.input.addcharatcursor(keycap)
                self.paintkeys()
                return False

        self.paintkeys() 
        return False

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
    def loop_hit_death(self, g, r, canbehit, canhitplayer):
        self.timer += 1
        self.image = pygame.transform.flip(self.image, self.direction, 0)

        s = Rect(self.rect)
        if self.mode != 'death':
            if s.colliderect (g.player.rect):
                if canhitplayer:
                    g.player.touch(self)

        if canbehit:
            for b in g.bullets:
                if b.owner == 'player':
                    drect = (b.rect.x, b.rect.y)
                    if s.collidepoint(drect):
                        b.destroy()
                        self.health -= b.get_damage()
                        e = Effect(self.g, 'health', (self.rect.x, self.rect.y))
                        e.healthchange = -b.get_damage()
                        if self.mode != 'ouch':
                            self.birdhit.play()
                        self.mode = 'ouch'
                        self.btimer = 0
            #k = Rect(b.rect)
            #k.x -= g.view.x
            #k.y -= g.view.y
            #pygame.draw.rect(g.screen, (0,255,255), k)
        #s.x -= g.view.x
        #s.y -= g.view.y
        #pygame.draw.rect(g.screen, (255,0,255), s)
        

        # dead
        if self.health <= 0:
            if self.mode != 'death':
                self.mode = 'death'
                self.btimer = 0

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
    def loop(self, g, r):
        enableflip = 1
        # reseting the frame count if not walking
        if self.walking == 0:
            self.framecount = 0
            
        # animation
        if self.type == None: # assistant ima
            self.image = self.orginalImage.subsurface((32 * ((self.framecount/2) % 4), 0, 32, 32))
            # hack! to get ima the only holding hand character
            if g.connected == 1 and self.direction == 0 and self.orginalImage.get_size() == (256, 128):
                self.image = self.orginalImage.subsurface((32 * ((self.framecount/2) % 4), 64, 32, 32))
            if self.faceup == 1:
                self.image = self.orginalImage.subsurface((32 * 4, 0, 32, 32))
            elif self.feeling == 'worried':
                self.image = self.orginalImage.subsurface((32 * 5, 0, 32, 32))
            elif self.feeling == 'pulled':
                self.image = self.orginalImage.subsurface((32 * 6, 0, 32, 32))
            elif self.feeling == 'coma':
                self.image = self.orginalImage.subsurface((32 * 7, 0, 32, 32))
            elif self.feeling == 'coma2':
                self.image = self.orginalImage.subsurface((32 * 7, 32, 32, 32))
        elif self.type == 'director':# director victora
            self.image = self.orginalImage.subsurface((32 * ((self.framecount/2) % 5), 0, 32, 32))
            if self.feeling == 'sit':
                self.image = self.orginalImage.subsurface((32 * 5, 0, 32, 32))
            elif self.feeling == 'sitangry':
                self.image = self.orginalImage.subsurface((32 * 6, 0, 32, 32))
            elif self.feeling == 'sitawake':
                self.image = self.orginalImage.subsurface((32 * 7, 0, 32, 32))
        elif self.type == 'robot':# robot 0
            self.image = self.orginalImage.subsurface((0, 0, 32, 32))
            if self.feeling == 'blink':
                self.image = self.orginalImage.subsurface((32, 0, 32, 32))
            elif self.feeling == 'happy':
                self.image = self.orginalImage.subsurface((64, 0, 32, 32))
            elif self.feeling == 'arms':
                self.image = self.orginalImage.subsurface((96, 0, 32, 32))
            elif self.feeling == 'attack':
                self.image = self.orginalImage.subsurface((96, 0, 32, 32))
            elif self.feeling == 'dead':
                self.image = self.orginalImage.subsurface((96, 32, 32, 32))
        elif self.type == 'mushroom':# mushroom king
            if self.dead:
                self.image = pygame.Surface((1, 1), SRCALPHA)
                return
            enableflip = 0
            self.timer += 1
            self.image = self.orginalImage.subsurface((256, 256, 256, 256))
            if self.feeling == 'walking':
                m = (self.timer / 3) % 3
                if m == 0:
                    self.image = self.orginalImage.subsurface((0, 0, 256, 256))
                elif m == 1:
                    self.image = self.orginalImage.subsurface((256, 0, 256, 256))
                elif m == 2:
                    self.image = self.orginalImage.subsurface((0, 256, 256, 256))
        elif self.type == 'doctor':# doctor robot
            if self.dead == 1:
                #self.image = pygame.Surface((1, 1), SRCALPHA)
                return
            self.image = pygame.Surface((256, 256), SRCALPHA)
            enableflip = 0
            self.timer += 1

            leftarmlength = self.attackleft
            rightarmlength = self.attackright
            rightarmspnning = 0
            if rightarmlength == 10:
                rightarmspnning = ((self.timer % 1000) - 600) / 40 + 1
            dead = 0
            if self.health <= 0:
                leftarmlength = 0
                rightarmlength = 0
                self.feeling = 'dead'
                self.image.blit(self.imagel, (0,0))
                dead = 1
            else:
                self.image.blit(self.imageh, (0,0))
            if self.feeling == 'walking':
                m = (self.timer / 2) % 2 == 0
                if m == 1:
                    self.image.blit(self.imagee, (0,0)) # wonky tracks 2
                else:
                    self.image.blit(self.imagef, (0,0)) # wonky tracks 1
            else:
                self.image.blit(self.imageg, (0,0)) # normal tracks

            # getting hit by a bullet
            s = Rect(self.rect)
            s.x += 50
            s.y += 40
            s.width -= 120
            s.height -= 140
            for b in g.bullets:
                if b.owner == 'player':
                    drect = (b.rect.x , b.rect.y )
                    if s.collidepoint(drect) and not dead and rightarmspnning == 0:
                        dmg = b.get_damage()
                        self.health -= dmg
#.........这里部分代码省略.........

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
 def mouse_down(self, point):
     for index, item in enumerate(self.items):
         item_rect = Rect(self.rect.x, self.rect.y + item.rect.y, item.rect.w, item.rect.h)
         if item_rect.collidepoint(point):
             self.select(index)
             break

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]

#.........这里部分代码省略.........
                    # draw hand
                    if g.connected == 1 and self.direction == 1:
                        g.player.image.blit(g.player.orginalImage.subsurface((2 * 32, 4 * 32, 32, 32)), (7, 0))
                else:
                    g.player.image = g.player.orginalImage.subsurface(
                        (iw * ((self.framecount / 3) % 5), 3 * 32, 32, 32)
                    )
            # looking forward
            if (faced == 1 or self.staylooking) and not shooting and not self.jumping:
                if self.direction == 0:
                    g.player.image = g.player.orginalImage.subsurface((5 * 32, 2 * 32, 32, 32))
                else:
                    g.player.image = g.player.orginalImage.subsurface((5 * 32, 3 * 32, 32, 32))
            if faced == 2:
                if self.direction == 0:
                    g.player.image = g.player.orginalImage.subsurface((4 * 32, 1 * 32, 32, 32))
                else:
                    g.player.image = g.player.orginalImage.subsurface((5 * 32, 1 * 32, 32, 32))
            if self.jumping == 1:
                if self.direction == 0:
                    g.player.image = g.player.orginalImage.subsurface((6 * 32, 2 * 32, 32, 32))
                else:
                    g.player.image = g.player.orginalImage.subsurface((6 * 32, 3 * 32, 32, 32))
            if aimup:
                if self.direction:
                    self.image = g.player.orginalImage.subsurface((5 * 32, 1 * 32, 32, 32))
                else:
                    self.image = g.player.orginalImage.subsurface((4 * 32, 1 * 32, 32, 32))
            if aimdown:
                if self.direction:
                    self.image = g.player.orginalImage.subsurface((7 * 32, 1 * 32, 32, 32))
                else:
                    self.image = g.player.orginalImage.subsurface((6 * 32, 1 * 32, 32, 32))
        if g.player.gravity == 0:
            self.jumping = 0
        self.looking = faced
        g.infobox = 0

        if self.hidden == 1:
            self.image = self.orginalImage.subsurface((0, 0, 0, 0))

        # getting shot
        for b in g.bullets:
            if b.owner == "enemy":
                drect = (b.rect.x, b.rect.y)
                if self.rect.collidepoint(drect):
                    self.touch(b)

        # edge
        g.player.gravity -= GRAVITY
        if g.player.gravity < MAXVEL:
            g.player.gravity = MAXVEL
        self.rect.x += self.dx
        self.rect.y += dy - g.player.gravity
        # self.rect.clamp_ip(g.view)

        # dead ...
        if self.health <= 0 and not g.dead:
            g.dead = 1
            g.exp2.play()
        if self.imortal > 0:
            if self.imortal / 5 % 2 == 0:
                g.player.image = g.make_image_white(g.player.image)
            self.imortal -= 1

        # getting demoted
        if self.g.saveData["weapon"] > 1:
            shottype = "shot" + str(self.g.saveData["weapon"])
            if self.g.saveData[shottype] == 0:
                if self.g.saveData["weapon"] == 2:
                    self.g.saveData["weapon"] = 1
                elif self.g.saveData["weapon"] == 4:
                    self.g.saveData["weapon"] = 2
                elif self.g.saveData["weapon"] == 7:
                    self.g.saveData["weapon"] = 4
                else:
                    print "weapon not down graded"

        # reloading the gun
        if self.shotcounter > 0:
            self.shotcounter -= 1

    # hitting the ground
    def hit_ground(self):
        if self.gravity <= -14:
            self.hitground.play()
        if self.gravity <= -2:
            if self.snowwalk == 1:
                self.snowwalk = 0
                Effect(self.g, "snow", (self.rect.x - 8, self.rect.y + 8))
                Effect(self.g, "snow", (self.rect.x - 8, self.rect.y + 8))

    # adds some health to the player
    def addHealth(self, n):
        self.health += n
        ef = Effect(self.g, "health", (self.rect.x, self.rect.y - 10))
        ef.healthchange = n
        if self.health > self.healthmax:
            self.health = self.healthmax
        self.g.saveData["health"] = self.health

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]

#.........这里部分代码省略.........
                    self.rect.y - camera.rect.y - 3 + self.h),
                (self.rect.x - camera.rect.x + 3,
                    self.rect.y - camera.rect.y - 3 + self.h - dy),
            ), 2)
            self.resourcemgr.screen.unlock()

    def draw_health_bar(self, camera):
        if self.selected or self.mouse_over:
            black_rect = Rect(self.rect.x - camera.rect.x,
                self.rect.y - camera.rect.y, self.w, 6)
            red_rect = Rect(self.rect.x - camera.rect.x + 1,
                self.rect.y - camera.rect.y + 1, self.w - 2, 4)
            green_rect = Rect(self.rect.x - camera.rect.x + 1,
                self.rect.y - camera.rect.y + 1,
                (self.w - 2) * (self.health / float(self.max_health)), 4)
            self.resourcemgr.screen.lock()
            draw.rect(self.resourcemgr.screen, BLACK, black_rect, 0)
            draw.rect(self.resourcemgr.screen, RED, red_rect, 0)
            draw.rect(self.resourcemgr.screen, GREEN, green_rect, 0)
            self.resourcemgr.screen.unlock()

    def die(self, camera):
        if self.is_dead():
            self.kill()
            v = calculate_volume(self.rect, camera)
            if v > 0:
                self.die_fx.set_volume(v)
                self.die_fx.play()

    def input(self, event, camera, mouse_rect, tilemgr):
        x, y = mouse.get_pos()
        x += camera.rect.x
        y += camera.rect.y
        self.mouse_over = self.rect.collidepoint(x, y)

        if event.type == MOUSEBUTTONUP:
            if event.button == MOUSE.LEFT:
                include = True
                if self.rect.colliderect(mouse_rect):
                    if self.team != self.mgr.team and \
                        len(self.mgr.selected) > 0:
                        include = False
                    elif self.team == self.mgr.team:
                        rem = []
                        for u in self.mgr.selected:
                            if u.team != self.mgr.team:
                                u.selected = False
                                rem.append(u)
                        self.mgr.selected.remove(*rem)

                        if self.has_flag(FLAGS.STRUCT):
                            for u in self.mgr.selected:
                                if u.has_flag(FLAGS.DUDE):
                                    include = False
                                    break
                        elif self.has_flag(FLAGS.DUDE):
                            rem = []
                            for u in self.mgr.selected:
                                if u.has_flag(FLAGS.STRUCT):
                                    u.selected = False
                                    rem.append(u)
                            self.mgr.selected.remove(*rem)
                else:
                    include = False

                if include:

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import collidepoint [as 别名]
class InputFieldWidget(Widget):
    """ widget where the user can enter text. 
    The widget loses focus when the user clicks somewhere else. 
    """

    def __init__(self, evManager, rect=None):
        Widget.__init__(self, evManager)
        # Widget init sets dirty to true, hence the actual rendering
        # will be done in InputFieldWidget.update(), called by the view renderer.

        self._em.reg_cb(NonprintableKeyEvent, self.on_invisiblekeypushed)
        self._em.reg_cb(UnicodeKeyPushedEvent, self.on_visiblekeypushed)
        self._em.reg_cb(DownClickEvent, self.on_downclick)

        self.text = ""
        self.font = Font(None, config_get_fontsize())

        if rect:
            self.rect = rect
        else:
            self.rect = Rect((0, 0), (100, config_get_fontsize() + 4))
            # 100px = default width,
            # 25px = font height, 4px = 1 px for each of border-bottom,
            # padding bottom, padding top, and border top.

        # rectangle to be drawn around the box as border
        border_rect = Rect((0, 0), self.rect.size)
        # draw and store unfocused empty box
        emptyboxImg = Surface(self.rect.size)
        self.unfocused_bgcolor = config_get_unfocusedinput_bgcolor()
        self.unfocused_txtcolor = config_get_unfocusedinput_txtcolor()
        emptyboxImg.fill(self.unfocused_bgcolor)
        pygame.draw.rect(emptyboxImg, self.unfocused_txtcolor, border_rect, 2)
        self.unfocused_emptyboxImg = emptyboxImg.convert_alpha()
        self.image = emptyboxImg
        # draw and store focused empty box
        emptyboxImg = Surface(self.rect.size)
        self.focused_bgcolor = config_get_focusedinput_bgcolor()
        self.focused_txtcolor = config_get_focusedinput_txtcolor()
        emptyboxImg.fill(self.focused_bgcolor)
        pygame.draw.rect(emptyboxImg, self.focused_txtcolor, border_rect, 2)
        self.focused_emptyboxImg = emptyboxImg.convert_alpha()

        self.textPos = (4, 2)  # 4px padding-left and 2px padding-top

    def update(self, duration):
        """ render the text in the box """
        if self.dirty == 0:
            return

        text = self.text
        if self.focused:
            text += "|"
            txtcolor = self.focused_txtcolor
            emptyboximg = self.focused_emptyboxImg
        else:
            txtcolor = self.unfocused_txtcolor
            emptyboximg = self.unfocused_emptyboxImg

        textImg = self.font.render(text, True, txtcolor)
        # cover the previous img instead of creating a new one
        # TODO: is bliting on existing faster than creating a new surface?
        self.image.blit(emptyboximg, (0, 0))
        self.image.blit(textImg, self.textPos)

        # self.dirty = 0

    def set_text(self, newtext):
        """ change the content of the text input field """
        self.text = newtext
        self.dirty = 1

    def submit_text(self):
        """ send the string typed, and reset the text input field """
        self.log.debug("Widget submit text: " + self.text)
        ev = SubmitChat(self.text)
        self.set_text("")
        self._em.post(ev)

    ###### CALLBACKS

    def on_downclick(self, event):
        """ Get focus if clicked, lose focus if something else is clicked """
        if self.rect.collidepoint(event.pos):  # box was clicked
            self.set_focus(True)
            self.dirty = 1
        elif self.focused:  # user clicked on something else
            self.set_focus(False)

    def on_invisiblekeypushed(self, event):
        """ Add/remove characters and 'submit' the string."""
        if self.focused:
            if event.key == K_BACKSPACE:  # erase last character
                newtxt = self.text[:-1]
                self.set_text(newtxt)
            elif event.key == K_RETURN:  # submit non-empty string
                if self.text:
                    self.submit_text()
                else:  # lose focus
                    self.set_focus(False)
#.........这里部分代码省略.........