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

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

@@ -0,0 +1,122 @@
+"""
+Config Example
+==============
+
+This file contains a simple example of how the use the Kivy settings classes in
+a real app. It allows the user to change the caption and font_size of the label
+and stores these changes.
+
+When the user next runs the programs, their changes are restored.
+
+"""
+
+from kivy.app import App
+from kivy.uix.settings import SettingsWithTabbedPanel
+from kivy.logger import Logger
+from kivy.lang import Builder
+
+# We first define our GUI
+kv = '''
+BoxLayout:
+    orientation: 'vertical'
+    Button:
+        text: 'Configure app (or press F1)'
+        on_release: app.open_settings()
+    Label:
+        id: label
+        text: 'Hello'
+'''
+
+# This JSON defines entries we want to appear in our App configuration screen
+json = '''
+[
+    {
+        "type": "string",
+        "title": "Label caption",
+        "desc": "Choose the text that appears in the label",
+        "section": "My Label",
+        "key": "text"
+    },
+    {
+        "type": "numeric",
+        "title": "Label font size",
+        "desc": "Choose the font size the label",
+        "section": "My Label",
+        "key": "font_size"
+    }
+]
+'''
+
+
+class MyApp(App):
+    def build(self):
+        """
+        Build and return the root widget.
+        """
+        # The line below is optional. You could leave it out or use one of the
+        # standard options, such as SettingsWithSidebar, SettingsWithSpinner
+        # etc.
+        self.settings_cls = MySettingsWithTabbedPanel
+
+        # We apply the saved configuration settings or the defaults
+        root = Builder.load_string(kv)
+        label = root.ids.label
+        label.text = self.config.get('My Label', 'text')
+        label.font_size = float(self.config.get('My Label', 'font_size'))
+        return root
+
+    def build_config(self, config):
+        """
+        Set the default values for the configs sections.
+        """
+        config.setdefaults('My Label', {'text': 'Hello', 'font_size': 20})
+
+    def build_settings(self, settings):
+        """
+        Add our custom section to the default configuration object.
+        """
+        # We use the string defined above for our JSON, but it could also be
+        # loaded from a file as follows:
+        #     settings.add_json_panel('My Label', self.config, 'settings.json')
+        settings.add_json_panel('My Label', self.config, data=json)
+
+    def on_config_change(self, config, section, key, value):
+        """
+        Respond to changes in the configuration.
+        """
+        Logger.info("main.py: App.on_config_change: {0}, {1}, {2}, {3}".format(
+            config, section, key, value))
+
+        if section == "My Label":
+            if key == "text":
+                self.root.ids.label.text = value
+            elif key == 'font_size':
+                self.root.ids.label.font_size = float(value)
+
+    def close_settings(self, settings=None):
+        """
+        The settings panel has been closed.
+        """
+        Logger.info("main.py: App.close_settings: {0}".format(settings))
+        super(MyApp, self).close_settings(settings)
+
+
+class MySettingsWithTabbedPanel(SettingsWithTabbedPanel):
+    """
+    It is not usually necessary to create subclass of a settings panel. There
+    are many built-in types that you can use out of the box
+    (SettingsWithSidebar, SettingsWithSpinner etc.).
+
+    You would only want to create a Settings subclass like this if you want to
+    change the behavior or appearance of an existing Settings class.
+    """
+    def on_close(self):
+        Logger.info("main.py: MySettingsWithTabbedPanel.on_close")
+
+    def on_config_change(self, config, section, key, value):
+        Logger.info(
+            "main.py: MySettingsWithTabbedPanel.on_config_change: "
+            "{0}, {1}, {2}, {3}".format(config, section, key, value))
+
+
+MyApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/shader/plasma.kv

@@ -0,0 +1,9 @@
+#:kivy 1.0
+
+<ShaderWidget>:
+    canvas:
+        Color:
+            rgb: 1, 0, 0
+        Rectangle:
+            pos: self.pos
+            size: self.size

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/shader/plasma.py

