Kivy-examples 2.3.1.dev0__py3-none-any.whl

kivy/input/providers/wm_touch.py

@@ -0,0 +1,157 @@
+'''
+Support for WM_TOUCH messages (Windows platform)
+================================================
+'''
+
+__all__ = ('WM_MotionEventProvider', 'WM_MotionEvent')
+
+import os
+from kivy.input.providers.wm_common import WNDPROC, \
+    SetWindowLong_WndProc_wrapper, RECT, POINT, WM_TABLET_QUERYSYSTEMGESTURE, \
+    QUERYSYSTEMGESTURE_WNDPROC, WM_TOUCH, WM_MOUSEMOVE, WM_MOUSELAST, \
+    TOUCHINPUT, PEN_OR_TOUCH_MASK, PEN_OR_TOUCH_SIGNATURE, PEN_EVENT_TOUCH_MASK
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+Window = None
+
+
+class WM_MotionEvent(MotionEvent):
+    '''MotionEvent representing the WM_MotionEvent event.
+       Supports pos, shape and size profiles.
+    '''
+    __attrs__ = ('size', )
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'shape', 'size')
+
+    def depack(self, args):
+        self.shape = ShapeRect()
+        self.sx, self.sy = args[0], args[1]
+        self.shape.width = args[2][0]
+        self.shape.height = args[2][1]
+        self.size = self.shape.width * self.shape.height
+        super().depack(args)
+
+    def __str__(self):
+        args = (self.id, self.uid, str(self.spos), self.device)
+        return '<WMMotionEvent id:%d uid:%d pos:%s device:%s>' % args
+
+
+if 'KIVY_DOC' in os.environ:
+    # documentation hack
+    WM_MotionEventProvider = None
+
+else:
+    from ctypes.wintypes import HANDLE
+    from ctypes import (windll, sizeof, byref)
+    from collections import deque
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+
+    class WM_MotionEventProvider(MotionEventProvider):
+
+        def start(self):
+            global Window
+            if not Window:
+                from kivy.core.window import Window
+
+            self.touch_events = deque()
+            self.touches = {}
+            self.uid = 0
+
+            # get window handle, and register to receive WM_TOUCH messages
+            self.hwnd = windll.user32.GetActiveWindow()
+            windll.user32.RegisterTouchWindow(self.hwnd, 1)
+
+            # inject our own wndProc to handle messages
+            # before window manager does
+            self.new_windProc = WNDPROC(self._touch_wndProc)
+            self.old_windProc = SetWindowLong_WndProc_wrapper(
+                self.hwnd, self.new_windProc)
+
+        def update(self, dispatch_fn):
+            c_rect = RECT()
+            windll.user32.GetClientRect(self.hwnd, byref(c_rect))
+            pt = POINT(x=0, y=0)
+            windll.user32.ClientToScreen(self.hwnd, byref(pt))
+            x_offset, y_offset = pt.x, pt.y
+            usable_w, usable_h = float(c_rect.w), float(c_rect.h)
+
+            while True:
+                try:
+                    t = self.touch_events.pop()
+                except:
+                    break
+
+                # adjust x,y to window coordinates (0.0 to 1.0)
+                x = (t.screen_x() - x_offset) / usable_w
+                y = 1.0 - (t.screen_y() - y_offset) / usable_h
+
+                # actually dispatch input
+                if t.event_type == 'begin':
+                    self.uid += 1
+                    self.touches[t.id] = WM_MotionEvent(
+                        self.device, self.uid, [x, y, t.size()])
+                    dispatch_fn('begin', self.touches[t.id])
+
+                if t.event_type == 'update' and t.id in self.touches:
+                    self.touches[t.id].move([x, y, t.size()])
+                    dispatch_fn('update', self.touches[t.id])
+
+                if t.event_type == 'end' and t.id in self.touches:
+                    touch = self.touches[t.id]
+                    touch.move([x, y, t.size()])
+                    touch.update_time_end()
+                    dispatch_fn('end', touch)
+                    del self.touches[t.id]
+
+        def stop(self):
+            windll.user32.UnregisterTouchWindow(self.hwnd)
+            self.new_windProc = SetWindowLong_WndProc_wrapper(
+                self.hwnd, self.old_windProc)
+
+        # we inject this wndProc into our main window, to process
+        # WM_TOUCH and mouse messages before the window manager does
+        def _touch_wndProc(self, hwnd, msg, wParam, lParam):
+            done = False
+            if msg == WM_TABLET_QUERYSYSTEMGESTURE:
+                return QUERYSYSTEMGESTURE_WNDPROC
+
+            if msg == WM_TOUCH:
+                done = self._touch_handler(msg, wParam, lParam)
+
+            if msg >= WM_MOUSEMOVE and msg <= WM_MOUSELAST:
+                done = self._mouse_handler(msg, wParam, lParam)
+
+            if not done:
+                return windll.user32.CallWindowProcW(self.old_windProc,
+                                                     hwnd, msg, wParam,
+                                                     lParam)
+            return 1
+
+        # this on pushes WM_TOUCH messages onto our event stack
+        def _touch_handler(self, msg, wParam, lParam):
+            touches = (TOUCHINPUT * wParam)()
+            windll.user32.GetTouchInputInfo(HANDLE(lParam),
+                                            wParam,
+                                            touches,
+                                            sizeof(TOUCHINPUT))
+            for i in range(wParam):
+                self.touch_events.appendleft(touches[i])
+            windll.user32.CloseTouchInputHandle(HANDLE(lParam))
+            return True
+
+        # filter fake mouse events, because touch and stylus
+        # also make mouse events
+        def _mouse_handler(self, msg, wparam, lParam):
+            info = windll.user32.GetMessageExtraInfo()
+            # its a touch or a pen
+            if (info & PEN_OR_TOUCH_MASK) == PEN_OR_TOUCH_SIGNATURE:
+                if info & PEN_EVENT_TOUCH_MASK:
+                    return True
+
+    MotionEventFactory.register('wm_touch', WM_MotionEventProvider)

