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

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/audio/audio.kv

@@ -0,0 +1,59 @@
+#:kivy 1.0
+#:import kivy kivy
+
+<AudioBackground>:
+    orientation: 'vertical'
+    canvas:
+        Color:
+            rgb: 1, 1, 1
+        Rectangle:
+            source: 'data/images/background.jpg'
+            size: self.size
+
+    BoxLayout:
+        padding: 10
+        spacing: 10
+        size_hint: 1, None
+        pos_hint: {'top': 1}
+        height: 44
+        Image:
+            size_hint: None, None
+            size: 24, 24
+            source: 'data/logo/kivy-icon-24.png'
+        Label:
+            height: 24
+            text_size: self.size
+            color: (1, 1, 1, .8)
+            text: 'Kivy %s - Audio sample' % kivy.__version__
+            valign: 'middle'
+
+    Label:
+        text: 'Audio example'
+        font_size: 32
+        size_hint_y: None
+
+    BoxLayout:
+        Slider:
+            min: 0.0
+            max: 1.0
+            value: 1.0
+            on_value: app.set_volume(self.value)
+            orientation: "vertical"
+            size_hint_x: None
+            width: "48dp"
+
+        StackLayout:
+            id: sl
+
+    Button:
+        text: 'Stop and release all audio'
+        size_hint_y: None
+        height: '50sp'
+        on_press: app.release_audio()
+
+<AudioButton>:
+    size_hint: None,0.333
+    width: self.height
+    text_size: self.size
+    font_size: '12sp'
+    valign: 'middle'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/audio/main.py

@@ -0,0 +1,81 @@
+'''
+Audio example
+=============
+
+This example plays sounds of different formats. You should see a grid of
+buttons labelled with filenames. Clicking on the buttons will play, or
+restart, each sound. Not all sound formats will play on all platforms.
+
+All the sounds are from the http://woolyss.com/chipmusic-samples.php
+"THE FREESOUND PROJECT", Under Creative Commons Sampling Plus 1.0 License.
+
+'''
+
+import kivy
+kivy.require('1.0.8')
+
+from kivy.app import App
+from kivy.uix.button import Button
+from kivy.uix.boxlayout import BoxLayout
+from kivy.core.audio import SoundLoader
+from kivy.properties import StringProperty, ObjectProperty, NumericProperty
+from glob import glob
+from os.path import dirname, join, basename
+
+
+class AudioButton(Button):
+
+    filename = StringProperty(None)
+    sound = ObjectProperty(None, allownone=True)
+    volume = NumericProperty(1.0)
+
+    def on_press(self):
+        if self.sound is None:
+            self.sound = SoundLoader.load(self.filename)
+        # stop the sound if it's currently playing
+        if self.sound.state != 'stop':
+            self.sound.stop()
+        self.sound.volume = self.volume
+        self.sound.play()
+
+    def release_audio(self):
+        if self.sound:
+            self.sound.stop()
+            self.sound.unload()
+            self.sound = None
+
+    def set_volume(self, volume):
+        self.volume = volume
+        if self.sound:
+            self.sound.volume = volume
+
+
+class AudioBackground(BoxLayout):
+    pass
+
+
+class AudioApp(App):
+
+    def build(self):
+
+        root = AudioBackground(spacing=5)
+        for fn in glob(join(dirname(__file__), '*.wav')):
+            btn = AudioButton(
+                text=basename(fn[:-4]).replace('_', ' '), filename=fn,
+                size_hint=(None, None), halign='center',
+                size=(128, 128), text_size=(118, None))
+            root.ids.sl.add_widget(btn)
+
+        return root
+
+    def release_audio(self):
+        for audiobutton in self.root.ids.sl.children:
+            audiobutton.release_audio()
+
+    def set_volume(self, value):
+        for audiobutton in self.root.ids.sl.children:
+            audiobutton.set_volume(value)
+
+
+if __name__ == '__main__':
+    AudioApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/audio/pitch.py

