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

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

@@ -0,0 +1,296 @@
+'''
+Line (SmoothLine) Experiment
+============================
+
+This demonstrates the experimental and unfinished SmoothLine feature
+for fast line drawing. You should see a multi-segment
+path at the top of the screen, and sliders and buttons along the bottom.
+You can click to add new points to the segment, change the transparency
+and width of the line, or hit 'Animate' to see a set of sine and cosine
+animations. The Cap and Joint buttons don't work: SmoothLine has not
+implemented these features yet.
+'''
+
+from kivy.app import App
+from kivy.properties import OptionProperty, NumericProperty, ListProperty, \
+        BooleanProperty
+from kivy.uix.floatlayout import FloatLayout
+from kivy.lang import Builder
+from kivy.clock import Clock
+from math import cos, sin
+
+Builder.load_string('''
+<LinePlayground>:
+    canvas:
+        Color:
+            rgba: .4, .4, 1, root.alpha
+        Line:
+            points: self.points
+            joint: self.joint
+            cap: self.cap
+            width: self.linewidth
+            close: self.close
+            dash_length: self.dash_length
+            dash_offset: self.dash_offset
+            dashes: self.dashes
+        Color:
+            rgba: .8, .8, .8, root.alpha_controlline
+        Line:
+            points: self.points
+            close: self.close
+            dash_length: self.dash_length
+            dash_offset: self.dash_offset
+            dashes: self.dashes
+        Color:
+            rgba: 1, .4, .4, root.alpha
+        Line:
+            points: self.points2
+            joint: self.joint
+            cap: self.cap
+            width: self.linewidth
+            close: self.close
+            dash_length: self.dash_length
+            dash_offset: self.dash_offset
+            dashes: self.dashes
+
+    GridLayout:
+        cols: 2
+        size_hint: 1, None
+        height: 44 * 5
+
+        GridLayout:
+            cols: 2
+
+            Label:
+                text: 'Alpha'
+            Slider:
+                value: root.alpha
+                on_value: root.alpha = float(args[1])
+                min: 0.
+                max: 1.
+            Label:
+                text: 'Alpha Control Line'
+            Slider:
+                value: root.alpha_controlline
+                on_value: root.alpha_controlline = float(args[1])
+                min: 0.
+                max: 1.
+            Label:
+                text: 'Width'
+            Slider:
+                value: root.linewidth
+                on_value: root.linewidth = args[1]
+                min: 1
+                max: 40
+            Label:
+                text: 'Cap'
+            GridLayout:
+                rows: 1
+                ToggleButton:
+                    group: 'cap'
+                    text: 'none'
+                    on_press: root.cap = self.text
+                ToggleButton:
+                    group: 'cap'
+                    text: 'round'
+                    on_press: root.cap = self.text
+                ToggleButton:
+                    group: 'cap'
+                    text: 'square'
+                    on_press: root.cap = self.text
+            Label:
+                text: 'Joint'
+            GridLayout:
+                rows: 1
+                ToggleButton:
+                    group: 'joint'
+                    text: 'none'
+                    on_press: root.joint = self.text
+                ToggleButton:
+                    group: 'joint'
+                    text: 'round'
+                    on_press: root.joint = self.text
+                ToggleButton:
+                    group: 'joint'
+                    text: 'miter'
+                    on_press: root.joint = self.text
+                ToggleButton:
+                    group: 'joint'
+                    text: 'bevel'
+                    on_press: root.joint = self.text
+
+            Label:
+                text: 'Close'
+            ToggleButton:
+                text: 'Close line'
+                on_press: root.close = self.state == 'down'
+
+            Label:
+                text: 'Dashes'
+            GridLayout:
+                rows: 1
+                ToggleButton:
+                    group: 'dashes'
+                    text: 'none'
+                    state: 'down'
+                    allow_no_selection: False
+                    size_hint_x: None
+                    width: self.texture_size[0]
+                    padding_x: '5dp'
+                    on_state:
+                        if self.state == 'down': root.dashes = []
+                        if self.state == 'down': root.dash_length = 1
+                        if self.state == 'down': root.dash_offset = 0
+                ToggleButton:
+                    id: constant
+                    group: 'dashes'
+                    text: 'Constant: '
+                    allow_no_selection: False
+                    size_hint_x: None
+                    width: self.texture_size[0]
+                    padding_x: '5dp'
+                    on_state:
+                        if self.state == 'down': root.dashes = []
+                        if self.state == 'down': root.dash_length = \
+                            int(dash_len.text or 1)
+                        if self.state == 'down': root.dash_offset = \
+                            int(dash_offset.text or 0)
+                Label:
+                    text: 'len'
+                    size_hint_x: None
+                    width: self.texture_size[0]
+                    padding_x: '5dp'
+                TextInput:
+                    id: dash_len
+                    size_hint_x: None
+                    width: '30dp'
+                    input_filter: 'int'
+                    multiline: False
+                    text: '1'
+                    on_text: if constant.state == 'down': \
+                        root.dash_length = int(self.text or 1)
+                Label:
+                    text: 'offset'
+                    size_hint_x: None
+                    width: self.texture_size[0]
+                    padding_x: '5dp'
+                TextInput:
+                    id: dash_offset
+                    size_hint_x: None
+                    width: '30dp'
+                    input_filter: 'int'
+                    multiline: False
+                    text: '0'
+                    on_text: if constant.state == 'down': \
+                        root.dash_offset = int(self.text or 0)
+                ToggleButton:
+                    id: dash_list
+                    group: 'dashes'
+                    text: 'List: '
+                    allow_no_selection: False
+                    size_hint_x: None
+                    width: self.texture_size[0]
+                    padding_x: '5dp'
+                    on_state:
+                        if self.state == 'down': root.dashes = list(map(lambda\
+                            x: int(x or 0), dash_list_in.text.split(',')))
+                        if self.state == 'down': root.dash_length = 1
+                        if self.state == 'down': root.dash_offset = 0
+                TextInput:
+                    id: dash_list_in
+                    size_hint_x: None
+                    width: '180dp'
+                    multiline: False
+                    text: '4,3,10,15'
+                    on_text: if dash_list.state == 'down': root.dashes = \
+                        list(map(lambda x: int(x or 0), self.text.split(',')))
+
+        AnchorLayout:
+            GridLayout:
+                cols: 1
+                size_hint: None, None
+                size: self.minimum_size
+                ToggleButton:
+                    size_hint: None, None
+                    size: 100, 44
+                    text: 'Animate'
+                    on_state: root.animate(self.state == 'down')
+                Button:
+                    size_hint: None, None
+                    size: 100, 44
+                    text: 'Clear'
+                    on_press: root.points = root.points2 = []
+
+''')
+
+
+class LinePlayground(FloatLayout):
+
+    alpha_controlline = NumericProperty(1.0)
+    alpha = NumericProperty(0.5)
+    close = BooleanProperty(False)
+    points = ListProperty([(500, 500),
+                          [300, 300, 500, 300],
+                          [500, 400, 600, 400]])
+    points2 = ListProperty([])
+    joint = OptionProperty('none', options=('round', 'miter', 'bevel', 'none'))
+    cap = OptionProperty('none', options=('round', 'square', 'none'))
+    linewidth = NumericProperty(10.0)
+    dt = NumericProperty(0)
+    dash_length = NumericProperty(1)
+    dash_offset = NumericProperty(0)
+    dashes = ListProperty([])
+
+    _update_points_animation_ev = None
+
+    def on_touch_down(self, touch):
+        if super(LinePlayground, self).on_touch_down(touch):
+            return True
+        touch.grab(self)
+        self.points.append(touch.pos)
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is self:
+            self.points[-1] = touch.pos
+            return True
+        return super(LinePlayground, self).on_touch_move(touch)
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is self:
+            touch.ungrab(self)
+            return True
+        return super(LinePlayground, self).on_touch_up(touch)
+
+    def animate(self, do_animation):
+        if do_animation:
+            self._update_points_animation_ev = Clock.schedule_interval(
+                self.update_points_animation, 0)
+        elif self._update_points_animation_ev is not None:
+            self._update_points_animation_ev.cancel()
+
+    def update_points_animation(self, dt):
+        cy = self.height * 0.6
+        cx = self.width * 0.1
+        w = self.width * 0.8
+        step = 20
+        points = []
+        points2 = []
+        self.dt += dt
+        for i in range(int(w / step)):
+            x = i * step
+            points.append(cx + x)
+            points.append(cy + cos(x / w * 8. + self.dt) * self.height * 0.2)
+            points2.append(cx + x)
+            points2.append(cy + sin(x / w * 8. + self.dt) * self.height * 0.2)
+        self.points = points
+        self.points2 = points2
+
+
+class TestLineApp(App):
+    def build(self):
+        return LinePlayground()
+
+
+if __name__ == '__main__':
+    TestLineApp().run()

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

