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

kivy/tests/test_uix_textinput.py

@@ -0,0 +1,577 @@
+'''
+uix.textinput tests
+========================
+'''
+
+import unittest
+from itertools import count
+
+from kivy.core.window import Window
+from kivy.tests.common import GraphicUnitTest, UTMotionEvent
+from kivy.uix.textinput import TextInput, TextInputCutCopyPaste
+from kivy.uix.widget import Widget
+from kivy.clock import Clock
+
+touch_id = count()
+
+
+class TextInputTest(unittest.TestCase):
+
+    def test_focusable_when_disabled(self):
+        ti = TextInput()
+        ti.disabled = True
+        ti.focused = True
+        ti.bind(focus=self.on_focused)
+
+    def on_focused(self, instance, value):
+        self.assertTrue(instance.focused, value)
+
+    def test_wordbreak(self):
+        self.test_txt = "Firstlongline\n\nSecondveryverylongline"
+
+        ti = TextInput(width='30dp', size_hint_x=None)
+        ti.bind(text=self.on_text)
+        ti.text = self.test_txt
+
+    def on_text(self, instance, value):
+        # Check if text is modified while recreating from lines and lines_flags
+        self.assertEqual(instance.text, self.test_txt)
+
+        # Check if wordbreaking is correctly done
+        # If so Secondvery... should start from the 7th line
+        pos_S = self.test_txt.index('S')
+        self.assertEqual(instance.get_cursor_from_index(pos_S), (0, 6))
+
+
+class TextInputIMETest(unittest.TestCase):
+
+    def test_ime(self):
+        empty_ti = TextInput()
+        empty_ti.focused = True
+        ti = TextInput(text='abc')
+        Window.dispatch('on_textedit', 'ㅎ')
+        self.assertEqual(empty_ti.text, 'ㅎ')
+        self.assertEqual(ti.text, 'abc')
+        ti.focused = True
+        Window.dispatch('on_textedit', 'ㅎ')
+        self.assertEqual(ti.text, 'abcㅎ')
+        Window.dispatch('on_textedit', '하')
+        self.assertEqual(ti.text, 'abc하')
+        Window.dispatch('on_textedit', '핫')
+        Window.dispatch('on_textedit', '')
+        Window.dispatch('on_textinput', '하')
+        Window.dispatch('on_textedit', 'ㅅ')
+        Window.dispatch('on_textedit', '세')
+        self.assertEqual(ti.text, 'abc하세')
+
+
+class TextInputGraphicTest(GraphicUnitTest):
+    def test_text_validate(self):
+        ti = TextInput(multiline=False)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertFalse(ti.multiline)
+        self.assertTrue(ti.focus)
+        self.assertTrue(ti.text_validate_unfocus)
+
+        ti.validate_test = None
+
+        ti.bind(on_text_validate=lambda *_: setattr(
+            ti, 'validate_test', True
+        ))
+        ti._key_down(
+            (
+                None,     # displayed_str
+                None,     # internal_str
+                'enter',  # internal_action
+                1         # scale
+            ),
+            repeat=False
+        )
+        self.assertTrue(ti.validate_test)
+        self.assertFalse(ti.focus)
+
+        ti.validate_test = None
+        ti.text_validate_unfocus = False
+        ti.focus = True
+        self.assertTrue(ti.focus)
+
+        ti._key_down(
+            (None, None, 'enter', 1),
+            repeat=False
+        )
+        self.assertTrue(ti.validate_test)
+        self.assertTrue(ti.focus)
+
+    def test_selection_enter_multiline(self):
+        text = 'multiline\ntext'
+        ti = TextInput(multiline=True, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        # multiline
+        # text$
+        self.assertEqual(
+            ti.cursor, (
+                len(text.split('\n')[-1]),
+                len(text.split('\n')) - 1
+            )
+        )
+
+        # move and check position
+        # mult$iline
+        # text
+        ti._key_down(     # push selection
+            (
+                None,     # displayed_str
+                None,     # internal_str
+                'shift',  # internal_action
+                1         # scale
+            ),
+            repeat=False
+        )
+        ti._key_down(
+            (None, None, 'cursor_up', 1),
+            repeat=False
+        )
+        # pop selection
+        ti._key_up(
+            (None, None, 'shift', 1),
+            repeat=False
+        )
+        self.assertEqual(
+            ti.cursor, (
+                len(text.split('\n')[-1]),
+                len(text.split('\n')) - 2
+            )
+        )
+        self.assertEqual(ti.text, text)
+
+        # overwrite selection with \n
+        ti._key_down(
+            (None, None, 'enter', 1),
+            repeat=False
+        )
+        self.assertEqual(ti.text, text[:4] + '\n')
+
+    def test_selection_enter_singleline(self):
+        text = 'singleline'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        # singleline$
+        self.assertEqual(ti.cursor, (len(text), 0))
+
+        # move and check position
+        # single$line
+        steps = 4
+        options = ((
+            'enter',
+            text
+        ), (
+            'backspace',
+            text[:len(text) - steps]
+        ))
+        for key, txt in options:
+            # push selection
+            ti._key_down((None, None, 'shift', 1), repeat=False)
+            for _ in range(steps):
+                ti._key_down(
+                    (None, None, 'cursor_left', 1),
+                    repeat=False
+                )
+
+            # pop selection
+            ti._key_up((None, None, 'shift', 1), repeat=False)
+            self.assertEqual(
+                ti.cursor, (len(text[:-steps]), 0)
+            )
+            self.assertEqual(ti.text, text)
+
+            # try to overwrite selection with \n
+            # (shouldn't work because single line)
+            ti._key_down(
+                (None, None, key, 1),
+                repeat=False
+            )
+            self.assertEqual(ti.text, txt)
+            ti._key_down((None, None, 'cursor_end', 1), repeat=False)
+
+    def test_del(self):
+        text = 'some_random_text'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        self.assertEqual(ti.cursor, (len(text), 0))
+
+        steps_skip = 2
+        steps_select = 4
+        del_key = 'del'
+
+        for _ in range(steps_skip):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+        # cursor at the place of ^
+        # some_random_te^xt
+
+        # push selection
+        ti._key_down((None, None, 'shift', 1), repeat=False)
+        for _ in range(steps_select):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+
+        # pop selection
+        ti._key_up((None, None, 'shift', 1), repeat=False)
+
+        # cursor at the place of ^, selection between * chars
+        # some_rando*^m_te*xt
+
+        self.assertEqual(
+            ti.cursor, (len(text[:-steps_select - steps_skip]), 0)
+        )
+        self.assertEqual(ti.text, text)
+
+        ti._key_down(
+            (None, None, del_key, 1),
+            repeat=False
+        )
+        # cursor now at: some_rando^xt
+        self.assertEqual(ti.text, 'some_randoxt')
+
+        ti._key_down(
+            (None, None, del_key, 1),
+            repeat=False
+        )
+        self.assertEqual(ti.text, 'some_randot')
+
+    def test_escape(self):
+        text = 'some_random_text'
+        escape_key = 'escape'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        ti._key_down(
+            (None, None, escape_key, 1),
+            repeat=False
+        )
+        self.assertFalse(ti.focus)
+        self.assertEqual(ti.text, text)
+
+    def test_no_shift_cursor_arrow_on_selection(self):
+        text = 'some_random_text'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        self.assertEqual(ti.cursor, (len(text), 0))
+
+        steps_skip = 2
+        steps_select = 4
+
+        for _ in range(steps_skip):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+        # cursor at the place of ^
+        # some_random_te^xt
+
+        # push selection
+        ti._key_down((None, None, 'shift', 1), repeat=False)
+        for _ in range(steps_select):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+
+        # pop selection
+        ti._key_up((None, None, 'shift', 1), repeat=False)
+
+        # cursor at the place of ^, selection between * chars
+        # some_rando*^m_te*xt
+
+        ti._key_down(
+            (None, None, 'cursor_right', 1),
+            repeat=False
+        )
+        self.assertEqual(ti.cursor, (len(text) - steps_skip, 0))
+
+    def test_cursor_movement_control(self):
+        text = "these are\nmany words"
+        ti = TextInput(multiline=True, text=text)
+
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        self.assertEqual(
+            ti.cursor, (
+                len(text.split('\n')[-1]),
+                len(text.split('\n')) - 1
+            )
+        )
+
+        options = (
+                ('cursor_left', (5, 1)),
+                ('cursor_left', (0, 1)),
+                ('cursor_left', (6, 0)),
+                ('cursor_right', (9, 0)),
+                ('cursor_right', (4, 1)))
+
+        for key, pos in options:
+            ti._key_down((None, None, 'ctrl_L', 1), repeat=False)
+            ti._key_down((None, None, key, 1), repeat=False)
+
+            self.assertEqual(ti.cursor, pos)
+
+            ti._key_up((None, None, 'ctrl_L', 1), repeat=False)
+
+    def test_cursor_blink(self):
+        ti = TextInput(cursor_blink=True)
+        ti.focus = True
+
+        # overwrite blinking event, because too long delay
+        ti._do_blink_cursor_ev = Clock.create_trigger(
+            ti._do_blink_cursor, 0.01, interval=True
+        )
+
+        self.render(ti)
+
+        # from kwargs cursor_blink == True
+        self.assertTrue(ti.cursor_blink)
+        self.assertTrue(ti._do_blink_cursor_ev.is_triggered)
+
+        # set whether to blink & check if resets
+        ti.cursor_blink = False
+        for i in range(30):
+            self.advance_frames(int(0.01 * Clock._max_fps) + 1)
+            self.assertFalse(ti._do_blink_cursor_ev.is_triggered)
+
+            # no blinking, cursor visible
+            self.assertFalse(ti._cursor_blink)
+
+        ti.cursor_blink = True
+        self.assertTrue(ti.cursor_blink)
+        for i in range(30):
+            self.advance_frames(int(0.01 * Clock._max_fps) + 1)
+            self.assertTrue(ti._do_blink_cursor_ev.is_triggered)
+
+    def test_visible_lines_range(self):
+        ti = self.make_scrollable_text_input()
+        assert ti._visible_lines_range == (20, 30)
+
+        ti.height = ti_height_for_x_lines(ti, 2.5)
+        ti.do_cursor_movement('cursor_home', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 3)
+
+        ti.height = ti_height_for_x_lines(ti, 0)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 0)
+
+    def test_keyboard_scroll(self):
+        ti = self.make_scrollable_text_input()
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_home', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+        assert prev_cursor != ti.cursor
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_down', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (1, 11)
+        # cursor position (col and row) should not be
+        # changed by "ctrl + cursor_down" and "ctrl + cursor_up"
+        assert prev_cursor == ti.cursor
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_up', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+        assert prev_cursor == ti.cursor
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_end', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (20, 30)
+        assert prev_cursor != ti.cursor
+
+    def test_scroll_doesnt_move_cursor(self):
+        ti = self.make_scrollable_text_input()
+
+        from kivy.base import EventLoop
+        win = EventLoop.window
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": ti.center_x / float(win.width),
+            "y": ti.center_y / float(win.height),
+        })
+        touch.profile.append('button')
+        touch.button = 'scrolldown'
+
+        prev_cursor = ti.cursor
+        assert ti._visible_lines_range == (20, 30)
+        EventLoop.post_dispatch_input("begin", touch)
+        EventLoop.post_dispatch_input("end", touch)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (
+            20 - ti.lines_to_scroll, 30 - ti.lines_to_scroll
+        )
+        assert ti.cursor == prev_cursor
+
+    def test_vertical_scroll_doesnt_depend_on_lines_rendering(self):
+        # TextInput.on_touch_down was checking the possibility to scroll_up
+        # using the positions of the rendered lines' rects. These positions
+        # don't change when the lines are skipped (e.g. during fast scroll
+        # or ctrl+cursor_home) which lead to scroll freeze
+        ti = self.make_scrollable_text_input()
+
+        # move viewport to the first line
+        ti.do_cursor_movement('cursor_home', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+
+        from kivy.base import EventLoop
+        win = EventLoop.window
+
+        # slowly scroll to the last line to render all lines at least once
+        # little overscroll is important for detection
+        # lines scrolled at once will follow the lines_to_scroll property
+        for _ in range(0, 30, ti.lines_to_scroll):
+            touch = UTMotionEvent("unittest", next(touch_id), {
+                "x": ti.center_x / float(win.width),
+                "y": ti.center_y / float(win.height),
+            })
+            touch.profile.append('button')
+            touch.button = 'scrollup'
+
+            EventLoop.post_dispatch_input("begin", touch)
+            EventLoop.post_dispatch_input("end", touch)
+            self.advance_frames(1)
+        assert ti._visible_lines_range == (20, 30)
+
+        # jump to the first line again
+        ti.do_cursor_movement('cursor_home', control=True)
+
+        # temp fix: only change of cursor position triggers update as for now
+        ti._trigger_update_graphics()
+
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+
+        # scrolling up should work now
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": ti.center_x / float(win.width),
+            "y": ti.center_y / float(win.height),
+        })
+        touch.profile.append('button')
+        touch.button = 'scrollup'
+        EventLoop.post_dispatch_input("begin", touch)
+        EventLoop.post_dispatch_input("end", touch)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (
+            ti.lines_to_scroll, 10 + ti.lines_to_scroll
+        )
+
+    def test_selectall_copy_paste(self):
+        text = 'test'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+        self.render(ti)
+
+        from kivy.base import EventLoop
+        win = EventLoop.window
+
+        # select all
+        # win.dispatch(event_name, key, scancode, kstr, modifiers)
+        win.dispatch('on_key_down', 97, 4, 'a', ['capslock', 'ctrl'])
+        win.dispatch('on_key_up', 97, 4)
+        self.advance_frames(1)
+
+        # copy
+        win.dispatch('on_key_down', 99, 6, 'c',
+                     ['capslock', 'numlock', 'ctrl'])
+        win.dispatch('on_key_up', 99, 6)
+        self.advance_frames(1)
+
+        # home
+        win.dispatch('on_key_down', 278, 74, None, ['capslock'])
+        win.dispatch('on_key_up', 278, 74)
+        self.advance_frames(1)
+
+        # paste
+        win.dispatch('on_key_down', 118, 25, 'v', ['numlock', 'ctrl'])
+        win.dispatch('on_key_up', 118, 25)
+        self.advance_frames(1)
+
+        assert ti.text == 'testtest'
+
+    def make_scrollable_text_input(self, num_of_lines=30, n_lines_to_show=10):
+        """Prepare and start rendering the scrollable text input.
+
+           num_of_lines -- amount of dummy lines used as contents
+           n_lines_to_show -- amount of lines to fit in viewport
+        """
+        # create TextInput instance with dummy contents
+        text = '\n'.join(map(str, range(num_of_lines)))
+        ti = TextInput(text=text)
+        ti.focus = True
+
+        # use container to have flexible TextInput size
+        container = Widget()
+        container.add_widget(ti)
+        self.render(container)
+
+        # change TextInput's size to contain the needed amount of lines
+        ti.height = ti_height_for_x_lines(ti, n_lines_to_show)
+        self.advance_frames(1)
+        return ti
+
+    def test_cutcopypastebubble_content(self):
+        tibubble = TextInputCutCopyPaste(textinput=TextInput())
+        assert tibubble.but_copy.parent == tibubble.content
+        assert tibubble.but_cut.parent == tibubble.content
+        assert tibubble.but_paste.parent == tibubble.content
+        assert tibubble.but_selectall.parent == tibubble.content
+
+
+def ti_height_for_x_lines(ti, x):
+    """Calculate TextInput height required to display x lines in viewport.
+
+    ti -- TextInput object being used
+    x -- number of lines to display
+    """
+    padding_top = ti.padding[1]
+    padding_bottom = ti.padding[3]
+    return int((ti.line_height + ti.line_spacing) * x
+               + padding_top + padding_bottom)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()