@@ -0,0 +1,86 @@
+'''
+Plasma Shader
+=============
+
+This shader example have been taken from
+http://www.iquilezles.org/apps/shadertoy/ with some adaptation.
+
+This might become a Kivy widget when experimentation will be done.
+'''
+
+
+from kivy.clock import Clock
+from kivy.app import App
+from kivy.uix.floatlayout import FloatLayout
+from kivy.core.window import Window
+from kivy.graphics import RenderContext
+from kivy.properties import StringProperty
+
+
+# Plasma shader
+plasma_shader = '''
+$HEADER$
+
+uniform vec2 resolution;
+uniform float time;
+
+void main(void)
+{
+   vec4 frag_coord = frag_modelview_mat * gl_FragCoord;
+   float x = frag_coord.x;
+   float y = frag_coord.y;
+   float mov0 = x+y+cos(sin(time)*2.)*100.+sin(x/100.)*1000.;
+   float mov1 = y / resolution.y / 0.2 + time;
+   float mov2 = x / resolution.x / 0.2;
+   float c1 = abs(sin(mov1+time)/2.+mov2/2.-mov1-mov2+time);
+   float c2 = abs(sin(c1+sin(mov0/1000.+time)
+              +sin(y/40.+time)+sin((x+y)/100.)*3.));
+   float c3 = abs(sin(c2+cos(mov1+mov2+c2)+cos(mov2)+sin(x/1000.)));
+   gl_FragColor = vec4( c1,c2,c3,1.0);
+}
+'''
+
+
+class ShaderWidget(FloatLayout):
+
+    # property to set the source code for fragment shader
+    fs = StringProperty(None)
+
+    def __init__(self, **kwargs):
+        # Instead of using Canvas, we will use a RenderContext,
+        # and change the default shader used.
+        self.canvas = RenderContext()
+
+        # call the constructor of parent
+        # if they are any graphics object, they will be added on our new canvas
+        super(ShaderWidget, self).__init__(**kwargs)
+
+        # We'll update our glsl variables in a clock
+        Clock.schedule_interval(self.update_glsl, 1 / 60.)
+
+    def on_fs(self, instance, value):
+        # set the fragment shader to our source code
+        shader = self.canvas.shader
+        old_value = shader.fs
+        shader.fs = value
+        if not shader.success:
+            shader.fs = old_value
+            raise Exception('failed')
+
+    def update_glsl(self, *largs):
+        self.canvas['time'] = Clock.get_boottime()
+        self.canvas['resolution'] = list(map(float, self.size))
+        # This is needed for the default vertex shader.
+        win_rc = Window.render_context
+        self.canvas['projection_mat'] = win_rc['projection_mat']
+        self.canvas['modelview_mat'] = win_rc['modelview_mat']
+        self.canvas['frag_modelview_mat'] = win_rc['frag_modelview_mat']
+
+
+class PlasmaApp(App):
+    def build(self):
+        return ShaderWidget(fs=plasma_shader)
+
+
+if __name__ == '__main__':
+    PlasmaApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/shader/rotated.kv

@@ -0,0 +1,91 @@
+#:kivy 1.10.1
+
+<TiltedWidget@Widget>:
+    canvas.before:
+        PushMatrix
+        Rotate:
+            angle: 45
+            origin: self.center
+    canvas.after:
+        PopMatrix
+
+<TiltedShiftedWidget@Widget>:
+    canvas.before:
+        PushMatrix
+        PushMatrix:
+            stack: 'frag_modelview_mat'
+        Rotate:
+            angle: 45
+            origin: self.center
+        Rotate:
+            stack: 'frag_modelview_mat'
+            angle: 45
+            origin: self.center
+    canvas.after:
+        PopMatrix
+        PopMatrix:
+            stack: 'frag_modelview_mat'
+
+<SmallLabel@Label>:
+    font_size: 30
+    outline_width: 1
+    pos_hint: {'center_x': .5, 'center_y': .5}
+
+<LargeTiltedLabel@TiltedWidget+Label>:
+    font_size: 60
+    outline_width: 3
+
+<MiniShaderWidget@ShaderWidget>:
+    size_hint: .3, .3
+    pos_hint: {'center_x': .25, 'center_y': .25}
+    canvas:
+        Color:
+            rgb: 1., .6, .3
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+<PhaseShiftedWidget@TiltedShiftedWidget+FloatLayout>:
+    size_hint: .3, .3
+    pos_hint: {'center_x': .75, 'center_y': .75}
+    canvas:
+        Color:
+            rgb: .3, .6, .9
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+    SmallLabel:
+        text: 'Phase Shifted'
+
+<InPhaseWidget@TiltedWidget+FloatLayout>:
+    size_hint: .3, .3
+    pos_hint: {'center_x': .25, 'center_y': .75}
+    canvas:
+        Color:
+            rgb: .3, .6, .9
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+    SmallLabel:
+        text: 'In Phase'
+
+<MainWidget@ShaderWidget+FloatLayout>:
+    mini: mini
+    canvas:
+        Color:
+            rgb: .9, .6, .3
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+    LargeTiltedLabel:
+        text: 'far out'
+        pos_hint: {'center_x': .75, 'center_y': .25}
+
+    MiniShaderWidget
+        id: mini
+
+    PhaseShiftedWidget
+    InPhaseWidget

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/shader/rotated.py

