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

kivy/modules/joycursor.py

@@ -0,0 +1,299 @@
+'''
+JoyCursor
+=========
+
+.. versionadded:: 1.10.0
+
+The JoyCursor is a tool for navigating with a joystick as if using a mouse
+or touch. Most of the actions that are possible for a mouse user are available
+in this module.
+
+For example:
+
+    * left click
+    * right click
+    * double click (two clicks)
+    * moving the cursor
+    * holding the button (+ moving at the same time)
+    * selecting
+    * scrolling
+
+There are some properties that can be edited live, such as intensity of the
+JoyCursor movement and toggling mouse button holding.
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation
+and these bindings:
+
++------------------+--------------------+
+| Event            | Joystick           |
++==================+====================+
+| cursor move      | Axis 3, Axis 4     |
++------------------+--------------------+
+| cursor intensity | Button 0, Button 1 |
++------------------+--------------------+
+| left click       | Button 2           |
++------------------+--------------------+
+| right click      | Button 3           |
++------------------+--------------------+
+| scroll up        | Button 4           |
++------------------+--------------------+
+| scroll down      | Button 5           |
++------------------+--------------------+
+| hold button      | Button 6           |
++------------------+--------------------+
+| joycursor on/off | Button 7           |
++------------------+--------------------+
+
+The JoyCursor, like Inspector, can also be imported and used as a normal
+python module. This has the added advantage of being able to activate and
+deactivate the module programmatically::
+
+    from kivy.lang import Builder
+    from kivy.base import runTouchApp
+    runTouchApp(Builder.load_string("""
+    #:import jc kivy.modules.joycursor
+    BoxLayout:
+        Button:
+            text: 'Press & activate with Ctrl+E or Button 7'
+            on_release: jc.create_joycursor(root.parent, root)
+        Button:
+            text: 'Disable'
+            on_release: jc.stop(root.parent, root)
+    """))
+'''
+
+__all__ = ('start', 'stop', 'create_joycursor')
+
+from kivy.clock import Clock
+from kivy.logger import Logger
+from kivy.uix.widget import Widget
+from kivy.graphics import Color, Line
+from kivy.properties import (
+    ObjectProperty,
+    NumericProperty,
+    BooleanProperty
+)
+
+
+class JoyCursor(Widget):
+    win = ObjectProperty()
+    activated = BooleanProperty(False)
+    cursor_width = NumericProperty(1.1)
+    cursor_hold = BooleanProperty(False)
+    intensity = NumericProperty(4)
+    dead_zone = NumericProperty(10000)
+    offset_x = NumericProperty(0)
+    offset_y = NumericProperty(0)
+
+    def __init__(self, **kwargs):
+        super(JoyCursor, self).__init__(**kwargs)
+        self.avoid_bring_to_top = False
+        self.size_hint = (None, None)
+        self.size = (21, 21)
+        self.set_cursor()
+
+        # draw cursor
+        with self.canvas:
+            Color(rgba=(0.19, 0.64, 0.81, 0.5))
+            self.cursor_ox = Line(
+                points=self.cursor_pts[:4],
+                width=self.cursor_width + 0.1
+            )
+            self.cursor_oy = Line(
+                points=self.cursor_pts[4:],
+                width=self.cursor_width + 0.1
+            )
+            Color(rgba=(1, 1, 1, 0.5))
+            self.cursor_x = Line(
+                points=self.cursor_pts[:4],
+                width=self.cursor_width
+            )
+            self.cursor_y = Line(
+                points=self.cursor_pts[4:],
+                width=self.cursor_width
+            )
+        self.pos = [-i for i in self.size]
+
+    def on_window_children(self, win, *args):
+        # pull JoyCursor to the front when added
+        # as a child directly to the window.
+        if self.avoid_bring_to_top or not self.activated:
+            return
+        self.avoid_bring_to_top = True
+        win.remove_widget(self)
+        win.add_widget(self)
+        self.avoid_bring_to_top = False
+
+    def on_activated(self, instance, activated):
+        # bind/unbind when JoyCursor's state is changed
+        if activated:
+            self.win.add_widget(self)
+            self.move = Clock.schedule_interval(self.move_cursor, 0)
+            self.win.fbind('on_joy_axis', self.check_cursor)
+            self.win.fbind('on_joy_button_down', self.set_intensity)
+            self.win.fbind('on_joy_button_down', self.check_dispatch)
+            self.win.fbind('mouse_pos', self.stop_cursor)
+            mouse_pos = self.win.mouse_pos
+            self.pos = (
+                mouse_pos[0] - self.size[0] / 2.0,
+                mouse_pos[1] - self.size[1] / 2.0
+            )
+            Logger.info('JoyCursor: joycursor activated')
+        else:
+            self.pos = [-i for i in self.size]
+            Clock.unschedule(self.move)
+            self.win.funbind('on_joy_axis', self.check_cursor)
+            self.win.funbind('on_joy_button_down', self.set_intensity)
+            self.win.funbind('on_joy_button_down', self.check_dispatch)
+            self.win.funbind('mouse_pos', self.stop_cursor)
+            self.win.remove_widget(self)
+            Logger.info('JoyCursor: joycursor deactivated')
+
+    def set_cursor(self, *args):
+        # create cursor points
+        px, py = self.pos
+        sx, sy = self.size
+        self.cursor_pts = [
+            px, py + round(sy / 2.0), px + sx, py + round(sy / 2.0),
+            px + round(sx / 2.0), py, px + round(sx / 2.0), py + sy
+        ]
+
+    def check_cursor(self, win, stickid, axisid, value):
+        # check axes and set offset if a movement is registered
+        intensity = self.intensity
+        dead = self.dead_zone
+
+        if axisid == 3:
+            if value < -dead:
+                self.offset_x = -intensity
+            elif value > dead:
+                self.offset_x = intensity
+            else:
+                self.offset_x = 0
+        elif axisid == 4:
+            # invert Y axis to behave like mouse
+            if value < -dead:
+                self.offset_y = intensity
+            elif value > dead:
+                self.offset_y = -intensity
+            else:
+                self.offset_y = 0
+        else:
+            self.offset_x = 0
+            self.offset_y = 0
+
+    def set_intensity(self, win, stickid, buttonid):
+        # set intensity of joycursor with joystick buttons
+        intensity = self.intensity
+        if buttonid == 0 and intensity > 2:
+            intensity -= 1
+        elif buttonid == 1:
+            intensity += 1
+        self.intensity = intensity
+
+    def check_dispatch(self, win, stickid, buttonid):
+        if buttonid == 6:
+            self.cursor_hold = not self.cursor_hold
+        if buttonid not in (2, 3, 4, 5, 6):
+            return
+
+        x, y = self.center
+        # window event, correction necessary
+        y = self.win.system_size[1] - y
+        modifiers = []
+        actions = {
+            2: 'left',
+            3: 'right',
+            4: 'scrollup',
+            5: 'scrolldown',
+            6: 'left'
+        }
+        button = actions[buttonid]
+
+        self.win.dispatch('on_mouse_down', x, y, button, modifiers)
+        if not self.cursor_hold:
+            self.win.dispatch('on_mouse_up', x, y, button, modifiers)
+
+    def move_cursor(self, *args):
+        # move joycursor as a mouse
+        self.pos[0] += self.offset_x
+        self.pos[1] += self.offset_y
+        modifiers = []
+        if self.cursor_hold:
+            self.win.dispatch(
+                'on_mouse_move',
+                self.center[0],
+                self.win.system_size[1] - self.center[1],
+                modifiers
+            )
+
+    def stop_cursor(self, instance, mouse_pos):
+        # pin the cursor to the mouse pos
+        self.offset_x = 0
+        self.offset_y = 0
+        self.pos = (
+            mouse_pos[0] - self.size[0] / 2.0,
+            mouse_pos[1] - self.size[1] / 2.0
+        )
+
+    def on_pos(self, instance, new_pos):
+        self.set_cursor()
+        self.cursor_x.points = self.cursor_pts[:4]
+        self.cursor_y.points = self.cursor_pts[4:]
+        self.cursor_ox.points = self.cursor_pts[:4]
+        self.cursor_oy.points = self.cursor_pts[4:]
+
+    def keyboard_shortcuts(self, win, scancode, *args):
+        modifiers = args[-1]
+        if scancode == 101 and modifiers == ['ctrl']:
+            self.activated = not self.activated
+            return True
+        elif scancode == 27:
+            if self.activated:
+                self.activated = False
+                return True
+
+    def joystick_shortcuts(self, win, stickid, buttonid):
+        if buttonid == 7:
+            self.activated = not self.activated
+            if self.activated:
+                self.pos = [round(i / 2.0) for i in win.size]
+
+
+def create_joycursor(win, ctx, *args):
+    '''Create a JoyCursor instance attached to the *ctx* and bound to the
+    Window's :meth:`~kivy.core.window.WindowBase.on_keyboard` event for
+    capturing the keyboard shortcuts.
+
+        :Parameters:
+            `win`: A :class:`Window <kivy.core.window.WindowBase>`
+                The application Window to bind to.
+            `ctx`: A :class:`~kivy.uix.widget.Widget` or subclass
+                The Widget for JoyCursor to attach to.
+
+    '''
+    ctx.joycursor = JoyCursor(win=win)
+    win.bind(children=ctx.joycursor.on_window_children,
+             on_keyboard=ctx.joycursor.keyboard_shortcuts)
+    # always listen for joystick input to open the module
+    # (like a keyboard listener)
+    win.fbind('on_joy_button_down', ctx.joycursor.joystick_shortcuts)
+
+
+def start(win, ctx):
+    Clock.schedule_once(lambda *t: create_joycursor(win, ctx))
+
+
+def stop(win, ctx):
+    '''Stop and unload any active JoyCursors for the given *ctx*.
+    '''
+    if hasattr(ctx, 'joycursor'):
+        ctx.joycursor.activated = False
+        win.unbind(children=ctx.joycursor.on_window_children,
+                   on_keyboard=ctx.joycursor.keyboard_shortcuts)
+        win.funbind('on_joy_button_down', ctx.joycursor.joystick_shortcuts)
+        win.remove_widget(ctx.joycursor)
+        del ctx.joycursor