@@ -0,0 +1,42 @@
+# encoding: utf8
+
+from kivy.app import App
+from kivy.core.audio import SoundLoader
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.button import Button
+
+from sys import version_info
+
+
+NOTES = (
+    ('Do', 1),
+    ('Ré', 9 / 8.),
+    ('Mi', 5 / 4.),
+    ('Fa', 4 / 3.),
+    ('Sol', 3 / 2.),
+    ('La', 5 / 3.),
+    ('Si', 15 / 8.),
+)
+
+
+class Test(App):
+    def build(self):
+        self.sound = SoundLoader.load(
+            '/usr/lib64/python{}.{}/test/audiodata/pluck-pcm32.wav'
+            .format(*version_info[0:2])
+        )
+        root = BoxLayout()
+        for octave in range(-2, 3):
+            for note, pitch in NOTES:
+                button = Button(text=note)
+                button.pitch = pitch * 2 ** octave
+                button.bind(on_release=self.play_note)
+                root.add_widget(button)
+        return root
+
+    def play_note(self, button):
+        self.sound.pitch = button.pitch
+        self.sound.play()
+
+
+Test().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/camera/main.py

@@ -0,0 +1,59 @@
+'''
+Camera Example
+==============
+
+This example demonstrates a simple use of the camera. It shows a window with
+a buttoned labelled 'play' to turn the camera on and off. Note that
+not finding a camera, perhaps because gstreamer is not installed, will
+throw an exception during the kv language processing.
+
+'''
+
+# Uncomment these lines to see all the messages
+# from kivy.logger import Logger
+# import logging
+# Logger.setLevel(logging.TRACE)
+
+from kivy.app import App
+from kivy.lang import Builder
+from kivy.uix.boxlayout import BoxLayout
+import time
+Builder.load_string('''
+<CameraClick>:
+    orientation: 'vertical'
+    Camera:
+        id: camera
+        resolution: (640, 480)
+        play: False
+    ToggleButton:
+        text: 'Play'
+        on_press: camera.play = not camera.play
+        size_hint_y: None
+        height: '48dp'
+    Button:
+        text: 'Capture'
+        size_hint_y: None
+        height: '48dp'
+        on_press: root.capture()
+''')
+
+
+class CameraClick(BoxLayout):
+    def capture(self):
+        '''
+        Function to capture the images and give them the names
+        according to their captured time and date.
+        '''
+        camera = self.ids['camera']
+        timestr = time.strftime("%Y%m%d_%H%M%S")
+        camera.export_to_png("IMG_{}.png".format(timestr))
+        print("Captured")
+
+
+class TestCamera(App):
+
+    def build(self):
+        return CameraClick()
+
+
+TestCamera().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/canvas/bezier.py

@@ -0,0 +1,105 @@
+'''
+Bezier Example
+==============
+
+This example shows a closed Bezier curve computed from a polygon. You
+should see a purple polygon, a red bezier curve computed from the polygon,
+and two sliders. You can drag points on the polygon to recompute the curve.
+The two sliders control the dash length of the dashed lines making up the two
+shapes.
+
+'''
+from kivy.app import App
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.slider import Slider
+from kivy.graphics import Color, Bezier, Line
+
+
+class BezierTest(FloatLayout):
+
+    def __init__(self, points=[], loop=False, *args, **kwargs):
+        super(BezierTest, self).__init__(*args, **kwargs)
+        self.d = 10  # pixel tolerance when clicking on a point
+        self.points = points
+        self.loop = loop
+        self.current_point = None  # index of point being dragged
+
+        with self.canvas:
+            Color(1.0, 0.0, 0.0)
+
+            self.bezier = Bezier(
+                    points=self.points,
+                    segments=150,
+                    loop=self.loop,
+                    dash_length=100,
+                    dash_offset=10)
+
+            Color(1.0, 0.0, 1.0)
+            self.line = Line(
+                    points=self.points + self.points[:2],
+                    dash_offset=10,
+                    dash_length=100)
+
+        s = Slider(y=0, pos_hint={'x': .3}, size_hint=(.7, None), height=50)
+        s.bind(value=self._set_bezier_dash_offset)
+        self.add_widget(s)
+
+        s = Slider(y=50, pos_hint={'x': .3}, size_hint=(.7, None), height=50)
+        s.bind(value=self._set_line_dash_offset)
+        self.add_widget(s)
+
+    def _set_bezier_dash_offset(self, instance, value):
+        # effect to reduce length while increase offset
+        self.bezier.dash_length = 100 - value
+        self.bezier.dash_offset = value
+
+    def _set_line_dash_offset(self, instance, value):
+        # effect to reduce length while increase offset
+        self.line.dash_length = 100 - value
+        self.line.dash_offset = value
+
+    def on_touch_down(self, touch):
+        if self.collide_point(touch.pos[0], touch.pos[1]):
+            for i, p in enumerate(list(zip(self.points[::2],
+                                           self.points[1::2]))):
+                if (abs(touch.pos[0] - self.pos[0] - p[0]) < self.d and
+                        abs(touch.pos[1] - self.pos[1] - p[1]) < self.d):
+                    self.current_point = i + 1
+                    return True
+            return super(BezierTest, self).on_touch_down(touch)
+
+    def on_touch_up(self, touch):
+        if self.collide_point(touch.pos[0], touch.pos[1]):
+            if self.current_point:
+                self.current_point = None
+                return True
+            return super(BezierTest, self).on_touch_up(touch)
+
+    def on_touch_move(self, touch):
+        if self.collide_point(touch.pos[0], touch.pos[1]):
+            c = self.current_point
+            if c:
+                self.points[(c - 1) * 2] = touch.pos[0] - self.pos[0]
+                self.points[(c - 1) * 2 + 1] = touch.pos[1] - self.pos[1]
+                self.bezier.points = self.points
+                self.line.points = self.points + self.points[:2]
+                return True
+            return super(BezierTest, self).on_touch_move(touch)
+
+
+class Main(App):
+
+    def build(self):
+        from math import cos, sin, radians
+        x = y = 150
+        z = 100
+        # Pacman !
+        points = [x, y]
+        for i in range(45, 360, 45):
+            i = radians(i)
+            points.extend([x + cos(i) * z, y + sin(i) * z])
+        return BezierTest(points=points, loop=True)
+
+
+if __name__ == '__main__':
+    Main().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/canvas/canvas_stress.py

