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

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/3Drendering/objloader.py

@@ -0,0 +1,147 @@
+class MeshData(object):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name")
+        self.vertex_format = [
+            (b'v_pos', 3, 'float'),
+            (b'v_normal', 3, 'float'),
+            (b'v_tc0', 2, 'float')]
+        self.vertices = []
+        self.indices = []
+
+    def calculate_normals(self):
+        for i in range(len(self.indices) / (3)):
+            fi = i * 3
+            v1i = self.indices[fi]
+            v2i = self.indices[fi + 1]
+            v3i = self.indices[fi + 2]
+
+            vs = self.vertices
+            p1 = [vs[v1i + c] for c in range(3)]
+            p2 = [vs[v2i + c] for c in range(3)]
+            p3 = [vs[v3i + c] for c in range(3)]
+
+            u, v = [0, 0, 0], [0, 0, 0]
+            for j in range(3):
+                v[j] = p2[j] - p1[j]
+                u[j] = p3[j] - p1[j]
+
+            n = [0, 0, 0]
+            n[0] = u[1] * v[2] - u[2] * v[1]
+            n[1] = u[2] * v[0] - u[0] * v[2]
+            n[2] = u[0] * v[1] - u[1] * v[0]
+
+            for k in range(3):
+                self.vertices[v1i + 3 + k] = n[k]
+                self.vertices[v2i + 3 + k] = n[k]
+                self.vertices[v3i + 3 + k] = n[k]
+
+
+class ObjFile:
+    def finish_object(self):
+        if self._current_object is None:
+            return
+
+        mesh = MeshData()
+        idx = 0
+        for f in self.faces:
+            verts = f[0]
+            norms = f[1]
+            tcs = f[2]
+            for i in range(3):
+                # get normal components
+                n = (0.0, 0.0, 0.0)
+                if norms[i] != -1:
+                    n = self.normals[norms[i] - 1]
+
+                # get texture coordinate components
+                t = (0.0, 0.0)
+                if tcs[i] != -1:
+                    t = self.texcoords[tcs[i] - 1]
+
+                # get vertex components
+                v = self.vertices[verts[i] - 1]
+
+                data = [v[0], v[1], v[2], n[0], n[1], n[2], t[0], t[1]]
+                mesh.vertices.extend(data)
+
+            tri = [idx, idx + 1, idx + 2]
+            mesh.indices.extend(tri)
+            idx += 3
+
+        self.objects[self._current_object] = mesh
+        # mesh.calculate_normals()
+        self.faces = []
+
+    def __init__(self, filename, swapyz=False):
+        """Loads a Wavefront OBJ file. """
+        self.objects = {}
+        self.vertices = []
+        self.normals = []
+        self.texcoords = []
+        self.faces = []
+
+        self._current_object = None
+
+        material = None
+        for line in open(filename, "r"):
+            if line.startswith('#'):
+                continue
+            if line.startswith('s'):
+                continue
+            values = line.split()
+            if not values:
+                continue
+            if values[0] == 'o':
+                self.finish_object()
+                self._current_object = values[1]
+            # elif values[0] == 'mtllib':
+            #    self.mtl = MTL(values[1])
+            # elif values[0] in ('usemtl', 'usemat'):
+            #    material = values[1]
+            if values[0] == 'v':
+                v = list(map(float, values[1:4]))
+                if swapyz:
+                    v = v[0], v[2], v[1]
+                self.vertices.append(v)
+            elif values[0] == 'vn':
+                v = list(map(float, values[1:4]))
+                if swapyz:
+                    v = v[0], v[2], v[1]
+                self.normals.append(v)
+            elif values[0] == 'vt':
+                self.texcoords.append(list(map(float, values[1:3])))
+            elif values[0] == 'f':
+                face = []
+                texcoords = []
+                norms = []
+                for v in values[1:]:
+                    w = v.split('/')
+                    face.append(int(w[0]))
+                    if len(w) >= 2 and len(w[1]) > 0:
+                        texcoords.append(int(w[1]))
+                    else:
+                        texcoords.append(-1)
+                    if len(w) >= 3 and len(w[2]) > 0:
+                        norms.append(int(w[2]))
+                    else:
+                        norms.append(-1)
+                self.faces.append((face, norms, texcoords, material))
+        self.finish_object()
+
+
+def MTL(filename):
+    contents = {}
+    mtl = None
+    return
+    for line in open(filename, "r"):
+        if line.startswith('#'):
+            continue
+        values = line.split()
+        if not values:
+            continue
+        if values[0] == 'newmtl':
+            mtl = contents[values[1]] = {}
+        elif mtl is None:
+            raise ValueError("mtl file doesn't start with newmtl stmt")
+        mtl[values[0]] = values[1:]
+    return contents

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/3Drendering/simple.glsl