@@ -0,0 +1,183 @@
+'''
+Lines Extended Demo
+===================
+
+This demonstrates how to use the extended line drawing routines such
+as circles, ellipses, and rectangles. You should see a static image of
+labelled shapes on the screen.
+'''
+
+from kivy.app import App
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.widget import Widget
+from kivy.lang import Builder
+
+Builder.load_string('''
+<LineEllipse1>:
+    canvas:
+        Color:
+            rgba: 1, .1, .1, .9
+        Line:
+            width: 2.
+            ellipse: (self.x, self.y, self.width, self.height)
+    Label:
+        center: root.center
+        text: 'Ellipse'
+
+<LineEllipse2>:
+    canvas:
+        Color:
+            rgba: 1, .1, .1, .9
+        Line:
+            width: 2.
+            ellipse: (self.x, self.y, self.width, self.height, 90, 180)
+    Label:
+        center: root.center
+        text: 'Ellipse from 90 to 180'
+
+# fun result with low segments!
+<LineEllipse3>:
+    canvas:
+        Color:
+            rgba: 1, .1, .1, .9
+        Line:
+            width: 2.
+            ellipse: (self.x, self.y, self.width, self.height, 90, 720, 10)
+    Label:
+        center: root.center
+        text: 'Ellipse from 90 to 720\\n10 segments'
+        halign: 'center'
+
+<LineCircle1>:
+    canvas:
+        Color:
+            rgba: .1, 1, .1, .9
+        Line:
+            width: 2.
+            circle:
+                (self.center_x, self.center_y, min(self.width, self.height)
+                / 2)
+    Label:
+        center: root.center
+        text: 'Circle'
+
+<LineCircle2>:
+    canvas:
+        Color:
+            rgba: .1, 1, .1, .9
+        Line:
+            width: 2.
+            circle:
+                (self.center_x, self.center_y, min(self.width, self.height)
+                / 2, 90, 180)
+    Label:
+        center: root.center
+        text: 'Circle from 90 to 180'
+
+<LineCircle3>:
+    canvas:
+        Color:
+            rgba: .1, 1, .1, .9
+        Line:
+            width: 2.
+            circle:
+                (self.center_x, self.center_y, min(self.width, self.height)
+                / 2, 90, 180, 10)
+    Label:
+        center: root.center
+        text: 'Circle from 90 to 180\\n10 segments'
+        halign: 'center'
+
+<LineCircle4>:
+    canvas:
+        Color:
+            rgba: .1, 1, .1, .9
+        Line:
+            width: 2.
+            circle:
+                (self.center_x, self.center_y, min(self.width, self.height)
+                / 2, 0, 360)
+    Label:
+        center: root.center
+        text: 'Circle from 0 to 360'
+        halign: 'center'
+
+<LineRectangle>:
+    canvas:
+        Color:
+            rgba: .1, .1, 1, .9
+        Line:
+            width: 2.
+            rectangle: (self.x, self.y, self.width, self.height)
+    Label:
+        center: root.center
+        text: 'Rectangle'
+
+<LineBezier>:
+    canvas:
+        Color:
+            rgba: .1, .1, 1, .9
+        Line:
+            width: 2.
+            bezier:
+                (self.x, self.y, self.center_x - 40, self.y + 100,
+                self.center_x + 40, self.y - 100, self.right, self.y)
+    Label:
+        center: root.center
+        text: 'Bezier'
+''')
+
+
+class LineEllipse1(Widget):
+    pass
+
+
+class LineEllipse2(Widget):
+    pass
+
+
+class LineEllipse3(Widget):
+    pass
+
+
+class LineCircle1(Widget):
+    pass
+
+
+class LineCircle2(Widget):
+    pass
+
+
+class LineCircle3(Widget):
+    pass
+
+
+class LineCircle4(Widget):
+    pass
+
+
+class LineRectangle(Widget):
+    pass
+
+
+class LineBezier(Widget):
+    pass
+
+
+class LineExtendedApp(App):
+    def build(self):
+        root = GridLayout(cols=2, padding=50, spacing=50)
+        root.add_widget(LineEllipse1())
+        root.add_widget(LineEllipse2())
+        root.add_widget(LineEllipse3())
+        root.add_widget(LineCircle1())
+        root.add_widget(LineCircle2())
+        root.add_widget(LineCircle3())
+        root.add_widget(LineCircle4())
+        root.add_widget(LineRectangle())
+        root.add_widget(LineBezier())
+        return root
+
+
+if __name__ == '__main__':
+    LineExtendedApp().run()

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