@@ -0,0 +1,72 @@
+'''
+Canvas stress
+=============
+
+This example tests the performance of our Graphics engine by drawing large
+numbers of small squares. You should see a black canvas with buttons and a
+label at the bottom. Pressing the buttons adds small colored squares to the
+canvas.
+
+'''
+
+from kivy.uix.button import Button
+from kivy.uix.widget import Widget
+from kivy.uix.label import Label
+from kivy.uix.boxlayout import BoxLayout
+from kivy.app import App
+from kivy.graphics import Color, Rectangle
+from random import random as r
+from functools import partial
+
+
+class StressCanvasApp(App):
+
+    def add_rects(self, label, wid, count, *largs):
+        label.text = str(int(label.text) + count)
+        with wid.canvas:
+            for x in range(count):
+                Color(r(), 1, 1, mode='hsv')
+                Rectangle(pos=(r() * wid.width + wid.x,
+                               r() * wid.height + wid.y), size=(20, 20))
+
+    def double_rects(self, label, wid, *largs):
+        count = int(label.text)
+        self.add_rects(label, wid, count, *largs)
+
+    def reset_rects(self, label, wid, *largs):
+        label.text = '0'
+        wid.canvas.clear()
+
+    def build(self):
+        wid = Widget()
+
+        label = Label(text='0')
+
+        btn_add100 = Button(text='+ 100 rects',
+                            on_press=partial(self.add_rects, label, wid, 100))
+
+        btn_add500 = Button(text='+ 500 rects',
+                            on_press=partial(self.add_rects, label, wid, 500))
+
+        btn_double = Button(text='x 2',
+                            on_press=partial(self.double_rects, label, wid))
+
+        btn_reset = Button(text='Reset',
+                           on_press=partial(self.reset_rects, label, wid))
+
+        layout = BoxLayout(size_hint=(1, None), height=50)
+        layout.add_widget(btn_add100)
+        layout.add_widget(btn_add500)
+        layout.add_widget(btn_double)
+        layout.add_widget(btn_reset)
+        layout.add_widget(label)
+
+        root = BoxLayout(orientation='vertical')
+        root.add_widget(wid)
+        root.add_widget(layout)
+
+        return root
+
+
+if __name__ == '__main__':
+    StressCanvasApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/canvas/circle.py