@@ -0,0 +1,47 @@
+/* simple.glsl
+
+simple diffuse lighting based on laberts cosine law; see e.g.:
+    http://en.wikipedia.org/wiki/Lambertian_reflectance
+    http://en.wikipedia.org/wiki/Lambert%27s_cosine_law
+*/
+---VERTEX SHADER-------------------------------------------------------
+#ifdef GL_ES
+    precision highp float;
+#endif
+
+attribute vec3  v_pos;
+attribute vec3  v_normal;
+
+uniform mat4 modelview_mat;
+uniform mat4 projection_mat;
+
+varying vec4 normal_vec;
+varying vec4 vertex_pos;
+
+void main (void) {
+    //compute vertex position in eye_space and normalize normal vector
+    vec4 pos = modelview_mat * vec4(v_pos,1.0);
+    vertex_pos = pos;
+    normal_vec = vec4(v_normal,0.0);
+    gl_Position = projection_mat * pos;
+}
+
+
+---FRAGMENT SHADER-----------------------------------------------------
+#ifdef GL_ES
+    precision highp float;
+#endif
+
+varying vec4 normal_vec;
+varying vec4 vertex_pos;
+
+uniform mat4 normal_mat;
+
+void main (void){
+    //correct normal, and compute light vector (assume light at the eye)
+    vec4 v_normal = normalize( normal_mat * normal_vec ) ;
+    vec4 v_light = normalize( vec4(0,0,0,1) - vertex_pos );
+    //reflectance based on lamberts law of cosine
+    float theta = clamp(dot(v_normal, v_light), 0.0, 1.0);
+    gl_FragColor = vec4(theta, theta, theta, 1.0);
+}

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/RST_Editor/editor.kv

@@ -0,0 +1,72 @@
+#:kivy 1.1.0
+
+Root:
+    text_input: text_input
+
+    BoxLayout:
+        orientation: 'vertical'
+        BoxLayout:
+            size_hint_y: None
+            height: 30
+            Button:
+                text: 'Load'
+                on_release: root.show_load()
+            Button:
+                text: 'Save'
+                on_release: root.show_save()
+
+        BoxLayout:
+            TextInput:
+                id: text_input
+                text: ''
+
+            RstDocument:
+                text: text_input.text
+                show_errors: True
+
+<LoadDialog>:
+    BoxLayout:
+        size: root.size
+        pos: root.pos
+        orientation: "vertical"
+        FileChooserListView:
+            id: filechooser
+
+        BoxLayout:
+            size_hint_y: None
+            height: 30
+            Button:
+                text: "Cancel"
+                on_release: root.cancel()
+
+            Button:
+                text: "Load"
+                on_release: root.load(filechooser.path, filechooser.selection)
+
+<SaveDialog>:
+    text_input: text_input
+    BoxLayout:
+        size: root.size
+        pos: root.pos
+        orientation: "vertical"
+        FileChooserListView:
+            id: filechooser
+            on_selection: text_input.text = self.selection and self.selection[0] or ''
+
+        TextInput:
+            id: text_input
+            size_hint_y: None
+            height: 30
+            multiline: False
+
+        BoxLayout:
+            size_hint_y: None
+            height: 30
+            Button:
+                text: "Cancel"
+                on_release: root.cancel()
+
+            Button:
+                text: "Save"
+                on_release: root.save(filechooser.path, text_input.text)
+

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

