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

kivy/input/providers/tuio.py

@@ -0,0 +1,326 @@
+'''
+TUIO Input Provider
+===================
+
+TUIO is the de facto standard network protocol for the transmission of
+touch and fiducial information between a server and a client. To learn
+more about TUIO (which is itself based on the OSC protocol), please
+refer to http://tuio.org -- The specification should be of special
+interest.
+
+Configure a TUIO provider in the config.ini
+-------------------------------------------
+
+The TUIO provider can be configured in the configuration file in the
+``[input]`` section::
+
+    [input]
+    # name = tuio,<ip>:<port>
+    multitouchtable = tuio,192.168.0.1:3333
+
+Configure a TUIO provider in the App
+------------------------------------
+
+You must add the provider before your application is run, like this::
+
+    from kivy.app import App
+    from kivy.config import Config
+
+    class TestApp(App):
+        def build(self):
+            Config.set('input', 'multitouchscreen1', 'tuio,0.0.0.0:3333')
+            # You can also add a second TUIO listener
+            # Config.set('input', 'source2', 'tuio,0.0.0.0:3334')
+            # Then do the usual things
+            # ...
+            return
+'''
+
+__all__ = ('TuioMotionEventProvider', 'Tuio2dCurMotionEvent',
+           'Tuio2dObjMotionEvent')
+
+from kivy.logger import Logger
+
+from functools import partial
+from collections import deque
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+
+class TuioMotionEventProvider(MotionEventProvider):
+    '''The TUIO provider listens to a socket and handles some of the incoming
+    OSC messages:
+
+        * /tuio/2Dcur
+        * /tuio/2Dobj
+
+    You can easily extend the provider to handle new TUIO paths like so::
+
+        # Create a class to handle the new TUIO type/path
+        # Replace NEWPATH with the pathname you want to handle
+        class TuioNEWPATHMotionEvent(MotionEvent):
+
+            def depack(self, args):
+                # In this method, implement 'unpacking' for the received
+                # arguments. you basically translate from TUIO args to Kivy
+                # MotionEvent variables. If all you receive are x and y
+                # values, you can do it like this:
+                if len(args) == 2:
+                    self.sx, self.sy = args
+                    self.profile = ('pos', )
+                self.sy = 1 - self.sy
+                super().depack(args)
+
+        # Register it with the TUIO MotionEvent provider.
+        # You obviously need to replace the PATH placeholders appropriately.
+        TuioMotionEventProvider.register('/tuio/PATH', TuioNEWPATHMotionEvent)
+
+    .. note::
+
+        The class name is of no technical importance. Your class will be
+        associated with the path that you pass to the ``register()``
+        function. To keep things simple, you should name your class after the
+        path that it handles, though.
+    '''
+
+    __handlers__ = {}
+
+    def __init__(self, device, args):
+        super().__init__(device, args)
+        args = args.split(',')
+        if len(args) == 0:
+            Logger.error('Tuio: Invalid configuration for TUIO provider')
+            Logger.error('Tuio: Format must be ip:port (eg. 127.0.0.1:3333)')
+            err = 'Tuio: Current configuration is <%s>' % (str(','.join(args)))
+            Logger.error(err)
+            return
+        ipport = args[0].split(':')
+        if len(ipport) != 2:
+            Logger.error('Tuio: Invalid configuration for TUIO provider')
+            Logger.error('Tuio: Format must be ip:port (eg. 127.0.0.1:3333)')
+            err = 'Tuio: Current configuration is <%s>' % (str(','.join(args)))
+            Logger.error(err)
+            return
+        self.ip, self.port = args[0].split(':')
+        self.port = int(self.port)
+        self.handlers = {}
+        self.oscid = None
+        self.tuio_event_q = deque()
+        self.touches = {}
+
+    @staticmethod
+    def register(oscpath, classname):
+        '''Register a new path to handle in TUIO provider'''
+        TuioMotionEventProvider.__handlers__[oscpath] = classname
+
+    @staticmethod
+    def unregister(oscpath, classname):
+        '''Unregister a path to stop handling it in the TUIO provider'''
+        if oscpath in TuioMotionEventProvider.__handlers__:
+            del TuioMotionEventProvider.__handlers__[oscpath]
+
+    @staticmethod
+    def create(oscpath, **kwargs):
+        '''Create a touch event from a TUIO path'''
+        if oscpath not in TuioMotionEventProvider.__handlers__:
+            raise Exception('Unknown %s touch path' % oscpath)
+        return TuioMotionEventProvider.__handlers__[oscpath](**kwargs)
+
+    def start(self):
+        '''Start the TUIO provider'''
+        try:
+            from oscpy.server import OSCThreadServer
+        except ImportError:
+            Logger.info(
+                'Please install the oscpy python module to use the TUIO '
+                'provider.'
+            )
+            raise
+        self.oscid = osc = OSCThreadServer()
+        osc.listen(self.ip, self.port, default=True)
+        for oscpath in TuioMotionEventProvider.__handlers__:
+            self.touches[oscpath] = {}
+            osc.bind(oscpath, partial(self._osc_tuio_cb, oscpath))
+
+    def stop(self):
+        '''Stop the TUIO provider'''
+        self.oscid.stop_all()
+
+    def update(self, dispatch_fn):
+        '''Update the TUIO provider (pop events from the queue)'''
+
+        # read the Queue with event
+        while True:
+            try:
+                value = self.tuio_event_q.pop()
+            except IndexError:
+                # queue is empty, we're done for now
+                return
+            self._update(dispatch_fn, value)
+
+    def _osc_tuio_cb(self, oscpath, address, *args):
+        self.tuio_event_q.appendleft([oscpath, address, args])
+
+    def _update(self, dispatch_fn, value):
+        oscpath, command, args = value
+
+        # verify commands
+        if command not in [b'alive', b'set']:
+            return
+
+        # move or create a new touch
+        if command == b'set':
+            id = args[0]
+            if id not in self.touches[oscpath]:
+                # new touch
+                touch = TuioMotionEventProvider.__handlers__[oscpath](
+                    self.device, id, args[1:])
+                self.touches[oscpath][id] = touch
+                dispatch_fn('begin', touch)
+            else:
+                # update a current touch
+                touch = self.touches[oscpath][id]
+                touch.move(args[1:])
+                dispatch_fn('update', touch)
+
+        # alive event, check for deleted touch
+        if command == b'alive':
+            alives = args
+            to_delete = []
+            for id in self.touches[oscpath]:
+                if id not in alives:
+                    # touch up
+                    touch = self.touches[oscpath][id]
+                    if touch not in to_delete:
+                        to_delete.append(touch)
+
+            for touch in to_delete:
+                dispatch_fn('end', touch)
+                del self.touches[oscpath][touch.id]
+
+
+class TuioMotionEvent(MotionEvent):
+    '''Abstraction for TUIO touches/fiducials.
+
+    Depending on the tracking software you use (e.g. Movid, CCV, etc.) and its
+    TUIO implementation, the TuioMotionEvent object can support multiple
+    profiles such as:
+
+        * Fiducial ID: profile name 'markerid', attribute ``.fid``
+        * Position: profile name 'pos', attributes ``.x``, ``.y``
+        * Angle: profile name 'angle', attribute ``.a``
+        * Velocity vector: profile name 'mov', attributes ``.X``, ``.Y``
+        * Rotation velocity: profile name 'rot', attribute ``.A``
+        * Motion acceleration: profile name 'motacc', attribute ``.m``
+        * Rotation acceleration: profile name 'rotacc', attribute ``.r``
+    '''
+    __attrs__ = ('a', 'b', 'c', 'X', 'Y', 'Z', 'A', 'B', 'C', 'm', 'r')
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        # Default argument for TUIO touches
+        self.a = 0.0
+        self.b = 0.0
+        self.c = 0.0
+        self.X = 0.0
+        self.Y = 0.0
+        self.Z = 0.0
+        self.A = 0.0
+        self.B = 0.0
+        self.C = 0.0
+        self.m = 0.0
+        self.r = 0.0
+
+    angle = property(lambda self: self.a)
+    mot_accel = property(lambda self: self.m)
+    rot_accel = property(lambda self: self.r)
+    xmot = property(lambda self: self.X)
+    ymot = property(lambda self: self.Y)
+    zmot = property(lambda self: self.Z)
+
+
+class Tuio2dCurMotionEvent(TuioMotionEvent):
+    '''A 2dCur TUIO touch.'''
+
+    def depack(self, args):
+        if len(args) < 5:
+            self.sx, self.sy = list(map(float, args[0:2]))
+            self.profile = ('pos', )
+        elif len(args) == 5:
+            self.sx, self.sy, self.X, self.Y, self.m = list(map(float,
+                                                                args[0:5]))
+            self.Y = -self.Y
+            self.profile = ('pos', 'mov', 'motacc')
+        else:
+            self.sx, self.sy, self.X, self.Y = list(map(float, args[0:4]))
+            self.m, width, height = list(map(float, args[4:7]))
+            self.Y = -self.Y
+            self.profile = ('pos', 'mov', 'motacc', 'shape')
+            if self.shape is None:
+                self.shape = ShapeRect()
+            self.shape.width = width
+            self.shape.height = height
+        self.sy = 1 - self.sy
+        super().depack(args)
+
+
+class Tuio2dObjMotionEvent(TuioMotionEvent):
+    '''A 2dObj TUIO object.
+    '''
+
+    def depack(self, args):
+        if len(args) < 5:
+            self.sx, self.sy = args[0:2]
+            self.profile = ('pos', )
+        elif len(args) == 9:
+            self.fid, self.sx, self.sy, self.a, self.X, self.Y = args[:6]
+            self.A, self.m, self.r = args[6:9]
+            self.Y = -self.Y
+            self.profile = ('markerid', 'pos', 'angle', 'mov', 'rot',
+                            'motacc', 'rotacc')
+        else:
+            self.fid, self.sx, self.sy, self.a, self.X, self.Y = args[:6]
+            self.A, self.m, self.r, width, height = args[6:11]
+            self.Y = -self.Y
+            self.profile = ('markerid', 'pos', 'angle', 'mov', 'rot', 'rotacc',
+                            'acc', 'shape')
+            if self.shape is None:
+                self.shape = ShapeRect()
+                self.shape.width = width
+                self.shape.height = height
+        self.sy = 1 - self.sy
+        super().depack(args)
+
+
+class Tuio2dBlbMotionEvent(TuioMotionEvent):
+    '''A 2dBlb TUIO object.
+    # FIXME 3d shape are not supported
+    /tuio/2Dobj set s i x y a       X Y A m r
+    /tuio/2Dblb set s   x y a w h f X Y A m r
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'angle', 'mov', 'rot', 'rotacc', 'acc', 'shape')
+
+    def depack(self, args):
+        self.sx, self.sy, self.a, self.X, self.Y, sw, sh, sd, \
+            self.A, self.m, self.r = args
+        self.Y = -self.Y
+        if self.shape is None:
+            self.shape = ShapeRect()
+            self.shape.width = sw
+            self.shape.height = sh
+        self.sy = 1 - self.sy
+        super().depack(args)
+
+
+# registers
+TuioMotionEventProvider.register(b'/tuio/2Dcur', Tuio2dCurMotionEvent)
+TuioMotionEventProvider.register(b'/tuio/2Dobj', Tuio2dObjMotionEvent)
+TuioMotionEventProvider.register(b'/tuio/2Dblb', Tuio2dBlbMotionEvent)
+MotionEventFactory.register('tuio', TuioMotionEventProvider)

kivy/input/providers/wm_common.py

@@ -0,0 +1,162 @@
+'''
+Common definitions for a Windows provider
+=========================================
+
+This file provides common definitions for constants used by WM_Touch / WM_Pen.
+'''
+import os
+
+WM_MOUSEFIRST = 512
+WM_MOUSEMOVE = 512
+WM_LBUTTONDOWN = 513
+WM_LBUTTONUP = 514
+WM_LBUTTONDBLCLK = 515
+WM_RBUTTONDOWN = 516
+WM_RBUTTONUP = 517
+WM_RBUTTONDBLCLK = 518
+WM_MBUTTONDOWN = 519
+WM_MBUTTONUP = 520
+WM_MBUTTONDBLCLK = 521
+WM_MOUSEWHEEL = 522
+WM_MOUSELAST = 522
+WM_DPICHANGED = 736
+WM_GETDPISCALEDSIZE = 740
+WM_NCCALCSIZE = 131
+
+WM_TOUCH = 576
+TOUCHEVENTF_MOVE = 1
+TOUCHEVENTF_DOWN = 2
+TOUCHEVENTF_UP = 4
+
+PEN_OR_TOUCH_SIGNATURE = 0xFF515700
+PEN_OR_TOUCH_MASK = 0xFFFFFF00
+PEN_EVENT_TOUCH_MASK = 0x80
+
+SM_CYCAPTION = 4
+
+WM_TABLET_QUERYSYSTEMGESTURE = 0x000002CC
+TABLET_DISABLE_PRESSANDHOLD = 0x00000001
+TABLET_DISABLE_PENTAPFEEDBACK = 0x00000008
+TABLET_DISABLE_PENBARRELFEEDBACK = 0x00000010
+TABLET_DISABLE_TOUCHUIFORCEON = 0x00000100
+TABLET_DISABLE_TOUCHUIFORCEOFF = 0x00000200
+TABLET_DISABLE_TOUCHSWITCH = 0x00008000
+TABLET_DISABLE_FLICKS = 0x00010000
+TABLET_ENABLE_FLICKSONCONTEXT = 0x00020000
+TABLET_ENABLE_FLICKLEARNINGMODE = 0x00040000
+TABLET_DISABLE_SMOOTHSCROLLING = 0x00080000
+TABLET_DISABLE_FLICKFALLBACKKEYS = 0x00100000
+GWL_WNDPROC = -4
+
+
+QUERYSYSTEMGESTURE_WNDPROC = (
+    TABLET_DISABLE_PRESSANDHOLD |
+    TABLET_DISABLE_PENTAPFEEDBACK |
+    TABLET_DISABLE_PENBARRELFEEDBACK |
+    TABLET_DISABLE_SMOOTHSCROLLING |
+    TABLET_DISABLE_FLICKFALLBACKKEYS |
+    TABLET_DISABLE_TOUCHSWITCH |
+    TABLET_DISABLE_FLICKS)
+
+if 'KIVY_DOC' not in os.environ:
+    from ctypes.wintypes import (ULONG, HANDLE, DWORD, LONG, UINT,
+                                 WPARAM, LPARAM, BOOL, HWND, POINT,
+                                 RECT as RECT_BASE)
+    from ctypes import (windll, WINFUNCTYPE, POINTER,
+                        c_int, c_longlong, c_void_p, Structure,
+                        sizeof, byref, cast)
+
+    class RECT(RECT_BASE):
+        x = property(lambda self: self.left)
+        y = property(lambda self: self.top)
+        w = property(lambda self: self.right - self.left)
+        h = property(lambda self: self.bottom - self.top)
+
+    # check availability of RegisterTouchWindow
+    if not hasattr(windll.user32, 'RegisterTouchWindow'):
+        raise Exception('Unsupported Window version')
+
+    LRESULT = LPARAM
+    WNDPROC = WINFUNCTYPE(LRESULT, HWND, UINT, WPARAM, LPARAM)
+
+    class TOUCHINPUT(Structure):
+        _fields_ = [
+            ('x', LONG),
+            ('y', LONG),
+            ('pSource', HANDLE),
+            ('id', DWORD),
+            ('flags', DWORD),
+            ('mask', DWORD),
+            ('time', DWORD),
+            ('extraInfo', POINTER(ULONG)),
+            ('size_x', DWORD),
+            ('size_y', DWORD)]
+
+        def size(self):
+            return (self.size_x, self.size_y)
+
+        def screen_x(self):
+            return self.x / 100.0
+
+        def screen_y(self):
+            return self.y / 100.0
+
+        def _event_type(self):
+            if self.flags & TOUCHEVENTF_MOVE:
+                return 'update'
+            if self.flags & TOUCHEVENTF_DOWN:
+                return 'begin'
+            if self.flags & TOUCHEVENTF_UP:
+                return 'end'
+        event_type = property(_event_type)
+
+    def SetWindowLong_WndProc_wrapper_generator(func):
+        def _closure(hWnd, wndProc):
+            oldAddr = func(hWnd, GWL_WNDPROC, cast(wndProc, c_void_p).value)
+            return cast(c_void_p(oldAddr), WNDPROC)
+
+        return _closure
+
+    try:
+        LONG_PTR = c_longlong
+        windll.user32.SetWindowLongPtrW.restype = LONG_PTR
+        windll.user32.SetWindowLongPtrW.argtypes = [HWND, c_int, LONG_PTR]
+        SetWindowLong_WndProc_wrapper = \
+            SetWindowLong_WndProc_wrapper_generator(
+                windll.user32.SetWindowLongPtrW)
+    except AttributeError:
+        windll.user32.SetWindowLongW.restype = LONG
+        windll.user32.SetWindowLongW.argtypes = [HWND, c_int, LONG]
+        SetWindowLong_WndProc_wrapper = \
+            SetWindowLong_WndProc_wrapper_generator(
+                windll.user32.SetWindowLongW)
+
+    windll.user32.GetMessageExtraInfo.restype = LPARAM
+    windll.user32.GetMessageExtraInfo.argtypes = []
+    windll.user32.GetClientRect.restype = BOOL
+    windll.user32.GetClientRect.argtypes = [HANDLE, POINTER(RECT_BASE)]
+    windll.user32.GetWindowRect.restype = BOOL
+    windll.user32.GetWindowRect.argtypes = [HANDLE, POINTER(RECT_BASE)]
+    windll.user32.CallWindowProcW.restype = LRESULT
+    windll.user32.CallWindowProcW.argtypes = [WNDPROC, HWND, UINT, WPARAM,
+                                              LPARAM]
+    windll.user32.GetActiveWindow.restype = HWND
+    windll.user32.GetActiveWindow.argtypes = []
+    windll.user32.RegisterTouchWindow.restype = BOOL
+    windll.user32.RegisterTouchWindow.argtypes = [HWND, ULONG]
+    windll.user32.UnregisterTouchWindow.restype = BOOL
+    windll.user32.UnregisterTouchWindow.argtypes = [HWND]
+    windll.user32.GetTouchInputInfo.restype = BOOL
+    windll.user32.GetTouchInputInfo.argtypes = [HANDLE, UINT,
+                                                POINTER(TOUCHINPUT), c_int]
+    windll.user32.GetSystemMetrics.restype = c_int
+    windll.user32.GetSystemMetrics.argtypes = [c_int]
+
+    windll.user32.ClientToScreen.restype = BOOL
+    windll.user32.ClientToScreen.argtypes = [HWND, POINTER(POINT)]
+
+    try:
+        windll.user32.GetDpiForWindow.restype = UINT
+        windll.user32.GetDpiForWindow.argtypes = [HWND]
+    except AttributeError:
+        pass

kivy/input/providers/wm_pen.py

@@ -0,0 +1,121 @@
+'''
+Support for WM_PEN messages (Windows platform)
+==============================================
+'''
+
+__all__ = ('WM_PenProvider', 'WM_Pen')
+
+import os
+from kivy.input.providers.wm_common import RECT, PEN_OR_TOUCH_MASK, \
+    PEN_OR_TOUCH_SIGNATURE, PEN_EVENT_TOUCH_MASK, WM_LBUTTONDOWN, \
+    WM_MOUSEMOVE, WM_LBUTTONUP, WM_TABLET_QUERYSYSTEMGESTURE, \
+    QUERYSYSTEMGESTURE_WNDPROC, WNDPROC, SetWindowLong_WndProc_wrapper
+from kivy.input.motionevent import MotionEvent
+
+
+class WM_Pen(MotionEvent):
+    '''MotionEvent representing the WM_Pen event. Supports the pos profile.'''
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ['pos']
+
+    def depack(self, args):
+        self.sx, self.sy = args[0], args[1]
+        super().depack(args)
+
+    def __str__(self):
+        i, u, s, d = (self.id, self.uid, str(self.spos), self.device)
+        return '<WMPen id:%d uid:%d pos:%s device:%s>' % (i, u, s, d)
+
+
+if 'KIVY_DOC' in os.environ:
+    # documentation hack
+    WM_PenProvider = None
+
+else:
+    from collections import deque
+    from ctypes import windll, byref, c_int16, c_int
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+
+    win_rect = RECT()
+
+    class WM_PenProvider(MotionEventProvider):
+
+        def _is_pen_message(self, msg):
+            info = windll.user32.GetMessageExtraInfo()
+            # It's a touch or a pen
+            if (info & PEN_OR_TOUCH_MASK) == PEN_OR_TOUCH_SIGNATURE:
+                if not info & PEN_EVENT_TOUCH_MASK:
+                    return True
+
+        def _pen_handler(self, msg, wParam, lParam):
+            if msg not in (WM_LBUTTONDOWN, WM_MOUSEMOVE, WM_LBUTTONUP):
+                return
+
+            windll.user32.GetClientRect(self.hwnd, byref(win_rect))
+            x = c_int16(lParam & 0xffff).value / float(win_rect.w)
+            y = c_int16(lParam >> 16).value / float(win_rect.h)
+            y = abs(1.0 - y)
+
+            if msg == WM_LBUTTONDOWN:
+                self.pen_events.appendleft(('begin', x, y))
+                self.pen_status = True
+
+            if msg == WM_MOUSEMOVE and self.pen_status:
+                self.pen_events.appendleft(('update', x, y))
+
+            if msg == WM_LBUTTONUP:
+                self.pen_events.appendleft(('end', x, y))
+                self.pen_status = False
+
+        def _pen_wndProc(self, hwnd, msg, wParam, lParam):
+            if msg == WM_TABLET_QUERYSYSTEMGESTURE:
+                return QUERYSYSTEMGESTURE_WNDPROC
+            if self._is_pen_message(msg):
+                self._pen_handler(msg, wParam, lParam)
+                return 1
+            else:
+                return windll.user32.CallWindowProcW(self.old_windProc,
+                                                     hwnd, msg, wParam, lParam)
+
+        def start(self):
+            self.uid = 0
+            self.pen = None
+            self.pen_status = None
+            self.pen_events = deque()
+
+            self.hwnd = windll.user32.GetActiveWindow()
+
+            # inject our own wndProc to handle messages
+            # before window manager does
+            self.new_windProc = WNDPROC(self._pen_wndProc)
+            self.old_windProc = SetWindowLong_WndProc_wrapper(
+                self.hwnd, self.new_windProc)
+
+        def update(self, dispatch_fn):
+            while True:
+
+                try:
+                    etype, x, y = self.pen_events.pop()
+                except:
+                    break
+
+                if etype == 'begin':
+                    self.uid += 1
+                    self.pen = WM_Pen(self.device, self.uid, [x, y])
+                elif etype == 'update':
+                    self.pen.move([x, y])
+                elif etype == 'end':
+                    self.pen.update_time_end()
+
+                dispatch_fn(etype, self.pen)
+
+        def stop(self):
+            self.pen = None
+            SetWindowLong_WndProc_wrapper(self.hwnd, self.old_windProc)
+
+    MotionEventFactory.register('wm_pen', WM_PenProvider)