@@ -0,0 +1,57 @@
+'''
+Mesh test
+=========
+
+This demonstrates the use of a mesh mode to distort an image. You should see
+a line of buttons across the bottom of a canvas. Pressing them displays
+the mesh, a small circle of points, with different mesh.mode settings.
+'''
+
+from kivy.uix.button import Button
+from kivy.uix.widget import Widget
+from kivy.uix.boxlayout import BoxLayout
+from kivy.app import App
+from kivy.graphics import Mesh
+from functools import partial
+from math import cos, sin, pi
+
+
+class MeshTestApp(App):
+
+    def change_mode(self, mode, *largs):
+        self.mesh.mode = mode
+
+    def build_mesh(self):
+        """ returns a Mesh of a rough circle. """
+        vertices = []
+        indices = []
+        step = 10
+        istep = (pi * 2) / float(step)
+        for i in range(step):
+            x = 300 + cos(istep * i) * 100
+            y = 300 + sin(istep * i) * 100
+            vertices.extend([x, y, 0, 0])
+            indices.append(i)
+        return Mesh(vertices=vertices, indices=indices)
+
+    def build(self):
+        wid = Widget()
+        with wid.canvas:
+            self.mesh = self.build_mesh()
+
+        layout = BoxLayout(size_hint=(1, None), height=50)
+        for mode in ('points', 'line_strip', 'line_loop', 'lines',
+                'triangle_strip', 'triangle_fan'):
+            button = Button(text=mode)
+            button.bind(on_release=partial(self.change_mode, mode))
+            layout.add_widget(button)
+
+        root = BoxLayout(orientation='vertical')
+        root.add_widget(wid)
+        root.add_widget(layout)
+
+        return root
+
+
+if __name__ == '__main__':
+    MeshTestApp().run()

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

