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

kivy/input/providers/mactouch.py

@@ -0,0 +1,220 @@
+'''
+Native support of MultitouchSupport framework for MacBook (MaxOSX platform)
+===========================================================================
+'''
+
+__all__ = ('MacMotionEventProvider', )
+
+import ctypes
+import threading
+import collections
+import os
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+if 'KIVY_DOC' not in os.environ:
+    CFArrayRef = ctypes.c_void_p
+    CFMutableArrayRef = ctypes.c_void_p
+    CFIndex = ctypes.c_long
+
+    dll = '/System/Library/PrivateFrameworks/' + \
+        'MultitouchSupport.framework/MultitouchSupport'
+    MultitouchSupport = ctypes.CDLL(dll)
+
+    CFArrayGetCount = MultitouchSupport.CFArrayGetCount
+    CFArrayGetCount.argtypes = [CFArrayRef]
+    CFArrayGetCount.restype = CFIndex
+
+    CFArrayGetValueAtIndex = MultitouchSupport.CFArrayGetValueAtIndex
+    CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]
+    CFArrayGetValueAtIndex.restype = ctypes.c_void_p
+
+    MTDeviceCreateList = MultitouchSupport.MTDeviceCreateList
+    MTDeviceCreateList.argtypes = []
+    MTDeviceCreateList.restype = CFMutableArrayRef
+
+    class MTPoint(ctypes.Structure):
+        _fields_ = [('x', ctypes.c_float),
+                    ('y', ctypes.c_float)]
+
+    class MTVector(ctypes.Structure):
+        _fields_ = [('position', MTPoint),
+                    ('velocity', MTPoint)]
+
+    class MTData(ctypes.Structure):
+        _fields_ = [
+            ('frame', ctypes.c_int),
+            ('timestamp', ctypes.c_double),
+            ('identifier', ctypes.c_int),
+            # Current state (of unknown meaning).
+            ('state', ctypes.c_int),
+            ('unknown1', ctypes.c_int),
+            ('unknown2', ctypes.c_int),
+            # Normalized position and vector of the touch (0 to 1)
+            ('normalized', MTVector),
+            # The area of the touch.
+            ('size', ctypes.c_float),
+            ('unknown3', ctypes.c_int),
+            # The following three define the ellipsoid of a finger.
+            ('angle', ctypes.c_float),
+            ('major_axis', ctypes.c_float),
+            ('minor_axis', ctypes.c_float),
+            ('unknown4', MTVector),
+            ('unknown5_1', ctypes.c_int),
+            ('unknown5_2', ctypes.c_int),
+            ('unknown6', ctypes.c_float), ]
+
+    MTDataRef = ctypes.POINTER(MTData)
+
+    MTContactCallbackFunction = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int,
+                                                 MTDataRef, ctypes.c_int,
+                                                 ctypes.c_double, ctypes.c_int)
+
+    MTDeviceRef = ctypes.c_void_p
+
+    MTRegisterContactFrameCallback = \
+        MultitouchSupport.MTRegisterContactFrameCallback
+    MTRegisterContactFrameCallback.argtypes = \
+        [MTDeviceRef, MTContactCallbackFunction]
+    MTRegisterContactFrameCallback.restype = None
+
+    MTDeviceStart = MultitouchSupport.MTDeviceStart
+    MTDeviceStart.argtypes = [MTDeviceRef, ctypes.c_int]
+    MTDeviceStart.restype = None
+
+else:
+    MTContactCallbackFunction = lambda x: None
+
+
+class MacMotionEvent(MotionEvent):
+    '''MotionEvent representing a contact point on the touchpad. Supports pos
+    and shape profiles.
+    '''
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'shape')
+
+    def depack(self, args):
+        self.shape = ShapeRect()
+        self.sx, self.sy = args[0], args[1]
+        self.shape.width = args[2]
+        self.shape.height = args[2]
+        super().depack(args)
+
+    def __str__(self):
+        return '<MacMotionEvent id=%d pos=(%f, %f) device=%s>' \
+            % (self.id, self.sx, self.sy, self.device)
+
+
+_instance = None
+
+
+class MacMotionEventProvider(MotionEventProvider):
+
+    def __init__(self, *largs, **kwargs):
+        global _instance
+        if _instance is not None:
+            raise Exception('Only one MacMotionEvent provider is allowed.')
+        _instance = self
+        super(MacMotionEventProvider, self).__init__(*largs, **kwargs)
+
+    def start(self):
+        # global uid
+        self.uid = 0
+        # touches will be per devices
+        self.touches = {}
+        # lock needed to access on uid
+        self.lock = threading.Lock()
+        # event queue to dispatch in main thread
+        self.queue = collections.deque()
+
+        # ok, listing devices, and attach !
+        devices = MultitouchSupport.MTDeviceCreateList()
+        num_devices = CFArrayGetCount(devices)
+        for i in range(num_devices):
+            device = CFArrayGetValueAtIndex(devices, i)
+            # create touch dict for this device
+            data_id = str(device)
+            self.touches[data_id] = {}
+            # start !
+            MTRegisterContactFrameCallback(device, self._mts_callback)
+            MTDeviceStart(device, 0)
+
+    def update(self, dispatch_fn):
+        # dispatch all event from threads
+        try:
+            while True:
+                event_type, touch = self.queue.popleft()
+                dispatch_fn(event_type, touch)
+        except:
+            pass
+
+    def stop(self):
+        # i don't known how to stop it...
+        pass
+
+    @MTContactCallbackFunction
+    def _mts_callback(device, data_ptr, n_fingers, timestamp, frame):
+        global _instance
+        devid = str(device)
+
+        # XXX create live touch, we get one case that
+        # the device announced by macosx don't match the device
+        # in _mts_callback....
+        if devid not in _instance.touches:
+            _instance.touches[devid] = {}
+
+        touches = _instance.touches[devid]
+        actives = []
+
+        for i in range(n_fingers):
+            # get pointer on data
+            data = data_ptr[i]
+
+            # add this touch as an active touch
+            actives.append(data.identifier)
+
+            # extract identifier
+            data_id = data.identifier
+
+            # prepare argument position
+            norm_pos = data.normalized.position
+            args = (norm_pos.x, norm_pos.y, data.size)
+
+            if data_id not in touches:
+                # increment uid
+                _instance.lock.acquire()
+                _instance.uid += 1
+                # create a touch
+                touch = MacMotionEvent(_instance.device, _instance.uid, args)
+                _instance.lock.release()
+                # create event
+                _instance.queue.append(('begin', touch))
+                # store touch
+                touches[data_id] = touch
+            else:
+                touch = touches[data_id]
+                # check if he really moved
+                if data.normalized.position.x == touch.sx and \
+                   data.normalized.position.y == touch.sy:
+                    continue
+                touch.move(args)
+                _instance.queue.append(('update', touch))
+
+        # delete old touchs
+        for tid in list(touches.keys())[:]:
+            if tid not in actives:
+                touch = touches[tid]
+                touch.update_time_end()
+                _instance.queue.append(('end', touch))
+                del touches[tid]
+
+        return 0
+
+
+MotionEventFactory.register('mactouch', MacMotionEventProvider)

