134 lines
4.4 KiB
Python
134 lines
4.4 KiB
Python
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()
|