Kivy：如何将同时触摸限制为一个？

Question

I am using Kivy 1.9.1 and Python 3.5.2. My application breaks when more than one touch event is fired before the first has finished processing. I'm looking for some way to either restrict the number of touch events at a given time to one (something like the max_pointers attribute in the HTML5 engine Phaser) or to filter the touch events and only process the first. As far as I'm aware, the touch event doesn't hold this information about itself.

I don't believe the specifics of my code are relevant, but better safe than sorry:

    def on_touch_down(self, touch):
        x, y = touch.x, touch.y
        x -= self.img_board.pos[0]
        y -= self.img_board.pos[1]
        if not (0 <= x <= self.img_board.size[0] and
                0 <= y <= self.img_board.size[1]):
            touch.ud['piece'] = None
            return

        file = int(x / self.square_size)
        rank = int(y / self.square_size)
        self.select((file, rank))
        piece = Board.instance.at_square(self.selected)
        touch.ud['piece'] = piece
        if piece:
            self.canvas.remove(piece.rect)
            self.canvas.after.add(piece.rect)

    def on_touch_move(self, touch):
        piece = touch.ud['piece']
        if piece:
            if Board.instance.to_move == piece.color:
                piece.rect.pos = (touch.x - piece.rect.size[0]/2,
                                  touch.y - piece.rect.size[1]/2)

    def on_touch_up(self, touch):
        piece = touch.ud['piece']
        if piece:
            self.canvas.after.remove(piece.rect)
            self.canvas.add(piece.rect)
            if Board.instance.to_move != piece.color:
                return

            x, y = touch.x, touch.y
            x -= self.img_board.pos[0]
            y -= self.img_board.pos[1]
            if not (0 <= x <= self.img_board.size[0] and
                    0 <= y <= self.img_board.size[1]):
                self.update_geometry()
                return

            dest = Board.an_from_tup( (int(x / self.square_size),
                                       int(y / self.square_size)) )
            if dest in piece.get_valid_moves():
                Board.instance.move(piece.position,dest)
                self.select(dest)
            self.update_geometry()

Answer 1

I was able to implement this by creating a TouchHandler widget:

class TouchHandler(Widget):
    """ Non-display widget to handle touch order """
    instance = None

    def __init__(self):
        super().__init__()
        TouchHandler.instance = self
        self.active = None

Then overriding Window 's on_motion method prior to calling MyApp().run() :

if __name__ == '__main__':
    # Ignore new touches before first touch has resolved
    TouchHandler()
    def on_motion(self, etype, me):
        if 'pos' in me.profile:
            if etype == 'begin':
                if not TouchHandler.instance.active:
                    TouchHandler.instance.active = me

    Window.bind(on_motion=on_motion)

    Window.size = (500,500)
    MyApp().run()

For this to work, you need to manage your touch events very carefully and reset TouchHandler.instance.active to None when you're done with the touch in the on_touch_up method for any widget that will use the touch:

def on_touch_up(self, touch):
    if touch != TouchHandler.instance.active:
        return True # Signals Kivy to kill the event
    piece = touch.ud['piece']
    if piece:
        # ...
        self.update_geometry()
    TouchHandler.instance.active = None

Answer 2

This is an answer, but I'm kind of afraid of it, I'm pretty sure it's bad programming practice but:

I created a global variable with touch_counter = 0 , then in on_touch_down I referenced the global variable and then += 1 it, and in on_touch_up I -= 1 it. In on_touch_move I check if the touch_counter == 1 and then performed what I wanted it to do with only one touch.

This works with multitouch_sim, I realize this might mess up with actually multitouch devices, but so far so good.