kivy/modules/keybinding.py

@@ -0,0 +1,64 @@
+'''Keybinding
+==========
+
+This module forces the mapping of some keys to functions:
+
+* F11: Rotate the Window through 0, 90, 180 and 270 degrees
+* Shift + F11: Switches between portrait and landscape on desktops
+* F12: Take a screenshot
+
+Note: this doesn't work if the application requests the keyboard beforehand.
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation.
+
+The Keybinding module, however, can also be imported and used just
+like a normal python module. This has the added advantage of being
+able to activate and deactivate the module programmatically::
+
+    from kivy.app import App
+    from kivy.uix.button import Button
+    from kivy.modules import keybinding
+    from kivy.core.window import Window
+
+    class Demo(App):
+
+        def build(self):
+            button = Button(text="Hello")
+            keybinding.start(Window, button)
+            return button
+
+    Demo().run()
+
+To remove the Keybinding, you can do the following::
+
+    Keybinding.stop(Window, button)
+
+'''
+
+from kivy.utils import platform
+
+__all__ = ('start', 'stop')
+
+
+def _on_keyboard_handler(instance, key, scancode, codepoint, modifiers):
+    if key == 293 and modifiers == []:  # F12
+        instance.screenshot()
+    elif key == 292 and modifiers == []:  # F11
+        instance.rotation += 90
+    elif key == 292 and modifiers == ['shift']:  # Shift + F11
+        if platform in ('win', 'linux', 'macosx'):
+            instance.rotation = 0
+            w, h = instance.size
+            w, h = h, w
+            instance.size = (w, h)
+
+
+def start(win, ctx):
+    win.bind(on_keyboard=_on_keyboard_handler)
+
+
+def stop(win, ctx):
+    win.unbind(on_keyboard=_on_keyboard_handler)

