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

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

@@ -0,0 +1,110 @@
+'''
+Multitexture Example
+====================
+
+This example blends two textures: the image mtexture1.png of the letter K
+and the image mtexture2.png of an orange circle. You should see an orange
+K clipped to a circle. It uses a custom shader, written in glsl
+(OpenGL Shading Language), stored in a local string.
+
+Note the image mtexture1.png is a white 'K' on a transparent background, which
+makes it hard to see.
+'''
+
+from kivy.clock import Clock
+from kivy.app import App
+from kivy.uix.widget import Widget
+from kivy.uix.floatlayout import FloatLayout
+from kivy.lang import Builder
+from kivy.core.window import Window
+from kivy.graphics import RenderContext, Color, Rectangle, BindTexture
+
+
+fs_multitexture = '''
+$HEADER$
+
+// New uniform that will receive texture at index 1
+uniform sampler2D texture1;
+
+void main(void) {
+
+    // multiple current color with both texture (0 and 1).
+    // currently, both will use exactly the same texture coordinates.
+    gl_FragColor = frag_color * \
+        texture2D(texture0, tex_coord0) * \
+        texture2D(texture1, tex_coord0);
+}
+'''
+
+
+kv = """
+<MultitextureLayout>:
+
+    Image:
+        source: "mtexture1.png"
+        size_hint: .3,.3
+        id: 1
+        pos: 0,200
+    Image:
+        source: "mtexture2.png"
+        size_hint: .3,.3
+        id: 2
+        pos: 200,200
+
+    MultitextureWidget:
+
+"""
+
+Builder.load_string(kv)
+
+
+class MultitextureWidget(Widget):
+
+    def __init__(self, **kwargs):
+        self.canvas = RenderContext()
+        # setting shader.fs to new source code automatically compiles it.
+        self.canvas.shader.fs = fs_multitexture
+        with self.canvas:
+            Color(1, 1, 1)
+
+            # here, we are binding a custom texture at index 1
+            # this will be used as texture1 in shader.
+            # The filenames are misleading: they do not correspond to the
+            # index here or in the shader.
+            BindTexture(source='mtexture2.png', index=1)
+
+            # create a rectangle with texture (will be at index 0)
+            Rectangle(size=(150, 150), source='mtexture1.png', pos=(500, 200))
+
+        # set the texture1 to use texture index 1
+        self.canvas['texture1'] = 1
+
+        # call the constructor of parent
+        # if they are any graphics objects, they will be added on our new
+        # canvas
+        super(MultitextureWidget, self).__init__(**kwargs)
+
+        # We'll update our glsl variables in a clock
+        Clock.schedule_interval(self.update_glsl, 0)
+
+    def update_glsl(self, *largs):
+        # This is needed for the default vertex shader.
+        self.canvas['projection_mat'] = Window.render_context['projection_mat']
+        self.canvas['modelview_mat'] = Window.render_context['modelview_mat']
+
+
+class MultitextureLayout(FloatLayout):
+
+    def __init__(self, **kwargs):
+        self.size = kwargs['size']
+        super(MultitextureLayout, self).__init__(**kwargs)
+
+
+class MultitextureApp(App):
+
+    def build(self):
+        return MultitextureLayout(size=(600, 600))
+
+
+if __name__ == '__main__':
+    MultitextureApp().run()

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

@@ -0,0 +1,65 @@
+'''
+Repeat Texture on Resize
+========================
+
+This examples repeats the letter 'K' (mtexture1.png) 64 times in a window.
+You should see 8 rows and 8 columns of white K letters, along a label
+showing the current size. As you resize the window, it stays an 8x8.
+This example includes a label with a colored background.
+
+Note the image mtexture1.png is a white 'K' on a transparent background, which
+makes it hard to see.
+'''
+
+from kivy.app import App
+from kivy.uix.image import Image
+from kivy.uix.label import Label
+from kivy.properties import ObjectProperty, ListProperty
+from kivy.lang import Builder
+
+kv = '''
+<LabelOnBackground>:
+    canvas.before:
+        Color:
+            rgb: self.background
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+FloatLayout:
+    canvas.before:
+        Color:
+            rgb: 1, 1, 1
+        Rectangle:
+            pos: self.pos
+            size: self.size
+            texture: app.texture
+
+    LabelOnBackground:
+        text: '{} (try to resize the window)'.format(root.size)
+        color: (0.4, 1, 1, 1)
+        background: (.3, .3, .3)
+        pos_hint: {'center_x': .5, 'center_y': .5 }
+        size_hint: None, None
+        height: 30
+        width: 250
+
+'''
+
+
+class LabelOnBackground(Label):
+    background = ListProperty((0.2, 0.2, 0.2))
+
+
+class RepeatTexture(App):
+
+    texture = ObjectProperty()
+
+    def build(self):
+        self.texture = Image(source='mtexture1.png').texture
+        self.texture.wrap = 'repeat'
+        self.texture.uvsize = (8, 8)
+        return Builder.load_string(kv)
+
+
+RepeatTexture().run()

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

