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

kivy/tests/test_uix_scrollview.py

@@ -0,0 +1,358 @@
+from kivy.tests.common import GraphicUnitTest
+
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.scrollview import ScrollView
+from kivy.uix.label import Label
+from kivy.base import EventLoop
+from kivy.clock import Clock
+from kivy.tests.common import UTMotionEvent
+
+from time import sleep
+from itertools import count
+
+DEBUG = False
+touch_id = count()
+
+
+class _TestGrid(GridLayout):
+    def __init__(self, **kwargs):
+        kwargs['cols'] = 1
+        kwargs['spacing'] = 10
+        kwargs['size_hint'] = (None, None)
+        super(_TestGrid, self).__init__(**kwargs)
+        self.bind(minimum_height=self.setter('height'))
+        self.bind(minimum_width=self.setter('width'))
+
+        for i in range(10):
+            self.add_widget(Label(
+                size_hint=(None, None),
+                height=100, width=1000,
+                text=str(i)
+            ))
+
+
+class _TestScrollbarHorizontal(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_y'] = False
+        super(_TestScrollbarHorizontal, self).__init__(**kwargs)
+
+
+class _TestScrollbarVertical(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_x'] = False
+        super(_TestScrollbarVertical, self).__init__(**kwargs)
+
+
+class _TestScrollbarBoth(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_width'] = 20
+        super(_TestScrollbarBoth, self).__init__(**kwargs)
+
+
+class _TestScrollbarHorizontalMargin(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_margin'] = 40
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_y'] = False
+        super(_TestScrollbarHorizontalMargin, self).__init__(**kwargs)
+
+
+class _TestScrollbarVerticalMargin(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_margin'] = 40
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_x'] = False
+        super(_TestScrollbarVerticalMargin, self).__init__(**kwargs)
+
+
+class _TestScrollbarBothMargin(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_margin'] = 40
+        kwargs['bar_width'] = 20
+        super(_TestScrollbarBothMargin, self).__init__(**kwargs)
+
+
+class ScrollViewTestCase(GraphicUnitTest):
+    framecount = 0
+
+    def process_points(self, scroll, points):
+        win = EventLoop.window
+        dt = 0.02
+
+        for point in points:
+            if DEBUG:
+                print('point:', point, scroll.scroll_x, scroll.scroll_y)
+                Clock.schedule_once(lambda *dt: sleep(0.5), 0)
+                self.render(scroll)
+
+            x, y, nx, ny, pos_x, pos_y, border_check = point
+            scroll.bar_pos = (pos_x, pos_y)
+
+            touch = UTMotionEvent("unittest", next(touch_id), {
+                "x": x / float(win.width),
+                "y": y / float(win.height),
+            })
+
+            # we start with the default top-left corner
+            self.assertAlmostEqual(scroll.scroll_x, 0.0, delta=dt)
+            self.assertAlmostEqual(scroll.scroll_y, 1.0, delta=dt)
+
+            # check the collision with the margin empty area
+            if border_check:
+                EventLoop.post_dispatch_input("begin", touch)
+                touch.move({
+                    "x": nx / float(win.width),
+                    "y": ny / float(win.height)
+                })
+                EventLoop.post_dispatch_input("update", touch)
+                EventLoop.post_dispatch_input("end", touch)
+
+                self.assertAlmostEqual(scroll.scroll_x, 0.0, delta=dt)
+                self.assertAlmostEqual(scroll.scroll_y, 1.0, delta=dt)
+                return
+
+            EventLoop.post_dispatch_input("begin", touch)
+            touch.move({
+                "x": nx / float(win.width),
+                "y": ny / float(win.height)
+            })
+            EventLoop.post_dispatch_input("update", touch)
+            EventLoop.post_dispatch_input("end", touch)
+
+            if DEBUG:
+                print(scroll.scroll_x, scroll.scroll_y)
+                Clock.schedule_once(lambda *dt: sleep(0.5), 0)
+                self.render(scroll)
+
+            # check the scroll position
+            self.assertAlmostEqual(
+                scroll.scroll_x, 0.0 if x == nx else 1.0,
+                delta=dt
+            )
+            self.assertAlmostEqual(
+                scroll.scroll_y, 1.0 if y == ny else 0.0,
+                delta=dt
+            )
+
+            # reset scroll to original state
+            scroll.scroll_x = 0.0
+            scroll.scroll_y = 1.0
+
+    def test_scrollbar_horizontal(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarHorizontal()
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        points = [
+            [left, bottom, right, bottom, 'bottom', 'right', False],
+            [left, top, right, top, 'top', 'right', False]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_vertical(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarVertical()
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        points = [
+            [right, top, right, bottom, 'bottom', 'right', False],
+            [left, top, left, bottom, 'bottom', 'left', False]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_both(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarBoth()
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        points = [
+            [left, bottom, right, bottom, 'bottom', 'right', False],
+            [left, top, right, top, 'top', 'right', False],
+            [right, top, right, bottom, 'bottom', 'right', False],
+            [left, top, left, bottom, 'bottom', 'left', False]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_horizontal_margin(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarHorizontalMargin()
+        margin = scroll.bar_margin
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        # touch in the half of the bar
+        m = margin + scroll.bar_width / 2.0
+        points = [
+            [left, bottom + m, right, bottom + m, 'bottom', 'right', False],
+            [left, top - m, right, top - m, 'top', 'right', False],
+            [left, bottom, right, bottom, 'bottom', 'right', True],
+            [left, top, right, top, 'top', 'right', True]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_vertical_margin(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarVerticalMargin()
+        margin = scroll.bar_margin
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        # touch in the half of the bar
+        m = margin + scroll.bar_width / 2.0
+        points = [
+            [right - m, top, right - m, bottom, 'bottom', 'right', False],
+            [left + m, top, left + m, bottom, 'bottom', 'left', False],
+            [right, top, right, bottom, 'bottom', 'right', True],
+            [left, top, left, bottom, 'bottom', 'left', True]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_both_margin(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarBothMargin()
+        margin = scroll.bar_margin
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        # touch in the half of the bar
+        m = margin + scroll.bar_width / 2.0
+        points = [
+            [left, bottom + m, right, bottom + m, 'bottom', 'right', False],
+            [left, top - m, right, top - m, 'top', 'right', False],
+            [right - m, top, right - m, bottom, 'bottom', 'right', False],
+            [left + m, top, left + m, bottom, 'bottom', 'left', False],
+            [left, bottom, right, bottom, 'bottom', 'right', True],
+            [left, top, right, top, 'top', 'right', True],
+            [right, top, right, bottom, 'bottom', 'right', True],
+            [left, top, left, bottom, 'bottom', 'left', True]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_smooth_scroll_end(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = ScrollView(smooth_scroll_end=10)
+
+        assert scroll.smooth_scroll_end == 10
+        scroll.add_widget(grid)
+
+        # XXX this shouldn't be needed, but previous tests apparently
+        # don't cleanup
+        while win.children:
+            win.remove_widget(win.children[0])
+
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        e = scroll.effect_y
+        assert e.velocity == 0
+
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": scroll.center_x / float(win.width),
+            "y": scroll.center_y / float(win.height),
+        })
+
+        touch.profile.append('button')
+        touch.button = 'scrollup'
+
+        EventLoop.post_dispatch_input("begin", touch)
+        # EventLoop.post_dispatch_input("update", touch)
+        assert e.velocity == 10 * scroll.scroll_wheel_distance
+        EventLoop.idle()
+        assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance
+        EventLoop.post_dispatch_input("end", touch)
+        EventLoop.idle()
+        assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance
+
+        # wait for velocity to die off
+        while e.velocity:
+            EventLoop.idle()
+
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": scroll.center_x / float(win.width),
+            "y": scroll.center_y / float(win.height),
+        })
+        touch.profile.append('button')
+        touch.button = 'scrolldown'
+
+        EventLoop.post_dispatch_input("begin", touch)
+        # EventLoop.post_dispatch_input("update", touch)
+        assert e.velocity == -10 * scroll.scroll_wheel_distance
+        EventLoop.idle()
+        assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance
+        EventLoop.post_dispatch_input("end", touch)
+        EventLoop.idle()
+        assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()

kivy/tests/test_uix_settings.py

@@ -0,0 +1,33 @@
+import json
+
+import pytest
+
+from kivy.config import ConfigParser
+from kivy.uix.settings import Settings
+
+
+def test_settings_create_json_panel_errors():
+    config = ConfigParser()
+
+    with pytest.raises(
+        Exception, match="You must specify either the filename or data"
+    ):
+        Settings().create_json_panel("Demo", config, filename=None, data=None)
+
+    with pytest.raises(
+        ValueError, match="The first element must be a list"
+    ):
+        data = json.dumps({"key": "value"})
+        Settings().create_json_panel("Demo", config, filename=None, data=data)
+
+    with pytest.raises(
+        ValueError, match="One setting are missing the \"type\" element"
+    ):
+        data = json.dumps([{"key": "value"}])
+        Settings().create_json_panel("Demo", config, filename=None, data=data)
+
+    with pytest.raises(
+        ValueError, match="No class registered to handle the <testunknown> type"
+    ):
+        data = json.dumps([{"type": "testunknown"}])
+        Settings().create_json_panel("Demo", config, filename=None, data=data)

kivy/tests/test_uix_slider.py

@@ -0,0 +1,156 @@
+from kivy.tests.common import GraphicUnitTest, UTMotionEvent
+
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.slider import Slider
+from kivy.base import EventLoop
+
+
+class _TestSliderHandle(Slider):
+    def __init__(self, **kwargs):
+        super(_TestSliderHandle, self).__init__(**kwargs)
+        self.sensitivity = 'handle'
+
+
+class _TestSliderAll(Slider):
+    def __init__(self, **kwargs):
+        super(_TestSliderAll, self).__init__(**kwargs)
+        self.sensitivity = 'all'
+
+
+class SliderMoveTestCase(GraphicUnitTest):
+    framecount = 0
+
+    def setUp(self):
+        # kill KV lang logging (too long test)
+        import kivy.lang.builder as builder
+
+        if not hasattr(self, '_trace'):
+            self._trace = builder.trace
+
+        self.builder = builder
+        builder.trace = lambda *_, **__: None
+        super(SliderMoveTestCase, self).setUp()
+
+    def tearDown(self, *args, **kwargs):
+        # add the logging back
+        import kivy.lang.builder as builder
+        builder.trace = self._trace
+        super(SliderMoveTestCase, self).tearDown(*args, **kwargs)
+
+    def test_slider_move(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        layout = BoxLayout(orientation='vertical')
+
+        s_handle = _TestSliderHandle()
+        s_all = _TestSliderAll()
+        layout.add_widget(s_handle)
+        layout.add_widget(s_all)
+        win.add_widget(layout)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        cur1 = s_handle.children[0]
+        cur2 = s_all.children[0]
+
+        h1 = cur1.to_window(*cur1.center)[1]
+        h2 = h1 - s_handle.cursor_height
+        h3 = cur2.to_window(*cur2.center)[1]
+        h4 = h3 - s_all.cursor_height
+
+        w1 = cur1.to_window(*cur1.center)[0]
+        w2 = cur2.to_window(*cur2.center)[0]
+        wh = win.width / 2.0
+        dt = 2
+
+        # default pos, new pos, slider ID
+        points = [
+            [w1, h1, wh, h1, 'handle'],
+            [w1, h2, wh, h2, 'handle'],
+            [w2, h3, wh, h3, 'all'],
+            [w2, h4, wh, h4, 'all'],
+        ]
+
+        for point in points:
+            x, y, nx, ny, id = point
+
+            # custom touch
+            touch = UTMotionEvent("unittest", 1, {
+                "x": x / float(win.width),
+                "y": y / float(win.height),
+            })
+
+            # touch down
+            EventLoop.post_dispatch_input("begin", touch)
+
+            if id == 'handle':
+                # touch on handle
+                if x == w1 and y == h1:
+                    self.assertAlmostEqual(
+                        s_handle.value, 0.0,
+                        delta=dt
+                    )
+                # touch in widget area (ignored, previous value)
+                elif x == w1 and y == h2:
+                    self.assertAlmostEqual(
+                        s_handle.value, 50.0,
+                        delta=dt
+                    )
+            elif id == 'all':
+                # touch on handle:
+                if x == w1 and y == h3:
+                    self.assertAlmostEqual(
+                        s_all.value, 0.0,
+                        delta=dt
+                    )
+                # touch in widget area
+                elif x == w1 and y == h4:
+                    self.assertAlmostEqual(
+                        s_all.value, 0.0,
+                        delta=dt
+                    )
+
+            # move from default to new pos
+            touch.move({
+                "x": nx / float(win.width),
+                "y": ny / float(win.height)
+            })
+            EventLoop.post_dispatch_input("update", touch)
+
+            if id == 'handle':
+                # move from handle to center
+                if nx == wh and ny == h1:
+                    self.assertAlmostEqual(
+                        s_handle.value, 50.0,
+                        delta=dt
+                    )
+                # move to center (ignored, previous value)
+                elif nx == wh and ny == h2:
+                    self.assertAlmostEqual(
+                        s_handle.value, 50.0,
+                        delta=dt
+                    )
+            elif id == 'all':
+                # touch on handle:
+                if nx == wh and ny == h3:
+                    self.assertAlmostEqual(
+                        s_all.value, 50.0,
+                        delta=dt
+                    )
+                # touch in widget area
+                elif nx == wh and ny == h4:
+                    self.assertAlmostEqual(
+                        s_all.value, 50.0,
+                        delta=dt
+                    )
+
+            # touch up
+            EventLoop.post_dispatch_input("end", touch)
+
+        self.render(layout)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()

kivy/tests/test_uix_stacklayout.py

@@ -0,0 +1,120 @@
+'''
+uix.stacklayout tests
+=====================
+'''
+
+import unittest
+
+from kivy.uix.stacklayout import StackLayout
+from kivy.uix.widget import Widget
+
+
+class UixStackLayoutTest(unittest.TestCase):
+
+    def test_stacklayout_no_children(self):
+        sl = StackLayout()
+        sl.do_layout()
+
+    def test_stacklayout_default(self):
+        # Default orientation is lr-tb.
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [0, sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, 0])
+        self.assertEqual(wgts[3].pos, [sl.width / 2., 0])
+
+    def test_stacklayout_fixed_size(self):
+        sl = StackLayout()
+        wgts = [Widget(size=(50, 50), size_hint=(None, None))
+                for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [0, sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, 0])
+        self.assertEqual(wgts[3].pos, [sl.width / 2., 0])
+
+    def test_stacklayout_orientation_btrl(self):
+        # Default orientation is lr-tb.
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.orientation = 'bt-rl'
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [sl.width / 2., 0])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, 0])
+        self.assertEqual(wgts[3].pos, [0, sl.height / 2.])
+
+    def test_stacklayout_orientation_rlbt(self):
+        # Default orientation is lr-tb.
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.orientation = 'rl-bt'
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [sl.width / 2., 0])
+        self.assertEqual(wgts[1].pos, [0, 0])
+        self.assertEqual(wgts[2].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[3].pos, [0, sl.height / 2.])
+
+    def test_stacklayout_padding(self):
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.padding = 5.
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [5., sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [5., 5.])
+        self.assertEqual(wgts[3].pos, [sl.width / 2., 5.])
+
+    def test_stacklayout_spacing(self):
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.spacing = 10
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [0, sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2. + 5, sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, -10])
+        self.assertEqual(wgts[3].pos, [sl.width / 2. + 5, -10])
+
+    def test_stacklayout_overflow(self):
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.2 * i, .2 * i)) for i in range(1, 4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.padding = 5
+        sl.spacing = 5
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [5, 77])
+        self.assertEqual(wgts[1].pos, [27, 59])
+        # floating point error, requires almost equal
+        self.assertAlmostEqual(wgts[2].pos[0], 5)
+        self.assertAlmostEqual(wgts[2].pos[1], 0)
+
+    def test_stacklayout_nospace(self):
+        # happens when padding is too big
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(1., .25)) for i in range(1, 4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.padding = 10
+        sl.do_layout()