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

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/customcollide.py

@@ -0,0 +1,82 @@
+'''
+Custom shape & collide widget
+=============================
+
+This is a Triangle widget with a triangle shape based on 3 points (p1, p2, p3),
+plus a custom collision function.
+
+The p1, p2, p3 are automatically calculated from the position and the size of
+the Widget bounding box. We are using them to draw the triangle shape.
+(Please note in the kv the special case for Scatter.)
+
+Then we need to setup a new collision function to collide only on the triangle.
+We are using a external method that will check if a point is inside a polygon
+(we consider our triangle as a polygon).
+'''
+
+
+import kivy
+kivy.require('1.0.8')
+
+from kivy.uix.scatter import Scatter
+from kivy.properties import ListProperty
+from kivy.lang import Builder
+
+
+Builder.load_string('''
+<Triangle>:
+    # example for doing a triangle
+    # this will automatically recalculate pX from pos/size
+    p1: 0, 0
+    p2: self.width, 0
+    p3: self.width / 2, self.height
+
+    # If you use a Widget instead of Scatter as base class, you need that:
+    #p1: self.pos
+    #p2: self.right, self.y
+    #p3: self.center_x, self.top
+
+    # draw something
+    canvas:
+        Color:
+            rgb: 1, 0, 0
+        Triangle:
+            points: self.p1 + self.p2 + self.p3
+''')
+
+
+def point_inside_polygon(x, y, poly):
+    '''Taken from http://www.ariel.com.au/a/python-point-int-poly.html
+    '''
+    n = len(poly)
+    inside = False
+    p1x = poly[0]
+    p1y = poly[1]
+    for i in range(0, n + 2, 2):
+        p2x = poly[i % n]
+        p2y = poly[(i + 1) % n]
+        if y > min(p1y, p2y):
+            if y <= max(p1y, p2y):
+                if x <= max(p1x, p2x):
+                    if p1y != p2y:
+                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= xinters:
+                        inside = not inside
+        p1x, p1y = p2x, p2y
+    return inside
+
+
+class Triangle(Scatter):
+    p1 = ListProperty([0, 0])
+    p2 = ListProperty([0, 0])
+    p3 = ListProperty([0, 0])
+
+    def collide_point(self, x, y):
+        x, y = self.to_local(x, y)
+        return point_inside_polygon(x, y,
+                self.p1 + self.p2 + self.p3)
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    runTouchApp(Triangle(size_hint=(None, None)))

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/effectwidget.py