@@ -0,0 +1,35 @@
+'''
+Rotation Example
+================
+
+This example rotates a button using PushMatrix and PopMatrix. You should see
+a static button with the words 'hello world' rotated at a 45 degree angle.
+'''
+
+
+from kivy.app import App
+from kivy.lang import Builder
+
+kv = '''
+FloatLayout:
+
+    Button:
+        text: 'hello world'
+        size_hint: None, None
+        pos_hint: {'center_x': .5, 'center_y': .5}
+        canvas.before:
+            PushMatrix
+            Rotate:
+                angle: 45
+                origin: self.center
+        canvas.after:
+            PopMatrix
+'''
+
+
+class RotationApp(App):
+    def build(self):
+        return Builder.load_string(kv)
+
+
+RotationApp().run()

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

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+from kivy.app import App
+from kivy.uix.widget import Widget
+from kivy.graphics import Color, Ellipse, Rectangle, RoundedRectangle
+from kivy.lang import Builder
+
+TEXTURE = 'kiwi.jpg'
+YELLOW = (1, .7, 0)
+ORANGE = (1, .45, 0)
+RED = (1, 0, 0)
+WHITE = (1, 1, 1)
+
+
+class RoundedRectangleWidget(Widget):
+    def prepare(self):
+        with self.canvas:
+            Color(*WHITE)
+
+            # Rectangle of default size 100x100
+            Rectangle(pos=(50, 400))
+
+            # RoundedRectangles of default size 100x100:
+
+            # Textured:
+            RoundedRectangle(
+                pos=(175, 400), radius=[0, 50, 0, 50], source=TEXTURE)
+
+            # Colored:
+            Color(*YELLOW)
+            RoundedRectangle(pos=(300, 400), radius=[0, 50, 0, 50])
+
+            # Textured + Colored
+            # Color(.3,.3,.3, 1)
+            RoundedRectangle(
+                pos=(425, 400), radius=[0, 50, 0, 50], source=TEXTURE)
+
+            # Possible radius arguments:
+            # 1) Same value for each corner
+            Color(*ORANGE)
+
+            # With same radius 20x20
+            RoundedRectangle(pos=(50, 275), radius=[20])
+
+            # With same radius dimensions 20x40
+            RoundedRectangle(pos=(175, 275), radius=[(20, 40)])
+
+            # 2) Different values for each corner
+            Color(*RED)
+
+            # With different radiuses NxN:
+            RoundedRectangle(pos=(300, 275), radius=[10, 20, 30, 40])
+
+            # With different radiuses:
+            RoundedRectangle(
+                pos=(425, 275),
+                radius=[(10, 20), (20, 30), (30, 40), (40, 50)])
+
+            # Default ellipses
+            Color(*WHITE)
+            Ellipse(pos=(50, 150))
+            Ellipse(pos=(175, 150))
+            Ellipse(pos=(300, 150))
+            Ellipse(pos=(425, 150))
+
+            # Radius dimensions can't be bigger than half of the figure side
+            RoundedRectangle(pos=(175, 150), radius=[9000], source=TEXTURE)
+
+            # Segments parameter defines how many segments each corner has.
+            # More segments - more roundness
+            Color(*RED)
+            RoundedRectangle(pos=(300, 150), radius=[9000])
+            RoundedRectangle(pos=(425, 150), radius=[9000], segments=15)
+
+            Color(*ORANGE)
+            RoundedRectangle(pos=(425, 150), radius=[9000], segments=2)
+
+            Color(*YELLOW)
+            RoundedRectangle(pos=(425, 150), radius=[9000], segments=1)
+
+            # Various sizes
+            # You can cut corners by setting segments to 1.
+            # You can set different segment count to corners,
+            # by using a list useful for lowering vertex count
+            # by using small amount on small corners, while using
+            # bigger amount on bigger corners.
+            RoundedRectangle(
+                pos=(50, 25),
+                radius=[40],
+                segments=[1, 1, 10, 10],
+                size=(125, 100))
+
+            # If radius dimension is 0, then the corner will be sharp
+            # (90 degrees). It is also possible to mix tuple values
+            # with numeric
+            Color(*ORANGE)
+            RoundedRectangle(
+                pos=(200, 25),
+                radius=[(40, 20),
+                45.5, 45.5, 0],
+                segments=[2, 3, 3, 1], size=(125, 100))
+
+            Color(*RED)
+            RoundedRectangle(
+                pos=(350, 25),
+                radius=[(40, 40), (40, 40), (20, 20), (20, 20)],
+                segments=[2, 3, 3, 2],
+                size=(150, 100))
+
+
+class DrawRoundedRectanglesApp(App):
+    def build(self):
+        kv = '''
+Widget:
+    canvas:
+        Color:
+            rgba: 1, 1,1, 1
+
+        RoundedRectangle:
+            pos: 575, 400
+            size: 100, 100
+            radius: [0, 50, 0, 50]
+            source: 'kiwi.jpg'
+
+        Color:
+            rgba: 0, 0.8, 0.8, 1
+
+        RoundedRectangle:
+            pos: 575, 275
+            size: 100, 100
+            radius: [(10, 20), (20, 30), (30, 40), (40, 50)]
+
+        RoundedRectangle:
+            pos: 575, 150
+            size: 100, 100
+            radius: [9000]
+            segments: 15
+
+        RoundedRectangle:
+            pos: 550, 25
+            size: 150, 100
+            segments: [1, 2, 1, 3]
+            radius: [30, 40, 30, 40]
+
+'''
+        widget = RoundedRectangleWidget()
+        widget.prepare()
+        kvrect = Builder.load_string(kv)
+        widget.add_widget(kvrect)
+        return widget
+
+
+if __name__ == '__main__':
+    DrawRoundedRectanglesApp().run()

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