@@ -0,0 +1,102 @@
+'''
+Rotated Shader
+=============
+
+This shader example is a modified version of plasma.py that shows how to
+rotate areas of fragment shaders bounded by vertex_instructions.
+'''
+from kivy.app import App
+from kivy.clock import Clock
+from kivy.factory import Factory
+from kivy.graphics import RenderContext
+from kivy.properties import StringProperty
+from kivy.uix.widget import Widget
+
+# imported early for side effects needed for Shader
+import kivy.core.window
+
+
+shared_code = '''
+$HEADER$
+
+uniform float time;
+
+vec4 tex(void)
+{
+   return frag_color * texture2D(texture0, tex_coord0);
+}
+
+float plasmaFunc(float n1, float n2, float n3, float n4)
+{
+   vec4 fPos = frag_modelview_mat * gl_FragCoord;
+   return abs(sin(
+                  sin(sin(fPos.x / n1) + time) +
+                  sin(fPos.y / n2 + time) +
+                  n4 * sin((fPos.x + fPos.y) / n3)));
+}
+
+'''
+
+
+plasma_shader = shared_code + '''
+void main(void)
+{
+   float green = plasmaFunc(40., 30., 100., 3.5);
+   gl_FragColor = vec4(1.0, green, 1.0, 1.0) * tex();
+}
+
+'''
+
+
+plasma_shader2 = shared_code + '''
+void main(void)
+{
+   float red = plasmaFunc(30., 20., 10., .5);
+   gl_FragColor = vec4(red, 1.0, 1.0, 1.0) * tex();
+}
+
+'''
+
+
+class ShaderWidget(Widget):
+
+    # property to set the source code for fragment shader
+    fs = StringProperty(None)
+
+    def __init__(self, **kwargs):
+        # Instead of using Canvas, we will use a RenderContext,
+        # and change the default fragment shader used.
+        self.canvas = RenderContext(use_parent_projection=True,
+                                    use_parent_modelview=True,
+                                    use_parent_frag_modelview=True)
+
+        # call the constructor of parent
+        # if they are any graphics object, they will be added on our new canvas
+        super(ShaderWidget, self).__init__(**kwargs)
+
+        # We'll update our glsl variables in a clock
+        Clock.schedule_interval(self.update_glsl, 1 / 60.)
+
+    def update_glsl(self, *largs):
+        self.canvas['time'] = Clock.get_boottime()
+
+    def on_fs(self, instance, value):
+        # set the fragment shader to our source code
+        shader = self.canvas.shader
+        old_value = shader.fs
+        shader.fs = value
+        if not shader.success:
+            shader.fs = old_value
+            raise Exception('failed')
+
+
+class RotatedApp(App):
+    def build(self):
+        main_widget = Factory.MainWidget()
+        main_widget.fs = plasma_shader
+        main_widget.mini.fs = plasma_shader2
+        return main_widget
+
+
+if __name__ == '__main__':
+    RotatedApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/shader/shadertree.kv

@@ -0,0 +1,29 @@
+#:kivy 1.10.1
+
+<ShaderWidget>:
+    Button:
+        text: 'Hello World'
+        pos_hint: {'center_x': .25, 'center_y': .5}
+        size_hint: None, None
+    ScatterImage
+
+<ScatterImage@Scatter>:
+    size: image.size
+    pos_hint: {'center_x': .75, 'center_y': .5}
+    size_hint: None, None
+    Image:
+        id: image
+        source: 'tex3.jpg'
+        size: self.texture_size
+
+<RootWidget>:
+    shader_btn: shader_btn
+    shader_widget: shader_widget
+
+    ShaderWidget:
+        id: shader_widget
+    Button:
+        id: shader_btn
+        text: 'Change fragment shader'
+        size_hint_y: None
+        height: 50

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/shader/shadertree.py