kivy/input/providers/mouse.py

@@ -0,0 +1,424 @@
+'''
+Mouse provider implementation
+=============================
+
+On linux systems, the mouse provider can be annoying when used with another
+multitouch provider (hidinput or mtdev). The Mouse can conflict with them: a
+single touch can generate one event from the mouse provider and another
+from the multitouch provider.
+
+To avoid this behavior, you can activate the "disable_on_activity" token in
+the mouse configuration. Then, if any touches are created by another
+provider, the mouse event will be discarded. Add this to your configuration::
+
+    [input]
+    mouse = mouse,disable_on_activity
+
+Using multitouch interaction with the mouse
+-------------------------------------------
+
+.. versionadded:: 1.3.0
+
+By default, the middle and right mouse buttons, as well as a combination of
+ctrl + left mouse button are used for multitouch emulation.
+If you want to use them for other purposes, you can disable this behavior by
+activating the "disable_multitouch" token::
+
+   [input]
+   mouse = mouse,disable_multitouch
+
+.. versionchanged:: 1.9.0
+
+You can now selectively control whether a click initiated as described above
+will emulate multi-touch. If the touch has been initiated in the above manner
+(e.g. right mouse button), a `multitouch_sim` value will be added to the
+touch's profile, and a `multitouch_sim` property will be added to the touch.
+By default, `multitouch_sim` is True and multitouch will be emulated for that
+touch. If, however, `multitouch_on_demand` is added to the config::
+
+   [input]
+   mouse = mouse,multitouch_on_demand
+
+then `multitouch_sim` defaults to `False`. In that case, if `multitouch_sim`
+is set to True before the mouse is released (e.g. in on_touch_down/move), the
+touch will simulate a multi-touch event. For example::
+
+    if 'multitouch_sim' in touch.profile:
+        touch.multitouch_sim = True
+
+.. versionchanged:: 2.1.0
+
+Provider dispatches hover events by listening to properties/events in
+:class:`~kivy.core.window.Window`. Dispatching can be disabled by setting
+:attr:`MouseMotionEventProvider.disable_hover` to ``True`` or by adding
+`disable_hover` in the config::
+
+    [input]
+    mouse = mouse,disable_hover
+
+It's also possible to enable/disable hover events at runtime with
+:attr:`MouseMotionEventProvider.disable_hover` property.
+
+Following is a list of the supported values for the
+:attr:`~kivy.input.motionevent.MotionEvent.profile` property list.
+
+================ ==========================================================
+Profile value    Description
+---------------- ----------------------------------------------------------
+button           Mouse button (one of `left`, `right`, `middle`, `scrollup`
+                 or `scrolldown`). Accessed via the 'button' property.
+pos              2D position. Also reflected in the
+                 :attr:`~kivy.input.motionevent.MotionEvent.x`,
+                 :attr:`~kivy.input.motionevent.MotionEvent.y`
+                 and :attr:`~kivy.input.motionevent.MotionEvent.pos`
+                 properties.
+multitouch_sim   Specifies whether multitouch is simulated or not. Accessed
+                 via the 'multitouch_sim' property.
+================ ==========================================================
+
+'''
+
+__all__ = ('MouseMotionEventProvider', )
+
+from kivy.base import EventLoop
+from collections import deque
+from kivy.logger import Logger
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+
+# late binding
+Color = Ellipse = None
+
+
+class MouseMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        self.multitouch_sim = False
+        super().__init__(*args, **kwargs)
+
+    def depack(self, args):
+        self.sx, self.sy = args[:2]
+        profile = self.profile
+        if self.is_touch:
+            # don't overwrite previous profile
+            if not profile:
+                profile.extend(('pos', 'button'))
+            if len(args) >= 3:
+                self.button = args[2]
+            if len(args) == 4:
+                self.multitouch_sim = args[3]
+                profile.append('multitouch_sim')
+        else:
+            if not profile:
+                profile.append('pos')
+        super().depack(args)
+
+    #
+    # Create automatically touch on the surface.
+    #
+
+    def update_graphics(self, win, create=False):
+        global Color, Ellipse
+        de = self.ud.get('_drawelement', None)
+        if de is None and create:
+            if Color is None:
+                from kivy.graphics import Color, Ellipse
+            with win.canvas.after:
+                de = (
+                    Color(.8, .2, .2, .7),
+                    Ellipse(size=(20, 20), segments=15))
+            self.ud._drawelement = de
+        if de is not None:
+            self.push()
+
+            # use same logic as WindowBase.on_motion() so we get correct
+            # coordinates when _density != 1
+            w, h = win._get_effective_size()
+
+            self.scale_for_screen(w, h, rotation=win.rotation)
+
+            de[1].pos = self.x - 10, self.y - 10
+            self.pop()
+
+    def clear_graphics(self, win):
+        de = self.ud.pop('_drawelement', None)
+        if de is not None:
+            win.canvas.after.remove(de[0])
+            win.canvas.after.remove(de[1])
+
+
+class MouseMotionEventProvider(MotionEventProvider):
+    __handlers__ = {}
+
+    def __init__(self, device, args):
+        super(MouseMotionEventProvider, self).__init__(device, args)
+        self.waiting_event = deque()
+        self.touches = {}
+        self.counter = 0
+        self.current_drag = None
+        self.alt_touch = None
+        self.disable_on_activity = False
+        self.disable_multitouch = False
+        self.multitouch_on_demand = False
+        self.hover_event = None
+        self._disable_hover = False
+        self._running = False
+        # split arguments
+        args = args.split(',')
+        for arg in args:
+            arg = arg.strip()
+            if arg == '':
+                continue
+            elif arg == 'disable_on_activity':
+                self.disable_on_activity = True
+            elif arg == 'disable_multitouch':
+                self.disable_multitouch = True
+            elif arg == 'disable_hover':
+                self.disable_hover = True
+            elif arg == 'multitouch_on_demand':
+                self.multitouch_on_demand = True
+            else:
+                Logger.error('Mouse: unknown parameter <%s>' % arg)
+
+    def _get_disable_hover(self):
+        return self._disable_hover
+
+    def _set_disable_hover(self, value):
+        if self._disable_hover != value:
+            if self._running:
+                if value:
+                    self._stop_hover_events()
+                else:
+                    self._start_hover_events()
+            self._disable_hover = value
+
+    disable_hover = property(_get_disable_hover, _set_disable_hover)
+    '''Disables dispatching of hover events if set to ``True``.
+
+    Hover events are enabled by default (`disable_hover` is ``False``). See
+    module documentation if you want to enable/disable hover events through
+    config file.
+
+    .. versionadded:: 2.1.0
+    '''
+
+    def start(self):
+        '''Start the mouse provider'''
+        if not EventLoop.window:
+            return
+        fbind = EventLoop.window.fbind
+        fbind('on_mouse_down', self.on_mouse_press)
+        fbind('on_mouse_move', self.on_mouse_motion)
+        fbind('on_mouse_up', self.on_mouse_release)
+        fbind('on_rotate', self.update_touch_graphics)
+        fbind('system_size', self.update_touch_graphics)
+        if not self.disable_hover:
+            self._start_hover_events()
+        self._running = True
+
+    def _start_hover_events(self):
+        fbind = EventLoop.window.fbind
+        fbind('mouse_pos', self.begin_or_update_hover_event)
+        fbind('system_size', self.update_hover_event)
+        fbind('on_cursor_enter', self.begin_hover_event)
+        fbind('on_cursor_leave', self.end_hover_event)
+        fbind('on_close', self.end_hover_event)
+        fbind('on_rotate', self.update_hover_event)
+
+    def stop(self):
+        '''Stop the mouse provider'''
+        if not EventLoop.window:
+            return
+        funbind = EventLoop.window.funbind
+        funbind('on_mouse_down', self.on_mouse_press)
+        funbind('on_mouse_move', self.on_mouse_motion)
+        funbind('on_mouse_up', self.on_mouse_release)
+        funbind('on_rotate', self.update_touch_graphics)
+        funbind('system_size', self.update_touch_graphics)
+        if not self.disable_hover:
+            self._stop_hover_events()
+        self._running = False
+
+    def _stop_hover_events(self):
+        funbind = EventLoop.window.funbind
+        funbind('mouse_pos', self.begin_or_update_hover_event)
+        funbind('system_size', self.update_hover_event)
+        funbind('on_cursor_enter', self.begin_hover_event)
+        funbind('on_cursor_leave', self.end_hover_event)
+        funbind('on_close', self.end_hover_event)
+        funbind('on_rotate', self.update_hover_event)
+
+    def test_activity(self):
+        if not self.disable_on_activity:
+            return False
+        # trying to get if we currently have other touch than us
+        # discard touches generated from kinetic
+        for touch in EventLoop.touches:
+            # discard all kinetic touch
+            if touch.__class__.__name__ == 'KineticMotionEvent':
+                continue
+            # not our instance, stop mouse
+            if touch.__class__ != MouseMotionEvent:
+                return True
+        return False
+
+    def find_touch(self, win, x, y):
+        factor = 10. / win.system_size[0]
+        for touch in self.touches.values():
+            if abs(x - touch.sx) < factor and abs(y - touch.sy) < factor:
+                return touch
+        return None
+
+    def create_event_id(self):
+        self.counter += 1
+        return self.device + str(self.counter)
+
+    def create_touch(self, win, nx, ny, is_double_tap, do_graphics, button):
+        event_id = self.create_event_id()
+        args = [nx, ny, button]
+        if do_graphics:
+            args += [not self.multitouch_on_demand]
+        self.current_drag = touch = MouseMotionEvent(
+            self.device, event_id, args,
+            is_touch=True,
+            type_id='touch'
+        )
+        touch.is_double_tap = is_double_tap
+        self.touches[event_id] = touch
+        if do_graphics:
+            # only draw red circle if multitouch is not disabled, and
+            # if the multitouch_on_demand feature is not enable
+            # (because in that case, we wait to see if multitouch_sim
+            # is True or not before doing the multitouch)
+            create_flag = (
+                not self.disable_multitouch
+                and not self.multitouch_on_demand
+            )
+            touch.update_graphics(win, create_flag)
+        self.waiting_event.append(('begin', touch))
+        return touch
+
+    def remove_touch(self, win, touch):
+        if touch.id in self.touches:
+            del self.touches[touch.id]
+            touch.update_time_end()
+            self.waiting_event.append(('end', touch))
+            touch.clear_graphics(win)
+
+    def create_hover(self, win, etype):
+        nx, ny = win.to_normalized_pos(*win.mouse_pos)
+        # Divide by density because it's used by mouse_pos
+        nx /= win._density
+        ny /= win._density
+        args = (nx, ny)
+        hover = self.hover_event
+        if hover:
+            hover.move(args)
+        else:
+            self.hover_event = hover = MouseMotionEvent(
+                self.device,
+                self.create_event_id(),
+                args,
+                type_id='hover'
+            )
+        if etype == 'end':
+            hover.update_time_end()
+            self.hover_event = None
+        self.waiting_event.append((etype, hover))
+
+    def on_mouse_motion(self, win, x, y, modifiers):
+        nx, ny = win.to_normalized_pos(x, y)
+        ny = 1.0 - ny
+        if self.current_drag:
+            touch = self.current_drag
+            touch.move([nx, ny])
+            touch.update_graphics(win)
+            self.waiting_event.append(('update', touch))
+        elif self.alt_touch is not None and 'alt' not in modifiers:
+            # alt just released ?
+            is_double_tap = 'shift' in modifiers
+            self.create_touch(win, nx, ny, is_double_tap, True, [])
+
+    def on_mouse_press(self, win, x, y, button, modifiers):
+        if self.test_activity():
+            return
+        nx, ny = win.to_normalized_pos(x, y)
+        ny = 1.0 - ny
+        found_touch = self.find_touch(win, nx, ny)
+        if found_touch:
+            self.current_drag = found_touch
+        else:
+            is_double_tap = 'shift' in modifiers
+            do_graphics = (
+                not self.disable_multitouch
+                and (button != 'left' or 'ctrl' in modifiers)
+            )
+            touch = self.create_touch(
+                win, nx, ny, is_double_tap, do_graphics, button
+            )
+            if 'alt' in modifiers:
+                self.alt_touch = touch
+                self.current_drag = None
+
+    def on_mouse_release(self, win, x, y, button, modifiers):
+        if button == 'all':
+            # Special case, if button is all,
+            # then remove all the current touches.
+            for touch in list(self.touches.values()):
+                self.remove_touch(win, touch)
+            self.current_drag = None
+        touch = self.current_drag
+        if touch:
+            not_right = button in (
+                'left',
+                'scrollup', 'scrolldown',
+                'scrollleft', 'scrollright'
+            )
+            not_ctrl = 'ctrl' not in modifiers
+            not_multi = (
+                self.disable_multitouch
+                or 'multitouch_sim' not in touch.profile
+                or not touch.multitouch_sim
+            )
+            if not_right and not_ctrl or not_multi:
+                self.remove_touch(win, touch)
+                self.current_drag = None
+            else:
+                touch.update_graphics(win, True)
+        if self.alt_touch:
+            self.remove_touch(win, self.alt_touch)
+            self.alt_touch = None
+
+    def update_touch_graphics(self, win, *args):
+        for touch in self.touches.values():
+            touch.update_graphics(win)
+
+    def begin_or_update_hover_event(self, win, *args):
+        etype = 'update' if self.hover_event else 'begin'
+        self.create_hover(win, etype)
+
+    def begin_hover_event(self, win, *args):
+        if not self.hover_event:
+            self.create_hover(win, 'begin')
+
+    def update_hover_event(self, win, *args):
+        if self.hover_event:
+            self.create_hover(win, 'update')
+
+    def end_hover_event(self, win, *args):
+        if self.hover_event:
+            self.create_hover(win, 'end')
+
+    def update(self, dispatch_fn):
+        '''Update the mouse provider (pop event from the queue)'''
+        try:
+            while True:
+                event = self.waiting_event.popleft()
+                dispatch_fn(*event)
+        except IndexError:
+            pass
+
+
+# registers
+MotionEventFactory.register('mouse', MouseMotionEventProvider)