kivy/input/recorder.py

@@ -0,0 +1,335 @@
+'''
+Input recorder
+==============
+
+.. versionadded:: 1.1.0
+
+.. warning::
+
+    This part of Kivy is still experimental and this API is subject to
+    change in a future version.
+
+This is a class that can record and replay some input events. This can
+be used for test cases, screen savers etc.
+
+Once activated, the recorder will listen for any input event and save its
+properties in a file with the delta time. Later, you can play the input
+file: it will generate fake touch events with the saved properties and
+dispatch it to the event loop.
+
+By default, only the position is saved ('pos' profile and 'sx', 'sy',
+attributes). Change it only if you understand how input handling works.
+
+Recording events
+----------------
+
+The best way is to use the "recorder" module. Check the :doc:`api-kivy.modules`
+documentation to see how to activate a module.
+
+Once activated, you can press F8 to start the recording. By default,
+events will be written to `<currentpath>/recorder.kvi`. When you want to
+stop recording, press F8 again.
+
+You can replay the file by pressing F7.
+
+Check the :doc:`api-kivy.modules.recorder` module for more information.
+
+Manual play
+-----------
+
+You can manually open a recorder file, and play it by doing::
+
+    from kivy.input.recorder import Recorder
+
+    rec = Recorder(filename='myrecorder.kvi')
+    rec.play = True
+
+If you want to loop over that file, you can do::
+
+
+    from kivy.input.recorder import Recorder
+
+    def recorder_loop(instance, value):
+        if value is False:
+            instance.play = True
+
+    rec = Recorder(filename='myrecorder.kvi')
+    rec.bind(play=recorder_loop)
+    rec.play = True
+
+Recording more attributes
+-------------------------
+
+You can extend the attributes to save on one condition: attributes values must
+be simple values, not instances of complex classes.
+
+Let's say you want to save the angle and pressure of the touch, if available::
+
+    from kivy.input.recorder import Recorder
+
+    rec = Recorder(filename='myrecorder.kvi',
+        record_attrs=['is_touch', 'sx', 'sy', 'angle', 'pressure'],
+        record_profile_mask=['pos', 'angle', 'pressure'])
+    rec.record = True
+
+Or with modules variables::
+
+    $ python main.py -m recorder,attrs=is_touch:sx:sy:angle:pressure, \
+            profile_mask=pos:angle:pressure
+
+Known limitations
+-----------------
+
+  - Unable to save attributes with instances of complex classes.
+  - Values that represent time will not be adjusted.
+  - Can replay only complete records. If a begin/update/end event is missing,
+    this could lead to ghost touches.
+  - Stopping the replay before the end can lead to ghost touches.
+
+'''
+
+__all__ = ('Recorder', )
+
+from os.path import exists
+from time import time
+from kivy.event import EventDispatcher
+from kivy.properties import ObjectProperty, BooleanProperty, StringProperty, \
+    NumericProperty, ListProperty
+from kivy.input.motionevent import MotionEvent
+from kivy.base import EventLoop
+from kivy.logger import Logger
+from ast import literal_eval
+from functools import partial
+
+
+class RecorderMotionEvent(MotionEvent):
+
+    def depack(self, args):
+        for key, value in list(args.items()):
+            setattr(self, key, value)
+        super(RecorderMotionEvent, self).depack(args)
+
+
+class Recorder(EventDispatcher):
+    '''Recorder class. Please check module documentation for more information.
+
+    :Events:
+        `on_stop`:
+            Fired when the playing stops.
+
+    .. versionchanged:: 1.10.0
+        Event `on_stop` added.
+    '''
+
+    window = ObjectProperty(None)
+    '''Window instance to attach the recorder. If None, it will use the
+    default instance.
+
+    :attr:`window` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    counter = NumericProperty(0)
+    '''Number of events recorded in the last session.
+
+    :attr:`counter` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0, read-only.
+    '''
+
+    play = BooleanProperty(False)
+    '''Boolean to start/stop the replay of the current file (if it exists).
+
+    :attr:`play` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    record = BooleanProperty(False)
+    '''Boolean to start/stop the recording of input events.
+
+    :attr:`record` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    filename = StringProperty('recorder.kvi')
+    '''Filename to save the output of the recorder.
+
+    :attr:`filename` is a :class:`~kivy.properties.StringProperty` and defaults
+    to 'recorder.kvi'.
+    '''
+
+    record_attrs = ListProperty(['is_touch', 'sx', 'sy'])
+    '''Attributes to record from the motion event.
+
+    :attr:`record_attrs` is a :class:`~kivy.properties.ListProperty` and
+    defaults to ['is_touch', 'sx', 'sy'].
+    '''
+
+    record_profile_mask = ListProperty(['pos'])
+    '''Profile to save in the fake motion event when replayed.
+
+    :attr:`record_profile_mask` is a :class:`~kivy.properties.ListProperty` and
+    defaults to ['pos'].
+    '''
+
+    # internals
+    record_fd = ObjectProperty(None)
+    record_time = NumericProperty(0.)
+
+    __events__ = ('on_stop',)
+
+    def __init__(self, **kwargs):
+        super(Recorder, self).__init__(**kwargs)
+        if self.window is None:
+            # manually set the current window
+            from kivy.core.window import Window
+            self.window = Window
+        self.window.bind(
+            on_motion=self.on_motion,
+            on_key_up=partial(self.on_keyboard, 'keyup'),
+            on_key_down=partial(self.on_keyboard, 'keydown'),
+            on_keyboard=partial(self.on_keyboard, 'keyboard'))
+
+    def on_motion(self, window, etype, motionevent):
+        if not self.record:
+            return
+
+        args = dict((arg, getattr(motionevent, arg))
+                    for arg in self.record_attrs if hasattr(motionevent, arg))
+
+        args['profile'] = [x for x in motionevent.profile if x in
+                           self.record_profile_mask]
+        self.record_fd.write('%r\n' % (
+            (time() - self.record_time, etype, motionevent.uid, args), ))
+        self.counter += 1
+
+    def on_keyboard(self, etype, window, key, *args, **kwargs):
+        if not self.record:
+            return
+        self.record_fd.write('%r\n' % (
+            (time() - self.record_time, etype, 0, {
+                'key': key,
+                'scancode': kwargs.get('scancode'),
+                'codepoint': kwargs.get('codepoint', kwargs.get('unicode')),
+                'modifier': kwargs.get('modifier'),
+                'is_touch': False}), ))
+        self.counter += 1
+
+    def release(self):
+        self.window.unbind(
+            on_motion=self.on_motion,
+            on_key_up=self.on_keyboard,
+            on_key_down=self.on_keyboard)
+
+    def on_record(self, instance, value):
+        if value:
+            # generate a record filename
+            self.counter = 0
+            self.record_time = time()
+            self.record_fd = open(self.filename, 'w')
+            self.record_fd.write('#RECORDER1.0\n')
+            Logger.info('Recorder: Recording inputs to %r' % self.filename)
+        else:
+            self.record_fd.close()
+            Logger.info('Recorder: Recorded %d events in %r' % (self.counter,
+                                                                self.filename))
+
+    # needed for acting as an input provider
+    def stop(self):
+        pass
+
+    def start(self):
+        pass
+
+    def on_play(self, instance, value):
+        if not value:
+            Logger.info('Recorder: Stop playing %r' % self.filename)
+            EventLoop.remove_input_provider(self)
+            return
+        if not exists(self.filename):
+            Logger.error('Recorder: Unable to find %r file, play aborted.' % (
+                self.filename))
+            return
+
+        with open(self.filename, 'r') as fd:
+            data = fd.read().splitlines()
+
+        if len(data) < 2:
+            Logger.error('Recorder: Unable to play %r, file truncated.' % (
+                self.filename))
+            return
+
+        if data[0] != '#RECORDER1.0':
+            Logger.error('Recorder: Unable to play %r, invalid header.' % (
+                self.filename))
+            return
+
+        # decompile data
+        self.play_data = [literal_eval(x) for x in data[1:]]
+        self.play_time = time()
+        self.play_me = {}
+        Logger.info('Recorder: Start playing %d events from %r' %
+                    (len(self.play_data), self.filename))
+        EventLoop.add_input_provider(self)
+
+    def on_stop(self):
+        pass
+
+    def update(self, dispatch_fn):
+        if not self.play_data:
+            Logger.info('Recorder: Playing finished.')
+            self.play = False
+            self.dispatch('on_stop')
+
+        dt = time() - self.play_time
+        while self.play_data:
+            event = self.play_data[0]
+            assert len(event) == 4
+            if event[0] > dt:
+                return
+
+            me = None
+            etype, uid, args = event[1:]
+            if etype == 'begin':
+                me = RecorderMotionEvent('recorder', uid, args)
+                self.play_me[uid] = me
+            elif etype == 'update':
+                me = self.play_me[uid]
+                me.depack(args)
+            elif etype == 'end':
+                me = self.play_me.pop(uid)
+                me.depack(args)
+            elif etype == 'keydown':
+                self.window.dispatch(
+                    'on_key_down',
+                    args['key'],
+                    args['scancode'],
+                    args['codepoint'],
+                    args['modifier'])
+            elif etype == 'keyup':
+                self.window.dispatch(
+                    'on_key_up',
+                    args['key'],
+                    args['scancode'],
+                    args['codepoint'],
+                    args['modifier'])
+            elif etype == 'keyboard':
+                self.window.dispatch(
+                    'on_keyboard',
+                    args['key'],
+                    args['scancode'],
+                    args['codepoint'],
+                    args['modifier'])
+
+            if me:
+                dispatch_fn(etype, me)
+
+            self.play_data.pop(0)
+
+
+def start(win, ctx):
+    ctx.recorder = Recorder(window=win)
+
+
+def stop(win, ctx):
+    if hasattr(ctx, 'recorder'):
+        ctx.recorder.release()

kivy/input/shape.py

@@ -0,0 +1,27 @@
+'''
+Motion Event Shape
+==================
+
+Represent the shape of the :class:`~kivy.input.motionevent.MotionEvent`
+'''
+
+__all__ = ('Shape', 'ShapeRect')
+
+
+class Shape(object):
+    '''Abstract class for all implementations of a shape'''
+    pass
+
+
+class ShapeRect(Shape):
+    '''Class for the representation of a rectangle.'''
+    __slots__ = ('width', 'height')
+
+    def __init__(self):
+        super(ShapeRect, self).__init__()
+
+        #: Width of the rect
+        self.width = 0
+
+        #: Height of the rect
+        self.height = 0