@@ -0,0 +1,84 @@
+'''
+Circle Example
+==============
+
+This example exercises circle (ellipse) drawing. You should see sliders at the
+top of the screen with the Kivy logo below it. The sliders control the
+angle start and stop and the height and width scales. There is a button
+to reset the sliders. The logo used for the circle's background image is
+from the kivy/data directory. The entire example is coded in the
+kv language description.
+'''
+
+from kivy.app import App
+from kivy.lang import Builder
+
+kv = '''
+BoxLayout:
+    orientation: 'vertical'
+    BoxLayout:
+        size_hint_y: None
+        height: sp(100)
+        BoxLayout:
+            orientation: 'vertical'
+            Slider:
+                id: e1
+                min: -360.
+                max: 360.
+            Label:
+                text: 'angle_start = {}'.format(e1.value)
+        BoxLayout:
+            orientation: 'vertical'
+            Slider:
+                id: e2
+                min: -360.
+                max: 360.
+                value: 360
+            Label:
+                text: 'angle_end = {}'.format(e2.value)
+
+    BoxLayout:
+        size_hint_y: None
+        height: sp(100)
+        BoxLayout:
+            orientation: 'vertical'
+            Slider:
+                id: wm
+                min: 0
+                max: 2
+                value: 1
+            Label:
+                text: 'Width mult. = {}'.format(wm.value)
+        BoxLayout:
+            orientation: 'vertical'
+            Slider:
+                id: hm
+                min: 0
+                max: 2
+                value: 1
+            Label:
+                text: 'Height mult. = {}'.format(hm.value)
+        Button:
+            text: 'Reset ratios'
+            on_press: wm.value = 1; hm.value = 1
+
+    FloatLayout:
+        canvas:
+            Color:
+                rgb: 1, 1, 1
+            Ellipse:
+                pos: 100, 100
+                size: 200 * wm.value, 201 * hm.value
+                source: 'data/logo/kivy-icon-512.png'
+                angle_start: e1.value
+                angle_end: e2.value
+
+'''
+
+
+class CircleApp(App):
+    def build(self):
+        return Builder.load_string(kv)
+
+
+CircleApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/canvas/fbo_canvas.py

@@ -0,0 +1,91 @@
+'''
+FBO Canvas
+==========
+
+This demonstrates a layout using an FBO (Frame Buffer Off-screen)
+instead of a plain canvas. You should see a black canvas with a
+button labelled 'FBO' in the bottom left corner. Clicking it
+animates the button moving right to left.
+'''
+
+__all__ = ('FboFloatLayout', )
+
+from kivy.graphics import Color, Rectangle, Canvas, ClearBuffers, ClearColor
+from kivy.graphics.fbo import Fbo
+from kivy.uix.floatlayout import FloatLayout
+from kivy.properties import ObjectProperty, NumericProperty
+from kivy.app import App
+from kivy.core.window import Window
+from kivy.animation import Animation
+from kivy.factory import Factory
+
+
+class FboFloatLayout(FloatLayout):
+
+    texture = ObjectProperty(None, allownone=True)
+
+    alpha = NumericProperty(1)
+
+    def __init__(self, **kwargs):
+        self.canvas = Canvas()
+        with self.canvas:
+            self.fbo = Fbo(size=self.size)
+            self.fbo_color = Color(1, 1, 1, 1)
+            self.fbo_rect = Rectangle()
+
+        with self.fbo:
+            ClearColor(0, 0, 0, 0)
+            ClearBuffers()
+
+        # wait that all the instructions are in the canvas to set texture
+        self.texture = self.fbo.texture
+        super(FboFloatLayout, self).__init__(**kwargs)
+
+    def add_widget(self, *args, **kwargs):
+        # trick to attach graphics instruction to fbo instead of canvas
+        canvas = self.canvas
+        self.canvas = self.fbo
+        ret = super(FboFloatLayout, self).add_widget(*args, **kwargs)
+        self.canvas = canvas
+        return ret
+
+    def remove_widget(self, *args, **kwargs):
+        canvas = self.canvas
+        self.canvas = self.fbo
+        super(FboFloatLayout, self).remove_widget(*args, **kwargs)
+        self.canvas = canvas
+
+    def on_size(self, instance, value):
+        self.fbo.size = value
+        self.texture = self.fbo.texture
+        self.fbo_rect.size = value
+
+    def on_pos(self, instance, value):
+        self.fbo_rect.pos = value
+
+    def on_texture(self, instance, value):
+        self.fbo_rect.texture = value
+
+    def on_alpha(self, instance, value):
+        self.fbo_color.rgba = (1, 1, 1, value)
+
+
+class ScreenLayerApp(App):
+    def build(self):
+
+        f = FboFloatLayout()
+        b = Factory.Button(text="FBO", size_hint=(None, None))
+        f.add_widget(b)
+
+        def anim_btn(*args):
+            if b.pos[0] == 0:
+                Animation(x=f.width - b.width).start(b)
+            else:
+                Animation(x=0).start(b)
+        b.bind(on_press=anim_btn)
+
+        return f
+
+
+if __name__ == "__main__":
+    ScreenLayerApp().run()