kivy/modules/monitor.py

@@ -0,0 +1,90 @@
+'''
+Monitor module
+==============
+
+The Monitor module is a toolbar that shows the activity of your current
+application :
+
+* FPS
+* Graph of input events
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation.
+
+'''
+
+__all__ = ('start', 'stop')
+
+from kivy.uix.label import Label
+from kivy.graphics import Rectangle, Color
+from kivy.metrics import dp
+from kivy.clock import Clock
+from functools import partial
+
+_statsinput = 0
+_maxinput = -1
+
+
+def update_fps(ctx, *largs):
+    ctx.label.text = 'FPS: %f' % Clock.get_fps()
+    ctx.rectangle.texture = ctx.label.texture
+    ctx.rectangle.size = ctx.label.texture_size
+
+
+def update_stats(win, ctx, *largs):
+    global _statsinput
+    ctx.stats = ctx.stats[1:] + [_statsinput]
+    _statsinput = 0
+    m = max(1., _maxinput)
+    for i, x in enumerate(ctx.stats):
+        ctx.statsr[i].size = (dp(4), ctx.stats[i] / m * dp(20))
+        ctx.statsr[i].pos = (
+            win.width - dp(64 * 4) + i * dp(4), win.height - dp(25))
+
+
+def _update_monitor_canvas(win, ctx, *largs):
+    with win.canvas.after:
+        ctx.overlay.pos = (0, win.height - dp(25))
+        ctx.overlay.size = (win.width, dp(25))
+        ctx.rectangle.pos = (dp(5), win.height - dp(20))
+
+
+class StatsInput(object):
+    def process(self, events):
+        global _statsinput, _maxinput
+        _statsinput += len(events)
+        if _statsinput > _maxinput:
+            _maxinput = float(_statsinput)
+        return events
+
+
+def start(win, ctx):
+    # late import to avoid breaking module loading
+    from kivy.input.postproc import kivy_postproc_modules
+    kivy_postproc_modules['fps'] = StatsInput()
+    global _ctx
+    ctx.label = Label(text='FPS: 0.0')
+    ctx.inputstats = 0
+    ctx.stats = []
+    ctx.statsr = []
+    with win.canvas.after:
+        ctx.color = Color(1, 0, 0, .5)
+        ctx.overlay = Rectangle(pos=(0, win.height - dp(25)),
+                                size=(win.width, dp(25)))
+        ctx.color = Color(1, 1, 1)
+        ctx.rectangle = Rectangle(pos=(dp(5), win.height - dp(20)))
+        ctx.color = Color(1, 1, 1, .5)
+        for i in range(64):
+            ctx.stats.append(0)
+            ctx.statsr.append(Rectangle(
+                pos=(win.width - dp(64 * 4) + i * dp(4), win.height - dp(25)),
+                size=(dp(4), 0)))
+    win.bind(size=partial(_update_monitor_canvas, win, ctx))
+    Clock.schedule_interval(partial(update_fps, ctx), .5)
+    Clock.schedule_interval(partial(update_stats, win, ctx), 1 / 60.)
+
+
+def stop(win, ctx):
+    win.canvas.remove(ctx.label)