@@ -0,0 +1,37 @@
+'''
+Scaling Example
+================
+
+This example scales a button using PushMatrix and PopMatrix. It shows
+a static button with the words 'hello world', stretched about its centre by
+a factor of 1.5 horizontally and 5 vertically.
+'''
+
+
+from kivy.app import App
+from kivy.lang import Builder
+
+kv = '''
+FloatLayout:
+
+    Button:
+        text: 'hello world'
+        size_hint: None, None
+        pos_hint: {'center_x': .5, 'center_y': .5}
+        canvas.before:
+            PushMatrix
+            Scale:
+                x: 1.5
+                y: 5
+                origin: self.center
+        canvas.after:
+            PopMatrix
+'''
+
+
+class ScalingApp(App):
+    def build(self):
+        return Builder.load_string(kv)
+
+
+ScalingApp().run()

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

@@ -0,0 +1,85 @@
+'''
+Stencil demo
+============
+
+This is a test of the stencil graphics instruction inside the stencil view
+widget. When you use a stencil, nothing will be drawn outside the bounding
+box. All the graphics will draw only in the stencil view.
+
+You can "draw" a stencil view by touch & draw. The touch down will set the
+position, and the drag will set the size.
+'''
+
+from kivy.app import App
+from kivy.core.window import Window
+from kivy.graphics import Color, Rectangle
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.button import Button
+from kivy.uix.label import Label
+from kivy.uix.stencilview import StencilView
+from random import random as r
+from functools import partial
+
+
+class StencilTestWidget(StencilView):
+    '''Drag to define stencil area
+    '''
+
+    def on_touch_down(self, touch):
+        self.pos = touch.pos
+        self.size = (1, 1)
+
+    def on_touch_move(self, touch):
+        self.size = (touch.x - touch.ox, touch.y - touch.oy)
+
+
+class StencilCanvasApp(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=(10, 10))
+
+    def reset_stencil(self, wid, *largs):
+        wid.pos = (0, 0)
+        wid.size = Window.size
+
+    def reset_rects(self, label, wid, *largs):
+        label.text = '0'
+        wid.canvas.clear()
+
+    def build(self):
+        wid = StencilTestWidget(size_hint=(None, None), size=Window.size)
+
+        label = Label(text='0')
+
+        btn_add500 = Button(text='+ 200 rects')
+        btn_add500.bind(on_press=partial(self.add_rects, label, wid, 200))
+
+        btn_reset = Button(text='Reset Rectangles')
+        btn_reset.bind(on_press=partial(self.reset_rects, label, wid))
+
+        btn_stencil = Button(text='Reset Stencil')
+        btn_stencil.bind(on_press=partial(self.reset_stencil, wid))
+
+        layout = BoxLayout(size_hint=(1, None), height=50)
+        layout.add_widget(btn_add500)
+        layout.add_widget(btn_reset)
+        layout.add_widget(btn_stencil)
+        layout.add_widget(label)
+
+        root = BoxLayout(orientation='vertical')
+        rfl = FloatLayout()
+        rfl.add_widget(wid)
+        root.add_widget(rfl)
+        root.add_widget(layout)
+
+        return root
+
+
+if __name__ == '__main__':
+    StencilCanvasApp().run()

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