@@ -0,0 +1,193 @@
+'''
+Example usage of the effectwidget.
+
+Currently highly experimental.
+'''
+
+from kivy.app import App
+from kivy.uix.effectwidget import EffectWidget
+from kivy.uix.spinner import Spinner
+from kivy.uix.boxlayout import BoxLayout
+from kivy.lang import Builder
+from kivy.properties import ObjectProperty
+
+from kivy.uix.effectwidget import (MonochromeEffect,
+                                   InvertEffect,
+                                   ChannelMixEffect,
+                                   ScanlinesEffect,
+                                   FXAAEffect,
+                                   PixelateEffect,
+                                   HorizontalBlurEffect,
+                                   VerticalBlurEffect)
+
+
+class ComparisonWidget(EffectWidget):
+    pass
+
+
+class EffectSpinner(Spinner):
+    pass
+
+
+class SpinnerRow(BoxLayout):
+    effectwidget = ObjectProperty()
+
+    def update_effectwidget(self, *args):
+        effects = []
+        for child in self.children[::-1]:
+            text = child.text
+            if text == 'none':
+                pass
+            if text == 'fxaa':
+                effects.append(FXAAEffect())
+            if text == 'monochrome':
+                effects.append(MonochromeEffect())
+            if text == 'invert':
+                effects.append(InvertEffect())
+            if text == 'mix':
+                effects.append(ChannelMixEffect())
+            if text == 'blur_h':
+                effects.append(HorizontalBlurEffect())
+            if text == 'blur_v':
+                effects.append(VerticalBlurEffect())
+            if text == 'postprocessing':
+                effects.append(ScanlinesEffect())
+            if text == 'pixelate':
+                effects.append(PixelateEffect())
+
+        if self.effectwidget:
+            self.effectwidget.effects = effects
+
+
+example = Builder.load_string('''
+#:import Vector kivy.vector.Vector
+BoxLayout:
+    orientation: 'vertical'
+    FloatLayout:
+        ComparisonWidget:
+            pos_hint: {'x': 0, 'y': 0}
+            size_hint: 0.5, 1
+            id: effect1
+        ComparisonWidget:
+            pos_hint: {'x': pos_slider.value, 'y': 0}
+            size_hint: 0.5, 1
+            id: effect2
+            background_color: (rs.value, gs.value, bs.value, als.value)
+    SpinnerRow:
+        effectwidget: effect1
+        text: 'left effects'
+    SpinnerRow:
+        effectwidget: effect2
+        text: 'right effects'
+    BoxLayout:
+        size_hint_y: None
+        height: sp(40)
+        Label:
+            text: 'control overlap:'
+        Slider:
+            min: 0
+            max: 0.5
+            value: 0.5
+            id: pos_slider
+    BoxLayout:
+        size_hint_y: None
+        height: sp(40)
+        Label:
+            text: 'right bg r,g,b,a'
+        Slider:
+            min: 0
+            max: 1
+            value: 0
+            id: rs
+        Slider:
+            min: 0
+            max: 1
+            value: 0
+            id: gs
+        Slider:
+            min: 0
+            max: 1
+            value: 0
+            id: bs
+        Slider:
+            min: 0
+            max: 1
+            value: 0
+            id: als
+
+
+<ComparisonWidget>:
+    Widget:
+        canvas:
+            Color:
+                rgba: 1, 0, 0, 1
+            Ellipse:
+                pos: Vector(self.pos) + 0.5*Vector(self.size)
+                size: 0.4*Vector(self.size)
+            Color:
+                rgba: 0, 1, 0.3, 1
+            Ellipse:
+                pos: Vector(self.pos) + 0.1*Vector(self.size)
+                size: 0.6*Vector(self.size)
+            Color:
+                rgba: 0.5, 0.3, 0.8, 1
+            Ellipse:
+                pos: Vector(self.pos) + Vector([0, 0.6])*Vector(self.size)
+                size: 0.4*Vector(self.size)
+            Color:
+                rgba: 1, 0.8, 0.1, 1
+            Ellipse:
+                pos: Vector(self.pos) + Vector([0.5, 0])*Vector(self.size)
+                size: 0.4*Vector(self.size)
+            Color:
+                rgba: 0, 0, 0.8, 1
+            Line:
+                points:
+                    [self.x, self.y,
+                    self.x + self.width, self.y + 0.3*self.height,
+                    self.x + 0.2*self.width, self.y + 0.1*self.height,
+                    self.x + 0.85*self.width, self.y + 0.72*self.height,
+                    self.x + 0.31*self.width, self.y + 0.6*self.height,
+                    self.x, self.top]
+                width: 1
+            Color:
+                rgba: 0, 0.9, 0.1, 1
+            Line:
+                points:
+                    [self.x + self.width, self.y + self.height,
+                    self.x + 0.35*self.width, self.y + 0.6*self.height,
+                    self.x + 0.7*self.width, self.y + 0.15*self.height,
+                    self.x + 0.2*self.width, self.y + 0.22*self.height,
+                    self.x + 0.3*self.width, self.y + 0.92*self.height]
+                width: 2
+
+<SpinnerRow>:
+    orientation: 'horizontal'
+    size_hint_y: None
+    height: dp(40)
+    text: ''
+    Label:
+        text: root.text
+    EffectSpinner:
+        on_text: root.update_effectwidget()
+    EffectSpinner:
+        on_text: root.update_effectwidget()
+    EffectSpinner:
+        on_text: root.update_effectwidget()
+
+<EffectSpinner>:
+    text: 'none'
+    values:
+        ['none', 'fxaa', 'monochrome',
+        'invert', 'mix',
+        'blur_h', 'blur_v',
+        'postprocessing', 'pixelate',]
+''')
+
+
+class EffectApp(App):
+    def build(self):
+        return example
+
+
+EffectApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/effectwidget2.py