@@ -0,0 +1,64 @@
+from kivy.app import App
+from kivy.uix.floatlayout import FloatLayout
+from kivy.factory import Factory
+from kivy.properties import ObjectProperty
+from kivy.uix.popup import Popup
+
+import os
+
+
+class LoadDialog(FloatLayout):
+    load = ObjectProperty(None)
+    cancel = ObjectProperty(None)
+
+
+class SaveDialog(FloatLayout):
+    save = ObjectProperty(None)
+    text_input = ObjectProperty(None)
+    cancel = ObjectProperty(None)
+
+
+class Root(FloatLayout):
+    loadfile = ObjectProperty(None)
+    savefile = ObjectProperty(None)
+    text_input = ObjectProperty(None)
+
+    def dismiss_popup(self):
+        self._popup.dismiss()
+
+    def show_load(self):
+        content = LoadDialog(load=self.load, cancel=self.dismiss_popup)
+        self._popup = Popup(title="Load file", content=content,
+                            size_hint=(0.9, 0.9))
+        self._popup.open()
+
+    def show_save(self):
+        content = SaveDialog(save=self.save, cancel=self.dismiss_popup)
+        self._popup = Popup(title="Save file", content=content,
+                            size_hint=(0.9, 0.9))
+        self._popup.open()
+
+    def load(self, path, filename):
+        with open(os.path.join(path, filename[0])) as stream:
+            self.text_input.text = stream.read()
+
+        self.dismiss_popup()
+
+    def save(self, path, filename):
+        with open(os.path.join(path, filename), 'w') as stream:
+            stream.write(self.text_input.text)
+
+        self.dismiss_popup()
+
+
+class Editor(App):
+    pass
+
+
+Factory.register('Root', cls=Root)
+Factory.register('LoadDialog', cls=LoadDialog)
+Factory.register('SaveDialog', cls=SaveDialog)
+
+
+if __name__ == '__main__':
+    Editor().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/android/compass/android.txt

@@ -0,0 +1,3 @@
+title=Compass
+author=Nik Klever
+orientation=portrait

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/android/compass/compass.kv

@@ -0,0 +1,25 @@
+#:kivy 1.7.0
+
+FloatLayout:
+
+    canvas:
+        Color:
+            rgb: .98, .98, .98
+        Rectangle:
+            size: self.size
+
+    Image:
+        source: 'rose.png'
+
+    Image:
+        source: 'needle.png'
+
+        canvas.before:
+            PushMatrix
+            Rotate:
+                angle: app.needle_angle
+                axis: 0, 0, 1
+                origin: self.center
+
+        canvas.after:
+            PopMatrix

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

@@ -0,0 +1,77 @@
+'''
+Compass example
+===============
+
+This example is a demonstration of Hardware class usage.
+But it has severals drawbacks, like using only the magnetic sensor, and
+extrapolating values to get the orientation. The compass is absolutely not
+accurate.
+
+The right way would be to get the accelerometer + magnetic, and computer
+everything according to the phone orientation. This is not the purpose of this
+example right now.
+
+You can compile it with::
+
+    ./build.py --package org.test.compass --name compass \
+        --private ~/code/kivy/examples/android/compass \
+        --window --version 1.0 debug installd
+'''
+
+
+import kivy
+kivy.require('1.7.0')
+
+from jnius import autoclass
+from math import floor
+from kivy.app import App
+from kivy.properties import NumericProperty
+from kivy.clock import Clock
+from kivy.vector import Vector
+from kivy.animation import Animation
+
+Hardware = autoclass('org.renpy.android.Hardware')
+
+
+class CompassApp(App):
+
+    needle_angle = NumericProperty(0)
+
+    def build(self):
+        self._anim = None
+        Hardware.magneticFieldSensorEnable(True)
+        Clock.schedule_interval(self.update_compass, 1 / 10.)
+
+    def update_compass(self, *args):
+        # read the magnetic sensor from the Hardware class
+        (x, y, z) = Hardware.magneticFieldSensorReading()
+
+        # calculate the angle
+        needle_angle = Vector(x, y).angle((0, 1)) + 90.
+
+        # fix animation transition around the unit circle
+        if (self.needle_angle % 360) - needle_angle > 180:
+            needle_angle += 360
+        elif (self.needle_angle % 360) - needle_angle < -180:
+            needle_angle -= 360
+        # add the number of revolutions to the result
+        needle_angle += 360 * floor(self.needle_angle / 360.)
+
+        # animate the needle
+        if self._anim:
+            self._anim.stop(self)
+        self._anim = Animation(needle_angle=needle_angle, d=.2, t='out_quad')
+        self._anim.start(self)
+
+    def on_pause(self):
+        # when you are going on pause, don't forget to stop the sensor
+        Hardware.magneticFieldSensorEnable(False)
+        return True
+
+    def on_resume(self):
+        # reactivate the sensor when you are back to the app
+        Hardware.magneticFieldSensorEnable(True)
+
+
+if __name__ == '__main__':
+    CompassApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/android/takepicture/android.txt

@@ -0,0 +1,3 @@
+title=TakePicture
+author=Mathieu Virbel
+orientation=portrait

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