@@ -0,0 +1,101 @@
+'''
+Mesh Manipulation Example
+=========================
+
+This demonstrates creating a mesh and using it to deform the texture (the
+kivy log). You should see the kivy logo with a five sliders to right.
+The sliders change the mesh points' x and y offsets, radius, and a
+'wobble' deformation's magnitude and speed.
+
+This example is developed in gabriel's blog post at
+http://kivy.org/planet/2014/01/kivy-image-manipulations-with-mesh-and-textures/
+'''
+
+from kivy.app import App
+from kivy.lang import Builder
+from kivy.core.image import Image as CoreImage
+from kivy.properties import ListProperty, ObjectProperty, NumericProperty
+from kivy.clock import Clock
+from kivy.core.window import Window
+from math import sin, cos, pi
+
+
+kv = '''
+BoxLayout:
+    Widget:
+        canvas:
+            Color:
+                rgba: 1, 1, 1, 1
+            Mesh:
+                vertices: app.mesh_points
+                indices: range(len(app.mesh_points) // 4)
+                texture: app.mesh_texture
+                mode: 'triangle_fan'
+    BoxLayout:
+        orientation: 'vertical'
+        size_hint_x: None
+        width: 100
+        Slider:
+            value: app.offset_x
+            on_value: app.offset_x = args[1]
+            min: -1
+            max: 1
+        Slider:
+            value: app.offset_y
+            on_value: app.offset_y = args[1]
+            min: -1
+            max: 1
+        Slider:
+            value: app.radius
+            on_value: app.radius = args[1]
+            min: 10
+            max: 1000
+        Slider:
+            value: app.sin_wobble
+            on_value: app.sin_wobble = args[1]
+            min: -50
+            max: 50
+        Slider:
+            value: app.sin_wobble_speed
+            on_value: app.sin_wobble_speed = args[1]
+            min: 0
+            max: 50
+            step: 1
+'''
+
+
+class MeshBallApp(App):
+    mesh_points = ListProperty([])
+    mesh_texture = ObjectProperty(None)
+    radius = NumericProperty(500)
+    offset_x = NumericProperty(.5)
+    offset_y = NumericProperty(.5)
+    sin_wobble = NumericProperty(0)
+    sin_wobble_speed = NumericProperty(0)
+
+    def build(self):
+        self.mesh_texture = CoreImage('data/logo/kivy-icon-512.png').texture
+        Clock.schedule_interval(self.update_points, 0)
+        return Builder.load_string(kv)
+
+    def update_points(self, *args):
+        """ replace self.mesh_points based on current slider positions.
+        Called continuously by a timer because this only sample code.
+        """
+        points = [Window.width / 2, Window.height / 2, .5, .5]
+        i = 0
+        while i < 2 * pi:
+            i += 0.01 * pi
+            points.extend([
+                Window.width / 2 + cos(i) * (self.radius + self.sin_wobble *
+                                             sin(i * self.sin_wobble_speed)),
+                Window.height / 2 + sin(i) * (self.radius + self.sin_wobble *
+                                              sin(i * self.sin_wobble_speed)),
+                self.offset_x + sin(i),
+                self.offset_y + cos(i)])
+
+        self.mesh_points = points
+
+
+if __name__ == '__main__':
+    MeshBallApp().run()