@@ -0,0 +1,146 @@
+'''
+Tesselate Demonstration
+=======================
+
+This demonstrates the experimental library for tesselating polygons. You
+should see a hollow square with some buttons below it. You can click and
+drag to create additional shapes, watching the number of vertices and elements
+at the top of the screen. The 'debug' button toggles showing the mesh in
+different colors.
+'''
+
+
+from kivy.app import App
+from kivy.graphics import Mesh, Color
+from kivy.graphics.tesselator import Tesselator, WINDING_ODD, TYPE_POLYGONS
+from kivy.uix.floatlayout import FloatLayout
+from kivy.lang import Builder
+from kivy.logger import Logger
+
+Builder.load_string("""
+<ShapeBuilder>:
+    BoxLayout:
+        size_hint_y: None
+        height: "48dp"
+        spacing: "2dp"
+        padding: "2dp"
+
+        ToggleButton:
+            text: "Debug"
+            id: debug
+            on_release: root.build()
+        Button:
+            text: "New shape"
+            on_release: root.push_shape()
+        Button:
+            text: "Build"
+            on_release: root.build()
+        Button:
+            text: "Reset"
+            on_release: root.reset()
+
+    BoxLayout:
+        size_hint_y: None
+        height: "48dp"
+        top: root.top
+        spacing: "2dp"
+        padding: "2dp"
+        Label:
+            id: status
+            text: "Status"
+""")
+
+
+class ShapeBuilder(FloatLayout):
+    def __init__(self, **kwargs):
+        super(ShapeBuilder, self).__init__(**kwargs)
+        self.shapes = [
+            [100, 100, 300, 100, 300, 300, 100, 300],
+            [150, 150, 250, 150, 250, 250, 150, 250]
+        ]  # the 'hollow square' shape
+        self.shape = []
+        self.build()
+
+    def on_touch_down(self, touch):
+        if super(ShapeBuilder, self).on_touch_down(touch):
+            return True
+        Logger.info('tesselate: on_touch_down (%5.2f, %5.2f)' % touch.pos)
+        self.shape.extend(touch.pos)
+        self.build()
+        return True
+
+    def on_touch_move(self, touch):
+        if super(ShapeBuilder, self).on_touch_move(touch):
+            return True
+        Logger.info('tesselate: on_touch_move (%5.2f, %5.2f)' % touch.pos)
+        self.shape.extend(touch.pos)
+        self.build()
+        return True
+
+    def on_touch_up(self, touch):
+        if super(ShapeBuilder, self).on_touch_up(touch):
+            return True
+        Logger.info('tesselate: on_touch_up (%5.2f, %5.2f)' % touch.pos)
+        self.push_shape()
+        self.build()
+
+    def push_shape(self):
+        self.shapes.append(self.shape)
+        self.shape = []
+
+    def build(self):
+        tess = Tesselator()
+        count = 0
+        for shape in self.shapes:
+            if len(shape) >= 3:
+                tess.add_contour(shape)
+                count += 1
+        if self.shape and len(self.shape) >= 3:
+            tess.add_contour(self.shape)
+            count += 1
+        if not count:
+            return
+        ret = tess.tesselate(WINDING_ODD, TYPE_POLYGONS)
+        Logger.info('tesselate: build: tess.tesselate returns {}'.format(ret))
+        self.canvas.after.clear()
+
+        debug = self.ids.debug.state == "down"
+        if debug:
+            with self.canvas.after:
+                c = 0
+                for vertices, indices in tess.meshes:
+                    Color(c, 1, 1, mode="hsv")
+                    c += 0.3
+                    indices = [0]
+                    for i in range(1, len(vertices) // 4):
+                        if i > 0:
+                            indices.append(i)
+                        indices.append(i)
+                        indices.append(0)
+                        indices.append(i)
+                    indices.pop(-1)
+                    Mesh(vertices=vertices, indices=indices, mode="lines")
+        else:
+            with self.canvas.after:
+                Color(1, 1, 1, 1)
+                for vertices, indices in tess.meshes:
+                    Mesh(vertices=vertices, indices=indices,
+                         mode="triangle_fan")
+
+        self.ids.status.text = "Shapes: {} - Vertex: {} - Elements: {}".format(
+            count, tess.vertex_count, tess.element_count)
+
+    def reset(self):
+        self.shapes = []
+        self.shape = []
+        self.ids.status.text = "Shapes: {} - Vertex: {} - Elements: {}".format(
+            0, 0, 0)
+        self.canvas.after.clear()
+
+
+class TessApp(App):
+    def build(self):
+        return ShapeBuilder()
+
+
+TessApp().run()