@@ -0,0 +1,193 @@
+'''
+Tree shader
+===========
+
+This example is an experimentation to show how we can use shader for a tree
+subset. Here, we made a ShaderTreeWidget, different than the ShaderWidget
+in the plasma.py example.
+
+The ShaderTree widget create a Framebuffer, render his children on it, and
+render the Framebuffer with a specific Shader.
+With this way, you can apply cool effect on your widgets :)
+
+'''
+
+from kivy.clock import Clock
+from kivy.app import App
+from kivy.uix.floatlayout import FloatLayout
+from kivy.core.window import Window  # side effects needed by Shader
+from kivy.properties import StringProperty, ObjectProperty
+from kivy.graphics import (RenderContext, Fbo, Color, ClearColor, ClearBuffers,
+        Rectangle)
+
+import itertools
+
+
+header = '''
+$HEADER$
+
+uniform vec2 resolution;
+uniform float time;
+'''
+
+# pulse (Danguafer/Silexars, 2010)
+shader_pulse = header + '''
+void main(void)
+{
+    vec2 halfres = resolution.xy/2.0;
+    vec2 cPos = vec4(frag_modelview_mat * gl_FragCoord).xy;
+
+    cPos.x -= 0.5*halfres.x*sin(time/2.0)+0.3*halfres.x*cos(time)+halfres.x;
+    cPos.y -= 0.4*halfres.y*sin(time/5.0)+0.3*halfres.y*cos(time)+halfres.y;
+    float cLength = length(cPos);
+
+    vec2 uv = tex_coord0+(cPos/cLength)*sin(cLength/30.0-time*10.0)/25.0;
+    vec3 col = texture2D(texture0,uv).xyz*50.0/cLength;
+
+    gl_FragColor = vec4(col,1.0);
+}
+'''
+
+# post processing (by iq, 2009)
+shader_postprocessing = header + '''
+uniform vec2 uvsize;
+uniform vec2 uvpos;
+void main(void)
+{
+    vec2 q = tex_coord0 * vec2(1, -1);
+    vec2 uv = 0.5 + (q-0.5);//*(0.9);// + 0.1*sin(0.2*time));
+
+    vec3 oricol = texture2D(texture0,vec2(q.x,1.0-q.y)).xyz;
+    vec3 col;
+
+    col.r = texture2D(texture0,vec2(uv.x+0.003,-uv.y)).x;
+    col.g = texture2D(texture0,vec2(uv.x+0.000,-uv.y)).y;
+    col.b = texture2D(texture0,vec2(uv.x-0.003,-uv.y)).z;
+
+    col = clamp(col*0.5+0.5*col*col*1.2,0.0,1.0);
+
+    //col *= 0.5 + 0.5*16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y);
+
+    col *= vec3(0.8,1.0,0.7);
+
+    col *= 0.9+0.1*sin(10.0*time+uv.y*1000.0);
+
+    col *= 0.97+0.03*sin(110.0*time);
+
+    float comp = smoothstep( 0.2, 0.7, sin(time) );
+    //col = mix( col, oricol, clamp(-2.0+2.0*q.x+3.0*comp,0.0,1.0) );
+
+    gl_FragColor = vec4(col,1.0);
+}
+'''
+
+shader_monochrome = header + '''
+void main() {
+    vec4 rgb = texture2D(texture0, tex_coord0);
+    float c = (rgb.x + rgb.y + rgb.z) * 0.3333;
+    gl_FragColor = vec4(c, c, c, 1.0);
+}
+'''
+
+
+class ShaderWidget(FloatLayout):
+
+    # property to set the source code for fragment shader
+    fs = StringProperty(None)
+
+    # texture of the framebuffer
+    texture = ObjectProperty(None)
+
+    def __init__(self, **kwargs):
+        # Instead of using canvas, we will use a RenderContext,
+        # and change the default shader used.
+        self.canvas = RenderContext(use_parent_projection=True,
+                                    use_parent_modelview=True,
+                                    use_parent_frag_modelview=True)
+
+        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()
+
+        # call the constructor of parent
+        # if they are any graphics object, they will be added on our new canvas
+        super(ShaderWidget, self).__init__(**kwargs)
+
+        # We'll update our glsl variables in a clock
+        Clock.schedule_interval(self.update_glsl, 0)
+
+    def update_glsl(self, *largs):
+        self.canvas['time'] = Clock.get_boottime()
+        self.canvas['resolution'] = [float(v) for v in self.size]
+
+    def on_fs(self, instance, value):
+        # set the fragment shader to our source code
+        shader = self.canvas.shader
+        old_value = shader.fs
+        shader.fs = value
+        if not shader.success:
+            shader.fs = old_value
+            raise Exception('failed')
+
+    #
+    # now, if we have new widget to add,
+    # add their graphics canvas to our Framebuffer, not the usual canvas.
+    #
+
+    def add_widget(self, *args, **kwargs):
+        c = self.canvas
+        self.canvas = self.fbo
+        super(ShaderWidget, self).add_widget(*args, **kwargs)
+        self.canvas = c
+
+    def remove_widget(self, *args, **kwargs):
+        c = self.canvas
+        self.canvas = self.fbo
+        super(ShaderWidget, self).remove_widget(*args, **kwargs)
+        self.canvas = c
+
+    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
+
+
+class RootWidget(FloatLayout):
+    shader_btn = ObjectProperty(None)
+    shader_widget = ObjectProperty(None)
+
+    def __init__(self, **kwargs):
+        super(RootWidget, self).__init__(**kwargs)
+
+        # prepare shader list
+        available_shaders = [
+                shader_pulse,
+                shader_postprocessing,
+                shader_monochrome,
+        ]
+        self.shaders = itertools.cycle(available_shaders)
+
+        self.shader_btn.bind(on_release=self.change)
+
+    def change(self, *largs):
+        self.shader_widget.fs = next(self.shaders)
+
+
+class ShaderTreeApp(App):
+    def build(self):
+        return RootWidget()
+
+
+if __name__ == '__main__':
+    ShaderTreeApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/svg/benchmark.py