kivy/modules/recorder.py

@@ -0,0 +1,94 @@
+'''
+Recorder module
+===============
+
+.. versionadded:: 1.1.0
+
+Create an instance of :class:`~kivy.input.recorder.Recorder`, attach to the
+class, and bind some keys to record / play sequences:
+
+    - F6: play the last record in a loop
+    - F7: read the latest recording
+    - F8: record input events
+
+Configuration
+-------------
+
+.. |attrs| replace:: :attr:`~kivy.input.recorder.Recorder.record_attrs`
+.. |profile_mask| replace::
+    :attr:`~kivy.input.recorder.Recorder.record_profile_mask`
+
+:Parameters:
+    `attrs`: str, defaults to |attrs| value.
+        Attributes to record from the motion event
+    `profile_mask`: str, defaults to |profile_mask| value.
+        Mask for motion event profile. Used to filter which profile will appear
+        in the fake motion event when replayed.
+    `filename`: str, defaults to 'recorder.kvi'
+        Name of the file to record / play with
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation.
+
+'''
+
+__all__ = ('start', 'stop')
+
+from kivy.logger import Logger
+from functools import partial
+
+
+def replay(recorder, *args):
+    if recorder.play:
+        return
+    else:
+        recorder.play = True
+
+
+def on_recorder_key(recorder, window, key, *largs):
+    if key == 289:  # F8
+        if recorder.play:
+            Logger.error('Recorder: Cannot start recording while playing.')
+            return
+        recorder.record = not recorder.record
+    elif key == 288:  # F7
+        if recorder.record:
+            Logger.error('Recorder: Cannot start playing while recording.')
+            return
+        recorder.play = not recorder.play
+    elif key == 287:  # F6
+        if recorder.play:
+            recorder.unbind(play=replay)
+        else:
+            recorder.bind(play=replay)
+            recorder.play = True
+
+
+def start(win, ctx):
+    keys = {}
+
+    # attributes
+    value = ctx.config.get('attrs', None)
+    if value is not None:
+        keys['record_attrs'] = value.split(':')
+
+    # profile mask
+    value = ctx.config.get('profile_mask', None)
+    if value is not None:
+        keys['record_profile_mask'] = value.split(':')
+
+    # filename
+    value = ctx.config.get('filename', None)
+    if value is not None:
+        keys['filename'] = value
+
+    from kivy.input.recorder import Recorder
+    ctx.recorder = Recorder(window=win, **keys)
+    win.bind(on_key_down=partial(on_recorder_key, ctx.recorder))
+
+
+def stop(win, ctx):
+    if hasattr(ctx, 'recorder'):
+        ctx.recorder.release()