@@ -0,0 +1,80 @@
+'''
+Take picture
+============
+
+.. author:: Mathieu Virbel <mat@kivy.org>
+
+Little example to demonstrate how to start an Intent, and get the result.
+When you use the Android.startActivityForResult(), the result will be
+dispatched into onActivityResult. You can catch the event with the
+android.activity API from python-for-android project.
+
+If you want to compile it, don't forget to add the CAMERA permission::
+
+    ./build.py --name 'TakePicture' --package org.test.takepicture \
+            --permission CAMERA --version 1 \
+            --private ~/code/kivy/examples/android/takepicture \
+            debug installd
+
+'''
+
+__version__ = '0.1'
+
+from kivy.app import App
+from os.path import exists
+from jnius import autoclass, cast
+from android import activity, mActivity
+from functools import partial
+from kivy.clock import Clock
+from kivy.uix.scatter import Scatter
+from kivy.properties import StringProperty
+
+from PIL import Image
+
+Intent = autoclass('android.content.Intent')
+MediaStore = autoclass('android.provider.MediaStore')
+Uri = autoclass('android.net.Uri')
+Environment = autoclass('android.os.Environment')
+
+
+class Picture(Scatter):
+    source = StringProperty(None)
+
+
+class TakePictureApp(App):
+    def build(self):
+        self.index = 0
+        activity.bind(on_activity_result=self.on_activity_result)
+
+    def get_filename(self):
+        while True:
+            self.index += 1
+            fn = (Environment.getExternalStorageDirectory().getPath() +
+                  '/takepicture{}.jpg'.format(self.index))
+            if not exists(fn):
+                return fn
+
+    def take_picture(self):
+        intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
+        self.last_fn = self.get_filename()
+        self.uri = Uri.parse('file://' + self.last_fn)
+        self.uri = cast('android.os.Parcelable', self.uri)
+        intent.putExtra(MediaStore.EXTRA_OUTPUT, self.uri)
+        mActivity.startActivityForResult(intent, 0x123)
+
+    def on_activity_result(self, requestCode, resultCode, intent):
+        if requestCode == 0x123:
+            Clock.schedule_once(partial(self.add_picture, self.last_fn), 0)
+
+    def add_picture(self, fn, *args):
+        im = Image.open(fn)
+        width, height = im.size
+        im.thumbnail((width / 4, height / 4), Image.ANTIALIAS)
+        im.save(fn, quality=95)
+        self.root.add_widget(Picture(source=fn, center=self.root.center))
+
+    def on_pause(self):
+        return True
+
+
+TakePictureApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/android/takepicture/takepicture.kv

@@ -0,0 +1,40 @@
+#:kivy 1.0
+#:import win kivy.core.window
+
+Widget:
+    canvas:
+        Color:
+            rgb: .85, .87, .88
+        Rectangle:
+            size: self.size
+
+    Button:
+        text: 'Take a picture'
+        width: self.texture_size[0] + dp(40)
+        height: '48dp'
+        on_release: app.take_picture()
+
+<Picture>:
+    on_size: self.center = win.Window.center
+    size: image.size
+    size_hint: None, None
+
+    Image:
+        id: image
+        source: root.source
+
+        # create initial image to be 400 pixels width
+        size: 400, 400
+
+        # add shadow background
+        canvas.before:
+            Color:
+                rgba: 1, 1, 1, 1
+            BorderImage:
+                source: 'shadow32.png'
+                border: (36, 36, 36, 36)
+                size:(self.width + 72, self.height + 72)
+                pos: (-36, -36)
+
+
+

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/animation/animate.py

@@ -0,0 +1,42 @@
+'''
+Widget animation
+================
+
+This example demonstrates creating and applying a multi-part animation to
+a button widget. You should see a button labelled 'plop' that will move with
+an animation when clicked.
+'''
+
+import kivy
+kivy.require('1.0.7')
+
+from kivy.animation import Animation
+from kivy.app import App
+from kivy.uix.button import Button
+
+
+class TestApp(App):
+
+    def animate(self, instance):
+        # create an animation object. This object could be stored
+        # and reused each call or reused across different widgets.
+        # += is a sequential step, while &= is in parallel
+        animation = Animation(pos=(100, 100), t='out_bounce')
+        animation += Animation(pos=(200, 100), t='out_bounce')
+        animation &= Animation(size=(500, 500))
+        animation += Animation(size=(100, 50))
+
+        # apply the animation on the button, passed in the "instance" argument
+        # Notice that default 'click' animation (changing the button
+        # color while the mouse is down) is unchanged.
+        animation.start(instance)
+
+    def build(self):
+        # create a button, and  attach animate() method as a on_press handler
+        button = Button(size_hint=(None, None), text='plop',
+                        on_press=self.animate)
+        return button
+
+
+if __name__ == '__main__':
+    TestApp().run()