@@ -0,0 +1,19 @@
+from kivy.core.window import Window
+from kivy.graphics.svg import Svg
+from time import time
+import sys
+import os
+
+filename = sys.argv[1]
+if "PROFILE" in os.environ:
+    import pstats
+    import cProfile
+    cProfile.runctx("Svg(filename)", globals(), locals(), "Profile.prof")
+    s = pstats.Stats("Profile.prof")
+    s.sort_stats("time").print_callers()
+else:
+    print("Loading {}".format(filename))
+    start = time()
+    svg = Svg(filename)
+    end = time()
+    print("Loaded in {:.2f}s".format((end - start)))

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/svg/cloud.svg

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 13.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 14948)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="128px" height="128px" viewBox="0 0 128 128" enable-background="new 0 0 128 128" xml:space="preserve">
+<polygon fill="#DBDBDB" points="-0.946,69.217 17.35,54.248 43.068,54.162 48.25,29.734 75.084,22.792 94.805,51.419 
+	113.099,56.417 128.142,77.678 116.961,96.551 86.061,100.891 79.149,88.741 68.579,102.625 40.525,105.445 32.1,95.478 
+	5.966,94.815 "/>
+<polygon fill="#FFFFFF" points="51.502,31.904 74.066,26.264 92.246,50.688 72.44,30.385 "/>
+<polygon fill="#FFFFFF" points="95.719,53.796 112.348,58.488 126.172,77.578 122.715,83.219 122.715,77.795 110.722,61.308 
+	96.999,56.721 89.504,59.28 "/>
+<polygon fill="#FFFFFF" points="12.333,61.406 18.025,56.417 43.415,55.878 52.373,68.858 41.971,58.549 18.431,59.237 "/>
+<polygon fill="#B6B6B6" points="0.681,70.952 7.592,92.646 31.551,93.467 9.219,88.741 "/>
+<polygon fill="#B6B6B6" points="34.659,95.478 41.614,103.823 67.025,101.438 42.833,100.569 "/>
+<polygon fill="#B6B6B6" points="77.93,84.837 86.467,99.587 116.147,95.467 88.297,96.116 "/>
+<polygon points="93.343,71.529 90.418,79.207 93.343,81.584 96.268,79.207 "/>
+<polygon fill="#404040" points="93.343,73.905 95.536,79.024 92.794,77.562 "/>
+<polygon points="107.938,71.498 105.014,79.176 107.938,81.553 110.863,79.176 "/>
+<polygon fill="#404040" points="107.938,73.874 110.132,78.993 107.39,77.53 "/>
+<polygon points="92.665,89.044 102.217,91.24 111.062,88.625 112.062,87.125 113.871,88.861 112.625,90.75 111.188,89.75 
+	102.217,92.923 92.848,90.141 91.751,91.238 90.472,89.775 91.568,87.765 "/>
+<polygon fill="#404040" points="112.562,87.812 112.688,88.562 113.5,88.875 "/>
+<polygon fill="#404040" points="91.688,88.188 92.611,89.079 91.625,89.062 "/>
+<polygon fill="#404040" points="92.938,89.375 101.875,91.5 104.938,90.625 101.812,92.125 "/>
+</svg>