@@ -0,0 +1,47 @@
+'''
+This is an example of creating your own effect by writing a glsl string.
+'''
+
+from kivy.base import runTouchApp
+from kivy.lang import Builder
+from kivy.uix.effectwidget import EffectWidget, EffectBase
+
+
+# The effect string is glsl code defining an effect function.
+effect_string = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{
+    // Note that time is a uniform variable that is automatically
+    // provided to all effects.
+    float red = color.x * abs(sin(time*2.0));
+    float green = color.y;  // No change
+    float blue = color.z * (1.0 - abs(sin(time*2.0)));
+    return vec4(red, green, blue, color.w);
+}
+'''
+
+
+class DemoEffect(EffectWidget):
+    def __init__(self, *args, **kwargs):
+        self.effect_reference = EffectBase(glsl=effect_string)
+        super(DemoEffect, self).__init__(*args, **kwargs)
+
+
+widget = Builder.load_string('''
+DemoEffect:
+    effects: [self.effect_reference] if checkbox.active else []
+    orientation: 'vertical'
+    Button:
+        text: 'Some text so you can see what happens.'
+    BoxLayout:
+        size_hint_y: None
+        height: dp(50)
+        Label:
+            text: 'Enable effect?'
+        CheckBox:
+            id: checkbox
+            active: True
+''')
+
+
+runTouchApp(widget)

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/effectwidget3_advanced.py

@@ -0,0 +1,62 @@
+'''
+This example demonstrates creating and using an AdvancedEffectBase. In
+this case, we use it to efficiently pass the touch coordinates into the shader.
+'''
+
+from kivy.base import runTouchApp
+from kivy.properties import ListProperty
+from kivy.lang import Builder
+from kivy.uix.effectwidget import EffectWidget, AdvancedEffectBase
+
+
+effect_string = '''
+uniform vec2 touch;
+
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{
+    vec2 distance = 0.025*(coords - touch);
+    float dist_mag = (distance.x*distance.x + distance.y*distance.y);
+    vec3 multiplier = vec3(abs(sin(dist_mag - time)));
+    return vec4(multiplier * color.xyz, 1.0);
+}
+'''
+
+
+class TouchEffect(AdvancedEffectBase):
+    touch = ListProperty([0.0, 0.0])
+
+    def __init__(self, *args, **kwargs):
+        super(TouchEffect, self).__init__(*args, **kwargs)
+        self.glsl = effect_string
+
+        self.uniforms = {'touch': [0.0, 0.0]}
+
+    def on_touch(self, *args, **kwargs):
+        self.uniforms['touch'] = [float(i) for i in self.touch]
+
+
+class TouchWidget(EffectWidget):
+    def __init__(self, *args, **kwargs):
+        super(TouchWidget, self).__init__(*args, **kwargs)
+        self.effect = TouchEffect()
+        self.effects = [self.effect]
+
+    def on_touch_down(self, touch):
+        super(TouchWidget, self).on_touch_down(touch)
+        self.on_touch_move(touch)
+
+    def on_touch_move(self, touch):
+        self.effect.touch = touch.pos
+
+
+root = Builder.load_string('''
+TouchWidget:
+    Button:
+        text: 'Some text!'
+    Image:
+        source: 'data/logo/kivy-icon-512.png'
+        fit_mode: "fill"
+''')
+
+
+runTouchApp(root)

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/fbowidget.py

@@ -0,0 +1,111 @@
+'''
+FBO example
+===========
+
+This is an example of how to use FBO (Frame Buffer Object) to speedup graphics.
+An Fbo is like a texture that you can draw on it.
+
+By default, all the children are added in the canvas of the parent.
+When you are displaying thousand of widget, you'll do thousands of graphics
+instructions each frame.
+The idea is to do this drawing only one time in a Fbo, and then, draw the Fbo
+every frame instead of all children's graphics instructions.
+
+We created a FboFloatLayout that create his canvas, and a Fbo.
+After the Fbo is created, we are adding Color and Rectangle instruction to
+display the texture of the Fbo itself.
+The overload of on_pos/on_size are here to update size of Fbo if needed, and
+adapt the position/size of the rectangle too.
+
+Then, when a child is added or removed, we are redirecting addition/removal of
+graphics instruction to our Fbo. This is why add_widget/remove_widget are
+overloaded too.
+
+.. note::
+
+    This solution can be helpful but not ideal. Multisampling are not available
+    in Framebuffer. We will work to add the support of it if the hardware is
+    capable of, but it could be not the same.
+
+'''
+
+
+# needed to create Fbo, must be resolved in future kivy version
+from kivy.core.window import Window
+
+from kivy.graphics import Color, Rectangle, Canvas
+from kivy.graphics.fbo import Fbo
+from kivy.uix.floatlayout import FloatLayout
+from kivy.properties import ObjectProperty
+
+
+class FboFloatLayout(FloatLayout):
+
+    texture = ObjectProperty(None, allownone=True)
+
+    def __init__(self, **kwargs):
+        self.canvas = Canvas()
+        with self.canvas:
+            self.fbo = Fbo(size=self.size)
+            Color(1, 1, 1)
+            self.fbo_rect = Rectangle()
+
+        # 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
+
+
+if __name__ == '__main__':
+    from kivy.uix.button import Button
+    from kivy.app import App
+
+    class TestFboApp(App):
+        def build(self):
+
+            # test with FboFloatLayout or FloatLayout
+            # comment/uncomment to test it
+            root = FboFloatLayout()
+            # root = FloatLayout()
+
+            # this part of creation can be slow. try to optimize the loop a
+            # little bit.
+            s = 30
+            size = (s, s)
+            sh = (None, None)
+            add = root.add_widget
+            print('Creating 5000 widgets...')
+            for i in range(5000):
+                x = (i % 40) * s
+                y = int(i / 40) * s
+                add(Button(text=str(i), pos=(x, y), size_hint=sh, size=size))
+                if i % 1000 == 1000 - 1:
+                    print(5000 - i - 1, 'left...')
+
+            return root
+
+    TestFboApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/focus_behavior.py

@@ -0,0 +1,98 @@
+from kivy.app import App
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.label import Label
+from kivy.uix.behaviors import FocusBehavior
+from kivy.graphics import Color, Rectangle
+
+
+class FocusWithColor(FocusBehavior):
+    ''' Class that when focused, changes its background color to red.
+    '''
+
+    _color = None
+    _rect = None
+
+    def __init__(self, **kwargs):
+        super(FocusWithColor, self).__init__(**kwargs)
+        with self.canvas:
+            self._color = Color(1, 1, 1, .2)
+            self._rect = Rectangle(size=self.size, pos=self.pos)
+            self.bind(size=self._update_rect, pos=self._update_rect)
+
+    def _update_rect(self, instance, value):
+        self._rect.pos = instance.pos
+        self._rect.size = instance.size
+
+    def on_focused(self, instance, value, *largs):
+        self._color.rgba = [1, 0, 0, .2] if value else [1, 1, 1, .2]
+
+
+class FocusLabel(FocusWithColor, Label):
+    '''A label, which in addition to turn red when focused, it also sets the
+    keyboard input to the text of the label.
+    '''
+
+    def keyboard_on_key_down(self, window, keycode, text, modifiers):
+        '''We call super before doing anything else to enable tab cycling
+        by FocusBehavior. If we wanted to use tab for ourselves, we could just
+        not call it, or call it if we didn't need tab.
+        '''
+        if super(FocusLabel, self).keyboard_on_key_down(window, keycode,
+                                                         text, modifiers):
+            return True
+        self.text = keycode[1]
+        return True
+
+
+class FocusGridLayout(FocusWithColor, GridLayout):
+    pass
+
+
+class FocusBoxLayout(FocusWithColor, BoxLayout):
+    pass
+
+
+class FocusApp(App):
+
+    def build(self):
+        root = FocusBoxLayout(padding=[10, 10], spacing=10)
+        self.grid1 = grid1 = FocusGridLayout(cols=4, padding=[10, 10],
+                                             spacing=10)
+        self.grid2 = grid2 = FocusGridLayout(cols=4, padding=[10, 10],
+                                             spacing=10)
+        root.add_widget(FocusLabel(text='Left', size_hint_x=0.4))
+        root.add_widget(grid1)
+        root.add_widget(grid2)
+        root.add_widget(FocusLabel(text='Right', size_hint_x=0.4))
+
+        for i in range(40):
+            grid1.add_widget(FocusLabel(text='l' + str(i)))
+        for i in range(40):
+            grid2.add_widget(FocusLabel(text='r' + str(i)))
+
+        # make elements 29, 9 un-focusable. The widgets are displayed in
+        # reverse order, so 9 = 39 - 10
+        grid2.children[30].text = grid1.children[14].text =\
+            grid2.children[15].text = grid1.children[34].text = 'Skip me'
+        grid2.children[15].is_focusable = False
+        grid2.children[30].is_focusable = False
+        # similarly, make 39 - 14 = 25, and 5 un-focusable
+        grid1.children[14].is_focusable = False
+        grid1.children[34].is_focusable = False
+        # don't move focus passed this element
+        grid2.children[35].focus_next = StopIteration
+        grid2.children[35].text = 'Stop forward'
+
+        # exchange the links between the sides so that it'll skip to the other
+        # side in the middle. Remember that children are displayed reversed
+        # in layouts.
+        grid1.children[10].focus_next = grid2.children[9]
+        grid2.children[10].focus_next = grid1.children[9]
+        grid1.children[10].text = '-->'
+        grid2.children[10].text = '<--'
+        return root
+
+
+if __name__ == '__main__':
+    FocusApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/image_mipmap.py

@@ -0,0 +1,31 @@
+'''
+Image mipmap
+============
+
+Difference between a mipmapped image and no mipmap image.
+The lower image is normal, and the top image is mipmapped.
+'''
+
+import kivy
+kivy.require('1.0.7')
+
+from kivy.app import App
+from kivy.uix.scatter import ScatterPlane
+from kivy.uix.image import Image
+from os.path import join
+
+
+class LabelMipmapTest(App):
+    def build(self):
+        s = ScatterPlane(scale=.5)
+        filename = join(kivy.kivy_data_dir, 'logo', 'kivy-icon-256.png')
+        l1 = Image(source=filename, pos=(400, 100), size=(256, 256))
+        l2 = Image(source=filename, pos=(400, 356), size=(256, 256),
+                   mipmap=True)
+        s.add_widget(l1)
+        s.add_widget(l2)
+        return s
+
+
+if __name__ == '__main__':
+    LabelMipmapTest().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/keyboardlistener.py

@@ -0,0 +1,42 @@
+import kivy
+kivy.require('1.0.8')
+
+from kivy.core.window import Window
+from kivy.uix.widget import Widget
+
+
+class MyKeyboardListener(Widget):
+
+    def __init__(self, **kwargs):
+        super(MyKeyboardListener, self).__init__(**kwargs)
+        self._keyboard = Window.request_keyboard(
+            self._keyboard_closed, self, 'text')
+        if self._keyboard.widget:
+            # If it exists, this widget is a VKeyboard object which you can use
+            # to change the keyboard layout.
+            pass
+        self._keyboard.bind(on_key_down=self._on_keyboard_down)
+
+    def _keyboard_closed(self):
+        print('My keyboard have been closed!')
+        self._keyboard.unbind(on_key_down=self._on_keyboard_down)
+        self._keyboard = None
+
+    def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
+        print('The key', keycode, 'have been pressed')
+        print(' - text is %r' % text)
+        print(' - modifiers are %r' % modifiers)
+
+        # Keycode is composed of an integer + a string
+        # If we hit escape, release the keyboard
+        if keycode[1] == 'escape':
+            keyboard.release()
+
+        # Return True to accept the key. Otherwise, it will be used by
+        # the system.
+        return True
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    runTouchApp(MyKeyboardListener())

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/widgets/label_mipmap.py

@@ -0,0 +1,28 @@
+'''
+Label mipmap
+============
+
+This show how to create a mipmapped label, and the visual difference between a
+non mipmapped and mipmapped label.
+'''
+
+import kivy
+kivy.require('1.0.7')
+
+from kivy.app import App
+from kivy.uix.scatter import ScatterPlane
+from kivy.uix.label import Label
+
+
+class LabelMipmapTest(App):
+    def build(self):
+        s = ScatterPlane(scale=.5)
+        l1 = Label(text='Kivy rulz', font_size=98, pos=(400, 100), mipmap=True)
+        l2 = Label(text='Kivy rulz', font_size=98, pos=(400, 328))
+        s.add_widget(l1)
+        s.add_widget(l2)
+        return s
+
+
+if __name__ == '__main__':
+    LabelMipmapTest().run()