Ajout du GUI

kivy/tests/test_uix_asyncimage.py

@@ -0,0 +1,133 @@
+from os import remove
+from os.path import join
+from shutil import copyfile, rmtree
+from tempfile import mkdtemp
+from threading import Event
+from zipfile import ZipFile
+try:
+    from urllib import urlretrieve
+except ImportError:
+    from urllib.request import urlretrieve
+
+from kivy.tests.common import GraphicUnitTest, ensure_web_server
+
+
+class AsyncImageTestCase(GraphicUnitTest):
+
+    @classmethod
+    def setUpClass(cls):
+        from kivy import kivy_examples_dir
+        ensure_web_server(kivy_examples_dir)
+
+    def setUp(self):
+        from kivy.config import Config
+        self.maxfps = Config.getint('graphics', 'maxfps')
+        assert(self.maxfps > 0)
+        super(AsyncImageTestCase, self).setUp()
+
+    def zip_frames(self, path):
+        with ZipFile(path) as zipf:
+            return len(zipf.namelist())
+
+    def wait_for_event_or_timeout(self, event):
+        timeout = 30 * self.maxfps
+        while timeout and not event.is_set():
+            self.advance_frames(1)
+            timeout -= 1
+
+    def load_zipimage(self, source, frames):
+        # load ZIP with images named: 000.png, 001.png, ...
+        from kivy.uix.image import AsyncImage
+        event = Event()
+        image = AsyncImage(anim_delay=0.0333333333333333)
+        # bind to 'on_load' because there are various
+        # steps where the image is (re)loaded, but
+        # the event is triggered only at the end
+        image.bind(on_load=lambda *args, **kwargs: event.set())
+        image.source = source
+        self.wait_for_event_or_timeout(event)
+        self.render(image)
+        proxyimg = image._coreimage
+        self.assertTrue(proxyimg.anim_available)
+        self.assertEqual(len(proxyimg.image.textures), frames)
+        return image
+
+    def test_remote_zipsequence(self):
+        # cube ZIP has 63 PNGs used for animation
+        zip_cube = (
+            'http://localhost:8000/widgets/'
+            'sequenced_images/data/images/cube.zip'
+        )
+        # ref Loader._load_urllib
+        tempf, headers = urlretrieve(zip_cube)
+        zip_pngs = self.zip_frames(tempf)
+        remove(tempf)
+        image = self.load_zipimage(zip_cube, zip_pngs)
+        # pure delay * fps isn't enough and
+        # just +1 isn't either (index collisions)
+        self.assertTrue(self.check_sequence_frames(
+            image._coreimage,
+            int(image._coreimage.anim_delay * self.maxfps + 3)
+        ))
+
+    def test_local_zipsequence(self):
+        # cube ZIP has 63 PNGs used for animation
+        from kivy import kivy_examples_dir
+        zip_cube = join(
+            kivy_examples_dir, 'widgets', 'sequenced_images',
+            'data', 'images', 'cube.zip'
+        )
+        zip_pngs = self.zip_frames(zip_cube)
+        image = self.load_zipimage(zip_cube, zip_pngs)
+        # pure delay * fps isn't enough and
+        # just +1 isn't either (index collisions)
+        self.assertTrue(self.check_sequence_frames(
+            image._coreimage,
+            int(image._coreimage.anim_delay * self.maxfps + 3)
+        ))
+
+    def check_sequence_frames(self, img, frames, slides=5):
+        # check whether it really changes the images
+        # in the anim_delay interval
+        old = None
+        while slides:
+            # different frames, sequence is changing
+            self.assertNotEqual(img.anim_index, old)
+            old = img.anim_index
+            self.advance_frames(frames)
+            slides -= 1
+        return True
+
+    def test_reload_asyncimage(self):
+        from kivy.resources import resource_find
+        from kivy.uix.image import AsyncImage
+
+        temp_dir = mkdtemp()
+        event = Event()
+        image = AsyncImage()
+        image.bind(on_load=lambda *args, **kwargs: event.set())
+
+        fn = resource_find('data/logo/kivy-icon-16.png')
+        source = join(temp_dir, 'source.png')
+        copyfile(fn, source)
+        event.clear()
+        image.source = source
+        self.wait_for_event_or_timeout(event)
+        self.render(image, framecount=2)
+        self.assertEqual(image.texture_size, [16, 16])
+        remove(source)
+
+        fn = resource_find('data/logo/kivy-icon-32.png')
+        copyfile(fn, source)
+        event.clear()
+        image.reload()
+        self.wait_for_event_or_timeout(event)
+        self.render(image, framecount=2)
+        self.assertEqual(image.texture_size, [32, 32])
+        remove(source)
+        rmtree(temp_dir)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()