kivy/tests/test_uix_translate_coordinates.py

@@ -0,0 +1,72 @@
+import pytest
+import functools
+
+non_relative_type_widget_cls_names = ('Widget', )
+relative_type_widget_cls_names = (
+    'RelativeLayout', 'Scatter', 'ScrollView',
+)
+all_widget_cls_names = \
+    non_relative_type_widget_cls_names + \
+    relative_type_widget_cls_names
+
+
+@functools.lru_cache(maxsize=1)
+def get_relative_type_widget_classes():
+    from kivy.factory import Factory
+    return tuple(
+        Factory.get(cls_name)
+        for cls_name in relative_type_widget_cls_names
+    )
+
+
+def is_relative_type(widget):
+    return isinstance(widget, get_relative_type_widget_classes())
+
+
+@pytest.mark.parametrize('widget_cls_name', relative_type_widget_cls_names)
+def test_to_local_and_to_parent__relative(widget_cls_name, kivy_clock):
+    from kivy.factory import Factory
+    widget = Factory.get(widget_cls_name)(pos=(100, 100))
+    kivy_clock.tick()
+    assert widget.to_local(0, 0) == (-100, -100)
+    assert widget.to_parent(0, 0) == (100, 100)
+
+
+@pytest.mark.parametrize('widget_cls_name', non_relative_type_widget_cls_names)
+def test_to_local_and_to_parent__not_relative(widget_cls_name, kivy_clock):
+    from kivy.factory import Factory
+    widget = Factory.get(widget_cls_name)(pos=(100, 100))
+    kivy_clock.tick()
+    assert widget.to_local(0, 0) == (0, 0)
+    assert widget.to_parent(0, 0) == (0, 0)
+
+
+@pytest.mark.parametrize('root_widget_cls_name', all_widget_cls_names)
+@pytest.mark.parametrize('target_widget_cls_name', all_widget_cls_names)
+def test_to_window_and_to_widget(
+        root_widget_cls_name, target_widget_cls_name, kivy_clock):
+    from textwrap import dedent
+    from kivy.lang import Builder
+    root = Builder.load_string(dedent('''
+        {}:
+            pos: 100, 0
+
+            # In case the root widget is ScrollView, this cushion is needed,
+            # because ScrollView's direct child is always at pos(0, 0)
+            Widget:
+                pos: 0, 0
+
+                {}:
+                    id: target
+                    pos: 0, 100
+        ''').format(root_widget_cls_name, target_widget_cls_name))
+    kivy_clock.tick()
+    target = root.ids.target
+    if is_relative_type(root):
+        assert target.to_window(*target.pos) == (100, 100)
+        assert target.to_widget(0, 0) == \
+            ((-100, -100) if is_relative_type(target) else (-100, 0))
+    else:
+        assert target.to_window(*target.pos) == (0, 100)
+        assert target.to_widget(0, 0) == \
+            ((0, -100) if is_relative_type(target) else (0, 0))